Правила: «Справочник» в Markdown

Скан без текстового слоя распознан вручную постранично, 427 блоков:
золотые правила, глоссарий (пункт статьи — отдельный блок, «Связанные
темы» — kind: related), краткая справка и разъяснения карт. Содержание
(стр. 19) не перенесено — его заменяют заголовки.

#6

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LqSoRj99iwVEH5U5fnZgsd

.dockerignore

@@ -1,13 +1,23 @@
+# Шаблоны отсчитываются от корня контекста: без «**/» правило ловит только корень
+# (так `data/` пропускал backend/data/dev/ с dev-БД и загрузками в образ, #71).
+
 # Python
 **/__pycache__/
 **/*.pyc
+**/*.egg-info/
 backend/.venv/
 backend/.pytest_cache/
-backend/*.db
-backend/*.db-wal
-backend/*.db-shm
 backend/openapi.json
 
+# Данные: dev-БД, загрузки и ачивки дева (backend/data/dev/), любые файлы SQLite и
+# локальные копии бэкапов — ни в образ, ни в контекст сборки
+backend/data/
+data/
+backups/
+**/*.db
+**/*.db-wal
+**/*.db-shm
+
 # Node / сборка фронта
 frontend/node_modules/
 frontend/dist/
@@ -23,8 +33,7 @@ backend/tests/
 backend/pyproject.toml
 
 # Прочее
-.env
-data/
+**/.env
 **/.DS_Store
 *.md
 .claude/

.env.example

@@ -1,5 +1,5 @@
 # ═══════════════════════════════════════════════════════════════════════════
-#  Forbidden Stars — единый .env (dev / test / prod)
+#  Forbidden Stars — единый .env (dev / prod)
 #  Скопируйте в .env, заполните секреты. Реальный .env в git НЕ идёт.
 #  Окружение — строкой APP_ENV (ниже); публикация локалки наружу — LOCAL_PUBLIC.
 # ═══════════════════════════════════════════════════════════════════════════
@@ -7,7 +7,6 @@
 # ─── ГЛАВНЫЙ ПЕРЕКЛЮЧАТЕЛЬ ────────────────────────────────────────────────────
 # Этот параметр читает ЛАУНЧЕР (run.ps1 / run.sh) и решает, что запускать:
 #   development — нативно: uvicorn --reload + vite, БД в ./data/dev/, вход TG+ник
-#   test        — прод-клон в Docker локально (порт 8080), вход только TG
 #   production  — НЕ запускается лаунчером; деплой на Pi отдельно (docker compose up -d).
 #                 Прод-контейнер ИГНОРИРУЕТ это значение и всегда production.
 APP_ENV=development
@@ -15,21 +14,24 @@ APP_ENV=development
 # ─── ПУБЛИКАЦИЯ ЧЕРЕЗ ДОМЕН (VPS-туннель) ─────────────────────────────────────
 # LOCAL_PUBLIC — только для DEV на твоём ПК: local = приложение лишь на localhost;
 # vps = лаунчер (run.ps1) дополнительно поднимает SSH-туннель → дев на forbidden-stars.ru.
-# TEST и PROD выставляют себя сами через туннель-КОНТЕЙНЕР (docker-compose*.yml) — им
-# LOCAL_PUBLIC не нужен, но VPS_TUNNEL_HOST/USER ниже они тоже читают.
+#   Тогда любому посетителю домена открыты dev-инструменты: вход по нику без пароля,
+#   список/создание игроков, жёсткое удаление аккаунтов, Swagger. Дефолтные SECRET_KEY
+#   и ADMIN_PASSWORD при vps не дают стартовать — задайте свои (#69).
+# PROD выставляет себя сам через туннель-КОНТЕЙНЕР (docker-compose*.yml) — ему
+# LOCAL_PUBLIC не нужен, но VPS_TUNNEL_HOST/USER ниже он тоже читает.
 LOCAL_PUBLIC=local
-# Параметры VPS: их читают и dev-туннель (run.ps1), и туннель-контейнер test/prod.
+# Параметры VPS: их читают и dev-туннель (run.ps1), и туннель-контейнер прода.
 # Ключ туннеля — в deploy/tunnel/id_tunnel (в git не идёт); pubkey → authorized_keys у tunnel@VPS.
 VPS_TUNNEL_HOST=186.246.51.17
 VPS_TUNNEL_USER=tunnel
 # VPS_TUNNEL_PORT обычно НЕ задают — каждый контур берёт свой слот по умолчанию:
-#   dev (run.ps1) → 9001, прод-контейнер → 9000, test-контейнер → 9001.
+#   dev (run.ps1) → 9001, прод-контейнер → 9000.
 # Раскомментируй и переопредели, только если нужен нестандартный слот.
 #VPS_TUNNEL_PORT=9001
 
 # Приватный ключ туннеля в base64 — чтобы на Pi хватило только docker-compose.yml + .env
-# (без файла deploy/tunnel/id_tunnel). Нужен ТОЛЬКО для прод-контейнера на Pi; для dev/test
-# на ПК ключ берётся из файла. Сгенерируй ключ на ПК и закодируй БЕЗ переносов строк:
+# (без файла deploy/tunnel/id_tunnel). Нужен ТОЛЬКО для прод-контейнера на Pi; временный прод
+# на ПК берёт ключ из файла. Сгенерируй ключ на ПК и закодируй БЕЗ переносов строк:
 #   Git Bash / Linux:  base64 -w0 deploy/tunnel/id_tunnel
 #   PowerShell:        [Convert]::ToBase64String([IO.File]::ReadAllBytes((Resolve-Path "deploy/tunnel/id_tunnel")))
 # Pubkey (deploy/tunnel/id_tunnel.pub) добавь в authorized_keys у tunnel@VPS.
@@ -45,27 +47,28 @@ ADMIN_BOOTSTRAP_ENABLED=true
 # Методы входа задаёт APP_ENV: dev → Telegram + stub (вход по нику), prod → только
 # Telegram. Для Telegram нужны токен и юзернейм бота (@BotFather). /setdomain у
 # BotFather укажи на ОБА домена, где открывается виджет: forbiddenstars.ru (prod)
-# и forbidden-stars.ru (dev/test).
+# и forbidden-stars.ru (dev).
 TELEGRAM_BOT_TOKEN=
 TELEGRAM_BOT_USERNAME=
-# Внешний адрес (зарезервировано): prod https://forbiddenstars.ru; dev/test https://forbidden-stars.ru.
+# Внешний адрес (зарезервировано): prod https://forbiddenstars.ru; dev https://forbidden-stars.ru.
 PUBLIC_BASE_URL=
 
 # ─── БЕЗОПАСНОСТЬ / СЕССИИ ────────────────────────────────────────────────────
 # Сгенерировать: python -c "import secrets;print(secrets.token_urlsafe(48))"
 # ВАЖНО: в секретах НЕ используйте символ '$' — docker compose трактует его как
 # подстановку переменной (token_urlsafe даёт только [A-Za-z0-9_-], это безопасно).
+# У dev и prod ключи должны быть РАЗНЫМИ: иначе токен, подписанный на dev, примет прод.
 SECRET_KEY=change-me-dev-secret-not-for-production
 JWT_ALGORITHM=HS256
 JWT_USER_TTL_MINUTES=10080
 JWT_ADMIN_TTL_MINUTES=480
 # COOKIE_SECURE задаётся АВТОМАТИЧЕСКИ по окружению (HTTPS-домен ⇒ Secure-cookie):
-#   dev+localhost → false; dev через VPS, test, prod → true. Вручную задавать НЕ нужно.
+#   dev+localhost → false; dev через VPS, prod → true. Вручную задавать НЕ нужно.
 COOKIE_DOMAIN=
 
 # ─── БАЗА ДАННЫХ (структура общая, файлы РАЗНЫЕ; выбор по APP_ENV) ────────────
-# dev → DEV_DATABASE_URL (файл в ./data/dev/); test и prod → PROD_DATABASE_URL
-# (том /data; у test и prod это РАЗНЫЕ тома контейнера, см. docker-compose*.yml).
+# dev → DEV_DATABASE_URL (файл в ./data/dev/); prod → PROD_DATABASE_URL
+# (том /data контейнера, см. docker-compose*.yml).
 DEV_DATABASE_URL=sqlite:///./data/dev/forbidden_stars.db
 PROD_DATABASE_URL=sqlite:////data/forbidden_stars.db
 

.gitattributes

@@ -4,9 +4,9 @@
 *.sh                text eol=lf
 backend/entrypoint.sh text eol=lf
 
-# ── export-ignore: НЕ попадает в `git archive` (чистая выгрузка прод/тест) ─────
+# ── export-ignore: НЕ попадает в `git archive` (чистая выгрузка прода) ─────────
 # В git эти файлы есть и доступны на всех ветках (нужны для разработки),
-# но в архив деплоя (scripts/export-*.sh) не идут. На Docker-сборку НЕ влияет —
+# но в архив деплоя (scripts/export-prod.sh) не идут. На Docker-сборку НЕ влияет —
 # там чистоту образа обеспечивает .dockerignore.
 backend/tests/                   export-ignore
 backend/app/auth/dev_stub.py     export-ignore

.gitignore

@@ -15,7 +15,7 @@ venv/
 data/
 backend/dev.db*
 
-# Env / секреты — коммитим ТОЛЬКО шаблон .env.example (единый .env для dev/test/prod)
+# Env / секреты — коммитим ТОЛЬКО шаблон .env.example (единый .env для dev/prod)
 .env
 !.env.example
 
@@ -43,6 +43,7 @@ mockups/
 
 # AI-ассистенты (локальные, в репозиторий не идут)
 CLAUDE.md
+AGENTS.md
 .claude/
 
 # Редактор / ОС

README.md

@@ -1,29 +1,37 @@
 # Forbidden Stars — учёт партий
 
 Мобильное веб-приложение для учёта партий настольной игры **Forbidden Stars**:
-профили игроков (вход по логину и паролю или через Telegram), группы, создание партий
-с рандомом фракций и фильтром по дополнениям группы, статистика и общий топ, админ-панель.
+профили игроков (вход по логину и паролю или через Telegram), группы с приглашениями,
+создание партий с рандомом фракций и фильтром по дополнениям группы, фото партий,
+уведомления, статистика и общий топ, админ-панель.
 
 - **Бэкенд / ядро + API:** Python · FastAPI · SQLModel · SQLite
-- **Фронтенд:** React · Vite · TypeScript (SPA, общается с ядром только по REST API)
-- **Хостинг:** Raspberry Pi 4 (ARM64) в Docker
+- **Фронтенд:** React · Vite · TypeScript (SPA; с ядром общается по REST API, живые
+  обновления приходят SSE-потоком `/api/events`)
+- **Хостинг:** Raspberry Pi 4 (ARM64) в Docker; наружу — через VPS-привратник (см. «Домен и публикация»)
 
 ## Структура
 
 ```
-backend/    FastAPI: ядро, REST API, БД, миграции, seed
-frontend/   React + Vite SPA
-Dockerfile  multi-stage сборка (фронт собирается node, отдаётся FastAPI)
-docker-compose.yml
-.env.example
+backend/                 FastAPI: ядро, REST API, БД, миграции Alembic, seed, тесты
+frontend/                React + Vite SPA
+deploy/                  публикация и эксплуатация: vps/ (Caddy), pi/ (прод), tunnel/ и backup/ (образы)
+scripts/                 build-push.* (сборка и пуш образов), fs-backup.* (бэкапы с ПК), export-prod.sh
+Dockerfile               multi-stage сборка (фронт собирается node, отдаётся FastAPI)
+docker-compose.yml       прод на Pi: app + tunnel + backup
+docker-compose.temp.yml  временный прод на ПК вместо Pi: app + tunnel
+run.ps1 / run.sh         единый лаунчер dev
+.env.example             шаблон единого .env
 ```
 
 ## Локальная разработка
 
+Всё проверяется в `development` — отдельного тестового контейнера нет.
+
 ### Единый лаунчер (`run.ps1` / `run.sh`)
 
-После разовой настройки (ниже) dev и test запускаются **одной командой** — что именно,
-решает `APP_ENV` в корневом `.env`:
+После разовой настройки (ниже) dev запускается **одной командой** (лаунчер читает
+`APP_ENV` в корневом `.env`):
 
 ```powershell
 .\run.ps1        # Windows   (Linux / macOS / Git Bash:  ./run.sh)
@@ -31,9 +39,9 @@ docker-compose.yml
 
 | `APP_ENV` в `.env` | что делает лаунчер |
 |---|---|
-| `development` | `uvicorn --reload` (бэк) + `vite` (фронт) нативно, в двух окнах |
-| `test` | `docker compose` прод-клон на :8080 (со сборкой образа) |
-| `production` | не запускает — прод деплоится отдельно (см. «Git и деплой») |
+| `development` | сначала `alembic upgrade head`, затем `uvicorn --reload` (бэк) + `vite` (фронт) нативно: `run.ps1` — в отдельных окнах, `run.sh` — в текущем терминале (Ctrl+C останавливает оба). При `LOCAL_PUBLIC=vps` дополнительно поднимает SSH-туннель на `forbidden-stars.ru` |
+| `production` | не запускает — прод деплоится отдельно (см. «Production» и «Git и деплой») |
+| другое значение | отказ: допустимы только `development` и `production` (бэкенд тоже не стартует) |
 
 Разовая настройка перед первым запуском — поднять venv бэка и зависимости фронта
 (после неё повседневный цикл — просто `.\run.ps1`). Vite проксирует `/api` на бэкенд.
@@ -47,8 +55,8 @@ python -m venv .venv
 .\.venv\Scripts\Activate.ps1     # если ругается на политику: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
 pip install -e ".[dev]"          # .[dev] — один аргумент (пакет + dev-зависимости)
 Copy-Item ..\.env.example ..\.env  # ЕДИНЫЙ .env лежит в КОРНЕ репозитория
-alembic upgrade head             # применит миграции и сидинг
-python -m app.bootstrap          # создаст/синхронизирует администратора из .env
+alembic upgrade head             # применит миграции и сидинг справочников
+python -m app.bootstrap          # справочники + создаст/синхронизирует администратора из .env (опционально)
 uvicorn app.main:app --reload --timeout-graceful-shutdown 2   # http://localhost:8000  (Swagger: /api/docs)
 ```
 
@@ -75,6 +83,10 @@ python -m app.bootstrap
 uvicorn app.main:app --reload --timeout-graceful-shutdown 2
 ```
 
+> В dev тот же bootstrap (справочники + админ из `.env`) выполняется сам при старте uvicorn,
+> поэтому `python -m app.bootstrap` вручную обычно не нужен. Dev-БД, загрузки и ачивки
+> лежат в `backend/data/dev/` (пути в `.env` относительные — запускайте из `backend/`).
+
 > **`--timeout-graceful-shutdown` обязателен.** Открытая вкладка держит SSE-поток
 > `/api/events`, и без лимита `--reload` ждёт его закрытия вечно — сайт висит на загрузке,
 > а в логе только `Reloading...`.
@@ -96,45 +108,42 @@ npm run dev                    # http://127.0.0.1:5173 или http://localhost:5
 
 ## Production (Docker на Pi)
 
+На Pi нужны только **два файла** — `docker-compose.yml` и `.env`: образы `app`, `tunnel` и
+`backup` собираются на ПК под arm64 и пушатся в Gitea-реестр, Pi тянет их сам.
+
+```powershell
+# ПК (обычно с ветки main): собрать и опубликовать образы
+docker login gitea.arseniev.info
+.\scripts\build-push.ps1
+```
 ```bash
-cp .env.example .env           # заполните SECRET_KEY, ADMIN_PASSWORD и пр.
-docker compose build           # на ARM64 собирается нативно
-docker compose up -d           # приложение на :8000, БД на томе
+# Pi, папка с docker-compose.yml и .env
+docker compose up -d           # pull_policy: always — тянет свежие образы, без сборки
 ```
 
-FastAPI отдаёт собранный SPA и API с одного origin. Миграции и бутстрап админа
-выполняются автоматически при старте (`entrypoint.sh`).
+Портов на хост нет — прод доступен только на `https://forbiddenstars.ru` через
+туннель-контейнер. FastAPI отдаёт собранный SPA и API с одного origin. Миграции, сидинг
+справочников и создание админа выполняются автоматически при старте (`entrypoint.sh`).
+В production закрыты OpenAPI/Swagger, а с дефолтным или коротким `SECRET_KEY` либо
+дефолтным `ADMIN_PASSWORD` приложение не стартует. `ADMIN_PASSWORD` применяется сам только
+при первом создании админа; сменить его потом — правкой `.env`, `docker compose up -d` и
+`docker compose exec app python -m app.bootstrap --reset-admin-password` (все админские
+сессии завершатся; подробно — в `deploy/pi/README.md`).
+Пошагово — [`deploy/pi/README.md`](deploy/pi/README.md), бэкапы — [`deploy/backup/README.md`](deploy/backup/README.md).
 
-## Test — локальный прод-клон в контейнере
-
-Тот же образ и поведение, что и прод (FastAPI отдаёт SPA, БД на томе, вход игроков
-по логину/паролю или через Telegram), но на своей машине — для проверки прод-сборки до выката на Pi.
-Изолированные тома и порт **8080** (не конфликтует с dev-uvicorn на :8000).
-
-Проще всего — через лаунчер: поставить `APP_ENV=test` в `.env` и запустить `.\run.ps1`.
-Вручную (тот же эффект):
-```bash
-docker compose -f docker-compose.test.yml up -d --build
-# открыть http://localhost:8080  (Swagger: /api/docs)
-docker compose -f docker-compose.test.yml down -v   # остановить и стереть тестовые данные
-```
-
-- Окружение `test` (прод-клон), но `COOKIE_SECURE=false` (локально по HTTP).
-- Читает **тот же `.env`**, что dev/prod (отдельного `.env.test` больше нет); внутри
-  контейнера `APP_ENV` форсится в `test` (см. `docker-compose.test.yml`).
-- Данные — на отдельных томах `db-data-test` / `uploads-data-test` (не пересекаются с dev и Pi).
-- Вход: **админ-панель** (`/admin/login`) работает сразу по логину/паролю; **игроки** —
-  по логину/паролю сразу, через Telegram — при боте и публичном HTTPS/туннеле на `localhost:8080`.
 - **Не используйте `$` в секретах.** Единый `.env` читают и pydantic (dev — `$` дословно),
-  и docker compose (test/prod — `$` = подстановка переменной). Чтобы значение совпадало
+  и docker compose (prod — `$` = подстановка переменной). Чтобы значение совпадало
   везде, в `SECRET_KEY`/`ADMIN_PASSWORD` не должно быть `$`. Удобно генерировать так:
   `python -c "import secrets;print(secrets.token_urlsafe(48))"` (даёт только `[A-Za-z0-9_-]`).
+- **Временный прод на ПК** (вместо Pi): `docker compose -f docker-compose.temp.yml up -d --build` —
+  поведение production, локальная сборка x86, ключ туннеля из файла `deploy/tunnel/id_tunnel`,
+  тот же слот VPS 9000, что у Pi (одновременно не запускать).
 
 ## Аутентификация
 
 Методы входа зависят от окружения (`APP_ENV`):
 
-| | dev | test / prod |
+| | dev | prod |
 |---|---|---|
 | Логин (= ник) и пароль | ✓ | ✓ (основной) |
 | Telegram Login Widget | ✓ | ✓ |
@@ -142,57 +151,73 @@ docker compose -f docker-compose.test.yml down -v   # остановить и с
 
 - **Логин и пароль** (`app/auth/password.py`) — основной вход. Логин — это ник игрока
   (смена ника меняет логин). Пароль: от 8 символов, не длиннее 72 байт, хранится bcrypt.
-  От перебора — окно 15 минут в памяти процесса: 5 неудач на пару «IP + логин» и 20 на IP,
-  дальше `429 TOO_MANY_ATTEMPTS`. Игрок без пароля (из Telegram или созданный до паролей)
-  после входа видит обязательное окно «Задайте пароль». В профиле пароль меняется (нужен
-  текущий) и привязывается Telegram (ник не меняется). Забытый пароль задаёт админ
-  на вкладке аккаунтов — почту приложение не хранит.
-- **Stub-вход (по нику)** — только для разработки. Его код **физически не попадает в прод:**
-  файлы `backend/app/auth/dev_stub.py` и `backend/app/routers/dev_auth.py` исключены из
-  Docker-образа (`.dockerignore`), роутер подключается лишь при `APP_ENV=development`
-  (`app/main.py`), а на фронте dev-блок вырезается из прод-сборки (`import.meta.env.DEV`).
-- **Telegram:** сервер проверяет подпись виджета (HMAC по `TELEGRAM_BOT_TOKEN`).
-  `GET /api/auth/config` отдаёт доступные методы и `telegram_bot_username` для виджета.
+  От перебора — окно 15 минут в памяти процесса: 5 неудач на пару «IP + логин», 20 на IP и
+  50 на аккаунт (независимо от IP), дальше `429 TOO_MANY_ATTEMPTS`. Регистраций — не больше
+  10 с одного IP за окно. Игрок без пароля (из Telegram или созданный до паролей) после входа
+  видит обязательное окно «Задайте пароль»: закрыть его нельзя, только задать пароль или
+  выйти; в dev-сборке есть кнопка «Позже (dev)». В профиле пароль меняется (нужен текущий) и
+  привязывается Telegram (ник не меняется). Забытый пароль задаёт админ на вкладке
+  аккаунтов — почту приложение не хранит. Смена или сброс пароля завершает все прежние
+  сессии игрока (при смене в профиле текущее устройство остаётся в системе); «Выйти»
+  отзывает токен этого устройства.
+- **Stub-вход (по нику)** и **жёсткое удаление аккаунтов** в админке — только для разработки.
+  Их код **физически не попадает в прод:** файлы `backend/app/auth/dev_stub.py`,
+  `backend/app/routers/dev_auth.py` и `backend/app/routers/dev_admin.py` исключены из
+  Docker-образа (`.dockerignore`), роутеры подключаются лишь при `APP_ENV=development`
+  (`app/main.py`), а на фронте dev-блоки вырезаются из прод-сборки (`import.meta.env.DEV`).
+  В проде аккаунт можно только отключить.
+- **Telegram:** сервер проверяет подпись виджета (HMAC по `TELEGRAM_BOT_TOKEN`) и свежесть
+  данных (не старше суток). Первый вход регистрирует игрока под Telegram-тегом; если такой ник
+  занят или некорректен, фронт просит выбрать другой. `GET /api/auth/config` отдаёт доступные
+  методы и `telegram_bot_username` для виджета.
 
 **Настройка Telegram (когда будете подключать реальный вход):**
 1. Создать бота у [@BotFather](https://t.me/BotFather) → получить **токен** и **username**.
-2. `/setdomain` у BotFather → оба домена: `forbiddenstars.ru` (prod) и `forbidden-stars.ru` (dev/test).
+2. `/setdomain` у BotFather → оба домена: `forbiddenstars.ru` (prod) и `forbidden-stars.ru` (dev).
 3. В `.env`: `TELEGRAM_BOT_TOKEN=...`, `TELEGRAM_BOT_USERNAME=...` (без `@`).
 4. Виджету нужен HTTPS-домен (см. «Домен и публикация») — по голому HTTP/localhost он не работает.
 
-Админ-вход (секретная панель, логин+пароль) — отдельный механизм, доступен во всех окружениях.
+Админ-вход (секретная панель, логин+пароль) — отдельный механизм, доступен во всех
+окружениях. Страница — `/admin/login`; из интерфейса туда ведёт удержание кнопки «Меню» 10 секунд.
 
-## Окружения (dev / test / prod)
+## Окружения (dev / prod)
 
-Один и тот же код; контур задаёт `APP_ENV` в **едином** `.env` (его читает лаунчер):
+Один и тот же код; контур задаёт `APP_ENV` в **едином** `.env`. Допустимы только
+`development` и `production` — с любым другим значением бэкенд не стартует:
 
-| | dev | test (прод-клон локально) | prod (Pi) |
-|---|---|---|---|
-| Запуск | `.\run.ps1` → `uvicorn --reload` + `vite` | `.\run.ps1` → `docker compose -f docker-compose.test.yml` | `docker compose up -d` |
-| `APP_ENV` | `development` | `test` (форсится в compose) | `production` (форсится в compose) |
-| Env-файл | единый `.env` | единый `.env` | единый `.env` (на Pi) |
-| Раздача SPA | Vite (HMR), :5173 | FastAPI, :8080 | FastAPI, :8000 |
-| База данных | `backend/data/dev/…` | том `db-data-test` (`/data`) | том `db-data` (`/data`) |
-| Вход игроков | пароль + Telegram + ник (stub) | пароль + Telegram | пароль + Telegram |
+| | dev | prod (Pi) |
+|---|---|---|
+| Запуск | `.\run.ps1` → `uvicorn --reload` + `vite` | `docker compose up -d` |
+| `APP_ENV` | `development` | `production` (форсится в compose) |
+| Env-файл | единый `.env` | единый `.env` (на Pi) |
+| Раздача SPA | Vite (HMR), `:5173` | FastAPI, только через `https://forbiddenstars.ru` |
+| База данных | `backend/data/dev/…` | том `db-data` (`/data`) |
+| Вход игроков | пароль + Telegram + ник (stub) | пароль + Telegram |
+| Swagger (`/api/docs`) | ✓ | ✗ |
+| Fail-fast по дефолтным секретам | ✗ | ✓ |
 
-- **Один `.env` на машину** в корне (рядом с `.env.example`). `APP_ENV` в нём решает, что
-  запустит лаунчер (`development`/`test`); прод-контейнер это значение **игнорирует** и всегда
-  `production`. Отдельного `.env.test` больше нет.
+- **Один `.env` на машину** в корне (рядом с `.env.example`). Прод-контейнер значение
+  `APP_ENV` из него **игнорирует** и всегда `production`.
 - **Структура БД одна** (общие миграции Alembic), **файлы разные**: dev → `DEV_DATABASE_URL`
-  (`backend/data/dev/`), test и prod → `PROD_DATABASE_URL` (том `/data`; у test и prod это
-  РАЗНЫЕ тома). Данные дева в образ **не попадают** (`data/` в `.dockerignore`).
-- **В Docker идёт только прод-код:** dev-вход (stub) и тесты физически исключены из образа
-  (`.dockerignore`); `test` — тот же образ, что и прод, просто локально и с `APP_ENV=test`.
+  (`backend/data/dev/`), prod → `PROD_DATABASE_URL` (том `/data`). Так же раздельно лежат
+  загрузки (`*_UPLOAD_DIR`) и ачивки (`*_ACHIEVEMENTS_DIR`).
+- **В Docker идёт только прод-код:** dev-вход (stub), dev-удаление аккаунтов и тесты физически
+  исключены из образа (`.dockerignore`). Данные дева (`backend/data/`), любые файлы SQLite
+  и локальные бэкапы (`backups/`) в образ тоже не попадают.
 
 ## Git и деплой
 
-- Ветка **`dev`** — рабочая: весь код, лаунчер, тесты. Повседневная разработка и `test` здесь.
+- Ветка **`dev`** — рабочая: весь код, лаунчер, тесты. Повседневная разработка и проверка здесь.
 - Ветка **`main`** — релиз прода: готовое промоутишь из `dev` через `merge dev→main`. Файлы во
   всех ветках одинаковы (окружение задаёт `.env`/compose, а не ветка) → merge безболезненный;
   чистоту прод-образа обеспечивает `.dockerignore`, а не разные наборы файлов.
-- **Деплой на Pi:** `git pull` ветки `main` → `scripts/build-push.ps1`.
-- **Чистая выгрузка в папку без git** (опц.): `scripts/export-prod.sh <dir> main` (через
-  `git archive` + `export-ignore` — в папку идёт ровно прод-набор, без лаунчера/тестов/dev-входа).
+- **Деплой на Pi:** на ПК с ветки `main` — `.\scripts\build-push.ps1` (собирает и пушит
+  образы app + tunnel + backup под arm64), на Pi — `docker compose up -d`. На Windows нужна
+  именно PS-версия скрипта (`build-push.sh` из PowerShell уходит в WSL).
+- **Чистая выгрузка в папку без git** (опц., к деплою на Pi не относится):
+  `scripts/export-prod.sh <dir> [ref]` — через `git archive` + `export-ignore` из
+  `.gitattributes` (без тестов, stub-входа, `pyproject.toml`, README-файлов и лаунчера).
+  `dev_admin.py` в `export-ignore` пока не внесён (задача #70).
 
 Секреты (`.env`) и данные (`data/`, `*.db`) в git не идут — см. `.gitignore`.
 
@@ -200,21 +225,32 @@ docker compose -f docker-compose.test.yml down -v   # остановить и с
 
 Публичные адреса отдаёт **VPS-привратник** (Caddy + HTTPS твоими сертификатами), а
 приложение само открывает к нему SSH reverse-туннель (дома белого IP нет — CGNAT).
-У **test/prod** туннель — **отдельный контейнер** в их `docker-compose`, и портов на хост
-они не публикуют (доступны только через домен):
+У **прода** туннель — **отдельный контейнер** в `docker-compose.yml`, и портов на хост он
+не публикует (доступен только через домен):
 
 | | домен | как выставляется | слот VPS |
 |---|---|---|---|
 | prod | `forbiddenstars.ru` | туннель-контейнер (постоянно) → `app:8000` | 9000 |
-| test | `forbidden-stars.ru` | туннель-контейнер → `app:8000` | 9001 |
-| dev | `forbidden-stars.ru` | `run.ps1` при `LOCAL_PUBLIC=vps` → `localhost:5173` | 9001 |
+| dev | `forbidden-stars.ru` | лаунчер (`run.ps1`/`run.sh`) при `LOCAL_PUBLIC=vps` → `localhost:5173` | 9001 |
 
-- Прод (9000) и dev/test (9001) на **разных слотах/доменах** → прод и (dev|test) работают
-  одновременно. Dev и test делят слот 9001 → по очереди.
-- Dev по умолчанию только на localhost; `LOCAL_PUBLIC=vps` + `run.ps1` выставляет его на домен.
+- Прод (9000) и dev (9001) на **разных слотах/доменах** → работают одновременно. Временный
+  прод на ПК (`docker-compose.temp.yml`) занимает слот 9000 — одновременно с продом на Pi не запускать.
+- Dev по умолчанию только на localhost; `LOCAL_PUBLIC=vps` + лаунчер выставляет его на домен.
+  В dev при этом открыты stub-вход по нику и Swagger — держите туннель поднятым только на
+  время проверки (задача #69).
 - `COOKIE_SECURE` выводится автоматически (HTTPS-домен ⇒ Secure-cookie; dev+localhost ⇒ нет).
+- Ключ туннеля: временный прод берёт файл `deploy/tunnel/id_tunnel`, прод на Pi —
+  `TUNNEL_KEY_B64` (base64) в `.env`, dev-туннель — системный `ssh` с ключом по умолчанию
+  (`~/.ssh`). Публичные части — в `authorized_keys` пользователя `tunnel` на VPS.
 - Пошаговая настройка — в [`deploy/`](deploy/README.md): `vps/` (Caddy, сертификаты, юзер `tunnel`),
-  `pi/` (app + туннель в Docker), образ туннеля — `deploy/tunnel/`. Ключ — `deploy/tunnel/id_tunnel`.
+  `pi/` (app + туннель + бэкапы в Docker), образ туннеля — `deploy/tunnel/`.
+
+## Бэкапы
+
+Контейнер `backup` (restic) в `docker-compose.yml` каждую ночь делает зашифрованный снимок
+БД, `uploads` и `achievements` — на Pi (том `backup-data`) и на VPS по SFTP. С ПК снимки
+скачиваются со сверкой sha256 (`scripts/fs-backup.ps1 pull`).
+Настройка, восстановление и действия при гибели Pi — [`deploy/backup/README.md`](deploy/backup/README.md).
 
 ## Дополнения и фракции
 
@@ -225,4 +261,6 @@ docker compose -f docker-compose.test.yml down -v   # остановить и с
 | Forsaken Voids | Инквизиция, Сёстры битвы, Друкхари, Адептус Механикус |
 
 Группа отмечает имеющиеся дополнения; при создании партии доступны только фракции
-этих дополнений (база — всегда).
+этих дополнений (база — всегда). Справочник сидится из `backend/app/seed/reference_data.py`.
+Админ может переименовать фракцию в панели, но сейчас переименование откатывается при
+каждом перезапуске приложения (задача #72).

backend/alembic/versions/0014_rating_inputs.py

@@ -0,0 +1,133 @@
+"""Рейтинг (#23): раунд окончания, цели и миры участников, правило 9 раундов, last_standing.
+
+Идемпотентна: на свежей БД столбцы и новый CHECK создаёт 0001 (create_all из актуальных
+моделей) -> меняется только бэкфилл (на пустой БД он ничего не находит); на существующей
+БД добавляет столбцы, расширяет CHECK причины победы (если он в БД есть) и проставляет
+last_standing.
+
+Столбцы nullable и задним числом не заполняются: NULL — «нет данных», рейтинг
+подставляет вместо них типичные значения (docs/rating/rating-system.md, 4.8).
+
+Revision ID: 0014_rating_inputs
+Revises: 0013_user_token_version
+Create Date: 2026-09-14
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+from alembic import op
+
+revision: str = "0014_rating_inputs"
+down_revision: Union[str, None] = "0013_user_token_version"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+CK_WIN_REASON = "ck_match_win_reason"
+OLD_REASONS = "win_reason IS NULL OR win_reason IN ('objectives','worlds','plastic','resources')"
+NEW_REASONS = (
+    "win_reason IS NULL OR win_reason IN "
+    "('objectives','worlds','plastic','resources','last_standing')"
+)
+
+# Причина last_standing ⇔ невыбывший участник ровно один (решение владельца по #22).
+# Только у партий хотя бы с двумя участниками: партия, из которой dev-удаление аккаунта
+# вычеркнуло соперника, тоже имеет «одного невыбывшего», но победой выжившего не была.
+BACKFILL_LAST_STANDING = """
+UPDATE matches SET win_reason = 'last_standing'
+WHERE status = 'finished'
+  AND (win_reason IS NULL OR win_reason <> 'last_standing')
+  AND (SELECT COUNT(*) FROM match_participants mp
+       WHERE mp.match_id = matches.id AND mp.eliminated = 0) = 1
+  AND (SELECT COUNT(*) FROM match_participants mp WHERE mp.match_id = matches.id) >= 2
+"""
+
+
+def _columns(insp, table: str) -> set[str]:
+    return {c["name"] for c in insp.get_columns(table)}
+
+
+def _win_reason_check(insp) -> str | None:
+    for ck in insp.get_check_constraints("matches"):
+        if ck.get("name") == CK_WIN_REASON:
+            return ck["sqltext"]
+    return None
+
+
+def _recreate_matches_with_check(bind, drop_existing: bool, sqltext: str) -> None:
+    """Замена CHECK в SQLite = пересоздание таблицы matches (batch copy-and-move).
+
+    При включённых внешних ключах DROP старой таблицы выполнил бы неявный DELETE, и
+    ON DELETE CASCADE унёс бы участников, вложения и черновики. Alembic из CLI работает
+    без PRAGMA foreign_keys (её включает только движок приложения), а внутри транзакции
+    PRAGMA не переключить — поэтому не рискуем и отказываемся с понятной ошибкой."""
+    if bind.exec_driver_sql("PRAGMA foreign_keys").scalar():
+        raise RuntimeError(
+            "0014: PRAGMA foreign_keys=ON — пересоздание matches удалило бы участников "
+            "каскадом. Запускайте миграции через `alembic upgrade head` (CLI)."
+        )
+    with op.batch_alter_table("matches", recreate="always") as b:
+        if drop_existing:
+            b.drop_constraint(CK_WIN_REASON, type_="check")
+        b.create_check_constraint(CK_WIN_REASON, sqltext)
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    insp = inspect(bind)
+
+    if "nine_rounds_rule" not in _columns(insp, "groups"):
+        with op.batch_alter_table("groups") as b:
+            b.add_column(
+                sa.Column("nine_rounds_rule", sa.Boolean(), nullable=False, server_default="0")
+            )
+
+    match_cols = _columns(insp, "matches")
+    with op.batch_alter_table("matches") as b:
+        if "end_round" not in match_cols:
+            b.add_column(sa.Column("end_round", sa.Integer(), nullable=True))
+        if "nine_rounds_rule" not in match_cols:
+            b.add_column(
+                sa.Column("nine_rounds_rule", sa.Boolean(), nullable=False, server_default="0")
+            )
+
+    participant_cols = _columns(insp, "match_participants")
+    with op.batch_alter_table("match_participants") as b:
+        if "objectives" not in participant_cols:
+            b.add_column(sa.Column("objectives", sa.Integer(), nullable=True))
+        if "worlds" not in participant_cols:
+            b.add_column(sa.Column("worlds", sa.Integer(), nullable=True))
+
+    # БД, созданные до появления CHECK в моделях (0001 тогда был старше), ограничения
+    # не имеют вовсе — last_standing им и так разрешён, пересоздавать таблицу незачем.
+    check = _win_reason_check(inspect(bind))
+    if check is not None and "last_standing" not in check:
+        _recreate_matches_with_check(bind, drop_existing=True, sqltext=NEW_REASONS)
+
+    op.execute(BACKFILL_LAST_STANDING)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    # Прежний CHECK не знает last_standing: такие партии теряют признак (раньше их
+    # записывали «по целям»).
+    op.execute("UPDATE matches SET win_reason = 'objectives' WHERE win_reason = 'last_standing'")
+    check = _win_reason_check(inspect(bind))
+    if check is not None and "last_standing" in check:
+        _recreate_matches_with_check(bind, drop_existing=True, sqltext=OLD_REASONS)
+
+    insp = inspect(bind)
+    participant_cols = _columns(insp, "match_participants")
+    with op.batch_alter_table("match_participants") as b:
+        for name in ("worlds", "objectives"):
+            if name in participant_cols:
+                b.drop_column(name)
+    match_cols = _columns(insp, "matches")
+    with op.batch_alter_table("matches") as b:
+        for name in ("nine_rounds_rule", "end_round"):
+            if name in match_cols:
+                b.drop_column(name)
+    if "nine_rounds_rule" in _columns(insp, "groups"):
+        with op.batch_alter_table("groups") as b:
+            b.drop_column("nine_rounds_rule")

backend/alembic/versions/0015_announcements.py

@@ -0,0 +1,80 @@
+"""Объявления администрации (#84): сами объявления и отметки «игрок закрыл».
+
+Идемпотентна: на свежей БД таблицы создаёт 0001 (create_all из актуальных моделей) -> no-op;
+на существующей БД создаёт недостающие таблицы.
+
+Отходит от 0013, а не от 0014: объявления выпущены в main раньше рейтинга. Ветки рейтинга
+(0014) и объявлений (0015) сводит пустая миграция 0016.
+
+Revision ID: 0015_announcements
+Revises: 0013_user_token_version
+Create Date: 2026-09-18
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+from alembic import op
+
+revision: str = "0015_announcements"
+down_revision: Union[str, None] = "0013_user_token_version"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    tables = set(inspect(bind).get_table_names())
+
+    if "announcements" not in tables:
+        op.create_table(
+            "announcements",
+            sa.Column("id", sa.Integer(), primary_key=True),
+            sa.Column("title", sa.String(64), nullable=False),
+            sa.Column("body_html", sa.Text(), nullable=False),
+            sa.Column("starts_at", sa.DateTime(), nullable=False),
+            sa.Column("ends_at", sa.DateTime(), nullable=False),
+            sa.Column("show_to_new_players", sa.Boolean(), nullable=False, server_default="1"),
+            sa.Column("revision", sa.Integer(), nullable=False, server_default="1"),
+            sa.Column(
+                "created_by",
+                sa.Integer(),
+                sa.ForeignKey("users.id", ondelete="SET NULL"),
+                nullable=True,
+            ),
+            sa.Column("created_at", sa.DateTime(), nullable=False),
+            sa.Column("updated_at", sa.DateTime(), nullable=False),
+            sa.CheckConstraint("ends_at > starts_at", name="ck_announcement_period"),
+        )
+        op.create_index("ix_announcements_period", "announcements", ["starts_at", "ends_at"])
+
+    if "announcement_views" not in tables:
+        op.create_table(
+            "announcement_views",
+            sa.Column(
+                "announcement_id",
+                sa.Integer(),
+                sa.ForeignKey("announcements.id", ondelete="CASCADE"),
+                primary_key=True,
+            ),
+            sa.Column(
+                "user_id",
+                sa.Integer(),
+                sa.ForeignKey("users.id", ondelete="CASCADE"),
+                primary_key=True,
+            ),
+            sa.Column("revision", sa.Integer(), nullable=False),
+            sa.Column("closed_at", sa.DateTime(), nullable=False),
+        )
+        op.create_index(
+            "ix_announcement_views_user_id", "announcement_views", ["user_id"]
+        )
+
+
+def downgrade() -> None:
+    tables = set(inspect(op.get_bind()).get_table_names())
+    if "announcement_views" in tables:
+        op.drop_table("announcement_views")
+    if "announcements" in tables:
+        op.drop_table("announcements")

backend/alembic/versions/0016_merge_rating_announcements.py

@@ -0,0 +1,25 @@
+"""Слияние веток миграций: рейтинг (0014) и объявления (0015).
+
+Объявления (#84) вышли в main раньше рейтинга, поэтому 0015 отходит от 0013, а не от 0014,
+и у графа миграций две ветки. Эта миграция сводит их в одну голову и сама ничего не меняет:
+прод, стоящий на 0015 (релиз без рейтинга), при переходе на эту версию получит 0014 и её;
+база на 0014 (dev) — 0015 и её.
+
+Revision ID: 0016_merge_rating_announcements
+Revises: 0014_rating_inputs, 0015_announcements
+Create Date: 2026-09-18
+"""
+from typing import Sequence, Union
+
+revision: str = "0016_merge_rating_announcements"
+down_revision: Union[str, Sequence[str], None] = ("0014_rating_inputs", "0015_announcements")
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass

backend/app/bootstrap.py

@@ -1,9 +1,12 @@
 """Идемпотентный бутстрап: справочники + учётная запись администратора.
 
 Запуск: `python -m app.bootstrap` (вызывается из entrypoint.sh после миграций).
+Ротация пароля админа из .env: `python -m app.bootstrap --reset-admin-password` (#73).
 """
 from __future__ import annotations
 
+import argparse
+
 from sqlmodel import Session, select
 
 from app.core.config import settings
@@ -11,6 +14,7 @@ from app.core.security import hash_password, verify_password
 from app.db.session import engine
 from app.models import User
 from app.seed.reference_data import seed_reference_data
+from app.services import user_service
 
 
 def _ensure_admin(session: Session) -> None:
@@ -38,7 +42,9 @@ def _ensure_admin(session: Session) -> None:
 
     # Администратор уже существует.
     if not settings.is_development:
-        # В test/prod пароль НЕ перезаписываем (мог быть изменён через панель).
+        # В prod обычный старт пароль НЕ перезаписывает: смена ADMIN_PASSWORD в .env сама
+        # по себе ничего не делает — применить её можно только осознанно, командой
+        # ротации (reset_admin_password), которая заодно отзывает админские сессии.
         return
 
     # DEV: подтягиваем логин/пароль из .env (env — источник истины в деве).
@@ -55,11 +61,48 @@ def _ensure_admin(session: Session) -> None:
         print(f"[bootstrap] DEV: администратор обновлён из .env ({', '.join(changed)})")
 
 
+def reset_admin_password(session: Session) -> User:
+    """Записать существующему админу пароль из ADMIN_PASSWORD (#73) — в любом окружении.
+
+    Через панель пароль админа не меняется, а обычный старт в prod его из .env не берёт:
+    это единственный штатный способ, и он требует доступа к серверу. set_password
+    проверяет пароль и увеличивает token_version — все выданные админские сессии
+    (в том числе чужая, если пароль утёк) перестают действовать. Логин не трогаем."""
+    if not settings.admin_bootstrap_enabled:
+        raise RuntimeError(
+            "ADMIN_BOOTSTRAP_ENABLED=false — администратором управляют вручную, ротация отключена."
+        )
+    password = (settings.admin_password or "").strip()
+    if not password:
+        raise RuntimeError("ADMIN_PASSWORD пуст — нечего применять.")
+    admin = session.exec(select(User).where(User.role == "admin")).first()
+    if admin is None:
+        raise RuntimeError("Администратора ещё нет — запустите обычный bootstrap, он его создаст.")
+    return user_service.set_password(session, admin, password)
+
+
 def bootstrap() -> None:
     with Session(engine) as session:
         seed_reference_data(session)  # идемпотентно
         _ensure_admin(session)
 
 
+def main(argv: list[str] | None = None) -> None:
+    ap = argparse.ArgumentParser(prog="python -m app.bootstrap", description=__doc__)
+    ap.add_argument(
+        "--reset-admin-password",
+        action="store_true",
+        help="применить ADMIN_PASSWORD из .env к существующему админу и завершить его сессии",
+    )
+    args = ap.parse_args(argv)
+    if not args.reset_admin_password:
+        bootstrap()
+        return
+    with Session(engine) as session:
+        admin = reset_admin_password(session)
+    print(f"[bootstrap] Пароль администратора {admin.nickname} обновлён из .env; "
+          "все его сессии завершены.")
+
+
 if __name__ == "__main__":
-    bootstrap()
+    main()

backend/app/core/config.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from functools import lru_cache
 from pathlib import Path
 
-from pydantic import model_validator
+from pydantic import field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Единый .env лежит в КОРНЕ репозитория (рядом с .env.example) — читается одинаково
@@ -12,12 +12,15 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 # (исключён из образа) — там настройки приходят переменными от docker compose.
 _ROOT_ENV = str(Path(__file__).resolve().parents[3] / ".env")
 
-# Небезопасные значения по умолчанию (годятся только для dev). В production приложение
-# с ними не стартует — см. валидатор _forbid_default_secrets_in_prod (#59).
+# Небезопасные значения по умолчанию (годятся только для dev на localhost). Опубликованное
+# приложение с ними не стартует — см. валидатор _forbid_default_secrets_when_published.
 _DEFAULT_SECRET_KEY = "change-me-dev-secret-not-for-production"
 _DEFAULT_ADMIN_PASSWORD = "change-me-admin-password"
 _MIN_SECRET_KEY_LENGTH = 32
 
+# Допустимые окружения. Отдельного test-контура нет: всё проверяется в development.
+_APP_ENVS = ("development", "production")
+
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
@@ -27,16 +30,16 @@ class Settings(BaseSettings):
         case_sensitive=False,
     )
 
-    # ── Главный переключатель окружения: development | test | production ───────
+    # ── Главный переключатель окружения: development | production ─────────────
     # development — нативный dev (uvicorn + vite), БД в ./data/dev/, вход Telegram+ник.
-    # test        — прод-клон в Docker локально (порт 8080), ведёт себя как прод.
     # production  — Docker на Pi; контейнер форсит это значение, игнорируя .env.
     app_env: str = "development"
     log_level: str = "INFO"
 
-    # Публикация локального окружения (dev/test) наружу через VPS-туннель.
+    # Публикация локального dev-окружения наружу через VPS-туннель.
     # Читает ЛАУНЧЕР (run.ps1/run.sh): local — только localhost; vps — плюс SSH-туннель
-    # на forbidden-stars.ru. Влияет на cookie_secure (vps ⇒ снаружи HTTPS ⇒ Secure-cookie).
+    # на forbidden-stars.ru. Приложению значение говорит, опубликовано ли оно (is_published):
+    # от этого зависят Secure-cookie и проверка секретов при старте.
     local_public: str = "local"
 
     # Часовой пояс приложения (фиксированное смещение, по умолчанию МСК +3).
@@ -91,17 +94,13 @@ class Settings(BaseSettings):
         стартовый bootstrap в lifespan и синхронизацию админа из .env."""
         return self.app_env.lower() == "development"
 
-    @property
-    def is_test(self) -> bool:
-        return self.app_env.lower() == "test"
-
     @property
     def is_production(self) -> bool:
         return self.app_env.lower() == "production"
 
     @property
     def database_url(self) -> str:
-        """БД: dev — отдельный файл дева; test и prod — том контейнера (/data)."""
+        """БД: dev — отдельный файл дева; prod — том контейнера (/data)."""
         return self.dev_database_url if self.is_development else self.prod_database_url
 
     @property
@@ -113,23 +112,41 @@ class Settings(BaseSettings):
         return self.dev_achievements_dir if self.is_development else self.prod_achievements_dir
 
     @property
-    def cookie_secure(self) -> bool:
-        """Secure-cookie нужен везде, где снаружи HTTPS (домен). Исключение —
-        нативный dev на localhost по HTTP (development + local_public=local)."""
+    def is_published(self) -> bool:
+        """Приложение доступно снаружи по домену: production или dev, выставленный через
+        VPS-туннель. Не опубликован только нативный dev на localhost
+        (development + local_public=local)."""
         return not (self.is_development and self.local_public.lower() == "local")
 
+    @property
+    def cookie_secure(self) -> bool:
+        """Secure-cookie нужен везде, где снаружи HTTPS (домен), — у опубликованного
+        приложения. На localhost по HTTP браузер Secure-cookie не вернул бы."""
+        return self.is_published
+
     @property
     def cookie_domain_value(self) -> str | None:
         return self.cookie_domain or None
 
-    @model_validator(mode="after")
-    def _forbid_default_secrets_in_prod(self) -> "Settings":
-        """Fail-fast: в production не стартуем с дефолтными/слабыми секретами (#59).
+    @field_validator("app_env")
+    @classmethod
+    def _known_app_env(cls, value: str) -> str:
+        """Неизвестное окружение — ошибка старта, а не молчаливое «почти прод»: любое
+        значение, кроме development, выбирает прод-пути к данным и выключает dev-вход."""
+        if value.lower() not in _APP_ENVS:
+            raise ValueError(
+                f"APP_ENV={value!r} не поддерживается — допустимо: {', '.join(_APP_ENVS)}"
+            )
+        return value
 
-        Деплой, скопировавший .env.example дословно (или забывший поле), иначе поднялся бы
-        с общеизвестным ключом подписи JWT (подделка любого токена, включая админский) и
-        известным паролем администратора. В dev/test проверка не мешает — там дефолты норма."""
-        if self.app_env.lower() != "production":
+    @model_validator(mode="after")
+    def _forbid_default_secrets_when_published(self) -> "Settings":
+        """Fail-fast: опубликованное приложение не стартует с дефолтными/слабыми
+        секретами (#59, #69) — и прод, и dev, выставленный на домен (LOCAL_PUBLIC=vps).
+
+        Иначе снаружи оказались бы общеизвестный ключ подписи JWT (подделка любого токена,
+        включая админский) и известный пароль администратора. На localhost дефолты — норма."""
+        if not self.is_published:
             return self
         problems: list[str] = []
         if self.secret_key == _DEFAULT_SECRET_KEY or len(self.secret_key) < _MIN_SECRET_KEY_LENGTH:
@@ -141,8 +158,13 @@ class Settings(BaseSettings):
             if not password or password == _DEFAULT_ADMIN_PASSWORD:
                 problems.append("ADMIN_PASSWORD не задан или дефолтный")
         if problems:
+            where = (
+                "production"
+                if self.is_production
+                else f"dev, опубликованного наружу (LOCAL_PUBLIC={self.local_public})"
+            )
             raise ValueError(
-                "Небезопасная конфигурация production — задайте секреты в .env: "
+                f"Небезопасная конфигурация {where} — задайте секреты в .env: "
                 + "; ".join(problems)
             )
         return self

backend/app/main.py

@@ -17,6 +17,7 @@ from app.core.errors import AppError, app_error_handler
 from app.routers import (
     achievements,
     admin,
+    announcements,
     auth,
     events,
     groups,
@@ -131,8 +132,18 @@ async def _lifespan(_app: FastAPI):
 
     hub.bind_loop(asyncio.get_running_loop())
 
+    if settings.is_development and settings.is_published:
+        # Решение владельца (#69): dev-инструменты остаются и на опубликованном dev —
+        # но о том, что они открыты любому посетителю домена, нужно сказать громко.
+        logging.getLogger("fs").warning(
+            "DEV ОПУБЛИКОВАН НАРУЖУ (LOCAL_PUBLIC=%s): любому посетителю домена открыты "
+            "вход по нику без пароля, список и создание игроков, жёсткое удаление аккаунтов "
+            "и Swagger. Не держите в dev-базе копию прод-данных.",
+            settings.local_public,
+        )
+
     # В DEV приложение само подтягивает справочники и админа из .env при старте
-    # (в test/prod это делает entrypoint.sh; в pytest отключено FS_STARTUP_BOOTSTRAP=0).
+    # (в prod это делает entrypoint.sh; в pytest отключено FS_STARTUP_BOOTSTRAP=0).
     if settings.is_development and os.getenv("FS_STARTUP_BOOTSTRAP", "1") != "0":
         try:
             from app.bootstrap import bootstrap
@@ -151,7 +162,7 @@ async def _lifespan(_app: FastAPI):
 
 
 def create_app() -> FastAPI:
-    # Схему API (openapi.json + Swagger/ReDoc) отдаём только в dev/test: она нужна для
+    # Схему API (openapi.json + Swagger/ReDoc) отдаём только в dev: она нужна для
     # `npm run gen:api` (генерация типов фронта) и удобной отладки. В production закрываем —
     # незачем облегчать разведку поверхности API анонимам (#61).
     docs_enabled = not settings.is_production
@@ -165,7 +176,7 @@ def create_app() -> FastAPI:
     )
 
     # CORS нужен только в dev (vite на :5173 и API на :8000 — разные origin).
-    # В test/prod (и dev через VPS-туннель) всё single-origin → CORS не подключаем.
+    # В prod (и в dev через VPS-туннель) всё single-origin → CORS не подключаем.
     if settings.is_development and settings.cors_origins_list:
         app.add_middleware(
             CORSMiddleware,
@@ -199,12 +210,13 @@ def create_app() -> FastAPI:
     # API-роутеры под /api.
     api_routers = [auth.router, users.router, groups.router, invitations.router,
                    matches.router, reference.router, stats.router, achievements.router,
-                   events.router, notifications.router, admin.router]
+                   events.router, notifications.router, announcements.router,
+                   admin.router]
     for r in api_routers:
         app.include_router(r, prefix="/api")
 
     # DEV-роутеры (вход по нику, жёсткое удаление аккаунтов) — только в development
-    # и только если код физически есть (в test/prod-образе dev_*-файлы исключены
+    # и только если код физически есть (в прод-образе dev_*-файлы исключены
     # .dockerignore, импорт просто не выполнится).
     if settings.is_development:
         for mod_name in ("dev_auth", "dev_admin"):

backend/app/models.py

@@ -195,6 +195,12 @@ class Group(SQLModel, table=True):
         sa_column_kwargs={"onupdate": utcnow},
         nullable=False,
     )
+    # Домашнее правило: при 5–6 игроках играется 9 раундов вместо 8. Партия снимает
+    # значение при старте (Match.nine_rounds_rule), так что смена галочки историю не трогает.
+    nine_rounds_rule: bool = Field(
+        default=False,
+        sa_column=Column(Boolean, nullable=False, server_default="0"),
+    )
 
 
 class GroupMember(SQLModel, table=True):
@@ -275,7 +281,8 @@ class Match(SQLModel, table=True):
         Index("ix_matches_group_played", "group_id", "played_at"),
         CheckConstraint("status IN ('in_progress','finished')", name="ck_match_status"),
         CheckConstraint(
-            "win_reason IS NULL OR win_reason IN ('objectives','worlds','plastic','resources')",
+            "win_reason IS NULL OR win_reason IN "
+            "('objectives','worlds','plastic','resources','last_standing')",
             name="ck_match_win_reason",
         ),
     )
@@ -295,6 +302,14 @@ class Match(SQLModel, table=True):
     finished_at: datetime | None = Field(default=None, sa_column=Column(DateTime, nullable=True))
     duration_minutes: int | None = Field(default=None, sa_column=Column(Integer, nullable=True))
     win_reason: str | None = Field(default=None, sa_column=Column(String(16), nullable=True))
+    # Раунд, в котором партия закончилась (NULL — не указан). Лимит раундов не хранится:
+    # он выводится из снимка nine_rounds_rule и числа участников (scoring.max_rounds).
+    end_round: int | None = Field(default=None, sa_column=Column(Integer, nullable=True))
+    # Снимок Group.nine_rounds_rule на момент старта партии.
+    nine_rounds_rule: bool = Field(
+        default=False,
+        sa_column=Column(Boolean, nullable=False, server_default="0"),
+    )
     player_count: int = Field(sa_column=Column(Integer, nullable=False))
     overall_comment: str | None = Field(sa_column=Column(Text, nullable=True))
     created_by: int = Field(
@@ -340,6 +355,10 @@ class MatchParticipant(SQLModel, table=True):
     eliminated: bool = Field(sa_column=Column(Boolean, nullable=False, server_default="0"))
     was_random: bool = Field(sa_column=Column(Boolean, nullable=False, server_default="0"))
     comment: str | None = Field(sa_column=Column(Text, nullable=True))
+    # Итог партии для рейтинга (NULL — не указан): маркеры целей и дружественные миры
+    # на конец партии. У выбывшего миров 0.
+    objectives: int | None = Field(default=None, sa_column=Column(Integer, nullable=True))
+    worlds: int | None = Field(default=None, sa_column=Column(Integer, nullable=True))
     created_at: datetime = Field(default_factory=utcnow, nullable=False)
 
 
@@ -428,6 +447,69 @@ class Notification(SQLModel, table=True):
     created_at: datetime = Field(default_factory=utcnow, nullable=False, index=True)
 
 
+# ─── Объявления администрации ────────────────────────────────────────────────
+
+class Announcement(SQLModel, table=True):
+    """Объявление администрации (#84): окно поверх приложения в период показа, каждому
+    игроку — пока он его не закроет.
+
+    body_html — уже очищенный сервером HTML (announcement_service.sanitize_body), фронт
+    вставляет его как есть. revision растёт, когда админ сохраняет правку с «показать
+    заново»: закрывшие прежнюю версию увидят объявление ещё раз с пометкой «обновлено».
+    show_to_new_players=False — не показывать зарегистрировавшимся после starts_at."""
+
+    __tablename__ = "announcements"
+    __table_args__ = (
+        CheckConstraint("ends_at > starts_at", name="ck_announcement_period"),
+        Index("ix_announcements_period", "starts_at", "ends_at"),
+    )
+
+    id: int | None = Field(default=None, primary_key=True)
+    title: str = Field(sa_column=Column(String(64), nullable=False))
+    body_html: str = Field(sa_column=Column(Text, nullable=False))
+    starts_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    ends_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    show_to_new_players: bool = Field(
+        default=True,
+        sa_column=Column(Boolean, nullable=False, server_default="1"),
+    )
+    revision: int = Field(default=1, sa_column=Column(Integer, nullable=False, server_default="1"))
+    created_by: int | None = Field(
+        default=None,
+        sa_column=Column(
+            Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True
+        ),
+    )
+    created_at: datetime = Field(default_factory=utcnow, nullable=False)
+    updated_at: datetime = Field(
+        default_factory=utcnow,
+        sa_column_kwargs={"onupdate": utcnow},
+        nullable=False,
+    )
+
+
+class AnnouncementView(SQLModel, table=True):
+    """Игрок закрыл объявление. revision — какую версию он видел: если админ выпустил
+    новую, объявление покажется снова."""
+
+    __tablename__ = "announcement_views"
+
+    announcement_id: int | None = Field(
+        default=None,
+        sa_column=Column(
+            Integer, ForeignKey("announcements.id", ondelete="CASCADE"), primary_key=True
+        ),
+    )
+    user_id: int | None = Field(
+        default=None,
+        sa_column=Column(
+            Integer, ForeignKey("users.id", ondelete="CASCADE"), primary_key=True, index=True
+        ),
+    )
+    revision: int = Field(sa_column=Column(Integer, nullable=False))
+    closed_at: datetime = Field(default_factory=utcnow, nullable=False)
+
+
 # ─── Журнал аудита ───────────────────────────────────────────────────────────
 
 class AuditLog(SQLModel, table=True):

backend/app/routers/admin.py

@@ -13,12 +13,12 @@ from app.core.errors import InvalidCredentialsError, NotFoundError
 from app.core.timeutil import iso_utc
 from app.db.session import get_session
 from app.models import User
-from app.routers.matches import attachment_read, build_match_read
+from app.routers.matches import attachment_read, build_match_read, participant_inputs
 from app.schemas import api as s
-from app.services.match_service import ParticipantInput
 from app.services import (
     achievement_service,
     admin_service,
+    announcement_service,
     attachment_service,
     audit_service,
     faction_service,
@@ -153,7 +153,7 @@ def set_user_password(
 
 
 # Удаление аккаунта — намеренно НЕ здесь: это dev-only возможность, вынесена в
-# routers/dev_admin.py (исключён из прод/тест-образа). В проде аккаунт только
+# routers/dev_admin.py (исключён из прод-образа). В проде аккаунт только
 # отключается (PATCH is_active), удалять нельзя.
 
 
@@ -243,19 +243,6 @@ def update_match(
     admin: User = Depends(get_current_admin),
 ) -> s.MatchRead:
     match = match_service.get_match(session, match_id)
-    participants = None
-    if body.participants is not None:
-        participants = [
-            ParticipantInput(
-                user_id=p.user_id,
-                faction_id=p.faction_id,
-                place=p.place,
-                eliminated=p.eliminated,
-                was_random=p.was_random,
-                comment=p.comment,
-            )
-            for p in body.participants
-        ]
     match = match_service.update_match(
         session,
         match,
@@ -264,7 +251,9 @@ def update_match(
         overall_comment_set=("overall_comment" in body.model_fields_set),
         win_reason=body.win_reason,
         win_reason_set=("win_reason" in body.model_fields_set),
-        participants=participants,
+        end_round=body.end_round,
+        end_round_set=("end_round" in body.model_fields_set),
+        participants=participant_inputs(body),
         expected_version=body.expected_version,
     )
     audit_service.record(
@@ -326,16 +315,15 @@ def delete_match(
     session: Session = Depends(get_session),
     admin: User = Depends(get_current_admin),
 ) -> s.OkResponse:
-    group_id = match_service.get_match(session, match_id).group_id  # для уведомления
-    # До удаления: каскад унесёт участников вместе с партией.
-    participant_ids = notify.match_participant_ids(session, match_id)
+    match = match_service.get_match(session, match_id)
+    group_id, finished = match.group_id, match.status == "finished"  # для уведомления
     admin_service.delete_match(session, match_id)
     audit_service.record(
         session, actor_id=admin.id, action="delete", entity_type="match", entity_id=match_id,
         ip=client_ip(request),
     )
     session.commit()
-    notify.match_removed(session, match_id, group_id, participant_ids)
+    notify.match_removed(session, match_id, group_id, finished=finished)
     return s.OkResponse()
 
 
@@ -475,6 +463,127 @@ def delete_achievement(
     return s.OkResponse()
 
 
+# ─── Объявления ──────────────────────────────────────────────────────────────
+
+def _announcement_read(item: dict) -> s.AdminAnnouncementRead:
+    a = item["a"]
+    return s.AdminAnnouncementRead(
+        id=a.id,
+        title=a.title,
+        body_html=a.body_html,
+        starts_at=iso_utc(a.starts_at),  # type: ignore[arg-type]
+        ends_at=iso_utc(a.ends_at),  # type: ignore[arg-type]
+        show_to_new_players=a.show_to_new_players,
+        revision=a.revision,
+        status=item["status"],
+        seen_count=item["seen"],
+        audience_count=item["audience"],
+        created_at=iso_utc(a.created_at),  # type: ignore[arg-type]
+        updated_at=iso_utc(a.updated_at),  # type: ignore[arg-type]
+    )
+
+
+def _announcement_by_id(session: Session, announcement_id: int) -> s.AdminAnnouncementRead:
+    return _announcement_read(announcement_service.admin_item(session, announcement_id))
+
+
+@router.get("/announcements", response_model=list[s.AdminAnnouncementRead])
+def list_announcements(
+    session: Session = Depends(get_session),
+    _admin: User = Depends(get_current_admin),
+) -> list[s.AdminAnnouncementRead]:
+    return [_announcement_read(i) for i in announcement_service.list_admin(session)]
+
+
+@router.post("/announcements", response_model=s.AdminAnnouncementRead)
+def create_announcement(
+    body: s.AnnouncementWrite,
+    request: Request,
+    session: Session = Depends(get_session),
+    admin: User = Depends(get_current_admin),
+) -> s.AdminAnnouncementRead:
+    a = announcement_service.create(
+        session,
+        title=body.title,
+        body_html=body.body_html,
+        starts_at=body.starts_at,
+        ends_at=body.ends_at,
+        show_to_new_players=body.show_to_new_players,
+        actor_id=admin.id,
+    )
+    audit_service.record(
+        session, actor_id=admin.id, action="create", entity_type="announcement",
+        entity_id=a.id, payload={"title": a.title}, ip=client_ip(request),
+    )
+    session.commit()
+    notify.announcements_changed(session)
+    return _announcement_by_id(session, a.id)  # type: ignore[arg-type]
+
+
+@router.put("/announcements/{announcement_id}", response_model=s.AdminAnnouncementRead)
+def update_announcement(
+    announcement_id: int,
+    body: s.AnnouncementUpdate,
+    request: Request,
+    session: Session = Depends(get_session),
+    admin: User = Depends(get_current_admin),
+) -> s.AdminAnnouncementRead:
+    a = announcement_service.update(
+        session,
+        announcement_id,
+        title=body.title,
+        body_html=body.body_html,
+        starts_at=body.starts_at,
+        ends_at=body.ends_at,
+        show_to_new_players=body.show_to_new_players,
+        reshow=body.reshow,
+    )
+    audit_service.record(
+        session, actor_id=admin.id, action="update", entity_type="announcement",
+        entity_id=announcement_id,
+        payload={"title": a.title, "reshow": body.reshow, "revision": a.revision},
+        ip=client_ip(request),
+    )
+    session.commit()
+    notify.announcements_changed(session)
+    return _announcement_by_id(session, announcement_id)
+
+
+@router.post("/announcements/{announcement_id}/stop", response_model=s.AdminAnnouncementRead)
+def stop_announcement(
+    announcement_id: int,
+    request: Request,
+    session: Session = Depends(get_session),
+    admin: User = Depends(get_current_admin),
+) -> s.AdminAnnouncementRead:
+    """«Снять с показа»: период идущего объявления заканчивается сейчас."""
+    announcement_service.stop(session, announcement_id)
+    audit_service.record(
+        session, actor_id=admin.id, action="update", entity_type="announcement",
+        entity_id=announcement_id, payload={"stopped": True}, ip=client_ip(request),
+    )
+    session.commit()
+    notify.announcements_changed(session)
+    return _announcement_by_id(session, announcement_id)
+
+
+@router.delete("/announcements/{announcement_id}", response_model=s.OkResponse)
+def delete_announcement(
+    announcement_id: int,
+    request: Request,
+    session: Session = Depends(get_session),
+    admin: User = Depends(get_current_admin),
+) -> s.OkResponse:
+    announcement_service.delete(session, announcement_id)
+    audit_service.record(
+        session, actor_id=admin.id, action="delete", entity_type="announcement",
+        entity_id=announcement_id, ip=client_ip(request),
+    )
+    session.commit()
+    notify.announcements_changed(session)
+    return s.OkResponse()
+
+
 # ─── Журнал аудита ───────────────────────────────────────────────────────────
 
 @router.get("/audit-logs", response_model=s.AuditLogList)

backend/app/routers/announcements.py

@@ -0,0 +1,46 @@
+"""Объявления администрации для игрока: что показать сейчас и «Понятно».
+
+Появление нового объявления у открытой вкладки обеспечивает SSE-сигнал
+`{type:"announcements"}`; объявление с отложенным началом клиент подхватывает
+периодическим перезапросом."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from sqlmodel import Session
+
+from app.auth.deps import get_current_user
+from app.db.session import get_session
+from app.models import User
+from app.schemas import api as s
+from app.services import announcement_service
+
+router = APIRouter(prefix="/announcements", tags=["announcements"])
+
+
+@router.get("/pending", response_model=list[s.AnnouncementRead])
+def pending(
+    session: Session = Depends(get_session),
+    user: User = Depends(get_current_user),
+) -> list[s.AnnouncementRead]:
+    return [
+        s.AnnouncementRead(
+            id=a.id,  # type: ignore[arg-type]
+            title=a.title,
+            body_html=a.body_html,
+            revision=a.revision,
+            updated=updated,
+        )
+        for a, updated in announcement_service.pending_for_user(session, user)
+    ]
+
+
+@router.post("/{announcement_id}/ack", response_model=s.OkResponse)
+def acknowledge(
+    announcement_id: int,
+    body: s.AnnouncementAck,
+    session: Session = Depends(get_session),
+    user: User = Depends(get_current_user),
+) -> s.OkResponse:
+    announcement_service.acknowledge(session, user.id, announcement_id, body.revision)  # type: ignore[arg-type]
+    session.commit()
+    return s.OkResponse()

backend/app/routers/dev_admin.py

@@ -1,9 +1,9 @@
 """DEV-ТОЛЬКО роутер: жёсткое удаление аккаунта игрока.
 
-Этот файл ФИЗИЧЕСКИ исключён из прод/тест-образа (.dockerignore), а роутер
+Этот файл ФИЗИЧЕСКИ исключён из прод-образа (.dockerignore), а роутер
 подключается лишь когда APP_ENV == development (см. app/main.py). На фронте кнопка
 удаления вырезается из прод-сборки тришейкингом (import.meta.env.DEV). Так
-возможность удаления не попадает ни в прод, ни в тест — там аккаунт можно только
+возможность удаления не попадает в прод — там аккаунт можно только
 отключить (PATCH is_active).
 
 Семантика («вычёркивание из партий»): аккаунт удаляется, а партии сохраняются —

backend/app/routers/groups.py

@@ -33,6 +33,7 @@ def _detail(session: Session, group_id: int, user_id: int) -> s.GroupDetail:
         owner_id=group.owner_id,
         my_role=member.role,
         expansion_ids=group_service.group_expansion_ids(session, group_id),
+        nine_rounds_rule=group.nine_rounds_rule,
     )
 
 
@@ -79,15 +80,19 @@ def get_group(
 
 
 @router.patch("/{group_id}", response_model=s.GroupDetail)
-def rename_group(
+def update_group(
     group_id: int,
-    body: s.GroupRename,
+    body: s.GroupUpdate,
     session: Session = Depends(get_session),
     user: User = Depends(get_current_user),
 ) -> s.GroupDetail:
+    """Название и домашние правила группы; меняются только переданные поля."""
     group_service.assert_member(session, group_id, user.id)  # type: ignore[arg-type]
     group = group_service.get_group(session, group_id)
-    group_service.rename_group(session, group, body.name)
+    if body.name is not None:
+        group_service.rename_group(session, group, body.name)
+    if body.nine_rounds_rule is not None:
+        group_service.set_nine_rounds_rule(session, group, body.nine_rounds_rule)
     return _detail(session, group_id, user.id)  # type: ignore[arg-type]
 
 

backend/app/routers/matches.py

@@ -22,10 +22,30 @@ from app.services import (
     user_service,
 )
 from app.services.match_service import FinishInput, ParticipantInput, RosterInput
+from app.services.scoring import max_rounds
 
 router = APIRouter(prefix="/matches", tags=["matches"])
 
 
+def participant_inputs(body: s.MatchUpdate) -> list[ParticipantInput] | None:
+    """Участники правки — общее для игроцкого и админского PATCH."""
+    if body.participants is None:
+        return None
+    return [
+        ParticipantInput(
+            user_id=p.user_id,
+            faction_id=p.faction_id,
+            place=p.place,
+            eliminated=p.eliminated,
+            was_random=p.was_random,
+            comment=p.comment,
+            objectives=p.objectives,
+            worlds=p.worlds,
+        )
+        for p in body.participants
+    ]
+
+
 
 def attachment_read(att: MatchAttachment, base: str) -> s.AttachmentRead:
     """AttachmentRead с URL под нужным префиксом (base = '/api/matches/{id}' или
@@ -56,6 +76,8 @@ def build_match_read(session: Session, match: Match, *, can_modify: bool = False
             eliminated=p.eliminated,
             was_random=p.was_random,
             comment=p.comment,
+            objectives=p.objectives,
+            worlds=p.worlds,
             avatar_url=user_service.avatar_url_for(u.id, u.avatar_path, u.updated_at),  # type: ignore[arg-type]
         )
         for p, u, f in match_service.participants_detail(session, match.id)  # type: ignore[arg-type]
@@ -79,6 +101,9 @@ def build_match_read(session: Session, match: Match, *, can_modify: bool = False
         finished_at=iso_utc(match.finished_at),
         duration_minutes=match.duration_minutes,
         win_reason=match.win_reason,  # type: ignore[arg-type]
+        end_round=match.end_round,
+        nine_rounds_rule=match.nine_rounds_rule,
+        max_rounds=max_rounds(match.player_count, match.nine_rounds_rule),
         player_count=match.player_count,
         overall_comment=match.overall_comment,
         created_by=match.created_by,
@@ -157,6 +182,8 @@ def finish_match(
             eliminated=p.eliminated,
             comment=p.comment,
             faction_id=p.faction_id,
+            objectives=p.objectives,
+            worlds=p.worlds,
         )
         for p in body.participants
     ]
@@ -165,6 +192,7 @@ def finish_match(
         match,
         finish=finish,
         win_reason=body.win_reason,
+        end_round=body.end_round,
         overall_comment=body.overall_comment,
         overall_comment_set=("overall_comment" in body.model_fields_set),
         expected_version=body.expected_version,
@@ -206,19 +234,6 @@ def update_match(
 ) -> s.MatchRead:
     match = match_service.get_match(session, match_id)
     match_service.assert_can_modify(session, match, user)
-    participants = None
-    if body.participants is not None:
-        participants = [
-            ParticipantInput(
-                user_id=p.user_id,
-                faction_id=p.faction_id,
-                place=p.place,
-                eliminated=p.eliminated,
-                was_random=p.was_random,
-                comment=p.comment,
-            )
-            for p in body.participants
-        ]
     match = match_service.update_match(
         session,
         match,
@@ -227,7 +242,9 @@ def update_match(
         overall_comment_set=("overall_comment" in body.model_fields_set),
         win_reason=body.win_reason,
         win_reason_set=("win_reason" in body.model_fields_set),
-        participants=participants,
+        end_round=body.end_round,
+        end_round_set=("end_round" in body.model_fields_set),
+        participants=participant_inputs(body),
         expected_version=body.expected_version,
     )
     audit_service.record(
@@ -335,9 +352,7 @@ def delete_match(
     match_service.assert_can_modify(session, match, user)
     match_id_val = match.id
     group_id_val = match.group_id
-    # Участников читаем до удаления: каскад унесёт их строки вместе с партией,
-    # а событию они нужны, чтобы клиент знал, чьи витрины протухли.
-    participant_ids = notify.match_participant_ids(session, match_id_val)  # type: ignore[arg-type]
+    finished = match.status == "finished"  # после удаления статус уже не прочитать
     match_service.delete_match(session, match, expected_version=expected_version)
     audit_service.record(
         session,
@@ -350,5 +365,5 @@ def delete_match(
         user_agent=request.headers.get("user-agent"),
     )
     session.commit()
-    notify.match_removed(session, match_id_val, group_id_val, participant_ids)  # type: ignore[arg-type]
+    notify.match_removed(session, match_id_val, group_id_val, finished=finished)  # type: ignore[arg-type]
     return s.OkResponse()

backend/app/schemas/api.py

@@ -1,12 +1,19 @@
 """Pydantic-схемы (граница HTTP). Из них генерируется OpenAPI → типы фронта."""
 from __future__ import annotations
 
-from datetime import date
-from typing import Literal
+from datetime import date, datetime
+from typing import Annotated, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
-WinReason = Literal["objectives", "worlds", "plastic", "resources"]
+# last_standing — все соперники выбыли. Вручную не выбирается: сервер требует её ровно
+# тогда, когда невыбывший участник один (match_service._check_last_standing).
+WinReason = Literal["objectives", "worlds", "plastic", "resources", "last_standing"]
+
+# Итоги партии для рейтинга. Верхние границы — только отсечка мусора: правила игры
+# ограничивают сильнее, но их проверка — дело предупреждений в форме, а не отказа.
+EndRound = Annotated[int, Field(ge=1, le=9)]
+Count = Annotated[int, Field(ge=0, le=99)]
 
 
 # ─── Auth ────────────────────────────────────────────────────────────────────
@@ -162,8 +169,10 @@ class GroupCreate(BaseModel):
     expansion_ids: list[int] = []
 
 
-class GroupRename(BaseModel):
-    name: str
+class GroupUpdate(BaseModel):
+    # Частичная правка: переданные поля меняются, остальные остаются как есть.
+    name: str | None = None
+    nine_rounds_rule: bool | None = None
 
 
 class GroupExpansionsUpdate(BaseModel):
@@ -176,6 +185,8 @@ class GroupDetail(BaseModel):
     owner_id: int
     my_role: str
     expansion_ids: list[int] = []
+    # Домашнее правило: 9 раундов при 5–6 игроках (снимается в партию при старте).
+    nine_rounds_rule: bool = False
 
 
 class MemberRead(BaseModel):
@@ -222,6 +233,23 @@ class NotificationMarkRead(BaseModel):
     ids: list[int] | None = None
 
 
+# ─── Объявления (игрок) ──────────────────────────────────────────────────────
+
+class AnnouncementRead(BaseModel):
+    id: int
+    title: str
+    # HTML, уже очищенный сервером по белому списку — фронт вставляет как есть.
+    body_html: str
+    revision: int
+    # Игрок закрывал прежнюю версию — окно показывает пометку «обновлено».
+    updated: bool = False
+
+
+class AnnouncementAck(BaseModel):
+    # Версия, которую игрок видел и закрыл (AnnouncementRead.revision).
+    revision: int = Field(ge=1)
+
+
 # ─── Партии ──────────────────────────────────────────────────────────────────
 
 class RandomizeRequest(BaseModel):
@@ -252,17 +280,20 @@ class MatchFinishParticipant(BaseModel):
     eliminated: bool = False  # выбыл из партии → авто-проставится последнее место
     comment: str | None = None
     faction_id: int | None = None  # опц. смена фракции при завершении
+    objectives: Count | None = None  # маркеры целей на конец партии (необязательно)
+    worlds: Count | None = None  # дружественные миры на конец партии; у выбывшего 0
 
 
 class MatchFinish(BaseModel):
     participants: list[MatchFinishParticipant]
     win_reason: WinReason
+    end_round: EndRound | None = None  # раунд, в котором партия закончилась
     overall_comment: str | None = None
     # Оптимистичная блокировка: версия партии, которую видел клиент (см. MatchRead.version).
     expected_version: str | None = None
 
 
-# Полный участник (правка завершённой партии админом).
+# Полный участник (правка результатов завершённой партии).
 class ParticipantInput(BaseModel):
     user_id: int
     faction_id: int
@@ -270,12 +301,15 @@ class ParticipantInput(BaseModel):
     eliminated: bool = False
     was_random: bool = False
     comment: str | None = None
+    objectives: Count | None = None
+    worlds: Count | None = None
 
 
 class MatchUpdate(BaseModel):
     played_at: date | None = None
     overall_comment: str | None = None
     win_reason: WinReason | None = None
+    end_round: EndRound | None = None
     participants: list[ParticipantInput] | None = None
     expected_version: str | None = None  # оптимистичная блокировка
 
@@ -289,6 +323,8 @@ class MatchParticipantRead(BaseModel):
     eliminated: bool = False
     was_random: bool
     comment: str | None = None
+    objectives: int | None = None
+    worlds: int | None = None
     avatar_url: str | None = None
 
 
@@ -311,6 +347,10 @@ class MatchFinishDraftData(BaseModel):
     comments: dict[str, str] = {}
     win_reason: WinReason | None = None
     overall_comment: str | None = None
+    end_round: EndRound | None = None
+    # Ключ — user_id строкой (как у comments); незаполненные поля в словарь не попадают.
+    objectives: dict[str, Count] = {}
+    worlds: dict[str, Count] = {}
 
 
 class MatchFinishDraftRead(BaseModel):
@@ -329,6 +369,11 @@ class MatchRead(BaseModel):
     finished_at: str | None = None
     duration_minutes: int | None = None
     win_reason: WinReason | None = None
+    end_round: int | None = None
+    # Снимок правила 9 раундов и вычисленный из него лимит раундов этой партии:
+    # фронт берёт лимит отсюда, а не повторяет правило у себя.
+    nine_rounds_rule: bool = False
+    max_rounds: int
     player_count: int
     overall_comment: str | None = None
     created_by: int
@@ -347,7 +392,8 @@ class OverallStats(BaseModel):
     wins: int
     win_rate: float
     avg_place: float | None = None
-    score: float | None = None
+    # Рейтинг (Elo, старт 1500) целым числом; None — игрок ещё не сыграл ни одной партии.
+    score: int | None = None
 
 
 class LeaderboardEntry(OverallStats):
@@ -355,6 +401,9 @@ class LeaderboardEntry(OverallStats):
     nickname: str
     rank: int | None = None
     avatar_url: str | None = None
+    # Рейтинг подтверждён: MIN_GAMES+ партий во всём приложении. На странице группы games —
+    # партии в группе, поэтому статус не выводится из них (и из блока, где стоит строка).
+    rating_confirmed: bool = False
 
 
 class MatchHistory(BaseModel):
@@ -388,6 +437,8 @@ class FactionStat(BaseModel):
     wins: int
     win_rate: float
     avg_place: float | None = None
+    # Средний результат относительно ожидания (S − E) × 100 — метрика лучшей/худшей
+    # фракции: выше нуля — игрок на ней выступает лучше своих рейтинговых шансов.
     score: float | None = None
 
 
@@ -451,6 +502,8 @@ class MatchListParticipant(BaseModel):
     eliminated: bool = False
     was_random: bool
     comment: str | None = None
+    objectives: int | None = None
+    worlds: int | None = None
 
 
 class MatchListItem(BaseModel):
@@ -465,6 +518,9 @@ class MatchListItem(BaseModel):
     overall_comment: str | None = None
     created_by: int
     participants: list[MatchListParticipant] = []
+    # Изменение общего рейтинга владельца истории за эту партию (один знак после запятой).
+    # Заполняется только в истории игрока (GET /users/{id}/matches); в списке группы — None.
+    rating_delta: float | None = None
 
 
 class MatchList(BaseModel):
@@ -588,3 +644,39 @@ class AuditLogList(BaseModel):
     items: list[AuditLogItem] = []
     limit: int
     offset: int
+
+
+# ─── Объявления (админ) ──────────────────────────────────────────────────────
+
+AnnouncementStatus = Literal["planned", "live", "finished"]
+
+
+class AnnouncementWrite(BaseModel):
+    # Точные правила (заголовок до 60 символов, текст до 600 видимых) — в
+    # announcement_service; здесь только отсечка мегабайтных тел.
+    title: str = Field(max_length=200)
+    body_html: str = Field(max_length=20_000)
+    starts_at: datetime
+    ends_at: datetime
+    show_to_new_players: bool = True
+
+
+class AnnouncementUpdate(AnnouncementWrite):
+    # Показать заново тем, кто уже закрыл (с пометкой «обновлено»).
+    reshow: bool = False
+
+
+class AdminAnnouncementRead(BaseModel):
+    id: int
+    title: str
+    body_html: str
+    starts_at: str
+    ends_at: str
+    show_to_new_players: bool
+    revision: int
+    status: AnnouncementStatus
+    # Закрыли текущую версию / сколько активных игроков в адресатах.
+    seen_count: int
+    audience_count: int
+    created_at: str
+    updated_at: str

backend/app/seed/reference_data.py

@@ -33,7 +33,13 @@ FACTIONS: list[tuple[str, str, str, int]] = [
 
 
 def seed_reference_data(session: Session) -> None:
-    """Создаёт/обновляет дополнения и фракции. Безопасно вызывать многократно."""
+    """Создаёт/обновляет дополнения и фракции. Безопасно вызывать многократно.
+
+    Идёт при каждом старте (entrypoint.sh, lifespan dev), поэтому не перетирает то, что
+    правят руками: имя существующей фракции меняет админка (admin_service.rename_faction),
+    и после создания записи источник правды для него — БД (#72). Имя из кода получает
+    только новая фракция; поправить имя существующей — админкой или миграцией.
+    Служебные поля (дополнение, порядок) и всё у дополнений синхронизируются с кодом."""
     code_to_expansion: dict[str, Expansion] = {}
 
     for code, name_ru, is_base, order in EXPANSIONS:
@@ -61,7 +67,6 @@ def seed_reference_data(session: Session) -> None:
             )
             session.add(fac)
         else:
-            fac.name_ru = name_ru
             fac.expansion_id = expansion.id  # type: ignore[assignment]
             fac.sort_order = order
 

backend/app/services/admin_service.py

@@ -63,8 +63,9 @@ def update_user(session: Session, user_id: int, *, nickname: str | None = None,
 
 
 def set_player_password(session: Session, user_id: int, new_password: str) -> User:
-    """Новый пароль игроку (восстановление забытого). Пароль админа так не меняется —
-    он задаётся ADMIN_PASSWORD в .env."""
+    """Новый пароль игроку (восстановление забытого). Пароль админа через панель не
+    меняется: он задаётся ADMIN_PASSWORD в .env и применяется к существующему админу
+    командой `python -m app.bootstrap --reset-admin-password` (#73)."""
     user = session.get(User, user_id)
     if user is None:
         raise NotFoundError("Пользователь не найден.")
@@ -74,7 +75,7 @@ def set_player_password(session: Session, user_id: int, new_password: str) -> Us
 
 
 # Жёсткое удаление пользователя — dev-only, в services/admin_service нет намеренно:
-# логика вынесена в routers/dev_admin.py (файл исключён из прод/тест-образа).
+# логика вынесена в routers/dev_admin.py (файл исключён из прод-образа).
 
 
 # ─── Группы ──────────────────────────────────────────────────────────────────

backend/app/services/announcement_service.py

@@ -0,0 +1,336 @@
+"""Объявления администрации (#84): очистка текста, период показа, кому и что показать.
+
+Объявление видно игроку, пока идёт его период и игрок не закрыл текущую версию. Закрытие
+(«Понятно») пишет отметку с номером версии; правка с «показать заново» поднимает версию —
+и закрывшие прежнюю увидят объявление снова, с пометкой «обновлено».
+
+Текст хранится HTML-ом из редактора админки, но только после очистки по белому списку
+(sanitize_body): фронт вставляет его без экранирования, так что это единственный барьер
+между полем редактора и страницей игрока.
+"""
+from __future__ import annotations
+
+import html
+from datetime import datetime, timezone
+from html.parser import HTMLParser
+
+from sqlalchemy import func
+from sqlmodel import Session, select
+
+from app.core.errors import NotFoundError, ValidationError
+from app.core.timeutil import utcnow
+from app.models import Announcement, AnnouncementView, User
+
+TITLE_MAX = 60
+TEXT_MAX = 600  # видимых символов, без разметки
+
+# ─── Очистка HTML ────────────────────────────────────────────────────────────
+
+# Что оставляем и во что превращаем. Редактор (contenteditable + execCommand) в разных
+# браузерах пишет то <b>, то <strong>, абзацы — <div> или <p>; приводим к одному виду.
+_TAGS = {
+    "b": "b",
+    "strong": "b",
+    "i": "em",
+    "em": "em",
+    "mark": "mark",
+    "p": "p",
+    "div": "p",
+    "br": "br",
+}
+# Теги, которые выбрасываются вместе с содержимым: их текст не предназначен для показа.
+_DROP_WITH_CONTENT = {
+    "script", "style", "template", "noscript", "iframe", "object", "embed",
+    "svg", "math", "head", "title", "textarea", "select",
+}
+_VOID = {"br"}
+
+
+class _Sanitizer(HTMLParser):
+    """Пересобирает HTML из разобранных токенов: теги — только из белого списка и без
+    атрибутов (кроме class="red" у <mark>), весь текст экранируется заново. Всё, что
+    парсер не распознал как тег из списка, становится текстом или пропадает."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.out: list[str] = []
+        self.text: list[str] = []
+        self.stack: list[str] = []
+        self.drop_depth = 0
+
+    def _pop(self) -> str:
+        top = self.stack.pop()
+        last = self.out[-1] if self.out else ""
+        # Точное сравнение: startswith("<b") поймал бы и <br>.
+        if last == f"<{top}>" or last.startswith(f"<{top} "):
+            self.out.pop()  # пустая пара (<p></p> от вложенных <div>) — выбрасываем
+        else:
+            self.out.append(f"</{top}>")
+        return top
+
+    def _close_to(self, tag: str) -> None:
+        while self.stack:
+            if self._pop() == tag:
+                return
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag in _DROP_WITH_CONTENT:
+            self.drop_depth += 1
+            return
+        if self.drop_depth or tag not in _TAGS:
+            return
+        name = _TAGS[tag]
+        if name in _VOID:
+            self.out.append(f"<{name}>")
+            return
+        if name == "p" and "p" in self.stack:
+            # Абзац внутри абзаца (вложенные <div> из contenteditable) — закрываем прежний.
+            self._close_to("p")
+        opening = f"<{name}>"
+        if name == "mark":
+            classes = next((v or "" for k, v in attrs if k == "class"), "").split()
+            if "red" in classes:
+                opening = '<mark class="red">'
+        self.stack.append(name)
+        self.out.append(opening)
+
+    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        # <br/> и прочие самозакрытые: содержимого нет, так что drop-теги тут ни при чём.
+        if not self.drop_depth and _TAGS.get(tag) in _VOID:
+            self.out.append(f"<{_TAGS[tag]}>")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in _DROP_WITH_CONTENT:
+            self.drop_depth = max(0, self.drop_depth - 1)
+            return
+        if self.drop_depth:
+            return
+        name = _TAGS.get(tag)
+        if name and name not in _VOID and name in self.stack:
+            self._close_to(name)
+
+    def handle_data(self, data: str) -> None:
+        if self.drop_depth:
+            return
+        self.text.append(data)
+        self.out.append(html.escape(data, quote=False))
+
+    def result(self) -> tuple[str, str]:
+        self.close()
+        while self.stack:
+            self._pop()
+        return "".join(self.out), "".join(self.text)
+
+
+def sanitize_body(raw: str) -> tuple[str, str]:
+    """(очищенный HTML, видимый текст). Видимый текст нужен для проверки длины."""
+    parser = _Sanitizer()
+    parser.feed(raw)
+    return parser.result()
+
+
+# ─── Проверки и время ─────────────────────────────────────────────────────────
+
+def _now() -> datetime:
+    # В SQLite моменты лежат наивными (UTC) — сравниваем с наивным же «сейчас».
+    return utcnow().replace(tzinfo=None)
+
+
+def _naive_utc(dt: datetime) -> datetime:
+    """Момент из запроса → наивный UTC. Время без смещения считаем UTC."""
+    if dt.tzinfo is not None:
+        dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
+    return dt.replace(second=0, microsecond=0)
+
+
+def _clean_fields(
+    title: str, body_html: str, starts_at: datetime, ends_at: datetime
+) -> tuple[str, str, datetime, datetime]:
+    title = title.strip()
+    if not title:
+        raise ValidationError("Заголовок не может быть пустым.")
+    if len(title) > TITLE_MAX:
+        raise ValidationError(f"Заголовок длиннее {TITLE_MAX} символов.")
+    clean_html, text = sanitize_body(body_html)
+    text = text.strip()
+    if not text:
+        raise ValidationError("Текст объявления не может быть пустым.")
+    if len(text) > TEXT_MAX:
+        raise ValidationError(f"Текст длиннее {TEXT_MAX} символов ({len(text)}).")
+    start, end = _naive_utc(starts_at), _naive_utc(ends_at)
+    if end <= start:
+        raise ValidationError("Конец показа должен быть позже начала.")
+    return title, clean_html, start, end
+
+
+def status_of(a: Announcement, now: datetime | None = None) -> str:
+    now = now or _now()
+    if now < a.starts_at:
+        return "planned"
+    if now >= a.ends_at:
+        return "finished"
+    return "live"
+
+
+def get(session: Session, announcement_id: int) -> Announcement:
+    a = session.get(Announcement, announcement_id)
+    if a is None:
+        raise NotFoundError("Объявление не найдено.")
+    return a
+
+
+# ─── Админка ─────────────────────────────────────────────────────────────────
+
+def create(
+    session: Session,
+    *,
+    title: str,
+    body_html: str,
+    starts_at: datetime,
+    ends_at: datetime,
+    show_to_new_players: bool,
+    actor_id: int | None,
+) -> Announcement:
+    title, body_html, start, end = _clean_fields(title, body_html, starts_at, ends_at)
+    if end <= _now():
+        raise ValidationError("Период показа уже закончился.")
+    a = Announcement(
+        title=title,
+        body_html=body_html,
+        starts_at=start,
+        ends_at=end,
+        show_to_new_players=show_to_new_players,
+        created_by=actor_id,
+    )
+    session.add(a)
+    session.flush()
+    return a
+
+
+def update(
+    session: Session,
+    announcement_id: int,
+    *,
+    title: str,
+    body_html: str,
+    starts_at: datetime,
+    ends_at: datetime,
+    show_to_new_players: bool,
+    reshow: bool,
+) -> Announcement:
+    a = get(session, announcement_id)
+    a.title, a.body_html, a.starts_at, a.ends_at = _clean_fields(
+        title, body_html, starts_at, ends_at
+    )
+    a.show_to_new_players = show_to_new_players
+    if reshow:
+        # Новая версия: отметки о закрытии прежней больше не прячут объявление.
+        a.revision += 1
+    a.updated_at = utcnow()
+    session.add(a)
+    session.flush()
+    return a
+
+
+def stop(session: Session, announcement_id: int) -> Announcement:
+    """«Снять с показа»: период заканчивается сейчас. Только у идущего объявления —
+    у запланированного конец раньше начала нарушил бы период; его просто удаляют."""
+    a = get(session, announcement_id)
+    now = _now()
+    if status_of(a, now) != "live" or now <= a.starts_at:
+        raise ValidationError("Снять с показа можно только идущее объявление.")
+    a.ends_at = now
+    a.updated_at = utcnow()
+    session.add(a)
+    session.flush()
+    return a
+
+
+def delete(session: Session, announcement_id: int) -> None:
+    session.delete(get(session, announcement_id))
+    session.flush()
+
+
+def _audience_filter(a: Announcement):
+    """Условия «игрок — адресат объявления» (для счётчиков и для показа)."""
+    conds = [User.role == "player", User.is_active.is_(True)]  # type: ignore[union-attr]
+    if not a.show_to_new_players:
+        conds.append(User.created_at <= a.starts_at)
+    return conds
+
+
+def _admin_item(session: Session, a: Announcement, now: datetime) -> dict:
+    """Объявление со статусом и счётчиком «закрыли N из M»: N — закрывшие текущую
+    версию, M — сколько активных игроков сейчас в адресатах."""
+    audience = _audience_filter(a)
+    audience_count = session.exec(select(func.count()).select_from(User).where(*audience)).one()
+    seen_count = session.exec(
+        select(func.count())
+        .select_from(AnnouncementView)
+        .join(User, User.id == AnnouncementView.user_id)
+        .where(
+            AnnouncementView.announcement_id == a.id,
+            AnnouncementView.revision >= a.revision,
+            *audience,
+        )
+    ).one()
+    return {"a": a, "status": status_of(a, now), "seen": seen_count, "audience": audience_count}
+
+
+def admin_item(session: Session, announcement_id: int) -> dict:
+    return _admin_item(session, get(session, announcement_id), _now())
+
+
+def list_admin(session: Session) -> list[dict]:
+    """Все объявления, новые сверху. Объявлений единицы, поэтому счётчики — по паре
+    запросов на объявление."""
+    now = _now()
+    rows = session.exec(
+        select(Announcement).order_by(Announcement.starts_at.desc(), Announcement.id.desc())  # type: ignore[union-attr]
+    ).all()
+    return [_admin_item(session, a, now) for a in rows]
+
+
+# ─── Игрок ───────────────────────────────────────────────────────────────────
+
+def pending_for_user(session: Session, user: User) -> list[tuple[Announcement, bool]]:
+    """Что показать игроку сейчас — от старого к новому. Второй элемент — «обновлено»:
+    игрок закрывал прежнюю версию этого объявления."""
+    now = _now()
+    registered = user.created_at.replace(tzinfo=None)  # только что созданный — aware UTC
+    rows = session.exec(
+        select(Announcement, AnnouncementView.revision)
+        .join(
+            AnnouncementView,
+            (AnnouncementView.announcement_id == Announcement.id)
+            & (AnnouncementView.user_id == user.id),
+            isouter=True,
+        )
+        .where(Announcement.starts_at <= now, Announcement.ends_at > now)
+        .order_by(Announcement.starts_at, Announcement.id)
+    ).all()
+    result = []
+    for a, seen_revision in rows:
+        if seen_revision is not None and seen_revision >= a.revision:
+            continue
+        if not a.show_to_new_players and registered > a.starts_at:
+            continue
+        result.append((a, seen_revision is not None))
+    return result
+
+
+def acknowledge(session: Session, user_id: int, announcement_id: int, revision: int) -> None:
+    """Игрок закрыл объявление в версии revision. Версию берём с клиента: если админ
+    выпустил новую, пока окно было открыто, игрок закрыл старую и новую ещё увидит."""
+    a = get(session, announcement_id)
+    revision = min(revision, a.revision)
+    view = session.get(AnnouncementView, (announcement_id, user_id))
+    if view is None:
+        session.add(
+            AnnouncementView(announcement_id=announcement_id, user_id=user_id, revision=revision)
+        )
+    elif revision > view.revision:
+        view.revision = revision
+        view.closed_at = utcnow()
+        session.add(view)
+    session.flush()

backend/app/services/group_service.py

@@ -97,6 +97,16 @@ def rename_group(session: Session, group: Group, name: str) -> Group:
     return group
 
 
+def set_nine_rounds_rule(session: Session, group: Group, enabled: bool) -> Group:
+    """Хоумрул «9 раундов при 5–6 игроках». Действует на партии, начатые после смены:
+    уже начатые хранят свой снимок (Match.nine_rounds_rule)."""
+    group.nine_rounds_rule = enabled
+    session.add(group)
+    session.commit()
+    session.refresh(group)
+    return group
+
+
 def set_expansions(session: Session, group: Group, expansion_ids: list[int]) -> Group:
     valid = set(_valid_non_base_expansion_ids(session, expansion_ids))
     current = session.exec(

backend/app/services/match_service.py

@@ -19,9 +19,12 @@ from app.core.errors import (
 from app.core.timeutil import app_today, iso_utc, utcnow
 from app.models import Faction, GroupMember, Match, MatchFinishDraft, MatchParticipant, User
 from app.services import group_service
+from app.services.scoring import EXTENDED_ROUNDS, max_rounds
 
 MAX_MATCH_PLAYERS = 6
-WIN_REASONS = ("objectives", "worlds", "plastic", "resources")
+LAST_STANDING = "last_standing"
+WIN_REASONS = ("objectives", "worlds", "plastic", "resources", LAST_STANDING)
+MAX_COUNT = 99  # отсечка мусора в целях/мирах (та же, что в схеме API)
 
 
 @dataclass
@@ -42,11 +45,13 @@ class FinishInput:
     eliminated: bool = False
     comment: str | None = None
     faction_id: int | None = None  # опц. смена фракции при завершении
+    objectives: int | None = None
+    worlds: int | None = None
 
 
 @dataclass
 class ParticipantInput:
-    """Полный участник (для правки завершённой партии админом)."""
+    """Полный участник (для правки результатов завершённой партии)."""
 
     user_id: int
     faction_id: int
@@ -54,6 +59,8 @@ class ParticipantInput:
     eliminated: bool = False
     was_random: bool = False
     comment: str | None = None
+    objectives: int | None = None
+    worlds: int | None = None
 
 
 def round_to_30(minutes: float) -> int:
@@ -154,6 +161,43 @@ def _resolve_finish_places(rows: list[tuple[int, int | None, bool]]) -> dict[int
     return {uid: (elim_place if elim else place) for uid, place, elim in rows}  # type: ignore[misc]
 
 
+# ─── Итоги партии для рейтинга ────────────────────────────────────────────────
+# Сервер проверяет только диапазоны и явные противоречия. Согласованность итогов между
+# собой (тип победы и цели лидеров и т.п.) — предупреждения формы, а не отказ.
+
+def _check_end_round(end_round: int | None, player_count: int, nine_rounds_rule: bool) -> None:
+    if end_round is None:
+        return
+    rmax = max_rounds(player_count, nine_rounds_rule)
+    if not 1 <= end_round <= rmax:
+        raise ValidationError(f"Раунд окончания — от 1 до {rmax}.")
+
+
+def _worlds_of(eliminated: bool, worlds: int | None) -> int | None:
+    """У выбывшего миров нет: пустое поле записывается нулём, иное число — противоречие."""
+    if not eliminated:
+        return worlds
+    if worlds:
+        raise ValidationError("У выбывшего игрока не может быть миров.")
+    return 0
+
+
+def _check_last_standing(win_reason: str | None, eliminated: list[bool]) -> None:
+    """Причина «последний выживший» ⇔ невыбывший участник ровно один (решение по #22).
+
+    Выбрать её вручную нельзя, и забыть поставить тоже: форма проставляет её сама,
+    сервер лишь не пропускает расхождение."""
+    alone = sum(1 for e in eliminated if not e) == 1
+    if alone and win_reason != LAST_STANDING:
+        raise ValidationError(
+            "Остался один невыбывший игрок — причина победы «последний выживший»."
+        )
+    if not alone and win_reason == LAST_STANDING:
+        raise ValidationError(
+            "«Последний выживший» возможен, только когда все, кроме победителя, выбыли."
+        )
+
+
 def _group_member_ids(session: Session, group_id: int) -> set[int]:
     return {
         m.user_id
@@ -208,12 +252,15 @@ def create_match(
     )
 
     now = utcnow()
+    group = group_service.get_group(session, group_id)
     match = Match(
         group_id=group_id,
         status="in_progress",
         played_at=app_today(),  # дата игры — в поясе приложения (+3)
         started_at=now,
         player_count=len(roster),
+        # Снимок: смена настройки группы потом не переписывает лимит раундов этой партии.
+        nine_rounds_rule=group.nine_rounds_rule,
         created_by=creator.id,  # type: ignore[arg-type]
     )
     session.add(match)
@@ -242,6 +289,7 @@ def finish_match(
     *,
     finish: list[FinishInput],
     win_reason: str,
+    end_round: int | None = None,
     overall_comment: str | None = None,
     overall_comment_set: bool = False,
     expected_version: str | None = None,
@@ -251,6 +299,7 @@ def finish_match(
         raise ConflictError("Партия уже завершена.")
     if win_reason not in WIN_REASONS:
         raise ValidationError("Укажите корректную причину победы.")
+    _check_end_round(end_round, match.player_count, match.nine_rounds_rule)
 
     existing = {
         p.user_id: p
@@ -273,12 +322,16 @@ def finish_match(
         raise FactionNotAvailableError()
 
     places = _resolve_finish_places([(f.user_id, f.place, f.eliminated) for f in finish])
+    _check_last_standing(win_reason, [f.eliminated for f in finish])
+    worlds = {f.user_id: _worlds_of(f.eliminated, f.worlds) for f in finish}
 
     for f in finish:
         p = existing[f.user_id]
         p.place = places[f.user_id]
         p.eliminated = f.eliminated
         p.comment = f.comment or None
+        p.objectives = f.objectives
+        p.worlds = worlds[f.user_id]
         if f.faction_id is not None:
             p.faction_id = f.faction_id
         session.add(p)
@@ -294,6 +347,7 @@ def finish_match(
         match.duration_minutes = round_to_30(elapsed_min)
     match.status = "finished"
     match.win_reason = win_reason
+    match.end_round = end_round
     if overall_comment_set:
         match.overall_comment = overall_comment or None
 
@@ -312,22 +366,44 @@ def get_finish_draft(session: Session, match_id: int) -> MatchFinishDraft | None
     return session.get(MatchFinishDraft, match_id)
 
 
+def _draft_counts(value: object) -> dict[str, int]:
+    """Цели/миры черновика: {user_id строкой: число}. Пустые поля в словарь не попадают."""
+    if not isinstance(value, dict):
+        raise ValidationError("Некорректный черновик.")
+    out: dict[str, int] = {}
+    for k, v in value.items():
+        if isinstance(v, bool) or not isinstance(v, int) or not 0 <= v <= MAX_COUNT:
+            raise ValidationError("Некорректный черновик.")
+        out[str(k)] = v
+    return out
+
+
 def _validate_draft(session: Session, match: Match, data: dict) -> dict:
     """Черновик — свободная форма, но не мусор: состав обязан совпадать с участниками
     партии, а причина победы быть из известных. Места здесь НЕ валидируются: человек
-    раскладывает их постепенно, и промежуточное состояние может быть любым."""
+    раскладывает их постепенно, и промежуточное состояние может быть любым. По той же
+    причине не проверяется и правило «последнего выжившего»."""
     if not isinstance(data, dict):
         raise ValidationError("Некорректный черновик.")
     blocks = data.get("blocks") or []
     eliminated = data.get("eliminated") or []
     comments = data.get("comments") or {}
     win_reason = data.get("win_reason")
+    end_round = data.get("end_round")
     if not isinstance(blocks, list) or not isinstance(eliminated, list):
         raise ValidationError("Некорректный черновик.")
     if not isinstance(comments, dict):
         raise ValidationError("Некорректный черновик.")
     if win_reason is not None and win_reason not in WIN_REASONS:
         raise ValidationError("Некорректная причина победы.")
+    if end_round is not None and (
+        isinstance(end_round, bool)
+        or not isinstance(end_round, int)
+        or not 1 <= end_round <= EXTENDED_ROUNDS
+    ):
+        raise ValidationError("Некорректный черновик.")
+    objectives = _draft_counts(data.get("objectives") or {})
+    worlds = _draft_counts(data.get("worlds") or {})
 
     participant_ids = {
         p.user_id
@@ -354,6 +430,9 @@ def _validate_draft(session: Session, match: Match, data: dict) -> dict:
         "comments": {str(k): str(v) for k, v in comments.items()},
         "win_reason": win_reason,
         "overall_comment": overall,
+        "end_round": end_round,
+        "objectives": objectives,
+        "worlds": worlds,
     }
 
 
@@ -409,35 +488,41 @@ def update_match(
     overall_comment_set: bool = False,
     win_reason: str | None = None,
     win_reason_set: bool = False,
+    end_round: int | None = None,
+    end_round_set: bool = False,
     participants: list[ParticipantInput] | None = None,
     expected_version: str | None = None,
 ) -> Match:
-    """Правка партии: состав с местами, дата, комментарий, причина победы.
+    """Правка партии: состав с местами и итогами, дата, комментарий, причина победы, раунд.
 
-    Результаты (места и причина победы) пишутся только в завершённую партию: иначе они
-    оседали бы в партии со статусом in_progress, которая остаётся в «Незавершённых» и не
-    попадает ни в одну витрину статистики (SCORED_CTE считает только status='finished').
-    Дату и общий комментарий править можно и по ходу партии — двойственного состояния
-    они не создают."""
-    results_touched = participants is not None or win_reason_set
+    Результаты (места, итоги, причина победы, раунд) пишутся только в завершённую партию:
+    иначе они оседали бы в партии со статусом in_progress, которая остаётся
+    в «Незавершённых» и не попадает ни в одну витрину статистики (рейтинг проигрывает
+    только status='finished'). Дату и общий комментарий править можно и по ходу
+    партии — двойственного состояния они не создают."""
+    results_touched = participants is not None or win_reason_set or end_round_set
     if results_touched and match.status != "finished":
         raise ConflictError(
             "Результаты незавершённой партии нельзя править — сначала завершите её."
         )
     assert_version(match, expected_version)
-    if played_at is not None:
-        match.played_at = played_at
-    if overall_comment_set:
-        match.overall_comment = overall_comment or None
-    if win_reason_set:
-        if win_reason is not None and win_reason not in WIN_REASONS:
-            raise ValidationError("Некорректная причина победы.")
-        match.win_reason = win_reason
+    if win_reason_set and win_reason is not None and win_reason not in WIN_REASONS:
+        raise ValidationError("Некорректная причина победы.")
 
+    saved = session.exec(
+        select(MatchParticipant).where(MatchParticipant.match_id == match.id)
+    ).all()
+    # Проверки — по состоянию партии ПОСЛЕ правки: частичный запрос сверяется
+    # с тем, что уже записано.
+    new_reason = win_reason if win_reason_set else match.win_reason
+    new_end_round = end_round if end_round_set else match.end_round
+    new_count = len(participants) if participants is not None else match.player_count
+    if end_round_set or participants is not None:
+        _check_end_round(new_end_round, new_count, match.nine_rounds_rule)
+
+    places: dict[int, int] = {}
+    worlds: dict[int, int | None] = {}
     if participants is not None:
-        saved = session.exec(
-            select(MatchParticipant).where(MatchParticipant.match_id == match.id)
-        ).all()
         # Что уже записано в партии, остаётся допустимым: состав группы и набор
         # дополнений с тех пор могли поменяться, но историю это чинить не мешает.
         _validate_roster_basics(
@@ -451,6 +536,25 @@ def update_match(
         places = _resolve_finish_places(
             [(p.user_id, p.place, p.eliminated) for p in participants]
         )
+        worlds = {p.user_id: _worlds_of(p.eliminated, p.worlds) for p in participants}
+    if participants is not None or win_reason_set:
+        flags = (
+            [p.eliminated for p in participants]
+            if participants is not None
+            else [p.eliminated for p in saved]
+        )
+        _check_last_standing(new_reason, flags)
+
+    if played_at is not None:
+        match.played_at = played_at
+    if overall_comment_set:
+        match.overall_comment = overall_comment or None
+    if win_reason_set:
+        match.win_reason = win_reason
+    if end_round_set:
+        match.end_round = end_round
+
+    if participants is not None:
         for old in saved:
             session.delete(old)
         session.flush()
@@ -464,6 +568,8 @@ def update_match(
                     eliminated=p.eliminated,
                     was_random=p.was_random,
                     comment=p.comment or None,
+                    objectives=p.objectives,
+                    worlds=worlds[p.user_id],
                 )
             )
         match.player_count = len(participants)

backend/app/services/notify.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 from sqlmodel import Session, select
 
 from app.core.events import hub
-from app.models import GroupMember, Match, MatchParticipant
+from app.models import GroupMember, Match, User
 
 
 def _group_member_ids(session: Session, group_id: int) -> list[int]:
@@ -17,30 +17,28 @@ def _group_member_ids(session: Session, group_id: int) -> list[int]:
     )
 
 
-def match_participant_ids(session: Session, match_id: int) -> list[int]:
-    """Кто играл в партии. Нужен в событии, чтобы клиент понимал, чьи витрины
-    (история игр, публичный профиль, личная статистика) реально протухли."""
-    return list(
-        session.exec(
-            select(MatchParticipant.user_id).where(MatchParticipant.match_id == match_id)
+def _ratings_changed(session: Session, notified: list[int]) -> None:
+    """Рейтинг общий и считается по всей истории (#80): завершённая партия двигает топ,
+    главную, историю и профили всех, кто играл после неё, и страницы других групп.
+    Игрокам вне группы (notified уже знают) — событие без подробностей о партии."""
+    skip = set(notified)
+    ids = [
+        uid
+        for uid in session.exec(
+            select(User.id).where(User.role == "player", User.is_active.is_(True))  # type: ignore[union-attr]
         ).all()
-    )
+        if uid not in skip
+    ]
+    hub.publish(ids, {"type": "ratings"})
 
 
 def match_changed(session: Session, match: Match) -> None:
-    """Партия изменилась — уведомить всех участников её группы.
-
-    Адресат — вся группа: списки партий и статистика группы меняются у всех. А вот
-    история и профили протухают только у игравших, поэтому их id едут в событии."""
-    hub.publish(
-        _group_member_ids(session, match.group_id),
-        {
-            "type": "match",
-            "match_id": match.id,
-            "group_id": match.group_id,
-            "participant_ids": match_participant_ids(session, match.id),  # type: ignore[arg-type]
-        },
-    )
+    """Партия изменилась — уведомить всех участников её группы, а если она завершена —
+    и остальных игроков (_ratings_changed)."""
+    members = _group_member_ids(session, match.group_id)
+    hub.publish(members, {"type": "match", "match_id": match.id, "group_id": match.group_id})
+    if match.status == "finished":
+        _ratings_changed(session, members)
 
 
 def match_draft_changed(session: Session, match: Match, actor_id: int) -> None:
@@ -53,22 +51,13 @@ def match_draft_changed(session: Session, match: Match, actor_id: int) -> None:
     hub.publish(ids, {"type": "match_draft", "match_id": match.id, "group_id": match.group_id})
 
 
-def match_removed(
-    session: Session, match_id: int, group_id: int, participant_ids: list[int] | None = None
-) -> None:
-    """Партия удалена — уведомить участников группы (обновить списки).
-
-    participant_ids передаются снаружи: к этому моменту партии уже нет, а её участники
-    ушли каскадом, и собрать их из базы невозможно."""
-    hub.publish(
-        _group_member_ids(session, group_id),
-        {
-            "type": "match",
-            "match_id": match_id,
-            "group_id": group_id,
-            "participant_ids": participant_ids or [],
-        },
-    )
+def match_removed(session: Session, match_id: int, group_id: int, *, finished: bool) -> None:
+    """Партия удалена — уведомить участников группы (обновить списки), а если она была
+    завершена — и остальных игроков. Статус передаётся снаружи: партии уже нет."""
+    members = _group_member_ids(session, group_id)
+    hub.publish(members, {"type": "match", "match_id": match_id, "group_id": group_id})
+    if finished:
+        _ratings_changed(session, members)
 
 
 def group_changed(session: Session, group_id: int, extra_user_ids: list[int] | None = None) -> None:
@@ -87,3 +76,13 @@ def invitations_changed(user_id: int) -> None:
 def notifications_changed(user_id: int) -> None:
     """У пользователя появилось/изменилось уведомление — пусть подтянет список."""
     hub.publish([user_id], {"type": "notifications"})
+
+
+def announcements_changed(session: Session) -> None:
+    """Админ создал, поправил, снял или удалил объявление — всем активным игрокам:
+    открытые вкладки перезапросят, что показать. Объявление, чей период начнётся
+    позже, клиент подхватит сам — периодическим перезапросом."""
+    ids = session.exec(
+        select(User.id).where(User.role == "player", User.is_active.is_(True))  # type: ignore[union-attr]
+    ).all()
+    hub.publish(ids, {"type": "announcements"})

backend/app/services/scoring.py

@@ -1,58 +1,220 @@
-"""Метрика рейтинга. Вынесена отдельно — легко заменить.
+"""Метрика рейтинга: многопользовательский Elo с множителем отрыва (#22, #23).
 
-По умолчанию: League Points — нормированные очки за место с учётом размера стола
-и ничьих (competition ranking). За партию из N игроков:
-    points = (N - place - (tie_size - 1)/2) / (N - 1)
-1-е место = 1.0, последнее = 0.0; равные места делят сумму очков поровну.
+Полное описание, обоснование коэффициентов и примеры — docs/rating/rating-system.md;
+эталонная реализация тех же формул — docs/rating/simulate.py (тесты сверяют с ней).
 
-Рейтинговый счёт игрока — сглаженное среднее (байесовское, формула IMDB):
-    score = (PRIOR_GAMES * PRIOR_MEAN + SUM(points)) / (PRIOR_GAMES + games) * 100
-К реальным партиям «дописываются» PRIOR_GAMES виртуальных со средним PRIOR_MEAN:
-на малой выборке рейтинг держится около 50 и лишь с опытом сходится к чистому
-среднему — короткая удачная серия новичка не обгоняет стабильного ветерана.
+Партия раскладывается на пары игроков. Для пары a (выше или наравне) и b:
+    E_ab = 1 / (1 + 10^((R_b − R_a) / D))          ожидание по рейтингам ДО партии
+    S_ab = 1 / 0.5 / 0                               выше / поровну / ниже
+    ΔR_i = K_i · G(N) / (N − 1) · Σ_j M_ij · (S_ij − E_ij)
+Пары двух выбывших в сумму не входят (#91), остальные — все. K_i спускается от K_MAX
+у новичка до K_MIN за K_GAMES партий, G(N) — вес размера стола, M — множитель отрыва
+(темп, цели, миры; близость по типу победы — только у пар с победителем). Недостающий
+признак партии подставляется типичным и не влияет на M.
+
+Модуль — только константы и чистые функции без БД: калибровка на реальных данных —
+правка констант, пересчёт выполняется сам (рейтинг — функция упорядоченной истории).
 """
 from __future__ import annotations
 
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from itertools import combinations
+
 # Порог числа игр для попадания в ранжированный топ (ниже — «Новички»/provisional).
 MIN_GAMES = 10
 # Порог числа игр на фракцию для расчёта лучшей/худшей фракции.
 FACTION_MIN_GAMES = 2
 
-# Сглаживание рейтинга: сколько «виртуальных» партий и с каким средним добавляем.
-PRIOR_GAMES = 10
-PRIOR_MEAN = 0.5
+# ─── Правила игры ────────────────────────────────────────────────────────────
 
-# SQL-выражение сглаженного рейтинга поверх агрегата по строкам scored (s.points).
-# При 0 партий SUM = NULL → score = NULL (рейтинга без игр нет).
-SMOOTHED_SCORE_SQL = (
-    f"({PRIOR_GAMES} * {PRIOR_MEAN} + SUM(s.points)) / ({PRIOR_GAMES} + COUNT(*)) * 100"
-)
+# Размер поля в тайлах по числу игроков (дуэль — 2×3, шестеро — 4×5).
+BOARD_TILES = {2: 6, 3: 9, 4: 12, 5: 16, 6: 20}
+WORLDS_PER_TILE = 2.2
+BASE_ROUNDS = 8
+# Домашнее правило группы: при 5–6 игроках играется 9 раундов.
+EXTENDED_ROUNDS = 9
+EXTENDED_MIN_PLAYERS = 5
 
-# SQL-выражение очков за участие (tie-aware). Использует поля m.player_count,
-# mp.place и t.tie_size (размер группы игроков с тем же местом в партии).
-MATCH_POINTS_SQL = (
-    "CASE WHEN m.player_count > 1 "
-    "THEN (m.player_count - mp.place - (t.tie_size - 1) / 2.0) "
-    "/ (m.player_count - 1) "
-    "ELSE 1.0 END"
-)
+# ─── Коэффициенты (документ, 4.10) ───────────────────────────────────────────
+
+R0 = 1500.0  # стартовый рейтинг
+D = 400.0  # масштаб: разница 400 пунктов — шансы 10:1
+K_MAX = 64.0  # K новичка (0 партий)
+K_MIN = 16.0  # K опытного игрока
+K_GAMES = 20  # за сколько партий K линейно спускается от K_MAX к K_MIN
+W_TABLE = 0.5  # вес размера стола
+W_TEMPO = 1.0  # вес темпа победы
+W_OBJ = 0.5  # вес отрыва по целям
+W_WORLDS = 0.5  # вес отрыва по мирам
+MU_OBJ = 0.5  # типичный отрыв по целям
+MU_WORLDS = 0.5  # типичный отрыв по мирам
+M_MIN = 0.5  # страховка: одна партия не легче половины обычной…
+M_MAX = 2.0  # …и не тяжелее двух
+# Близость партии по типу победы — множитель пар с победителем.
+CLOSENESS = {
+    "objectives": 1.0,
+    "worlds": 0.85,
+    "plastic": 0.7,
+    "resources": 0.6,
+    "last_standing": 1.0,
+}
 
 
-def smoothed_score(points_sum: float, games: int) -> float | None:
-    """Тот же сглаженный рейтинг, что и SMOOTHED_SCORE_SQL, но в Python.
+def max_rounds(player_count: int, nine_rounds_rule: bool) -> int:
+    """Лимит раундов партии: 9 при хоумруле группы и 5+ игроках, иначе 8."""
+    if nine_rounds_rule and player_count >= EXTENDED_MIN_PLAYERS:
+        return EXTENDED_ROUNDS
+    return BASE_ROUNDS
 
-    Нужен там, где строки уже вытащены и агрегировать в SQL нечего (профиль игрока).
-    Держим рядом с SQL-версией и на одних константах: разъехавшиеся реализации одной
-    формулы — источник расхождений, который потом ловится только глазами."""
-    if games <= 0:
-        return None  # рейтинга без игр нет — как SUM(...) = NULL в SQL
-    return (PRIOR_GAMES * PRIOR_MEAN + points_sum) / (PRIOR_GAMES + games) * 100
+
+def fair_worlds(player_count: int) -> float:
+    """«Честная доля» миров на игрока — масштаб для разницы миров."""
+    return BOARD_TILES[player_count] * WORLDS_PER_TILE / player_count
+
+
+def mu_tempo(rmax: int) -> float:
+    """Типичный темп: партия закончилась в предпоследнем раунде."""
+    return 1.0 / (rmax - 1)
+
+
+def expected(r_a: float, r_b: float) -> float:
+    """Ожидаемый результат a против b (вероятность, что a окажется выше)."""
+    return 1.0 / (1.0 + 10.0 ** ((r_b - r_a) / D))
+
+
+def k_factor(games: int) -> float:
+    left = max(0.0, 1.0 - games / K_GAMES)
+    return K_MIN + (K_MAX - K_MIN) * left
+
+
+def table_weight(player_count: int) -> float:
+    return 1.0 + W_TABLE * (player_count - 2) / 4.0
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, x))
+
+
+# ─── Партия как вход расчёта ─────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class RatedSeat:
+    user_id: int
+    place: int
+    faction_id: int = 0
+    eliminated: bool = False
+    objectives: int | None = None  # маркеры целей на конец партии
+    worlds: int | None = None  # дружественные миры на конец партии
+
+
+@dataclass(frozen=True)
+class RatedMatch:
+    seats: tuple[RatedSeat, ...]
+    win_reason: str | None = None
+    end_round: int | None = None  # раунд, в котором партия закончилась
+    nine_rounds_rule: bool = False  # снимок настройки группы на момент партии
+    id: int = 0
+    group_id: int = 0
+    played_at: date | None = None
+    finished_at: datetime | None = None
+
+
+def pair_multiplier(m: RatedMatch, a: RatedSeat, b: RatedSeat) -> float:
+    """Множитель отрыва пары; a — выше или наравне с b."""
+    n = len(m.seats)
+    tie = a.place == b.place
+    winner_pair = a.place == 1
+    add = 1.0
+
+    def diff(x: int, y: int) -> float:
+        return abs(x - y) if tie else max(0, x - y)
+
+    if winner_pair:
+        rmax = max_rounds(n, m.nine_rounds_rule)
+        mu = mu_tempo(rmax)
+        tempo = mu if m.end_round is None else (rmax - m.end_round) / (rmax - 1)
+        add += W_TEMPO * (tempo - mu)
+    if winner_pair and m.win_reason == "last_standing":
+        obj = 1.0  # все соперники устранены — отрыв максимальный, сколько бы ни было маркеров
+    elif a.objectives is not None and b.objectives is not None:
+        obj = _clamp(diff(a.objectives, b.objectives) / n, 0.0, 1.0)
+    else:
+        obj = MU_OBJ
+    add += W_OBJ * (obj - MU_OBJ)
+    if a.worlds is not None and b.worlds is not None:
+        wor = _clamp(diff(a.worlds, b.worlds) / fair_worlds(n), 0.0, 1.0)
+    else:
+        wor = MU_WORLDS
+    add += W_WORLDS * (wor - MU_WORLDS)
+
+    close = CLOSENESS.get(m.win_reason, 1.0) if winner_pair and m.win_reason else 1.0
+    return _clamp(add, M_MIN, M_MAX) * close
+
+
+def rate_match(
+    ratings: dict[int, float], games: dict[int, int], m: RatedMatch
+) -> tuple[dict[int, float], dict[int, float]]:
+    """Изменения рейтинга участников и их результат относительно ожидания.
+
+    Возвращает (ΔR, perf): perf_i = Σ_j (S_ij − E_ij) / (N − 1) — насколько игрок
+    выступил выше ожидания, без множителя отрыва и K. Входные словари не мутирует."""
+    n = len(m.seats)
+    delta = {s.user_id: 0.0 for s in m.seats}
+    perf = {s.user_id: 0.0 for s in m.seats}
+    if n < 2:
+        return delta, perf
+    g = table_weight(n)
+    r = {s.user_id: ratings.get(s.user_id, R0) for s in m.seats}
+    k = {s.user_id: k_factor(games.get(s.user_id, 0)) for s in m.seats}
+    for a, b in combinations(m.seats, 2):
+        if a.eliminated and b.eliminated:
+            # Выбывшие между собой не сравниваются: в этой партии все они проиграли, а миров
+            # у них нет (решение владельца, #91). Нормировка на N − 1 остаётся прежней.
+            continue
+        if a.place > b.place:
+            a, b = b, a
+        s_ab = 0.5 if a.place == b.place else 1.0
+        e_ab = expected(r[a.user_id], r[b.user_id])
+        x = pair_multiplier(m, a, b) * (s_ab - e_ab)
+        delta[a.user_id] += k[a.user_id] * g / (n - 1) * x
+        delta[b.user_id] -= k[b.user_id] * g / (n - 1) * x
+        perf[a.user_id] += (s_ab - e_ab) / (n - 1)
+        perf[b.user_id] -= (s_ab - e_ab) / (n - 1)
+    return delta, perf
+
+
+@dataclass
+class Replay:
+    """Итог проигрывания истории: рейтинги без округления и следы каждой партии."""
+
+    ratings: dict[int, float] = field(default_factory=dict)
+    games: dict[int, int] = field(default_factory=dict)
+    delta: dict[tuple[int, int], float] = field(default_factory=dict)  # (match_id, user_id)
+    perf: dict[tuple[int, int], float] = field(default_factory=dict)  # (match_id, user_id)
+
+
+def replay(matches: Iterable[RatedMatch]) -> Replay:
+    """Проигрывает партии в переданном порядке (хронологию задаёт вызывающий)."""
+    out = Replay()
+    for m in matches:
+        delta, perf = rate_match(out.ratings, out.games, m)
+        for uid, dv in delta.items():
+            out.ratings[uid] = out.ratings.get(uid, R0) + dv
+            out.games[uid] = out.games.get(uid, 0) + 1
+            out.delta[(m.id, uid)] = dv
+            out.perf[(m.id, uid)] = perf[uid]
+    return out
 
 
 def leaderboard_sort_key(row: dict) -> tuple:
-    """Ключ сортировки топа: счёт ↓, winrate ↓, игры ↓, среднее место ↑, ник ↑."""
+    """Ключ сортировки топа: рейтинг ↓, winrate ↓, игры ↓, среднее место ↑, ник ↑.
+
+    row["rating"] — рейтинг без округления: два игрока с одинаковым целым в топе
+    всё равно упорядочены по настоящему значению."""
     return (
-        -(row["score"] or 0.0),
+        -(row["rating"] or 0.0),
         -(row["win_rate"] or 0.0),
         -(row["games"] or 0),
         (row["avg_place"] or 0.0),

backend/app/services/stats_service.py

@@ -1,105 +1,183 @@
-"""Статистика и рейтинги. Считается «вживую» (объём данных мал, кэш не нужен)."""
+"""Статистика и рейтинги. Считается «вживую» (объём данных мал, кэш не нужен).
+
+Рейтинг — функция упорядоченной истории (scoring.replay), поэтому витрины не агрегируют
+SQL, а проигрывают завершённые партии: одна загрузка истории на запрос, из неё же
+считаются игры, победы, среднее место и разбивки. Рейтинг у игрока один — по всем
+партиям приложения (#80). Страница группы берёт из него только рейтинг, а игры, победы,
+винрейт и среднее место считает по партиям группы."""
 from __future__ import annotations
 
-from typing import Any
+from collections import defaultdict
 
-from sqlalchemy import func, text
+from sqlalchemy import func
 from sqlmodel import Session, select
 
 from app.core.timeutil import iso_utc
-from app.models import Faction, Group, GroupMember, Match, MatchParticipant, User
+from app.models import Expansion, Faction, Group, GroupMember, Match, MatchParticipant, User
 from app.services import faction_service, group_service, membership_service, user_service
 from app.services.scoring import (
     FACTION_MIN_GAMES,
-    MATCH_POINTS_SQL,
     MIN_GAMES,
-    SMOOTHED_SCORE_SQL,
+    RatedMatch,
+    RatedSeat,
+    Replay,
     leaderboard_sort_key,
-    smoothed_score,
+    replay,
 )
 
-# Базовый блок: одна строка на участие с tie-aware очками.
-# Учитываются только ЗАВЕРШЁННЫЕ партии (in_progress без мест в статистику не входят).
-SCORED_CTE = f"""
-WITH tie AS (
-  SELECT mp.match_id AS match_id, mp.place AS place, COUNT(*) AS tie_size
-  FROM match_participants mp
-  JOIN matches m ON m.id = mp.match_id
-  WHERE m.status = 'finished' AND mp.place IS NOT NULL
-  GROUP BY mp.match_id, mp.place
-),
-scored AS (
-  SELECT mp.user_id      AS user_id,
-         mp.faction_id   AS faction_id,
-         m.id            AS match_id,
-         m.group_id      AS group_id,
-         m.played_at     AS played_at,
-         mp.place        AS place,
-         mp.was_random   AS was_random,
-         m.player_count  AS player_count,
-         ({MATCH_POINTS_SQL}) AS points,
-         CASE WHEN mp.place = 1 THEN 1 ELSE 0 END AS is_win
-  FROM match_participants mp
-  JOIN matches m ON m.id = mp.match_id
-  JOIN tie t ON t.match_id = mp.match_id AND t.place = mp.place
-  WHERE m.status = 'finished'
-)
-"""
+
+MIN_PARTICIPANTS = 2  # партия, где осталось меньше участников, партией не считается
 
 
-def _round(value: Any, ndigits: int) -> float | None:
-    return None if value is None else round(float(value), ndigits)
+def _playable_match_ids():
+    """Подзапрос id партий, в которых не меньше MIN_PARTICIPANTS участников.
+
+    Партия может «опустеть» в деве: жёсткое удаление аккаунта (routers/dev_admin.py)
+    вычёркивает игрока из партий и не пересчитывает их. Партия с одним участником —
+    уже не игра: её нет ни в рейтинге, ни в историях и списках (админка её видит)."""
+    return (
+        select(MatchParticipant.match_id)
+        .group_by(MatchParticipant.match_id)
+        .having(func.count() >= MIN_PARTICIPANTS)
+    )
 
 
-def _normalize(row: dict) -> dict:
-    # avatar_url мирроринг user_service.avatar_url_for: версия = epoch(updated_at) из SQL.
-    avatar_url = None
-    if row.get("avatar_path"):
-        avatar_url = f"/api/users/{row['user_id']}/avatar?v={int(row.get('avatar_version') or 0)}"
+def load_history(session: Session) -> list[RatedMatch]:
+    """Все завершённые партии в порядке проигрывания: дата игры, момент завершения, id.
+
+    Один запрос на партии с участниками. In_progress в рейтинг не входят: мест у них нет,
+    партии меньше чем с двумя участниками — тоже (_playable_match_ids). Срез группы —
+    _for_group по этой же истории: рейтинг считается только целиком."""
+    stmt = (
+        select(Match, MatchParticipant)
+        .join(MatchParticipant, MatchParticipant.match_id == Match.id)
+        .where(Match.status == "finished")
+        .order_by(Match.played_at, Match.finished_at, Match.id, MatchParticipant.id)
+    )
+
+    history: list[RatedMatch] = []
+    current: Match | None = None
+    seats: list[RatedSeat] = []
+
+    def flush() -> None:
+        if current is not None and len(seats) >= MIN_PARTICIPANTS:
+            history.append(
+                RatedMatch(
+                    seats=tuple(seats),
+                    win_reason=current.win_reason,
+                    end_round=current.end_round,
+                    nine_rounds_rule=current.nine_rounds_rule,
+                    id=current.id,  # type: ignore[arg-type]
+                    group_id=current.group_id,
+                    played_at=current.played_at,
+                    finished_at=current.finished_at,
+                )
+            )
+
+    for m, p in session.exec(stmt).all():
+        if current is None or m.id != current.id:
+            flush()
+            current, seats = m, []
+        if p.place is None:  # у завершённой партии мест без значения не бывает
+            continue
+        seats.append(
+            RatedSeat(
+                user_id=p.user_id,
+                place=p.place,
+                faction_id=p.faction_id,
+                eliminated=p.eliminated,
+                objectives=p.objectives,
+                worlds=p.worlds,
+            )
+        )
+    flush()
+    return history
+
+
+def _for_group(history: list[RatedMatch], group_id: int) -> list[RatedMatch]:
+    return [m for m in history if m.group_id == group_id]
+
+
+def _user_seats(history: list[RatedMatch], user_id: int) -> list[tuple[RatedMatch, RatedSeat]]:
+    return [(m, s) for m in history for s in m.seats if s.user_id == user_id]
+
+
+def _rating_confirmed(rep: Replay, user_id: int) -> bool:
+    """Рейтинг подтверждён, когда за игроком MIN_GAMES партий во всём приложении."""
+    return rep.games.get(user_id, 0) >= MIN_GAMES
+
+
+def _summary(seats: list[tuple[RatedMatch, RatedSeat]], rating: float | None) -> dict:
+    """Итог игрока: игры, победы, винрейт, среднее место и рейтинг целым числом.
+
+    В расчёте рейтинг без округления (иначе ошибка копилась бы по цепочке партий),
+    показывается — целым."""
+    games = len(seats)
+    if games == 0:
+        return {"games": 0, "wins": 0, "win_rate": 0.0, "avg_place": None, "score": None}
+    wins = sum(1 for _m, s in seats if s.place == 1)
     return {
-        "user_id": row["user_id"],
-        "nickname": row["nickname"],
-        "games": int(row["games"] or 0),
-        "wins": int(row["wins"] or 0),
-        "win_rate": _round(row["win_rate"] or 0.0, 4),
-        "avg_place": _round(row["avg_place"], 2),
-        "score": _round(row["score"], 1),
-        "avatar_url": avatar_url,
+        "games": games,
+        "wins": wins,
+        "win_rate": round(wins / games, 4),
+        "avg_place": round(sum(s.place for _m, s in seats) / games, 2),
+        "score": None if rating is None else round(rating),
     }
 
 
-def _leaderboard_rows(session: Session, group_id: int | None) -> list[dict]:
-    where = "WHERE s.group_id = :gid" if group_id is not None else ""
-    sql = f"""
-    {SCORED_CTE}
-    SELECT u.id AS user_id, u.nickname AS nickname,
-           u.avatar_path AS avatar_path,
-           CAST(strftime('%s', u.updated_at) AS INTEGER) AS avatar_version,
-           COUNT(*) AS games,
-           SUM(s.is_win) AS wins,
-           AVG(CAST(s.is_win AS FLOAT)) AS win_rate,
-           AVG(s.place) AS avg_place,
-           {SMOOTHED_SCORE_SQL} AS score
-    FROM scored s
-    JOIN users u ON u.id = s.user_id
-    {where}
-    GROUP BY u.id, u.nickname, u.avatar_path, u.updated_at
-    """
-    params = {"gid": group_id} if group_id is not None else {}
-    result = session.execute(text(sql), params).mappings().all()
-    return [_normalize(dict(r)) for r in result]
+def leaderboard(
+    session: Session,
+    group_id: int | None = None,
+    *,
+    history: list[RatedMatch] | None = None,
+    rep: Replay | None = None,
+    member_ids: set[int] | None = None,
+) -> dict:
+    """Топ: общий или группы. history/rep — вся история и её проигрывание (home и
+    group_stats их переиспользуют).
 
+    Рейтинг и статус «Новичок» — всегда общие: статус описывает надёжность рейтинга, а он
+    считается по всем партиям. С group_id игры, победы, винрейт и среднее место берутся
+    только из партий группы (#80). member_ids — показывать только этих игроков (топ
+    группы — её текущий состав, #76); места нумеруются уже после фильтра."""
+    if history is None:
+        history = load_history(session)
+    if rep is None:
+        rep = replay(history)
+    shown = history if group_id is None else _for_group(history, group_id)
 
-def leaderboard(session: Session, group_id: int | None = None) -> dict:
-    rows = _leaderboard_rows(session, group_id)
-    qualified = [r for r in rows if r["games"] >= MIN_GAMES]
-    provisional = [r for r in rows if r["games"] < MIN_GAMES]
-    qualified.sort(key=leaderboard_sort_key)
-    provisional.sort(key=leaderboard_sort_key)
+    by_user: dict[int, list[tuple[RatedMatch, RatedSeat]]] = defaultdict(list)
+    for m in shown:
+        for s in m.seats:
+            if member_ids is None or s.user_id in member_ids:
+                by_user[s.user_id].append((m, s))
+    users = (
+        {u.id: u for u in session.exec(select(User).where(User.id.in_(list(by_user)))).all()}
+        if by_user
+        else {}
+    )
+
+    rows = []
+    for uid, seats in by_user.items():
+        u = users[uid]
+        rows.append(
+            {
+                "user_id": uid,
+                "nickname": u.nickname,
+                **_summary(seats, rep.ratings[uid]),
+                "rating": rep.ratings[uid],  # только для сортировки
+                "rating_confirmed": _rating_confirmed(rep, uid),
+                "avatar_url": user_service.avatar_url_for(u.id, u.avatar_path, u.updated_at),  # type: ignore[arg-type]
+            }
+        )
+    qualified = sorted((r for r in rows if r["rating_confirmed"]), key=leaderboard_sort_key)
+    provisional = sorted((r for r in rows if not r["rating_confirmed"]), key=leaderboard_sort_key)
     for i, r in enumerate(qualified, start=1):
         r["rank"] = i
     for r in provisional:
         r["rank"] = None
+    for r in rows:
+        del r["rating"]
     return {
         "entries": qualified,
         "provisional": provisional,
@@ -107,72 +185,38 @@ def leaderboard(session: Session, group_id: int | None = None) -> dict:
     }
 
 
-def _user_scored_rows(session: Session, user_id: int) -> list[dict]:
-    """Строки участия игрока со всеми полями, нужными витринам профиля.
-
-    Один проход по SCORED_CTE вместо трёх: общий итог, разбивка по фракциям и форма
-    последних партий считаются из одного и того же набора строк. CTE джойнит участия
-    со всеми партиями приложения, поэтому каждый лишний проход дорожает вместе с
-    общим числом партий, а не с числом партий игрока."""
-    sql = f"""
-    {SCORED_CTE}
-    SELECT s.group_id AS group_id, s.match_id AS match_id, s.played_at AS played_at,
-           s.place AS place, s.player_count AS player_count,
-           s.points AS points, s.is_win AS is_win,
-           f.id AS faction_id, f.code AS code, f.name_ru AS name_ru,
-           e.code AS expansion_code
-    FROM scored s
-    JOIN factions f ON f.id = s.faction_id
-    JOIN expansions e ON e.id = f.expansion_id
-    WHERE s.user_id = :uid
-    """
-    rows = session.execute(text(sql), {"uid": user_id}).mappings().all()
-    return [dict(r) for r in rows]
-
-
-def _for_group(rows: list[dict], group_id: int | None) -> list[dict]:
-    return rows if group_id is None else [r for r in rows if r["group_id"] == group_id]
-
-
-def _overall_from_rows(rows: list[dict]) -> dict:
-    """Тот же итог, что раньше считал SQL: COUNT/SUM/AVG плюс сглаженный рейтинг."""
-    games = len(rows)
-    if games == 0:
-        return {"games": 0, "wins": 0, "win_rate": 0.0, "avg_place": None, "score": None}
-    wins = sum(int(r["is_win"]) for r in rows)
-    return {
-        "games": games,
-        "wins": wins,
-        "win_rate": _round(wins / games, 4),
-        "avg_place": _round(sum(r["place"] for r in rows) / games, 2),
-        "score": _round(smoothed_score(sum(float(r["points"]) for r in rows), games), 1),
+def _faction_breakdown(
+    session: Session, seats: list[tuple[RatedMatch, RatedSeat]], rep: Replay, user_id: int
+) -> list[dict]:
+    by_faction: dict[int, list[tuple[RatedMatch, RatedSeat]]] = defaultdict(list)
+    for m, s in seats:
+        by_faction[s.faction_id].append((m, s))
+    if not by_faction:
+        return []
+    meta = {
+        f.id: (f, code)
+        for f, code in session.exec(
+            select(Faction, Expansion.code)
+            .join(Expansion, Expansion.id == Faction.expansion_id)
+            .where(Faction.id.in_(list(by_faction)))
+        ).all()
     }
-
-
-def _faction_breakdown_from_rows(rows: list[dict]) -> list[dict]:
-    by_faction: dict[int, list[dict]] = {}
-    for r in rows:
-        by_faction.setdefault(r["faction_id"], []).append(r)
     out = []
     for fid, group in by_faction.items():
-        games = len(group)
-        wins = sum(int(r["is_win"]) for r in group)
-        meta = group[0]
+        faction, expansion_code = meta[fid]
+        perf = sum(rep.perf[(m.id, user_id)] for m, _s in group) / len(group)
         out.append(
             {
                 "faction_id": fid,
-                "code": meta["code"],
-                "name_ru": meta["name_ru"],
-                "expansion_code": meta["expansion_code"],
-                "games": games,
-                "wins": wins,
-                "win_rate": _round(wins / games, 4),
-                "avg_place": _round(sum(r["place"] for r in group) / games, 2),
-                # Фракции: чистое среднее (служебная метрика «лучшая/худшая»,
-                # сглаживание задавило бы её к 50).
-                "score": _round(sum(float(r["points"]) for r in group) / games * 100, 1),
+                "code": faction.code,
+                "name_ru": faction.name_ru,
+                "expansion_code": expansion_code,
+                **{k: v for k, v in _summary(group, None).items() if k != "score"},
+                # Средний результат относительно ожидания (S − E) × 100: насколько игрок
+                # на фракции выступает выше рейтинговых шансов — без привязки к рейтингу.
+                "score": round(perf * 100, 1),
                 "name_ru_prepositional": faction_service.prepositional(
-                    meta["code"], meta["name_ru"]
+                    faction.code, faction.name_ru
                 ),
             }
         )
@@ -180,15 +224,15 @@ def _faction_breakdown_from_rows(rows: list[dict]) -> list[dict]:
     return out
 
 
-def _recent_form_from_rows(rows: list[dict], limit: int = 5) -> list[dict]:
-    recent = sorted(rows, key=lambda r: (str(r["played_at"]), r["match_id"]), reverse=True)
+def _recent_form(seats: list[tuple[RatedMatch, RatedSeat]], limit: int = 5) -> list[dict]:
+    recent = sorted(seats, key=lambda ms: (str(ms[0].played_at), ms[0].id), reverse=True)
     return [
         {
-            "place": r["place"],
-            "player_count": r["player_count"],
-            "played_at": str(r["played_at"]),
+            "place": s.place,
+            "player_count": len(m.seats),
+            "played_at": str(m.played_at),
         }
-        for r in recent[:limit]
+        for m, s in recent[:limit]
     ]
 
 
@@ -208,78 +252,91 @@ def _favorite_faction(session: Session, user_id: int) -> dict | None:
     }
 
 
+def _overall(history: list[RatedMatch], rep: Replay, user_id: int) -> dict:
+    return _summary(_user_seats(history, user_id), rep.ratings.get(user_id))
+
+
 def profile_stats(
     session: Session,
     user_id: int,
-    group_id: int | None = None,
     *,
-    rows: list[dict] | None = None,
+    history: list[RatedMatch] | None = None,
+    rep: Replay | None = None,
 ) -> dict:
-    """Витрина профиля. rows — уже вытащенные строки игрока (home() их переиспользует)."""
-    scoped = _for_group(rows if rows is not None else _user_scored_rows(session, user_id), group_id)
-    overall = _overall_from_rows(scoped)
-    factions = _faction_breakdown_from_rows(scoped)
+    """Витрина профиля — общие показатели. history/rep — уже посчитанные (home их
+    переиспользует)."""
+    if history is None:
+        history = load_history(session)
+    if rep is None:
+        rep = replay(history)
+    seats = _user_seats(history, user_id)
+    factions = _faction_breakdown(session, seats, rep, user_id)
     qualified = [f for f in factions if f["games"] >= FACTION_MIN_GAMES]
-    best = max(qualified, key=lambda f: (f["score"] or 0)) if qualified else None
-    worst = min(qualified, key=lambda f: (f["score"] or 0)) if qualified else None
+    best = max(qualified, key=lambda f: f["score"]) if qualified else None
+    worst = min(qualified, key=lambda f: f["score"]) if qualified else None
     # «Чаще всего играет на» — самая игранная фракция по всей истории, включая
     # рандомные раздачи.
     main = max(factions, key=lambda f: f["games"]) if factions else None
     return {
         "user_id": user_id,
-        "overall": overall,
+        "overall": _summary(seats, rep.ratings.get(user_id)),
         "factions": factions,
         "best_faction": best,
         "worst_faction": worst,
         "favorite_faction": _favorite_faction(session, user_id),
         "main_faction": main,
-        "recent_form": _recent_form_from_rows(scoped),
+        "recent_form": _recent_form(seats),
         "min_games": MIN_GAMES,
     }
 
 
 def group_stats(session: Session, group_id: int) -> dict:
-    board = leaderboard(session, group_id=group_id)
-    # Нужны только счётчик и дата последней партии — тянуть строки целиком незачем.
-    games_count, last_played = session.exec(
-        select(func.count(), func.max(Match.played_at)).where(
-            Match.group_id == group_id, Match.status == "finished"
-        )
-    ).one()
-    last_at = str(last_played) if last_played else None
+    history = load_history(session)
+    rep = replay(history)
+    group_history = _for_group(history, group_id)
+    members = membership_service.list_members(session, group_id)
+    # Список игроков группы — только её текущий состав: удалённый из группы в нём не висит.
+    board = leaderboard(
+        session,
+        group_id,
+        history=history,
+        rep=rep,
+        member_ids={u.id for _m, u in members},  # type: ignore[misc]
+    )
+    last_played = max((m.played_at for m in group_history), default=None)
 
+    games: dict[int, int] = defaultdict(int)
+    wins: dict[int, int] = defaultdict(int)
+    for m in group_history:
+        for s in m.seats:
+            games[s.faction_id] += 1
+            wins[s.faction_id] += s.place == 1
     available_ids = group_service.available_faction_ids(session, group_id)
-    faction_meta = []
-    sql = f"""
-    {SCORED_CTE}
-    SELECT f.id AS faction_id, f.code AS code, f.name_ru AS name_ru,
-           COUNT(s.user_id) AS games, SUM(s.is_win) AS wins
-    FROM factions f
-    LEFT JOIN scored s ON s.faction_id = f.id AND s.group_id = :gid
-    GROUP BY f.id, f.code, f.name_ru
-    ORDER BY games DESC, f.sort_order
-    """
-    rows = session.execute(text(sql), {"gid": group_id}).mappings().all()
-    for r in rows:
-        faction_meta.append(
-            {
-                "faction_id": r["faction_id"],
-                "code": r["code"],
-                "name_ru": r["name_ru"],
-                "games": int(r["games"] or 0),
-                "wins": int(r["wins"] or 0),
-                "available": r["faction_id"] in available_ids,
-            }
-        )
+    factions = sorted(
+        session.exec(select(Faction)).all(), key=lambda f: (-games[f.id], f.sort_order)  # type: ignore[index]
+    )
+    faction_meta = [
+        {
+            "faction_id": f.id,
+            "code": f.code,
+            "name_ru": f.name_ru,
+            "games": games[f.id],  # type: ignore[index]
+            "wins": wins[f.id],  # type: ignore[index]
+            "available": f.id in available_ids,
+        }
+        for f in factions
+    ]
 
-    # Участники без завершённых партий — отдельным блоком (нули, rank=null).
+    # Участники без завершённых партий в группе — отдельным блоком (нули, rank=null).
+    # Рейтинг у них общий: если игрок играл в других группах, он виден и здесь.
     played_ids = {e["user_id"] for e in board["entries"]} | {
         e["user_id"] for e in board["provisional"]
     }
     inactive = []
-    for _m, u in membership_service.list_members(session, group_id):
+    for _m, u in members:
         if u.id in played_ids:
             continue
+        rating = rep.ratings.get(u.id)  # type: ignore[arg-type]
         inactive.append(
             {
                 "user_id": u.id,
@@ -288,7 +345,8 @@ def group_stats(session: Session, group_id: int) -> dict:
                 "wins": 0,
                 "win_rate": 0.0,
                 "avg_place": None,
-                "score": None,
+                "score": None if rating is None else round(rating),
+                "rating_confirmed": _rating_confirmed(rep, u.id),  # type: ignore[arg-type]
                 "rank": None,
                 "avatar_url": user_service.avatar_url_for(u.id, u.avatar_path, u.updated_at),
             }
@@ -296,8 +354,8 @@ def group_stats(session: Session, group_id: int) -> dict:
 
     return {
         "group_id": group_id,
-        "total_matches": games_count,
-        "last_match_at": last_at,
+        "total_matches": len(group_history),
+        "last_match_at": str(last_played) if last_played else None,
         "leaderboard": board["entries"],
         "provisional": board["provisional"],
         "inactive": inactive,
@@ -316,6 +374,8 @@ def _participant_row(p: MatchParticipant, u: User, f: Faction) -> dict:
         "eliminated": p.eliminated,
         "was_random": p.was_random,
         "comment": p.comment,
+        "objectives": p.objectives,
+        "worlds": p.worlds,
     }
 
 
@@ -337,8 +397,12 @@ def _participants_by_match(session: Session, match_ids: list[int]) -> dict[int,
     return out
 
 
-def _match_items(session: Session, matches) -> list[dict]:
-    """Элементы списка партий (общее для списка группы и истории игрока)."""
+def _match_items(
+    session: Session, matches, rating_deltas: dict[int, float] | None = None
+) -> list[dict]:
+    """Элементы списка партий (общее для списка группы и истории игрока).
+
+    rating_deltas — {match_id: ΔR} владельца истории; у списка группы их нет."""
     by_match = _participants_by_match(session, [m.id for m in matches])
 
     items = []
@@ -357,18 +421,18 @@ def _match_items(session: Session, matches) -> list[dict]:
                 "overall_comment": m.overall_comment,
                 "created_by": m.created_by,
                 "participants": parts,
+                "rating_delta": None if rating_deltas is None else rating_deltas.get(m.id),
             }
         )
     return items
 
 
 def group_match_list(session: Session, group_id: int, limit: int = 20, offset: int = 0) -> dict:
-    total = session.exec(
-        select(func.count()).select_from(Match).where(Match.group_id == group_id)
-    ).one()
+    where = (Match.group_id == group_id, Match.id.in_(_playable_match_ids()))
+    total = session.exec(select(func.count()).select_from(Match).where(*where)).one()
     matches = session.exec(
         select(Match)
-        .where(Match.group_id == group_id)
+        .where(*where)
         .order_by(Match.played_at.desc(), Match.id.desc())
         .offset(offset)
         .limit(limit)
@@ -390,27 +454,29 @@ def user_match_list(
 ) -> dict:
     """История партий игрока: только ЗАВЕРШЁННЫЕ, свежие сверху.
 
-    best_only — одна лучшая партия по League Points (s.points из SCORED_CTE учитывает
-    место и размер стола); при равных очках берём более свежую."""
+    У каждой партии — изменение общего рейтинга игрока за неё (rating_delta, один знак
+    после запятой). best_only — одна лучшая партия: наибольший прирост рейтинга
+    (учитывает и соперников, и ход партии); при равенстве берём более свежую."""
+    history = load_history(session)
+    rep = replay(history)
+    mine = _user_seats(history, user_id)
+    # + 0.0 превращает −0.0 (мелкий минус, округлённый до нуля) в обычный ноль.
+    deltas = {m.id: round(rep.delta[(m.id, user_id)], 1) + 0.0 for m, _s in mine}
     if best_only:
-        sql = f"""
-        {SCORED_CTE}
-        SELECT s.match_id AS match_id
-        FROM scored s
-        WHERE s.user_id = :uid
-        ORDER BY s.points DESC, s.played_at DESC, s.match_id DESC
-        LIMIT 1
-        """
-        row = session.execute(text(sql), {"uid": user_id}).mappings().first()
-        matches = [session.get(Match, row["match_id"])] if row else []
+        candidates = [(rep.delta[(m.id, user_id)], m.played_at, m.id) for m, _s in mine]
+        matches = [session.get(Match, max(candidates)[2])] if candidates else []
         return {
-            "items": _match_items(session, matches),
+            "items": _match_items(session, matches, deltas),
             "total": len(matches),
             "limit": 1,
             "offset": 0,
         }
 
-    where = (MatchParticipant.user_id == user_id, Match.status == "finished")
+    where = (
+        MatchParticipant.user_id == user_id,
+        Match.status == "finished",
+        Match.id.in_(_playable_match_ids()),
+    )
     total = session.exec(
         select(func.count())
         .select_from(Match)
@@ -426,7 +492,7 @@ def user_match_list(
         .limit(limit)
     ).all()
     return {
-        "items": _match_items(session, matches),
+        "items": _match_items(session, matches, deltas),
         "total": total,
         "limit": limit,
         "offset": offset,
@@ -464,10 +530,12 @@ def user_in_progress_matches(session: Session, user_id: int) -> list[dict]:
 
 
 def home(session: Session, user_id: int, active_group_id: int | None, leaderboard_limit: int = 10) -> dict:
-    board = leaderboard(session, group_id=None)
-    # Строки игрока тянем один раз: из них считается и профиль, и итог по активной группе.
-    rows = _user_scored_rows(session, user_id)
-    profile = profile_stats(session, user_id, group_id=None, rows=rows)
+    # История грузится и проигрывается один раз: из неё и топ, и профиль, и блок активной
+    # группы (там игры и победы по группе, рейтинг — общий).
+    history = load_history(session)
+    rep = replay(history)
+    board = leaderboard(session, history=history, rep=rep)
+    profile = profile_stats(session, user_id, history=history, rep=rep)
     active_group_brief = None
     if active_group_id is not None:
         group = session.get(Group, active_group_id)
@@ -475,7 +543,7 @@ def home(session: Session, user_id: int, active_group_id: int | None, leaderboar
             active_group_brief = {
                 "id": group.id,
                 "name": group.name,
-                **_overall_from_rows(_for_group(rows, active_group_id)),
+                **_overall(_for_group(history, active_group_id), rep, user_id),
             }
     return {
         "leaderboard": board["entries"][:leaderboard_limit],

backend/app/services/user_service.py

@@ -380,5 +380,5 @@ def public_profile(session: Session, user_id: int) -> dict:
         "nickname": user.nickname,
         "bio": user.bio,
         "avatar_url": avatar_url_for(user.id, user.avatar_path, user.updated_at),  # type: ignore[arg-type]
-        "stats": stats_service.profile_stats(session, user_id, group_id=None),
+        "stats": stats_service.profile_stats(session, user_id),
     }

backend/tests/test_admin_extra.py

@@ -2,7 +2,11 @@
 from __future__ import annotations
 
 from fastapi.testclient import TestClient
+from sqlalchemy.pool import StaticPool
+from sqlmodel import Session, SQLModel, create_engine, select
 
+from app.models import Faction
+from app.seed.reference_data import FACTIONS, seed_reference_data
 from tests.conftest import add_group_member, create_finished_match, csrf_headers, login, start_match
 
 
@@ -205,6 +209,37 @@ def test_admin_rename_faction_system_wide(client: TestClient, make_admin, engine
     assert ap["faction_name"] == "Орки WAAAGH"
 
 
+def test_faction_rename_survives_restart_seeding(client: TestClient, make_admin, engine):
+    """Сидинг идёт при каждом старте (entrypoint.sh, lifespan) и не должен откатывать
+    имя, заданное админом (#72)."""
+    login(client, "Кто-то")
+    orks = next(f for f in client.get("/api/factions").json() if f["code"] == "orks")
+    _admin_login(client, make_admin)
+    r = client.patch(
+        f"/api/admin/factions/{orks['id']}",
+        json={"name_ru": "Орки WAAAGH"},
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 200, r.text
+
+    with Session(engine) as s:
+        seed_reference_data(s)  # то же, что делает рестарт
+        assert s.get(Faction, orks["id"]).name_ru == "Орки WAAAGH"
+
+
+def test_seeding_is_complete_and_idempotent():
+    """Пустая БД: фракции из кода создаются со своими именами, повтор ничего не ломает."""
+    engine = create_engine(
+        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
+    )
+    SQLModel.metadata.create_all(engine)
+    with Session(engine) as s:
+        seed_reference_data(s)
+        seed_reference_data(s)
+        names = {f.code: f.name_ru for f in s.exec(select(Faction)).all()}
+    assert names == {code: name for code, name, _exp, _order in FACTIONS}
+
+
 def test_admin_delete_group_with_matches_is_conflict(client: TestClient, make_admin, engine):
     """Группу с партиями удалять нельзя — но ответ должен быть внятным 409.
 

backend/tests/test_admin_password_reset.py

@@ -0,0 +1,77 @@
+"""Ротация пароля администратора из .env (#73): `python -m app.bootstrap --reset-admin-password`."""
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlmodel import Session, select
+
+from app import bootstrap
+from app.core.security import verify_password
+from app.models import User
+from tests.conftest import csrf_headers
+
+OLD, NEW = "secret123", "brand-new-admin-pw"
+
+
+def _admin(engine) -> User:
+    with Session(engine) as s:
+        return s.exec(select(User).where(User.role == "admin")).one()
+
+
+def _login(client: TestClient, password: str):
+    return client.post(
+        "/api/admin/auth/login",
+        json={"username": "admin", "password": password},
+        headers=csrf_headers(client),
+    )
+
+
+def test_reset_applies_env_password_and_revokes_sessions(
+    client: TestClient, engine, make_admin, monkeypatch
+):
+    make_admin("admin", OLD)
+    assert _login(client, OLD).status_code == 200
+    assert client.get("/api/admin/me").status_code == 200
+    version = _admin(engine).token_version
+
+    monkeypatch.setattr(bootstrap.settings, "admin_password", NEW)
+    with Session(engine) as s:
+        bootstrap.reset_admin_password(s)
+
+    admin = _admin(engine)
+    assert verify_password(NEW, admin.password_hash)
+    assert admin.token_version == version + 1
+    # Прежняя админская cookie больше не действует (в т.ч. у того, кто украл пароль).
+    assert client.get("/api/admin/me").status_code == 401
+    assert _login(client, OLD).status_code == 401
+    assert _login(client, NEW).status_code == 200
+
+
+def test_regular_bootstrap_keeps_admin_password_outside_dev(engine, make_admin, monkeypatch):
+    """Обычный старт в prod по-прежнему не берёт пароль из .env — только ротация."""
+    make_admin("admin", OLD)
+    monkeypatch.setattr(bootstrap.settings, "app_env", "production")
+    monkeypatch.setattr(bootstrap.settings, "admin_password", NEW)
+    with Session(engine) as s:
+        bootstrap._ensure_admin(s)
+    assert verify_password(OLD, _admin(engine).password_hash)
+
+
+def test_reset_refuses_without_admin_or_password(engine, make_admin, monkeypatch):
+    monkeypatch.setattr(bootstrap.settings, "admin_password", NEW)
+    with Session(engine) as s, pytest.raises(RuntimeError, match="Администратора ещё нет"):
+        bootstrap.reset_admin_password(s)
+
+    make_admin("admin", OLD)
+    monkeypatch.setattr(bootstrap.settings, "admin_password", "  ")
+    with Session(engine) as s, pytest.raises(RuntimeError, match="ADMIN_PASSWORD пуст"):
+        bootstrap.reset_admin_password(s)
+    assert verify_password(OLD, _admin(engine).password_hash)
+
+
+def test_reset_refuses_when_bootstrap_disabled(engine, make_admin, monkeypatch):
+    make_admin("admin", OLD)
+    monkeypatch.setattr(bootstrap.settings, "admin_bootstrap_enabled", False)
+    monkeypatch.setattr(bootstrap.settings, "admin_password", NEW)
+    with Session(engine) as s, pytest.raises(RuntimeError, match="ADMIN_BOOTSTRAP_ENABLED"):
+        bootstrap.reset_admin_password(s)

backend/tests/test_announcements.py

@@ -0,0 +1,286 @@
+"""Объявления администрации (#84): очистка HTML, права, период показа, «новые игроки»,
+повторный показ с пометкой «обновлено», снятие с показа и удаление."""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlmodel import Session, select
+
+from app.models import AnnouncementView, User
+from app.services import notify
+from app.services.announcement_service import sanitize_body
+from tests.conftest import csrf_headers, login
+
+
+def _iso(dt: datetime) -> str:
+    return dt.astimezone(timezone.utc).isoformat()
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _admin_login(client: TestClient, make_admin) -> None:
+    make_admin("admin", "secret123")
+    r = client.post(
+        "/api/admin/auth/login",
+        json={"username": "admin", "password": "secret123"},
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 200, r.text
+
+
+def _create(client: TestClient, **over) -> dict:
+    body = {
+        "title": "Турнир",
+        "body_html": "<p>Суббота, <b>11:00</b></p>",
+        "starts_at": _iso(_now() - timedelta(hours=1)),
+        "ends_at": _iso(_now() + timedelta(days=1)),
+        "show_to_new_players": True,
+    }
+    body.update(over)
+    r = client.post("/api/admin/announcements", json=body, headers=csrf_headers(client))
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _update(client: TestClient, ann: dict, **over) -> dict:
+    body = {
+        "title": ann["title"],
+        "body_html": ann["body_html"],
+        "starts_at": ann["starts_at"],
+        "ends_at": ann["ends_at"],
+        "show_to_new_players": ann["show_to_new_players"],
+        "reshow": False,
+    }
+    body.update(over)
+    r = client.put(
+        f"/api/admin/announcements/{ann['id']}", json=body, headers=csrf_headers(client)
+    )
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _pending(client: TestClient) -> list[dict]:
+    r = client.get("/api/announcements/pending")
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _ack(client: TestClient, ann_id: int, revision: int):
+    return client.post(
+        f"/api/announcements/{ann_id}/ack",
+        json={"revision": revision},
+        headers=csrf_headers(client),
+    )
+
+
+def _admin_item(client: TestClient, ann_id: int) -> dict:
+    return next(a for a in client.get("/api/admin/announcements").json() if a["id"] == ann_id)
+
+
+# ─── Очистка HTML ────────────────────────────────────────────────────────────
+
+def test_sanitize_keeps_allowed_and_strips_everything_else():
+    raw = (
+        '<div>Привет <strong onclick="steal()">мир</strong></div>'
+        '<p style="color:red"><i>курсив</i> <mark class="red big">красный</mark> '
+        '<mark class="gold" onmouseover="x()">золотой</mark></p>'
+        "<script>alert(1)</script><style>p{display:none}</style>"
+        '<img src=x onerror="alert(1)"><a href="javascript:alert(1)">ссылка</a>'
+        "<svg><text>svg-текст</text></svg>&lt;b&gt;"
+    )
+    html, text = sanitize_body(raw)
+    assert html == (
+        "<p>Привет <b>мир</b></p>"
+        '<p><em>курсив</em> <mark class="red">красный</mark> <mark>золотой</mark></p>'
+        "ссылка&lt;b&gt;"
+    )
+    # Содержимое script/style/svg в видимый текст (и в счётчик длины) не попадает.
+    assert text == "Привет миркурсив красный золотойссылка<b>"
+
+
+def test_sanitize_fixes_nesting_and_keeps_line_breaks():
+    html, _ = sanitize_body("<div><div>один</div><div>два<br></div></div><b>жирный<br/>хвост")
+    # Вложенные <div> из contenteditable → плоские абзацы без пустых <p></p>;
+    # <br> внутри <b> не путается с самим <b>; незакрытое закрывается.
+    assert html == "<p>один</p><p>два<br></p><b>жирный<br>хвост</b>"
+
+
+# ─── Права ───────────────────────────────────────────────────────────────────
+
+def test_admin_endpoints_are_closed_to_players(client: TestClient):
+    assert client.get("/api/admin/announcements").status_code == 401
+    login(client, "Игрок")
+    assert client.get("/api/admin/announcements").status_code == 401
+    r = client.post(
+        "/api/admin/announcements",
+        json={
+            "title": "x",
+            "body_html": "y",
+            "starts_at": _iso(_now()),
+            "ends_at": _iso(_now() + timedelta(days=1)),
+        },
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 401
+
+
+def test_pending_requires_player_session(client: TestClient):
+    assert client.get("/api/announcements/pending").status_code == 401
+
+
+# ─── Показ ───────────────────────────────────────────────────────────────────
+
+def test_created_announcement_is_shown_once(client: TestClient, make_admin, monkeypatch):
+    events: list[dict] = []
+    monkeypatch.setattr(notify.hub, "publish", lambda ids, ev: events.append(ev))
+    login(client, "Игрок")
+    _admin_login(client, make_admin)
+
+    ann = _create(client, body_html="<p>Сбор <b>в 11:00</b></p><script>alert(1)</script>")
+    assert ann["body_html"] == "<p>Сбор <b>в 11:00</b></p>"
+    assert ann["status"] == "live"
+    assert (ann["seen_count"], ann["audience_count"]) == (0, 1)
+    assert {"type": "announcements"} in events
+
+    items = _pending(client)
+    assert [(a["id"], a["revision"], a["updated"]) for a in items] == [(ann["id"], 1, False)]
+    assert _ack(client, ann["id"], 1).status_code == 200
+    assert _pending(client) == []
+    assert _admin_item(client, ann["id"])["seen_count"] == 1
+
+    logs = client.get("/api/admin/audit-logs?entity_type=announcement").json()["items"]
+    assert [(l["action"], l["entity_id"]) for l in logs] == [("create", ann["id"])]
+
+
+def test_pending_respects_period_and_order(client: TestClient, make_admin):
+    login(client, "Игрок")
+    _admin_login(client, make_admin)
+    later = _create(client, title="Позже", starts_at=_iso(_now() - timedelta(minutes=30)))
+    earlier = _create(client, title="Раньше", starts_at=_iso(_now() - timedelta(hours=3)))
+    planned = _create(
+        client,
+        title="Завтра",
+        starts_at=_iso(_now() + timedelta(days=1)),
+        ends_at=_iso(_now() + timedelta(days=2)),
+    )
+    assert planned["status"] == "planned"
+    # Пересекающиеся периоды — от старого к новому; запланированного пока нет.
+    assert [a["title"] for a in _pending(client)] == ["Раньше", "Позже"]
+    assert earlier["id"] != later["id"]
+
+    # Период, который уже закончился, создать нельзя.
+    r = client.post(
+        "/api/admin/announcements",
+        json={
+            "title": "Прошлое",
+            "body_html": "текст",
+            "starts_at": _iso(_now() - timedelta(days=2)),
+            "ends_at": _iso(_now() - timedelta(days=1)),
+        },
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 422
+
+
+def test_hidden_from_players_registered_after_start(client: TestClient, make_admin, engine):
+    login(client, "Старожил")
+    with Session(engine) as s:
+        old = s.exec(select(User).where(User.nickname == "Старожил")).one()
+        old.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        s.add(old)
+        s.commit()
+    _admin_login(client, make_admin)
+    ann = _create(client, show_to_new_players=False)
+    assert ann["audience_count"] == 1
+
+    assert [a["id"] for a in _pending(client)] == [ann["id"]]
+    login(client, "Новичок")  # зарегистрирован уже после начала показа
+    assert _pending(client) == []
+    # Адресаты — по-прежнему только старожил.
+    assert _admin_item(client, ann["id"])["audience_count"] == 1
+
+
+def test_reshow_brings_announcement_back_marked_updated(client: TestClient, make_admin):
+    login(client, "Игрок")
+    _admin_login(client, make_admin)
+    ann = _create(client)
+    assert _ack(client, ann["id"], 1).status_code == 200
+
+    # Правка без «показать заново» — закрывшие её не видят.
+    ann = _update(client, ann, body_html="<p>Сбор в 12:00</p>")
+    assert ann["revision"] == 1
+    assert _pending(client) == []
+
+    ann = _update(client, ann, body_html="<p>Сбор в 13:00</p>", reshow=True)
+    assert ann["revision"] == 2
+    assert ann["seen_count"] == 0  # закрывших новую версию ещё нет
+    items = _pending(client)
+    assert [(a["revision"], a["updated"], a["body_html"]) for a in items] == [
+        (2, True, "<p>Сбор в 13:00</p>")
+    ]
+
+    # Пока окно висело, админ выпустил третью версию: закрыв вторую, игрок увидит третью.
+    ann = _update(client, ann, reshow=True)
+    assert _ack(client, ann["id"], 2).status_code == 200
+    assert [(a["revision"], a["updated"]) for a in _pending(client)] == [(3, True)]
+    assert _ack(client, ann["id"], 3).status_code == 200
+    assert _pending(client) == []
+
+
+def test_stop_and_delete(client: TestClient, make_admin, engine):
+    login(client, "Игрок")
+    _admin_login(client, make_admin)
+    live = _create(client)
+    planned = _create(
+        client,
+        starts_at=_iso(_now() + timedelta(days=1)),
+        ends_at=_iso(_now() + timedelta(days=2)),
+    )
+
+    r = client.post(f"/api/admin/announcements/{planned['id']}/stop", headers=csrf_headers(client))
+    assert r.status_code == 422  # снять можно только идущее
+
+    r = client.post(f"/api/admin/announcements/{live['id']}/stop", headers=csrf_headers(client))
+    assert r.status_code == 200, r.text
+    assert r.json()["status"] == "finished"
+    assert _pending(client) == []
+
+    assert _ack(client, live["id"], 1).status_code == 200  # закрыть можно и снятое
+    r = client.delete(f"/api/admin/announcements/{live['id']}", headers=csrf_headers(client))
+    assert r.status_code == 200
+    with Session(engine) as s:
+        assert s.exec(select(AnnouncementView)).all() == []  # отметки ушли каскадом
+    assert client.delete(
+        f"/api/admin/announcements/{live['id']}", headers=csrf_headers(client)
+    ).status_code == 404
+    assert _ack(client, live["id"], 1).status_code == 404
+
+
+@pytest.mark.parametrize(
+    ("over", "message_part"),
+    [
+        ({"title": "   "}, "Заголовок"),
+        ({"title": "Я" * 61}, "Заголовок"),
+        ({"body_html": "<p> </p><script>текст</script>"}, "пустым"),
+        ({"body_html": "<p>" + "а" * 601 + "</p>"}, "600"),
+        ({"ends_at": _iso(_now() - timedelta(hours=2))}, "позже начала"),
+    ],
+)
+def test_validation(client: TestClient, make_admin, over: dict, message_part: str):
+    _admin_login(client, make_admin)
+    body = {
+        "title": "Заголовок",
+        "body_html": "<p>текст</p>",
+        "starts_at": _iso(_now() - timedelta(hours=1)),
+        "ends_at": _iso(_now() + timedelta(days=1)),
+    }
+    body.update(over)
+    r = client.post("/api/admin/announcements", json=body, headers=csrf_headers(client))
+    assert r.status_code == 422, r.text
+    err = r.json()["error"]
+    assert err["code"] == "VALIDATION_ERROR"
+    assert message_part in err["message"]

backend/tests/test_api_hardening.py

@@ -1,4 +1,4 @@
-"""Хардненинг API: раскрытие схемы закрыто в production, открыто в dev/test (#61, F6)."""
+"""Хардненинг API: раскрытие схемы закрыто в production, открыто в dev (#61, F6)."""
 from __future__ import annotations
 
 from fastapi.testclient import TestClient

backend/tests/test_auth.py

@@ -23,14 +23,12 @@ def test_enabled_methods_by_env(monkeypatch):
 
     monkeypatch.setattr(settings, "app_env", "development")
     assert set(enabled_methods()) == {"password", "telegram", "stub"}
-    monkeypatch.setattr(settings, "app_env", "test")
-    assert enabled_methods() == ["password", "telegram"]  # test (прод-клон) → без stub
     monkeypatch.setattr(settings, "app_env", "production")
     assert enabled_methods() == ["password", "telegram"]  # prod → без stub
 
 
 def test_env_flags_and_db_path(monkeypatch):
-    """dev → файл дева; test и prod → том /data (общая ветвь is_development)."""
+    """dev → файл дева; prod → том /data."""
     from app.core.config import settings
 
     monkeypatch.setattr(settings, "dev_database_url", "sqlite:///dev.db")
@@ -38,8 +36,6 @@ def test_env_flags_and_db_path(monkeypatch):
 
     monkeypatch.setattr(settings, "app_env", "development")
     assert settings.is_development and settings.database_url == "sqlite:///dev.db"
-    monkeypatch.setattr(settings, "app_env", "test")
-    assert settings.is_test and settings.database_url == "sqlite:////data/prod.db"
     monkeypatch.setattr(settings, "app_env", "production")
     assert settings.is_production and settings.database_url == "sqlite:////data/prod.db"
 

backend/tests/test_config_security.py

@@ -1,6 +1,9 @@
-"""Fail-fast конфигурации: production не стартует с дефолтными секретами (#59, F4)."""
+"""Fail-fast конфигурации: опубликованное приложение (production и dev на домене) не
+стартует с дефолтными секретами (#59, F4, #69)."""
 from __future__ import annotations
 
+import logging
+
 import pytest
 from pydantic import ValidationError
 
@@ -61,7 +64,79 @@ def test_production_skips_admin_check_when_bootstrap_disabled():
 def test_development_allows_defaults():
     s = config.Settings(
         app_env="development",
+        local_public="local",
         secret_key=config._DEFAULT_SECRET_KEY,
         admin_password=config._DEFAULT_ADMIN_PASSWORD,
     )
     assert s.is_development
+    assert not s.is_published and not s.cookie_secure
+
+
+# ─── Dev, опубликованный на домен (LOCAL_PUBLIC=vps, #69) ─────────────────────
+# Снаружи он так же доступен, как прод: общеизвестный ключ JWT и пароль админа там
+# открывают админку и подделку любого токена.
+
+
+@pytest.mark.parametrize(
+    "secret_key,admin_password",
+    [
+        (config._DEFAULT_SECRET_KEY, _STRONG_ADMIN_PW),
+        ("too-short", _STRONG_ADMIN_PW),
+        (_STRONG_SECRET, config._DEFAULT_ADMIN_PASSWORD),
+    ],
+    ids=["default-secret", "short-secret", "default-admin-password"],
+)
+def test_published_dev_rejects_weak_secrets(secret_key, admin_password):
+    with pytest.raises(ValidationError, match="LOCAL_PUBLIC=vps"):
+        config.Settings(
+            app_env="development",
+            local_public="vps",
+            secret_key=secret_key,
+            admin_password=admin_password,
+        )
+
+
+def test_published_dev_accepts_strong_secrets():
+    s = config.Settings(
+        app_env="development",
+        local_public="vps",
+        secret_key=_STRONG_SECRET,
+        admin_password=_STRONG_ADMIN_PW,
+    )
+    assert s.is_development and s.is_published and s.cookie_secure
+
+
+def test_published_dev_warns_on_startup(monkeypatch, caplog):
+    """Dev-инструменты на опубликованном dev остаются (решение владельца) — но старт
+    громко перечисляет, что открыто любому посетителю домена."""
+    from fastapi.testclient import TestClient
+
+    from app import main
+
+    monkeypatch.setattr(main.settings, "local_public", "vps")
+    with caplog.at_level(logging.WARNING, logger="fs"), TestClient(main.create_app()):
+        pass
+    assert "DEV ОПУБЛИКОВАН НАРУЖУ" in caplog.text
+    assert "вход по нику без пароля" in caplog.text
+
+
+def test_local_dev_starts_quietly(caplog):
+    from fastapi.testclient import TestClient
+
+    from app import main
+
+    with caplog.at_level(logging.WARNING, logger="fs"), TestClient(main.create_app()):
+        pass
+    assert "DEV ОПУБЛИКОВАН НАРУЖУ" not in caplog.text
+
+
+@pytest.mark.parametrize("app_env", ["test", "staging", ""])
+def test_unknown_app_env_rejected(app_env):
+    # Отдельного test-контура больше нет: такое значение не должно молча включать прод-пути.
+    with pytest.raises(ValidationError):
+        config.Settings(app_env=app_env)
+
+
+def test_app_env_case_insensitive():
+    s = config.Settings(app_env="Development")
+    assert s.is_development

backend/tests/test_events_payload.py

@@ -1,4 +1,5 @@
-"""Событие партии несёт список участников: по нему клиент решает, чьи витрины протухли."""
+"""Адресаты событий партии. Рейтинг общий (#80): завершённая партия двигает витрины
+всех игроков, поэтому игроки вне группы получают событие ratings (#88)."""
 from __future__ import annotations
 
 from fastapi.testclient import TestClient
@@ -16,20 +17,29 @@ def _capture_events(monkeypatch) -> list[tuple[list[int], dict]]:
     return published
 
 
-def _match_events(published: list[tuple[list[int], dict]]) -> list[dict]:
-    return [e for _ids, e in published if e.get("type") == "match"]
+def _recipients(published: list[tuple[list[int], dict]], kind: str) -> set[int]:
+    return {uid for ids, e in published if e.get("type") == kind for uid in ids}
 
 
-def test_match_event_carries_participants(client: TestClient, engine, monkeypatch):
+def _two_groups(client: TestClient, engine) -> tuple[dict, int, int, int, list[int]]:
+    """Хост и Игрок2 в группе партии, Чужой — только в другой группе хоста."""
     me = login(client, "Хост")
     exps = [e["id"] for e in client.get("/api/expansions").json()]
-    gid = client.post(
-        "/api/groups", json={"name": "Группа", "expansion_ids": exps}, headers=csrf_headers(client)
-    ).json()["id"]
+
+    def group(name: str) -> int:
+        return client.post(
+            "/api/groups", json={"name": name, "expansion_ids": exps}, headers=csrf_headers(client)
+        ).json()["id"]
+
+    gid, other_gid = group("Группа"), group("Другая")
     p2 = add_group_member(engine, gid, "Игрок2")
-    # Третий в группе, но НЕ в партии: его история от этой партии не меняется.
-    p3 = add_group_member(engine, gid, "Зритель")
+    outsider = add_group_member(engine, other_gid, "Чужой")
     fids = [f["id"] for f in client.get(f"/api/groups/{gid}/factions").json()]
+    return me, gid, p2, outsider, fids
+
+
+def test_finished_match_reaches_players_outside_group(client: TestClient, engine, monkeypatch):
+    me, gid, p2, outsider, fids = _two_groups(client, engine)
 
     published = _capture_events(monkeypatch)
     started = start_match(
@@ -37,36 +47,31 @@ def test_match_event_carries_participants(client: TestClient, engine, monkeypatc
         [{"user_id": me["id"], "faction_id": fids[0]}, {"user_id": p2, "faction_id": fids[1]}],
     )
     assert started.status_code == 200, started.text
-    mid = started.json()["id"]
-
-    ev = _match_events(published)[-1]
-    assert sorted(ev["participant_ids"]) == sorted([me["id"], p2])
-    assert p3 not in ev["participant_ids"]
+    # Незавершённая партия рейтинг не двигает — знать о ней нужно только группе.
+    assert _recipients(published, "match") == {me["id"], p2}
+    assert _recipients(published, "ratings") == set()
 
     published.clear()
     fin = finish_match(
-        client, mid, [{"user_id": me["id"], "place": 1}, {"user_id": p2, "place": 2}]
+        client, started.json()["id"], [{"user_id": me["id"], "place": 1}, {"user_id": p2, "place": 2}]
     )
     assert fin.status_code == 200, fin.text
-    assert sorted(_match_events(published)[-1]["participant_ids"]) == sorted([me["id"], p2])
+    assert _recipients(published, "match") == {me["id"], p2}
+    ratings = _recipients(published, "ratings")
+    assert outsider in ratings
+    assert not ratings & {me["id"], p2}  # группа уже получила подробное событие
 
 
-def test_delete_event_carries_participants(client: TestClient, engine, monkeypatch):
-    """Удаление — главный случай: строки участников уже уничтожены каскадом.
-
-    Если собирать их после удаления, список всегда окажется пустым, и клиент не
-    обновит историю тем, кто в этой партии играл."""
-    me = login(client, "Хост")
-    exps = [e["id"] for e in client.get("/api/expansions").json()]
-    gid = client.post(
-        "/api/groups", json={"name": "Группа", "expansion_ids": exps}, headers=csrf_headers(client)
-    ).json()["id"]
-    p2 = add_group_member(engine, gid, "Игрок2")
-    fids = [f["id"] for f in client.get(f"/api/groups/{gid}/factions").json()]
+def test_deleting_finished_match_reaches_players_outside_group(
+    client: TestClient, engine, monkeypatch
+):
+    """Удаление завершённой партии пересчитывает рейтинг всех, кто играл после неё."""
+    me, gid, p2, outsider, fids = _two_groups(client, engine)
     mid = start_match(
         client, gid,
         [{"user_id": me["id"], "faction_id": fids[0]}, {"user_id": p2, "faction_id": fids[1]}],
     ).json()["id"]
+    finish_match(client, mid, [{"user_id": me["id"], "place": 1}, {"user_id": p2, "place": 2}])
 
     published = _capture_events(monkeypatch)
     version = client.get(f"/api/matches/{mid}").json()["version"]
@@ -74,4 +79,5 @@ def test_delete_event_carries_participants(client: TestClient, engine, monkeypat
         f"/api/matches/{mid}", params={"expected_version": version}, headers=csrf_headers(client)
     )
     assert r.status_code == 200, r.text
-    assert sorted(_match_events(published)[-1]["participant_ids"]) == sorted([me["id"], p2])
+    assert _recipients(published, "match") == {me["id"], p2}
+    assert outsider in _recipients(published, "ratings")

backend/tests/test_group_rating_members.py

@@ -0,0 +1,85 @@
+"""Список игроков группы — только текущий состав (#76).
+
+Удалённый из группы игрок пропадает из рейтинга группы, но его партии остаются в
+истории: они уже повлияли на (общий) рейтинг оставшихся."""
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+
+from tests.conftest import add_group_member, create_finished_match, csrf_headers, login
+
+
+def _ids(stats: dict) -> dict[str, set[int]]:
+    return {
+        block: {e["user_id"] for e in stats[block]}
+        for block in ("leaderboard", "provisional", "inactive")
+    }
+
+
+def _group(client: TestClient) -> tuple[int, list[int]]:
+    gid = client.post(
+        "/api/groups", json={"name": "Группа", "expansion_ids": []}, headers=csrf_headers(client)
+    ).json()["id"]
+    fids = [f["id"] for f in client.get(f"/api/groups/{gid}/factions").json()]
+    return gid, fids
+
+
+def _remove(client: TestClient, gid: int, uid: int) -> None:
+    r = client.delete(f"/api/groups/{gid}/members/{uid}", headers=csrf_headers(client))
+    assert r.status_code == 200, r.text
+
+
+def test_removed_member_leaves_group_rating_but_not_overall(client: TestClient, engine):
+    me = login(client, "Хозяин")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Ушедший")
+    create_finished_match(
+        client, gid,
+        [
+            {"user_id": me["id"], "faction_id": fids[0], "place": 1},
+            {"user_id": b, "faction_id": fids[1], "place": 2},
+        ],
+    )
+    before = client.get(f"/api/groups/{gid}/stats").json()
+    my_score = next(e["score"] for e in before["provisional"] if e["user_id"] == me["id"])
+
+    _remove(client, gid, b)
+
+    stats = client.get(f"/api/groups/{gid}/stats").json()
+    ids = _ids(stats)
+    assert all(b not in block for block in ids.values())
+    assert me["id"] in ids["provisional"]
+    # Партия с ушедшим учтена: рейтинг оставшегося не изменился, счётчик партий тоже.
+    assert next(e["score"] for e in stats["provisional"] if e["user_id"] == me["id"]) == my_score
+    assert stats["total_matches"] == 1
+
+    board = client.get("/api/stats/leaderboard").json()
+    assert b in {e["user_id"] for e in board["entries"] + board["provisional"]}
+
+    # Вернули в группу — снова в списке со своей историей.
+    add_group_member(engine, gid, "Ушедший")
+    back = client.get(f"/api/groups/{gid}/stats").json()
+    entry = next(e for e in back["provisional"] if e["user_id"] == b)
+    assert (entry["games"], entry["score"]) == (1, 1468)
+
+
+def test_group_ranks_renumbered_after_removal(client: TestClient, engine):
+    me = login(client, "Первый")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Второй")
+    c = add_group_member(engine, gid, "Третий")
+    for _ in range(10):
+        create_finished_match(
+            client, gid,
+            [
+                {"user_id": me["id"], "faction_id": fids[0], "place": 1},
+                {"user_id": b, "faction_id": fids[1], "place": 2},
+                {"user_id": c, "faction_id": fids[2], "place": 3},
+            ],
+        )
+    assert [e["rank"] for e in client.get(f"/api/groups/{gid}/stats").json()["leaderboard"]] == [1, 2, 3]
+
+    _remove(client, gid, b)
+
+    board = client.get(f"/api/groups/{gid}/stats").json()["leaderboard"]
+    assert [(e["user_id"], e["rank"]) for e in board] == [(me["id"], 1), (c, 2)]

backend/tests/test_profile.py

@@ -322,9 +322,10 @@ def test_history_excludes_matches_without_the_player(client: TestClient, engine)
 
 
 def test_history_best_mode_picks_highest_points(client: TestClient, engine):
-    """Режим best берёт партию с максимальными League Points, а не самую свежую.
+    """Режим best берёт партию с наибольшим приростом рейтинга, а не самую свежую.
 
-    Второе место из четырёх даёт (4-2)/3 ≈ 0.67, второе из двух — (2-2)/1 = 0."""
+    Второе место из четырёх равных приносит рейтинг (обыграны двое), второе место
+    в дуэли — отнимает."""
     me = login(client, "Лучший")
     gid, (a, b, c), fids = _group_with(client, engine, "А", "Б", "В")
 

backend/tests/test_rating_examples.py

@@ -0,0 +1,217 @@
+"""Движок рейтинга: примеры docs/rating/rating-system.md и сверка с эталоном simulate.py.
+
+Числа примеров — те же, что в документе (раздел 6) и в EXPECTED эталона: разъехаться
+документ, эталон и приложение не должны. Сверка с simulate.py дополнительно гоняет
+синтетический сезон и требует совпадения каждого изменения рейтинга."""
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+from app.services import scoring
+from app.services.scoring import RatedMatch, RatedSeat, rate_match, replay
+
+VETERAN = 40  # партий у «опытного» игрока: K = K_MIN
+A, B, C, D, E, F = 1, 2, 3, 4, 5, 6
+
+
+def _vets(*ids: int) -> dict[int, int]:
+    return dict.fromkeys(ids, VETERAN)
+
+
+def _duel(first: int, second: int, **kw) -> RatedMatch:
+    return RatedMatch((RatedSeat(first, 1), RatedSeat(second, 2)), **kw)
+
+
+def _seat(uid: int, place: int, objectives=None, worlds=None, eliminated=False) -> RatedSeat:
+    return RatedSeat(uid, place, objectives=objectives, worlds=worlds, eliminated=eliminated)
+
+
+FIVE = tuple(RatedSeat(uid, i + 1) for i, uid in enumerate((A, B, C, D, E)))
+SIX = tuple(RatedSeat(uid, i + 1) for i, uid in enumerate((A, B, C, D, E, F)))
+
+# (ключ, рейтинги, сыграно партий, партия, ожидаемые ΔR с точностью до 0.01)
+EXAMPLES = [
+    ("1a", {A: 1600, B: 1400}, _vets(A, B), _duel(A, B, win_reason="objectives"),
+     {A: 3.84, B: -3.84}),
+    ("1b", {A: 1600, B: 1400}, _vets(A, B), _duel(B, A, win_reason="objectives"),
+     {B: 12.16, A: -12.16}),
+    ("2a", {A: 1500, B: 1500}, _vets(A, B),
+     RatedMatch((_seat(A, 1, 2, 5), _seat(B, 2, 1, 4)), "objectives", end_round=3),
+     {A: 11.18, B: -11.18}),
+    ("2b", {A: 1500, B: 1500}, _vets(A, B),
+     RatedMatch((_seat(A, 1, 2, 5), _seat(B, 2, 1, 4)), "objectives", end_round=8),
+     {A: 5.46, B: -5.46}),
+    ("3a", {A: 1500, B: 1500}, _vets(A, B), _duel(A, B, win_reason="objectives"),
+     {A: 8.0, B: -8.0}),
+    ("3b", dict.fromkeys((A, B, C, D, E), 1500), _vets(A, B, C, D, E),
+     RatedMatch(FIVE, "objectives"),
+     {A: 11.0, B: 5.5, C: 0.0, D: -5.5, E: -11.0}),
+    ("4a", {A: 1500, B: 1500}, _vets(A, B), _duel(A, B, win_reason="worlds"),
+     {A: 6.8, B: -6.8}),
+    ("4b", {A: 1500, B: 1500}, _vets(A, B), _duel(A, B, win_reason="plastic"),
+     {A: 5.6, B: -5.6}),
+    ("4c", {A: 1500, B: 1500}, _vets(A, B), _duel(A, B, win_reason="resources"),
+     {A: 4.8, B: -4.8}),
+    ("4d", {A: 1500, B: 1500}, _vets(A, B),
+     RatedMatch((_seat(A, 1, 2, 6), _seat(B, 2, 2, 5)), "worlds", end_round=8),
+     {A: 3.4, B: -3.4}),
+    ("4e", {A: 1500, B: 1500}, _vets(A, B),
+     RatedMatch((_seat(A, 1, 2, 8), _seat(B, 2, 0, 2)), "objectives", end_round=3),
+     {A: 16.0, B: -16.0}),
+    ("5", {A: 1550, B: 1500, C: 1480, D: 1450}, _vets(A, B, C, D),
+     RatedMatch(
+         (_seat(A, 1, 4, 8), _seat(B, 2, 3, 7),
+          _seat(C, 3, 1, 0, eliminated=True), _seat(D, 3, 0, 0, eliminated=True)),
+         "objectives", end_round=7,
+     ),
+     {A: 9.27, B: 5.85, C: -7.6, D: -7.53}),
+    ("6a", dict.fromkeys(range(A, F + 1), 1500), _vets(*range(A, F + 1)),
+     RatedMatch(SIX, "objectives", end_round=8, nine_rounds_rule=True),
+     {A: 12.0, B: 7.2, C: 2.4, D: -2.4, E: -7.2, F: -12.0}),
+    ("6b", dict.fromkeys(range(A, F + 1), 1500), _vets(*range(A, F + 1)),
+     RatedMatch(SIX, "objectives", end_round=8, nine_rounds_rule=False),
+     {A: 10.29, B: 7.54, C: 2.74, D: -2.06, E: -6.86, F: -11.66}),
+    ("7", {A: 1500, B: 1500}, {A: 0, B: VETERAN}, _duel(A, B, win_reason="objectives"),
+     {A: 32.0, B: -8.0}),
+]
+
+
+@pytest.mark.parametrize(
+    "ratings,games,match,want", [e[1:] for e in EXAMPLES], ids=[e[0] for e in EXAMPLES]
+)
+def test_document_examples(ratings, games, match, want):
+    delta, _perf = rate_match(ratings, games, match)
+    assert {uid: round(v, 2) for uid, v in delta.items()} == want
+
+
+def test_examples_cover_whole_section():
+    assert len(EXAMPLES) == 15
+
+
+def test_last_standing_counts_full_objective_gap():
+    """Победа last_standing: отрыв победителя по целям = 1, сколько бы маркеров ни было."""
+    seats = (_seat(A, 1, 1, 6), _seat(B, 2, 1, 0, eliminated=True))
+    ordinary = rate_match({}, _vets(A, B), RatedMatch(seats, "objectives"))[0][A]
+    standing = rate_match({}, _vets(A, B), RatedMatch(seats, "last_standing"))[0][A]
+    # Отрыв по целям 1 вместо 0 → множитель больше на W_OBJ·1 = 0.5; ΔR = K·ΔM·(S − E).
+    assert standing - ordinary == pytest.approx(16 * 0.5 * 0.5)
+
+
+def test_eliminated_are_not_compared_with_each_other():
+    """Выбывшие между собой не сравниваются (#91): слабый выбывший среди сильных не
+    получает рейтинг, а рейтинги прочих выбывших на его изменение не влияют."""
+    six = range(A, F + 1)
+    seats = (_seat(A, 1),) + tuple(_seat(u, 2, eliminated=True) for u in six if u != A)
+    match = RatedMatch(seats, "last_standing")
+    strong = {**dict.fromkeys(six, 1800), F: 1200}
+    delta = rate_match(strong, _vets(*six), match)[0]
+    assert delta[F] < 0
+    # Сильные выбывшие → слабые: у F и у победителя ничего не меняется от этого.
+    weak = {**dict.fromkeys(six, 1200), A: 1800}
+    again = rate_match(weak, _vets(*six), match)[0]
+    assert again[F] == pytest.approx(delta[F])
+    # Победителю сила соперников по-прежнему важна: против слабых он получает меньше.
+    assert again[A] < delta[A]
+
+
+# ─── Сверка с эталоном ───────────────────────────────────────────────────────
+
+SIMULATE = Path(__file__).resolve().parents[2] / "docs" / "rating" / "simulate.py"
+
+
+@pytest.fixture(scope="module")
+def sim():
+    if not SIMULATE.exists():
+        pytest.skip("docs/rating/simulate.py недоступен")
+    spec = importlib.util.spec_from_file_location("rating_simulate", SIMULATE)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module  # dataclasses ищут модуль по имени
+    spec.loader.exec_module(module)  # type: ignore[union-attr]
+    return module
+
+
+def _convert(m, ids: dict[str, int], match_id: int) -> RatedMatch:
+    return RatedMatch(
+        tuple(
+            RatedSeat(
+                ids[s.player], s.place, eliminated=s.eliminated,
+                objectives=s.objectives, worlds=s.worlds,
+            )
+            for s in m.seats
+        ),
+        m.win_reason,
+        end_round=m.round,
+        nine_rounds_rule=m.nine_rounds,
+        id=match_id,
+    )
+
+
+def test_constants_match_reference(sim):
+    p = sim.PROPOSED
+    assert (p.r0, p.d, p.k_max, p.k_min, p.k_games) == (
+        scoring.R0, scoring.D, scoring.K_MAX, scoring.K_MIN, scoring.K_GAMES
+    )
+    assert (p.w_table, p.w_tempo, p.w_obj, p.w_worlds) == (
+        scoring.W_TABLE, scoring.W_TEMPO, scoring.W_OBJ, scoring.W_WORLDS
+    )
+    assert (p.mu_obj, p.mu_worlds, p.m_min, p.m_max) == (
+        scoring.MU_OBJ, scoring.MU_WORLDS, scoring.M_MIN, scoring.M_MAX
+    )
+    assert dict(p.closeness) == scoring.CLOSENESS
+    assert sim.BOARD_TILES == scoring.BOARD_TILES
+    assert not p.autocorr
+    assert p.skip_eliminated_pairs  # выбывшие между собой не сравниваются (#91)
+
+
+@pytest.mark.parametrize("scenario", ["сигнал", "клубы", "рост"])
+@pytest.mark.parametrize("stripped", [False, True], ids=["full", "history"])
+def test_replay_matches_reference_season(sim, scenario, stripped):
+    """Весь сезон: каждое изменение рейтинга совпадает с эталоном до 1e-9."""
+    cfg = sim.SCENARIOS[scenario]
+    _skill, matches = sim.generate_season(
+        cfg["seed"], sim.SEASON_MATCHES, cfg["informative"], cfg["clubs"], cfg["learning"]
+    )
+    if stripped:
+        matches = [sim.strip_details(m) for m in matches]
+    ids: dict[str, int] = {}
+    for m in matches:
+        for s in m.seats:
+            ids.setdefault(s.player, len(ids) + 1)
+
+    reference = sim.Elo(sim.PROPOSED)
+    ours = replay(_convert(m, ids, i) for i, m in enumerate(matches))
+    for i, m in enumerate(matches):
+        for player, dv in reference.update(m).items():
+            assert ours.delta[(i, ids[player])] == pytest.approx(dv, abs=1e-9)
+    for player, uid in ids.items():
+        assert ours.ratings[uid] == pytest.approx(reference.rating(player), abs=1e-6)
+
+
+def test_monotone_and_zero_sum(sim):
+    """Победитель без ничьей не теряет, последний без ничьей и любой выбывший не получают;
+    при равных K сумма изменений за партию — ноль."""
+    cfg = sim.SCENARIOS["сигнал"]
+    _skill, matches = sim.generate_season(cfg["seed"] + 7, 200, True)
+    ids: dict[str, int] = {}
+    for m in matches:
+        for s in m.seats:
+            ids.setdefault(s.player, len(ids) + 1)
+    veterans = dict.fromkeys(ids.values(), VETERAN)
+    for i, m in enumerate(matches):
+        rm = _convert(m, ids, i)
+        delta, _ = rate_match({}, veterans, rm)
+        places = [s.place for s in rm.seats]
+        for s in rm.seats:
+            if s.eliminated:
+                assert delta[s.user_id] < 0
+            if places.count(s.place) > 1:
+                continue
+            if s.place == 1:
+                assert delta[s.user_id] > 0
+            if s.place == max(places):
+                assert delta[s.user_id] < 0
+        assert sum(delta.values()) == pytest.approx(0.0, abs=1e-9)

backend/tests/test_rating_inputs.py

@@ -0,0 +1,226 @@
+"""Итоги партии для рейтинга (#23): раунд окончания, цели и миры, правило 9 раундов,
+причина «последний выживший». Сервер проверяет диапазоны и явные противоречия."""
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+
+from tests.conftest import add_group_member, csrf_headers, finish_match, login, start_match
+
+
+def _group(client: TestClient, engine, players: int) -> tuple[int, list[int], list[int]]:
+    """Группа со всеми дополнениями и players участниками (первый — вошедший)."""
+    me = login(client, "Хозяин")
+    exps = [e["id"] for e in client.get("/api/expansions").json()]
+    gid = client.post(
+        "/api/groups", json={"name": "Группа", "expansion_ids": exps}, headers=csrf_headers(client)
+    ).json()["id"]
+    uids = [me["id"]] + [add_group_member(engine, gid, f"Игрок{i}") for i in range(2, players + 1)]
+    fids = [f["id"] for f in client.get(f"/api/groups/{gid}/factions").json()]
+    return gid, uids, fids
+
+
+def _start(client: TestClient, gid: int, uids: list[int], fids: list[int]) -> dict:
+    r = start_match(
+        client, gid, [{"user_id": u, "faction_id": fids[i]} for i, u in enumerate(uids)]
+    )
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _finish(client: TestClient, mid: int, participants: list[dict], win_reason: str, **extra):
+    body = {"participants": participants, "win_reason": win_reason, **extra}
+    return client.post(f"/api/matches/{mid}/finish", json=body, headers=csrf_headers(client))
+
+
+def _set_rule(client: TestClient, gid: int, enabled: bool) -> dict:
+    r = client.patch(
+        f"/api/groups/{gid}", json={"nine_rounds_rule": enabled}, headers=csrf_headers(client)
+    )
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def test_finish_saves_round_objectives_and_worlds(client: TestClient, engine):
+    gid, (a, b), fids = _group(client, engine, 2)
+    match = _start(client, gid, [a, b], fids)
+    assert match["max_rounds"] == 8 and match["end_round"] is None
+
+    r = _finish(
+        client, match["id"],
+        [
+            {"user_id": a, "place": 1, "objectives": 2, "worlds": 5},
+            {"user_id": b, "place": 2, "objectives": 1},  # миры не указаны — так и остаётся
+        ],
+        "objectives", end_round=6,
+    )
+    assert r.status_code == 200, r.text
+    data = r.json()
+    assert data["end_round"] == 6
+    parts = {p["user_id"]: p for p in data["participants"]}
+    assert (parts[a]["objectives"], parts[a]["worlds"]) == (2, 5)
+    assert (parts[b]["objectives"], parts[b]["worlds"]) == (1, None)
+
+    listed = client.get(f"/api/groups/{gid}/matches").json()["items"][0]["participants"]
+    assert {p["user_id"]: p["objectives"] for p in listed} == {a: 2, b: 1}
+
+
+def test_end_round_limited_by_max_rounds(client: TestClient, engine):
+    gid, (a, b), fids = _group(client, engine, 2)
+    match = _start(client, gid, [a, b], fids)
+    rows = [{"user_id": a, "place": 1}, {"user_id": b, "place": 2}]
+    assert _finish(client, match["id"], rows, "objectives", end_round=9).status_code == 422
+    assert _finish(client, match["id"], rows, "objectives", end_round=0).status_code == 422
+    assert _finish(client, match["id"], rows, "objectives", end_round=8).status_code == 200
+
+
+def test_nine_rounds_rule_is_snapshotted_for_five_players(client: TestClient, engine):
+    gid, uids, fids = _group(client, engine, 5)
+    assert _set_rule(client, gid, True)["nine_rounds_rule"] is True
+    assert client.get(f"/api/groups/{gid}").json()["name"] == "Группа"  # имя не тронуто
+
+    five = _start(client, gid, uids, fids)
+    four = _start(client, gid, uids[:4], fids)
+    assert (five["nine_rounds_rule"], five["max_rounds"]) == (True, 9)
+    assert (four["nine_rounds_rule"], four["max_rounds"]) == (True, 8)  # правило — только с 5
+
+    # Смена настройки группы не переписывает уже начатую партию.
+    _set_rule(client, gid, False)
+    assert client.get(f"/api/matches/{five['id']}").json()["max_rounds"] == 9
+
+    rows = [{"user_id": u, "place": i + 1} for i, u in enumerate(uids)]
+    assert _finish(client, five["id"], rows, "objectives", end_round=9).status_code == 200
+    rows4 = [{"user_id": u, "place": i + 1} for i, u in enumerate(uids[:4])]
+    assert _finish(client, four["id"], rows4, "objectives", end_round=9).status_code == 422
+
+
+def test_last_standing_required_exactly_when_one_survivor(client: TestClient, engine):
+    gid, (a, b, c), fids = _group(client, engine, 3)
+    match = _start(client, gid, [a, b, c], fids)
+    alone = [
+        {"user_id": a, "place": 1},
+        {"user_id": b, "eliminated": True},
+        {"user_id": c, "eliminated": True},
+    ]
+    r = _finish(client, match["id"], alone, "objectives")
+    assert r.status_code == 422 and "последний выживший" in r.json()["error"]["message"]
+
+    two = [
+        {"user_id": a, "place": 1},
+        {"user_id": b, "place": 2},
+        {"user_id": c, "eliminated": True},
+    ]
+    assert _finish(client, match["id"], two, "last_standing").status_code == 422
+
+    ok = _finish(client, match["id"], alone, "last_standing")
+    assert ok.status_code == 200, ok.text
+    assert ok.json()["win_reason"] == "last_standing"
+
+
+def test_eliminated_player_has_no_worlds(client: TestClient, engine):
+    gid, (a, b, c), fids = _group(client, engine, 3)
+    match = _start(client, gid, [a, b, c], fids)
+    rows = [
+        {"user_id": a, "place": 1, "worlds": 7},
+        {"user_id": b, "place": 2, "worlds": 4},
+        {"user_id": c, "eliminated": True, "worlds": 2},
+    ]
+    assert _finish(client, match["id"], rows, "objectives").status_code == 422
+
+    rows[2] = {"user_id": c, "eliminated": True, "objectives": 1}  # миры не указаны
+    r = _finish(client, match["id"], rows, "objectives")
+    assert r.status_code == 200, r.text
+    parts = {p["user_id"]: p for p in r.json()["participants"]}
+    assert (parts[c]["worlds"], parts[c]["objectives"]) == (0, 1)
+
+
+def test_negative_counts_rejected(client: TestClient, engine):
+    gid, (a, b), fids = _group(client, engine, 2)
+    match = _start(client, gid, [a, b], fids)
+    rows = [{"user_id": a, "place": 1, "objectives": -1}, {"user_id": b, "place": 2}]
+    assert _finish(client, match["id"], rows, "objectives").status_code == 422
+
+
+def _finished(client: TestClient, gid: int, uids: list[int], fids: list[int]) -> dict:
+    match = _start(client, gid, uids, fids)
+    rows = [{"user_id": u, "place": i + 1} for i, u in enumerate(uids)]
+    r = _finish(client, match["id"], rows, "objectives")
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _edit_rows(match: dict, **by_user) -> list[dict]:
+    rows = []
+    for p in match["participants"]:
+        row = {"user_id": p["user_id"], "faction_id": p["faction_id"], "place": p["place"]}
+        row.update(by_user.get(str(p["user_id"]), {}))
+        rows.append(row)
+    return rows
+
+
+def test_edit_checks_last_standing_and_round(client: TestClient, engine):
+    gid, (a, b, c), fids = _group(client, engine, 3)
+    match = _finished(client, gid, [a, b, c], fids)
+    mid = match["id"]
+
+    def patch(body: dict):
+        return client.patch(f"/api/matches/{mid}", json=body, headers=csrf_headers(client))
+
+    elim = {"place": None, "eliminated": True}
+    rows = _edit_rows(match, **{str(b): elim, str(c): elim})
+    assert patch({"participants": rows, "win_reason": "worlds"}).status_code == 422
+    # Причина не передана — сверяется с записанной («по целям»): тоже противоречие.
+    assert patch({"participants": rows}).status_code == 422
+    r = patch({"participants": rows, "win_reason": "last_standing", "end_round": 5})
+    assert r.status_code == 200, r.text
+    assert (r.json()["win_reason"], r.json()["end_round"]) == ("last_standing", 5)
+
+    # Одна только причина: при одном выжившем вернуть «по целям» нельзя.
+    assert patch({"win_reason": "objectives"}).status_code == 422
+    # Один только раунд: в пределах лимита — можно, за лимитом — нет.
+    assert patch({"end_round": 9}).status_code == 422
+    assert patch({"end_round": None}).json()["end_round"] is None
+
+
+def test_admin_edit_saves_counts(client: TestClient, engine, make_admin):
+    gid, (a, b), fids = _group(client, engine, 2)
+    match = _finished(client, gid, [a, b], fids)
+    make_admin("admin", "secret123")
+    assert client.post(
+        "/api/admin/auth/login",
+        json={"username": "admin", "password": "secret123"},
+        headers=csrf_headers(client),
+    ).status_code == 200
+    rows = _edit_rows(match, **{str(a): {"objectives": 2, "worlds": 6}})
+    r = client.patch(
+        f"/api/admin/matches/{match['id']}",
+        json={"participants": rows, "win_reason": "objectives", "end_round": 7},
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 200, r.text
+    parts = {p["user_id"]: p for p in r.json()["participants"]}
+    assert (parts[a]["objectives"], parts[a]["worlds"], r.json()["end_round"]) == (2, 6, 7)
+
+
+def test_draft_keeps_round_and_counts(client: TestClient, engine):
+    gid, (a, b), fids = _group(client, engine, 2)
+    match = _start(client, gid, [a, b], fids)
+    body = {
+        "blocks": [[a], [b]],
+        "win_reason": "last_standing",  # черновик — незаконченный ввод, правило не проверяется
+        "end_round": 4,
+        "objectives": {str(a): 2},
+        "worlds": {str(a): 5, str(b): 3},
+    }
+    r = client.put(f"/api/matches/{match['id']}/finish-draft", json=body, headers=csrf_headers(client))
+    assert r.status_code == 200, r.text
+    data = client.get(f"/api/matches/{match['id']}").json()["finish_draft"]["data"]
+    assert data["end_round"] == 4
+    assert data["objectives"] == {str(a): 2}
+    assert data["worlds"] == {str(a): 5, str(b): 3}
+
+    bad = client.put(
+        f"/api/matches/{match['id']}/finish-draft",
+        json={"worlds": {str(a): -3}},
+        headers=csrf_headers(client),
+    )
+    assert bad.status_code == 422

backend/tests/test_rating_stats.py

@@ -0,0 +1,240 @@
+"""Рейтинг в витринах (#23, #80): Elo по упорядоченной истории, один рейтинг на игрока."""
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+
+from app.services.scoring import RatedMatch, RatedSeat, replay
+from tests.conftest import add_group_member, create_finished_match, csrf_headers, login
+
+
+def _group(client: TestClient, name: str = "Группа") -> tuple[int, list[int]]:
+    gid = client.post(
+        "/api/groups", json={"name": name, "expansion_ids": []}, headers=csrf_headers(client)
+    ).json()["id"]
+    fids = [f["id"] for f in client.get(f"/api/groups/{gid}/factions").json()]
+    return gid, fids
+
+
+def _duel(client: TestClient, gid: int, fids: list[int], winner: int, loser: int) -> dict:
+    return create_finished_match(
+        client, gid,
+        [
+            {"user_id": winner, "faction_id": fids[0], "place": 1},
+            {"user_id": loser, "faction_id": fids[1], "place": 2},
+        ],
+    )
+
+
+def _board(client: TestClient, path: str = "/api/stats/leaderboard") -> dict[int, dict]:
+    data = client.get(path).json()
+    rows = data["entries"] + data["provisional"] if "entries" in data else (
+        data["leaderboard"] + data["provisional"]
+    )
+    return {e["user_id"]: e for e in rows}
+
+
+def test_newcomer_duel_moves_rating_by_32(client: TestClient, engine):
+    """Первая дуэль новичков на 1500: K = 64, ожидание 0.5, деталей нет → ±32."""
+    me = login(client, "Хозяин")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Гость")
+    _duel(client, gid, fids, me["id"], b)
+
+    board = client.get("/api/stats/leaderboard").json()
+    by_id = {e["user_id"]: e for e in board["entries"] + board["provisional"]}
+    assert by_id[me["id"]]["score"] == 1532
+    assert by_id[b]["score"] == 1468
+    # 1 игра < MIN_GAMES=10 → оба пока «Новички», ранжированный топ пуст.
+    assert board["entries"] == []
+    assert board["min_games"] == 10
+
+    prof = client.get("/api/users/me/stats").json()
+    assert prof["overall"]["score"] == 1532
+    # Фракционная метрика — S − E: победа при шансах 0.5 даёт +0.5 → 50.0.
+    assert prof["factions"][0]["score"] == 50.0
+
+
+def test_ranked_after_min_games(client: TestClient, engine):
+    me = login(client, "Чемпион")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Спарринг")
+    for _ in range(10):
+        _duel(client, gid, fids, me["id"], b)
+    board = client.get("/api/stats/leaderboard").json()
+    ranks = {e["user_id"]: (e["rank"], e["score"]) for e in board["entries"]}
+    assert ranks[me["id"]][0] == 1 and ranks[b][0] == 2
+    assert ranks[me["id"]][1] > 1500 > ranks[b][1]
+    assert isinstance(ranks[me["id"]][1], int)
+
+
+def test_editing_past_match_recalculates_later_ones(client: TestClient, engine):
+    """Рейтинг — функция истории: правка первой партии меняет итог после второй."""
+    me = login(client, "А")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Б")
+    first = _duel(client, gid, fids, me["id"], b)
+    _duel(client, gid, fids, me["id"], b)
+
+    def expected(first_winner: int, first_loser: int) -> dict[int, int]:
+        rep = replay([
+            RatedMatch((RatedSeat(first_winner, 1), RatedSeat(first_loser, 2)), "objectives", id=1),
+            RatedMatch((RatedSeat(me["id"], 1), RatedSeat(b, 2)), "objectives", id=2),
+        ])
+        return {uid: round(r) for uid, r in rep.ratings.items()}
+
+    before = expected(me["id"], b)
+    assert {uid: e["score"] for uid, e in _board(client).items()} == before
+
+    rows = [
+        {"user_id": b, "faction_id": fids[1], "place": 1},
+        {"user_id": me["id"], "faction_id": fids[0], "place": 2},
+    ]
+    r = client.patch(
+        f"/api/matches/{first['id']}",
+        json={"participants": rows, "win_reason": "objectives"},
+        headers=csrf_headers(client),
+    )
+    assert r.status_code == 200, r.text
+    after = expected(b, me["id"])
+    assert after != before
+    assert {uid: e["score"] for uid, e in _board(client).items()} == after
+
+
+def test_group_page_shows_overall_rating_with_group_stats(client: TestClient, engine):
+    """Рейтинг один на всё приложение (#80): в группе он тот же, что в общем топе,
+    а игры и победы — только по партиям группы."""
+    me = login(client, "Путешественник")
+    g1, f1 = _group(client, "Первая")
+    g2, f2 = _group(client, "Вторая")
+    b = add_group_member(engine, g1, "Сосед")
+    c = add_group_member(engine, g2, "Соседка")
+    _duel(client, g1, f1, me["id"], b)  # в первой группе — победа
+    _duel(client, g2, f2, c, me["id"])  # во второй — поражение
+
+    overall = _board(client)[me["id"]]
+    assert overall["games"] == 2
+    assert overall["score"] == round(
+        replay([
+            RatedMatch((RatedSeat(me["id"], 1), RatedSeat(b, 2)), "objectives", id=1),
+            RatedMatch((RatedSeat(c, 1), RatedSeat(me["id"], 2)), "objectives", id=2),
+        ]).ratings[me["id"]]
+    )
+    first = _board(client, f"/api/groups/{g1}/stats")[me["id"]]
+    second = _board(client, f"/api/groups/{g2}/stats")[me["id"]]
+    assert first["score"] == second["score"] == overall["score"]
+    assert (first["games"], first["wins"]) == (1, 1)
+    assert (second["games"], second["wins"]) == (1, 0)
+
+    # Главная и профиль — общие показатели; блок активной группы — игры в группе.
+    client.put("/api/users/me/active-group", json={"group_id": g2}, headers=csrf_headers(client))
+    home = client.get("/api/home").json()
+    assert (home["profile"]["overall"]["games"], home["profile"]["overall"]["score"]) == (
+        2, overall["score"]
+    )
+    assert (home["active_group"]["games"], home["active_group"]["score"]) == (1, overall["score"])
+
+
+def test_veteran_is_not_a_newcomer_in_new_group(client: TestClient, engine):
+    """Статус «Новичок» — про надёжность рейтинга, а он общий: 10 партий где угодно
+    делают игрока ранжированным и в группе, где он сыграл одну."""
+    me = login(client, "Ветеран")
+    g1, f1 = _group(client, "Старая")
+    b = add_group_member(engine, g1, "Спарринг")
+    for _ in range(10):
+        _duel(client, g1, f1, me["id"], b)
+
+    g2, f2 = _group(client, "Новая")
+    c = add_group_member(engine, g2, "Новенький")
+    add_group_member(engine, g2, "Спарринг")  # опытный, но в новой группе не играл
+    d = add_group_member(engine, g2, "Зритель")  # не играл нигде
+    _duel(client, g2, f2, me["id"], c)
+
+    stats = client.get(f"/api/groups/{g2}/stats").json()
+    ranked = {e["user_id"]: e for e in stats["leaderboard"]}
+    assert ranked[me["id"]]["rank"] == 1
+    assert (ranked[me["id"]]["games"], ranked[me["id"]]["rating_confirmed"]) == (1, True)
+    assert ranked[me["id"]]["score"] == _board(client)[me["id"]]["score"]
+    assert [e["user_id"] for e in stats["provisional"]] == [c]
+
+    inactive = {e["user_id"]: e for e in stats["inactive"]}
+    assert inactive[b]["score"] == _board(client)[b]["score"]
+    assert (inactive[b]["games"], inactive[b]["rating_confirmed"]) == (0, True)
+    assert (inactive[d]["score"], inactive[d]["rating_confirmed"]) == (None, False)
+
+
+def test_best_match_is_biggest_rating_gain(client: TestClient, engine):
+    """Лучшая партия — наибольший прирост рейтинга, а не свежая из равных побед.
+
+    Обе партии — победы в дуэли. Первая — новичком над равным (+32), вторая — уже
+    с рейтингом 1532 и меньшим K над новичком (≈ +28): лучше первая."""
+    me = login(client, "Лучший")
+    gid, fids = _group(client)
+    x = add_group_member(engine, gid, "Икс")
+    y = add_group_member(engine, gid, "Игрек")
+    first = _duel(client, gid, fids, me["id"], x)
+    _duel(client, gid, fids, me["id"], y)
+
+    client.patch("/api/users/me/profile", json={"history_mode": "best"}, headers=csrf_headers(client))
+    data = client.get(f"/api/users/{me['id']}/matches").json()
+    assert data["total"] == 1
+    assert data["items"][0]["id"] == first["id"]
+
+
+def test_match_left_with_one_participant_is_not_a_game(client: TestClient, engine, make_admin):
+    """Dev-удаление аккаунта вычёркивает игрока из партий, не трогая сами партии. Партия,
+    где остался один участник, — не игра: её нет в рейтинге, историях и списках группы
+    (карточка «с одним игроком» раньше висела в профиле)."""
+    me = login(client, "Выживший")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Удалённый")
+    c = add_group_member(engine, gid, "Соперник")
+    orphan = _duel(client, gid, fids, me["id"], b)
+    kept = _duel(client, gid, fids, c, me["id"])
+
+    make_admin("admin", "secret123")
+    assert client.post(
+        "/api/admin/auth/login",
+        json={"username": "admin", "password": "secret123"},
+        headers=csrf_headers(client),
+    ).status_code == 200
+    assert client.delete(f"/api/admin/dev/users/{b}", headers=csrf_headers(client)).status_code == 200
+    # Админка партию по-прежнему видит — удалить её можно оттуда.
+    assert client.get(f"/api/admin/matches/{orphan['id']}").status_code == 200
+
+    history = client.get(f"/api/users/{me['id']}/matches").json()
+    assert (history["total"], [i["id"] for i in history["items"]]) == (1, [kept["id"]])
+    group_list = client.get(f"/api/groups/{gid}/matches").json()
+    assert (group_list["total"], [i["id"] for i in group_list["items"]]) == (1, [kept["id"]])
+    assert client.get(f"/api/groups/{gid}/stats").json()["total_matches"] == 1
+
+    # В рейтинге — только настоящая партия: дуэль новичков, проигрыш −32.
+    board = _board(client)
+    assert (board[me["id"]]["games"], board[me["id"]]["score"]) == (1, 1468)
+    assert board[c]["score"] == 1532
+
+
+def test_history_shows_rating_delta_of_its_owner(client: TestClient, engine):
+    """История игрока несёт изменение его общего рейтинга за каждую партию (#77)."""
+    me = login(client, "Историк")
+    gid, fids = _group(client)
+    b = add_group_member(engine, gid, "Оппонент")
+    _duel(client, gid, fids, me["id"], b)  # новички на 1500: ±32
+    _duel(client, gid, fids, b, me["id"])  # реванш: 1468 обыгрывает 1532
+
+    mine = client.get(f"/api/users/{me['id']}/matches").json()["items"]
+    theirs = client.get(f"/api/users/{b}/matches").json()["items"]
+    # Свежие сверху: реванш первым.
+    assert (mine[1]["rating_delta"], theirs[1]["rating_delta"]) == (32.0, -32.0)
+    assert mine[0]["rating_delta"] == -theirs[0]["rating_delta"] < 0
+    # Изменения складываются в рейтинг (с точностью округления до десятых).
+    score = _board(client)[me["id"]]["score"]
+    assert abs(1500 + sum(i["rating_delta"] for i in mine) - score) <= 0.6
+
+    # В списке партий группы дельты нет — непонятно, чья она была бы.
+    group_items = client.get(f"/api/groups/{gid}/matches").json()["items"]
+    assert [i["rating_delta"] for i in group_items] == [None, None]
+
+    # Режим «лучшая партия» тоже её отдаёт.
+    client.patch("/api/users/me/profile", json={"history_mode": "best"}, headers=csrf_headers(client))
+    best = client.get(f"/api/users/{me['id']}/matches").json()["items"]
+    assert best[0]["rating_delta"] == 32.0

backend/tests/test_scoring_smoothing.py

@@ -1,39 +0,0 @@
-"""Сглаживание рейтинга: score = (C·m + сумма очков) / (C + игр) × 100, C=10, m=0.5."""
-from __future__ import annotations
-
-from fastapi.testclient import TestClient
-
-from tests.conftest import add_group_member, create_finished_match, csrf_headers, login
-
-
-def test_leaderboard_and_profile_score_are_smoothed(client: TestClient, engine):
-    me = login(client, "Хозяин")
-    gid = client.post(
-        "/api/groups", json={"name": "Группа", "expansion_ids": []}, headers=csrf_headers(client)
-    ).json()["id"]
-    b = add_group_member(engine, gid, "Гость")
-    factions = client.get(f"/api/groups/{gid}/factions").json()
-    f1, f2 = factions[0]["id"], factions[1]["id"]
-
-    create_finished_match(
-        client,
-        gid,
-        [
-            {"user_id": me["id"], "faction_id": f1, "place": 1},
-            {"user_id": b, "faction_id": f2, "place": 2},
-        ],
-    )
-
-    board = client.get("/api/stats/leaderboard").json()
-    by_id = {e["user_id"]: e for e in board["entries"] + board["provisional"]}
-    # Победитель: 1 очко за партию → (10·0.5 + 1) / (10 + 1) × 100 = 54.5.
-    # Проигравший: 0 очков → (10·0.5 + 0) / 11 × 100 = 45.5.
-    assert by_id[me["id"]]["score"] == 54.5
-    assert by_id[b]["score"] == 45.5
-    # 1 игра < MIN_GAMES=10 → оба пока «Новички», ранжированный топ пуст.
-    assert board["entries"] == []
-    assert board["min_games"] == 10
-
-    # Профиль показывает тот же сглаженный рейтинг, что и топ.
-    prof = client.get("/api/users/me/stats").json()
-    assert prof["overall"]["score"] == 54.5

backend/tests/test_stats_passes.py

@@ -1,9 +1,9 @@
-"""Статистика профиля: цифры сходятся с лидербордом, а главная не гоняет CTE лишний раз."""
+"""Статистика профиля: цифры сходятся с лидербордом, а главная не грузит историю лишний раз."""
 from __future__ import annotations
 
 from fastapi.testclient import TestClient
-from sqlalchemy import event
 
+from app.services import stats_service
 from tests.conftest import add_group_member, create_finished_match, csrf_headers, login
 
 
@@ -31,10 +31,7 @@ def _group_with_matches(client: TestClient, engine, games: int = 3) -> tuple[dic
 
 
 def test_profile_numbers_match_leaderboard(client: TestClient, engine):
-    """Профиль считает в Python, лидерборд — в SQL: цифры обязаны совпадать.
-
-    Формула сглаженного рейтинга живёт в двух видах (SMOOTHED_SCORE_SQL и
-    scoring.smoothed_score); этот тест ловит их расхождение."""
+    """Профиль и лидерборд собирают итог разными путями: цифры обязаны совпадать."""
     me, gid, p2 = _group_with_matches(client, engine, games=4)
 
     profile = client.get("/api/users/me/stats").json()["overall"]
@@ -47,33 +44,25 @@ def test_profile_numbers_match_leaderboard(client: TestClient, engine):
         assert profile[field] == entry[field], field
 
 
-def test_home_does_not_repeat_scored_cte(client: TestClient, engine):
-    """Главная делает не больше двух проходов по SCORED_CTE.
-
-    Было пять: лидерборд, три запроса профиля и итог по активной группе. Без этой
-    проверки оптимизация тихо отъедет назад при следующей правке витрин."""
+def test_home_loads_history_once(client: TestClient, engine, monkeypatch):
+    """Главная грузит историю партий один раз: топ, профиль и итог активной группы
+    считаются из неё. Без этой проверки лишняя загрузка тихо вернётся при правке витрин."""
     me, gid, p2 = _group_with_matches(client, engine, games=2)
     client.put(
         "/api/users/me/active-group", json={"group_id": gid}, headers=csrf_headers(client)
     )
 
-    seen: list[str] = []
+    calls: list[int] = []
+    original = stats_service.load_history
 
-    def before_execute(conn, cursor, statement, params, context, executemany):
-        if "WITH tie AS" in statement:
-            seen.append(statement)
+    def spy(session):
+        calls.append(1)
+        return original(session)
 
-    event.listen(engine, "before_cursor_execute", before_execute)
-    try:
-        r = client.get("/api/home")
-        assert r.status_code == 200, r.text
-    finally:
-        event.remove(engine, "before_cursor_execute", before_execute)
-
-    # Сейчас ровно два: лидерборд и один проход по строкам игрока. Нижняя граница не
-    # для красоты — без неё тест пройдёт и когда счётчик молча перестанет что-либо
-    # ловить (сменился путь, переименован CTE).
-    assert 1 <= len(seen) <= 2, f"ожидали 1–2 прохода, получили {len(seen)}"
+    monkeypatch.setattr(stats_service, "load_history", spy)
+    r = client.get("/api/home")
+    assert r.status_code == 200, r.text
+    assert len(calls) == 1
     # Главная всё ещё показывает и профиль, и блок активной группы.
     body = r.json()
     assert body["profile"]["overall"]["games"] == 2

deploy/README.md

@@ -1,6 +1,6 @@
 # Публикация: домены, VPS, туннели
 
-Приложение крутится дома (Pi — прод) и на твоём ПК (dev/test). Дома белого IP нет
+Приложение крутится дома (Pi — прод) и на твоём ПК (dev). Дома белого IP нет
 (CGNAT), поэтому наружу выставляем через **VPS-привратник**: на нём Caddy терминирует
 HTTPS твоими сертификатами и проксирует трафик в SSH reverse-туннели, которые
 приложение само открывает к VPS.
@@ -11,40 +11,40 @@ HTTPS твоими сертификатами и проксирует трафи
                        │                        ▲ туннель-КОНТЕЙНЕР        │
                        │                        └── Pi : app:8000   PROD   │
  forbidden-stars.ru ──►│ :443 (cert твой) → 127.0.0.1:9001               │
-                       │                        ▲ контейнер (test) ИЛИ     │
-                       │                        ▲ ssh с ПК (dev)           │
-                       │                        ├── ПК test : app:8000     │
-                       │                        └── ПК dev  : vite:5173     │
+                       │                        ▲ ssh с ПК (по требованию) │
+                       │                        └── ПК dev : vite:5173 DEV │
                        └───────────────────────────────────────────────────┘
 ```
 
-- **PROD** — Pi. `docker compose up -d` поднимает два сервиса: `app` + `tunnel`. У `app`
-  **портов на хост нет** — наружу его выставляет только туннель-контейнер
-  (`ssh -R 9000:app:8000` к VPS). Постоянно, Docker сам переподключает. См. [`pi/`](pi/README.md).
-- **TEST** — ПК. То же самое: `docker compose -f docker-compose.test.yml up` поднимает
-  `app` + `tunnel` (`ssh -R 9001:app:8000`). Портов на хост нет — тест виден только на
-  `forbidden-stars.ru`. Обычно запускается лаунчером при `APP_ENV=test`.
+- **PROD** — Pi. `docker compose up -d` поднимает три сервиса: `app` + `tunnel` + `backup`
+  (образы из Gitea-реестра, собираются на ПК `scripts/build-push.ps1`). У `app` **портов на
+  хост нет** — наружу его выставляет только туннель-контейнер (`ssh -R 9000:app:8000` к VPS).
+  Работает постоянно: при обрыве `ssh` завершается, и Docker перезапускает контейнер
+  (`restart: unless-stopped`). См. [`pi/`](pi/README.md).
 - **DEV** — ПК, нативно (`uvicorn`+`vite`). По умолчанию только на localhost; при
-  `LOCAL_PUBLIC=vps` лаунчер (`run.ps1`) дополнительно поднимает SSH-туннель с ПК
-  (`ssh -R 9001:localhost:5173`) → дев виден на `forbidden-stars.ru`.
-- DEV и TEST делят слот **9001** (`forbidden-stars.ru`) → поднимай что-то **одно за раз**.
-  PROD на отдельном слоте **9000** (`forbiddenstars.ru`) — работает независимо.
+  `LOCAL_PUBLIC=vps` лаунчер (`run.ps1` / `run.sh`) дополнительно поднимает SSH-туннель с ПК
+  (`ssh -R 9001:localhost:5173`) → дев виден на `forbidden-stars.ru` (слот **9001**).
+- PROD на отдельном слоте **9000** (`forbiddenstars.ru`) — работает независимо от dev.
+  Временный прод на ПК (`docker-compose.temp.yml`) тоже занимает **9000** — одновременно с Pi нельзя.
 
-Ключ туннеля — **`deploy/tunnel/id_tunnel`** (приватный, в git не идёт). Его публичную
-часть добавь в `authorized_keys` пользователя `tunnel` на VPS. Один и тот же ключ годится
-для контейнерного туннеля (Pi/ПК) и для dev-туннеля `run.ps1`.
+Ключи туннеля (приватные, в git не идут; публичные части — в `authorized_keys` пользователя
+`tunnel` на VPS):
+- **Pi** — `TUNNEL_KEY_B64` (base64 приватного ключа) в `.env`; файла ключа на Pi нет.
+- **ПК, временный прод** — файл `deploy/tunnel/id_tunnel`, монтируется в туннель-контейнер.
+- **ПК, dev** — `run.ps1`/`run.sh` зовут системный `ssh` без `-i`, то есть с ключом по
+  умолчанию из `~/.ssh`. Он должен быть в `authorized_keys` (можно тем же, что `id_tunnel`).
 
 Настройка по шагам:
 1. **VPS** — [`vps/README.md`](vps/README.md): Caddy, файрвол, пользователь `tunnel`, сертификаты, `Caddyfile`.
-2. **Pi (прод)** — [`pi/README.md`](pi/README.md): ключ в `deploy/tunnel/id_tunnel`, `.env`, `docker compose up -d`.
-3. **ПК (dev/test)** — тот же ключ в `deploy/tunnel/id_tunnel` (для test-контейнера) и/или
-   ключ по умолчанию для dev (`run.ps1`); pubkey — в `authorized_keys` у `tunnel@VPS`.
+2. **Pi (прод)** — [`pi/README.md`](pi/README.md): ключ туннеля в `TUNNEL_KEY_B64`, `.env`, `docker compose up -d`.
+3. **ПК (dev)** — ключ по умолчанию в `~/.ssh` (для dev-туннеля) и, если нужен временный прод,
+   файл `deploy/tunnel/id_tunnel`; pubkey — в `authorized_keys` у `tunnel@VPS`.
 4. **Бэкапы** — [`backup/README.md`](backup/README.md): контейнер `backup` (restic) делает
-   снимки на Pi и на VPS (`fsbackup@VPS`, только SFTP), скрипты ПК скачивают их и проверяют
-   восстановление на тест-клоне.
+   снимки на Pi и на VPS (`fsbackup@VPS`, только SFTP), скрипты ПК скачивают их на ПК.
 
-Секреты не в git: сертификаты/ключи (`*.pem`, `*.key`, `id_tunnel*`) живут на VPS/Pi/ПК,
-в репозитории только `Caddyfile`, `deploy/tunnel/` (образ туннеля) и шаблоны.
+Секреты не в git: сертификаты/ключи (`*.pem`, `*.key`, `id_tunnel*`, `id_backup*`) живут на
+VPS/Pi/ПК, в репозитории только `Caddyfile`, страница-заглушка, образы `deploy/tunnel/` и
+`deploy/backup/` и шаблоны.
 
 > Telegram-вход требует HTTPS-домен: у BotFather `/setdomain` укажи оба домена
 > (`forbiddenstars.ru` и `forbidden-stars.ru`).
@@ -62,6 +62,6 @@ HTTPS твоими сертификатами и проксирует трафи
 внешний брокер (Redis pub/sub), иначе события увидит только тот воркер, что принял мутацию.
 
 SSE-поток сам не закрывается, поэтому uvicorn запускается с `--timeout-graceful-shutdown`
-(`entrypoint.sh`, `run.*`). Без него остановка ждёт закрытия всех соединений: в dev
+(10 с в `entrypoint.sh`, 2 с в `run.*`). Без него остановка ждёт закрытия всех соединений: в dev
 `--reload` при открытой вкладке висит вечно, в контейнере остановку обрывает только SIGKILL
 по `stop_grace_period`.

deploy/backup/README.md

@@ -16,7 +16,7 @@
 4. [Сборка и публикация образов](#шаг-4-сборка-и-публикация-образов) — ПК
 5. [Pi: включить бэкапы](#шаг-5-pi-включить-бэкапы) — Pi
 6. [ПК: доступ к Pi и выгрузка бэкапов](#шаг-6-пк-доступ-к-pi-и-выгрузка-бэкапов) — ПК
-7. [Учебное восстановление на тест-клоне](#шаг-7-учебное-восстановление-на-тест-клоне) — ПК
+7. [Проверка скачанного архива](#шаг-7-проверка-скачанного-архива) — ПК
 8. [Восстановление прода](#8-восстановление-прода) — Pi
 9. [Катастрофа: Pi умер](#9-катастрофа-pi-умер) — новый Pi
 10. [Повседневные действия](#10-повседневные-действия)
@@ -55,8 +55,8 @@
 4. удаляет старые снимки по правилам хранения;
 5. проверяет, что репозитории целы.
 
-Раз в неделю (воскресенье, 05:30) дополнительно читает часть сохранённых данных и убеждается,
-что последний снимок действительно восстанавливается.
+Раз в неделю (воскресенье, 05:30) дополнительно читает часть сохранённых данных (10 %) и
+убеждается, что БД из последнего снимка извлекается и проходит проверку целостности.
 
 **Словарь**
 
@@ -562,43 +562,42 @@
 
 ---
 
-## Шаг 7. Учебное восстановление на тест-клоне
+## Шаг 7. Проверка скачанного архива
 
-**Где:** ПК с Docker Desktop. **Зачем:** убедиться, что бэкап действительно
-восстанавливается, **до** того как это понадобится по-настоящему. Прод не затрагивается.
+**Где:** ПК. **Зачем:** убедиться, что БД в скачанном снимке целая и в ней те данные, что
+ожидаются, **до** того как это понадобится по-настоящему. Прод не затрагивается.
 
-> Данные тест-клона на ПК будут заменены данными из архива. Прежние данные тест-клона
-> сохраняются в его собственный снимок `pre-restore`.
+> Отдельного тестового контейнера для учебного восстановления больше нет. Сам механизм
+> `restore`/`import` отрабатывает только на Pi ([раздел 8](#8-восстановление-прода)); здесь
+> проверяется содержимое архива.
 
-1. Восстановите скачанный архив в тест-клон (подставьте имя своего файла):
+1. Распакуйте последний скачанный архив во временную папку:
 
    ```powershell
-   .\scripts\fs-backup.ps1 restore-test -File backups\fs_20260914_0400_3f2a9c1d.tar
+   $f = (Get-ChildItem backups\fs_*.tar | Sort-Object LastWriteTime | Select-Object -Last 1).FullName
+   $d = Join-Path $env:TEMP "fs-check"; New-Item -ItemType Directory -Force $d | Out-Null
+   tar -xf $f -C $d
    ```
 
-   В первый раз Docker соберёт образы тест-клона — это несколько минут.
+2. Откройте `%TEMP%\fs-check\forbidden_stars.db` в [DB Browser for SQLite](https://sqlitebrowser.org)
+   (вкладка «Выполнить SQL») и выполните:
 
-2. Проверьте, что приложение тест-клона поднялось:
+   ```sql
+   PRAGMA integrity_check;
+   SELECT (SELECT count(*) FROM users WHERE role = 'player') AS players,
+          (SELECT count(*) FROM matches) AS matches;
+   ```
+
+3. Закройте DB Browser и удалите временную папку — данные в ней не зашифрованы:
 
    ```powershell
-   docker compose -f docker-compose.test.yml ps
-   docker compose -f docker-compose.test.yml logs --tail 20 app
+   Remove-Item -Recurse -Force (Join-Path $env:TEMP "fs-check")
    ```
 
-3. Посмотрите на сайт: в `.env` на ПК временно поставьте `APP_ENV=test` и запустите
-   `.\run.ps1`. Тест-клон откроется на `https://forbidden-stars.ru`: проверьте топ,
-   профили, историю партий. Потом верните `APP_ENV=development`.
-
 **Что должно получиться:**
-- в выводе `restore-test`:
-  - `Развёрнутые данные в порядке: игроков N, партий M.` — те же числа, что в `list` на Pi;
-  - `Данные восстановлены.`;
-  - `Done. The test clone now runs on the restored data.`;
-- `docker compose ... ps` показывает `app` в состоянии `Up … (healthy)`;
-- на сайте тест-клона — данные прода на момент снимка.
-
-> Этим же способом можно восстановить в тест-клон старые архивы `fs_*.tar.gz` прежнего
-> `scripts/backup.sh`: `.\scripts\fs-backup.ps1 restore-test -File backups\fs_20260710_140914.tar.gz`.
+- `PRAGMA integrity_check` → `ok`;
+- `players` и `matches` совпадают со столбцами `Игроков` / `Партий` этого снимка в `list` на Pi;
+- в папке рядом с БД есть `uploads\…` (фото партий) и, если заводились, `achievements\…`.
 
 ---
 
@@ -646,13 +645,14 @@
    | `Игроков` / `Партий` | сколько игроков и партий было в БД в этот момент — по ним легко найти «до поломки» |
    | `Размер` | полный объём данных снимка |
    | `Прирост` | сколько места снимок реально добавил в репозиторий |
-   | `Метки` | `scheduled` — по расписанию, `manual` — вручную, `pre-restore` — страховочный, прочие — имя, данное вручную |
+   | `Метки` | `scheduled` — по расписанию, `manual` — вручную, `pre-restore` — страховочный, `keep` + имя — именованный снимок (`run --tag имя`) |
 
    Если локальный репозиторий повреждён или пуст, смотрите копию на VPS:
    `docker compose exec backup fs-backup list vps`.
 
-2. **По желанию, но рекомендуется:** сначала отрепетируйте на ПК:
-   `.\scripts\fs-backup.ps1 pull -Snapshot <ID>`, затем `restore-test` ([шаг 7](#шаг-7-учебное-восстановление-на-тест-клоне)).
+2. **По желанию, но рекомендуется:** перед восстановлением проверьте выбранный снимок на ПК:
+   `.\scripts\fs-backup.ps1 pull -Snapshot <ID>`, затем [шаг 7](#шаг-7-проверка-скачанного-архива).
+   Заодно у вас останется копия этого снимка вне Pi.
 
 3. Остановите приложение. Сайт покажет страницу «Технические шоколадки»:
 
@@ -737,30 +737,44 @@
    ```
 
 3. Дождитесь, пока приложение создаст пустую БД (`docker compose ps` → `app` `(healthy)`).
-   В журнале бэкапа это нормально (`docker compose logs backup`):
+   Контейнер `backup` стартует одновременно с `app` и сразу пробует сделать первый бэкап. В его
+   журнале (`docker compose logs backup`) нормально увидеть одно из двух:
 
-   ```
-   В БД нет ни игроков, ни партий, а последний снимок в репозитории vps — с данными.
-   Похоже на новый или очищенный сервер: бэкап НЕ сделан, чтобы пустые данные не вытеснили историю.
-   ```
+   - если `backup` успел раньше, чем `app` создал БД:
 
-   Это защита: пустой новый Pi не перезапишет историю на VPS.
+     ```
+     ОШИБКА: БД /fs-db/forbidden_stars.db не найдена — приложение ещё ни разу не запускалось?
+     Первый бэкап не удался — следующая попытка по расписанию.
+     ```
 
-4. Посмотрите снимки на VPS и выберите нужный (обычно самый свежий):
+   - если БД уже была:
+
+     ```
+     В БД нет ни игроков, ни партий, а последний снимок в репозитории vps — с данными.
+     Похоже на новый или очищенный сервер: бэкап НЕ сделан, чтобы пустые данные не вытеснили историю.
+     ```
+
+     Это защита: пустой новый Pi не перезапишет историю на VPS.
+
+4. Посмотрите снимки на VPS и выберите нужный (обычно самый свежий **с данными**):
 
    ```bash
    docker compose exec backup fs-backup list vps
    ```
 
-5. Восстановите:
+   Проверьте, что у выбранного снимка в столбцах `Игроков`/`Партий` числа, а не `0` и не `?`.
+   Защита выше не распознаёт БД без таблиц: если первый бэкап попал ровно в момент создания
+   БД, в списке может появиться свежий снимок с `?` (задача #74). Такой снимок не выбирайте.
+
+5. Восстановите, подставив ID из `list vps`:
 
    ```bash
    docker compose stop app
-   docker compose exec backup fs-backup restore latest --repo vps --yes
+   docker compose exec backup fs-backup restore <ID> --repo vps --yes
    docker compose start app
    ```
 
-   Вместо `latest` можно указать ID из `list vps`.
+   Если самый свежий снимок в `list vps` — с данными, вместо ID можно написать `latest`.
 
 6. Проверьте сайт. Затем сделайте снимок вручную, чтобы локальная копия появилась сразу:
 
@@ -792,7 +806,7 @@
 - **Перед каждым обновлением прода** — `now -Tag before-update` (метка — латиница, цифры, `.`, `_`, `-`).
 - **Раз в месяц:**
   - скачать снимок на ПК (`pull`);
-  - раз в пару месяцев сделать учебное восстановление (`restore-test`);
+  - проверить скачанный архив ([шаг 7](#шаг-7-проверка-скачанного-архива));
   - удалить с ПК старые архивы — они не зашифрованы.
 - **Иногда:** посмотреть `docker compose ps`. Статус `unhealthy` у `backup` означает, что
   бэкапы перестали проходить (причину покажет `fs-backup status`).
@@ -852,7 +866,7 @@ docker compose logs --tail 100 backup
 | `снимок '…' не найден в репозитории` | опечатка в ID или снимок в другом репозитории | `fs-backup list` и `fs-backup list vps` |
 | `service "backup" is not running` | контейнер не запущен | `docker compose up -d backup` |
 | `permission denied while trying to connect to the Docker daemon socket` | пользователь Pi не в группе `docker` | `sudo usermod -aG docker $USER`, перезайти по SSH |
-| `docker compose ps` → `backup` `unhealthy` | последний успешный бэкап старше `BACKUP_MAX_AGE_HOURS` | `docker compose exec backup fs-backup health` покажет причину, дальше по таблице |
+| `docker compose ps` → `backup` `unhealthy` | последний успешный бэкап старше `BACKUP_MAX_AGE_HOURS`, успешных бэкапов ещё не было или не задан `BACKUP_PASSWORD` | `docker compose exec backup fs-backup health` покажет причину, дальше по таблице |
 
 **Про `recover`.** Команда сама определяет, на каком этапе оборвалось восстановление:
 - если замена успела пройти во всех томах — дочищает промежуточные папки, восстановленные
@@ -885,7 +899,7 @@ docker volume rm <имя тома>
 | `WARNING: UNPROTECTED PRIVATE KEY FILE!` | у файла ключа слишком открытые права (ключ создан в Git Bash/WSL или скопирован) | `icacls <путь к ключу> /inheritance:r /grant:r "$($env:USERNAME):(R)"` |
 | `Checksum mismatch … run pull again` | файл повредился при передаче | повторить `pull` (битый файл уже удалён) |
 | `Already downloaded: …` | этот снимок уже скачан | ничего не делать; нужен новый — сначала `now`, потом `pull` |
-| `restore-test`: `Import failed … The test clone data was not changed` | архив повреждён или неполный | скачать заново (`pull`); текст ошибки выше в выводе |
+| шаг 7: `integrity_check` не `ok` или счётчики не совпадают с `list` | архив повреждён или скачан не тот снимок | удалить файл из `backups\` и скачать заново (`pull -Snapshot <ID>`); если повторяется — `fs-backup verify` на Pi |
 
 ---
 
@@ -907,8 +921,11 @@ docker volume rm <имя тома>
 | `export <ID\|latest> [--repo …]` | снимок в tar в stdout: `docker compose exec -T backup fs-backup export latest > fs.tar` |
 | `restic <local\|vps> <аргументы>` | любая команда restic с настройками контейнера, например `restic vps stats` |
 | `help` | краткая справка |
+| `init`, `info`, `health`, `has-snapshots` | служебные: создать репозитории, данные снимка для скриптов ПК, healthcheck, проверка «есть ли снимки» при старте |
 
 Без `--yes` команды `restore` и `import` только показывают, что собираются сделать.
+Флаг `--no-pre-restore` у `restore`/`import` пропускает страховочный снимок — используйте,
+только если текущие данные точно не нужны.
 
 ### Скрипт ПК
 
@@ -918,11 +935,9 @@ docker volume rm <имя тома>
 |---|---|
 | `status`, `list [-Repo vps]`, `now [-Tag имя]`, `verify` | то же, что на Pi, но с ПК |
 | `pull [-Snapshot ID] [-Repo vps]` | скачать снимок в `backups\` со сверкой sha256 |
-| `restore-test -File <архив>` | учебное восстановление в локальный тест-клон |
-| `-Target test` | выполнить `status`/`list`/`now`/`verify`/`pull` на локальном тест-клоне |
 
 В bash-версии те же команды пишутся так: `list vps`, `now --tag имя`,
-`pull <ID> --repo vps`, `restore-test <архив>`, `--test` первым аргументом.
+`pull <ID> --repo vps`.
 
 ### Переменные `.env`
 
@@ -970,7 +985,7 @@ docker volume rm <имя тома>
 - [ ] На Pi первый бэкап прошёл в `local` и `vps`, `status` без ошибок (шаг 5)
 - [ ] `docker compose ps` показывает `backup` `(healthy)` (шаг 5)
 - [ ] С ПК `status`, `list`, `pull` работают без пароля (шаг 6)
-- [ ] Учебное восстановление на тест-клоне прошло, данные на месте (шаг 7)
+- [ ] Скачанный архив проверен: БД целая, числа совпадают с `list` (шаг 7)
 
 **Через сутки**
 - [ ] В `list` появился снимок с меткой `scheduled` в 04:00

deploy/pi/README.md

@@ -2,12 +2,13 @@
 
 На Pi нужны только **ДВА файла**: `docker-compose.yml` и `.env`. Репозиторий, сборка и файл
 ключа туннеля не нужны:
-- образы (`app` + `tunnel`) тянутся из Gitea-реестра (`pull_policy: always`);
+- образы (`app` + `tunnel` + `backup`) тянутся из Gitea-реестра (`pull_policy: always`);
 - приватный ключ туннеля лежит в `.env` как `TUNNEL_KEY_B64` (base64).
 
-`docker compose up` поднимает два контейнера: `app` (FastAPI+SPA, портов на хост нет) и
-`tunnel` (`ssh -R 9000:app:8000` к VPS). Публичная точка — VPS, домен `forbiddenstars.ru`
-(Pi за CGNAT — туннель стучится наружу сам).
+`docker compose up` поднимает три контейнера: `app` (FastAPI+SPA, портов на хост нет),
+`tunnel` (`ssh -R 9000:app:8000` к VPS, стартует после `healthy` у `app`) и `backup` (restic,
+см. раздел «Бэкапы»). Публичная точка — VPS, домен `forbiddenstars.ru` (Pi за CGNAT — туннель
+стучится наружу сам).
 
 ---
 
@@ -86,6 +87,23 @@ IMAGE_REGISTRY=gitea.arseniev.info/notbigghost   # уже значение по
 IMAGE_TAG=latest
 ```
 `APP_ENV` (форсится в `production`) и `VPS_TUNNEL_PORT` (прод → 9000) не трогать.
+Блок `BACKUP_*` можно оставить пустым: бэкапы включаются позже, по
+[`deploy/backup/README.md`](../backup/README.md).
+
+> В production приложение **не стартует**, если `SECRET_KEY` дефолтный или короче 32
+> символов, а `ADMIN_PASSWORD` пустой или дефолтный (при `ADMIN_BOOTSTRAP_ENABLED=true`).
+> `ADMIN_USERNAME`/`ADMIN_PASSWORD` применяются автоматически **только при первом создании**
+> админа: если потом поменять их в `.env`, у существующего админа само ничего не изменится.
+>
+> **Смена пароля админа** (плановая или при утечке) — осознанной командой, через панель
+> его не сменить:
+> 1. поменять `ADMIN_PASSWORD` в `.env` на Pi;
+> 2. `docker compose up -d` — пересоздаст `app` с новым `.env` (контейнер читает `.env`
+>    только при создании; без этого шага команда ниже увидит старый пароль);
+> 3. `docker compose exec app python -m app.bootstrap --reset-admin-password`.
+>
+> Все админские сессии, в том числе чужие, если пароль утёк, после этого завершаются.
+> Логин (`ADMIN_USERNAME`) команда не меняет.
 
 ## 4. Запуск
 ```bash
@@ -94,7 +112,8 @@ docker compose up -d                 # pull_policy: always → тянет обр
 docker compose ps                    # app healthy → поднимется tunnel
 docker compose logs -f tunnel        # ждём строку: [tunnel] -R 9000:app:8000 -> tunnel@...
 ```
-На старте контейнер сам применит миграции, засидит справочники и создаст админа из `.env`.
+На старте контейнер сам применит миграции, засидит справочники и создаст админа из `.env`
+(если админа ещё нет).
 
 ## 5. Проверка
 - Открой `https://forbiddenstars.ru` — должно отдать приложение (не заглушку).
@@ -103,9 +122,12 @@ docker compose logs -f tunnel        # ждём строку: [tunnel] -R 9000:a
 
 ## Обновление
 ```bash
+# Pi:  docker compose exec backup fs-backup run --tag before-update   # по желанию, если бэкапы включены
 # ПК:  .\scripts\build-push.ps1
-# Pi:  docker compose up -d          # always-pull подтянет свежий образ
+# Pi:  docker compose up -d          # always-pull подтянет свежие образы
 ```
+Если в новой версии менялся `docker-compose.yml` или `.env.example`, сначала скачайте
+свежий `docker-compose.yml` (шаг 3) и допишите новые переменные в `.env`.
 
 ## Автозапуск после перезагрузки
 Уже обеспечен: `systemctl enable docker` + `restart: unless-stopped`. После `sudo reboot`

deploy/tunnel/tunnel.sh

@@ -10,7 +10,7 @@ VPS_TUNNEL_USER="${VPS_TUNNEL_USER:-tunnel}"
 UPSTREAM="${UPSTREAM:-app:8000}"
 
 # Источник приватного ключа: либо TUNNEL_KEY_B64 (base64 в .env — прод: только compose+env),
-# либо смонтированный файл /key/id_tunnel (dev/test, где репозиторий есть на хосте).
+# либо смонтированный файл /key/id_tunnel (временный прод на ПК, где репозиторий есть на хосте).
 mkdir -p /root/.ssh
 KEY=/root/.ssh/id_tunnel
 if [ -n "${TUNNEL_KEY_B64:-}" ]; then

deploy/vps/Caddyfile

@@ -2,7 +2,7 @@
 # Два домена, ОБА с твоими сертификатами; проксируют в SSH-туннели:
 #
 #   forbiddenstars.ru   → 127.0.0.1:9000  ← Pi  (autossh, постоянно)   PROD
-#   forbidden-stars.ru  → 127.0.0.1:9001  ← ПК  (по требованию)        DEV/TEST
+#   forbidden-stars.ru  → 127.0.0.1:9001  ← ПК  (по требованию)        DEV
 #
 # Caddy сам терминирует TLS (он и есть edge: видит реального клиента), а вниз к
 # приложению передаёт X-Forwarded-Proto=https / X-Forwarded-For / Host —
@@ -38,10 +38,10 @@
 		-Server
 	}
 
-	# Content-Security-Policy подготовлена, но ВЫКЛЮЧЕНА до проверки на test-клоне: строгая
-	# политика легко ломает SPA (инлайновые стили Vite), Telegram-виджет входа (скрипт с
-	# telegram.org + iframe oauth.telegram.org) и EventSource (/api/events). Раскомментировать
-	# после проверки на forbidden-stars.ru, что вход и реал-тайм работают (#61).
+	# Content-Security-Policy подготовлена, но ВЫКЛЮЧЕНА до проверки: строгая политика легко
+	# ломает SPA (инлайновые стили Vite), Telegram-виджет входа (скрипт с telegram.org + iframe
+	# oauth.telegram.org) и EventSource (/api/events). Раскомментировать после проверки,
+	# что вход и реал-тайм работают (#61).
 	# header Content-Security-Policy "default-src 'self'; script-src 'self' https://telegram.org https://oauth.telegram.org; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self'; frame-src https://oauth.telegram.org; font-src 'self' data:; base-uri 'self'; form-action 'self'; frame-ancestors 'none'"
 
 	# HTML-документ (навигации, Accept: text/html) НЕ кэшируем. Иначе браузер отдаёт старый

deploy/vps/README.md

@@ -1,11 +1,11 @@
 # VPS (186.246.51.17) — реверс-прокси Caddy + точка входа SSH-туннелей
 
 Единственная публичная точка. На VPS: Caddy терминирует HTTPS твоими сертификатами
-для двух доменов и проксирует трафик в SSH reverse-туннели от Pi (прод) и ПК (dev/test).
+для двух доменов и проксирует трафик в SSH reverse-туннели от Pi (прод) и ПК (dev).
 
 ```
-forbiddenstars.ru   → 127.0.0.1:9000  ← Pi  (autossh, постоянно)   PROD
-forbidden-stars.ru  → 127.0.0.1:9001  ← ПК  (по требованию)        DEV/TEST
+forbiddenstars.ru   → 127.0.0.1:9000  ← Pi  (туннель-контейнер, постоянно)   PROD
+forbidden-stars.ru  → 127.0.0.1:9001  ← ПК  (ssh из лаунчера, по требованию)  DEV
 ```
 
 > Туннель `ssh -R` по умолчанию слушает на loopback VPS (127.0.0.1) — ровно туда смотрит
@@ -51,7 +51,9 @@ install -d -m 700 -o tunnel -g tunnel /home/tunnel/.ssh
 install -m 600 -o tunnel -g tunnel /dev/null /home/tunnel/.ssh/authorized_keys
 ```
 Публичные ключи Pi и ПК добавишь в `/home/tunnel/.ssh/authorized_keys` на шагах настройки
-Pi (`deploy/pi/README.md`) и ПК (через `ssh-copy-id`).
+Pi (`deploy/pi/README.md`) и ПК (`deploy/tunnel/id_tunnel.pub` и/или ключ по умолчанию из
+`~/.ssh` для dev-туннеля). Ключи **дописывай** (`>>`), а не перезаписывай файл (`>`):
+иначе туннель другого хоста перестанет пускать.
 
 ## 5. Сертификаты
 
@@ -67,11 +69,11 @@ Caddy читает **PEM** (текст с `-----BEGIN CERTIFICATE-----`). Рас
 
 Удобно собрать прямо на VPS — залей свои файлы и склей:
 ```bash
-mkdir -p /etc/caddy/certs/forbidden-stars.ru /root/certs-tmp
-# с локальной машины (пример для домена forbidden-stars.ru):
+mkdir -p /etc/caddy/certs/forbidden-stars.ru /etc/caddy/certs/forbiddenstars.ru /root/certs-tmp
+# с локальной машины (пример для домена forbidden-stars.ru; имена файлов — свои):
 scp forbidden-stars.crt intermediate.crt forbidden-stars.key root@186.246.51.17:/root/certs-tmp/
 # на VPS — собрать fullchain (leaf + промежуточный) и положить ключ:
-cat /root/certs-tmp/www_forbidden_stars_ru_2026_12_31.crt /root/certs-tmp/intermediate_pem_globalsign_ssl_dv_free_1.crt \
+cat /root/certs-tmp/forbidden-stars.crt /root/certs-tmp/intermediate.crt \
   > /etc/caddy/certs/forbidden-stars.ru/fullchain.pem
 cp /root/certs-tmp/forbidden-stars.key /etc/caddy/certs/forbidden-stars.ru/privkey.pem
 # то же для forbiddenstars.ru (свои crt/intermediate/key), затем права
@@ -96,13 +98,16 @@ scp deploy/vps/maintenance.html root@186.246.51.17:/etc/caddy/maintenance/mainte
 caddy validate --config /etc/caddy/Caddyfile
 systemctl reload caddy
 ```
-> Заглушка живёт в сниппете `(offline)` Caddyfile: при ответе апстрима 502/503/504
-> Caddy отдаёт `/etc/caddy/maintenance/maintenance.html` со статусом 503 и `Cache-Control: no-store`.
+> Заглушка живёт в сниппете `(edge)` Caddyfile (там же security-заголовки и `no-store` для
+> HTML): при ответе апстрима 502/503/504 Caddy отдаёт `/etc/caddy/maintenance/maintenance.html`
+> со статусом 503 и `Cache-Control: no-store`. Для `/api/events` (SSE) у каждого домена
+> отдельный `handle` без `encode` и с `flush_interval -1`.
 > Правки текста/вида — в `deploy/vps/maintenance.html`, затем повтори `scp` (reload Caddy не нужен,
 > файл читается на каждый запрос).
 
 ## 7. Проверка
-1. Подними туннель прода на Pi (см. `deploy/pi/README.md`) и/или dev/test на ПК (`run.ps1` при `LOCAL_PUBLIC=vps`).
+1. Подними туннель прода на Pi (см. `deploy/pi/README.md`) и/или dev на ПК
+   (лаунчер `run.ps1` при `LOCAL_PUBLIC=vps`).
 2. Открой `https://forbiddenstars.ru` и `https://forbidden-stars.ru`.
 3. Пока соответствующий туннель не поднят — Caddy отдаёт страницу-заглушку «Технические шоколадки»
    (HTTP 503), это ожидаемо.

docker-compose.temp.yml

@@ -5,7 +5,7 @@
 #
 #  Отличия от docker-compose.yml (прод на Pi):
 #    • локальный образ (сборка x86 на ПК), НЕ из реестра и НЕ пушится;
-#    • отдельный проект (name) и свои тома — не конфликтует с dev/test на этом ПК.
+#    • отдельный проект (name) и свои тома — не конфликтует с dev на этом ПК.
 #  Всё остальное — как у прода (APP_ENV=production, туннель на 9000, лимиты, healthcheck).
 #
 #    Запуск:     docker compose -f docker-compose.temp.yml up -d --build

docker-compose.test.yml

@@ -1,86 +0,0 @@
-# Локальный «клон прода» в контейнере — для проверки прод-сборки на своей машине
-# (а не на Raspberry Pi). Тот же образ, что и прод, изолированные тома, единый .env.
-# Портов на хост НЕТ: тест виден ТОЛЬКО снаружи на https://forbidden-stars.ru через
-# сервис tunnel (контейнер ssh -R 9001:app:8000 на VPS).
-#
-# Запуск (обычно лаунчером при APP_ENV=test):  docker compose -f docker-compose.test.yml up --build -d
-# Остановить и стереть данные:                 docker compose -f docker-compose.test.yml down -v
-services:
-  app:
-    build: .
-    image: forbidden-stars:test
-    container_name: forbidden-stars-test
-    restart: "no"
-    init: true
-    env_file:
-      - .env                 # единый .env (тот же, что у dev/prod); секреты не в git
-    environment:
-      # Окружение test: прод-клон, но отличимый от прода (см. config.is_test).
-      # Форсим здесь, чтобы значение не зависело от APP_ENV внутри .env.
-      APP_ENV: test
-    # Портов на хост НЕТ: тест доступен только изнутри сети compose; наружу — через
-    # сервис tunnel (ниже) на forbidden-stars.ru. Из LAN/localhost — недоступно.
-    volumes:
-      - db-data-test:/data            # изолированные тестовые данные
-      - uploads-data-test:/data/uploads
-      - achievements-data-test:/data/achievements  # определения ачивок (файлы)
-    healthcheck:
-      test:
-        - CMD
-        - python
-        - -c
-        - "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health')"
-      interval: 30s
-      timeout: 5s
-      retries: 3
-      start_period: 40s
-    mem_limit: 512m
-
-  # SSH reverse-туннель к VPS: forbidden-stars.ru (VPS:9001) -> app:8000 (по сети compose).
-  # Ключ — ./deploy/tunnel/id_tunnel (gitignore), pubkey в authorized_keys у tunnel@VPS.
-  # Внимание: слот 9001 общий с dev-туннелем (run.ps1); поднимай что-то одно за раз.
-  tunnel:
-    build: ./deploy/tunnel
-    image: forbidden-stars-tunnel:test
-    restart: unless-stopped
-    init: true
-    depends_on:
-      app:
-        condition: service_healthy
-    environment:
-      VPS_TUNNEL_HOST: ${VPS_TUNNEL_HOST}
-      VPS_TUNNEL_USER: ${VPS_TUNNEL_USER:-tunnel}
-      VPS_TUNNEL_PORT: "9001"          # forbidden-stars.ru (dev/test)
-      UPSTREAM: app:8000
-    volumes:
-      - ./deploy/tunnel/id_tunnel:/key/id_tunnel:ro
-    mem_limit: 64m
-
-  # Бэкапы тест-клона: тот же образ, что у прода (сборка локально), но ТОЛЬКО локальный
-  # репозиторий и без расписания. BACKUP_VPS_HOST принудительно пуст — тестовые данные
-  # никогда не попадут в прод-репозиторий на VPS. Учебное восстановление:
-  #   .\scripts\fs-backup.ps1 restore-test -File backups\fs_....tar
-  backup:
-    build: ./deploy/backup
-    image: forbidden-stars-backup:test
-    restart: "no"
-    environment:
-      BACKUP_PASSWORD: ${BACKUP_PASSWORD:-test-contour-only}
-      BACKUP_HOSTNAME: fs-test
-      BACKUP_SCHEDULE: ""
-      BACKUP_VERIFY_SCHEDULE: ""
-      BACKUP_VPS_HOST: ""
-      BACKUP_COMPRESSION: ${BACKUP_COMPRESSION:-max}
-      TZ: ${BACKUP_TZ:-Europe/Moscow}
-    volumes:
-      - db-data-test:/fs-db
-      - uploads-data-test:/fs/uploads
-      - achievements-data-test:/fs/achievements
-      - backup-data-test:/backup
-    mem_limit: 384m
-
-volumes:
-  db-data-test:
-  uploads-data-test:
-  achievements-data-test:
-  backup-data-test:

docker-compose.yml

@@ -84,7 +84,7 @@ services:
     restart: unless-stopped
     environment:
       BACKUP_PASSWORD: ${BACKUP_PASSWORD:-}              # пароль шифрования; пусто = бэкапы отключены
-      BACKUP_HOSTNAME: fs-prod                           # имя хоста в снимках (у тест-клона — fs-test)
+      BACKUP_HOSTNAME: fs-prod                           # имя хоста в снимках
       BACKUP_SCHEDULE: ${BACKUP_SCHEDULE:-0 4 * * *}
       BACKUP_VERIFY_SCHEDULE: ${BACKUP_VERIFY_SCHEDULE:-30 5 * * 0}
       BACKUP_KEEP_DAILY: ${BACKUP_KEEP_DAILY:-14}

docs/rating/rating-system.md

@@ -0,0 +1,757 @@
+# Новая рейтинговая система
+
+> **Статус:** утверждено (#22), реализовано в #23 (`backend/app/services/scoring.py`).
+> Решения владельца по открытым вопросам (2026-09-14) внесены — [раздел 9](#9-решения-владельца).
+> **Приложение:** [`simulate.py`](simulate.py) — эталонная реализация формул, все примеры
+> этого документа (с `assert`), симуляция и перебор коэффициентов. Только стандартная
+> библиотека Python, вывод воспроизводим:
+>
+> ```bash
+> python docs/rating/simulate.py          # примеры + сравнение систем (≈1.5 мин)
+> python docs/rating/simulate.py --grid   # примеры + подбор коэффициентов (≈7 мин)
+> ```
+
+## Коротко
+
+Сейчас рейтинг — среднее очков за место. Он не видит ни силы соперников, ни хода партии,
+а первое место в дуэли и за столом на пятерых стоит одинаково.
+
+Предлагается **многопользовательский Elo с множителем отрыва**:
+
+- **Разбор на дуэли.** Партия раскладывается на пары игроков. Каждая пара — дуэль, исход
+  которой сравнивается с ожидаемым по разнице рейтингов: победа над сильным даёт больше,
+  чем над слабым.
+- **Множитель отрыва.** Размер изменения зависит от того, *как* партия сыграна: на каком
+  раунде закончилась, какой отрыв по целям и мирам, какой тип победы. Размер стола тоже
+  влияет, но слабее темпа.
+- **Шкала — классический Elo.** Старт 1500, разница 400 пунктов — шансы 10:1. Пример из
+  задачи «60 против 40» в ней — 1600 против 1400.
+- **Выбывшие между собой не сравниваются.** Все они проиграли, а миров у них нет: пара двух
+  выбывших в расчёт не входит. Сила соперников при этом важна, как и прежде (4.4).
+- **Монотонность.** Единоличный победитель и выбывшие всегда движутся в свою сторону: первый
+  не теряет рейтинг, вторые его не получают. Внутри ничьей невыбывших — за 1-е или
+  последнее место — пара может сдвинуть рейтинг в любую сторону (4.9).
+- **Старая история.** Пересчитывается по тем же формулам: у партий без новых полей
+  признаки берутся нейтральными.
+
+На синтетической лиге система лучше текущей и чистого Elo во всех сценариях, где отрыв
+действительно связан с силой игроков. Например, после 10 партий она правильнее упорядочивает
+игроков: ρ = 0.807 против 0.769 у текущей. Там, где отрыв — чистый шум, она уступает
+чистому Elo около 0.1 п.п. точности. Подробности — в [разделе 7](#7-проверка-на-симуляции).
+
+## Содержание
+
+1. [Как считается сейчас и что с этим не так](#1-как-считается-сейчас-и-что-с-этим-не-так)
+2. [Исходные данные: правила игры](#2-исходные-данные-правила-игры)
+3. [Выбор модели](#3-выбор-модели)
+4. [Формулы](#4-формулы)
+5. [Требования → решения](#5-требования--решения)
+6. [Примеры расчётов](#6-примеры-расчётов)
+7. [Проверка на симуляции](#7-проверка-на-симуляции)
+8. [Что потребуется в реализации (#23)](#8-что-потребуется-в-реализации-23)
+9. [Решения владельца](#9-решения-владельца)
+
+---
+
+## 1. Как считается сейчас и что с этим не так
+
+`backend/app/services/scoring.py`. За партию на N игроков участник получает League Points:
+
+```math
+\text{points} = \frac{N - \text{place} - (\text{tie}-1)/2}{N-1}
+```
+
+1-е место — 1.0, последнее — 0.0; равные места делят очки. Рейтинг — сглаженное среднее
+с 10 «виртуальными» партиями по 0.5, в топ попадают игроки от 10 партий:
+
+```math
+\text{score} = \frac{10 \cdot 0.5 + \sum \text{points}}{10 + \text{games}} \cdot 100
+```
+
+Проблемы на цифрах:
+
+| # | Проблема | Пример |
+|---|---|---|
+| 1 | **Сила соперника не учитывается.** | Победа над лидером топа и над новичком — одинаковые 1.0. Кто играет в основном со слабыми, копит рейтинг быстрее. В симуляции с тремя группами разной силы текущая система упорядочивает игроков с ρ = 0.525, предложенная — с 0.644 (раздел 7). |
+| 2 | **Размер стола не учитывается.** | 1-е место в дуэли — 1.0, 1-е место за столом на пятерых — тоже 1.0, хотя обыграны четверо. |
+| 3 | **Ход партии не учитывается.** | Разгром на 3-м раунде (2:0 по целям, 8:2 по мирам) и победа на тай-брейке по мирам в конце 8-го раунда — одинаковые 1.0. |
+| 4 | **Рейтинг помнит всю историю с одним весом.** | Игрок, проигравший первые 10 дуэлей и выигравший следующие 10, имеет (5 + 10) / 30 · 100 = **50** — как середняк, хотя сейчас сильнее всех. В сценарии «рост» симуляции ρ после 10 партий у текущей системы 0.732, у предложенной 0.774. |
+
+## 2. Исходные данные: правила игры
+
+По справочнику (стр. 8, 11, 16) и уточнениям владельца в #22.
+
+**Победа.** Игрок, собравший маркеры целей в количестве, равном числу игроков N, побеждает.
+Цели собираются в фазе обновления, поэтому партия заканчивается на границе раунда.
+Если к концу последнего раунда никто не набрал N, побеждает тот, у кого больше целей.
+
+**Тай-брейки** (от менее близкой партии к более близкой) — это и есть типы победы
+в приложении:
+
+| Тип (`win_reason`) | Когда | Близость партии |
+|---|---|---|
+| `objectives` — по целям | больше всех целей | обычная |
+| `worlds` — по мирам | цели поровну, больше дружественных миров | близкая |
+| `plastic` — по пластику | цели и миры поровну, больше отрядов на поле | очень близкая |
+| `resources` — по ресурсам | всё выше поровну; **домашнее правило** | самая близкая |
+| `last_standing` — последний выживший | все соперники устранены (нет миров); **новая причина** (решение владельца, раздел 9) | разгром |
+
+Если поровну вообще всё, победа общая (в приложении — ничья за 1-е место).
+
+**Лимит раундов `R_max`.** По правилам 8. **Домашнее правило:** за столом на 5–6 игроков
+играется 9 раундов. Правило включается галочкой в настройках группы.
+
+**Миры.** В тексте #22 они названы «системами». По справочнику *система* — это целый тайл
+из четырёх областей, а область с планетой — *мир*. Дальше используется термин справочника.
+Размер поля и «честная доля» миров на игрока:
+
+| N | Поле | Тайлов | Миров на поле (×2.2) | Миров на игрока `W(N)/N` |
+|---|---|---|---|---|
+| 2 | 2×3 | 6 | 13.2 | 6.60 |
+| 3 | 3×3 | 9 | 19.8 | 6.60 |
+| 4 | 3×4 | 12 | 26.4 | 6.60 |
+| 5 | 4×4 | 16 | 35.2 | 7.04 |
+| 6 | 4×5 | 20 | 44.0 | 7.33 |
+
+## 3. Выбор модели
+
+Что нужно от модели:
+
+- учитывать силу соперников (треб. 3);
+- работать для столов на 2–6 игроков с ничьими и выбывшими;
+- принимать дополнительные признаки партии (треб. 1, 2, 4, 5);
+- считаться вручную — чтобы игроки могли проверить, почему рейтинг изменился именно так;
+- работать на малых данных: десятки игроков и сотни партий;
+- обходиться без внешних зависимостей: вся реализация — пара десятков строк.
+
+| Модель | Сила соперника | 2–6 игроков | Признаки партии | Ручной расчёт | Вывод |
+|---|---|---|---|---|---|
+| League Points (сейчас) | нет | да | только место | да | не выполняет треб. 1–5 |
+| Elo, парный | да | да, через пары | через множитель K | да | **база** |
+| Glicko-2 | да, плюс неопределённость | только через пары, как Elo; нужны рейтинговые периоды | нет | тяжело | сложность без выигрыша на наших объёмах |
+| TrueSkill / OpenSkill | да, плюс неопределённость | да, нативно | нет — только порядок мест | нет | не принимает отрыв без самодельных надстроек |
+
+Выбран **парный Elo с множителем отрыва**. Отрыв умножает K, а фактический результат пары
+остаётся 1/0.5/0. Можно было бы вшить отрыв в сам результат (например, близкая победа =
+0.6), но тогда фаворит, выигравший близко, *терял бы* рейтинг за победу. Множитель K
+сохраняет монотонность: победа всегда в плюс, отрыв влияет только на размер.
+
+## 4. Формулы
+
+### 4.1. Шкала
+
+Стартовый рейтинг **R₀ = 1500**, масштаб **D = 400**: разница 400 пунктов означает шансы 10:1.
+Это классическая шкала Elo (решение владельца, раздел 9).
+
+С нынешним топом (около 50) она не совпадает. Для сопоставления чисел в этом документе
+используется соответствие `R = 10·score + 1000`: 50 ↔ 1500, 60 ↔ 1600. Пример «60 против 40»
+из #22 — это 1600 против 1400. Формулы от выбора шкалы не зависят. Если пересчитать рейтинги
+по этому соответствию, а `D` и `K` умножить на 10, ожидания, порядок игроков и качество
+прогноза не изменятся — в 10 раз вырастут только изменения рейтинга и его разброс.
+`simulate.py` это проверяет: на одних и тех же сезонах обе шкалы дают одинаковые точность,
+Brier и ρ.
+
+### 4.2. Ожидаемый результат пары
+
+```math
+E_{ab} = \frac{1}{1 + 10^{(R_b - R_a)/D}}
+```
+
+`E_ab` — вероятность, что `a` окажется выше `b`. При 1600 против 1400 — 0.760, при равных — 0.500.
+
+### 4.3. Фактический результат пары
+
+`S_ab = 1`, если `a` занял место выше `b`; `0.5`, если места равны; `0` — если ниже.
+Выбывшие делят последнее место, как и сейчас (`match_service._resolve_finish_places`),
+но между собой не сравниваются (4.4).
+
+### 4.4. Изменение рейтинга
+
+```math
+\Delta R_i = \frac{K_i \cdot G(N)}{N-1} \sum_{j \ne i} M_{ij} \, (S_{ij} - E_{ij})
+```
+
+Все рейтинги в формуле — **до** партии. Деление на `N − 1` приводит сумму по соперникам
+к «средней дуэли», размер стола затем добавляется явно через `G(N)`.
+
+**Выбывшие между собой не сравниваются** (решение владельца, #91): если `i` и `j` оба
+выбыли, их пара в сумму не входит — ни `S − E`, ни множитель отрыва. В этой партии они
+все проиграли, то есть оказались одинаково слабы, а миров у выбывших нет. Пары выбывшего
+с невыбывшими, в том числе с победителем, считаются как обычно: сила соперников важна.
+Нормировка на `N − 1` не меняется, поэтому при равных рейтингах результат прежний — такая
+пара и раньше давала `S − E = 0`. Уходит только перекос, при котором слабый выбывший
+получал рейтинг за счёт сильных выбывших.
+
+### 4.5. Коэффициент K — скорость изменения
+
+```math
+K_i = K_{\min} + (K_{\max} - K_{\min}) \cdot \max\!\left(0,\; 1 - \frac{n_i}{n_K}\right)
+```
+
+`n_i` — сколько завершённых партий игрок сыграл до этой. Новичок стартует с `K_max = 64`,
+к 20-й партии K линейно спускается до `K_min = 16`. Так новичок быстро находит свой
+уровень, а рейтинг опытного игрока не скачет от одной партии.
+
+Эта схема заменяет нынешние «10 виртуальных партий». Минимум партий для топа
+(`MIN_GAMES = 10`) сохраняется. К 10-й партии предложенная система упорядочивает игроков
+лучше текущей: ρ 0.807 против 0.769 в сценарии «сигнал» (раздел 7).
+
+### 4.6. Вес размера стола (треб. 2)
+
+```math
+G(N) = 1 + w_N \cdot \frac{N-2}{4}, \qquad w_N = 0.5
+```
+
+`G` = 1.0 для дуэли, 1.25 для четверых, 1.5 для шестерых.
+
+### 4.7. Множитель отрыва пары
+
+Признаки пары (a — выше или наравне с b), каждый нормирован в [0, 1]:
+
+| Признак | Формула | Для каких пар | Типичное значение μ |
+|---|---|---|---|
+| темп `τ` (треб. 1) | `(R_max − раунд) / (R_max − 1)` | только пары с победителем | `1/(R_max − 1)` — конец в предпоследнем раунде |
+| отрыв по целям `o` (треб. 4) | `max(0, цели_a − цели_b) / N` | все | 0.5 |
+| отрыв по мирам `w` (треб. 4) | `min(1, max(0, миры_a − миры_b) / (W(N)/N))` | все | 0.5 |
+
+Для пар с равными местами разница берётся по модулю. При победе `last_standing` отрыв
+победителя по целям считается равным 1: все соперники устранены, сколько бы маркеров
+у них ни было.
+
+```math
+A_{ab} = 1 + w_\tau (\tau - \mu_\tau) + w_o (o - 0.5) + w_w (w - 0.5)
+```
+
+```math
+M_{ab} = \operatorname{clamp}(A_{ab},\; 0.5,\; 2.0) \cdot c_{ab}
+```
+
+- **Центрирование.** Благодаря вычитанию μ партия с типичными признаками получает `M = 1` —
+  то есть обычный Elo. Разгром поднимает множитель, близкая партия его снижает.
+- **Ограничение.** `clamp` ставит страховку: одна партия не может весить больше чем вдвое
+  или меньше чем вдвое против обычной.
+- **Близость по типу победы `c`** (треб. 5) действует только на пары с победителем: тип
+  победы описывает борьбу за первое место, а не за второе или третье.
+
+| `win_reason` | `objectives` | `worlds` | `plastic` | `resources` | `last_standing` |
+|---|---|---|---|---|---|
+| `c` | 1.00 | 0.85 | 0.70 | 0.60 | 1.00 |
+
+### 4.8. Партии без новых полей
+
+У партий из истории (и у любых, где поле не заполнено) нет раунда, целей или миров.
+Недостающий признак подставляется **типичным значением μ**: его слагаемое в `A` равно нулю.
+Тип победы в истории есть, поэтому близость `c` работает всегда. Для старой партии формула
+сводится к чистому Elo с учётом размера стола и типа победы. Заполнять историю задним числом
+не обязательно.
+
+### 4.9. Свойства
+
+- **Монотонность.** 1-е место без ничьей даёт `S − E > 0` во всех парах, а `M > 0` — значит,
+  рейтинг растёт. Последнее место без ничьей всегда уменьшает рейтинг. Выбывший — тоже:
+  его пары с выбывшими не считаются, а каждому невыбывшему он проиграл. Внутри ничьей
+  невыбывших `S = 0.5`, и знак `S − E` зависит от рейтингов: сильный игрок, поделивший
+  1-е место со слабым, может потерять.
+- **Сумма-ноль.** `M_ab = M_ba`, поэтому при равных K сумма изменений за партию равна нулю
+  и рейтинг не раздувается. Когда K разные (новичок и ветеран), сумма не нулевая —
+  это сделано намеренно (пример 7). В симуляции среднее по лиге за 300 партий сдвигается
+  не больше чем на 0.8 пункта, в сценарии «рост» — на −7 при разбросе силы игроков ±140.
+- **Ограниченность.** Изменение за партию не больше `K·G·2.0`: 32 у ветерана в дуэли,
+  128 у новичка в дуэли, 192 у новичка за столом на шестерых. Это теоретические пределы
+  для разгромной победы, которой почти никто не ждал (`E ≈ 0`); против равных — вдвое меньше.
+- **Детерминизм.** Рейтинг — функция упорядоченной истории партий. Пересчёт с нуля всегда
+  даёт тот же результат.
+
+### 4.10. Коэффициенты
+
+| Параметр | Значение | Откуда |
+|---|---|---|
+| `R₀`, `D` | 1500, 400 | шкала (4.1), решение владельца |
+| `K_max`, `K_min`, `n_K` | 64, 16, 20 | перебор (7.4): выигрыш на «сигнале» без потерь на «шуме» |
+| `w_N` (стол) | 0.5 | требование «слабее темпа»; в переборе 0.25–0.5 равноценны |
+| `w_τ` (темп) | 1.0 | требование 1 («значительно ценнее»); в переборе безопасен до 1.0, вред — с 2.0 |
+| `w_o` (цели) | 0.5 | требование 4; равен весу миров, пока нет данных, что один из признаков информативнее (7.4) |
+| `w_w` (миры) | 0.5 | требование 4; в переборе 0.5 — лучший вес единственного признака отрыва |
+| `c` (близость) | 1 / 0.85 / 0.7 / 0.6 / 1 | требование 5, экспертная оценка по порядку тай-брейков, **утверждена владельцем**; симуляция не подтверждает и не опровергает (7.5) |
+| `clamp` | [0.5, 2.0] | страховка от выбросов |
+
+## 5. Требования → решения
+
+| Требование из #22 | Механизм | Эффект (ветеран против равного, дуэль) |
+|---|---|---|
+| 1. Темп: 4 цели за 2 раунда ценнее, чем к концу 8-го | признак `τ`, вес 1.0 — самый большой из весов | победа на 3-м раунде +11.2, на 8-м +5.5 — **вдвое** (пример 2) |
+| 2. Размер стола, но слабее темпа | `G(N)`, вес 0.5 | 1-е место: дуэль +8.0, пятеро +11.0, шестеро +12.0 — **до ×1.5**, меньше, чем ×2 у темпа (примеры 3, 6) |
+| 3. Разница рейтингов с соперником | ожидание `E` | 1600 побеждает 1400: +3.8; 1400 побеждает 1600: +12.2 — **втрое** больше (пример 1) |
+| 4. Цели и миры на конец партии | признаки `o`, `w` | стол на 4: пары с выбывшими весят 1.25–1.5, пара лидеров — 0.7 (пример 5) |
+| 5. Тип победы | близость `c` | без деталей: по целям +8.0 → по мирам +6.8 → по пластику +5.6 → по ресурсам +4.8 (пример 4) |
+| Веса параметров (из треб. 2) | единый множитель `M` с весами | весь диапазон по отрыву: от +3.4 (самая близкая партия) до +16.0 (разгром) — **×4.7** (пример 4) |
+
+## 6. Примеры расчётов
+
+Все игроки опытные (40 партий, `K = 16`), если не сказано иное. Числа совпадают
+с выводом `simulate.py` — скрипт проверяет их через `assert`. Промежуточные значения
+здесь округлены. В приложении рейтинг показывается целым числом, а в расчёте хранится
+без округления (раздел 8).
+
+### Пример 1. Дуэль 1600 против 1400 (треб. 3)
+
+Партия из старой истории: только места и тип `objectives`, так что `M = 1`.
+
+- `E(A выше B) = 1 / (1 + 10^(−200/400)) = 1 / (1 + 0.316) = 0.760`.
+- **1a. Побеждает сильный A:** `ΔR_A = 16 · 1 · (1 − 0.760) = +3.84`, у B −3.84.
+- **1b. Побеждает слабый B:** `ΔR_B = 16 · 1 · (1 − 0.240) = +12.16`, у A −12.16.
+
+Неожиданная победа приносит втрое больше ожидаемой.
+
+### Пример 2. Быстрая и медленная победа (треб. 1)
+
+Равные (1500 и 1500), дуэль на поле 2×3, победа по целям 2:1, миры 5:4. Разница — только раунд.
+
+| | Раунд 3 (2a) | Раунд 8 (2b) |
+|---|---|---|
+| темп `τ = (8 − r)/7` | 0.714 | 0.000 |
+| `w_τ(τ − 1/7)` | +0.571 | −0.143 |
+| цели `o = 1/2` → `0.5·(0.5 − 0.5)` | 0 | 0 |
+| миры `w = 1/6.6 = 0.152` → `0.5·(0.152 − 0.5)` | −0.174 | −0.174 |
+| `A = M` | 1.397 | 0.683 |
+| `ΔR_A = 16 · M · (1 − 0.5)` | **+11.18** | **+5.46** |
+
+### Пример 3. Размер стола (треб. 2)
+
+Все по 1500, партии без деталей (`M = 1`).
+
+- **3a. Дуэль:** `ΔR_1 = 16 · 1 · 0.5 = +8.00`.
+- **3b. Стол на 5:** `G(5) = 1 + 0.5·3/4 = 1.375`, множитель перед суммой — `16·1.375/4 = 5.5`.
+
+| Место | Σ (S − E) по 4 соперникам | ΔR | Сейчас (League Points) |
+|---|---|---|---|
+| 1 | 4·0.5 = 2.0 | **+11.00** | 1.00 |
+| 2 | −0.5 + 3·0.5 = 1.0 | +5.50 | 0.75 |
+| 3 | 0 | 0.00 | 0.50 |
+| 4 | −1.0 | −5.50 | 0.25 |
+| 5 | −2.0 | −11.00 | 0.00 |
+
+### Пример 4. Тип победы и близость партии (треб. 5)
+
+Равные, дуэль.
+
+| Вариант | τ | o | w | A | c | M | ΔR победителя |
+|---|---|---|---|---|---|---|---|
+| по целям, без деталей (= 3a) | μ | μ | μ | 1.000 | 1.00 | 1.000 | +8.00 |
+| 4a: по мирам, без деталей | μ | μ | μ | 1.000 | 0.85 | 0.850 | +6.80 |
+| 4b: по пластику, без деталей | μ | μ | μ | 1.000 | 0.70 | 0.700 | +5.60 |
+| 4c: по ресурсам, без деталей | μ | μ | μ | 1.000 | 0.60 | 0.600 | +4.80 |
+| 4d: по мирам на 8-м раунде, цели 2:2, миры 6:5 | 0 | 0 | 0.152 | 0.433 → **0.5** | 0.85 | 0.425 | **+3.40** |
+| 4e: разгром — 3-й раунд, цели 2:0, миры 8:2 | 0.714 | 1 | 0.909 | 2.026 → **2.0** | 1.00 | 2.000 | **+16.00** |
+
+В 4d и 4e сработала страховка `clamp`.
+
+### Пример 5. Стол на 4 с выбывшими (треб. 4)
+
+Партия закончилась на 7-м раунде по целям. `G(4) = 1.25`, множитель перед суммой —
+`16·1.25/3 = 6.67`, честная доля миров — 6.6.
+
+| Игрок | Рейтинг | Место | Цели | Миры |
+|---|---|---|---|---|
+| A | 1550 | 1 | 4 | 8 |
+| B | 1500 | 2 | 3 | 7 |
+| C | 1480 | 3 (выбыл) | 1 | 0 |
+| D | 1450 | 3 (выбыл) | 0 | 0 |
+
+Темп `τ = 1/7` совпадает с типичным, его слагаемое равно 0.
+
+| Пара | S | E | o | w | A = M | M·(S − E) |
+|---|---|---|---|---|---|---|
+| A–B | 1 | 0.571 | 1/4 | 1/6.6 = 0.152 | 1 − 0.125 − 0.174 = **0.701** | 0.300 |
+| A–C | 1 | 0.599 | 3/4 | 1 | 1 + 0.125 + 0.25 = **1.375** | 0.551 |
+| A–D | 1 | 0.640 | 1 | 1 | 1 + 0.25 + 0.25 = **1.500** | 0.540 |
+| B–C | 1 | 0.529 | 2/4 | 1 | 1 + 0 + 0.25 = **1.250** | 0.589 |
+| B–D | 1 | 0.571 | 3/4 | 1 | **1.375** | 0.589 |
+| C–D | — | — | — | — | оба выбыли — пара не считается (4.4) | 0 |
+
+- `ΔR_A = 6.67 · (0.300 + 0.551 + 0.540)` = **+9.27**
+- `ΔR_B = 6.67 · (−0.300 + 0.589 + 0.589)` = **+5.85**
+- `ΔR_C = 6.67 · (−0.551 − 0.589)` = **−7.60**
+- `ΔR_D = 6.67 · (−0.540 − 0.589)` = **−7.53**
+
+Итого: A и B близки друг к другу по целям и мирам, поэтому эта пара весит 0.7. Отрыв обоих
+от выбывших огромный — эти пары весят 1.25–1.5. C и D между собой не сравниваются: оба
+проиграли всем невыбывшим. C теряет чуть больше, потому что от более сильного ждали большего.
+
+### Пример 6. Стол на 6 и хоумрул 9 раундов
+
+Все по 1500, партия закончилась **на 8-м раунде**, других деталей нет.
+`G(6) = 1.5`, множитель перед суммой — `16·1.5/5 = 4.8`.
+
+| | 6a: хоумрул включён, `R_max = 9` | 6b: хоумрул выключен, `R_max = 8` |
+|---|---|---|
+| темп `τ` | (9 − 8)/8 = 0.125 | (8 − 8)/7 = 0 |
+| типичный `μ_τ` | 1/8 = 0.125 | 1/7 = 0.143 |
+| `M` пар с победителем | 1.000 — обычная партия | 0.857 — затянутая |
+| ΔR по местам 1…6 | +12.00, +7.20, +2.40, −2.40, −7.20, −12.00 | +10.29, +7.54, +2.74, −2.06, −6.86, −11.66 |
+
+Конец на 8-м раунде при лимите 9 — это «предпоследний раунд», то есть типичная партия.
+При лимите 8 — затянутая партия, и победа весит меньше. Поэтому лимит раундов снимается
+в партию при её создании (раздел 8).
+
+### Пример 7. Новичок против ветерана
+
+Оба по 1500; A — новичок (0 партий, `K = 64`), B — 40 партий (`K = 16`). A побеждает.
+
+`ΔR_A = 64 · 0.5` = **+32**, `ΔR_B = 16 · (−0.5)` = **−8**.
+
+О силе новичка ещё ничего не известно, поэтому его рейтинг двигается быстро. Ветеран
+теряет как за обычное поражение от равного.
+
+## 7. Проверка на симуляции
+
+### 7.1. Модель лиги
+
+У настоящих партий пока нет раундов, целей и миров, поэтому система проверяется на
+синтетической лиге, где «истинная» сила игроков известна.
+
+| Параметр | Значение |
+|---|---|
+| Игроки | 12 со старта, ещё по 2 на 1/3 и 2/3 сезона; активность у каждого своя (0.5–1.5) |
+| Сезон | 300 партий; хоумрул 9 раундов включён в половине сезонов |
+| Размер стола | 2 — 45%, 3 — 25%, 4 — 20%, 5 — 7%, 6 — 3% |
+| Сила | `θ ~ N(0, 150)`; в шкале рейтинга ≈ ±140 |
+| Производительность в партии | `θ + N(0, 225)` — кубы, карты, ошибки; места — по производительности |
+| Детали партии | из отрыва производительности: раунд (чем больше отрыв, тем раньше конец), цели, миры, тип победы, выбывание. Получается 81% побед по целям, 10% по мирам, 4% по пластику, 1.4% по ресурсам, 3% последний выживший; чаще всего конец на 7–8 раунде |
+
+Сценарии:
+
+| Сценарий | Что проверяет |
+|---|---|
+| **сигнал** | базовый: отрыв связан с разницей сил |
+| **шум** | места те же, но величина отрыва случайна и с силой не связана — сколько система теряет, если признаки ничего не говорят |
+| **клубы** | три группы разной силы (−150 / 0 / +150), 90% партий внутри своей — умеет ли общий рейтинг «сшить» группы |
+| **рост** | новички стартуют слабее на 0–200 и догоняют с опытом (×1/e за 15 партий) — успевает ли рейтинг за ростом игрока |
+
+### 7.2. Метрики
+
+- **Точность** — доля пар без ничьих во второй половине сезона, где *до* партии рейтинг
+  выше у занявшего место выше. Потолок — тот же прогноз по истинной силе.
+- **Brier** — `(1 − E)²` по тем же парам, меньше — лучше. Показывает, насколько честны
+  сами вероятности; есть только у Elo-систем.
+- **ρ** — ранговая корреляция Спирмена рейтинга на конец сезона с истинной силой
+  (игроки с 10+ партиями).
+- **ρ@k** — то же сразу после k-й партии игрока: как быстро рейтинг «находит» игрока.
+- **RMSE** — ошибка рейтинга относительно истинной силы в пунктах шкалы.
+- **Наклон** — регрессия рейтинга на истинную силу: 1.0 — разброс честный, меньше —
+  рейтинги сжаты к середине.
+- **|ΔR|** — средний модуль изменения за партию у игроков с 20+ партиями (волатильность).
+  У League Points рейтинг в шкале 0–100, его |ΔR| приведён к шкале 1500 умножением на 10
+  (соответствие из 4.1).
+
+Сравнение идёт на одних и тех же сезонах (парные разности). Коэффициенты подбирались
+на других сезонах (7.4), так что это проверка вне выборки подбора.
+
+### 7.3. Результаты: 200 сезонов на сценарий
+
+«Без новых полей» — предложенная система на той же истории, но без раунда, целей и миров:
+так будет считаться история, накопленная до #23. Строки предложенной системы пересчитаны
+с правилом «выбывшие между собой не сравниваются» (#91). Оно сдвинуло метрики лишь
+в третьем знаке, у остальных систем цифры прежние.
+
+**Сигнал** (потолок точности 0.6843)
+
+| Система | Точность | Brier | ρ | ρ@5 | ρ@10 | ρ@20 | RMSE | Наклон | \|ΔR\| |
+|---|---|---|---|---|---|---|---|---|---|
+| League Points (сейчас) | 0.6683 | — | 0.913 | 0.660 | 0.769 | 0.854 | — | — | 6.91 |
+| Elo, чистый | 0.6691 | 0.2089 | 0.911 | 0.656 | 0.770 | 0.852 | 47.4 | 0.81 | 5.24 |
+| **Предложенная** | **0.6721** | **0.2077** | **0.929** | **0.712** | **0.807** | **0.881** | **41.9** | **0.95** | 5.95 |
+| Предложенная, без новых полей | 0.6701 | 0.2085 | 0.916 | 0.677 | 0.783 | 0.864 | 47.2 | 0.79 | 5.90 |
+
+**Клубы** (потолок 0.6308)
+
+| Система | Точность | Brier | ρ | ρ@5 | ρ@10 | ρ@20 | RMSE | Наклон | \|ΔR\| |
+|---|---|---|---|---|---|---|---|---|---|
+| League Points (сейчас) | 0.6045 | — | 0.525 | 0.303 | 0.391 | 0.463 | — | — | 8.06 |
+| Elo, чистый | 0.6063 | 0.2341 | 0.632 | 0.326 | 0.440 | 0.535 | 102.6 | 0.40 | 5.71 |
+| **Предложенная** | **0.6101** | 0.2336 | **0.645** | **0.356** | **0.463** | **0.555** | **100.3** | **0.47** | 6.53 |
+| Предложенная, без новых полей | 0.6073 | **0.2332** | 0.633 | 0.336 | 0.440 | 0.535 | 103.3 | 0.38 | 6.41 |
+
+**Рост** (потолок 0.6864)
+
+| Система | Точность | Brier | ρ | ρ@5 | ρ@10 | ρ@20 | RMSE | Наклон | \|ΔR\| |
+|---|---|---|---|---|---|---|---|---|---|
+| League Points (сейчас) | 0.6688 | — | 0.915 | 0.631 | 0.732 | 0.824 | — | — | 6.91 |
+| Elo, чистый | 0.6687 | 0.2086 | 0.916 | 0.632 | 0.733 | 0.825 | 48.0 | 0.81 | 5.25 |
+| **Предложенная** | **0.6726** | **0.2076** | **0.929** | **0.685** | **0.775** | **0.850** | **42.7** | **0.95** | 5.96 |
+| Предложенная, без новых полей | 0.6697 | 0.2081 | 0.922 | 0.651 | 0.750 | 0.835 | 47.5 | 0.79 | 5.91 |
+
+**Шум** (потолок 0.6894)
+
+| Система | Точность | Brier | ρ | ρ@5 | ρ@10 | ρ@20 | RMSE | Наклон | \|ΔR\| |
+|---|---|---|---|---|---|---|---|---|---|
+| League Points (сейчас) | 0.6737 | — | 0.916 | 0.656 | 0.761 | 0.848 | — | — | 6.89 |
+| Elo, чистый | 0.6739 | **0.2070** | 0.917 | 0.659 | 0.765 | 0.851 | **46.1** | **0.82** | 5.23 |
+| Предложенная | 0.6728 | 0.2076 | 0.908 | 0.643 | 0.750 | 0.844 | 48.5 | 0.81 | 5.91 |
+| Предложенная, без новых полей | **0.6744** | **0.2070** | **0.919** | **0.667** | **0.776** | **0.856** | 47.3 | 0.78 | 5.88 |
+
+Парные разности (среднее ± стандартная ошибка по 200 сезонам):
+
+| Сценарий | Brier: предложенная − чистый Elo | Точность: предложенная − чистый Elo | Точность: предложенная − сейчас |
+|---|---|---|---|
+| сигнал | −0.0011 ± 0.0001 | +0.30 ± 0.06 п.п. | +0.38 ± 0.07 п.п. |
+| клубы | −0.0005 ± 0.0002 | +0.38 ± 0.08 п.п. | +0.56 ± 0.10 п.п. |
+| рост | −0.0010 ± 0.0001 | +0.39 ± 0.06 п.п. | +0.38 ± 0.06 п.п. |
+| шум | +0.0006 ± 0.0001 | −0.12 ± 0.06 п.п. | −0.10 ± 0.07 п.п. |
+
+Выводы:
+
+1. **Если отрыв отражает силу** (а требования #22 исходят именно из этого), предложенная
+   система лучше обеих альтернатив по всем метрикам качества. Сильнее всего она выигрывает
+   в скорости: после 5 партий ρ = 0.71 против 0.66 у текущей, после 10 — 0.81 против 0.77.
+   Рейтинг меньше сжат к середине (наклон 0.95 против 0.81): сильные игроки быстрее
+   отрываются от середняков.
+2. **Сила соперников — главное преимущество Elo над текущей системой.** В «клубах» текущая
+   система упорядочивает игроков заметно хуже (ρ 0.525 против 0.645): чемпион слабой группы
+   у неё стоит рядом с чемпионом сильной.
+3. **Если отрыв — шум**, предложенная система теряет 0.1 п.п. точности и 0.0006 Brier —
+   цена лишней волатильности. Это худший из рассмотренных случаев: в остальных сценариях
+   она чистому Elo не уступает.
+4. **История без новых полей** считается как чистый Elo с учётом стола и типа победы.
+   По точности и Brier она не хуже чистого Elo ни в одном сценарии.
+5. **Абсолютные разности точности малы** (доли процента), потому что партия Forbidden Stars
+   сама по себе сильно случайна: даже знание истинной силы угадывает порядок пары лишь
+   в 68% случаев. Все системы близки к этому потолку. Качество рейтинга лучше видно
+   по ρ@k и RMSE, чем по точности.
+
+### 7.4. Подбор коэффициентов
+
+`simulate.py --grid` перебирает коэффициенты на **других** 40 сезонах каждого сценария.
+Критерий — средний Brier, меньше — лучше. Разница в 0.0001 — примерно граница шума.
+Перебор выполнен до правила «выбывшие между собой не сравниваются» (#91) и не
+переигрывался: правило сдвигает метрики лишь в третьем знаке (7.3).
+
+**Этап 1. K чистого Elo** (все четыре сценария). Спуск K за 20 партий лучше, чем за 10.
+Выгоден высокий K новичка и низкий K ветерана.
+
+| `K_max` \ `K_min` (спуск за 20 партий) | 16 | 24 | 32 |
+|---|---|---|---|
+| 48 | 0.21697 | 0.21708 | 0.21775 |
+| 64 | 0.21649 | 0.21675 | 0.21751 |
+| 96 | **0.21639** | 0.21669 | 0.21747 |
+| 128 | 0.21682 | 0.21703 | 0.21775 |
+| 160 | 0.21748 | 0.21755 | 0.21819 |
+
+Лучший вариант со спуском за 10 партий — 0.21676 (96 / 24). Для «чистого Elo»
+в сравнении 7.3 взяты K = 96 / 16 / 20. Чистый Elo не использует миры, поэтому поле 2×3
+на этот этап не повлияло.
+
+**Этап 2. Веса отрыва** при K этапа 1: 162 комбинации (`w_N` ∈ {0, 0.25, 0.5};
+`w_τ`, `w_o`, `w_w` ∈ {0, 0.5, 1}; близость да/нет); сценарии «сигнал», «клубы», «рост».
+
+Без множителя (чистый Elo с K этапа 1): Brier **0.21846**, на «шуме» **0.21017**.
+Лучшие комбинации:
+
+| Brier | Brier «шум» | `w_N` | `w_τ` | `w_o` | `w_w` | близость |
+|---|---|---|---|---|---|---|
+| 0.21797 | 0.20991 | 0.25 | 0 | 0 | 0.5 | да |
+| 0.21801 | 0.20985 | 0.5 | 0 | 0 | 0.5 | да |
+| 0.21802 | 0.21009 | 0 | 0 | 0 | 0.5 | да |
+| 0.21804 | 0.21005 | 0.25 | 0.5 | 0 | 0.5 | да |
+| 0.21804 | 0.20994 | 0.25 | 0 | 0 | 0.5 | нет |
+| … | | | | | | |
+| 0.21995 | | | | | | худшая комбинация |
+
+Лучшие комбинации выигрывают у отсутствия множителя около 0.0005, худшая проигрывает
+0.0015. Оптимум очень пологий: первые десять вариантов умещаются в 0.0001.
+
+Перебор оставляет **один** признак отрыва из трёх. Это ожидаемо: в генераторе раунд, цели
+и миры выводятся из одного и того же отрыва производительности, второй признак не добавляет
+информации и лишь увеличивает разброс.
+Реальная игра так не устроена: в ней ранний конец, счёт целей и контроль миров — разные
+стороны партии. Поэтому веса признаков заданы требованиями #22 в пределах безопасной
+зоны (этап 4), а не взяты из вершины перебора.
+
+**Этап 3. K для предложенных весов.** Множитель в среднем чуть больше 1, поэтому K нужен
+меньше, чем у чистого Elo. Спуск за 20 партий:
+
+| `K_max` | `K_min` | Brier (сигнальные) | Brier «шум» | Brier с поправкой на автокорреляцию |
+|---|---|---|---|---|
+| 48 | 12 | **0.21759** | 0.21063 | 0.21755 |
+| 48 | 16 | 0.21778 | 0.21049 | 0.21773 |
+| 64 | 12 | 0.21779 | 0.21026 | 0.21771 |
+| **64** | **16** | 0.21797 | **0.21022** | 0.21788 |
+| 80 | 16 | 0.21838 | 0.21028 | 0.21826 |
+
+- **Выбор 64 / 16.** Против чистого Elo он даёт −0.00049 на сигнальных сценариях и
+  +0.00005 на «шуме». Вариант 48 / 12 выигрывает больше (−0.00087), но на «шуме»
+  проигрывает +0.00046. Выбран вариант, который не теряет, если гипотеза ТЗ о значении
+  отрыва не подтвердится.
+- **Поправка на автокорреляцию** (FiveThirtyEight: фаворит закономерно побеждает с большим
+  отрывом, и без поправки его рейтинг раздувается) даёт около 0.0001. В формулу она не
+  включена: лишняя сложность для ручного расчёта при нулевом эффекте.
+
+**Этап 4. Чувствительность.** Меняется один параметр, остальные — как в предложении
+(Brier 0.21797, «шум» 0.21022). ρ@10 здесь — среднее по трём сценариям, включая «клубы»,
+поэтому оно ниже, чем в 7.3.
+
+| Параметр | Значение | Brier (сигнальные) | ρ@10 | Brier «шум» |
+|---|---|---|---|---|
+| `w_N` | 0 / 0.25 / **0.5** / 1.0 | 0.21803 / 0.21796 / **0.21797** / 0.21819 | 0.663 / 0.668 / **0.674** / 0.680 | 0.21072 / 0.21041 / **0.21022** / 0.21011 |
+| `w_τ` | 0 / 0.25 / 0.5 / **1.0** / 2.0 | 0.21771 / 0.21775 / 0.21781 / **0.21797** / 0.21826 | 0.672 / 0.672 / 0.673 / **0.674** / 0.667 | 0.20988 / 0.20995 / 0.21003 / **0.21022** / 0.21050 |
+| `w_o` | 0 / 0.25 / **0.5** / 1.0 / 2.0 | 0.21767 / 0.21778 / **0.21797** / 0.21838 / 0.21892 | 0.666 / 0.668 / **0.674** / 0.674 / 0.671 | 0.21003 / 0.21010 / **0.21022** / 0.21042 / 0.21073 |
+| `w_w` | 0 / 0.25 / **0.5** / 1.0 / 2.0 | 0.21781 / 0.21785 / **0.21797** / 0.21827 / 0.21873 | 0.667 / 0.671 / **0.674** / 0.673 / 0.669 | 0.21003 / 0.21011 / **0.21022** / 0.21037 / 0.21054 |
+| `c` | нет / **предложенная** / вдвое сильнее | 0.21799 / **0.21797** / 0.21799 | 0.673 / **0.674** / 0.672 | 0.21016 / **0.21022** / 0.21031 |
+
+Итог:
+
+- Веса в диапазоне 0–1 безопасны: изменение вдвое сдвигает Brier не больше чем на 0.00041
+  (`w_o` 0.5 → 1.0). Вред начинается с 2.0 — поэтому ни один вес не выше 1.
+- Вес размера стола полезен: от 0 до 0.5 растёт ρ@10 и падает Brier на «шуме».
+- Близость по типу победы в симуляции нейтральна (±0.00002).
+
+### 7.5. Что симуляция доказывает и что нет
+
+- **Доказывает:** формулы корректны и устойчивы, не раздувают рейтинг, быстро сходятся,
+  правильно «сшивают» группы разной силы. Выбранные веса лежат в пологой области: изменение
+  любого веса вдвое в любую сторону сдвигает Brier не больше чем на 0.00041. Если признаки
+  партии окажутся бесполезны, потеря мала.
+- **Не доказывает:**
+  - что в *реальных* партиях Forbidden Stars ранний конец, отрыв по целям и мирам связаны
+    с разницей сил так, как заложено в генераторе. Это допущение, на котором стоит и само
+    ТЗ;
+  - какой из признаков отрыва (раунд, цели, миры) информативнее: в генераторе все три
+    выводятся из одного отрыва и дублируют друг друга.
+  
+  Проверить это можно только на реальных данных после внедрения #23 (раздел 8,
+  «Калибровка»).
+- **Коэффициенты близости `c`** симуляция не подтверждает и не опровергает: при записанных
+  целях и мирах тип победы почти не добавляет информации. Значения — экспертная оценка
+  по порядку тай-брейков. Их главная роль — старые партии, где тип победы — единственный
+  признак хода игры.
+
+## 8. Что потребуется в реализации (#23)
+
+Изменение **ломающее** (`Compat/Breaking`): у всех игроков меняются числа рейтинга и,
+вероятно, порядок в топе.
+
+### Данные (миграция `0014_*`)
+
+| Где | Поле | Тип | Смысл |
+|---|---|---|---|
+| `groups` | `nine_rounds_rule` | bool, default false | галочка «9 раундов при 5–6 игроках» |
+| `matches` | `nine_rounds_rule` | bool, default false | **снимок** настройки группы при создании партии: смена настройки не должна переписывать историю (пример 6) |
+| `matches` | `end_round` | int NULL, `1 ≤ end_round ≤ R_max` | раунд, в котором партия закончилась |
+| `match_participants` | `objectives` | int NULL, ≥ 0 | маркеры целей на конец партии |
+| `match_participants` | `worlds` | int NULL, ≥ 0 | дружественные миры на конец партии; у выбывшего 0 |
+| `matches.win_reason` | + `last_standing` | CHECK | новая причина победы (раздел 9) |
+
+`R_max` в партии не хранится, а вычисляется: `9`, если `nine_rounds_rule` и `N ≥ 5`, иначе `8`.
+Число участников может поменяться при правке партии, а снимок правила — нет.
+
+Миграция идемпотентна, как `0003`: ALTER только при отсутствии столбца, `render_as_batch`
+для CHECK. Новые столбцы задним числом не заполняются: NULL — это «нет данных», и формулы
+его учитывают (4.8).
+
+**Бэкфилл нужен только для `last_standing`.** У завершённых партий, где невыбывший участник
+ровно один, миграция ставит `win_reason = last_standing`. Тогда старые партии не нарушают
+правило из раздела «Ввод» при правке, а в рейтинге считаются так же, как новые: отрыв
+победителя по целям = 1 (4.7). Бэкфилл идемпотентен: повторный запуск ничего не меняет.
+
+### Ввод
+
+- Форма завершения (`MatchDetailPage`, `match_service.finish_match`, черновик
+  `MatchFinishDraft`) и админская правка (`AdminMatchEdit`): раунд окончания и у каждого
+  участника цели и миры. Поля необязательные — пропуск лучше выдумки.
+- Серверная валидация — только диапазоны и явные противоречия: у выбывшего миры = 0;
+  раунд ≤ `R_max`. Подсказки о согласованности (тип `worlds` при неравных целях лидеров
+  и т.п.) лучше показывать предупреждением, а не отказом.
+- Настройки группы: галочка рядом с дополнениями (`PUT /groups/{id}/expansions` или
+  отдельный `PATCH`).
+- **Причина `last_standing`** (решение владельца):
+  - правило — «невыбывший участник ровно один» ⇔ `win_reason = last_standing`;
+  - в форме завершения и в админской правке причина проставляется автоматически, как только
+    все участники, кроме одного, отмечены выбывшими. Выбор причины при этом заблокирован;
+  - вернули второго невыбывшего — причина сбрасывается, её нужно выбрать заново;
+  - в выпадающем списке причин `last_standing` нет: выбрать её вручную нельзя;
+  - сервер проверяет то же правило в `finish_match` и при правке результатов: несовпадение —
+    ошибка валидации. Черновик формы (`PUT /matches/{id}/finish-draft`) правило не проверяет,
+    он хранит незаконченный ввод.
+
+### Отображение
+
+- Рейтинг показывается **целым числом**; в расчёте значения хранятся без округления, иначе
+  ошибка округления накапливается по цепочке партий.
+- Общий топ (`OverallStatsPage.tsx`): столбец «Поб» и сортировка по победам убираются, чтобы
+  четырёхзначный рейтинг поместился в строку; «Очки» переименовываются в «Рейтинг».
+  Для единообразия — «Очки (рейтинг)» в `ProfileStatsCard.tsx` и заголовок «Очки игроков
+  (рейтинг)» в `HelpPage.tsx`.
+- Подпись причины `last_standing` в карточке партии и истории — «последний выживший».
+
+### Расчёт
+
+- Рейтинг — функция упорядоченной истории, поэтому он **пересчитывается проигрыванием**
+  завершённых партий по порядку (`played_at`, `finished_at`, `id`), а не агрегатом SQL.
+  Данных мало: сотни партий, микросекунды на пару. Существующий принцип «считается вживую»
+  сохраняется, кэш можно ввести позже с инвалидацией по уже существующим SSE-событиям.
+- **Одна цепочка** (решение владельца 2026-09-15, #80): рейтинг у игрока один — по всем
+  партиям приложения, K — по всем его партиям. Отдельного группового рейтинга нет:
+  на странице группы игры, победы, винрейт и среднее место считаются по партиям группы,
+  а рейтинг и статус «Новичок» — общие. Первая версия реализации (#23) держала две
+  цепочки, общую и групповую, — это оказалось неинтуитивно (раздел 9).
+- Правка или удаление прошлой партии автоматически меняет всё после неё: при пересчёте
+  с нуля отдельной логики не нужно.
+- Эталон — `rate_match` в `simulate.py`. Примеры из раздела 6 стоит перенести в тесты
+  бэкенда как есть.
+- Смежные метрики на старых очках места:
+  - «лучшая партия» в профиле (`user_match_list(best_only)`) → партия с наибольшим ΔR;
+  - «лучшая/худшая фракция» → средний `S − E` на фракции: насколько игрок на ней
+    выступает выше ожидания, без привязки к рейтингу;
+  - `win_rate`, `avg_place`, «форма» — без изменений.
+
+### Что ломается для пользователей
+
+- Числа рейтинга у всех меняются: шкала другая (около 1500 вместо около 50), и это другая
+  величина — не «средний процент очков», а сила относительно соперников.
+- Порядок в топе может измениться — в первую очередь у тех, кто играл в основном со слабыми
+  или сильными соперниками.
+- Рейтинг новичка после одной партии меняется заметно сильнее, чем раньше: +32 за обычную
+  победу над равным, до +64 за разгром (теоретический предел — 128).
+- В общем топе пропадает столбец побед (win rate остаётся).
+- **Предложение:** разовое уведомление всем игрокам и короткое пояснение «как считается
+  рейтинг» на странице топа.
+
+### Калибровка после внедрения
+
+Когда наберётся ~100 партий с заполненными раундом, целями и мирами:
+
+- типичные значения `μ` заменить средними по реальным партиям;
+- повторить перебор весов из `simulate.py` на реальной истории: критерий — Brier прогноза
+  следующей партии;
+- проверить главное допущение: есть ли у ранних побед и большого отрыва связь с последующими
+  результатами игроков.
+
+Коэффициенты — константы в одном модуле (как сейчас `scoring.py`): калибровка — это правка
+констант и пересчёт, без миграций.
+
+### Справка
+
+Формула текущего рейтинга и пороги продублированы текстом на странице справки
+(`frontend/src/pages/HelpPage.tsx`). При реализации #23 её нужно переписать под новую
+систему: шкала, от чего зависит изменение рейтинга, `MIN_GAMES`, причина `last_standing`.
+
+## 9. Решения владельца
+
+Первая версия документа выносила шесть вопросов на решение. Ответы владельца —
+[комментарий к PR #65](https://gitea.arseniev.info/NotBigGhost/ForbiddenStarsApp/pulls/65#issuecomment-3466)
+(2026-09-14). Там же и в [#22](https://gitea.arseniev.info/NotBigGhost/ForbiddenStarsApp/issues/22#issuecomment-3380)
+уточнено поле дуэли: 2×3, а не 2×2 — исправлено в разделе 2, примерах и симуляции.
+
+| # | Вопрос | Решение | Что изменилось в документе |
+|---|---|---|---|
+| 1 | Шкала отображения: «Elo/10» (старт 50) или классические 1500 | **1500.** В общем топе убрать столбец побед, «Очки» переименовать в «Рейтинг» | 4.1 и все числа примеров и таблиц; раздел 8, «Отображение» |
+| 2 | Коэффициенты близости по типам победы (1 / 0.85 / 0.7 / 0.6 / 1) | **Согласованы** | 4.10 — отмечены как утверждённые |
+| 3 | Новая причина победы `last_standing` | **Добавить.** Ставится автоматически, когда невыбывший ровно один, и не меняется, пока невыбывших меньше двух; в списке выбора её нет | раздел 2; раздел 8 — «Данные» (бэкфилл) и «Ввод» |
+| 4 | Ввод миров на конец партии | **Оставить** | без изменений: `w_w = 0.5` |
+| 5 | Затухание за неактивность | **Не добавлять** | без изменений |
+| 6 | Минимум партий для топа | **Оставить 10** | без изменений: `MIN_GAMES = 10` |
+| 7 | Групповой рейтинг отдельной цепочкой (после внедрения, #80, 2026-09-15) | **Убрать.** Рейтинг единый; на странице группы — показатели по партиям группы, на главной и в профиле — общие | раздел 8, «Расчёт» |
+| 8 | Сравнивать ли выбывших между собой (после ревью, #87 → #91, 2026-09-18) | **Нет.** Все они проиграли и одинаково слабы в этой партии, миров у них нет; при расчёте победителя сила соперников по-прежнему важна | 4.3, 4.4, 4.9, пример 5, итоги 7.3 (подбор 7.4 не переигрывался) |
+
+Открытых вопросов по предложению не осталось. Калибровка коэффициентов на реальных данных —
+после внедрения #23 (раздел 8, «Калибровка»).

docs/rating/simulate.py

@@ -0,0 +1,868 @@
+#!/usr/bin/env python3
+"""Эталонная реализация и симуляция предложенной рейтинговой системы (#22).
+
+Скрипт — приложение к docs/rating/rating-system.md:
+
+1. Формулы документа в коде (раздел «Эталонная реализация»). #23 может сверять
+   с ними свою реализацию.
+2. Пошаговые примеры документа с assert на числа: документ и код не разъедутся.
+   Плюс проверка, что шкала (1500 или прежние 50) не влияет на качество прогноза.
+3. Синтетическая лига: игроки со скрытой «истинной» силой, партии на 2–6 человек.
+   Детали партии (раунд, цели, миры, тип победы) выводятся из отрыва
+   по производительности. На одних и тех же партиях сравниваются текущий League
+   Points, чистый парный Elo и предложенная система.
+4. Перебор весов (--grid).
+
+Только стандартная библиотека и фиксированные seed — вывод воспроизводим.
+
+    python docs/rating/simulate.py             # примеры + сравнение систем (≈1.5 мин)
+    python docs/rating/simulate.py --grid      # примеры + перебор K и весов (≈7 мин)
+"""
+from __future__ import annotations
+
+import argparse
+import math
+import random
+import statistics
+import sys
+from dataclasses import dataclass, replace
+from itertools import combinations
+
+# ═══ Правила игры ═══════════════════════════════════════════════════════════════
+
+# Размер поля в тайлах по числу игроков (дуэль — 2×3, 6 игроков — 4×5; уточнения владельца в #22).
+BOARD_TILES = {2: 6, 3: 9, 4: 12, 5: 16, 6: 20}
+WORLDS_PER_TILE = 2.2
+BASE_ROUNDS = 8
+# Хоумрул группы: при 5–6 игроках играется 9 раундов.
+EXTENDED_ROUNDS = 9
+EXTENDED_MIN_PLAYERS = 5
+
+
+def worlds_on_board(n: int) -> float:
+    return BOARD_TILES[n] * WORLDS_PER_TILE
+
+
+def fair_worlds(n: int) -> float:
+    """«Честная доля» миров на игрока — масштаб для разницы миров."""
+    return worlds_on_board(n) / n
+
+
+def max_rounds(n: int, nine_rounds: bool) -> int:
+    return EXTENDED_ROUNDS if nine_rounds and n >= EXTENDED_MIN_PLAYERS else BASE_ROUNDS
+
+
+# ═══ Эталонная реализация ═════════════════════════════════════════════════════
+
+
+@dataclass
+class Seat:
+    player: str
+    place: int
+    objectives: int | None = None  # маркеры целей на конец партии
+    worlds: int | None = None  # дружественные миры на конец партии
+    eliminated: bool = False
+
+
+@dataclass
+class Match:
+    seats: list[Seat]
+    win_reason: str | None = None
+    round: int | None = None  # раунд, в котором партия закончилась
+    nine_rounds: bool = False  # снимок настройки группы на момент партии
+
+
+@dataclass(frozen=True)
+class Params:
+    # Классическая шкала Elo (решение владельца в PR #65): старт 1500, разница 400 = шансы 10:1.
+    r0: float = 1500.0  # стартовый рейтинг
+    d: float = 400.0  # масштаб логистики
+    k_max: float = 64.0  # K новичка (0 партий)
+    k_min: float = 16.0  # K опытного игрока
+    k_games: int = 20  # за сколько партий K линейно спускается от k_max к k_min
+    w_table: float = 0.0  # вес размера стола (треб. 2)
+    w_tempo: float = 0.0  # вес темпа победы (треб. 1)
+    w_obj: float = 0.0  # вес разницы целей (треб. 4)
+    w_worlds: float = 0.0  # вес разницы миров (треб. 4)
+    # Близость партии по типу победы (треб. 5) — множитель пар с победителем.
+    closeness: tuple[tuple[str, float], ...] = ()
+    # «Типичные» значения признаков: партия с ними получает множитель 1,
+    # отсутствующий признак подставляется типичным (= нейтральным).
+    mu_obj: float = 0.5
+    mu_worlds: float = 0.5
+    m_min: float = 0.5
+    m_max: float = 2.0
+    autocorr: bool = False  # поправка на автокорреляцию (см. документ)
+    # Выбывшие между собой не сравниваются: пара двух выбывших не входит в сумму
+    # (решение владельца, #91). У систем для сравнения — как было.
+    skip_eliminated_pairs: bool = False
+
+    def closeness_for(self, reason: str | None) -> float:
+        return dict(self.closeness).get(reason, 1.0) if reason else 1.0
+
+
+def mu_tempo(rmax: int) -> float:
+    """Типичный темп: партия закончилась в предпоследнем раунде."""
+    return 1.0 / (rmax - 1)
+
+
+def expected(r_a: float, r_b: float, d: float) -> float:
+    """Ожидаемый результат a против b (вероятность, что a окажется выше)."""
+    return 1.0 / (1.0 + 10.0 ** ((r_b - r_a) / d))
+
+
+def k_factor(games: int, p: Params) -> float:
+    left = max(0.0, 1.0 - games / p.k_games)
+    return p.k_min + (p.k_max - p.k_min) * left
+
+
+def table_weight(n: int, p: Params) -> float:
+    return 1.0 + p.w_table * (n - 2) / 4.0
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, x))
+
+
+def pair_multiplier(
+    m: Match, a: Seat, b: Seat, r_a: float, r_b: float, p: Params
+) -> tuple[float, dict]:
+    """Множитель отрыва пары; a — выше или наравне с b. Возвращает (M, разбор)."""
+    n = len(m.seats)
+    tie = a.place == b.place
+    winner_pair = a.place == 1
+    parts: dict[str, float] = {}
+    add = 1.0
+
+    def diff(x: int, y: int) -> float:
+        return abs(x - y) if tie else max(0, x - y)
+
+    if winner_pair:
+        rmax = max_rounds(n, m.nine_rounds)
+        mu = mu_tempo(rmax)
+        tempo = mu if m.round is None else (rmax - m.round) / (rmax - 1)
+        parts["tempo"] = tempo
+        add += p.w_tempo * (tempo - mu)
+    if winner_pair and m.win_reason == "last_standing":
+        obj = 1.0  # все соперники устранены — отрыв максимальный, сколько бы ни было маркеров
+    elif a.objectives is not None and b.objectives is not None:
+        obj = _clamp(diff(a.objectives, b.objectives) / n, 0.0, 1.0)
+    else:
+        obj = p.mu_obj
+    parts["obj"] = obj
+    add += p.w_obj * (obj - p.mu_obj)
+    if a.worlds is not None and b.worlds is not None:
+        wor = _clamp(diff(a.worlds, b.worlds) / fair_worlds(n), 0.0, 1.0)
+    else:
+        wor = p.mu_worlds
+    parts["worlds"] = wor
+    add += p.w_worlds * (wor - p.mu_worlds)
+
+    if p.autocorr and add > 1.0 and not tie:
+        # Поправка FiveThirtyEight: 2.2 / (0.001·ΔElo + 2.2).
+        kappa = 2.2 / (0.001 * (r_a - r_b) + 2.2)
+        parts["kappa"] = kappa
+        add = 1.0 + (add - 1.0) * kappa
+    parts["additive"] = add
+    mult = _clamp(add, p.m_min, p.m_max)
+    close = p.closeness_for(m.win_reason) if winner_pair else 1.0
+    parts["closeness"] = close
+    return mult * close, parts
+
+
+def rate_match(
+    ratings: dict[str, float],
+    games: dict[str, int],
+    m: Match,
+    p: Params,
+    trace: list | None = None,
+) -> dict[str, float]:
+    """Изменения рейтинга участников партии. Рейтинги/счётчики не мутирует."""
+    n = len(m.seats)
+    g = table_weight(n, p)
+    r = {s.player: ratings.get(s.player, p.r0) for s in m.seats}
+    k = {s.player: k_factor(games.get(s.player, 0), p) for s in m.seats}
+    delta = {s.player: 0.0 for s in m.seats}
+    for a, b in combinations(m.seats, 2):
+        if p.skip_eliminated_pairs and a.eliminated and b.eliminated:
+            continue
+        if a.place > b.place:
+            a, b = b, a
+        s_ab = 0.5 if a.place == b.place else 1.0
+        e_ab = expected(r[a.player], r[b.player], p.d)
+        mult, parts = pair_multiplier(m, a, b, r[a.player], r[b.player], p)
+        x = mult * (s_ab - e_ab)
+        delta[a.player] += k[a.player] * g / (n - 1) * x
+        delta[b.player] -= k[b.player] * g / (n - 1) * x
+        if trace is not None:
+            trace.append(
+                {"a": a.player, "b": b.player, "S": s_ab, "E": e_ab, "M": mult, **parts}
+            )
+    return delta
+
+
+# ═══ Системы для сравнения ════════════════════════════════════════════════════
+
+
+class LeaguePoints:
+    """Текущая система (backend/app/services/scoring.py): сглаженное среднее очков за место."""
+
+    probabilistic = False
+    # Рейтинг в шкале 0–100; |ΔR| сравнивается с Elo в пересчёте R_Elo = 10·score + 1000.
+    move_scale = 10.0
+    PRIOR_GAMES = 10
+    PRIOR_MEAN = 0.5
+
+    def __init__(self) -> None:
+        self.sum: dict[str, float] = {}
+        self.games: dict[str, int] = {}
+
+    def rating(self, player: str) -> float:
+        g = self.games.get(player, 0)
+        return (self.PRIOR_GAMES * self.PRIOR_MEAN + self.sum.get(player, 0.0)) / (
+            self.PRIOR_GAMES + g
+        ) * 100
+
+    def update(self, m: Match) -> dict[str, float]:
+        n = len(m.seats)
+        tie = {}
+        for s in m.seats:
+            tie[s.place] = tie.get(s.place, 0) + 1
+        before = {s.player: self.rating(s.player) for s in m.seats}
+        for s in m.seats:
+            pts = (n - s.place - (tie[s.place] - 1) / 2) / (n - 1)
+            self.sum[s.player] = self.sum.get(s.player, 0.0) + pts
+            self.games[s.player] = self.games.get(s.player, 0) + 1
+        return {s.player: self.rating(s.player) - before[s.player] for s in m.seats}
+
+
+class Elo:
+    """Парный многопользовательский Elo; с нулевыми весами — «чистый» Elo."""
+
+    probabilistic = True
+    move_scale = 1.0
+
+    def __init__(self, p: Params) -> None:
+        self.p = p
+        self.r: dict[str, float] = {}
+        self.games: dict[str, int] = {}
+
+    def rating(self, player: str) -> float:
+        return self.r.get(player, self.p.r0)
+
+    def update(self, m: Match) -> dict[str, float]:
+        delta = rate_match(self.r, self.games, m, self.p)
+        for pl, dv in delta.items():
+            self.r[pl] = self.rating(pl) + dv
+            self.games[pl] = self.games.get(pl, 0) + 1
+        return delta
+
+
+# ═══ Генератор синтетической лиги ═════════════════════════════════════════════
+
+SIGMA_SKILL = 150.0  # разброс «истинной» силы игроков
+SIGMA_PERF = 225.0  # шум производительности в отдельной партии (кубы, карты, ошибки)
+# Истинная сила в шкале рейтинга: Φ(Δθ/(σ√2)) ≈ логистика с масштабом d=400 при ΔR ≈ 0.93·Δθ.
+SKILL_TO_RATING = 1.702 * 400 / (math.log(10) * SIGMA_PERF * math.sqrt(2))
+TABLE_SIZES = ((2, 0.45), (3, 0.25), (4, 0.20), (5, 0.07), (6, 0.03))
+ELIM_Z = 2.3  # отставание (в σ), при котором игрок может выбыть
+ELIM_P = 0.35  # вероятность выбывания при таком отставании
+
+
+def _choice_weighted(rng: random.Random, pairs) -> int:
+    x = rng.random() * sum(w for _, w in pairs)
+    for v, w in pairs:
+        x -= w
+        if x <= 0:
+            return v
+    return pairs[-1][0]
+
+
+def generate_match(
+    rng: random.Random,
+    skill: dict[str, float],
+    players: list[str],
+    nine_rounds: bool,
+    informative: bool,
+) -> Match:
+    """Партия: места — по производительности, детали — по отрыву.
+
+    informative=False — сценарий «шум»: места те же, но величина отрыва (а значит
+    раунд, цели, миры и тип победы) не связана с силой игроков."""
+    n = len(players)
+    perf = {pl: skill[pl] + rng.gauss(0, SIGMA_PERF) for pl in players}
+    order = sorted(players, key=perf.get, reverse=True)
+    if informative:
+        z = {pl: (perf[order[0]] - perf[pl]) / SIGMA_PERF for pl in players}
+    else:
+        ghost = sorted((rng.gauss(0, SIGMA_PERF) for _ in players), reverse=True)
+        z = {pl: (ghost[0] - ghost[i]) / SIGMA_PERF for i, pl in enumerate(order)}
+
+    winner = order[0]
+    eliminated = {pl for pl in order[1:] if z[pl] > ELIM_Z and rng.random() < ELIM_P}
+    survivors = [pl for pl in order if pl not in eliminated]
+    rmax = max_rounds(n, nine_rounds)
+
+    if len(survivors) == 1:
+        reason = "last_standing"
+        gap = z[order[1]]
+    else:
+        gap = z[survivors[1]]
+        if gap < 0.02:
+            reason = "resources"
+        elif gap < 0.08:
+            reason = "plastic"
+        elif gap < 0.25:
+            reason = "worlds"
+        else:
+            reason = "objectives"
+    rnd = int(_clamp(round(rmax + 0.3 - 1.4 * gap + rng.gauss(0, 0.9)), 3, rmax))
+
+    need = n
+    if reason == "last_standing":
+        o_win = rng.randint(max(0, need - 2), need - 1)
+    elif rnd < rmax:
+        o_win = need
+    else:
+        o_win = need if rng.random() < 0.5 else need - 1
+    objectives = {winner: o_win}
+    for pl in order[1:]:
+        o = round(o_win * (1 - 0.45 * z[pl]) + rng.gauss(0, 0.5))
+        objectives[pl] = int(_clamp(o, 0, max(0, o_win - 1)))
+
+    total = int(worlds_on_board(n))
+    mean_z = statistics.fmean(z[pl] for pl in survivors)
+    worlds = {}
+    for pl in order:
+        if pl in eliminated:
+            worlds[pl] = 0
+            continue
+        w = round(fair_worlds(n) * (1 + 0.35 * (mean_z - z[pl])) + rng.gauss(0, 0.8))
+        worlds[pl] = int(_clamp(w, 1, total))
+
+    if reason in ("worlds", "plastic", "resources"):
+        ru = survivors[1]
+        objectives[ru] = o_win
+        if reason == "worlds":
+            if worlds[winner] <= worlds[ru]:
+                worlds[winner] = worlds[ru] + 1
+        else:
+            worlds[ru] = worlds[winner]
+
+    seats = []
+    for i, pl in enumerate(survivors):
+        seats.append(Seat(pl, i + 1, objectives[pl], worlds[pl]))
+    last = len(survivors) + 1
+    for pl in order:
+        if pl in eliminated:
+            seats.append(Seat(pl, last, objectives[pl], 0, eliminated=True))
+    return Match(seats, reason, rnd, nine_rounds)
+
+
+def strip_details(m: Match) -> Match:
+    """Партия «из старой истории»: только места и тип победы."""
+    return Match(
+        [Seat(s.player, s.place, eliminated=s.eliminated) for s in m.seats], m.win_reason
+    )
+
+
+CLUB_OFFSETS = (-150.0, 0.0, 150.0)  # сценарий «клубы»: средняя сила трёх групп
+CLUB_SIGMA = 90.0  # разброс силы внутри клуба
+CLUB_MIXED_SHARE = 0.1  # доля партий, где встречаются игроки разных клубов
+
+
+LEARN_DEFICIT = 200.0  # сценарий «рост»: максимальное стартовое отставание новичка
+LEARN_GAMES = 15.0  # за столько партий отставание уменьшается в e раз
+
+
+def generate_season(
+    seed: int, n_matches: int, informative: bool, clubs: bool = False, learning: bool = False
+) -> tuple[dict, list[Match]]:
+    """Сезон: 12 игроков сразу, ещё по двое на 1/3 и 2/3 сезона.
+
+    clubs=True — игроки разбиты на три группы разной силы и почти всегда играют
+    внутри своей; общий рейтинг должен их правильно «сшить».
+    learning=True — сила растёт с опытом: θ − deficit·exp(−партии/LEARN_GAMES).
+    Возвращает силу на КОНЕЦ сезона — её и должен отражать рейтинг."""
+    rng = random.Random(seed)
+    skill = {}
+    activity = {}
+    joins = {}
+    club = {}
+    deficit = {}
+    played = {}
+    for i in range(18 if clubs else 16):
+        pl = f"p{i:02d}"
+        if clubs:
+            club[pl] = i % 3
+            skill[pl] = CLUB_OFFSETS[club[pl]] + rng.gauss(0, CLUB_SIGMA)
+            joins[pl] = 0 if i < 15 else n_matches // 3
+        else:
+            skill[pl] = rng.gauss(0, SIGMA_SKILL)
+            joins[pl] = 0 if i < 12 else (n_matches // 3 if i < 14 else 2 * n_matches // 3)
+        activity[pl] = rng.uniform(0.5, 1.5)
+        deficit[pl] = rng.uniform(0, LEARN_DEFICIT) if learning else 0.0
+        played[pl] = 0
+
+    def current(pl: str) -> float:
+        return skill[pl] - deficit[pl] * math.exp(-played[pl] / LEARN_GAMES)
+
+    nine_rounds = rng.random() < 0.5
+    matches = []
+    for t in range(n_matches):
+        active = [pl for pl in skill if joins[pl] <= t]
+        if clubs and rng.random() >= CLUB_MIXED_SHARE:
+            c = rng.randrange(3)
+            active = [pl for pl in active if club[pl] == c]
+        n = min(_choice_weighted(rng, TABLE_SIZES), len(active))
+        pool = active[:]
+        chosen = []
+        for _ in range(n):
+            pick = _choice_weighted(rng, [(pl, activity[pl]) for pl in pool])
+            pool.remove(pick)
+            chosen.append(pick)
+        now = {pl: current(pl) for pl in chosen}
+        matches.append(generate_match(rng, now, chosen, nine_rounds, informative))
+        for pl in chosen:
+            played[pl] += 1
+    return {pl: current(pl) for pl in skill}, matches
+
+
+# ═══ Метрики ══════════════════════════════════════════════════════════════════
+
+
+def _ranks(xs: list[float]) -> list[float]:
+    order = sorted(range(len(xs)), key=lambda i: xs[i])
+    ranks = [0.0] * len(xs)
+    i = 0
+    while i < len(order):
+        j = i
+        while j + 1 < len(order) and xs[order[j + 1]] == xs[order[i]]:
+            j += 1
+        for t in range(i, j + 1):
+            ranks[order[t]] = (i + j) / 2 + 1
+        i = j + 1
+    return ranks
+
+
+def spearman(xs: list[float], ys: list[float]) -> float:
+    if len(xs) < 3:
+        return float("nan")
+    rx, ry = _ranks(xs), _ranks(ys)
+    return statistics.correlation(rx, ry)
+
+
+CHECKPOINTS = (5, 10, 20)
+
+
+def evaluate(system, skill: dict[str, float], matches: list[Match], feed=None) -> dict:
+    """Прогоняет сезон. feed(m) — какую версию партии видит система (по умолчанию полную)."""
+    half = len(matches) // 2
+    hits = pairs = 0.0
+    brier = []
+    abs_moves = []
+    at_k: dict[int, dict[str, float]] = {k: {} for k in CHECKPOINTS}
+    games: dict[str, int] = {}
+    for t, m in enumerate(matches):
+        seen = feed(m) if feed else m
+        if t >= half:
+            for a, b in combinations(m.seats, 2):
+                if a.place == b.place:
+                    continue
+                if a.place > b.place:
+                    a, b = b, a
+                ra, rb = system.rating(a.player), system.rating(b.player)
+                pairs += 1
+                hits += 1.0 if ra > rb else 0.5 if ra == rb else 0.0
+                if system.probabilistic:
+                    brier.append((1.0 - expected(ra, rb, system.p.d)) ** 2)
+        delta = system.update(seen)
+        for s in m.seats:
+            games[s.player] = games.get(s.player, 0) + 1
+            gp = games[s.player]
+            if gp > 20:
+                abs_moves.append(abs(delta[s.player]) * system.move_scale)
+            if gp in at_k:
+                at_k[gp][s.player] = system.rating(s.player)
+    played = [pl for pl in skill if games.get(pl, 0) >= 10]
+    out = {
+        "acc": hits / pairs if pairs else float("nan"),
+        "rho": spearman([system.rating(pl) for pl in played], [skill[pl] for pl in played]),
+        "move": statistics.fmean(abs_moves) if abs_moves else float("nan"),
+    }
+    for k in CHECKPOINTS:
+        pls = list(at_k[k])
+        out[f"rho@{k}"] = spearman([at_k[k][pl] for pl in pls], [skill[pl] for pl in pls])
+    if system.probabilistic:
+        out["brier"] = statistics.fmean(brier)
+        rs = [system.rating(pl) for pl in played]
+        ts = [skill[pl] * SKILL_TO_RATING for pl in played]
+        mr, mt = statistics.fmean(rs), statistics.fmean(ts)
+        out["rmse"] = math.sqrt(statistics.fmean(((r - mr) - (t - mt)) ** 2 for r, t in zip(rs, ts)))
+        everyone = [system.rating(pl) for pl in games]
+        out["inflation"] = statistics.fmean(everyone) - system.p.r0
+        out["slope"] = _slope(ts, rs)
+    return out
+
+
+def oracle_accuracy(skill: dict[str, float], matches: list[Match]) -> float:
+    half = len(matches) // 2
+    hits = pairs = 0
+    for m in matches[half:]:
+        for a, b in combinations(m.seats, 2):
+            if a.place == b.place:
+                continue
+            if a.place > b.place:
+                a, b = b, a
+            pairs += 1
+            hits += skill[a.player] > skill[b.player]
+    return hits / pairs
+
+
+def _slope(xs: list[float], ys: list[float]) -> float:
+    """Наклон регрессии рейтинга на истинную силу: 1 — масштаб честный, >1 — раздут."""
+    mx, my = statistics.fmean(xs), statistics.fmean(ys)
+    sxx = sum((x - mx) ** 2 for x in xs)
+    return sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / sxx if sxx else float("nan")
+
+
+def summarize(rows: list[dict]) -> dict[str, tuple[float, float]]:
+    keys = rows[0].keys()
+    res = {}
+    for k in keys:
+        vals = [r[k] for r in rows if not math.isnan(r[k])]
+        mean = statistics.fmean(vals)
+        se = statistics.stdev(vals) / math.sqrt(len(vals)) if len(vals) > 1 else 0.0
+        res[k] = (mean, se)
+    return res
+
+
+# ═══ Коэффициенты ═════════════════════════════════════════════════════════════
+
+PLAIN = Params(k_max=96.0, k_min=16.0)  # чистый Elo со своими лучшими K (перебор, этап 1)
+CLOSENESS = (
+    ("objectives", 1.0),
+    ("worlds", 0.85),
+    ("plastic", 0.7),
+    ("resources", 0.6),
+    ("last_standing", 1.0),
+)
+# Для анализа чувствительности: отклонения от 1 вдвое больше.
+CLOSENESS_STRONG = tuple((r, 1.0 - 2 * (1.0 - c)) for r, c in CLOSENESS)
+PROPOSED = Params(
+    w_table=0.5,
+    w_tempo=1.0,
+    w_obj=0.5,
+    w_worlds=0.5,
+    closeness=CLOSENESS,
+    skip_eliminated_pairs=True,
+)
+
+
+# ═══ Примеры из документа ═════════════════════════════════════════════════════
+
+VETERAN = 40  # партий у «опытного» игрока: K = k_min
+
+
+def _vets(*names: str) -> dict[str, int]:
+    return {n: VETERAN for n in names}
+
+
+def examples() -> list[tuple[str, str, dict, dict, Match]]:
+    """(ключ, заголовок, рейтинги, сыграно партий, партия) — в порядке документа."""
+    duel = lambda first, second, **kw: Match([Seat(first, 1), Seat(second, 2)], **kw)  # noqa: E731
+    five = [Seat("A", 1), Seat("B", 2), Seat("C", 3), Seat("D", 4), Seat("E", 5)]
+    six = [Seat(x, i + 1) for i, x in enumerate("ABCDEF")]
+    return [
+        ("1a", "Дуэль 1600 против 1400: побеждает сильный",
+         {"A": 1600, "B": 1400}, _vets("A", "B"), duel("A", "B", win_reason="objectives")),
+        ("1b", "Дуэль 1600 против 1400: побеждает слабый",
+         {"A": 1600, "B": 1400}, _vets("A", "B"), duel("B", "A", win_reason="objectives")),
+        ("2a", "Быстрая победа: 3-й раунд",
+         {"A": 1500, "B": 1500}, _vets("A", "B"),
+         Match([Seat("A", 1, 2, 5), Seat("B", 2, 1, 4)], "objectives", round=3)),
+        ("2b", "Медленная победа: 8-й раунд",
+         {"A": 1500, "B": 1500}, _vets("A", "B"),
+         Match([Seat("A", 1, 2, 5), Seat("B", 2, 1, 4)], "objectives", round=8)),
+        ("3a", "Первое место в дуэли",
+         {"A": 1500, "B": 1500}, _vets("A", "B"), duel("A", "B", win_reason="objectives")),
+        ("3b", "Стол на 5: все места",
+         dict.fromkeys("ABCDE", 1500), _vets(*"ABCDE"), Match(five, "objectives")),
+        ("4a", "Тип победы без деталей: по мирам",
+         {"A": 1500, "B": 1500}, _vets("A", "B"), duel("A", "B", win_reason="worlds")),
+        ("4b", "Тип победы без деталей: по пластику",
+         {"A": 1500, "B": 1500}, _vets("A", "B"), duel("A", "B", win_reason="plastic")),
+        ("4c", "Тип победы без деталей: по ресурсам",
+         {"A": 1500, "B": 1500}, _vets("A", "B"), duel("A", "B", win_reason="resources")),
+        ("4d", "Самая близкая полная партия: по мирам на 8-м раунде, 2:2 цели, 6:5 миров",
+         {"A": 1500, "B": 1500}, _vets("A", "B"),
+         Match([Seat("A", 1, 2, 6), Seat("B", 2, 2, 5)], "worlds", round=8)),
+        ("4e", "Разгром: 3-й раунд, 2:0 цели, 8:2 миров",
+         {"A": 1500, "B": 1500}, _vets("A", "B"),
+         Match([Seat("A", 1, 2, 8), Seat("B", 2, 0, 2)], "objectives", round=3)),
+        ("5", "Стол на 4: двое выбывших, раунд 7",
+         {"A": 1550, "B": 1500, "C": 1480, "D": 1450}, _vets(*"ABCD"),
+         Match(
+             [Seat("A", 1, 4, 8), Seat("B", 2, 3, 7),
+              Seat("C", 3, 1, 0, eliminated=True), Seat("D", 3, 0, 0, eliminated=True)],
+             "objectives", round=7,
+         )),
+        ("6a", "Стол на 6, конец на 8-м раунде, хоумрул 9 раундов включён",
+         dict.fromkeys("ABCDEF", 1500), _vets(*"ABCDEF"),
+         Match(six, "objectives", round=8, nine_rounds=True)),
+        ("6b", "Стол на 6, конец на 8-м раунде, хоумрул выключен",
+         dict.fromkeys("ABCDEF", 1500), _vets(*"ABCDEF"),
+         Match(six, "objectives", round=8, nine_rounds=False)),
+        ("7", "Новичок (0 партий) побеждает ветерана, оба 1500",
+         {"A": 1500, "B": 1500}, {"A": 0, "B": VETERAN}, duel("A", "B", win_reason="objectives")),
+    ]
+
+
+# Изменения рейтинга в примерах (округление до 0.01) — те же числа стоят в документе.
+EXPECTED: dict[str, dict[str, float]] = {
+    "1a": {"A": 3.84, "B": -3.84},
+    "1b": {"B": 12.16, "A": -12.16},
+    "2a": {"A": 11.18, "B": -11.18},
+    "2b": {"A": 5.46, "B": -5.46},
+    "3a": {"A": 8.0, "B": -8.0},
+    "3b": {"A": 11.0, "B": 5.5, "C": 0.0, "D": -5.5, "E": -11.0},
+    "4a": {"A": 6.8, "B": -6.8},
+    "4b": {"A": 5.6, "B": -5.6},
+    "4c": {"A": 4.8, "B": -4.8},
+    "4d": {"A": 3.4, "B": -3.4},
+    "4e": {"A": 16.0, "B": -16.0},
+    "5": {"A": 9.27, "B": 5.85, "C": -7.6, "D": -7.53},
+    "6a": {"A": 12.0, "B": 7.2, "C": 2.4, "D": -2.4, "E": -7.2, "F": -12.0},
+    "6b": {"A": 10.29, "B": 7.54, "C": 2.74, "D": -2.06, "E": -6.86, "F": -11.66},
+    "7": {"A": 32.0, "B": -8.0},
+}
+
+
+def run_examples(p: Params = PROPOSED, verbose: bool = True) -> None:
+    for key, title, ratings, games, m in examples():
+        trace: list = []
+        delta = rate_match(ratings, games, m, p, trace)
+        got = {pl: round(v, 2) for pl, v in delta.items()}
+        if verbose:
+            n = len(m.seats)
+            print(f"\n### Пример {key}. {title}\n")
+            print(f"N={n}, G(N)={table_weight(n, p):.3f}, раунд={m.round}, R_max={max_rounds(n, m.nine_rounds)}, "
+                  f"тип={m.win_reason}, K: " + ", ".join(f"{pl}={k_factor(games[pl], p):.1f}" for pl in ratings))
+            print("\n| пара | S | E | темп | цели | миры | сумма | близость | M |")
+            print("|---|---|---|---|---|---|---|---|---|")
+            for t in trace:
+                tempo = f"{t['tempo']:.3f}" if "tempo" in t else "—"
+                print(f"| {t['a']}–{t['b']} | {t['S']} | {t['E']:.3f} | {tempo} | {t['obj']:.3f} | "
+                      f"{t['worlds']:.3f} | {t['additive']:.3f} | {t['closeness']} | {t['M']:.3f} |")
+            print("\nΔR: " + ", ".join(f"{pl} {v:+.3f}" for pl, v in got.items()))
+        if EXPECTED:
+            assert got == EXPECTED[key], f"пример {key}: {got} ≠ {EXPECTED[key]}"
+    if EXPECTED and verbose:
+        print("\nВсе примеры совпадают с документом.")
+
+
+def check_scale_invariance(seasons: int = 1) -> None:
+    """Шкала «50 / 40» (R = 10·score + 1000, D и K ÷10) и шкала 1500 дают одинаковые
+    точность, Brier и ρ; изменения рейтинга различаются ровно в 10 раз (документ, 4.1)."""
+    for cfg in SCENARIOS.values():
+        for s in range(seasons):
+            skill, matches = generate_season(
+                cfg["seed"] + s, SEASON_MATCHES, cfg["informative"], cfg["clubs"], cfg["learning"]
+            )
+            for p in (PROPOSED, PLAIN):
+                small = replace(p, r0=(p.r0 - 1000) / 10, d=p.d / 10, k_max=p.k_max / 10, k_min=p.k_min / 10)
+                big, tiny = evaluate(Elo(p), skill, matches), evaluate(Elo(small), skill, matches)
+                for key in ("acc", "brier", "rho", *(f"rho@{k}" for k in CHECKPOINTS)):
+                    assert math.isclose(big[key], tiny[key], abs_tol=1e-9), f"шкала: {key}"
+                assert math.isclose(big["move"], 10 * tiny["move"], rel_tol=1e-9), "шкала: |ΔR|"
+    print("Шкала 1500 и шкала 50 дают одинаковые точность, Brier и ρ.")
+
+
+# ═══ Сценарии запуска ═════════════════════════════════════════════════════════
+
+SEASON_MATCHES = 300
+
+
+SCENARIOS = {
+    "сигнал": {"informative": True, "clubs": False, "learning": False, "seed": 10_000},
+    "шум": {"informative": False, "clubs": False, "learning": False, "seed": 30_000},
+    "клубы": {"informative": True, "clubs": True, "learning": False, "seed": 40_000},
+    "рост": {"informative": True, "clubs": False, "learning": True, "seed": 50_000},
+}
+
+
+def compare(seasons: int, scenario: str, proposed: Params) -> None:
+    cfg = SCENARIOS[scenario]
+    print(f"\n## Сравнение систем — сценарий «{scenario}», {seasons} сезонов по {SEASON_MATCHES} партий\n")
+    variants = [
+        ("League Points (сейчас)", lambda: LeaguePoints(), None),
+        ("Elo, чистый", lambda: Elo(PLAIN), None),
+        ("Предложенная", lambda: Elo(proposed), None),
+        ("Предложенная, без новых полей", lambda: Elo(proposed), strip_details),
+    ]
+    results = {name: [] for name, _, _ in variants}
+    oracle = []
+    for s in range(seasons):
+        skill, matches = generate_season(
+            cfg["seed"] + s, SEASON_MATCHES, cfg["informative"], cfg["clubs"], cfg["learning"]
+        )
+        oracle.append(oracle_accuracy(skill, matches))
+        for name, make, feed in variants:
+            results[name].append(evaluate(make(), skill, matches, feed))
+    print(f"Потолок точности (прогноз по истинной силе): {statistics.fmean(oracle):.4f}\n")
+    cols = ["acc", "brier", "rho", "rho@5", "rho@10", "rho@20", "rmse", "slope", "move", "inflation"]
+    print("| Система | " + " | ".join(cols) + " |")
+    print("|---" * (len(cols) + 1) + "|")
+    for name, _, _ in variants:
+        sm = summarize(results[name])
+        cells = []
+        for c in cols:
+            if c not in sm:
+                cells.append("—")
+            else:
+                mean, se = sm[c]
+                cells.append(f"{mean:.4f} ±{se:.4f}" if c in ("acc", "brier") else f"{mean:.3f}")
+        print(f"| {name} | " + " | ".join(cells) + " |")
+    base = results["Elo, чистый"]
+    prop = results["Предложенная"]
+    lp = results["League Points (сейчас)"]
+    d_brier = [p["brier"] - b["brier"] for p, b in zip(prop, base)]
+    d_acc_lp = [p["acc"] - b["acc"] for p, b in zip(prop, lp)]
+    d_acc = [p["acc"] - b["acc"] for p, b in zip(prop, base)]
+    for title, ds in (
+        ("Brier: предложенная − чистый Elo", d_brier),
+        ("Точность: предложенная − чистый Elo", d_acc),
+        ("Точность: предложенная − League Points", d_acc_lp),
+    ):
+        mean = statistics.fmean(ds)
+        se = statistics.stdev(ds) / math.sqrt(len(ds))
+        print(f"- {title}: {mean:+.4f} ± {se:.4f} (парная разница)")
+
+
+GRID_SEED_SHIFT = 100_000  # перебор идёт на других сезонах, чем итоговое сравнение
+
+
+def grid(seasons: int) -> None:
+    """Подбор K и весов по Brier (меньше — лучше) на отдельных от сравнения сезонах."""
+    data: dict[str, list] = {}
+    for name, cfg in SCENARIOS.items():
+        data[name] = [
+            generate_season(
+                cfg["seed"] + GRID_SEED_SHIFT + s, SEASON_MATCHES,
+                cfg["informative"], cfg["clubs"], cfg["learning"],
+            )
+            for s in range(seasons)
+        ]
+    signal = [n for n, c in SCENARIOS.items() if c["informative"]]
+    cache: dict = {}
+
+    def run(p: Params, scenario: str) -> tuple[float, float]:
+        if (p, scenario) not in cache:
+            rows = [evaluate(Elo(p), sk, ms) for sk, ms in data[scenario]]
+            cache[(p, scenario)] = (
+                statistics.fmean(r["brier"] for r in rows),
+                statistics.fmean(r["rho@10"] for r in rows),
+            )
+        return cache[(p, scenario)]
+
+    def brier(p: Params, scenarios) -> float:
+        return statistics.fmean(run(p, sc)[0] for sc in scenarios)
+
+    def rho10(p: Params, scenarios) -> float:
+        return statistics.fmean(run(p, sc)[1] for sc in scenarios)
+
+    print(f"\n## Перебор: {seasons} сезонов на сценарий, критерий — средний Brier\n")
+    print("### Этап 1. K чистого Elo (все сценарии)\n")
+    print("| k_max | k_min | k_games | Brier |")
+    print("|---|---|---|---|")
+    k_res = []
+    for k_games in (10, 20):
+        for k_max in (48.0, 64.0, 96.0, 128.0, 160.0):
+            for k_min in (16.0, 24.0, 32.0):
+                p = replace(PLAIN, k_max=k_max, k_min=k_min, k_games=k_games)
+                b = brier(p, SCENARIOS)
+                k_res.append((b, k_max, k_min, k_games))
+                print(f"| {k_max} | {k_min} | {k_games} | {b:.5f} |")
+    _, k_max, k_min, k_games = min(k_res)
+    print(f"\nЛучшие K: k_max={k_max}, k_min={k_min}, k_games={k_games}")
+
+    print(f"\n### Этап 2. Веса отрыва (K этапа 1; сценарии {', '.join(signal)}; «шум» — контроль)\n")
+    res = []
+    for w_table in (0.0, 0.25, 0.5):
+        for w_tempo in (0.0, 0.5, 1.0):
+            for w_obj in (0.0, 0.5, 1.0):
+                for w_worlds in (0.0, 0.5, 1.0):
+                    for close in ((), CLOSENESS):
+                        p = Params(
+                            k_max=k_max, k_min=k_min, k_games=k_games, w_table=w_table,
+                            w_tempo=w_tempo, w_obj=w_obj, w_worlds=w_worlds, closeness=close,
+                        )
+                        res.append((brier(p, signal), p))
+    res.sort(key=lambda x: x[0])
+    zero = next(b for b, p in res if (p.w_table, p.w_tempo, p.w_obj, p.w_worlds) == (0, 0, 0, 0) and not p.closeness)
+    plain_best = replace(PLAIN, k_max=k_max, k_min=k_min, k_games=k_games)
+    print(f"Без множителя (все веса 0, без близости): Brier {zero:.5f}, "
+          f"«шум» {brier(plain_best, ['шум']):.5f}\n")
+    print("| Brier | Brier «шум» | w_table | w_tempo | w_obj | w_worlds | близость |")
+    print("|---|---|---|---|---|---|---|")
+    for b, p in res[:12]:
+        noise = brier(p, ["шум"])
+        print(
+            f"| {b:.5f} | {noise:.5f} | {p.w_table} | {p.w_tempo} | {p.w_obj} | {p.w_worlds} | "
+            f"{'да' if p.closeness else 'нет'} |"
+        )
+    print(f"\nХудшая комбинация: Brier {res[-1][0]:.5f}")
+
+    print("\n### Этап 3. Доводка K и поправка на автокорреляцию для предложенных весов\n")
+    print("| k_max | k_min | k_games | autocorr | Brier (сигнальные) | Brier «шум» |")
+    print("|---|---|---|---|---|---|")
+    for k_games2 in (10, 20):
+        for k_max2 in (48.0, 64.0, 80.0):
+            for k_min2 in (12.0, 16.0, 24.0):
+                for ac in (False, True):
+                    p = replace(PROPOSED, k_max=k_max2, k_min=k_min2, k_games=k_games2, autocorr=ac)
+                    print(
+                        f"| {k_max2} | {k_min2} | {k_games2} | {'да' if ac else 'нет'} | "
+                        f"{brier(p, signal):.5f} | {brier(p, ['шум']):.5f} |"
+                    )
+
+    print("\n### Этап 4. Чувствительность: один вес меняется, остальные — как в PROPOSED\n")
+    print(f"PROPOSED: Brier {brier(PROPOSED, signal):.5f}, ρ@10 {rho10(PROPOSED, signal):.3f}, "
+          f"Brier «шум» {brier(PROPOSED, ['шум']):.5f}\n")
+    print("| параметр | значение | Brier (сигнальные) | ρ@10 (сигнальные) | Brier «шум» |")
+    print("|---|---|---|---|---|")
+    sweeps = [
+        ("w_table", (0.0, 0.25, 0.5, 1.0)),
+        ("w_tempo", (0.0, 0.25, 0.5, 1.0, 2.0)),
+        ("w_obj", (0.0, 0.25, 0.5, 1.0, 2.0)),
+        ("w_worlds", (0.0, 0.25, 0.5, 1.0, 2.0)),
+    ]
+    for attr, values in sweeps:
+        for v in values:
+            p = replace(PROPOSED, **{attr: v})
+            print(f"| {attr} | {v} | {brier(p, signal):.5f} | {rho10(p, signal):.3f} | {brier(p, ['шум']):.5f} |")
+    for label, close in (("без близости", ()), ("близость ×2 сильнее", CLOSENESS_STRONG), ("предложенная", CLOSENESS)):
+        p = replace(PROPOSED, closeness=close)
+        print(f"| closeness | {label} | {brier(p, signal):.5f} | {rho10(p, signal):.3f} | {brier(p, ['шум']):.5f} |")
+
+
+def main() -> None:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--seasons", type=int, default=200, help="сезонов в сравнении систем")
+    ap.add_argument("--grid", action="store_true", help="перебор K и весов")
+    ap.add_argument("--grid-seasons", type=int, default=40)
+    args = ap.parse_args()
+    print("# Примеры расчётов")
+    run_examples()
+    check_scale_invariance()
+    if args.grid:
+        grid(args.grid_seasons)
+        return
+    for scenario in SCENARIOS:
+        compare(args.seasons, scenario, PROPOSED)
+
+
+if __name__ == "__main__":
+    main()

docs/rules/README.md

@@ -0,0 +1,94 @@
+# Правила Forbidden Stars в Markdown
+
+Текст правил, разбитый на логические блоки. Из него строится поиск по правилам (веха v1.6):
+на блоки навешиваются теги и синонимы (#7), затем их индексирует Meilisearch (#10).
+
+| Файл | Источник | Страниц | Блоков |
+|---|---|---|---|
+| [rules.md](rules.md) | буклет «Правила игры» — `fs_rules_rus_web.pdf` | 16 | 184 |
+| [reference.md](reference.md) | буклет «Справочник» — `fs_reference_rus_web.pdf` | 20 | 427 |
+| [cards-faq.md](cards-faq.md) | «Уточнение карт», декабрь 2020 — `Уточнение_карт_Forbidden_Stars_декабрь2020.pdf` | 12 | 93 |
+
+PDF в репозитории нет: они лежат вложениями в задаче #6. Правила и справочник — сканы без
+текстового слоя, их текст распознан вручную по страницам. У «Уточнения карт» текстовый слой
+есть, он взят за основу и сверен со страницами. Что не перенесено (обложки, художественный
+текст, содержание), сказано в шапке каждого файла.
+
+## Блок
+
+Блок — наименьшая единица поиска: абзац под заголовком источника, пункт списка статьи
+справочника или одна карта в уточнениях. Блок начинается маркером — HTML-комментарием,
+который при отображении не виден:
+
+```markdown
+<!-- block: rules.battle.retreat.attacker; page: 15 -->
+#### Атакующий отступает
+
+Когда атакующий отступает, он должен переместить…
+```
+
+- **Граница блока — маркер.** Блок тянется до следующего маркера. Заголовок внутри блока
+  относится к нему. Если у абзаца нет своего заголовка, блок начинается прямо с текста.
+- **Контекст блока** — цепочка заголовков над ним: `#` — файл, `##` — раздел или статья
+  глоссария, `###`/`####`/`#####` — подразделы. Первый блок раздела несёт его заголовок.
+- **Нумерованные шаги** (подготовка к игре, шаги битвы) — отдельные блоки, заголовок шага
+  сохраняет номер источника: `### 2. Раунд битвы`, `#### а. Выберите Боевую Карту`.
+- **Список** остаётся одним блоком вместе с вводной фразой, если пункты не имеют смысла
+  по отдельности. В справочнике каждый пункт статьи — самостоятельное правило, поэтому
+  каждый пункт — свой блок.
+
+### Поля маркера
+
+| Поле | Обязательно | Значение |
+|---|---|---|
+| `block` | да | постоянный id блока, уникальный во всей папке |
+| `page` | да | страница PDF; `4-5`, если блок переходит на следующую страницу |
+| `kind` | нет | тип не-правила (см. ниже); без `kind` блок — правило |
+
+### Id
+
+`<файл>.<раздел>[.<подраздел>…]` — латиница в нижнем регистре, слова через дефис, смысловые
+английские слаги: `rules.orders.advance.limits`, `ref.retreats.defender.not-attacker-system`,
+`faq.eldar.combat.psychic-lance`. Префикс: `rules.`, `ref.`, `faq.`. Вложенность id повторяет
+вложенность заголовков, но не обязана совпадать с ней буквально.
+
+**Id постоянны.** К ним привязываются теги, синонимы и ссылки «см. также» (#7), а через
+них — поисковый индекс. Исправлять текст блока можно свободно. Id переименовывать нельзя:
+новый блок получает новый id, а id удалённого блока больше не используется.
+
+### `kind`
+
+| Значение | Что это |
+|---|---|
+| `example` | врезка «Пример…» — иллюстрирует правило, но и сама может его уточнять |
+| `caption` | подпись к схеме или иллюстрации. Если схема без подписи несёт информацию (например, раскладка тайлов), её описание составлено при переносе и выделено курсивом |
+| `related` | строка «Связанные темы» из справочника — готовые связи между статьями |
+
+## Текст
+
+- Дословно, включая опечатки и авторскую пунктуацию источника. Ссылки «см. … на стр. N» —
+  номера страниц буклета.
+- Переносы склеены, колонки и врезки выведены в порядке чтения.
+- Выделение источника сохранено: жирный — `**…**`, курсив — `*…*`.
+- Художественный текст (лор) не переносится.
+
+## Значки
+
+Значки внутри текста передаются словом в квадратных скобках. При отображении их можно
+заменить картинкой, а для поиска они остаются словами.
+
+| Запись | Значок |
+|---|---|
+| `[атака]`, `[защита]`, `[мораль]` | боевой значок на любом компоненте (мораль — боевой дух, аквила) |
+| `[куб: атака]`, `[куб: защита]`, `[куб: мораль]` | значок на грани боевого куба |
+| `[куб]` | куб, который нужно бросить |
+| `[жетон: атака]`, `[жетон: защита]` | боевой жетон (значок в круге) |
+| `[ресурс: кузница]`, `[ресурс: запасы]`, `[ресурс: подкрепление]`, `[ресурс: процветание]` | значок ценного ресурса на знамени мира |
+| `[приказ: развертывание]`, `[приказ: планирование]`, `[приказ: доминирование]`, `[приказ: продвижение]` | жетон приказа |
+
+## Проверка
+
+Формальная проверка файлов (выполнялась при переносе, в репозиторий не входит): у каждого
+маркера корректный формат, id уникален и имеет префикс своего файла, страница — в пределах
+PDF, у каждого блока есть текст, каждая непропущенная страница дала хотя бы один блок, в
+тексте только значки из таблицы выше, нет висячих переносов.

docs/rules/cards-faq.md

@@ -0,0 +1,539 @@
+# Уточнение карт
+
+> **Источник:** «Уточнения эффектов карт» — `Уточнение_карт_Forbidden_Stars_декабрь2020.pdf`, 12 стр.
+> Уточнение по эффектам карт для перевода 2020 года. Автор: Дмитрий Wergg Комаров.
+> Верстка: Андрей Yxo Паровой. Декабрь 2020.
+> «Все возможные разночтения в эффектах карт решены на усмотрение автора. Пользуясь данной
+> справкой, вы соглашаетесь с его виденьем по данному вопросу.»
+>
+> **Не перенесено:** стр. 1 (обложка), изображения карт и иллюстрации; выходные данные
+> со стр. 12 — в этой шапке. Формат блоков и id — в [README](README.md).
+
+## Общие положения
+
+<!-- block: faq.general.effect-resolution; page: 2 -->
+### Розыгрыш эффекта
+
+- Если карта задает выбор, то выбор делается владельцем карты, если не сказано иного. Как в отношении своих компонентов, так и в отношении компонентов соперника.
+- **Жирным** в тексте карт выделены смысловые акценты, которые легко пропустить.
+- Владелец карты вправе отказаться разыгрывать эффект карты, кроме тех случаев, где эффект карты содержит слово **обязан**, выделенное жирным. От исполнения таких эффектов ни вы, ни ваш соперник не имеют права отказаться. Такие эффекты встречаются только в колоде Орков.
+- Эффекты карт изложены в специальных полях. В боевых картах обычно 2 поля - зеленое и коричневое. В остальных картах поле одно. В одном поле может быть сложносоставной эффект. Решение о розыгрыше или отказе от розыгрыша должно приниматься для всего эффекта, описанного в поле.
+- Если вы приняли решение разыграть эффект карты, то должны выполнить все предписания в поле настолько, насколько это возможно и именно в том порядке, в котором они перечислены.
+- Нельзя отказаться от части эффекта карты, если вы приняли решение разыграть эффект.
+- Если эффект подразумевает трату кубиков, то разыграть такой эффект можно ровно 1 раз, если только не оговорено, что потратить можно любое количество кубиков (и получить соответствующее количество активаций эффекта).
+
+<!-- block: faq.general.may-avoid; page: 2 -->
+### "Может избежать этого эффекта..."
+
+- Карты с формулировкой **"Может избежать этого эффекта..."** построены по принципу: происходит событие **А**. Противник может избежать наступления события путем уплаты стоимости, указанной после слов **"Может избежать этого эффекта..."**
+- Противник вправе отказаться уплачивать стоимость отмены. В этом случае событие **А** происходит.
+- Если противник **не может** уплатить стоимость отмены в виду отсутствия необходимых ресурсов или в виду эффектов карт, то событие **А** происходит. Требуется именно уплата стоимости отмены в полном объеме, а не принципиальный факт согласия на уплату.
+- Если противник согласился уплатить стоимость отмены, но не смог этого сделать в виду каких-либо эффектов карт или других причин, то событие **А** происходит.
+
+<!-- block: faq.general.retreat; page: 2 -->
+### Отступите / отступает
+
+- Если эффект карты предписывает отступать, то отступление производится по общим правилам с соответствующими ограничениями (см. правила). Не забывайте, что после отступления отряд становится деморализованным.
+- Отряд, отступивший в никем не контролируемую область, делает ее дружественной владельцу отряда.
+- Если за бой было несколько отступлений, то они могут производиться в разные области.
+- Если сражение началось по эффекту **карты** приказа, а не по самому приказу (карта "десантный модуль") или в результате действия боевых карт ("волновой змей"), то атакующий не сможет отступать (см правила отступления).
+- Если сражение началось по приказу "продвижение", вызванному эффектом карты (карта орков "вперед!"), то отступление атакующих - легально.
+
+<!-- block: faq.general.move; page: 2 -->
+### Переместите
+
+- Перемещать деморализованные отряды нельзя. Хоть по эффекту приказа, хоть по эффекту карты.
+
+<!-- block: faq.general.take-and-place; page: 3 -->
+### Забрать и поместить / разместить
+
+- Забрать и поместить в другую область можно только недеморализованные отряды.
+- При размещении игнорируется вместимость мира. Выбор, кого оставить производится после боя (если размещение было вызвано эффектом карты в бою) или после выполнения приказа (если размещение было сопряжено с приказом).
+- При размещении отряда в бою игнорируется лимит в "5 отрядов максимум в одной области" т.к. этот лимит наложен только на перемещение.
+- При размещении отряда в бою после броска кубиков новые кубики за вновь прибывший отряд уже не бросаются.
+
+<!-- block: faq.general.replace; page: 3 -->
+### Замените
+
+- Т.к. в бою (и только в бою!) фишки подкрепления являются отрядами, то заменять их на пластиковые фигурки - легально.
+- Процедура "заменить" не равна "купить". При замещении игнорируется командный уровень.
+- Можно заменить деморализованный отряд на недеморализованный.
+
+<!-- block: faq.general.purchase; page: 3 -->
+### Купите
+
+- Только процедура покупки, инициированная жетоном приказа "развертывание" требует наличия фабрики для приобретения отрядов.
+- Если эффект карты позволяет вам покупать отряды, то наличие фабрики не требуются. Однако командный уровень все еще учитывается.
+
+<!-- block: faq.general.gain; page: 3 -->
+### Получите
+
+- "Получить" не равно "Купить". Получение не требует соблюдения командного уровня.
+
+<!-- block: faq.general.command-level; page: 3 -->
+### Командный уровень
+
+- Ваш фактический командный уровень равен числу ваших городов.
+- Жетоны кузницы дают вам временное понижение командного уровня покупаемого отряда, сам командный уровень отрядов не меняется. Фактически командный уровень отрядов не уменьшается и всегда равен написанному на листе фракции.
+- Если эффект карты ссылается на командный уровень отряда или улучшения, то имеется в виду именно то, что написано фактически на листе фракции или карте.
+- Если эффект предписывает вам получить (а так же разместить или заменить) что-либо, то командный уровень игнорируется.
+
+<!-- block: faq.general.orbital-strike; page: 3 -->
+### Орбитальный удар
+
+- Помните про лимит в 8 кубиков.
+- Если способность предписывает потратить кубики во время выполнения орбитального удара, то это нужно сделать **до** назначения урона.
+- Если эффект подразумевает трату кубиков, то разыграть такой эффект можно ровно 1 раз (воруй, грабь, десантный модуль, огненный дождь, обстрел, расчетливый удар, полное разрушение, страх с небес).
+- Несмертельный урон не приводит к деморализации (в отличии от боя).
+- Вы в праве объявить орбитальный удар по миру без отрядов (и даже без бастиона) для активации способности.
+- Нельзя объявить орбитальный удар по никем не контролируемому или своему миру.
+- Нельзя объявить орбитальный удар по области без миров.
+- Нельзя объявить орбитальный удар по миру в соседней системе.
+
+## Орки
+
+<!-- block: faq.orks.faction-ability; page: 4 -->
+### Фракционная способность
+
+Вы можете купить только наземный отряд. Для покупки отряда **не** требуется наличие фабрики. Командный уровень покупаемого отряда учитывается. Вы можете использовать жетон запасов (шестеренки), чтобы уменьшить стоимость на 2. Вы можете использовать жетон кузницы (молот), чтобы снизить требование по командному уровню покупаемого отряда.
+
+### События
+
+<!-- block: faq.orks.events.more-boyz; page: 4 -->
+#### Больше бойзов!
+
+Вы не можете иметь более 3 жетонов 1 типа. Лишние жетоны подкрепления придется сразу сбросить.
+
+<!-- block: faq.orks.events.into-battle; page: 4 -->
+#### В бой!
+
+При размещении отрядов вы можете превысить лимит мира (количество черепов). Решение, какие отряды оставить в этом мире, принимается после размещения.
+
+<!-- block: faq.orks.events.how-did-we-get-here; page: 4 -->
+#### Как мы сюда попали?
+
+забрать и поместить можно только недеморализованный отряд. Разместить таким образом можно только наземный отряд.
+
+<!-- block: faq.orks.events.looting; page: 4 -->
+#### Мародерство
+
+Вы получите материалы, даже если у выбранного противника нет жетонов ценных ресурсов. У вас не может быть больше 14 материалов.
+
+<!-- block: faq.orks.events.tear-it-down; page: 4 -->
+#### Снести это!
+
+Вы можете уничтожить любую постройку (не только бастион).
+
+<!-- block: faq.orks.events.finish-them; page: 4 -->
+#### Добить их!
+
+Для того чтобы воспользоваться эффектом данной карты отряд противника должен стать деморализованным фактически. Если какой-либо эффект предотвратил деморализацию отрядов противника (напр. карта " не ведать страха" фракции Ультрамаринов), то уничтожить такой отряд при помощи этой карты нельзя.
+
+<!-- block: faq.orks.events.warboss; page: 4 -->
+#### Варбосс
+
+Скидка действует как при покупке при помощи приказа "развертывание", так и при покупке по эффекту карт или фракционной способности. Вы не можете иметь более 3 жетонов подкрепления.
+
+<!-- block: faq.orks.events.forward; page: 4 -->
+#### Вперед!
+
+Для того, чтобы воспользоваться этой картой вы должны иметь возможность вскрыть жетон приказа. Если все ваши жетоны приказов заблокированы жетонами соперников или ваши жетоны уже закончились, то вы не можете воспользоваться этой картой. При выполнении эффекта этой карты считайте, что вы вскрыли приказ "продвижение" в целевой системе. Т.к. считается, что сражение, начавшееся после розыгрыша данной карты, произошло по приказу "продвижение", то отступление атакующего - легально (см правила отступления).
+
+### Приказы
+
+<!-- block: faq.orks.orders.build-faster; page: 5 -->
+#### Строй быстрее!
+
+После постройки фабрики можно будет сразу же приобретать отряды в этой системе.
+
+<!-- block: faq.orks.orders.plunder; page: 5 -->
+#### Грабь!
+
+Вы не можете бросить более 8 кубиков для орбитального удара, все лишние кубики пропадут. Если у противника нет материалов, то вы все равно получите 1 материал. Если у вас уже 14 материалов, то противник все равно потеряет 1 материал (если вы потратите кубик, конечно).
+
+<!-- block: faq.orks.orders.green-tide; page: 5 -->
+#### Зеленая волна
+
+Вы должны выбрать тип разыгрываемого приказа при вскрытии жетона. Считайте, что на данном жетоне изображена иконка выбранного вами приказа. Если вы выбрали приказ, отличный от приказа "планирование", то не размещайте этот жетон приказа поверх колоды событий.
+
+<!-- block: faq.orks.orders.steal; page: 5 -->
+#### Воруй!
+
+Если у противника нет жетонов ценных ресурсов, то вы не получите ничего. Если у вас уже 3 жетона выбранного ресурса, то противник все равно потеряет выбранный жетон (вы при этом четвертый жетон не получите).
+
+<!-- block: faq.orks.orders.ork-ships; page: 5 -->
+#### Орочьи корабли
+
+Вы можете составить путь из настоящих кораблей и дружественных миров в любой пропорции и дополнительно **однократно** провести не более 2 наземных отрядов через пустую область как через дружественную. Переместить по приказу можно больше 2 отрядов, главное, чтобы именно через пустую область без кораблей по эффекту данной карты было перемещено не более 2 отрядов. Нельзя отступать через пустую область при помощи данной карты в защите. Нельзя отступать при помощи данной карты в атаке, если вы использовали ее для перемещения в оспариваемую область. Можно отступить при помощи данной карты в атаке (с соблюдением всех правил отступления), если вы не использовали ее для перемещения в оспариваемую область.
+
+### Боевые карты
+
+<!-- block: faq.orks.combat.hard-boyz; page: 5 -->
+#### Хард бойз
+
+Оба эффекта карты обязательны к исполнению и от них нельзя отказаться.
+
+<!-- block: faq.orks.combat.mega-nobz; page: 5 -->
+#### Мега нобз
+
+верхний эффект обязателен к исполнению и от него нельзя отказаться.
+
+<!-- block: faq.orks.combat.weirdboyz; page: 5 -->
+#### Вирдбойз
+
+верхний эффект обязателен к исполнению и от него нельзя отказаться. Если будет сыграно две карты **вирдбойз**, то их свойства будут складываться, т.е. вы будете получать удвоенное количество жетонов.
+
+<!-- block: faq.orks.combat.slugga-boyz; page: 5 -->
+#### Слагга бойз
+
+Верхний эффект обязателен к исполнению и от него нельзя отказаться.
+
+<!-- block: faq.orks.combat.biker-nobz; page: 5 -->
+#### Байкер нобз
+
+верхний эффект обязателен к исполнению и от него нельзя отказаться.
+
+<!-- block: faq.orks.combat.mek-boyz; page: 5 -->
+#### Мек бойз
+
+Противник сбрасывает карту с **колоды** (не с руки). Вы получаете именно значки (не жетоны). Это может быть важно для эффектов карт, заставляющих сбрасывать боевые жетоны. Если карта была сброшена таким образом в 3 раунде боя, то аквилы (орлы) со сброшенной карты не участвуют в подсчете общего количества морали, т.к. он производится **после** окончания 3 раунда.
+
+<!-- block: faq.orks.combat.shoota-boyz; page: 5 -->
+#### Шута бойз
+
+Оба эффекта карты обязательны к исполнению и от них нельзя отказаться.
+
+<!-- block: faq.orks.combat.ripping-gargant; page: 5 -->
+#### Разрывающий гаргант
+
+если сброшенная карта давала свойство, действующее в течение этого раунда или всего боя, то оно (свойство) немедленно прекращается.
+
+<!-- block: faq.orks.combat.party-wagon; page: 5 -->
+#### Пати вагон
+
+Т.к. жетон размещается бесплатно, то он берется из резерва (а не из вашего запаса). Ограничение на 3 жетона одного типа при этом соответственно игнорируется. Также игнорируется правило, что у вы не можете разместить больше жетонов подкрепления, чем пластиковых фигурок в бою на вашей стороне.
+
+<!-- block: faq.orks.combat.gretchin; page: 5 -->
+#### Гретчины
+
+Несмотря на слово "должен" вы можете не разыгрывать верхний эффект карты. Но тогда вы не получите боевые жетоны.
+
+<!-- block: faq.orks.combat.crushing-gargant; page: 5 -->
+#### Сокрушающий гаргант
+
+если у противника нет необходимого количества кубиков или он не хочет их тратить, то выбранный отряд уничтожается.
+
+<!-- block: faq.orks.combat.sea-of-green; page: 5 -->
+#### Море зеленых
+
+1. Т.к. жетон размещается бесплатно, то он берется из резерва (а не из вашего запаса). Ограничение на 3 жетона одного типа при этом соответственно игнорируется. Также игнорируется правило, что у вы не можете разместить больше жетонов подкрепления, чем фигурок в бою на вашей стороне.
+2. Если у противника нет кубиков с аквилами (орлами) или он не хочет их тратить, то он должен будет деморализовать 1 свой отряд (если сможет).
+
+## Космодесант Хаоса
+
+<!-- block: faq.chaos.faction-ability; page: 6 -->
+### Фракционная способность
+
+Т.к. это размещение, а не перемещение, то целевая планета может не иметь легального пути до места изначального размещения культиста и даже может находиться за варп-штормом. Забрать и разместить таким образом можно только недеморализованный отряд.
+
+### События
+
+<!-- block: faq.chaos.events.warp-touched; page: 6 -->
+#### Задетый варпом
+
+Т.к. вы получаете, а не покупаете улучшение, то ваш фактический командный уровень (число городов) не имеет значения.
+
+<!-- block: faq.chaos.events.nurgle-rot; page: 6 -->
+#### Отрава Нургла
+
+Для того, чтобы воспользоваться этой картой вы должны иметь возможность вскрыть жетон приказа. Если все ваши жетоны приказов заблокированы жетонами соперников или ваши жетоны уже закончились, то вы не можете воспользоваться этой картой.
+
+<!-- block: faq.chaos.events.tzeentch-incarnation; page: 6 -->
+#### Инкарнация Тзинча
+
+Если эта карта была вытянута в числе нескольких карт в 3 фазе (если на колоде событий лежало более 1 жетона) и была разыграна, то сначала тянуться еще 3 карты и играется одна из них, а только потом все карты замешиваются в колоду событий.
+
+<!-- block: faq.chaos.events.through-the-warp; page: 6 -->
+#### Сквозь варп
+
+Вы получите дополнительный кубик с аквилой (орлом) даже если не пересекали варп-шторм перед началом сражения. Помните про лимит в 8 кубиков. Т.к. вы получите кубик с аквилой еще до броска основных кубиков, то фактически вы не сможете бросить больше 7 кубиков (восьмой кубик будет аквилой). Вы можете отступить через варп-шторм после атаки. Вы не можете использовать эту карту для отступления в защите.
+
+### Приказы
+
+<!-- block: faq.chaos.orders.from-the-warp; page: 6 -->
+#### Из варпа
+
+Наземные отряды **не** могут пересекать варп-штормы по эффекту данной карты. Вы можете отступить через варп-шторм после атаки. Вы не можете использовать эту карту для отступления в защите.
+
+<!-- block: faq.chaos.orders.dark-gods-favor; page: 6 -->
+#### Расположение темных богов
+
+Дополнительные жетоны нужно взять из числа неиспользуемых в этом раунде (не с поля). В комбинации с картой **инкарнация Тзинча** можно просмотреть 6 карт из колоды событий.
+
+<!-- block: faq.chaos.orders.dread-ritual; page: 6 -->
+#### Ужасный ритуал
+
+Для покупки по эффекту данной карты не требуется завод. Вы можете купить корабль по эффекту данной карты, но разместить его нужно обязательно в дружественной области активной системы. Т.к. вы **покупаете** отряд, то ваш командный уровень все равно учитывается. Вы можете использовать жетон кузницы (молоток), если вам не хватает вашего текущего командного уровня для приобретения отряда. Вы не можете покупать титанов по эффекту данной карты, т.к. наложен запрет на покупку отрядов выше фактического второго уровня.
+
+<!-- block: faq.chaos.orders.terror-from-the-skies; page: 6 -->
+#### Страх с небес
+
+Не забывайте, что во время орбитального удара несмертельный урон не приводит к деморализации. Помните про лимит в 8 кубиков.
+
+<!-- block: faq.chaos.orders.total-destruction; page: 6 -->
+#### Полное разрушение
+
+Противник должен выбрать для уничтожения любую пластиковую фигурку (отряд или строение) **из имеющихся** в мире, подвергшемся орбитальному удару. Противник вправе выбрать небоевое строение (город/фабрика). Потратить кубики и разыграть способность нужно **до** назначения урона. Несмертельный урон не приводит к деморализации отряда. Вы в праве объявить орбитальный удар по враждебному миру без отрядов и/или бастиона для активации этой способности.
+
+### Боевые карты
+
+<!-- block: faq.chaos.combat.wrath-of-khorne; page: 7 -->
+#### Ярость Кхорна
+
+Если у противника нет кубика защиты (щит) или он не хочет его тратить, то он должен выбрать и деморализовать свой отряд. Если у противника нет недеморализованных отрядов или они не могут стать деморализованными (карта "не ведать страха"), то не произойдет ничего.
+
+<!-- block: faq.chaos.combat.daemonic-resilience; page: 7 -->
+#### Демоническая стойкость
+
+Если у противника нет отрядов для уничтожения или он не хочет этого делать, то вы получите жетоны защиты.
+
+<!-- block: faq.chaos.combat.mark-of-tzeentch-top; page: 7 -->
+#### Отметка Тзинча (верх)
+
+можно заменить деморализованный отряд культистов на нормальный отряд космодесанта хаоса. Можно заменить жетон подкрепления на фигурку космодесанта хаоса, т.к. в бою жетон подкрепления является отрядом (культистов).
+
+<!-- block: faq.chaos.combat.mark-of-tzeentch-bottom; page: 7 -->
+#### Отметка Тзинча (низ)
+
+можно выбрать разные грани кубиков, если потрачены 2 аквилы.
+
+<!-- block: faq.chaos.combat.mark-of-slaanesh-top; page: 7 -->
+#### Отметка Слаанеш (верх)
+
+если у противника нет недеморализованных отрядов или они не могут стать деморализованными, то не произойдет ничего.
+
+<!-- block: faq.chaos.combat.mark-of-khorne-bottom; page: 7 -->
+#### Отметка Кхорна (низ)
+
+если у противника нет деморализованных отрядов, то не произойдет ничего. Если у противника есть деморализованные отряды, но нет кубика защиты (щит) или он не хочет его тратить, то он должен выбрать и уничтожить свой деморализованный отряд.
+
+<!-- block: faq.chaos.combat.death-and-despair-top; page: 7 -->
+#### Смерть и отчаяние (верх)
+
+нельзя выбрать 1 болтер и 1 аквилу. Только либо 2 болтера, либо 2 аквилы. Выбор, какой отряд уничтожать, делается игроком за Хаос.
+
+<!-- block: faq.chaos.combat.lures-of-chaos-top; page: 7 -->
+#### Соблазны хаоса (верх)
+
+противник вправе выбрать деморализовать 1 свой отряд даже если у него нет недеморализованных отрядов или они не могут стать деморализованными (карта "не ведать страха"). Это приведет к тому, что хаос не получит культиста (т.к. выбран другой вариант, пусть и невыполнимый), а противник хаоса не получит кубик (т.к. он не "уплатил" цену этого кубика - фактически не деморализовал отряд).
+
+<!-- block: faq.chaos.combat.mark-of-nurgle-bottom; page: 7 -->
+#### Отметка Нургла (низ)
+
+если у противника нет деморализованных отрядов или он не хочет их уничтожать, то вы получите жетоны защиты.
+
+<!-- block: faq.chaos.combat.unholy-intent-bottom; page: 7 -->
+#### Нечистые намерения (низ)
+
+Если у противника нет недеморализованных отрядов, или они не могут стать деморализованными (карта "не ведать страха"), или он не хочет деморализовать свой отряд, то хаос получит жетоны атаки. Т.е. избежать получения жетонов атаки можно только фактически деморализовав свой отряд.
+
+<!-- block: faq.chaos.combat.dark-faith; page: 7 -->
+#### Темная вера
+
+размещенный таким образом культист может отрезать легальный путь к отступлению противника.
+
+<!-- block: faq.chaos.combat.chaos-united-top; page: 7 -->
+#### Хаос объединенный (верх)
+
+Противник может выбрать деморализацию своих отрядов даже если у него нет недеморализованных отрядов или они не могут стать деморализованными ( карта "не ведать страха"). Такой выбор не приведет к тому, что Хаос получит кубик. Противник обязан сделать выбор не зная, кубик с каким значением возьмет игрок за Хаос в случае отказа.
+
+<!-- block: faq.chaos.combat.chaos-united-bottom; page: 7 -->
+#### Хаос объединенный (низ)
+
+Можно превысить вместимость мира и даже превысить планку в 5 отрядов в бою т.к. это не перемещение, а размещение.
+
+## Ультрамарины
+
+<!-- block: faq.ultramarines.faction-ability; page: 8 -->
+### Фракционная способность
+
+Можно заменить деморализованный отряд на недеморализованный более высокого уровня. Командный уровень при замене игнорируется. Нельзя использовать жетон запасов (шестеренки) для активации этого свойства, т.к. это не покупка.
+
+### События
+
+<!-- block: faq.ultramarines.events.exterminatus; page: 8 -->
+#### Экстерминатус
+
+Вы должны заявить эффект данной карты до броска кубиков. Нельзя сначала бросить кубики и посмотреть результат, а затем сыграть эту карту.
+
+<!-- block: faq.ultramarines.events.steadfast; page: 8 -->
+#### Непоколебимость
+
+Для того, чтобы воспользоваться этой картой вы должны иметь возможность вскрыть жетон приказа. Если все ваши жетоны приказов заблокированы жетонами соперников или ваши жетоны уже закончились, то вы не можете воспользоваться этой картой.
+
+<!-- block: faq.ultramarines.events.pre-battle-ceremony; page: 8 -->
+#### Церемония перед боем
+
+Т.к. это покупка, то командный уровень учитывается. Купить можно только улучшение приказа (не боевое улучшение). Скидка дается именно за миры с бастионами, а не сами бастионы.
+
+<!-- block: faq.ultramarines.events.emperors-protection; page: 8 -->
+#### Защита Императора
+
+Т.к. это не строительство, а размещение, то второй вариант розыгрыша карты не может быть оплачен жетоном запасов (шестеренки). За 2 материала вы не покупаете бастион, а активируете способность карты, которая даст вам бастион.
+
+### Приказы
+
+<!-- block: faq.ultramarines.orders.crusade; page: 8 -->
+#### Крестовый поход
+
+Вы не обязаны использовать полученный жетон в этой битве. Помните про лимит в 3 жетона одного типа. Вы получите жетон подкрепления, если вы нападаете из одного мира в другой в пределах одной системы и переместили все наземные войска в оспариваемую область.
+
+<!-- block: faq.ultramarines.orders.recruiting-worlds; page: 8 -->
+#### Миры призыва
+
+Чтобы не ошибиться с подсчетом суммарного лимита следует сначала сложить все лимиты миров с фабриками и бастионами в системе. Если в 1 мире находятся и фабрика и бастион или 2 бастиона, то лимит этого мира следует считать дважды (как будто это 2 фабрики, см. эффект карты **направлять верующих**). После этого из получившейся суммы следует вычесть количество бастионов в системе.
+
+<!-- block: faq.ultramarines.orders.guide-the-faithful; page: 8 -->
+#### Направлять верующих
+
+Можно создавать миры с одинаковыми постройками. Если будет создан мир с 2 фабриками, то лимит развертывания будет равен удвоенному количеству черепов этого мира.
+
+<!-- block: faq.ultramarines.orders.drop-pod; page: 8 -->
+#### Десантный модуль
+
+Вы вправе объявить орбитальный удар по миру противника без отрядов и/или бастиона для активации свойства. Сочетание этой карты и карты **крестовый поход** даст вам жетон подкрепления после высадки космодесантника, если остальные условия получения жетона будут соблюдены. Если космодесантник в бою, инициированном эффектом данной карты, должен будет отступить, то его придется уничтожить (см. правила отступления).
+
+### Боевые карты
+
+<!-- block: faq.ultramarines.combat.know-no-fear; page: 9 -->
+#### Не ведать страха
+
+Вы должны выбрать будете ли вы использовать верхнее свойство карты в момент ее вскрытия. Если эффект карты активирован, то вы не сможете уплатить цену эффектов с ключевыми словами "деморализуйте свой отряд". Вы все еще вправе выбирать варианты, подразумевающие деморализацию ваших отрядов, если такой выбор задается. В этом случае вы не сможете деморализовать свой отряд, но это и не приведет к автоматическому выбору второго варианта. Подробнее сочетание этой карты с другими смотрите в соответствующих уточнениях (Хаос объединенный, Соблазны хаоса, Ярость Кхорна, Нечистые намерения, Море зеленых)
+
+<!-- block: faq.ultramarines.combat.veteran-scouts; page: 9 -->
+#### Скауты ветераны
+
+Т.к. проверка окончания боя будет только в конце шага нанесения боевых повреждений, то противнику придется распределять урон в свои отряды даже если все ваши отряды выйдут из боя. Достаточно 1 недеморализованного скаута, чтобы отступить несколькими отрядами (за аналогичное количество кубиков с аквилами). После отступления отряд становится деморализованным. Отступить можно и деморализованным отрядом. Отряд, отступивший в никем не контролируемую область, делает ее дружественной. Отступление по данной карте должно производиться в 1 область. Если будет разыграна вторая карта **скауты ветераны**, то отступление можно будет производить в другую область.
+
+<!-- block: faq.ultramarines.combat.ambush; page: 9 -->
+#### Засада
+
+Трата кубиков с аквилами не предотвращает уничтожение отрядов другим способом (например, от смертельного урона или эффектов карт с ключевым словом "уничтожьте"). Если **засада** разыграна в защите, а игрок за Эльдар ранее в этом раунде разыграл **наставления видящих**, то отряд Эльдар не уничтожается, т.к. эффект засады действует от момента раскрытия карты.
+
+<!-- block: faq.ultramarines.combat.drop-assault; page: 9 -->
+#### Десант
+
+Можно забрать и поместить только недеморализованный отряд
+
+<!-- block: faq.ultramarines.combat.power-fist; page: 9 -->
+#### Бронекулак
+
+Противник тоже наносит урон. Урон между шагами не складывается. Поэтому если с 1 стороны остался только 1 отряд с выносливостью 3 и против него нужно дважды разыграть урон 2, то после первого шага отряд станет деморализованным, а второй шаг не сделает ничего.
+
+<!-- block: faq.ultramarines.combat.recon; page: 9 -->
+#### Разведка
+
+Т.к. проверка окончания боя будет только в конце шага нанесения боевых повреждений, то противнику придется распределять урон в свои отряды даже если все ваши отряды выйдут из боя. По эффекту данной карты отступить могут любые отряды, а не только скаут/ударный крейсер. После отступления отряд становится деморализованным. Отступить можно и деморализованным отрядом. Отряд, отступивший в никем не контролируемую область, делает ее дружественной. Отступление по данной карте должно производиться в 1 область. Если будет разыграна вторая карта **Разведка**, то отступление можно будет производить в другую область.
+
+## Эльдар
+
+<!-- block: faq.eldar.faction-ability; page: 10 -->
+### Фракционная способность
+
+Можно превысить лимит мира при размещении отряда. Выбор, кого оставить, производится после размещения. Разместить таким образом можно только наземные отряды. Вам не требуется легальный путь, т.к. это не перемещение, а именно размещение. Забрать и поместить в другую область деморализованный отряд нельзя.
+
+### События
+
+<!-- block: faq.eldar.events.legacy-of-vaul; page: 10 -->
+#### Наследие Ваула
+
+У вас не может быть более 3 жетонов 1 типа. Лишние придется сбросить.
+
+<!-- block: faq.eldar.events.exodite-colony; page: 10 -->
+#### Колония экзодитов
+
+Данное действие не является строительством, это бесплатное размещение города, где цена в 1 материал – это цена активации способности. Нельзя потратить жетон запасов (шестеренки) на активацию этого свойства, т.к. это не строительство.
+
+<!-- block: faq.eldar.events.terror-raid; page: 10 -->
+#### Ужасный налет
+
+Помните про лимит в 8 кубиков. Если вы должны получить девятый вы вместо этого не получаете кубик.
+
+<!-- block: faq.eldar.events.path-of-the-warrior; page: 10 -->
+#### Путь воина
+
+Купить можно только боевое улучшение колоды (не улучшение приказа). Улучшение приказа таким образом купить нельзя. Скидка считается именно по количеству миров (планет) с городами, а не количеству городов. Командный уровень при покупке учитывается.
+
+<!-- block: faq.eldar.events.warp-gate; page: 10 -->
+#### Врата варпа
+
+Для того, чтобы воспользоваться этой картой вы должны иметь возможность вскрыть жетон приказа. Если все ваши жетоны приказов заблокированы жетонами соперников или ваши жетоны уже закончились, то вы не можете воспользоваться этой картой. Забрать и поместить в другую область деморализованный отряд нельзя.
+
+<!-- block: faq.eldar.events.foresight; page: 10 -->
+#### Предвидение
+
+Забрать и поместить в другую область деморализованные отряды нельзя. Проверка окончания боя будет только в конце шага нанесения боевых повреждений, значит противнику придется распределять урон в свои отряды (не смотря на то, что все отряды Эльдар выйдут из боя). Игроку за Эльдар урон распределять не нужно, если все его отряды выйдут из боя. Если у игрока за Эльдар в бою останется бастион и/или деморализованные отряды, то урон от противника достанется им, а бой продолжится.
+
+### Приказы
+
+<!-- block: faq.eldar.orders.bombardment; page: 10 -->
+#### Обстрел
+
+Деморализованные отряды перемещать нельзя.
+
+<!-- block: faq.eldar.orders.calculated-strike; page: 10 -->
+#### Расчетливый удар
+
+Помните про лимит в 8 кубиков. Если вы должны получить девятый, вы вместо этого не получаете кубик.
+
+<!-- block: faq.eldar.orders.corsair-raid; page: 10 -->
+#### Рейд корсаров
+
+Нельзя выполнить 2 орбитальных удара по эффекту данной карты.
+
+### Боевые карты
+
+<!-- block: faq.eldar.combat.hit-and-run; page: 11 -->
+#### Бей и беги
+
+Деморализованные отряды перемещать нельзя. Можно переместиться в соседнюю систему, главное, чтобы область назначения была соседней (примыкала ортогонально). Таким перемещением можно отрезать легальный путь для отступления противнику.
+
+<!-- block: faq.eldar.combat.howling-banshees; page: 11 -->
+#### Воющие баньши
+
+Если у противника нет отрядов для деморализации или они не могут стать деморализованными по эффекту карт, то не произойдет ничего.
+
+<!-- block: faq.eldar.combat.ranger-cover; page: 11 -->
+#### Прикрытие рейнджеров
+
+После отступления отряд становится деморализованным. Отступить можно и деморализованным отрядом. Отряд, отступивший в никем не контролируемую область, делает ее дружественной. Отступление по данной карте должно производиться в 1 область. Если будет разыграна вторая карта **прикрытие рейнджеров**, то отступление можно будет производить в другую область.
+
+<!-- block: faq.eldar.combat.autarch-guidance; page: 11 -->
+#### Руководство Аутарха
+
+Помните про лимит в 8 кубиков. Если вы не можете разыграть свойство на получение кубика или восстановление подразделения, то это не запрещает вам разыграть свойство на розыгрыш дополнительной карты.
+
+<!-- block: faq.eldar.combat.wraithguard-advance; page: 11 -->
+#### Наступление призрачных стражей
+
+Если у противника нет кубиков с аквилами (орлами), то он должен деморализовать свой отряд (если есть и если это возможно). Если у противника нет недеморализованных отрядов или его отряды не могут стать деморализованными, то не произойдет ничего (противник не обязан тратить кубик с аквилой).
+
+<!-- block: faq.eldar.combat.seer-counsel; page: 11 -->
+#### Наставления видящих
+
+Противник тоже не получит повреждений. Карта не запрещает деморализовать отряды и напрямую их уничтожать по эффектам других карт. Блокируются только боевые повреждения.
+
+<!-- block: faq.eldar.combat.wave-serpent-top; page: 11 -->
+#### Волновой змей (верхнее свойство)
+
+Если у противника нет кубиков с аквилами (орлами), то Эльдар получат жетоны защиты.
+
+<!-- block: faq.eldar.combat.wave-serpent-bottom; page: 11 -->
+#### Волновой змей (нижнее свойство)
+
+Деморализованные отряды перемещать нельзя. Можно переместиться в соседнюю систему, главное, чтобы область назначения была соседней (примыкала ортогонально). Такое перемещение может отрезать легальный путь к отступлению сопернику. Отряды Эльдар не смогут отступать из боя, вызванного этим эффектом (см правила отступления).
+
+<!-- block: faq.eldar.combat.psychic-lance; page: 11 -->
+#### Психокопье
+
+Формулировка карты переписана (по сравнению с английской версией). Карта задает выбор: ИЛИ владелец психокопья получает 4 жетона атаки (**А**), ИЛИ противник **соглашается** на то, что владелец психокопья выберет открытую боевую карту соперника и сбросит ее (прикажет ее сбросить) (**Б**). Если у противника нет открытых боевых карт, то это никак не влияет на саму принципиальную возможность **согласиться** на эту процедуру. Противник вправе выбрать вариант **Б**, даже если у него нет отрытых боевых карт (например, идет 1 раунд боя и Эльдар атакуют). В таком случае игрок за Эльдар не получит боевые жетоны, а противник Эльдар не потеряет ничего, т.к. ему нечего терять.

docs/rules/rules.md

@@ -0,0 +1,835 @@
+# Правила игры
+
+> **Источник:** буклет «Правила игры» — `fs_rules_rus_web.pdf`, 16 стр. (скан без текстового
+> слоя, распознан вручную). Перевод: Копылов Олег.
+>
+> **Не перенесено:** стр. 1 (обложка); художественный текст — «Нет мира среди звезд» и описания
+> фракций (стр. 2), вводный абзац врезки «Что такое варп-штормы?» (стр. 7); иллюстрации. От схем оставлены подписи; описание схемы, составленное
+> при переносе, выделено курсивом. Формат блоков, id и обозначения иконок — в [README](README.md).
+
+<!-- block: rules.overview; page: 2 -->
+## Обзор игры
+
+*Forbidden Stars* — игра о галактической войне, действие которой происходит во вселенной *Warhammer 40,000.* От двух до четырех игроков командуют Космодесантниками, Орками, Эльдарами или Космодесантниками Хаоса (в базовой игре). Каждая фракция стремится вернуть потерянные реликвии и места силы, которые являются ключевыми для их выживания. Для этого они должны собирать ресурсы, улучшать свои силы и завоевывать миры давно потерянного Скопления Геракон.
+
+<!-- block: rules.overview.using-this-booklet; page: 2 -->
+### Использование этого буклета
+
+Этот буклет «Правила Игры» предназначен для обучения новых игроков игре в Forbidden Stars. Чтобы научить игре быстро и просто, в этом буклете опущены многие исключения из правил и сложные игровые взаимодействия из-за большого количества типов отрядов и боевых карт. Игроки должны использовать прилагающийся Справочник, чтобы разрешить эти ситуации.
+
+<!-- block: rules.factions; page: 2 -->
+## Фракции
+
+В *Forbidden Stars* представлены четыре основные фракции вселенной Warhammer 40,000. Каждая фракция имеет свои уникальные компоненты, которые можно отличить по цвету или по символу фракции. Это позволяет определить, какие компоненты принадлежат каким игрокам.
+
+- **Орден Космодесантников Ультрамарины**
+- **Легион-Предатель Космодесантников Хаоса Пожиратели Миров**
+- **Мир-Корабль Эльдар Йанден**
+- **Орки Клана Злосолнца**
+
+<!-- block: rules.components; page: 3 -->
+## Список компонентов
+
+- 1 Справочник
+- 112 Боевых Карт (28 на фракцию)
+- 32 Карт Событий (8 на фракцию)
+- 20 Карт Улучшения Приказов (5 на фракцию)
+- 24 Маркера Целей (6 на фракцию)
+- 36 Маркеров Контроля Построек (9 на фракцию)
+- 32 Жетона Приказов (8 на фракцию)
+- 4 Карты Справок
+- 1 Счетчик Раунда, 1 Маркер Раунда
+- 1 Жетон Первого Игрока
+- 36 Жетонов Ценных Ресурсов (по 12 каждого типа)
+- 16 Кубов
+- 12 Боевых Жетонов ([жетон: атака] спереди, [жетон: защита] сзади)
+- 4 Счетчиков Материалов
+- 4 Жетона Варп-Штормов
+- 12 Двусторонних Тайлов Систем
+- 4 Листа Фракций
+- 35 Пластиковых Построек (10 Фабрик, 15 Городов,и 10 Бастионов)
+- 105 Пластиковых Отрядов (27 для Космодесанта, 24 для Эльдаров, 27 для Орков, 27 для Хаоса), и 27 пластиковых подставок (Пластиковые Отряды от КТ визуально отличаются)
+
+<!-- block: rules.components.material-dials-assembly; page: 3 -->
+### Сборка счетчиков материалов
+
+Перед началом игры в *Forbidden Stars* в первый раз, осторожно соберите четыре счетчика материалов, как указано на рисунке ниже. (В редакции от КТ счетчики материалов уже собраны)
+
+<!-- block: rules.components.ships-assembly; page: 3 -->
+### Сборка кораблей
+
+Перед началом игры в *Forbidden Stars*, осторожно вставьте пластиковые подставки в каждую фигурку корабля, как показано на рисунке справа.
+
+<!-- block: rules.setup; page: 4 -->
+## Подготовка к игре
+
+Перед началом игры в *Forbidden Stars*, игроки должны выполнить следующие шаги подготовки к игре:
+
+<!-- block: rules.setup.choose-factions; page: 4 -->
+### 1. Выберите Фракции
+
+Каждый игрок выбирает одну фракцию и берет соответствующие листы фракции, жетоны, карты событий, карты улучшений приказов, боевые карты и отряды этой фракции.
+
+<!-- block: rules.setup.choose-factions.first-game; page: 4 -->
+**Если** это ваша первая игра, и игроков меньше четырех, то **исключите** фракции Орков и Эльдар из игры для двух игроков, и фракцию Эльдар из игры для трех игроков.
+
+<!-- block: rules.setup.starting-components; page: 4 -->
+### 2. Получите Начальные Компоненты
+
+Каждый игрок берет все компоненты, перечисленные в графе «*Стартовые Силы*» на обратной стороне листа его фракции. Затем он переворачивает лист своей фракции лицевой стороной вверх и кладет эти компоненты поверх него.
+
+<!-- block: rules.setup.starting-components.materials; page: 4 -->
+Наконец, он берет счетчик материалов и устанавливает его на цифру «6». Это значение также указано в поле «*Стартовые Силы*» на обратной стороне листа его фракции.
+
+<!-- block: rules.setup.first-player; page: 4 -->
+### 3. Определите Первого Игрока
+
+Перемешайте по одному маркеру контроля постройки каждого игрока в крышке коробки и вытяните один случайным образом. Этому игроку дается жетон первого игрока.
+
+<!-- block: rules.setup.game-board; page: 4 -->
+### 4. Соберите Игровое Поле
+
+Для первой игры разместите необходимые тайлы систем в центре игровой зоны, как показано на диаграмме «*Расстановка к Первой Игре*» ниже. При игре на менее чем четырех игроков часть игрового поля исключается.
+
+<!-- block: rules.setup.game-board.place-components; page: 4 -->
+Затем разместите отряды, постройки, жетоны контроля над постройками, маркеры цели и жетоны варп-штормов на игровом поле, как показано на схеме. Не размещайте жетоны или отряды неиспользуемых фракций. Жетон подкрепления, указанный в «*Стартовых Силах*» орков, не помещается на игровое поле, а остается рядом с его листом фракции, пока не будет использован.
+
+<!-- block: rules.setup.game-board.first-game-layout; page: 4; kind: caption -->
+#### Расстановка к первой игре
+
+*Схема: игровое поле из трех рядов по четыре тайла систем. Верхний ряд — 10A, 1A, 11B, 2B; средний — 5A, 3B, 8A, 6B; нижний — 7A, 12A, 4B, 9A. «2 игрока» — два левых столбца, «3 игрока» — три левых столбца, «4 игрока» — все четыре столбца.*
+
+<!-- block: rules.setup.game-board.custom-board-note; page: 5 -->
+**Примечание:** Сыграв одну игру с использованием схемы «*Расстановка к Первой Игре*», игроки могут подготавливаться к игре, используя правила «*Создание Игрового Поля*» на стр. 16. Эти правила позволяют игрокам создавать уникальное игровое поле для каждой игры, выбирая, где размещать тайлы систем, отряды, жетоны целей и варп-штормы.
+
+<!-- block: rules.setup.decks; page: 5 -->
+### 5. Подготовьте Колоды Событий, Улучшений и Боевые Колоды
+
+Каждый игрок перемешивает свои карты событий и кладет их колодой лицевой стороной вниз в своей игровой зоне.
+
+<!-- block: rules.setup.decks.combat-deck; page: 5 -->
+Затем каждый игрок находит десять боевых карт с символом своей фракции, напечатанным в верхнем левом углу, и перемешивает их, чтобы сформировать свою боевую колоду.
+
+<!-- block: rules.setup.decks.faction-symbol-caption; page: 5; kind: caption -->
+Символ Фракции на Боевой Карте
+
+<!-- block: rules.setup.decks.upgrade-decks; page: 5 -->
+Наконец, каждый игрок формирует две колоды улучшений, используя все карты улучшения приказов своей фракции и оставшиеся боевые карты. Эти колоды не нужно тасовать. Игроки кладут их **лицевой стороной вверх** рядом со своим листом фракции, не смешивая их с боевой колодой.
+
+<!-- block: rules.setup.round-track; page: 5 -->
+### 6. Подготовьте Счетчик Раундов
+
+Поместите шкалу раундов рядом с игровым полем и поместите маркер раунда на ячейку «1» на шкале.
+
+<!-- block: rules.setup.supply; page: 5 -->
+### 7. Создайте Запас
+
+Разделите все жетоны подкреплений, жетоны запасов, жетоны кузницы, кубы и пластиковые постройки в кучки и положите их рядом с игровым полем, где все игроки могут их достать.
+
+<!-- block: rules.setup.ready; page: 5 -->
+После завершения шагов подготовки к игре компоненты каждого игрока должны находиться в его игровой зоне, как показано ниже. Затем игроки готовы начать первый раунд игры.
+
+<!-- block: rules.setup.play-area-example; page: 5; kind: caption -->
+#### Пример игровой зоны
+
+*Схема: игровая зона игрока — Колода Событий, Жетоны Приказов, Пластиковые Отряды, Счетчик Материалов, Маркеры Контроля Построек, Улучшения Приказов, Боевые Улучшения, Лист Фракции, Боевая Колода.*
+
+<!-- block: rules.game-round; page: 5 -->
+## Ход игры
+
+Игра в *Forbidden Stars* состоит из серии игровых раундов. Каждый игровой раунд состоит из трех фаз, которые играются в следующем порядке:
+
+1. **Фаза Планирования:** Во время этой фазы игроки по очереди размещают жетоны приказов на игровом поле.
+2. **Фаза Действий:** Во время этой фазы игроки по очереди разыгрывают жетоны приказов, которые они разместили на игровом поле.
+3. **Фаза Обновления:** Во время этой фазы игроки собирают цели, материалы, восстанавливают деморализованные отряды, перемещают варп-штормы и разыгрывают карты событий. Затем первый игрок передает жетон первого игрока и продвигает маркер раунда по счетчику раундов.
+
+<!-- block: rules.game-round.next-round; page: 5 -->
+После завершения Фазы Обновления игроки начинают новый раунд, начиная с новой Фазы Планирования. Они продолжают разыгрывать игровые раунды до тех пор, пока один из игроков не выиграет игру, собрав достаточное количество маркеров целей (подробно объяснено позже).
+
+<!-- block: rules.planning; page: 5 -->
+## Фаза 1: Фаза Планирования
+
+Во время Фазы Планирования игроки по очереди кладут жетоны приказов лицевой стороной вниз на игровое поле. Игроки раскрывают эти жетоны и применяют их эффекты во время Фазы Действий.
+
+<!-- block: rules.planning.placing-orders; page: 5 -->
+Чтобы начать Фазу Планирования, первый игрок кладет один из своих жетонов приказов лицевой стороной вниз на зону для жетонов приказов на **тайле системы**. Затем по часовой стрелке каждый игрок кладет по одному жетону приказа на любой тайл системы. Игроки повторяют этот процесс до тех пор, пока каждый игрок не положит на игровое поле по четыре жетона приказов.
+
+<!-- block: rules.planning.system-tile-diagram; page: 5; kind: caption -->
+*Схема тайла системы:* Области Миров; Зона для Жетонов Приказов; Области Пустот.
+
+<!-- block: rules.planning.order-stacks; page: 5 -->
+Игроки кладут жетоны приказов **лицевой стороной вниз**, чтобы тип приказа был скрыт от других игроков. Если в системе уже есть один или несколько жетонов приказов, игрок кладет свой жетон приказа поверх стека существующих жетонов приказов. Жетон приказа на вершине стека всегда является жетоном приказа, который был помещен в эту систему последним.
+
+<!-- block: rules.planning.order-stacks.captions; page: 5; kind: caption -->
+Жетоны приказов размещаются лицевой стороной вниз на зону для жетонов приказов. Любое количество жетонов приказов могут быть размещены друг на друга формируя стек.
+
+<!-- block: rules.planning.adjacency; page: 6 -->
+**Важно:** Игрок не может положить жетон приказа в систему, если у него нет отрядов или построек либо в этой системе, либо в соседних с ней. Каждая система соседствует с системами, с которыми её тайл имеет общее ребро. Если у тайлов двух систем общий только угол, а не ребро, то они не являются соседними.
+
+<!-- block: rules.planning.order-types; page: 6 -->
+### Типы жетонов приказов
+
+Игроки используют жетоны приказов, чтобы выполнять основные действия в *Forbidden Stars*, такие как перемещение отрядов, атака отрядами и производство новых отрядов и построек.
+
+<!-- block: rules.planning.order-types.list; page: 6 -->
+Существует четыре типа жетонов приказов. Когда игрок раскрывает жетон приказа, он разыгрывает эффект, соответствующий типу раскрытого жетона.
+
+- **Развертывание:** Игрок может потратить свои материалы на покупку новых отрядов и построек в системе.
+- **Планирование:** Игрок может купить улучшение приказа, боевое улучшение или оба. Затем он кладет жетон приказа на верх своей колоды событий, что позволяет ему взять карту события во время Фазы Обновления.
+- **Доминирование:** Игрок получает ценные ресурсы из каждого дружественного мира в системе. Он также может использовать специальную способность на листе своей фракции.
+- **Продвижение:** Игрок может переместить свои отряды в систему и начать одну битву.
+
+Детали для выполнения каждого типа приказов подробно объяснены позже.
+
+<!-- block: rules.action; page: 6 -->
+## Фаза 2: Фаза Действий
+
+Во время Фазы Действий игроки по очереди разыгрывают жетоны приказов, размещенные во время Фазы Планирования. Начиная с первого игрока и далее по часовой стрелке, каждый игрок выбирает один из своих жетонов приказов **сверху любого стека**. Он раскрывает выбранный жетон приказа, разыгрывает его эффект и убирает его с игрового поля. Фаза Действий заканчивается, когда игроки разыграли все жетоны приказов на игровом поле.
+
+<!-- block: rules.action.resolve-or-event; page: 6 -->
+Когда активный игрок раскрывает жетон приказа, он решает либо разыграть эффект жетона, либо положить жетон лицевой стороной вверх на верх своей колоды событий. Каждый жетон на колоде событий игрока позволяет ему взять одну карту события во время Фазы Обновления.
+
+<!-- block: rules.action.no-available-order; page: 6 -->
+**Примечание:** Если у игрока нет ни одного жетона приказа на вершине какого-либо стека, он обязан пропустить свой ход. Он обязан выполнить приказ во время своего следующего хода, если в этот момент на вершине какого-либо стека будет его приказ.
+
+<!-- block: rules.units-and-structures; page: 6 -->
+## Что такое отряды и постройки?
+
+Наземные отряды и корабли — это типы **отрядов**, представленные пластиковыми фигурками. Игроки перемещают отряды, атакуют ими и размещают их, чтобы контролировать области на игровом поле, что в конечном счете позволяет им собирать свои маркеры целей. **Постройки** предоставляют игрокам боевые усиления (бастионы), позволяют игрокам покупать отряды (фабрики) и повышают командный уровень игрока (города), который необходим для приобретения карт улучшений и более мощных отрядов. Таким образом, для достижения победы игроку необходим тщательный баланс как построек, так и отрядов.
+
+<!-- block: rules.refresh; page: 6 -->
+## Фаза 3: Фаза Обновления
+
+Во время Фазы Обновления каждый игрок собирает материалы и маркеры целей из **дружественных** миров — миров, в которых есть только его отряды и/или постройки. Также во время этой фазы каждый игрок восстанавливает свои деморализованные отряды, чтобы они были готовы к следующему игровому раунду.
+
+<!-- block: rules.refresh.steps; page: 6 -->
+Во время Фазы Обновления каждый игрок выполняет следующие шаги по порядку:
+
+1. Соберите Цели
+2. Соберите Материалы
+3. Восстановите Деморализованные Отряды
+4. Возьмите События и Переместите Варп-Штормы
+5. Конец Раунда
+
+После завершения этой фазы игроки начинают новый игровой раунд.
+
+<!-- block: rules.refresh.objectives; page: 6 -->
+### Соберите Цели
+
+Каждый игрок собирает любые **свои** маркеры **целей**, которые находятся в дружественных мирах. Он помещает маркеры в поле «Маркеры целей» на листе своей фракции, чтобы все игроки могли легко видеть, сколько маркеров он собрал.
+
+<!-- block: rules.refresh.objectives.caption; page: 6; kind: caption -->
+Игрок за Эльдар собрал маркер цели с дружественного мира.
+
+<!-- block: rules.refresh.objectives.victory; page: 6 -->
+Игрок выигрывает игру, если он собирает количество маркеров цели, равное количеству игроков в игре (см. «Победа в игре» ниже).
+
+<!-- block: rules.refresh.materials; page: 6 -->
+### Соберите Материалы
+
+У большинства миров есть **производственное значение**, которое обозначается числом на зеленом значке материалов.
+
+<!-- block: rules.refresh.materials.caption; page: 6; kind: caption -->
+Производственное значение этого мира равно двум
+
+<!-- block: rules.refresh.materials.gain; page: 7 -->
+Во время Фазы Обновления каждый игрок получает количество материалов, равное сумме производственных значений всех его дружественных миров. Когда игрок получает материалы, он поворачивает счетчик материалов на соответствующую величину в большую сторону.
+
+<!-- block: rules.refresh.materials.dial-caption; page: 7; kind: caption -->
+Счетчик материалов установлен на значении «4».
+
+<!-- block: rules.refresh.rally; page: 7 -->
+### Восстановите Деморализованные Отряды
+
+Каждый игрок **восстанавливает** все свои **деморализованные** отряды. Отряды могут стать деморализованными во время битвы и кладутся на бок, чтобы это обозначить. Деморализованный отряд не может перемещаться или быть использованными для срабатывания способностей боевых карт. Он также не может привносить свои кубы или значение своего боевого духа в битву или орбитальный удар. Чтобы показать восстановление отряда, игрок возвращает его в исходное недеморализованное состояние: ставит фигурку ровно.
+
+<!-- block: rules.refresh.rally.caption; page: 7; kind: caption -->
+Недеморализованный Отряд; Деморализованный Отряд
+
+<!-- block: rules.refresh.events-and-warp-storms; page: 7 -->
+### Возьмите События и Переместите Варп-Штормы
+
+Каждый игрок берет из своей колоды событий количество карт, равное количеству жетонов приказов **на ней**, возвращая жетоны приказов в свой запас неиспользованных жетонов приказов. Жетоны приказов кладутся на верх этой колоды после выполнения Приказа Планирования (подробно объяснено позже).
+
+<!-- block: rules.refresh.events-and-warp-storms.choose-event; page: 7 -->
+Затем, начиная с первого игрока и далее по часовой стрелке, каждый игрок выбирает одну карту события из тех, что он только что вытянул. Он перемещает один варп-шторм по игровому полю, следуя значку движения варп-шторма, изображенному на выбранной им карте (см. «Перемещение варп-шторма» справа). Затем он **может** разыграть способность карты события.
+
+<!-- block: rules.refresh.events-and-warp-storms.event-types; page: 7 -->
+Карты событий бывают двух видов: **тактика** и **план**.
+
+<!-- block: rules.refresh.events-and-warp-storms.event-types.caption; page: 7; kind: caption -->
+Карта Событий «Тактика»; Карта Событий «План»
+
+<!-- block: rules.refresh.events-and-warp-storms.tactic-and-scheme; page: 7 -->
+Разыграв карту события-тактики, игрок замешивает ее обратно в свою колоду событий. Карты событий-планов размещаются лицом вверх рядом с листом фракции игрока, и их эффекты можно использовать в будущем, как описано на карте.
+
+<!-- block: rules.refresh.events-and-warp-storms.reshuffle; page: 7 -->
+После того, как игрок разыграет свою карту события, он замешивает все невыбранные карты событий из своей руки обратно в свою колоду.
+
+<!-- block: rules.refresh.warp-storms; page: 7 -->
+#### Что такое варп-штормы?
+
+В *Forbidden Stars* жетоны варп-штормов размещаются на игровом поле вдоль ребер некоторых тайлов систем. Отряды не могут двигаться сквозь варп-штормы. Варп-штормы перемещаются в конце каждого игрового раунда, превращая игровое поле в постоянно меняющуюся и непредсказуемую среду.
+
+<!-- block: rules.refresh.warp-storm-movement; page: 7 -->
+#### Перемещение Варп-Штормов
+
+Чтобы переместить варп-шторм, игрок выбирает один варп-шторм, **который не перемещали в этой фазе**. Затем он перемещает жетон в одном из двух направлений, указанных значком движения варп-шторма в правой части его карты события.
+
+<!-- block: rules.refresh.warp-storm-movement.icon-caption; page: 7; kind: caption -->
+Иконка Движения Варп-Шторма
+
+<!-- block: rules.refresh.warp-storm-movement.caption; page: 7; kind: caption -->
+Существует восемь направлений, в которых может двигаться варп-шторм.
+
+<!-- block: rules.refresh.warp-storm-movement.no-stacking; page: 7 -->
+Игроки **не могут** переместить жетон варп-шторма на другой варп-шторм.
+
+<!-- block: rules.refresh.warp-storm-movement.must-move; page: 7 -->
+Когда идёт выбор, какой варп-шторм двигать и направление в котором его двигать, игрок всегда должен выбирать тот результат, при котором произойдёт движение варп-шторма, если это возможно.
+
+<!-- block: rules.refresh.warp-storm-movement.no-events; page: 7 -->
+**Важно:** Если игрок не брал карты событий, он все равно должен переместить варп-шторм. Для этого он раскрывает верхнюю карту своей колоды событий и перемещает один варп-шторм, используя значок движения варп-шторма на этой карте, как описано выше. Затем он замешивает карту события обратно в свою колоду, не разыгрывая ее способность.
+
+<!-- block: rules.refresh.end-of-round; page: 8 -->
+### Конец Раунда
+
+Первый игрок отдает жетон первого игрока игроку слева от себя. Затем он передвигает маркер раунда на одно деление по счетчику раундов. Если маркер раунда сдвинется с деления «8» счетчика, игра заканчивается, и игрок с наибольшим количеством маркеров целей выигрывает игру.
+
+<!-- block: rules.victory; page: 8 -->
+## Победа в игре
+
+Игрок выигрывает игру, когда он собрал количество своих маркеров целей, **равное количеству игроков в игре**. Например, во время игры для двух игроков игрок выигрывает игру, когда он собирает два своих маркера целей.
+
+<!-- block: rules.victory.after-round-eight; page: 8 -->
+Если ни один игрок не выиграл игру к концу восьмого игрового раунда, игра заканчивается, и игрок, собравший больше всего маркеров целей, побеждает в игре.
+
+<!-- block: rules.victory.objective-markers; page: 8 -->
+### Что такое маркеры целей?
+
+Маркеры целей представляют собой важные объекты, людей или места, являющиеся ключевыми для выживания фракции. На обратной стороне каждого маркера цели показано, что тематически представляет этот маркер цели. Хотя у каждого маркера есть уникальное изображение, оно несет лишь тематический характер и **не влияет на игровой процесс**. На обратной стороне листа фракции каждого игрока есть краткое описание историй, связанных с его целями.
+
+<!-- block: rules.victory.objective-markers.description-caption; page: 8; kind: caption -->
+Описание Маркера Цели: «Лорд Системы: Лорд Халовар присягнул на верность Империуму. Теперь он просит помощи в избавлении от тьмы.»
+
+<!-- block: rules.victory.objective-markers.face-up; page: 8 -->
+Маркеры целей **всегда остаются лежать лицевой стороной вверх**, чтобы игроки могли видеть символ фракции. Это важно, потому что игрок не может собирать маркеры целей, принадлежащие другим игрокам. Однако игроки могут размещать отряды в мирах, содержащих вражеские маркеры целей, чтобы помешать своим противникам добиться победы.
+
+<!-- block: rules.victory.objective-markers.face-caption; page: 8; kind: caption -->
+Лицевая Сторона Маркера Цели
+
+<!-- block: rules.orders; page: 8 -->
+## Приказы подробно
+
+Каждая фракция имеет по два жетона каждого из четырех типов приказов. Когда игрок выполняет приказ во время Фазы Действий, тайл системы, на котором был размещен приказ, становится **активной системой**. В этом разделе описывается, как игроки выполняют приказы каждого из четырех типов.
+
+<!-- block: rules.orders.deploy; page: 8 -->
+### Приказ Развертывания
+
+Игроки используют Приказ Развертывания, чтобы размещать новые отряды и постройки на игровом поле. Чтобы выполнить Приказ Развертывания, активный игрок совершает следующие два шага **в указанном порядке**:
+
+1. **Покупка Отрядов**: Если у игрока есть фабрика в активной системе, он может купить отряды и разместить их в любых дружественных или неконтролируемых (не содержащих никаких отрядов или построек) областях в активной системе.
+2. **Покупка Построек**: Игрок может купить **одну** постройку и разместить ее в любом дружественном мире в активной системе, где еще нет постройки.
+
+<!-- block: rules.orders.deploy.token-caption; page: 8; kind: caption -->
+Жетон Приказа Развертывания
+
+<!-- block: rules.orders.deploy.purchase-units; page: 8 -->
+#### Покупка Отрядов
+
+Игрок покупает отряд, тратя количество материала, равное стоимости в материалах этого отряда, указанной на его листе фракции. Чтобы потратить материал, игрок поворачивает счетчик материалов на соответствующую величину в меньшую сторону. Затем он размещает отряд в любую **дружественную или неконтролируемую** область в активной системе.
+
+<!-- block: rules.orders.deploy.purchase-units.forge-tokens; page: 8 -->
+Некоторые отряды стоят жетон кузницы в дополнение к их стоимости в материалах. Чтобы потратить жетон кузницы, игрок берет жетон кузницы из своей игровой зоны и возвращает его в запас.
+
+<!-- block: rules.orders.deploy.purchase-units.cost-caption; page: 8; kind: caption -->
+*Схема строки отряда на листе фракции:* Материальная Стоимость Отряда; Требование Жетона Кузницы.
+
+<!-- block: rules.orders.deploy.purchase-units.placement; page: 8 -->
+Игроки могут размещать наземные отряды только в мирах, а корабли — в пустотах. В дополнение к этим основным ограничениям игрок обязан соблюдать ограничения на командный уровень.
+
+<!-- block: rules.orders.deploy.purchase-units.deployment-limit; page: 8 -->
+Максимальное количество отрядов, которое игрок может приобрести в рамках одного Приказа Развертывания, определяется его **лимитом развертывания**. Его лимит развертывания равен вместимости мира активной системы, где расположена фабрика. Вместимость равна количеству черепов на знамени этого мира.
+
+<!-- block: rules.orders.deploy.purchase-units.capacity-caption; page: 8; kind: caption -->
+Вместимость отрядов этого мира равна двум.
+
+<!-- block: rules.orders.deploy.command-level; page: 9 -->
+#### Командный уровень
+
+У каждого игрока есть **командный уровень**, который указывает, какие отряды и улучшения он может купить. Командный уровень игрока равен количеству городов, которые он контролирует.
+
+<!-- block: rules.orders.deploy.command-level.requirements; page: 9 -->
+У каждого отряда и карты улучшения приказа или боевой карты есть требование к командному уровню. Игрок может приобретать отряды и улучшения только с требованиями, равными его командному уровню или меньшими, чем его командный уровень.
+
+<!-- block: rules.orders.deploy.command-level.caption; page: 9; kind: caption -->
+*Схема строки отряда на листе фракции:* Требуемый Командный Уровень Отряда.
+
+<!-- block: rules.orders.deploy.purchase-structures; page: 9 -->
+#### Покупка Построек
+
+Игрок покупает постройку (город, бастион или фабрику), потратив количество материалов, равное стоимости в материалах этой постройки, указанной на его листе фракции. Затем он размещает пластиковую постройку на любой дружественный мир в активной системе поверх одного из своих **маркеров контроля постройки**. Маркер под каждой постройкой указывает, кому принадлежит эта постройка.
+
+<!-- block: rules.orders.deploy.purchase-structures.one-per-world; page: 9 -->
+**Важно:** Игрок не может разместить постройку в мире, в котором уже есть постройка.
+
+<!-- block: rules.orders.deploy.purchase-structures.caption; page: 9; kind: caption -->
+Эта постройка контролируется игроком фракции Эльдар.
+
+<!-- block: rules.orders.dominate; page: 9 -->
+### Приказ Доминирования
+
+Игроки используют Приказы Доминирования, чтобы получать ценные ресурсы с миров и использовать свои особые способности фракции. Чтобы выполнить Приказ Доминирования, активный игрок выполняет следующие шаги по порядку:
+
+<!-- block: rules.orders.dominate.token-caption; page: 9; kind: caption -->
+Жетон Приказа Доминирования
+
+<!-- block: rules.orders.dominate.gain-resources; page: 9 -->
+#### 1. Получение ценных ресурсов
+
+Игрок получает ценные ресурсы, предоставленные каждым дружественным миром в активной системе. Ценные ресурсы отображаются в правом углу знамени мира.
+
+<!-- block: rules.orders.dominate.gain-resources.take-tokens; page: 9 -->
+Игрок берет соответствующие жетоны из запаса и кладет их в свою игровую зону. Если мир предоставляет несколько ценных ресурсов, игрок берет их все.
+
+<!-- block: rules.orders.dominate.faction-ability; page: 9 -->
+#### 2. Использование специальной способности фракции
+
+Игрок может использовать специальную способность, указанную на листе его фракции.
+
+<!-- block: rules.orders.dominate.resources; page: 9 -->
+#### Ценные ресурсы
+
+Игроки могут получить ценные ресурсы с дружественных миров, выполнив Приказ Доминирования. Каждый ценный ресурс имеет уникальный эффект, как описано ниже:
+
+<!-- block: rules.orders.dominate.resources.forge; page: 9 -->
+##### Жетоны Кузницы
+
+Некоторые отряды требуют, чтобы игрок потратил жетон кузницы, чтобы купить их. Это отображается на листе фракции ниже стоимости соответствующего отряда в материалах.
+
+<!-- block: rules.orders.dominate.resources.forge.command-level; page: 9 -->
+В качестве альтернативы игрок может потратить жетон кузницы при покупке отряда, чтобы снизить требование к его командному уровню на **один**. Это позволяет ему купить отряд, который при нормальных условиях не может быть куплен (см. «Командный уровень» слева).
+
+<!-- block: rules.orders.dominate.resources.forge.caption; page: 9; kind: caption -->
+Этот мир предоставляет жетон кузницы.
+
+<!-- block: rules.orders.dominate.resources.supply; page: 9 -->
+##### Жетоны Запасов
+
+При покупке отряда или постройки игрок может потратить жетон запасов, чтобы снизить стоимость в материалах этого отряда или постройки на два.
+
+<!-- block: rules.orders.dominate.resources.supply.caption; page: 9; kind: caption -->
+Этот мир предоставляет жетон запасов.
+
+<!-- block: rules.orders.dominate.resources.reinforcement; page: 9 -->
+##### Жетоны Подкрепления
+
+Во время шага вызова подкреплений во время битвы атакующий, а затем защищающийся могут разместить свои жетоны подкреплений в оспариваемую область.
+
+<!-- block: rules.orders.dominate.resources.reinforcement.unit; page: 9 -->
+Жетон подкрепления остается на время битвы и считается наземным отрядом или кораблем соответствующей фракции нулевого командного уровня. Находясь в области, он соблюдает все правила и ограничения, применимые к отрядам.
+
+<!-- block: rules.orders.dominate.resources.reinforcement.example; page: 9 -->
+Например, каждый жетон подкрепления, который игрок Ультрамаринов размещает в мире, рассматривается как отряд Разведчиков.
+
+<!-- block: rules.orders.dominate.resources.reinforcement.caption; page: 9; kind: caption -->
+Этот мир предоставляет жетон подкрепления.
+
+<!-- block: rules.orders.dominate.resources.prosperity; page: 9 -->
+##### Процветание
+
+Когда игрок получает этот ценный ресурс, он вместо этого получает один жетон ресурса по своему выбору.
+
+<!-- block: rules.orders.dominate.resources.prosperity.caption; page: 9; kind: caption -->
+Этот мир предоставляет один жетон ценного ресурса любого типа
+
+<!-- block: rules.orders.strategize; page: 10 -->
+### Приказ Планирования
+
+Чтобы выполнить Приказ Планирования у игрока должен быть **отряд или постройка в активной системе**. Он может просмотреть все карты в своих колодах улучшений. Затем он может купить одно улучшение приказа и/или одно боевое улучшение, если он соответствует ограничениям командного уровня каждой карты (см. «Командный уровень» на стр. 9). После выполнения этого приказа он кладет жетон приказа **на верх своей колоды событий**, что позволит ему взять карту события во время Фазы Обновления.
+
+<!-- block: rules.orders.strategize.token-caption; page: 10; kind: caption -->
+Жетон Приказа Планирования
+
+<!-- block: rules.orders.strategize.upgrade-cost; page: 10 -->
+Чтобы купить улучшение, игрок должен потратить количество материалов, равное стоимости в материалах, указанной в левом верхнем углу карты улучшения приказа или боевой колоды. Чтобы потратить материалы, игрок поворачивает счетчик материалов на соответствующую величину в меньшую сторону.
+
+<!-- block: rules.orders.strategize.upgrade-cost.caption; page: 10; kind: caption -->
+*Схема карты улучшения:* Требуемый Командный Уровень Улучшения; Материальная Стоимость Улучшения.
+
+<!-- block: rules.orders.strategize.upgrade-types; page: 10 -->
+Существует два типа улучшений: **улучшения приказов** и **боевые улучшения**, а именно:
+
+- **Улучшения Приказов:** Улучшения приказов повышают функциональность жетонов приказов. После покупки улучшения приказа игрок помещает его в свою игровую зону рядом со своим листом фракции. Каждое улучшение приказа соответствует одному из четырех приказов (Развертывание, Планирование, Доминирование, Продвижение) и дает игроку преимущество при выполнении соответствующего приказа.
+- **Боевые Улучшения:** Боевые улучшения — это более мощные боевые карты, которые игрок добавляет в свою боевую колоду.
+
+<!-- block: rules.orders.strategize.upgrade-types.caption; page: 10; kind: caption -->
+Карта Улучшения Приказов («Крестовый поход»); Карта Боевого Улучшения («Держать строй»)
+
+<!-- block: rules.orders.strategize.combat-upgrades; page: 10 -->
+#### Покупка боевых улучшений
+
+Игрок покупает карты боевых улучшений парами. Когда игрок покупает одну карту боевого улучшения, он получает **обе копии карты**.
+
+<!-- block: rules.orders.strategize.combat-upgrades.swap; page: 10 -->
+Когда игрок покупает пару боевых карт, он должен убрать две копии любой другой карты из своей боевой колоды и поместить их обе в свою колоду боевых улучшений. Затем он добавляет обе копии купленного улучшения в свою боевую колоду и перемешивает колоду.
+
+<!-- block: rules.orders.strategize.combat-upgrades.deck-size; page: 10 -->
+Боевая колода всегда содержит две копии пяти карт, что в сумме дает десять карт.
+
+<!-- block: rules.orders.advance; page: 10 -->
+### Приказ Продвижения
+
+Игроки используют Приказы Продвижения для перемещения отрядов и начала битв. Чтобы выполнить Приказ Продвижения, игрок перемещает отряды **в активную систему**. После перемещения отрядов игрок разрешает битву, если есть **оспариваемая область** — область, в которой есть как дружественные, так и вражеские отряды или постройки.
+
+<!-- block: rules.orders.advance.token-caption; page: 10; kind: caption -->
+Жетон Приказа Продвижения
+
+<!-- block: rules.orders.advance.steps; page: 10 -->
+Чтобы выполнить Приказ Продвижения, активный игрок совершает следующие шаги по порядку:
+
+1. **Перемещение Кораблей:** Активный игрок может переместить свои корабли в активной системе и из одной соседней системы в любые пустоты в активной системе.
+2. **Перемещение Наземных Отрядов:** Активный игрок может переместить свои наземные отряды в активной системе и из одной соседней системы в любые миры в активной системе. Если он перемещал корабли из соседней системы, он не может перемещать наземные отряды из другой соседней системы.
+3. **Разрешение Битвы:** Активный игрок разрешает битву, если есть оспариваемая область (см. «Битва» на стр. 12). Если оспариваемой области нет, он может вместо этого провести орбитальный удар (см. «Орбитальный удар» на стр. 11).
+
+<!-- block: rules.orders.advance.limits; page: 10 -->
+**Важно:** Отряды **не могут двигаться через варп-штормы**, и игрок может создать **максимум одну** оспариваемую область при выполнении Приказа Продвижения. Игрок может переместить любое количество отрядов Приказом Продвижения, но **максимум пять отрядов** могут закончить свое перемещение в каждой области.
+
+<!-- block: rules.orders.advance.ship-movement; page: 10 -->
+#### Перемещение Кораблей
+
+При перемещении корабля игрок может переместить корабль из пустоты, которую он в данный момент занимает, в любую пустоту в активной системе, даже если эти две области не являются соседними.
+
+<!-- block: rules.orders.advance.ground-movement; page: 10 -->
+#### Перемещение Наземных Отрядов
+
+При перемещении наземного отряда игрок может переместить отряд из мира, в котором он находится в данный момент, в любой мир в активной системе, соединенной **путем**. Путь представляет собой ряд соседних (не по диагонали) дружественных областей. Путь может состоять из миров, пустот или их сочетаний (см. «Пример Приказа Продвижения» на стр. 11).
+
+<!-- block: rules.orders.advance.ground-movement.adjacent-worlds; page: 10 -->
+Наземные отряды могут перемещаться из одного мира в соседний без использования корабля. Тематически они используют невоенные транспортные корабли или другие простые формы передвижения, не представленные в игре. Количество отрядов, которые игрок может перемещать через дружественную область, не ограничено.
+
+<!-- block: rules.orders.advance.capacity; page: 10 -->
+#### Вместимость Отрядов
+
+Каждая область имеет **вместимость**. Вместимость пустоты равна трем, а вместимость каждого мира равна количеству значков черепа, представленных на знамени мира. Вместимость области указывает **максимальное количество отрядов**, которые могут существовать в области после полного выполнения приказа.
+
+<!-- block: rules.orders.advance.capacity.caption; page: 10; kind: caption -->
+Вместимость Отрядов Мира
+
+<!-- block: rules.orders.advance.example; page: 11; kind: example -->
+#### Пример Приказа Продвижения
+
+1. Настала очередь игрока за Ультрамаринов разыгрывать приказ, поэтому он раскрывает один из своих Приказов Продвижения переворачивая его лицевой стороной вверх.
+2. Сначала он должен переместить корабли. У него нет кораблей в активной системе, поэтому он перемещает Ударный Крейсер из соседней системы в пустоту в активной системе.
+3. Затем игрок решает переместить некоторые из своих наземных отрядов из соседней системы в активную систему. Теперь, когда у него есть корабль в пустоте, он может перемещать через нее наземные отряды. Он перемещает своих Космодесантников через пустоту в мир в правом верхнем углу активной системы.
+4. Затем игрок перемещает своего Разведчика через пустоту в мир в левом нижнем углу активной области.
+5. Наконец, игрок решает переместить своего Разведчика, который уже был в активной системе, в соседний мир в правом нижнем углу.
+
+<!-- block: rules.orbital-strike; page: 11 -->
+## Орбитальный удар
+
+После выполнения Приказа Продвижения, если нет оспариваемых областей (и, следовательно, битва не начиналась), активный игрок может выполнить орбитальный удар.
+
+<!-- block: rules.orbital-strike.procedure; page: 11 -->
+Чтобы выполнить орбитальный удар, игрок выбирает вражеский мир в активной системе. Затем он выбирает одну пустоту в активной системе, соседнюю этому миру. Он бросает количество кубиков, равное общей боевой мощи всех его кораблей в этой пустоте.
+
+<!-- block: rules.orbital-strike.damage; page: 11 -->
+Вражеские отряды в выбранном мире получают урон, равный количеству выпавших значков атаки ([куб: атака]). Боевая мощь и получение урона подробно объясняются позже.
+
+<!-- block: rules.orbital-strike.bastion; page: 11 -->
+Игрок не может выполнить орбитальный удар по миру, содержащему бастион. Бастионы описаны позже.
+
+<!-- block: rules.battle; page: 12 -->
+## Битва
+
+После того, как игрок перемещает отряды с помощью Приказа Продвижения, он должен разыграть битву, если у него есть отряды в области, содержащей как дружественные, так и вражеские отряды или постройки (т. е. оспариваемой области). Во время битвы игрок, выполняющий Приказ Продвижения, является **атакующим**, а другой игрок - **защищающимся**.
+
+<!-- block: rules.battle.overview; page: 12 -->
+В битвах в *Forbidden Stars* используется комбинация кубов и карт. Игроки начинают битву, бросая кубы в зависимости от боевой мощи своих отрядов. Затем они разыгрывают боевые карты, чтобы активировать специальные способности и получить боевые знаки, кубы и боевые жетоны. Игрок с наибольшим значением боевого духа ([мораль]) в конце битвы становится победителем, а его противник должен отступить.
+
+Битва состоит из следующих шагов:
+
+<!-- block: rules.battle.preparation; page: 12 -->
+### 1. Подготовка
+
+Игроки готовятся к битве, выполняя следующие подшаги:
+
+<!-- block: rules.battle.preparation.roll-dice; page: 12 -->
+#### а. Бросьте Кубы
+
+И нападающий, и защищающийся одновременно бросают количество кубов, равное суммарной **боевой мощи** всех его недеморализованных отрядов в бою. Боевая мощь отрядов игрока указана на его листе фракции. Например, если игрок за Ультрамаринов имеет в бою два Ленд Рейдера, он бросает шесть кубов.
+
+<!-- block: rules.battle.preparation.roll-dice.caption; page: 12; kind: caption -->
+Боевая Мощь Отряда На Листе Фракции
+
+<!-- block: rules.battle.preparation.roll-dice.group; page: 12 -->
+Каждый игрок распределяет свои брошенные кубы по группам с одинаковыми значками, чтобы и он, и его противник могли легко оценить результаты.
+
+<!-- block: rules.battle.preparation.draw-cards; page: 12 -->
+#### б. Возьмите Боевые Карты
+
+Каждый игрок берет пять боевых карт с верха своей боевой колоды.
+
+<!-- block: rules.battle.preparation.reinforcements; page: 12 -->
+#### в. Шаг Вызова Подкреплений
+
+Сначала у атакующего, а затем у защищающегося есть возможность разместить несколько своих жетонов подкреплений рядом со своими отрядами в оспариваемой области. Количество жетонов подкреплений, которое может разместить игрок, равно количеству его отрядов в битве (см. «Ценные ресурсы» на стр. 9).
+
+<!-- block: rules.battle.round; page: 12 -->
+### 2. Раунд битвы
+
+Игроки играют до трех раундов битвы, разыгрывая боевые карты со своих рук. Во время **каждого раунда битвы** игроки выполняют следующие подшаги:
+
+<!-- block: rules.battle.round.choose-card; page: 12 -->
+#### а. Выберите Боевую Карту
+
+Атакующий и защищающийся одновременно выбирают по одной боевой карте с руки и кладут выбранную карту лицевой стороной вниз в игровую зону.
+
+<!-- block: rules.battle.round.resolve-card; page: 12 -->
+#### б. Разыграйте Боевую Карту
+
+Атакующий раскрывает и разыгрывает свою боевую карту. Затем защитник раскрывает и разыгрывает свою боевую карту, как описано на стр. 13.
+
+<!-- block: rules.battle.round.damage; page: 12 -->
+#### в. Шаг Нанесения Повреждений
+
+Начиная с атакующего, оба игрока должны получить урон, равный общему количеству значков атаки его противника ([атака]) с кубов, боевых жетонов и открытых боевых карт. Каждый значок защиты ([защита]), который есть у игрока (с кубов, боевых жетонов и его открытых боевых карт), уменьшает количество получаемого урона на один. Правила получения урона объясняются на стр. 13.
+
+<!-- block: rules.battle.round.damage.caption; page: 12; kind: caption -->
+Игрок Ультрамаринов в общей сложности имеет три знака атаки ([атака]) и четыре защиты ([защита]).
+
+<!-- block: rules.battle.round.damage.sole-survivor; page: 12 -->
+После того, как оба игрока получили урон, если только у одного игрока остались отряды и/или бастионы в области, он побеждает в битве и переходит к подэтапу «Захватите постройки», как описано ниже.
+
+<!-- block: rules.battle.resolution; page: 12 -->
+### 3. Разрешение
+
+После завершения третьего раунда битвы игроки заканчивают битву, выполнив следующие подшаги:
+
+<!-- block: rules.battle.resolution.determine-winner; page: 12 -->
+#### а. Определите Победителя
+
+Игрок с наибольшим суммарным значением боевого духа побеждает в бою (защитник побеждает при ничье), а вражеские отряды должны отступить (объясняется позже).
+
+<!-- block: rules.battle.resolution.determine-winner.total-morale; page: 12 -->
+Игрок определяет свой суммарный боевой дух, складывая количество значков своего боевого духа ([мораль]) на своих кубах и боевых картах, лежащих лицом вверх, а также значения боевого духа и на листе своей фракции, которые соответствуют каждому из его бастионов и недеморализованных отрядов в битве.
+
+<!-- block: rules.battle.resolution.determine-winner.caption; page: 12; kind: caption -->
+Боевой Дух Отряда На Листе Фракции
+
+<!-- block: rules.battle.resolution.capture-structures; page: 12 -->
+#### б. Захватите Постройки
+
+Если атакующий побеждает в битве, он получает контроль над всеми постройками в мире, убирая маркеры контроля построек противника и заменяя их своими собственными.
+
+<!-- block: rules.battle.resolution.cleanup; page: 12 -->
+#### в. Очистка
+
+Каждый игрок сбрасывает все жетоны подкреплений, которые он использовал, в запас и замешивает все свои боевые карты обратно в свою боевую колоду.
+
+<!-- block: rules.battle.resolving-cards; page: 13 -->
+### Розыгрыш Боевых Карт
+
+Все боевые карты имеют одну или две ячейки боевых способностей. Разыгрывая боевую карту, игрок сначала применяет все общие способности (зеленая ячейка), а затем применяет все способности отрядов (коричневая ячейка). Он применяет каждую способность в том порядке, в котором она указана, сверху вниз.
+
+<!-- block: rules.battle.resolving-cards.unit-abilities; page: 13 -->
+Способностям отрядов всегда предшествует хотя бы одно имя отряда. Чтобы использовать способность отрядов, игрок должен иметь хотя бы один из перечисленных отрядов в бою, и этот отряд должен быть недеморализованным.
+
+<!-- block: rules.battle.resolving-cards.caption; page: 13; kind: caption -->
+*Схема боевой карты:* Общая Способность — «Получите 2 [жетон: защита].»; Способность Отрядов — «Бастион/Космодесантник/Ударный Крейсер: Переверните до 2 ваших кубов на [куб: защита].»
+
+Чтобы воспользоваться способностью отрядов, у игрока должен быть хотя бы один Бастион или недеморализованный Космодесантник или недеморализованный Ударный Крейсер в битве.
+
+<!-- block: rules.battle.card-icons; page: 13 -->
+### Значки Боевых Карт
+
+Большинство боевых карт содержат один или несколько боевых значков ([атака], [защита], [мораль]) в левой части карты. Эти значки действуют так же, как значки на кубах, и сохраняются до конца битвы.
+
+<!-- block: rules.battle.card-icons.caption; page: 13; kind: caption -->
+Значки на Боевой Карте («Не показывать страха»)
+
+<!-- block: rules.battle.dice; page: 13 -->
+### Боевые Кубы
+
+Когда игрок получает [куб: атака], [куб: защита] или [куб: мораль] от способности, он берет один кубик из запаса неиспользованных кубов и кладет его рядом с другими кубами указанным значком вверх. Когда игрок теряет куб, он берет один из своих кубов с соответствующим значком и возвращает его в запас.
+
+<!-- block: rules.battle.dice.roll-extra; page: 13 -->
+Если игровой эффект позволяет игроку получить [куб], он берет куб из запаса, бросает его и кладет его вместе с другими своими кубами.
+
+<!-- block: rules.battle.dice.limit; page: 13 -->
+**Важно:** Атакующий и защищающийся ограничены **восьмью кубами** во время битвы.
+
+<!-- block: rules.battle.tokens; page: 13 -->
+### Боевые Жетоны
+
+Некоторые способности боевых карт предоставляют игрокам боевые жетоны, представленные значками боевых жетонов ([жетон: атака] и [жетон: защита]). Когда игрок получает [жетон: атака] или [жетон: защита], он берет боевой жетон из резерва и кладет его соответствующей стороной вверх рядом со своими кубами. При расчете атаки или защиты во время битвы боевые жетоны игрока добавляются к его окончательному значению. Все боевые жетоны являются **временными** и возвращаются в запас в конце раунда битвы, в котором они были получены.
+
+<!-- block: rules.battle.tokens.caption; page: 13; kind: caption -->
+Жетоны Сражения
+
+<!-- block: rules.battle.taking-damage; page: 13 -->
+### Получение Урона
+
+Когда игрок получает урон, он обязан выбрать один дружественный отряд в оспариваемой области, который получит урон. Этот отряд должен быть недеморализованным, кроме ситуаций, когда все отряды деморализованы. Если урон равен **показателю здоровья** выбранного отряда или превышает его, этот отряд **уничтожается** и удаляется с игрового поля.
+
+<!-- block: rules.battle.taking-damage.caption; page: 13; kind: caption -->
+Показатель Здоровья Отряда на Листе Фракции
+
+<!-- block: rules.battle.taking-damage.excess; page: 13 -->
+Если урон ниже показателя здоровья выбранного отряда, этот отряд становится деморализованным. Если урон **превышает** показатель здоровья выбранного отряда, любой урон, превышающий показатель здоровья отряда, должен быть нанесен другому дружественному отряду. Игрок повторяет этот процесс до тех пор, пока либо не останется урона, либо не останется больше отрядов.
+
+<!-- block: rules.battle.taking-damage.orbital-strike; page: 13 -->
+**Важно:** При получении урона во время орбитального удара любые неуничтоженные отряды **не становятся деморализованными**.
+
+<!-- block: rules.battle.taking-damage.example; page: 13; kind: example -->
+*Пример:* У игрока за Ультрамаринов в битве два Разведчика. В течение первого раунда битвы он должен получить три урона. Он выбирает одного из своих Разведчиков, который первым получит урон. Он сравнивает свои два здоровья с тремя единицами урона; поскольку показатель здоровья Разведчика равно или меньше урона, он уничтожается. Затем игрок назначает один оставшийся урон другому своему Разведчику. Этот отряд не уничтожается, а становится деморализованным, а урон отбрасывается, потому что показатель здоровья отряда превышает урон.
+
+<!-- block: rules.battle.routed-units; page: 13 -->
+### Деморализованные Отряды
+
+Отряды могут стать **деморализованными** из-за способностей боевых карт, отступления или получения урона, который меньше их показателей здоровья. При деморализации отряда пластиковая модель кладется на бок. Если отряд представлен жетоном подкрепления, этот жетон переворачивается на деморализованную сторону.
+
+<!-- block: rules.battle.routed-units.effects; page: 13 -->
+Деморализованные отряды не добавляют значение своего боевого духа ([мораль]) при определении победителя боя и не могут удовлетворять требованиям отрядов на боевой карте. Кроме того, игрок **не может назначать урон** деморализованному отряду, если у него есть один или несколько недеморализованных отрядов или бастионов в области. Во время Фазы Обновления все деморализованные отряды восстанавливаются: пластиковые модели поднимаются вертикально.
+
+<!-- block: rules.battle.bastions; page: 13 -->
+### Бастионы
+
+Бастионы не являются отрядами, но они добавляют кубы и свои значения боевого духа во время битвы. Кроме того, бастионы могут быть выбраны для получения урона. Если бастион получает урон, равный показателю его здоровья, он удаляется с игрового поля и возвращается в запас. Бастионы не могут стать деморализованными.
+
+<!-- block: rules.battle.example-part-1; page: 14; kind: example -->
+### Пример битвы часть I
+
+1. Игрок за Ультрамаринов (синий) выполняет Приказ Продвижения. После перемещения своих отрядов у него есть два отряда в области с двумя эльдарскими отрядами. Игроки за Ультрамаринов и Эльдар теперь должны разрешить битву.
+2. Игроки сверяются с листами своих фракций, чтобы определить, сколько кубов дают их отряды. Оба игрока одновременно бросают свои кубы.
+
+   Затем каждый игрок берет пять карт из своей боевой колоды и держит эти карты скрытыми друг от друга.
+
+**Первый раунд битвы:** Каждый игрок выбирает боевую карту из своей руки и кладет ее лицом вниз перед собой. Затем игроки выполняют следующие шаги:
+
+3. Игрок за Ультрамаринов является атакующим, поэтому он первым раскрывает и разыгрывает свою карту. Сначала он применяет общую способность в зеленой ячейке, что дает ему два боевых жетона защиты.
+4. Затем он применяет способность отрядов в коричневой ячейке. У него есть отряд Космодесантников, необходимый для применения этой способности, поэтому он решает перевернуть один из своих [куб: атака] кубов в [куб: защита] куб.
+5. Игрок за Эльдар раскрывает и разыгрывает свою карту. Сначала он применяет общую способность в зеленой ячейке, что дает ему один куб. Он бросает куб и кладет его рядом с остальными кубами.
+6. Затем игрок за Эльдар применяет способность отрядов в коричневой ячейке. У него есть Аспектный Воин, и он решает потратить [куб: мораль] куб, чтобы вынудить своего противника выбрать и деморализовать один свой отряд. Игрок за Ультрамаринов решает деморализовать одного из своих Разведчиков.
+
+В качестве последнего шага этого раунда битвы игроки должны получить урон. Каждый игрок подсчитывает количество имеющихся у него боевых значков на своих кубах, своих боевых картах и своих боевых жетонах.
+
+Ни один из игроков не имеет больше значков атаки ([атака]), чем значков защиты его противника ([защита]), поэтому ни один из игроков не получает урон.
+
+Игроки сбрасывают все боевые жетоны, затем проводят следующий раунд битвы(см. «Пример битвы, часть II» на стр. 15).
+
+<!-- block: rules.battle.example-part-2; page: 15; kind: example -->
+### Пример битвы часть II
+
+**Второй Раунд Битвы:** Каждый игрок выбирает боевую карту из своей руки и кладет ее лицом вниз перед собой. Затем игроки выполняют следующие шаги:
+
+7. Игрок за Ультрамаринов раскрывает и разыгрывает свою карту. Сначала он применяет общую способность в зеленой ячейке, что дает ему один куб. Он бросает куб и кладет его рядом с остальными своими кубами.
+8. Затем он применяет способность отрядов в коричневой ячейке. У него есть отряд Космодесантников, необходимый для применения этой способности, поэтому он выбирает восстановить своего Разведчика.
+9. Затем игрок за Эльдар раскрывает и разыгрывает свою карту. Сначала он применяет общую способность в зеленой ячейке, что дает ему два боевых жетона атаки.
+10. Теперь игрок за Эльдар может применить способность в коричневой ячейке, но он решает это не делать.
+11. Каждый игрок подсчитывает количество значков атаки ([атака]) на его кубах, боевых картах и боевых жетонах.
+
+    Игрок за Эльдар — единственный игрок, у которого больше значков атаки ([атака]), чем значков защиты ([защита]) его противника. У него шесть значков атаки, а у его противника — два значка защиты, поэтому его противник получает четыре урона.
+12. Игрок за Ультрамаринов решает сначала распределить урон на Разведчика. У него всего два здоровья и он уничтожен. Остальные два урона распределяются на другой его отряд, у которого три здоровья. Этого урона недостаточно для его уничтожения, поэтому отряд становится деморализованным.
+
+Игроки сбрасывают все боевые жетоны. Поскольку у обоих игроков остались отряды, они разыгрывают еще один раунд битвы. Если у обоих игроков есть хотя бы по одному выжившему отряду, игрок с наибольшим суммарным значением боевого духа в конце этого раунда битвы побеждает в битве, а его противник должен отступить всеми своими отрядами.
+
+<!-- block: rules.battle.retreat; page: 15 -->
+### Отступление
+
+Отряды должны отступить, когда они проигрывают битву. Кроме того, некоторые способности боевых карт могут заставить отряды отступить. После отступления отряды становятся деморализованными.
+Атакующие и защищающиеся отряды следуют разным правилам отступления, а именно:
+
+<!-- block: rules.battle.retreat.attacker; page: 15 -->
+#### Атакующий отступает
+
+Когда атакующий отступает, он должен переместить все свои оставшиеся отряды из оспариваемой области в другую область — корабли должны отступить в пустоту, а наземные отряды должны отступить в мир по легальному пути перемещения.
+
+<!-- block: rules.battle.retreat.attacker.same-area; page: 15 -->
+Все отступающие отряды обязаны переместиться в одну и ту же область, и это должна быть область, из которой изначально переместился хотя бы один из отрядов в битве.
+
+<!-- block: rules.battle.retreat.defender; page: 15 -->
+#### Защищающийся отступает
+
+Когда защищающийся отступает, он должен переместить все свои оставшиеся отряды из оспариваемой области в дружественную или неконтролируемую область в активной системе или соседней системе — корабли должны отступить в пустоту, а наземные отряды должны отступить в мир по легальному пути перемещения. Все отступающие отряды должны переместиться в одну и ту же область. Если защищающийся может отступить как в дружественную, так и в неконтролируемую область, он обязан отступить в дружественную область.
+
+<!-- block: rules.board-building.stop; page: 16 -->
+## Стоп!
+
+Теперь вы знаете все правила, необходимые для вашей первой игры. Поиграв со схемой *«Расстановка к Первой Игре»*, вы готовы изучить дополнительные правила на этой странице.
+
+<!-- block: rules.board-building; page: 16 -->
+## Создание игрового поля
+
+После игры с использованием игрового поля, представленного на схеме *«Расстановка к Первой Игре»*, игроки готовы играть, создав уникальное игровое поле во время подготовки к игре самостоятельно.
+
+<!-- block: rules.board-building.steps; page: 16 -->
+Сборка игрового поля — это стратегическое упражнение, в котором игроки выбирают, где размещать тайлы системы и где размещать свои первоначальные силы. На шаге подготовки к игре «Сборка игрового поля» игроки выполняют следующие действия:
+
+<!-- block: rules.board-building.distribute-tiles; page: 16 -->
+### 1. Распределите Тайлы Систем
+
+Каждый игрок получает тайл системы, на котором есть значок его фракции. Затем первый игрок берет все тайлы систем, на которых нет значков фракций, перемешивает их под столом и раздает по два каждому игроку.
+
+<!-- block: rules.board-building.distribute-objectives; page: 16 -->
+### 2. Распределите маркеры целей
+
+Каждый игрок отдает по два своих маркера целей каждому другому игроку и возвращает оставшиеся маркеры в коробку с игрой.
+
+<!-- block: rules.board-building.assemble; page: 16 -->
+### 3. Соберите игровое поле
+
+Начиная с первого игрока и далее по **часовой стрелке**, каждый игрок размещает один тайл системы в игровой зоне следующим образом:
+
+<!-- block: rules.board-building.assemble.place-tile; page: 16 -->
+#### а. Разместите Тайл Системы
+
+Игрок выбирает один из своих тайлов системы и кладет его рядом хотя бы с одним другим тайлом системы (см. «Пример размещения тайла» справа).
+
+<!-- block: rules.board-building.assemble.place-forces; page: 16 -->
+#### б. Разместите Отряды и Постройки
+
+Игрок может разместить любое количество компонентов со своего листа фракции (в ячейке «Стартовые силы») на тайл, который он только что разместил.
+
+<!-- block: rules.board-building.assemble.place-objectives; page: 16 -->
+#### в. Разместите Маркеры Целей
+
+Игрок **обязан** разместить один из маркеров целей противника **на каждую ячейку для маркеров целей** на только что размещенном тайле системы, соблюдая следующие ограничения:
+
+- Игрок не может размещать два маркера одной и той же фракции на одном тайле системы.
+- Игрок не может разместить маркер цели, принадлежащий одной фракции, если у него больше маркеров цели, принадлежащих другой фракции.
+- После того, как он разместил все тайлы, полученные на шаге 2, он больше не размещает маркеров целей.
+
+<!-- block: rules.board-building.assemble.objective-zone-caption; page: 16; kind: caption -->
+Зона Размещения Маркера Целей
+
+<!-- block: rules.board-building.assemble.repeat; page: 16 -->
+Игроки повторяют этот процесс до тех пор, пока каждый игрок не поместит все свои тайлы системы и все свои компоненты, перечисленные в поле «Стартовые силы» на листе своей фракции.
+
+<!-- block: rules.board-building.warp-storms; page: 16 -->
+### 4. Разместите Варп-Штормы
+
+Начиная с игрока, **разместившего последнюю систему**, и далее **против часовой стрелки**, каждый игрок размещает один варп-шторм вдоль любого ребра любого тайла системы; это может быть внешнее ребро - край игрового поля.
+
+<!-- block: rules.board-building.tile-placement; page: 16 -->
+### Размещение Тайлов Системы
+
+При размещении тайла системы игрок может разместить либо тайл своей фракции, либо любой другой тайл. Он может положить тайл любой стороной вверх и в любой ориентации; однако после того, как первый игрок поместит свой первый тайл системы, все остальные тайлы должны быть размещены **по соседству** с другим тайлом.
+
+<!-- block: rules.board-building.tile-placement.max-size; page: 16 -->
+Игрок **не может размещать тайл** таким образом, чтобы он нарушал максимальный размер игрового поля. Этот размер варьируется в зависимости от количества игроков:
+
+- **Два Игрока:** Три тайла на два тайла
+- **Три Игрока:** Три тайла на три тайла
+- **Четыре Игрока:** Три тайла на четыре тайла
+
+<!-- block: rules.board-building.tile-placement.orientation; page: 16 -->
+Ориентация игрового поля не определяется до тех пор, пока максимальное количество тайлов не будет размещено в одном ряду или столбце. Например, игра для четырех игроков может быть либо шириной в четыре тайла, либо высотой в четыре тайла. Это определяется, как только четвертый тайл размещается в строке или столбце.
+
+<!-- block: rules.board-building.tile-placement.example; page: 16; kind: example -->
+#### Пример размещения тайла
+
+Настала очередь игрока за Эльдар размещать тайл во время игры вчетвером. Он решает разместить тайл своей фракции.
+
+Он может разместить тайл своей фракции в любом из восьми возможных мест, обведенных зеленым.
+Он не может разместить свой тайл ни на одной из трех ячеек на концах, потому что это нарушит максимальный размер игрового поля, отведенный для игры вчетвером, который составляет три тайла на четыре тайла.

frontend/src/api/queryKeys.ts

@@ -1,3 +1,5 @@
+import type { QueryClient } from "@tanstack/react-query";
+
 export const qk = {
   me: ["me"] as const,
   adminMe: ["adminMe"] as const,
@@ -19,19 +21,22 @@ export const qk = {
   authConfig: ["authConfig"] as const,
   invitations: ["invitations"] as const,
   notifications: ["notifications"] as const,
+  announcements: ["announcements"] as const,
   devUsers: ["devUsers"] as const,
   adminUsers: ["adminUsers"] as const,
   adminGroups: ["adminGroups"] as const,
   adminMatches: ["adminMatches"] as const,
   adminLogs: ["adminLogs"] as const,
   adminAchievements: ["adminAchievements"] as const,
+  adminAnnouncements: ["adminAnnouncements"] as const,
 };
 
 /**
- * Ключи, которые протухают от любой партии: конкретных участников мы не знаем
- * (событие приходит на всю группу), поэтому инвалидируем по префиксу. Один
- * список на SSE-обработчик и на завершение партии — иначе переименование ключа
- * в этом файле тихо разойдётся с местами, где он написан строкой.
+ * Ключи, которые протухают от любой завершённой партии: рейтинг общий и считается по
+ * всей истории (#80), так что партия двигает топ, историю и профили всех, кто играл
+ * после неё. Поэтому инвалидируем по префиксу. Один список на SSE-обработчик и на
+ * мутации партии — иначе переименование ключа тихо разойдётся с местами, где он
+ * написан строкой.
  */
 export const matchAffectedKeys = [
   qk.home,
@@ -40,3 +45,15 @@ export const matchAffectedKeys = [
   ["userMatches"],
   ["publicProfile"],
 ] as const;
+
+/**
+ * Все рейтинговые витрины, включая статистику любой группы: рейтинг игроков в ней
+ * общий, так что его двигает и партия другой группы (#88). Перезапрашиваются только
+ * открытые на экране запросы, остальные лишь помечаются устаревшими.
+ */
+export function invalidateRatingViews(qc: QueryClient) {
+  for (const key of matchAffectedKeys) qc.invalidateQueries({ queryKey: key });
+  qc.invalidateQueries({
+    predicate: (q) => q.queryKey[0] === "group" && q.queryKey[2] === "stats",
+  });
+}

frontend/src/api/schema.d.ts

@@ -377,8 +377,11 @@ export interface paths {
         delete?: never;
         options?: never;
         head?: never;
-        /** Rename Group */
-        patch: operations["rename_group_api_groups__group_id__patch"];
+        /**
+         * Update Group
+         * @description Название и домашние правила группы; меняются только переданные поля.
+         */
+        patch: operations["update_group_api_groups__group_id__patch"];
         trace?: never;
     };
     "/api/groups/{group_id}/expansions": {
@@ -839,6 +842,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/announcements/pending": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Pending */
+        get: operations["pending_api_announcements_pending_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/announcements/{announcement_id}/ack": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Acknowledge */
+        post: operations["acknowledge_api_announcements__announcement_id__ack_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/admin/auth/login": {
         parameters: {
             query?: never;
@@ -1137,6 +1174,62 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/admin/announcements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List Announcements */
+        get: operations["list_announcements_api_admin_announcements_get"];
+        put?: never;
+        /** Create Announcement */
+        post: operations["create_announcement_api_admin_announcements_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/announcements/{announcement_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Update Announcement */
+        put: operations["update_announcement_api_admin_announcements__announcement_id__put"];
+        post?: never;
+        /** Delete Announcement */
+        delete: operations["delete_announcement_api_admin_announcements__announcement_id__delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/announcements/{announcement_id}/stop": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Stop Announcement
+         * @description «Снять с показа»: период идущего объявления заканчивается сейчас.
+         */
+        post: operations["stop_announcement_api_admin_announcements__announcement_id__stop_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/admin/audit-logs": {
         parameters: {
             query?: never;
@@ -1274,6 +1367,36 @@ export interface components {
             /** Group Id */
             group_id?: number | null;
         };
+        /** AdminAnnouncementRead */
+        AdminAnnouncementRead: {
+            /** Id */
+            id: number;
+            /** Title */
+            title: string;
+            /** Body Html */
+            body_html: string;
+            /** Starts At */
+            starts_at: string;
+            /** Ends At */
+            ends_at: string;
+            /** Show To New Players */
+            show_to_new_players: boolean;
+            /** Revision */
+            revision: number;
+            /**
+             * Status
+             * @enum {string}
+             */
+            status: "planned" | "live" | "finished";
+            /** Seen Count */
+            seen_count: number;
+            /** Audience Count */
+            audience_count: number;
+            /** Created At */
+            created_at: string;
+            /** Updated At */
+            updated_at: string;
+        };
         /** AdminGroupRead */
         AdminGroupRead: {
             /** Id */
@@ -1307,7 +1430,7 @@ export interface components {
             /** Duration Minutes */
             duration_minutes?: number | null;
             /** Win Reason */
-            win_reason?: ("objectives" | "worlds" | "plastic" | "resources") | null;
+            win_reason?: ("objectives" | "worlds" | "plastic" | "resources" | "last_standing") | null;
             /** Player Count */
             player_count: number;
             /** Created By */
@@ -1358,6 +1481,76 @@ export interface components {
             /** Is Active */
             is_active?: boolean | null;
         };
+        /** AnnouncementAck */
+        AnnouncementAck: {
+            /** Revision */
+            revision: number;
+        };
+        /** AnnouncementRead */
+        AnnouncementRead: {
+            /** Id */
+            id: number;
+            /** Title */
+            title: string;
+            /** Body Html */
+            body_html: string;
+            /** Revision */
+            revision: number;
+            /**
+             * Updated
+             * @default false
+             */
+            updated: boolean;
+        };
+        /** AnnouncementUpdate */
+        AnnouncementUpdate: {
+            /** Title */
+            title: string;
+            /** Body Html */
+            body_html: string;
+            /**
+             * Starts At
+             * Format: date-time
+             */
+            starts_at: string;
+            /**
+             * Ends At
+             * Format: date-time
+             */
+            ends_at: string;
+            /**
+             * Show To New Players
+             * @default true
+             */
+            show_to_new_players: boolean;
+            /**
+             * Reshow
+             * @default false
+             */
+            reshow: boolean;
+        };
+        /** AnnouncementWrite */
+        AnnouncementWrite: {
+            /** Title */
+            title: string;
+            /** Body Html */
+            body_html: string;
+            /**
+             * Starts At
+             * Format: date-time
+             */
+            starts_at: string;
+            /**
+             * Ends At
+             * Format: date-time
+             */
+            ends_at: string;
+            /**
+             * Show To New Players
+             * @default true
+             */
+            show_to_new_players: boolean;
+        };
         /** AttachmentRead */
         AttachmentRead: {
             /** Id */
@@ -1576,6 +1769,11 @@ export interface components {
              * @default []
              */
             expansion_ids: number[];
+            /**
+             * Nine Rounds Rule
+             * @default false
+             */
+            nine_rounds_rule: boolean;
         };
         /** GroupExpansionsUpdate */
         GroupExpansionsUpdate: {
@@ -1585,11 +1783,6 @@ export interface components {
              */
             expansion_ids: number[];
         };
-        /** GroupRename */
-        GroupRename: {
-            /** Name */
-            name: string;
-        };
         /** GroupStats */
         GroupStats: {
             /** Group Id */
@@ -1621,6 +1814,13 @@ export interface components {
             /** Min Games */
             min_games: number;
         };
+        /** GroupUpdate */
+        GroupUpdate: {
+            /** Name */
+            name?: string | null;
+            /** Nine Rounds Rule */
+            nine_rounds_rule?: boolean | null;
+        };
         /** HTTPValidationError */
         HTTPValidationError: {
             /** Detail */
@@ -1714,6 +1914,11 @@ export interface components {
             rank?: number | null;
             /** Avatar Url */
             avatar_url?: string | null;
+            /**
+             * Rating Confirmed
+             * @default false
+             */
+            rating_confirmed: boolean;
         };
         /** MatchCreate */
         MatchCreate: {
@@ -1730,7 +1935,9 @@ export interface components {
              * Win Reason
              * @enum {string}
              */
-            win_reason: "objectives" | "worlds" | "plastic" | "resources";
+            win_reason: "objectives" | "worlds" | "plastic" | "resources" | "last_standing";
+            /** End Round */
+            end_round?: number | null;
             /** Overall Comment */
             overall_comment?: string | null;
             /** Expected Version */
@@ -1761,9 +1968,25 @@ export interface components {
                 [key: string]: string;
             };
             /** Win Reason */
-            win_reason?: ("objectives" | "worlds" | "plastic" | "resources") | null;
+            win_reason?: ("objectives" | "worlds" | "plastic" | "resources" | "last_standing") | null;
             /** Overall Comment */
             overall_comment?: string | null;
+            /** End Round */
+            end_round?: number | null;
+            /**
+             * Objectives
+             * @default {}
+             */
+            objectives: {
+                [key: string]: number;
+            };
+            /**
+             * Worlds
+             * @default {}
+             */
+            worlds: {
+                [key: string]: number;
+            };
         };
         /** MatchFinishDraftRead */
         MatchFinishDraftRead: {
@@ -1790,6 +2013,10 @@ export interface components {
             comment?: string | null;
             /** Faction Id */
             faction_id?: number | null;
+            /** Objectives */
+            objectives?: number | null;
+            /** Worlds */
+            worlds?: number | null;
         };
         /**
          * MatchHistory
@@ -1844,7 +2071,7 @@ export interface components {
             /** Duration Minutes */
             duration_minutes?: number | null;
             /** Win Reason */
-            win_reason?: ("objectives" | "worlds" | "plastic" | "resources") | null;
+            win_reason?: ("objectives" | "worlds" | "plastic" | "resources" | "last_standing") | null;
             /** Player Count */
             player_count: number;
             /** Overall Comment */
@@ -1856,6 +2083,8 @@ export interface components {
              * @default []
              */
             participants: components["schemas"]["MatchListParticipant"][];
+            /** Rating Delta */
+            rating_delta?: number | null;
         };
         /** MatchListParticipant */
         MatchListParticipant: {
@@ -1878,6 +2107,10 @@ export interface components {
             was_random: boolean;
             /** Comment */
             comment?: string | null;
+            /** Objectives */
+            objectives?: number | null;
+            /** Worlds */
+            worlds?: number | null;
         };
         /** MatchParticipantRead */
         MatchParticipantRead: {
@@ -1900,6 +2133,10 @@ export interface components {
             was_random: boolean;
             /** Comment */
             comment?: string | null;
+            /** Objectives */
+            objectives?: number | null;
+            /** Worlds */
+            worlds?: number | null;
             /** Avatar Url */
             avatar_url?: string | null;
         };
@@ -1923,7 +2160,16 @@ export interface components {
             /** Duration Minutes */
             duration_minutes?: number | null;
             /** Win Reason */
-            win_reason?: ("objectives" | "worlds" | "plastic" | "resources") | null;
+            win_reason?: ("objectives" | "worlds" | "plastic" | "resources" | "last_standing") | null;
+            /** End Round */
+            end_round?: number | null;
+            /**
+             * Nine Rounds Rule
+             * @default false
+             */
+            nine_rounds_rule: boolean;
+            /** Max Rounds */
+            max_rounds: number;
             /** Player Count */
             player_count: number;
             /** Overall Comment */
@@ -1956,7 +2202,9 @@ export interface components {
             /** Overall Comment */
             overall_comment?: string | null;
             /** Win Reason */
-            win_reason?: ("objectives" | "worlds" | "plastic" | "resources") | null;
+            win_reason?: ("objectives" | "worlds" | "plastic" | "resources" | "last_standing") | null;
+            /** End Round */
+            end_round?: number | null;
             /** Participants */
             participants?: components["schemas"]["ParticipantInput"][] | null;
             /** Expected Version */
@@ -2104,6 +2352,10 @@ export interface components {
             was_random: boolean;
             /** Comment */
             comment?: string | null;
+            /** Objectives */
+            objectives?: number | null;
+            /** Worlds */
+            worlds?: number | null;
         };
         /** PasswordChange */
         PasswordChange: {
@@ -2987,7 +3239,7 @@ export interface operations {
             };
         };
     };
-    rename_group_api_groups__group_id__patch: {
+    update_group_api_groups__group_id__patch: {
         parameters: {
             query?: never;
             header?: never;
@@ -2998,7 +3250,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["GroupRename"];
+                "application/json": components["schemas"]["GroupUpdate"];
             };
         };
         responses: {
@@ -3918,6 +4170,61 @@ export interface operations {
             };
         };
     };
+    pending_api_announcements_pending_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AnnouncementRead"][];
+                };
+            };
+        };
+    };
+    acknowledge_api_announcements__announcement_id__ack_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                announcement_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AnnouncementAck"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OkResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     admin_login_api_admin_auth_login_post: {
         parameters: {
             query?: never;
@@ -4614,6 +4921,156 @@ export interface operations {
             };
         };
     };
+    list_announcements_api_admin_announcements_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminAnnouncementRead"][];
+                };
+            };
+        };
+    };
+    create_announcement_api_admin_announcements_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AnnouncementWrite"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminAnnouncementRead"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    update_announcement_api_admin_announcements__announcement_id__put: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                announcement_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AnnouncementUpdate"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminAnnouncementRead"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    delete_announcement_api_admin_announcements__announcement_id__delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                announcement_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OkResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    stop_announcement_api_admin_announcements__announcement_id__stop_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                announcement_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminAnnouncementRead"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     audit_logs_api_admin_audit_logs_get: {
         parameters: {
             query?: {

frontend/src/app/router.tsx

@@ -14,6 +14,7 @@ import { OverallStatsPage } from "../pages/OverallStatsPage";
 import { PublicProfilePage } from "../pages/PublicProfilePage";
 import { AdminAccountsPage } from "../pages/admin/AdminAccountsPage";
 import { AdminAchievementsPage } from "../pages/admin/AdminAchievementsPage";
+import { AdminAnnouncementsPage } from "../pages/admin/AdminAnnouncementsPage";
 import { AdminFactionsPage } from "../pages/admin/AdminFactionsPage";
 import { AdminLayout } from "../pages/admin/AdminLayout";
 import { AdminLogsPage } from "../pages/admin/AdminLogsPage";
@@ -70,6 +71,7 @@ export const router = createBrowserRouter([
       { path: "factions", element: <AdminFactionsPage /> },
       { path: "achievements", element: <AdminAchievementsPage /> },
       { path: "logs", element: <AdminLogsPage /> },
+      { path: "announcements", element: <AdminAnnouncementsPage /> },
     ],
   },
   { path: "*", element: <Navigate to="/" replace /> },

frontend/src/components/AnnouncementDialog.tsx

@@ -0,0 +1,40 @@
+import { useEffect, useState } from "react";
+
+import { useAckAnnouncement, usePendingAnnouncements } from "../hooks/announcements";
+import { AnnouncementWindow } from "./AnnouncementWindow";
+
+/**
+ * Очередь объявлений администрации поверх любой страницы: по одному, от старого
+ * к новому, следующее — после «Понятно» на предыдущем. AppShell монтирует её только
+ * когда пароль задан: обязательное окно пароля всегда первое.
+ */
+export function AnnouncementDialog() {
+  const { data } = usePendingAnnouncements(true);
+  const ack = useAckAnnouncement();
+  // Сколько уже закрыто в этой очереди — для точек «2 из 3». Закрытые сразу уходят
+  // из данных запроса, так что без счётчика точки показывали бы только остаток.
+  const [closed, setClosed] = useState(0);
+  const items = data ?? [];
+
+  useEffect(() => {
+    if (items.length === 0) setClosed(0);
+  }, [items.length]);
+
+  if (items.length === 0) return null;
+  const current = items[0];
+
+  return (
+    <AnnouncementWindow
+      key={current.id}
+      title={current.title}
+      bodyHtml={current.body_html}
+      updated={current.updated}
+      index={closed}
+      total={closed + items.length}
+      onOk={() => {
+        setClosed((c) => c + 1);
+        ack.mutate({ id: current.id, revision: current.revision });
+      }}
+    />
+  );
+}

frontend/src/components/AnnouncementWindow.tsx

@@ -0,0 +1,50 @@
+import { useId } from "react";
+
+/**
+ * Окно объявления администрации (вариант E из #84): заголовок — в плашке-шапке, ниже текст,
+ * точки очереди и «Понятно». Крестика нет намеренно: закрытие — только осознанное.
+ *
+ * bodyHtml у игрока — HTML, очищенный сервером по белому списку (announcement_service),
+ * поэтому вставляется как есть. В предпросмотре админки — содержимое его же редактора.
+ */
+export function AnnouncementWindow({
+  title,
+  bodyHtml,
+  updated = false,
+  index = 0,
+  total = 1,
+  onOk,
+}: {
+  title: string;
+  bodyHtml: string;
+  updated?: boolean;
+  index?: number;
+  total?: number;
+  onOk: () => void;
+}) {
+  const titleId = useId();
+  return (
+    <div className="modal-overlay">
+      <div className="modal ann-modal" role="dialog" aria-modal="true" aria-labelledby={titleId}>
+        <div className="ann-ribbon">
+          <div className="ann-ribbon-title" id={titleId}>
+            {title}
+          </div>
+          {updated && <div className="ann-updated">обновлено</div>}
+        </div>
+        <div className="ann-body" dangerouslySetInnerHTML={{ __html: bodyHtml }} />
+        <div className="modal-actions ann-actions">
+          <div className="ann-dots" aria-hidden="true">
+            {total > 1 &&
+              Array.from({ length: total }, (_, k) => (
+                <i key={k} className={k <= index ? "on" : undefined} />
+              ))}
+          </div>
+          <button className="btn btn-primary" onClick={onOk} autoFocus>
+            Понятно
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/AppShell.tsx

@@ -3,6 +3,7 @@ import { Outlet, useLocation, useNavigate } from "react-router-dom";
 
 import { useMe } from "../hooks/auth";
 import { useServerEvents } from "../hooks/useServerEvents";
+import { AnnouncementDialog } from "./AnnouncementDialog";
 import { BottomBar } from "./BottomBar";
 import { NotificationBell } from "./NotificationBell";
 import { NotificationToaster } from "./NotificationToaster";
@@ -55,6 +56,8 @@ export function AppShell() {
 
       {/* Без пароля дальше не пускаем: логин = ник, пароль нужен для входа. */}
       {me && !me.has_password && <SetPasswordDialog nickname={me.nickname} />}
+      {/* Объявления администрации — только после окна пароля, на любой странице. */}
+      {me?.has_password && <AnnouncementDialog />}
     </div>
   );
 }

frontend/src/components/Leaderboard.tsx

@@ -30,8 +30,14 @@ function Row({
         </div>
       </div>
       {/* Серебристый — у новичков и у прочерка ещё не игравших; золотой — только
-          подтверждённый рейтинг. */}
-      <div className={"lb-score" + (provisional || entry.score == null ? " provisional" : "")}>
+          подтверждённый рейтинг. Рейтинг общий, поэтому подтверждённость приходит
+          флагом: в группе «Ещё не играли» бывают и новички, и опытные игроки. */}
+      <div
+        className={
+          "lb-score" +
+          (provisional || entry.score == null || !entry.rating_confirmed ? " provisional" : "")
+        }
+      >
         {entry.score ?? "—"}
       </div>
     </>

frontend/src/components/MatchHistory.tsx

@@ -3,6 +3,7 @@ import { useNavigate } from "react-router-dom";
 import { formatDate, formatDuration } from "../domain/format";
 import type { MatchListItem } from "../domain/types";
 import { MatchListView } from "./MatchList";
+import { RatingDelta } from "./RatingDelta";
 
 /**
  * История партий игрока в профиле. Подробный режим — тот же список, что у группы
@@ -53,29 +54,33 @@ export function MatchHistory({
         return (
           <button
             key={m.id}
-            className="card row-between"
+            className="card"
             style={{ margin: 0, width: "100%", textAlign: "left" }}
             onClick={() => navigate(`/match/${m.id}`)}
           >
-            <div className="row" style={{ gap: 10, minWidth: 0 }}>
-              <span
-                className={
-                  "place-badge" +
-                  (mine?.place === 1 && !mine?.eliminated ? " first" : "") +
-                  (mine?.eliminated ? " eliminated" : "")
-                }
-              >
-                {mine?.eliminated ? "✕" : (mine?.place ?? "—")}
-              </span>
-              <span
-                style={{ overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
-              >
-                {mine?.faction_name ?? "—"}
+            <div className="row-between">
+              <div className="row" style={{ gap: 10, minWidth: 0 }}>
+                <span
+                  className={
+                    "place-badge" +
+                    (mine?.place === 1 && !mine?.eliminated ? " first" : "") +
+                    (mine?.eliminated ? " eliminated" : "")
+                  }
+                >
+                  {mine?.eliminated ? "✕" : (mine?.place ?? "—")}
+                </span>
+                <span
+                  style={{ overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
+                >
+                  {mine?.faction_name ?? "—"}
+                </span>
+              </div>
+              <span className="muted small" style={{ flexShrink: 0 }}>
+                {formatDate(m.played_at)} · {formatDuration(m.duration_minutes)}
               </span>
             </div>
-            <span className="muted small" style={{ flexShrink: 0 }}>
-              {formatDate(m.played_at)} · {formatDuration(m.duration_minutes)}
-            </span>
+            {/* Второй строкой — изменение рейтинга владельца профиля за партию. */}
+            {m.rating_delta != null && <RatingDelta delta={m.rating_delta} />}
           </button>
         );
       })}

frontend/src/components/MatchList.tsx

@@ -3,10 +3,12 @@ import { useNavigate } from "react-router-dom";
 import { formatDate, formatDuration } from "../domain/format";
 import { winReasonLabel } from "../domain/winReasons";
 import type { MatchListItem } from "../domain/types";
+import { RatingDelta } from "./RatingDelta";
 
 /** Список ЗАВЕРШЁННЫХ партий. Незавершённые сюда не попадают: группа отдаёт их
  * отдельным блоком (InProgressMatches), а история профиля приходит с бэкенда уже
- * отфильтрованной по status="finished". */
+ * отфильтрованной по status="finished". В истории профиля у партии есть rating_delta
+ * владельца — она идёт последней строкой; у списка группы её нет. */
 export function MatchListView({ items }: { items: MatchListItem[] }) {
   const navigate = useNavigate();
   if (items.length === 0) return <div className="muted small">Партий пока нет.</div>;
@@ -48,6 +50,7 @@ export function MatchListView({ items }: { items: MatchListItem[] }) {
                 </div>
               ))}
             </div>
+            {m.rating_delta != null && <RatingDelta delta={m.rating_delta} />}
           </button>
         );
       })}

frontend/src/components/MatchOutcomeFields.tsx

@@ -0,0 +1,76 @@
+import { PickerSelect } from "./PickerSelect";
+import { LAST_STANDING, WIN_REASONS, type WinReason, winReasonLabel } from "../domain/winReasons";
+
+const REASON_OPTIONS = WIN_REASONS.map((w) => ({ id: w.code, label: w.label }));
+const NO_ROUND = 0;
+
+/**
+ * Итог партии в форме завершения и правки результатов: причина победы, раунд окончания
+ * и предупреждения о несогласованном вводе. «Последний выживший» не выбирается —
+ * пока выживший один, причина зафиксирована (её ставит родитель, см. reasonForSurvivors).
+ */
+export function MatchOutcomeFields({
+  winReason,
+  onReason,
+  endRound,
+  onEndRound,
+  maxRounds,
+  warnings,
+}: {
+  winReason: WinReason | null;
+  onReason: (reason: WinReason) => void;
+  endRound: number | null;
+  onEndRound: (round: number | null) => void;
+  maxRounds: number;
+  warnings: string[];
+}) {
+  const roundOptions = [
+    { id: NO_ROUND, label: "не указан" },
+    ...Array.from({ length: maxRounds }, (_, i) => ({ id: i + 1, label: `${i + 1}-й` })),
+  ];
+  return (
+    <div className="card">
+      <h3>Итог партии</h3>
+      <div className="field">
+        <label className="label">Причина победы</label>
+        {winReason === LAST_STANDING ? (
+          <div className="picker-trigger" aria-disabled>
+            {winReasonLabel(LAST_STANDING)}
+            <span className="muted small" style={{ marginLeft: "auto" }}>
+              все соперники выбыли
+            </span>
+          </div>
+        ) : (
+          <PickerSelect
+            selected={REASON_OPTIONS.find((o) => o.id === winReason) ?? null}
+            options={REASON_OPTIONS}
+            placeholder="— выберите причину —"
+            renderOption={(o) => o.label}
+            onPick={(o) => onReason(o.id)}
+          />
+        )}
+      </div>
+      <div className="field" style={{ marginBottom: 0 }}>
+        <label className="label">Раунд окончания (из {maxRounds})</label>
+        <PickerSelect
+          selected={roundOptions.find((o) => o.id === (endRound ?? NO_ROUND)) ?? null}
+          options={roundOptions}
+          placeholder="не указан"
+          renderOption={(o) => o.label}
+          onPick={(o) => onEndRound(o.id === NO_ROUND ? null : o.id)}
+        />
+      </div>
+      <p className="muted small" style={{ marginBottom: 0 }}>
+        Раунд, цели и миры необязательны, но делают рейтинг точнее: быстрая и крупная победа
+        весит больше.
+      </p>
+      {warnings.length > 0 && (
+        <ul className="warn-list">
+          {warnings.map((w) => (
+            <li key={w}>{w}</li>
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}

frontend/src/components/PlaceEditor.tsx

@@ -2,6 +2,7 @@ import { Scissors } from "lucide-react";
 import { useRef } from "react";
 
 import { Avatar } from "./Avatar";
+import { MAX_COUNT, parseCount } from "../domain/matchCounts";
 
 export interface PlacePlayer {
   user_id: number;
@@ -10,6 +11,10 @@ export interface PlacePlayer {
   avatar_url?: string | null;
 }
 
+export type CountField = "objectives" | "worlds";
+/** Цели и миры на конец партии по user_id; отсутствие ключа или null — не указано. */
+export type Counts = Record<number, { objectives: number | null; worlds: number | null }>;
+
 type Target =
   | { type: "merge"; idx: number }
   | { type: "insert"; idx: number }
@@ -28,7 +33,8 @@ interface DragState {
  * Редактор мест перетаскиванием (макет A2): вертикальный список блоков игроков,
  * верхний — 1-е место. Бросок между блоками — порядок, на середину чужого блока —
  * слияние в ничью (общая рамка и место, ✂ выносит обратно), в пунктирную зону —
- * выбывший. В каждом блоке — строка комментария об игроке.
+ * выбывший. В каждом блоке — строка комментария об игроке и (если переданы counts)
+ * цели и миры на конец партии; у выбывшего миров нет — поле заблокировано нулём.
  *
  * Контролируемый: blocks (упорядоченные группы user_id, длина >1 = ничья) и
  * eliminated живут у родителя. Во время drag DOM двигается напрямую (transform,
@@ -41,6 +47,8 @@ export function PlaceEditor({
   comments,
   onChange,
   onComment,
+  counts,
+  onCount,
 }: {
   players: PlacePlayer[];
   blocks: number[][];
@@ -48,6 +56,8 @@ export function PlaceEditor({
   comments: Record<number, string>;
   onChange: (blocks: number[][], eliminated: number[]) => void;
   onComment: (userId: number, text: string) => void;
+  counts?: Counts;
+  onCount?: (userId: number, field: CountField, value: number | null) => void;
 }) {
   const listRef = useRef<HTMLDivElement>(null);
   const elimRef = useRef<HTMLDivElement>(null);
@@ -225,15 +235,41 @@ export function PlaceEditor({
     );
   };
 
-  const commentInput = (userId: number) => (
-    <input
-      className="rank-comment"
-      placeholder="Комментарий об игроке"
-      value={comments[userId] ?? ""}
-      onChange={(e) => onComment(userId, e.target.value)}
-    />
+  const countInput = (userId: number, field: CountField, label: string, locked = false) => (
+    <label className="rank-count">
+      <span>{label}</span>
+      <input
+        type="number"
+        inputMode="numeric"
+        min={0}
+        max={MAX_COUNT}
+        placeholder="—"
+        disabled={locked}
+        value={locked ? 0 : (counts?.[userId]?.[field] ?? "")}
+        onChange={(e) => onCount?.(userId, field, parseCount(e.target.value))}
+      />
+    </label>
   );
 
+  const commentInput = (userId: number) => {
+    const comment = (
+      <input
+        className="rank-comment"
+        placeholder="Комментарий об игроке"
+        value={comments[userId] ?? ""}
+        onChange={(e) => onComment(userId, e.target.value)}
+      />
+    );
+    if (!counts) return comment;
+    return (
+      <div className="rank-details">
+        {comment}
+        {countInput(userId, "objectives", "цели")}
+        {countInput(userId, "worlds", "миры", eliminated.includes(userId))}
+      </div>
+    );
+  };
+
   return (
     <div>
       <div className="rank-list" ref={listRef}>

frontend/src/components/ProfileStatsCard.tsx

@@ -35,7 +35,7 @@ export function ProfileStatsCard({
         <b>{o.avg_place ?? "—"}</b>
       </div>
       <div className="row-between">
-        <div>Очки (рейтинг)</div>
+        <div>Рейтинг</div>
         <b className={"lb-score" + (provisional ? " provisional" : "")}>{o.score ?? "—"}</b>
       </div>
       {/* Любимая — личный выбор игрока в профиле; ниже — статистика по партиям. */}

frontend/src/components/RatingDelta.tsx

@@ -0,0 +1,13 @@
+import { formatRatingDelta } from "../domain/format";
+
+/** Строка карточки истории: сколько общего рейтинга владелец профиля получил или
+ * потерял за партию. Рост — зелёным, падение — красным, ноль — без цвета. */
+export function RatingDelta({ delta }: { delta: number }) {
+  const text = formatRatingDelta(delta);
+  const tone = text.startsWith("+") ? "rating-up" : text.startsWith("−") ? "rating-down" : undefined;
+  return (
+    <div className="small rating-delta">
+      Рейтинг: <b className={tone}>{text}</b>
+    </div>
+  );
+}

frontend/src/domain/finishWarnings.ts

@@ -0,0 +1,101 @@
+import { LAST_STANDING, type WinReason, winReasonLabel } from "./winReasons";
+
+export interface OutcomeSeat {
+  userId: number;
+  nickname: string;
+  /** Место невыбывшего; у выбывшего не учитывается. */
+  place: number;
+  eliminated: boolean;
+  objectives: number | null;
+  worlds: number | null;
+}
+
+/**
+ * Подсказки о несогласованных итогах партии. Это предупреждения, а не отказ: сервер
+ * проверяет только диапазоны и явные противоречия, а здесь — сочетания, которые по
+ * правилам почти наверняка опечатка. Проверка идёт только по заполненным полям.
+ */
+export function finishWarnings({
+  seats,
+  winReason,
+  endRound,
+  maxRounds,
+}: {
+  seats: OutcomeSeat[];
+  winReason: WinReason | null;
+  endRound: number | null;
+  maxRounds: number;
+}): string[] {
+  const out: string[] = [];
+  const n = seats.length;
+  const survivors = seats.filter((s) => !s.eliminated).sort((a, b) => a.place - b.place);
+  const winners = survivors.filter((s) => s.place === 1);
+  if (winners.length === 0 || winReason === LAST_STANDING) return out;
+
+  // Досрочно партия заканчивается, только когда кто-то набрал столько целей, сколько
+  // игроков за столом.
+  const winnerObjectives = winners.map((w) => w.objectives).filter((v): v is number => v != null);
+  if (
+    endRound != null &&
+    endRound < maxRounds &&
+    winnerObjectives.length > 0 &&
+    Math.max(...winnerObjectives) < n
+  ) {
+    out.push(
+      `Партия закончилась в ${endRound}-м раунде из ${maxRounds}, но у победителя меньше ${n} целей — ` +
+        `досрочно побеждает тот, кто набрал ${n}.`,
+    );
+  }
+
+  // Остальное сравнивает победителя с соперниками — при ничьей за 1-е место не с кем.
+  if (winners.length > 1) return out;
+  const winner = winners[0];
+  const secondPlace = survivors.find((s) => s.place > 1)?.place;
+  const runnersUp = survivors.filter((s) => s.place === secondPlace);
+  const label = winReasonLabel(winReason).toLowerCase();
+
+  for (const r of runnersUp) {
+    const objKnown = winner.objectives != null && r.objectives != null;
+    const worldsKnown = winner.worlds != null && r.worlds != null;
+    if (winReason === "objectives" && objKnown && winner.objectives === r.objectives) {
+      out.push(
+        `У ${winner.nickname} и ${r.nickname} поровну целей (${winner.objectives}) — ` +
+          "при равенстве победа определяется по мирам, пластику или ресурсам.",
+      );
+    }
+    if (winReason && winReason !== "objectives" && objKnown && winner.objectives !== r.objectives) {
+      out.push(
+        `Победа ${label} предполагает равные цели у лидеров: у ${winner.nickname} — ` +
+          `${winner.objectives}, у ${r.nickname} — ${r.objectives}.`,
+      );
+    }
+    if (winReason === "worlds" && worldsKnown && winner.worlds! <= r.worlds!) {
+      out.push(
+        `Победа по мирам, но у ${winner.nickname} миров не больше, чем у ${r.nickname} ` +
+          `(${winner.worlds} и ${r.worlds}).`,
+      );
+    }
+    if (
+      (winReason === "plastic" || winReason === "resources") &&
+      worldsKnown &&
+      winner.worlds !== r.worlds
+    ) {
+      out.push(
+        `Победа ${label} предполагает равные миры у лидеров: у ${winner.nickname} — ` +
+          `${winner.worlds}, у ${r.nickname} — ${r.worlds}.`,
+      );
+    }
+  }
+
+  if (winner.objectives != null) {
+    for (const s of seats) {
+      if (s.userId !== winner.userId && s.objectives != null && s.objectives > winner.objectives) {
+        out.push(
+          `У ${s.nickname} целей больше, чем у победителя ${winner.nickname} ` +
+            `(${s.objectives} против ${winner.objectives}).`,
+        );
+      }
+    }
+  }
+  return out;
+}

frontend/src/domain/format.ts

@@ -18,6 +18,14 @@ export function plural(n: number, one: string, few: string, many: string): strin
   return many;
 }
 
+// Изменение рейтинга за партию: всегда со знаком и одним знаком после запятой
+// («+12.3», «−4.1», «0.0»); минус — типографский, как в справке.
+export function formatRatingDelta(delta: number): string {
+  const abs = Math.abs(delta).toFixed(1);
+  if (abs === "0.0") return "0.0";
+  return `${delta > 0 ? "+" : "−"}${abs}`;
+}
+
 export function formatDuration(minutes: number | null | undefined): string {
   if (minutes == null) return "—";
   const h = Math.floor(minutes / 60);
@@ -42,6 +50,21 @@ export function formatDate(iso: string | null | undefined): string {
   return m ? `${m[3]}.${m[2]}.${m[1]}` : iso;
 }
 
+// Значение <input type="datetime-local"> — «настенное» время в том же поясе +3, что и всё
+// отображение: админ вводит время показа объявления по МСК, где бы ни был его браузер.
+export function toAppLocalInput(iso: string): string {
+  const d = shifted(iso);
+  return `${d.getUTCFullYear()}-${p2(d.getUTCMonth() + 1)}-${p2(d.getUTCDate())}T${p2(d.getUTCHours())}:${p2(d.getUTCMinutes())}`;
+}
+
+// Обратно: «настенное» время +3 из datetime-local → момент ISO (UTC). null — поле пустое.
+export function fromAppLocalInput(value: string): string | null {
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(value);
+  if (!m) return null;
+  const ms = Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5]) - APP_TZ_OFFSET_MIN * 60_000;
+  return new Date(ms).toISOString();
+}
+
 export function formatDateTime(iso: string | null | undefined): string {
   if (!iso) return "—";
   const d = shifted(iso);

frontend/src/domain/matchCounts.ts

@@ -0,0 +1,10 @@
+/** Верхняя граница целей и миров — отсечка мусора, та же, что в схеме API (Count). */
+export const MAX_COUNT = 99;
+
+/** Поле «цели»/«миры» формы: пустое — не указано (null), иначе целое 0..MAX_COUNT. */
+export function parseCount(raw: string): number | null {
+  const text = raw.trim();
+  const num = Number(text);
+  if (text === "" || !Number.isFinite(num)) return null;
+  return Math.min(MAX_COUNT, Math.max(0, Math.trunc(num)));
+}

frontend/src/domain/types.ts

@@ -34,3 +34,7 @@ export type MatchUpdate = S["MatchUpdate"];
 export type MatchCreate = S["MatchCreate"];
 export type MatchFinish = S["MatchFinish"];
 export type MatchFinishDraftData = S["MatchFinishDraftData"];
+export type AnnouncementRead = S["AnnouncementRead"];
+export type AdminAnnouncementRead = S["AdminAnnouncementRead"];
+export type AnnouncementWrite = S["AnnouncementWrite"];
+export type AnnouncementUpdate = S["AnnouncementUpdate"];

frontend/src/domain/winReasons.ts

@@ -2,7 +2,10 @@ import type { components } from "../api/schema";
 
 export type WinReason = components["schemas"]["MatchFinish"]["win_reason"];
 
-// Фиксированный порядок (сверху вниз).
+export const LAST_STANDING: WinReason = "last_standing";
+
+// Причины для ручного выбора, фиксированный порядок (сверху вниз). «Последний выживший»
+// сюда не входит: она ставится сама, когда невыбывший игрок остался один.
 export const WIN_REASONS: { code: WinReason; label: string }[] = [
   { code: "objectives", label: "По целям" },
   { code: "worlds", label: "По мирам" },
@@ -10,10 +13,21 @@ export const WIN_REASONS: { code: WinReason; label: string }[] = [
   { code: "resources", label: "По ресурсам" },
 ];
 
-const LABELS: Record<string, string> = Object.fromEntries(
-  WIN_REASONS.map((w) => [w.code, w.label]),
-);
+const LABELS: Record<string, string> = {
+  ...Object.fromEntries(WIN_REASONS.map((w) => [w.code, w.label])),
+  [LAST_STANDING]: "Последний выживший",
+};
 
 export function winReasonLabel(code: string | null | undefined): string {
   return code ? LABELS[code] ?? code : "—";
 }
+
+/**
+ * Причина победы после изменения состава выбывших. Правило сервера: невыбывший ровно
+ * один ⇔ «последний выживший». Поэтому при одном выжившем причина ставится сама, а когда
+ * выживших снова двое — сбрасывается (null): её нужно выбрать заново, а не угадывать.
+ */
+export function reasonForSurvivors(current: WinReason | null, survivors: number): WinReason | null {
+  if (survivors === 1) return LAST_STANDING;
+  return current === LAST_STANDING ? null : current;
+}

frontend/src/hooks/admin.ts

@@ -2,7 +2,12 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { api, authProbeRetry, unwrap } from "../api/client";
 import { qk } from "../api/queryKeys";
-import type { AdminMe, MatchUpdate } from "../domain/types";
+import type {
+  AdminMe,
+  AnnouncementUpdate,
+  AnnouncementWrite,
+  MatchUpdate,
+} from "../domain/types";
 import { uploadFile } from "../lib/upload";
 
 export function useAdminMe() {
@@ -282,3 +287,57 @@ export function useUploadAchievementIcon() {
     onSuccess: () => qc.invalidateQueries({ queryKey: qk.adminAchievements }),
   });
 }
+
+// ─── Объявления ──────────────────────────────────────────────────────────────
+
+export function useAdminAnnouncements() {
+  return useQuery({
+    queryKey: qk.adminAnnouncements,
+    queryFn: async () => unwrap(await api.GET("/api/admin/announcements")),
+  });
+}
+
+function useAnnouncementMutation<A, R>(fn: (args: A) => Promise<R>) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: fn,
+    onSuccess: () => qc.invalidateQueries({ queryKey: qk.adminAnnouncements }),
+  });
+}
+
+export function useAdminCreateAnnouncement() {
+  return useAnnouncementMutation(async (body: AnnouncementWrite) =>
+    unwrap(await api.POST("/api/admin/announcements", { body })),
+  );
+}
+
+export function useAdminUpdateAnnouncement() {
+  return useAnnouncementMutation(async (args: { id: number; body: AnnouncementUpdate }) =>
+    unwrap(
+      await api.PUT("/api/admin/announcements/{announcement_id}", {
+        params: { path: { announcement_id: args.id } },
+        body: args.body,
+      }),
+    ),
+  );
+}
+
+export function useAdminStopAnnouncement() {
+  return useAnnouncementMutation(async (id: number) =>
+    unwrap(
+      await api.POST("/api/admin/announcements/{announcement_id}/stop", {
+        params: { path: { announcement_id: id } },
+      }),
+    ),
+  );
+}
+
+export function useAdminDeleteAnnouncement() {
+  return useAnnouncementMutation(async (id: number) =>
+    unwrap(
+      await api.DELETE("/api/admin/announcements/{announcement_id}", {
+        params: { path: { announcement_id: id } },
+      }),
+    ),
+  );
+}

frontend/src/hooks/announcements.ts

@@ -0,0 +1,40 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+import { api, unwrap } from "../api/client";
+import { qk } from "../api/queryKeys";
+import type { AnnouncementRead } from "../domain/types";
+
+// Объявления администрации, которые игрок ещё не закрыл, — от старого к новому.
+export function usePendingAnnouncements(enabled: boolean) {
+  return useQuery({
+    queryKey: qk.announcements,
+    queryFn: async () => unwrap(await api.GET("/api/announcements/pending")),
+    enabled,
+    // Новое и изменённое объявление приходит SSE-событием, а вот наступление отложенного
+    // начала показа — не событие в данных. Его подхватываем периодическим перезапросом.
+    refetchInterval: 5 * 60_000,
+  });
+}
+
+// «Понятно»: объявление помечается закрытым в той версии, которую игрок видел.
+export function useAckAnnouncement() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (a: { id: number; revision: number }) =>
+      unwrap(
+        await api.POST("/api/announcements/{announcement_id}/ack", {
+          params: { path: { announcement_id: a.id } },
+          body: { revision: a.revision },
+        }),
+      ),
+    // Закрытое убираем из очереди сразу — следующее открывается, не дожидаясь сети.
+    onMutate: async (a) => {
+      await qc.cancelQueries({ queryKey: qk.announcements });
+      qc.setQueryData<AnnouncementRead[]>(qk.announcements, (old) =>
+        old?.filter((x) => x.id !== a.id),
+      );
+    },
+    // Если отметка не записалась, объявление вернётся с перезапросом, а не пропадёт молча.
+    onSettled: () => qc.invalidateQueries({ queryKey: qk.announcements }),
+  });
+}

frontend/src/hooks/groups.ts

@@ -75,14 +75,15 @@ export function useCreateGroup() {
   });
 }
 
-export function useRenameGroup(groupId: number) {
+export function useUpdateGroup(groupId: number) {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: async (name: string) =>
+    // Частичная правка: название и/или домашние правила (например, 9 раундов).
+    mutationFn: async (body: { name?: string; nine_rounds_rule?: boolean }) =>
       unwrap(
         await api.PATCH("/api/groups/{group_id}", {
           params: { path: { group_id: groupId } },
-          body: { name },
+          body,
         }),
       ),
     onSuccess: () => {
@@ -137,6 +138,8 @@ export function useRemoveMember(groupId: number) {
       ),
     onSuccess: () => {
       qc.invalidateQueries({ queryKey: qk.groupMembers(groupId) });
+      // Список игроков группы показывает только текущий состав — удалённый из него уходит.
+      qc.invalidateQueries({ queryKey: qk.groupStats(groupId) });
       qc.invalidateQueries({ queryKey: qk.me });
     },
   });

frontend/src/hooks/matches.ts

@@ -1,7 +1,7 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { api, unwrap } from "../api/client";
-import { matchAffectedKeys, qk } from "../api/queryKeys";
+import { invalidateRatingViews, qk } from "../api/queryKeys";
 import type {
   FactionRead,
   MatchCreate,
@@ -83,8 +83,7 @@ export function useFinishMatch() {
     onSuccess: (m) => {
       qc.invalidateQueries({ queryKey: qk.match(m.id) });
       qc.invalidateQueries({ queryKey: qk.groupMatches(m.group_id) });
-      qc.invalidateQueries({ queryKey: qk.groupStats(m.group_id) });
-      for (const key of matchAffectedKeys) qc.invalidateQueries({ queryKey: key });
+      invalidateRatingViews(qc);
     },
   });
 }
@@ -103,9 +102,8 @@ export function useUpdateMatch() {
     onSuccess: (m) => {
       qc.setQueryData(qk.match(m.id), m);
       qc.invalidateQueries({ queryKey: qk.groupMatches(m.group_id) });
-      qc.invalidateQueries({ queryKey: qk.groupStats(m.group_id) });
-      // Места изменились — значит изменились лидерборд, история и профили.
-      for (const key of matchAffectedKeys) qc.invalidateQueries({ queryKey: key });
+      // Места изменились — значит изменились рейтинги, топ, истории и профили.
+      invalidateRatingViews(qc);
     },
   });
 }

frontend/src/hooks/useServerEvents.ts

@@ -1,15 +1,20 @@
 import { useQueryClient } from "@tanstack/react-query";
-import { useEffect, useRef } from "react";
+import { useEffect } from "react";
 
-import { matchAffectedKeys, qk } from "../api/queryKeys";
-import { useMe } from "./auth";
+import { invalidateRatingViews, qk } from "../api/queryKeys";
 
 interface ServerEvent {
-  type: "match" | "match_draft" | "group" | "invitations" | "notifications";
+  /** ratings — завершённая партия чужой группы сдвинула общий рейтинг (#88). */
+  type:
+    | "match"
+    | "match_draft"
+    | "ratings"
+    | "group"
+    | "invitations"
+    | "notifications"
+    | "announcements";
   match_id?: number;
   group_id?: number;
-  /** Кто играл в партии: их история и профили протухли, чужие — нет. */
-  participant_ids?: number[];
 }
 
 /**
@@ -19,11 +24,6 @@ interface ServerEvent {
  */
 export function useServerEvents(enabled: boolean) {
   const qc = useQueryClient();
-  const { data: me } = useMe();
-  // Свой id — в ref: положив его в зависимости эффекта, мы бы пересоздавали
-  // SSE-соединение каждый раз, когда профиль перезапрашивается.
-  const myId = useRef<number | null>(null);
-  myId.current = me?.id ?? null;
   useEffect(() => {
     if (!enabled) return;
     const base = import.meta.env.VITE_API_BASE_URL || "";
@@ -40,6 +40,8 @@ export function useServerEvents(enabled: boolean) {
         qc.invalidateQueries({ queryKey: qk.invitations });
       } else if (ev.type === "notifications") {
         qc.invalidateQueries({ queryKey: qk.notifications });
+      } else if (ev.type === "announcements") {
+        qc.invalidateQueries({ queryKey: qk.announcements });
       } else if (ev.type === "match_draft") {
         // Черновик меняется на каждое движение тайла: трогаем только саму партию,
         // без лидерборда и историй — иначе группа захлебнётся перезапросами.
@@ -48,26 +50,12 @@ export function useServerEvents(enabled: boolean) {
         if (ev.match_id != null) qc.invalidateQueries({ queryKey: qk.match(ev.match_id) });
         if (ev.group_id != null) {
           qc.invalidateQueries({ queryKey: qk.groupMatches(ev.group_id) });
-          qc.invalidateQueries({ queryKey: qk.groupStats(ev.group_id) });
-        }
-        // Общее меняется от любой партии: рейтинг глобальный, и чужая игра двигает топ.
-        qc.invalidateQueries({ queryKey: qk.home });
-        qc.invalidateQueries({ queryKey: qk.leaderboard });
-        if (ev.participant_ids) {
-          // Личные витрины — только у игравших: иначе каждая партия в группе
-          // заставляла бы всех остальных перезапрашивать свою историю.
-          for (const pid of ev.participant_ids) {
-            qc.invalidateQueries({ queryKey: qk.userMatches(pid) });
-            qc.invalidateQueries({ queryKey: qk.publicProfile(pid) });
-          }
-          if (myId.current != null && ev.participant_ids.includes(myId.current)) {
-            qc.invalidateQueries({ queryKey: qk.myStats });
-          }
-        } else {
-          // Событие от бэкенда без списка участников (вкладка открыта до обновления
-          // сервера) — ведём себя как раньше, широко.
-          for (const key of matchAffectedKeys) qc.invalidateQueries({ queryKey: key });
         }
+        // Рейтинг общий и считается по всей истории: партия двигает топ, историю
+        // и профили всех, кто играл после неё, и страницы других групп.
+        invalidateRatingViews(qc);
+      } else if (ev.type === "ratings") {
+        invalidateRatingViews(qc);
       } else if (ev.type === "group") {
         if (ev.group_id != null) {
           qc.invalidateQueries({ queryKey: qk.group(ev.group_id) });

frontend/src/pages/GroupSettingsPage.tsx

@@ -13,8 +13,8 @@ import {
   useGroup,
   useGroupMembers,
   useRemoveMember,
-  useRenameGroup,
   useSetGroupExpansions,
+  useUpdateGroup,
 } from "../hooks/groups";
 import { useExpansions } from "../hooks/reference";
 
@@ -25,7 +25,7 @@ export function GroupSettingsPage() {
   const { data: expansions } = useExpansions();
   const { data: members } = useGroupMembers(groupId);
   const setExpansions = useSetGroupExpansions(groupId ?? 0);
-  const renameGroup = useRenameGroup(groupId ?? 0);
+  const updateGroup = useUpdateGroup(groupId ?? 0);
   const removeMember = useRemoveMember(groupId ?? 0);
   const toast = useToast();
 
@@ -55,7 +55,7 @@ export function GroupSettingsPage() {
     const trimmed = nameValue.trim();
     if (!trimmed || trimmed === group.name) return;
     try {
-      await renameGroup.mutateAsync(trimmed);
+      await updateGroup.mutateAsync({ name: trimmed });
       setName(null);
       toast.show("Название сохранено");
     } catch (e) {
@@ -63,6 +63,15 @@ export function GroupSettingsPage() {
     }
   };
 
+  const saveNineRounds = async (enabled: boolean) => {
+    try {
+      await updateGroup.mutateAsync({ nine_rounds_rule: enabled });
+      toast.show(enabled ? "9 раундов при 5–6 игроках включено" : "Правило 9 раундов выключено");
+    } catch (e) {
+      toast.error(e instanceof ApiError ? e.message : "Ошибка");
+    }
+  };
+
   const saveExpansions = async () => {
     try {
       await setExpansions.mutateAsync([...selected]);
@@ -95,7 +104,7 @@ export function GroupSettingsPage() {
           <button
             className="btn btn-primary"
             onClick={saveName}
-            disabled={renameGroup.isPending || !nameValue.trim() || nameValue.trim() === group.name}
+            disabled={updateGroup.isPending || !nameValue.trim() || nameValue.trim() === group.name}
           >
             Сохранить
           </button>
@@ -127,6 +136,22 @@ export function GroupSettingsPage() {
         )}
       </div>
 
+      <div className="card">
+        <h3>Домашние правила</h3>
+        <label className="row" style={{ justifyContent: "space-between" }}>
+          <span>9 раундов при 5–6 игроках</span>
+          <Switch
+            checked={group.nine_rounds_rule}
+            disabled={updateGroup.isPending}
+            onChange={saveNineRounds}
+          />
+        </label>
+        <p className="muted small" style={{ marginBottom: 0 }}>
+          Действует на партии, начатые после смены: лимит раундов уже идущих и сыгранных
+          партий не меняется.
+        </p>
+      </div>
+
       <div className="card">
         {/* Приглашение нового игрока — на странице группы («Список игроков»). */}
         <h3>Участники ({(members ?? []).length}/{MAX_GROUP_SIZE})</h3>

frontend/src/pages/HelpPage.tsx

@@ -2,8 +2,9 @@ import { ChevronDown, ChevronUp } from "lucide-react";
 import { useState } from "react";
 
 /**
- * Справка — разделы, раскрывающиеся по кнопке. Пока раздел один: «Рейтинг»
- * (как считаются очки игроков). Текст соответствует backend/app/services/scoring.py.
+ * Справка — разделы, раскрывающиеся по кнопке. Пока раздел один: «Рейтинг».
+ * Текст соответствует backend/app/services/scoring.py и docs/rating/rating-system.md:
+ * коэффициенты, пороги и примеры менять вместе с ними.
  */
 export function HelpPage() {
   const [showRating, setShowRating] = useState(false);
@@ -32,50 +33,118 @@ export function HelpPage() {
       {showRating && (
         <>
           <div className="card">
-            <h3>Очки игроков (рейтинг)</h3>
+            <h3>Рейтинг игроков</h3>
             <p className="small">
-              Рейтинг считается только по <b>завершённым</b> партиям. Незавершённые и отменённые
-              в зачёт не идут.
+              Рейтинг — оценка силы игрока относительно соперников (система Elo). Каждый начинает
+              с <b>1500</b>. Разница в <b>400</b> пунктов означает шансы 10 к 1 в пользу более
+              сильного.
             </p>
             <p className="small">
-              За каждую партию игрок получает «очки за место» — они нормированы по числу игроков
-              за столом, поэтому победа за большим столом ценится выше, чем за маленьким:
+              Считаются только <b>завершённые</b> партии, по порядку их игры. Правка или удаление
+              старой партии пересчитывает и все последующие.
             </p>
-            <div className="formula">
-              очки = (N − место − (размер_ничьей − 1) / 2) / (N − 1)
+            <p className="small">
+              Партия раскладывается на пары игроков. В каждой паре фактический результат (выше —
+              1, поровну — 0.5, ниже — 0) сравнивается с ожидаемым по рейтингам до партии:
+            </p>
+            <div className="formula">ожидание = 1 / (1 + 10^((R соперника − R игрока) / 400))</div>
+            <div className="formula" style={{ marginTop: 6 }}>
+              ΔR = K × G / (N − 1) × Σ M × (результат − ожидание)
             </div>
             <p className="small" style={{ marginTop: 10 }}>
-              где <b>N</b> — число игроков в партии. Первое место даёт <b>1.0</b>, последнее — <b>0.0</b>.
-            </p>
-            <ul className="small" style={{ marginTop: 0, paddingLeft: 18 }}>
-              <li>Если несколько игроков делят место (ничья) — они делят сумму очков поровну.</li>
-              <li>Выбывшие из партии считаются как последнее место.</li>
-            </ul>
-            <p className="small">
-              Итоговый <b>рейтинг</b> игрока — сглаженное среднее: к реальным партиям
-              «дописываются» 10 виртуальных со средним результатом 0.5 (шкала от 0 до 100):
-            </p>
-            <div className="formula">
-              рейтинг = (10 × 0.5 + сумма очков) / (10 + число партий) × 100
-            </div>
-            <p className="small" style={{ marginTop: 10 }}>
-              Пока партий мало, рейтинг держится около 50 и с опытом сходится к реальному
-              среднему — стабильные результаты на длинной дистанции ценятся выше короткой
-              удачной серии.
+              где <b>N</b> — число игроков, сумма — по всем соперникам. Поэтому победа над сильным
+              приносит больше, чем над слабым, а поражение от слабого отнимает больше. Выбывшие
+              делят последнее место, но между собой не сравниваются: в этой партии все они
+              проиграли, так что пара двух выбывших рейтинг не двигает.
             </p>
           </div>
 
           <div className="card">
-            <h3>Пример (стол на 4 игроков)</h3>
+            <h3>От чего зависит изменение</h3>
+            <ul className="small" style={{ margin: 0, paddingLeft: 18 }}>
+              <li>
+                <b>K — скорость.</b> У новичка 64, к 20-й партии плавно снижается до 16: новичок
+                быстро находит свой уровень, а рейтинг опытного игрока не скачет.
+              </li>
+              <li>
+                <b>G — размер стола:</b> 1 + 0.5 × (N − 2) / 4. В дуэли 1.0, вчетвером 1.25,
+                вшестером 1.5.
+              </li>
+              <li>
+                <b>M — отрыв в паре</b>, от 0.5 до 2. Обычная партия даёт 1. Больше, если:
+                <ul style={{ paddingLeft: 16 }}>
+                  <li>
+                    партия закончилась раньше — для пар с победителем; обычной считается конец
+                    в предпоследнем раунде;
+                  </li>
+                  <li>разница целей велика относительно числа игроков;</li>
+                  <li>разница миров велика относительно доли миров на игрока.</li>
+                </ul>
+              </li>
+              <li>
+                <b>Тип победы</b> — для пар с победителем, чем ближе партия, тем меньше:
+                по целям ×1, по мирам ×0.85, по пластику ×0.7, по ресурсам ×0.6,
+                последний выживший ×1.
+              </li>
+            </ul>
+            <p className="small" style={{ marginTop: 10 }}>
+              Раунд окончания, цели и миры вводить <b>необязательно</b>: пропущенное считается
+              обычным значением и множитель не меняет. «Последний выживший» ставится сам, когда
+              все соперники выбыли, — отрыв по целям тогда максимальный. Лимит раундов — 8,
+              с правилом группы «9 раундов» при 5–6 игроках — 9.
+            </p>
+            <p className="small" style={{ marginBottom: 0 }}>
+              Единоличный победитель никогда не теряет рейтинг, а единоличное последнее место
+              и выбывание никогда его не приносят. Невыбывшие, поделившие место, сравниваются
+              между собой как в ничьей: слабый может получить рейтинг, сильный — потерять.
+            </p>
+          </div>
+
+          <div className="card">
+            <h3>Примеры (опытные игроки)</h3>
             <div className="stack" style={{ gap: 6 }}>
-              <div className="row-between small"><span>1-е место</span><b>(4−1−0)/3 = 1.00 → 100</b></div>
-              <div className="row-between small"><span>2-е место</span><b>(4−2−0)/3 = 0.67 → 67</b></div>
-              <div className="row-between small"><span>3-е место</span><b>(4−3−0)/3 = 0.33 → 33</b></div>
-              <div className="row-between small"><span>4-е место</span><b>(4−4−0)/3 = 0.00 → 0</b></div>
               <div className="row-between small">
-                <span>Ничья за 1-е (двое)</span><b>(4−1−0.5)/3 = 0.83 каждому</b>
+                <span>Дуэль 1600 и 1400: победил сильный</span>
+                <b>+3.8 / −3.8</b>
+              </div>
+              <div className="row-between small">
+                <span>Дуэль 1600 и 1400: победил слабый</span>
+                <b>+12.2 / −12.2</b>
+              </div>
+              <div className="row-between small">
+                <span>Равные, победа по целям без деталей</span>
+                <b>+8.0</b>
+              </div>
+              <div className="row-between small">
+                <span>Равные, победа по мирам без деталей</span>
+                <b>+6.8</b>
+              </div>
+              <div className="row-between small">
+                <span>Разгром на 3-м раунде (цели 2:0, миры 8:2)</span>
+                <b>+16.0</b>
+              </div>
+              <div className="row-between small">
+                <span>1-е место за столом на 5 равных</span>
+                <b>+11.0</b>
+              </div>
+              <div className="row-between small">
+                <span>Новичок обыграл равного опытного</span>
+                <b>+32 / −8</b>
               </div>
             </div>
+            <p className="muted small" style={{ marginBottom: 0 }}>
+              Рейтинг показывается целым числом, но считается без округления.
+            </p>
+          </div>
+
+          <div className="card">
+            <h3>Один рейтинг на всё приложение</h3>
+            <p className="small" style={{ margin: 0 }}>
+              Рейтинг у игрока один — по всем его партиям во всех группах, поэтому он одинаковый
+              в общем топе, в профиле и на странице группы. На странице группы по партиям этой
+              группы считаются только игры, победы, винрейт и среднее место; рейтинг и статус
+              «Новичок» там общие.
+            </p>
           </div>
 
           <div className="card">
@@ -91,6 +160,7 @@ export function HelpPage() {
             <ul className="small" style={{ margin: 0, paddingLeft: 18 }}>
               <li><b>Винрейт (WR)</b> — доля партий, в которых игрок занял 1-е место.</li>
               <li><b>Среднее место</b> — среднее по завершённым партиям.</li>
+              <li><b>Лучшая партия</b> в профиле — та, что принесла больше всего рейтинга.</li>
               <li>
                 При равенстве рейтинга топ сортируется по: винрейту, числу игр, среднему месту
                 и затем по нику.

frontend/src/pages/MatchDetailPage.tsx

@@ -4,13 +4,15 @@ import { useNavigate, useParams } from "react-router-dom";
 import { ApiError } from "../api/client";
 import { ConfirmDialog } from "../components/ConfirmDialog";
 import { MatchMedia } from "../components/MatchMedia";
+import { MatchOutcomeFields } from "../components/MatchOutcomeFields";
 import { PickerSelect } from "../components/PickerSelect";
-import { PlaceEditor } from "../components/PlaceEditor";
+import { type CountField, type Counts, PlaceEditor } from "../components/PlaceEditor";
 import { PlayerLink } from "../components/PlayerLink";
 import { Spinner } from "../components/Spinner";
+import { finishWarnings, type OutcomeSeat } from "../domain/finishWarnings";
 import { formatDate, formatDuration, formatTime } from "../domain/format";
-import type { MatchFinishDraftData } from "../domain/types";
-import { WIN_REASONS, type WinReason, winReasonLabel } from "../domain/winReasons";
+import type { MatchFinishDraftData, MatchRead } from "../domain/types";
+import { reasonForSurvivors, type WinReason, winReasonLabel } from "../domain/winReasons";
 import { useToast } from "../context/ToastContext";
 import { useMe } from "../hooks/auth";
 import {
@@ -24,14 +26,50 @@ import {
 } from "../hooks/matches";
 import { useGroupFactions } from "../hooks/reference";
 
-const REASON_OPTIONS = WIN_REASONS.map((w) => ({ id: w.code, label: w.label }));
+type Participant = MatchRead["participants"][number];
+
+const countsOf = (participants: Participant[]): Counts =>
+  Object.fromEntries(
+    participants.map((p) => [p.user_id, { objectives: p.objectives ?? null, worlds: p.worlds ?? null }]),
+  );
+
+const countsFromDraft = (participants: Participant[], data: MatchFinishDraftData): Counts =>
+  Object.fromEntries(
+    participants.map((p) => [
+      p.user_id,
+      {
+        objectives: data.objectives?.[String(p.user_id)] ?? null,
+        worlds: data.worlds?.[String(p.user_id)] ?? null,
+      },
+    ]),
+  );
+
+// Черновик хранит только заполненные поля: {user_id строкой: число}.
+const countDict = (counts: Counts, field: CountField): Record<string, number> =>
+  Object.fromEntries(
+    Object.entries(counts).flatMap(([uid, c]) => (c[field] == null ? [] : [[uid, c[field]]])),
+  );
+
+const survivorsIn = (blocks: number[][]) => blocks.reduce((sum, ids) => sum + ids.length, 0);
+
+// Места по раскладке: блоки сверху вниз (competition ranking — ничья съедает следующие
+// места), затем выбывшие с общим последним местом.
+const placeRows = (blocks: number[][], eliminated: number[]) => {
+  let place = 1;
+  const survivors = blocks.flatMap((ids) => {
+    const rows = ids.map((uid) => ({ uid, place, eliminated: false }));
+    place += ids.length;
+    return rows;
+  });
+  return [...survivors, ...eliminated.map((uid) => ({ uid, place, eliminated: true }))];
+};
 
 export function MatchDetailPage() {
   const { matchId } = useParams();
   // Number("abc") — NaN, а не null: без проверки запрос уходил бы на /api/matches/NaN.
   const parsed = matchId ? Number(matchId) : NaN;
   const id = Number.isInteger(parsed) ? parsed : null;
-  const { data: match, isLoading, refetch } = useMatch(id);
+  const { data: match, isLoading, error: loadError, refetch } = useMatch(id);
   const { data: me } = useMe();
   const { data: groupFactions } = useGroupFactions(match?.group_id ?? null);
   const finish = useFinishMatch();
@@ -47,7 +85,10 @@ export function MatchDetailPage() {
   const [blocks, setBlocks] = useState<number[][] | null>(null);
   const [elim, setElim] = useState<number[]>([]);
   const [comments, setComments] = useState<Record<number, string> | null>(null);
-  const [winReason, setWinReason] = useState<WinReason>("objectives");
+  const [counts, setCounts] = useState<Counts | null>(null);
+  // null — причина не выбрана: сброшена после «последнего выжившего» (см. reasonForSurvivors).
+  const [winReason, setWinReason] = useState<WinReason | null>("objectives");
+  const [endRound, setEndRound] = useState<number | null>(null);
   const [overall, setOverall] = useState("");
   const [error, setError] = useState<string | null>(null);
   const [confirmRemove, setConfirmRemove] = useState(false);
@@ -86,23 +127,38 @@ export function MatchDetailPage() {
   // Чужой черновик применяем, только если человек сейчас ничего не двигает:
   // иначе правка соседа перетёрла бы тайл прямо под рукой.
   const incoming = match?.finish_draft;
+  const participants = match?.participants;
   useEffect(() => {
-    if (!incoming || match?.status !== "in_progress") return;
+    if (!incoming || !participants || match?.status !== "in_progress") return;
     if (incoming.updated_by === me?.id) return;
     if (incoming.updated_at === appliedDraftAt.current) return;
     if (Date.now() - lastLocalEdit.current < 1500) return;
     setBlocks(incoming.data.blocks);
     setElim(incoming.data.eliminated);
     setComments(incoming.data.comments);
-    setWinReason((incoming.data.win_reason ?? "objectives") as WinReason);
+    setCounts(countsFromDraft(participants, incoming.data));
+    setWinReason(incoming.data.win_reason ?? null);
+    setEndRound(incoming.data.end_round ?? null);
     setOverall(incoming.data.overall_comment ?? "");
     appliedDraftAt.current = incoming.updated_at;
-  }, [incoming, match?.status, me?.id]);
+  }, [incoming, participants, match?.status, me?.id]);
 
   if (isLoading) return <Spinner />;
-  if (!match) return <div className="muted">Партия не найдена.</div>;
+  if (!match) {
+    // Из истории чужого профиля можно попасть в партию группы, где зритель не состоит:
+    // сервер отдаёт 403, и «не найдена» здесь вводила бы в заблуждение.
+    if (loadError instanceof ApiError && loadError.code === "NOT_GROUP_MEMBER") {
+      return (
+        <div className="muted">
+          Партия сыграна в группе, в которой вы не состоите, — открыть её могут только
+          участники группы.
+        </div>
+      );
+    }
+    return <div className="muted">Партия не найдена.</div>;
+  }
 
-  const canModify = !!match.can_modify; // авторитетный флаг с бэкенда (создатель/owner/admin)
+  const canModify = !!match.can_modify; // авторитетный флаг с бэкенда (любой участник группы или админ)
   const inProgress = match.status === "in_progress";
 
   // Ленивая инициализация раскладки из участников: каждый — отдельным блоком.
@@ -110,6 +166,7 @@ export function MatchDetailPage() {
   const finishComments: Record<number, string> =
     comments ??
     Object.fromEntries(match.participants.map((p) => [p.user_id, p.comment ?? ""]));
+  const finishCounts: Counts = counts ?? countsOf(match.participants);
 
   // Конфликт версий (кто-то изменил партию с другого устройства) → сообщаем и обновляем.
   const isStale = (e: unknown) => e instanceof ApiError && e.code === "STALE_WRITE";
@@ -123,44 +180,80 @@ export function MatchDetailPage() {
     ),
     win_reason: winReason,
     overall_comment: overall.trim() || null,
+    end_round: endRound,
+    objectives: countDict(finishCounts, "objectives"),
+    worlds: countDict(finishCounts, "worlds"),
     ...patch,
   });
 
+  // Раскладка изменилась: при одном выжившем причина становится «последний выживший»,
+  // при возврате второго — сбрасывается.
+  const applyLayout = (b: number[][], e: number[]): WinReason | null => {
+    const reason = reasonForSurvivors(winReason, survivorsIn(b));
+    setBlocks(b);
+    setElim(e);
+    setWinReason(reason);
+    return reason;
+  };
+
+  const applyCount = (uid: number, field: CountField, value: number | null): Counts => {
+    const current = finishCounts[uid] ?? { objectives: null, worlds: null };
+    const next = { ...finishCounts, [uid]: { ...current, [field]: value } };
+    setCounts(next);
+    return next;
+  };
+
+  const outcomeSeats = (): OutcomeSeat[] => {
+    const byId = new Map(match.participants.map((p) => [p.user_id, p]));
+    return placeRows(finishBlocks, elim).map(({ uid, place, eliminated }) => ({
+      userId: uid,
+      nickname: byId.get(uid)?.nickname ?? "",
+      place,
+      eliminated,
+      objectives: finishCounts[uid]?.objectives ?? null,
+      worlds: eliminated ? 0 : (finishCounts[uid]?.worlds ?? null),
+    }));
+  };
+
+  const warnings = () =>
+    finishWarnings({
+      seats: outcomeSeats(),
+      winReason,
+      endRound,
+      maxRounds: match.max_rounds,
+    });
+
+  // Строки результатов для API. Место выбывшего и его миры (0) проставит сервер.
+  const resultRows = () =>
+    placeRows(finishBlocks, elim).map(({ uid, place, eliminated }) => ({
+      user_id: uid,
+      place: eliminated ? null : place,
+      eliminated,
+      comment: (finishComments[uid] ?? "").trim() || null,
+      objectives: finishCounts[uid]?.objectives ?? null,
+      worlds: eliminated ? null : (finishCounts[uid]?.worlds ?? null),
+    }));
+
   const submitFinish = async () => {
     if (!id || !match) return;
     setError(null);
+    if (!winReason) {
+      setError("Выберите причину победы.");
+      return;
+    }
     // Дожимаем отложенную запись: иначе последняя правка ушла бы в результаты,
     // но не в черновик, и второй участник увидел бы не то, что записалось.
     if (draftTimer.current) {
       clearTimeout(draftTimer.current);
       sendDraft();
     }
-    const commentOf = (uid: number) => (finishComments[uid] ?? "").trim() || null;
-    let place = 1;
-    const survivors = finishBlocks.flatMap((ids) => {
-      const rows = ids.map((uid) => ({
-        user_id: uid,
-        place,
-        eliminated: false,
-        comment: commentOf(uid),
-      }));
-      place += ids.length; // competition ranking: ничья съедает следующие места
-      return rows;
-    });
     try {
       await finish.mutateAsync({
         matchId: id,
         body: {
-          participants: [
-            ...survivors,
-            ...elim.map((uid) => ({
-              user_id: uid,
-              place: null,
-              eliminated: true,
-              comment: commentOf(uid),
-            })),
-          ],
+          participants: resultRows(),
           win_reason: winReason,
+          end_round: endRound,
           overall_comment: overall.trim() || null,
           expected_version: match.version,
         },
@@ -188,7 +281,9 @@ export function MatchDetailPage() {
     setComments(
       Object.fromEntries(match.participants.map((p) => [p.user_id, p.comment ?? ""])),
     );
-    setWinReason((match.win_reason ?? "objectives") as WinReason);
+    setCounts(countsOf(match.participants));
+    setWinReason((match.win_reason ?? null) as WinReason | null);
+    setEndRound(match.end_round ?? null);
     setOverall(match.overall_comment ?? "");
     setEditFactions(Object.fromEntries(match.participants.map((p) => [p.user_id, p.faction_id])));
     setError(null);
@@ -199,36 +294,31 @@ export function MatchDetailPage() {
     setEditing(false);
     setBlocks(null);
     setComments(null);
+    setCounts(null);
     setError(null);
   };
 
   const submitEdit = async () => {
     if (!id || !match) return;
     setError(null);
+    if (!winReason) {
+      setError("Выберите причину победы.");
+      return;
+    }
     const wasRandom = Object.fromEntries(
       match.participants.map((p) => [p.user_id, p.was_random]),
     );
-    const commentOf = (uid: number) => (finishComments[uid] ?? "").trim() || null;
-    const rowOf = (uid: number, place: number | null, eliminated: boolean) => ({
-      user_id: uid,
-      faction_id: editFactions[uid],
-      place,
-      eliminated,
-      was_random: wasRandom[uid] ?? false,
-      comment: commentOf(uid),
-    });
-    let place = 1;
-    const survivors = finishBlocks.flatMap((ids) => {
-      const rows = ids.map((uid) => rowOf(uid, place, false));
-      place += ids.length; // competition ranking: ничья съедает следующие места
-      return rows;
-    });
     try {
       await updateMatch.mutateAsync({
         matchId: id,
         body: {
-          participants: [...survivors, ...elim.map((uid) => rowOf(uid, null, true))],
+          participants: resultRows().map((r) => ({
+            ...r,
+            faction_id: editFactions[r.user_id],
+            was_random: wasRandom[r.user_id] ?? false,
+          })),
           win_reason: winReason,
+          end_round: endRound,
           overall_comment: overall.trim() || null,
           expected_version: match.version,
         },
@@ -276,6 +366,13 @@ export function MatchDetailPage() {
       .map((p) => ({ id: p.faction_id, code: "", name_ru: p.faction_name, expansion_id: 0 })),
   ];
 
+  const placeHint = (
+    <p className="muted small">
+      Перетаскивайте игроков за ⠿: верхний — 1-е место. Бросьте на другого игрока, чтобы
+      разделить место (ничья). Цели и миры — на конец партии.
+    </p>
+  );
+
   return (
     <div>
       <div className="card">
@@ -294,6 +391,9 @@ export function MatchDetailPage() {
         {!inProgress && (
           <div className="small" style={{ marginTop: 4 }}>
             Победа: <b>{winReasonLabel(match.win_reason)}</b>
+            {match.end_round != null && (
+              <span className="muted"> · конец в {match.end_round}-м раунде из {match.max_rounds}</span>
+            )}
           </div>
         )}
         {match.overall_comment && <p className="small" style={{ marginTop: 6 }}>{match.overall_comment}</p>}
@@ -304,20 +404,16 @@ export function MatchDetailPage() {
         <>
           <div className="card">
             <h3>Правка результатов</h3>
-            <p className="muted small">
-              Перетаскивайте игроков за ⠿: верхний — 1-е место. Бросьте на другого
-              игрока, чтобы разделить место (ничья).
-            </p>
+            {placeHint}
             <PlaceEditor
               players={match.participants}
               blocks={finishBlocks}
               eliminated={elim}
               comments={finishComments}
-              onChange={(b, e) => {
-                setBlocks(b);
-                setElim(e);
-              }}
+              counts={finishCounts}
+              onChange={applyLayout}
               onComment={(uid, text) => setComments({ ...finishComments, [uid]: text })}
+              onCount={applyCount}
             />
           </div>
 
@@ -345,16 +441,14 @@ export function MatchDetailPage() {
             </div>
           </div>
 
-          <div className="card">
-            <h3>Причина победы</h3>
-            <PickerSelect
-              selected={REASON_OPTIONS.find((o) => o.id === winReason) ?? null}
-              options={REASON_OPTIONS}
-              placeholder="— причина —"
-              renderOption={(o) => o.label}
-              onPick={(o) => setWinReason(o.id)}
-            />
-          </div>
+          <MatchOutcomeFields
+            winReason={winReason}
+            onReason={setWinReason}
+            endRound={endRound}
+            onEndRound={setEndRound}
+            maxRounds={match.max_rounds}
+            warnings={warnings()}
+          />
 
           <div className="card">
             <h3>О партии</h3>
@@ -413,6 +507,11 @@ export function MatchDetailPage() {
                   <span className="muted small">· {p.faction_name}</span>
                   {p.was_random && <span className="badge">🎲</span>}
                 </PlayerLink>
+                {(p.objectives != null || p.worlds != null) && (
+                  <div className="small muted" style={{ marginLeft: 32 }}>
+                    цели {p.objectives ?? "—"} · миры {p.worlds ?? "—"}
+                  </div>
+                )}
                 {p.comment && <div className="small muted" style={{ marginLeft: 32 }}>{p.comment}</div>}
               </div>
             ))}
@@ -448,10 +547,7 @@ export function MatchDetailPage() {
             <>
               <div className="card">
                 <h3>Места</h3>
-                <p className="muted small">
-                  Перетаскивайте игроков за ⠿: верхний — 1-е место. Бросьте на другого
-                  игрока, чтобы разделить место (ничья).
-                </p>
+                {placeHint}
                 {match.finish_draft && match.finish_draft.updated_by !== me?.id && (
                   <p className="small" style={{ color: "var(--accent-2)" }}>
                     Результаты заполняет также {match.finish_draft.updated_by_nickname ?? "другой игрок"}
@@ -464,10 +560,10 @@ export function MatchDetailPage() {
                   blocks={finishBlocks}
                   eliminated={elim}
                   comments={finishComments}
+                  counts={finishCounts}
                   onChange={(b, e) => {
-                    setBlocks(b);
-                    setElim(e);
-                    queueDraft(draftOf({ blocks: b, eliminated: e }));
+                    const reason = applyLayout(b, e);
+                    queueDraft(draftOf({ blocks: b, eliminated: e, win_reason: reason }));
                   }}
                   onComment={(uid, text) => {
                     const next = { ...finishComments, [uid]: text };
@@ -480,23 +576,33 @@ export function MatchDetailPage() {
                       }),
                     );
                   }}
-                />
-              </div>
-
-              <div className="card">
-                <h3>Причина победы</h3>
-                <PickerSelect
-                  selected={REASON_OPTIONS.find((o) => o.id === winReason) ?? null}
-                  options={REASON_OPTIONS}
-                  placeholder="— причина —"
-                  renderOption={(o) => o.label}
-                  onPick={(o) => {
-                    setWinReason(o.id);
-                    queueDraft(draftOf({ win_reason: o.id }));
+                  onCount={(uid, field, value) => {
+                    const next = applyCount(uid, field, value);
+                    queueDraft(
+                      draftOf({
+                        objectives: countDict(next, "objectives"),
+                        worlds: countDict(next, "worlds"),
+                      }),
+                    );
                   }}
                 />
               </div>
 
+              <MatchOutcomeFields
+                winReason={winReason}
+                onReason={(reason) => {
+                  setWinReason(reason);
+                  queueDraft(draftOf({ win_reason: reason }));
+                }}
+                endRound={endRound}
+                onEndRound={(round) => {
+                  setEndRound(round);
+                  queueDraft(draftOf({ end_round: round }));
+                }}
+                maxRounds={match.max_rounds}
+                warnings={warnings()}
+              />
+
               <div className="card">
                 <h3>О партии</h3>
                 <textarea

frontend/src/pages/OverallStatsPage.tsx

@@ -6,7 +6,9 @@ import { Spinner } from "../components/Spinner";
 import type { LeaderboardEntry } from "../domain/types";
 import { useLeaderboard } from "../hooks/stats";
 
-type SortKey = "rank" | "games" | "wins" | "win_rate" | "score";
+// Столбца побед нет: четырёхзначный рейтинг иначе не помещается в строку, а доля побед
+// уже есть в WR.
+type SortKey = "rank" | "games" | "win_rate" | "score";
 
 function pct(v: number | null | undefined): string {
   return v == null ? "—" : `${Math.round(v * 100)}%`;
@@ -50,7 +52,6 @@ export function OverallStatsPage() {
         <span className="nick">{e.nickname}</span>
       </span>
       <span className="st-num">{e.games}</span>
-      <span className="st-num">{e.wins}</span>
       <span className="st-num">{pct(e.win_rate)}</span>
       <span className={"st-num lb-score" + (isProvisional || e.score == null ? " provisional" : "")}>
         {e.score ?? "—"}
@@ -70,9 +71,8 @@ export function OverallStatsPage() {
           <button onClick={() => toggleSort("rank")}>#{arrow("rank")}</button>
           <span>Игрок</span>
           <button onClick={() => toggleSort("games")}>Игр{arrow("games")}</button>
-          <button onClick={() => toggleSort("wins")}>Поб{arrow("wins")}</button>
           <button onClick={() => toggleSort("win_rate")}>WR{arrow("win_rate")}</button>
-          <button onClick={() => toggleSort("score")}>Очки{arrow("score")}</button>
+          <button onClick={() => toggleSort("score")}>Рейтинг{arrow("score")}</button>
         </div>
         {entries.length === 0 ? (
           <div className="muted small" style={{ paddingTop: 8 }}>

frontend/src/pages/admin/AdminAccountsPage.tsx

@@ -6,7 +6,7 @@ import { Spinner } from "../../components/Spinner";
 import { useToast } from "../../context/ToastContext";
 import { useAdminSetPassword, useAdminUpdateUser, useAdminUsers } from "../../hooks/admin";
 // DEV-ТОЛЬКО: удаление аккаунтов. Импорт используется лишь под import.meta.env.DEV,
-// поэтому в прод/тест-сборке вырезается тришейкингом (как и dev-вход).
+// поэтому в прод-сборке вырезается тришейкингом (как и dev-вход).
 import { DevDeleteAccountButton } from "./DevDeleteAccountButton";
 
 export function AdminAccountsPage() {

frontend/src/pages/admin/AdminAnnouncementsPage.tsx

@@ -0,0 +1,329 @@
+import { useRef, useState } from "react";
+
+import { ApiError } from "../../api/client";
+import { AnnouncementWindow } from "../../components/AnnouncementWindow";
+import { ConfirmDialog } from "../../components/ConfirmDialog";
+import { Spinner } from "../../components/Spinner";
+import { Switch } from "../../components/Switch";
+import { useToast } from "../../context/ToastContext";
+import { formatDateTime, fromAppLocalInput, toAppLocalInput } from "../../domain/format";
+import type { AdminAnnouncementRead } from "../../domain/types";
+import {
+  useAdminAnnouncements,
+  useAdminCreateAnnouncement,
+  useAdminDeleteAnnouncement,
+  useAdminStopAnnouncement,
+  useAdminUpdateAnnouncement,
+} from "../../hooks/admin";
+import { RichTextEditor } from "./RichTextEditor";
+
+// Те же пределы, что проверяет сервер (announcement_service).
+const TITLE_MAX = 60;
+const TEXT_MAX = 600;
+const WEEK_MS = 7 * 24 * 3600_000;
+
+const STATUS: Record<AdminAnnouncementRead["status"], [string, string]> = {
+  planned: ["Запланировано", "badge"],
+  live: ["Идёт", "badge badge-live"],
+  finished: ["Завершено", "badge muted"],
+};
+
+interface Draft {
+  id: number | null; // null — новое объявление
+  key: number; // смена key пересоздаёт редактор с новым начальным текстом
+  title: string;
+  html: string;
+  length: number;
+  starts: string; // datetime-local, МСК
+  ends: string;
+  showToNew: boolean;
+  reshow: boolean;
+}
+
+let draftSeq = 0;
+
+// Новое объявление: показ с текущей минуты на неделю. from — «Дублировать».
+function newDraft(from?: AdminAnnouncementRead): Draft {
+  const now = Date.now();
+  return {
+    id: null,
+    key: ++draftSeq,
+    title: from?.title ?? "",
+    html: from?.body_html ?? "",
+    length: 0,
+    starts: toAppLocalInput(new Date(now).toISOString()),
+    ends: toAppLocalInput(new Date(now + WEEK_MS).toISOString()),
+    showToNew: from?.show_to_new_players ?? true,
+    reshow: false,
+  };
+}
+
+function editDraft(a: AdminAnnouncementRead): Draft {
+  return {
+    id: a.id,
+    key: ++draftSeq,
+    title: a.title,
+    html: a.body_html,
+    length: 0,
+    starts: toAppLocalInput(a.starts_at),
+    ends: toAppLocalInput(a.ends_at),
+    showToNew: a.show_to_new_players,
+    reshow: false,
+  };
+}
+
+export function AdminAnnouncementsPage() {
+  const { data: items, isLoading } = useAdminAnnouncements();
+  const create = useAdminCreateAnnouncement();
+  const update = useAdminUpdateAnnouncement();
+  const stop = useAdminStopAnnouncement();
+  const remove = useAdminDeleteAnnouncement();
+  const toast = useToast();
+  const formRef = useRef<HTMLDivElement>(null);
+
+  const [draft, setDraft] = useState<Draft>(() => newDraft());
+  const [error, setError] = useState<string | null>(null);
+  const [preview, setPreview] = useState(false);
+  const [toDelete, setToDelete] = useState<AdminAnnouncementRead | null>(null);
+
+  const patch = (p: Partial<Draft>) => setDraft((d) => ({ ...d, ...p }));
+
+  const openDraft = (d: Draft) => {
+    setDraft(d);
+    setError(null);
+    formRef.current?.scrollIntoView({ behavior: "smooth", block: "start" });
+  };
+
+  const validate = (): { starts: string; ends: string } | string => {
+    if (!draft.title.trim()) return "Введите заголовок.";
+    if (draft.length === 0) return "Введите текст объявления.";
+    if (draft.length > TEXT_MAX) return `Текст длиннее ${TEXT_MAX} символов.`;
+    const starts = fromAppLocalInput(draft.starts);
+    const ends = fromAppLocalInput(draft.ends);
+    if (!starts || !ends) return "Укажите начало и конец показа.";
+    if (ends <= starts) return "Конец показа должен быть позже начала.";
+    return { starts, ends };
+  };
+
+  const save = async () => {
+    const period = validate();
+    if (typeof period === "string") {
+      setError(period);
+      return;
+    }
+    setError(null);
+    const body = {
+      title: draft.title.trim(),
+      body_html: draft.html,
+      starts_at: period.starts,
+      ends_at: period.ends,
+      show_to_new_players: draft.showToNew,
+    };
+    try {
+      if (draft.id == null) {
+        const a = await create.mutateAsync(body);
+        toast.show(a.status === "planned" ? "Объявление запланировано" : "Объявление опубликовано");
+      } else {
+        await update.mutateAsync({ id: draft.id, body: { ...body, reshow: draft.reshow } });
+        toast.show(draft.reshow ? "Сохранено — игроки увидят обновление" : "Сохранено");
+      }
+      setDraft(newDraft());
+    } catch (e) {
+      toast.error(e instanceof ApiError ? e.message : "Ошибка");
+    }
+  };
+
+  const doStop = async (a: AdminAnnouncementRead) => {
+    try {
+      await stop.mutateAsync(a.id);
+      toast.show("Снято с показа");
+    } catch (e) {
+      toast.error(e instanceof ApiError ? e.message : "Ошибка");
+    }
+  };
+
+  const doDelete = async () => {
+    const a = toDelete;
+    setToDelete(null);
+    if (!a) return;
+    try {
+      await remove.mutateAsync(a.id);
+      if (draft.id === a.id) setDraft(newDraft());
+      toast.show("Объявление удалено");
+    } catch (e) {
+      toast.error(e instanceof ApiError ? e.message : "Ошибка");
+    }
+  };
+
+  const saving = create.isPending || update.isPending;
+
+  return (
+    <div>
+      <div className="card ann-form" ref={formRef}>
+        {draft.id != null && (
+          <div className="row-between" style={{ marginBottom: 8 }}>
+            <span className="muted small">Правка объявления</span>
+            <button className="btn btn-ghost small" onClick={() => openDraft(newDraft())}>
+              Отменить правку
+            </button>
+          </div>
+        )}
+
+        <div className="field">
+          <label className="label" htmlFor="ann-title">
+            Заголовок
+          </label>
+          <input
+            id="ann-title"
+            maxLength={TITLE_MAX}
+            value={draft.title}
+            onChange={(e) => patch({ title: e.target.value })}
+          />
+        </div>
+
+        <div className="field">
+          <span className="label">Текст объявления</span>
+          <RichTextEditor
+            key={draft.key}
+            initialHtml={draft.html}
+            onChange={(html, length) => patch({ html, length })}
+          />
+          <div className={"rte-counter" + (draft.length > TEXT_MAX ? " over" : "")}>
+            {draft.length} / {TEXT_MAX}
+          </div>
+        </div>
+
+        <div className="row" style={{ alignItems: "flex-start" }}>
+          <div className="field" style={{ flex: 1, minWidth: 0 }}>
+            <label className="label" htmlFor="ann-starts">
+              Показывать с (МСК)
+            </label>
+            <input
+              id="ann-starts"
+              type="datetime-local"
+              value={draft.starts}
+              onChange={(e) => patch({ starts: e.target.value })}
+            />
+          </div>
+          <div className="field" style={{ flex: 1, minWidth: 0 }}>
+            <label className="label" htmlFor="ann-ends">
+              по (МСК)
+            </label>
+            <input
+              id="ann-ends"
+              type="datetime-local"
+              value={draft.ends}
+              onChange={(e) => patch({ ends: e.target.value })}
+            />
+          </div>
+        </div>
+
+        <label className="row-between">
+          <span>Показывать новым игрокам</span>
+          <Switch checked={draft.showToNew} onChange={(v) => patch({ showToNew: v })} />
+        </label>
+        <p className="muted small" style={{ margin: "4px 0 12px" }}>
+          Выключите, если объявление ни к чему тем, кто зарегистрируется после начала показа.
+        </p>
+
+        {draft.id != null && (
+          <>
+            <label className="row-between">
+              <span>Показать заново тем, кто уже закрыл</span>
+              <Switch checked={draft.reshow} onChange={(v) => patch({ reshow: v })} />
+            </label>
+            <p className="muted small" style={{ margin: "4px 0 12px" }}>
+              Они увидят объявление ещё раз — с красной пометкой «обновлено» под заголовком.
+            </p>
+          </>
+        )}
+
+        {error && <p className="error-text">{error}</p>}
+
+        <div className="row">
+          <button className="btn btn-ghost" onClick={() => setPreview(true)}>
+            Предпросмотр
+          </button>
+          <button className="btn btn-primary" style={{ flex: 1 }} disabled={saving} onClick={save}>
+            {draft.id == null ? "Опубликовать" : "Сохранить"}
+          </button>
+        </div>
+      </div>
+
+      <h3>Созданные объявления</h3>
+      {isLoading ? (
+        <Spinner />
+      ) : !items?.length ? (
+        <p className="muted small">Объявлений пока нет.</p>
+      ) : (
+        <div className="stack">
+          {items.map((a) => {
+            const [label, badge] = STATUS[a.status];
+            const meta = [
+              `${formatDateTime(a.starts_at)} — ${formatDateTime(a.ends_at)}`,
+              `закрыли ${a.seen_count} из ${a.audience_count}`,
+              ...(a.show_to_new_players ? [] : ["без новых игроков"]),
+              ...(a.revision > 1 ? [`версия ${a.revision}`] : []),
+            ];
+            return (
+              <div key={a.id} className="card" style={{ margin: 0 }}>
+                <div className="row-between" style={{ alignItems: "flex-start" }}>
+                  <div style={{ minWidth: 0 }}>
+                    <div style={{ fontWeight: 600, overflowWrap: "anywhere" }}>{a.title}</div>
+                    <div className="muted small" style={{ marginTop: 2 }}>
+                      {meta.join(" · ")}
+                    </div>
+                  </div>
+                  <span className={badge}>{label}</span>
+                </div>
+                <div className="row" style={{ marginTop: 10, flexWrap: "wrap", gap: 8 }}>
+                  <button className="btn btn-ghost small" onClick={() => openDraft(editDraft(a))}>
+                    Изменить
+                  </button>
+                  {a.status === "live" ? (
+                    <button
+                      className="btn btn-ghost small"
+                      disabled={stop.isPending}
+                      onClick={() => doStop(a)}
+                    >
+                      Снять с показа
+                    </button>
+                  ) : (
+                    <button className="btn btn-ghost small" onClick={() => openDraft(newDraft(a))}>
+                      Дублировать
+                    </button>
+                  )}
+                  <button className="btn btn-danger small" onClick={() => setToDelete(a)}>
+                    Удалить
+                  </button>
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      )}
+
+      {preview && (
+        <AnnouncementWindow
+          title={draft.title.trim() || "Без заголовка"}
+          bodyHtml={draft.html}
+          onOk={() => setPreview(false)}
+        />
+      )}
+
+      <ConfirmDialog
+        open={toDelete != null}
+        title="Удалить объявление?"
+        message={
+          toDelete
+            ? `«${toDelete.title}» пропадёт у всех, кто его ещё не закрыл, а отметки о прочтении удалятся.`
+            : undefined
+        }
+        confirmLabel="Удалить"
+        danger
+        onConfirm={doDelete}
+        onCancel={() => setToDelete(null)}
+      />
+    </div>
+  );
+}

frontend/src/pages/admin/AdminLayout.tsx

@@ -38,6 +38,9 @@ export function AdminLayout() {
         <NavLink to="/admin/logs" className={tab}>
           Логи
         </NavLink>
+        <NavLink to="/admin/announcements" className={tab}>
+          Объявления
+        </NavLink>
       </div>
       <main className="app-main" style={{ paddingBottom: 24 }}>
         <Outlet />

frontend/src/pages/admin/AdminLogsPage.tsx

@@ -5,7 +5,7 @@ import { formatDateTime } from "../../domain/format";
 import { useAdminLogs } from "../../hooks/admin";
 
 const ACTIONS = ["", "login", "create", "update", "delete"];
-const ENTITIES = ["", "user", "group", "group_member", "match", "admin"];
+const ENTITIES = ["", "user", "group", "group_member", "match", "admin", "announcement"];
 
 export function AdminLogsPage() {
   const [action, setAction] = useState("");

frontend/src/pages/admin/AdminMatchEdit.tsx

@@ -5,7 +5,15 @@ import { ApiError } from "../../api/client";
 import { MatchMedia } from "../../components/MatchMedia";
 import { Spinner } from "../../components/Spinner";
 import { Switch } from "../../components/Switch";
-import { WIN_REASONS, type WinReason } from "../../domain/winReasons";
+import { finishWarnings } from "../../domain/finishWarnings";
+import { MAX_COUNT, parseCount } from "../../domain/matchCounts";
+import {
+  LAST_STANDING,
+  reasonForSurvivors,
+  WIN_REASONS,
+  type WinReason,
+  winReasonLabel,
+} from "../../domain/winReasons";
 import {
   useAdminDeleteAttachment,
   useAdminFactions,
@@ -23,6 +31,8 @@ interface Row {
   eliminated: boolean;
   was_random: boolean;
   comment: string;
+  objectives: number | null;
+  worlds: number | null;
 }
 
 export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose: () => void }) {
@@ -37,7 +47,8 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
   const [rows, setRows] = useState<Row[]>([]);
   const [playedAt, setPlayedAt] = useState("");
   const [overall, setOverall] = useState("");
-  const [winReason, setWinReason] = useState<WinReason>("objectives");
+  const [winReason, setWinReason] = useState<WinReason | null>("objectives");
+  const [endRound, setEndRound] = useState<number | null>(null);
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
@@ -51,19 +62,32 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
           eliminated: p.eliminated,
           was_random: p.was_random,
           comment: p.comment ?? "",
+          objectives: p.objectives ?? null,
+          worlds: p.worlds ?? null,
         })),
       );
       setPlayedAt(match.played_at);
       setOverall(match.overall_comment ?? "");
-      if (match.win_reason) setWinReason(match.win_reason);
+      setWinReason(match.win_reason ?? null);
+      setEndRound(match.end_round ?? null);
     }
   }, [match]);
 
-  const upd = (i: number, patch: Partial<Row>) =>
-    setRows((rs) => rs.map((r, idx) => (idx === i ? { ...r, ...patch } : r)));
+  const upd = (i: number, patch: Partial<Row>) => {
+    const next = rows.map((r, idx) => (idx === i ? { ...r, ...patch } : r));
+    setRows(next);
+    // Выбывание меняет число выживших: «последний выживший» ставится и снимается сам.
+    if ("eliminated" in patch) {
+      setWinReason(reasonForSurvivors(winReason, next.filter((r) => !r.eliminated).length));
+    }
+  };
 
   const save = async () => {
     setError(null);
+    if (!winReason) {
+      setError("Выберите причину победы.");
+      return;
+    }
     try {
       await update.mutateAsync({
         matchId,
@@ -71,6 +95,7 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
           played_at: playedAt,
           overall_comment: overall.trim() || null,
           win_reason: winReason,
+          end_round: endRound,
           participants: rows.map((r) => ({
             user_id: r.user_id,
             faction_id: r.faction_id,
@@ -78,6 +103,8 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
             eliminated: r.eliminated,
             was_random: r.was_random,
             comment: r.comment.trim() || null,
+            objectives: r.objectives,
+            worlds: r.eliminated ? null : r.worlds,
           })),
         },
       });
@@ -87,6 +114,22 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
     }
   };
 
+  const warnings = match
+    ? finishWarnings({
+        seats: rows.map((r) => ({
+          userId: r.user_id,
+          nickname: r.nickname,
+          place: r.place,
+          eliminated: r.eliminated,
+          objectives: r.objectives,
+          worlds: r.eliminated ? 0 : r.worlds,
+        })),
+        winReason,
+        endRound,
+        maxRounds: match.max_rounds,
+      })
+    : [];
+
   return (
     // Полноэкранная страница правки (не нижний «лист»): занимает весь экран.
     <div
@@ -159,23 +202,81 @@ export function AdminMatchEdit({ matchId, onClose }: { matchId: number; onClose:
                       выбыл
                     </label>
                   </div>
-                  <input
-                    placeholder="Комментарий об игроке"
-                    value={r.comment}
-                    onChange={(e) => upd(i, { comment: e.target.value })}
-                  />
+                  <div className="row">
+                    <input
+                      style={{ flex: 1 }}
+                      placeholder="Комментарий об игроке"
+                      value={r.comment}
+                      onChange={(e) => upd(i, { comment: e.target.value })}
+                    />
+                    <input
+                      style={{ flex: "0 0 70px" }}
+                      type="number"
+                      min={0}
+                      max={MAX_COUNT}
+                      placeholder="цели"
+                      title="Цели на конец партии"
+                      value={r.objectives ?? ""}
+                      onChange={(e) => upd(i, { objectives: parseCount(e.target.value) })}
+                    />
+                    <input
+                      style={{ flex: "0 0 70px" }}
+                      type="number"
+                      min={0}
+                      max={MAX_COUNT}
+                      placeholder="миры"
+                      title="Миры на конец партии"
+                      disabled={r.eliminated}
+                      value={r.eliminated ? 0 : (r.worlds ?? "")}
+                      onChange={(e) => upd(i, { worlds: parseCount(e.target.value) })}
+                    />
+                  </div>
                 </div>
               ))}
 
               <div className="field">
                 <label className="label">Причина победы</label>
-                <select value={winReason} onChange={(e) => setWinReason(e.target.value as WinReason)}>
-                  {WIN_REASONS.map((w) => (
-                    <option key={w.code} value={w.code}>
-                      {w.label}
+                {winReason === LAST_STANDING ? (
+                  <select value={LAST_STANDING} disabled>
+                    <option value={LAST_STANDING}>{winReasonLabel(LAST_STANDING)}</option>
+                  </select>
+                ) : (
+                  <select
+                    value={winReason ?? ""}
+                    onChange={(e) => setWinReason(e.target.value as WinReason)}
+                  >
+                    <option value="" disabled>
+                      — выберите причину —
+                    </option>
+                    {WIN_REASONS.map((w) => (
+                      <option key={w.code} value={w.code}>
+                        {w.label}
+                      </option>
+                    ))}
+                  </select>
+                )}
+              </div>
+
+              <div className="field">
+                <label className="label">Раунд окончания (из {match.max_rounds})</label>
+                <select
+                  value={endRound ?? ""}
+                  onChange={(e) => setEndRound(e.target.value === "" ? null : Number(e.target.value))}
+                >
+                  <option value="">не указан</option>
+                  {Array.from({ length: match.max_rounds }, (_, k) => k + 1).map((n) => (
+                    <option key={n} value={n}>
+                      {n}-й
                     </option>
                   ))}
                 </select>
+                {warnings.length > 0 && (
+                  <ul className="warn-list">
+                    {warnings.map((w) => (
+                      <li key={w}>{w}</li>
+                    ))}
+                  </ul>
+                )}
               </div>
 
               <div className="field">

frontend/src/pages/admin/DevDeleteAccountButton.tsx

@@ -10,9 +10,9 @@ import { useToast } from "../../context/ToastContext";
  * DEV-ТОЛЬКО кнопка жёсткого удаления аккаунта.
  *
  * Эндпоинт `DELETE /api/admin/dev/users/{id}` существует только в dev-сборке бэкенда
- * (backend/app/routers/dev_admin.py, исключён из прод/тест-образа). Этот модуль
+ * (backend/app/routers/dev_admin.py, исключён из прод-образа). Этот модуль
  * рендерится лишь под `import.meta.env.DEV` в AdminAccountsPage, поэтому в прод-сборке
- * он не используется и вырезается тришейкингом — в прод/тест удаление недоступно.
+ * он не используется и вырезается тришейкингом — в проде удаление недоступно.
  */
 export function DevDeleteAccountButton({
   userId,
@@ -39,7 +39,7 @@ export function DevDeleteAccountButton({
       <button
         className="btn small"
         // Яркая (сплошная) красная кнопка. Стиль инлайном, а не классом в общем CSS,
-        // чтобы в прод/тест-стили не попало ничего, связанного с удалением.
+        // чтобы в прод-стили не попало ничего, связанного с удалением.
         style={{ background: "var(--danger)", borderColor: "var(--danger)", color: "#fff" }}
         disabled={del.isPending}
         onClick={() => setConfirmOpen(true)}

frontend/src/pages/admin/RichTextEditor.tsx

@@ -0,0 +1,183 @@
+import { type ReactNode, useEffect, useRef, useState } from "react";
+
+const EMOJI = ["🏆", "📈", "🛠️", "🍂", "⚔️", "💀", "🔥", "🎲", "📅", "❗"];
+
+const escapeHtml = (s: string) =>
+  s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+// Кнопка панели. mousedown гасим, чтобы фокус и выделение остались в поле текста.
+function Tool({
+  title,
+  className,
+  onClick,
+  children,
+}: {
+  title: string;
+  className?: string;
+  onClick: () => void;
+  children: ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      className={"rte-tool" + (className ? ` ${className}` : "")}
+      title={title}
+      aria-label={title}
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={onClick}
+    >
+      {children}
+    </button>
+  );
+}
+
+/**
+ * Редактор текста объявления (вариант R1 из #84): поле contenteditable и панель —
+ * жирный, курсив, золотой и красный акцент, эмодзи, снятие оформления. Набор узкий
+ * намеренно: сервер всё равно оставит только b / em / mark / p / br
+ * (announcement_service.sanitize_body). Вставка и перетаскивание — только простым текстом.
+ *
+ * Поле неуправляемое: начальный HTML ставится при монтировании (для другого объявления
+ * родитель пересоздаёт редактор через key), дальше каждое изменение уходит в onChange
+ * вместе с длиной видимого текста в символах — так же её считает сервер.
+ */
+export function RichTextEditor({
+  initialHtml,
+  onChange,
+}: {
+  initialHtml: string;
+  onChange: (html: string, length: number) => void;
+}) {
+  const ref = useRef<HTMLDivElement>(null);
+  const [emojiOpen, setEmojiOpen] = useState(false);
+
+  const emit = () => {
+    const el = ref.current;
+    if (el) onChange(el.innerHTML, [...(el.textContent ?? "").trim()].length);
+  };
+
+  // Только при монтировании: дальше содержимым владеет сам contenteditable.
+  useEffect(() => {
+    if (ref.current) ref.current.innerHTML = initialHtml;
+    emit();
+  }, []);
+
+  // Выделение внутри поля — кнопки панели работают только с ним.
+  const rangeInEditor = (): Range | null => {
+    const sel = document.getSelection();
+    if (!sel || sel.rangeCount === 0) return null;
+    const range = sel.getRangeAt(0);
+    return ref.current?.contains(range.commonAncestorContainer) ? range : null;
+  };
+
+  // Курсор в конец поля, если в нём ещё не кликали (эмодзи до первого клика в текст).
+  const ensureCaret = () => {
+    const el = ref.current;
+    if (!el) return;
+    el.focus();
+    if (rangeInEditor()) return;
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    range.collapse(false);
+    const sel = document.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  };
+
+  const run = (fn: () => void) => {
+    fn();
+    emit();
+  };
+
+  const format = (cmd: "bold" | "italic") =>
+    run(() => {
+      if (rangeInEditor()) document.execCommand(cmd);
+    });
+
+  // Акцент: выделенный текст целиком оборачивается в <mark> (золотой) или
+  // <mark class="red">. Оформление внутри выделения при этом снимается — для коротких
+  // акцентов это проще, чем вложенные теги.
+  const accent = (red: boolean) =>
+    run(() => {
+      const range = rangeInEditor();
+      if (!range || range.collapsed) return;
+      const inner = range.toString().split("\n").map(escapeHtml).join("<br>");
+      document.execCommand("insertHTML", false, `<mark${red ? ' class="red"' : ""}>${inner}</mark>`);
+    });
+
+  const clearFormat = () =>
+    run(() => {
+      if (!rangeInEditor()) return;
+      document.execCommand("removeFormat");
+      // removeFormat не знает про <mark> — акценты в выделении снимаем сами.
+      const range = rangeInEditor();
+      ref.current?.querySelectorAll("mark").forEach((m) => {
+        if (range?.intersectsNode(m)) m.replaceWith(...Array.from(m.childNodes));
+      });
+    });
+
+  const insertEmoji = (emoji: string) =>
+    run(() => {
+      ensureCaret();
+      document.execCommand("insertText", false, emoji);
+    });
+
+  return (
+    <div>
+      <div className="rte-toolbar">
+        <Tool title="Жирный" onClick={() => format("bold")}>
+          <b>Ж</b>
+        </Tool>
+        <Tool title="Курсив" onClick={() => format("italic")}>
+          <em>К</em>
+        </Tool>
+        <Tool title="Золотой акцент" className="rte-gold" onClick={() => accent(false)}>
+          A
+        </Tool>
+        <Tool title="Красный акцент" className="rte-red" onClick={() => accent(true)}>
+          A
+        </Tool>
+        <span className="rte-sep" />
+        <Tool title="Эмодзи" onClick={() => setEmojiOpen((v) => !v)}>
+          😀
+        </Tool>
+        <span className="rte-sep" />
+        <Tool title="Убрать оформление" onClick={clearFormat}>
+          ✕&nbsp;формат
+        </Tool>
+      </div>
+      <div
+        ref={ref}
+        className="rte-editor ann-body"
+        contentEditable
+        suppressContentEditableWarning
+        role="textbox"
+        aria-multiline="true"
+        aria-label="Текст объявления"
+        data-placeholder="Короткий текст объявления…"
+        onInput={emit}
+        // Enter создаёт <p>, а не <div> — абзацы сразу в том виде, что хранит сервер.
+        onFocus={() => document.execCommand("defaultParagraphSeparator", false, "p")}
+        onPaste={(e) => {
+          e.preventDefault();
+          document.execCommand("insertText", false, e.clipboardData.getData("text/plain"));
+        }}
+        onDrop={(e) => e.preventDefault()}
+      />
+      {emojiOpen && (
+        <div className="rte-emoji">
+          {EMOJI.map((emoji) => (
+            <button
+              key={emoji}
+              type="button"
+              onMouseDown={(e) => e.preventDefault()}
+              onClick={() => insertEmoji(emoji)}
+            >
+              {emoji}
+            </button>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/styles/global.css

@@ -103,6 +103,11 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent); }
 
 .error-text { color: var(--danger); font-size: 13px; }
 
+/* Изменение рейтинга за партию в истории профиля */
+.rating-delta { color: var(--text-muted); margin-top: 6px; }
+.rating-up { color: var(--success); }
+.rating-down { color: var(--danger); }
+
 /* Формула в справке */
 .formula {
   font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
@@ -371,6 +376,30 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent); }
   padding: 7px 10px;
   border-radius: 8px;
 }
+/* Строка под игроком: комментарий + цели и миры на конец партии */
+.rank-details { display: flex; gap: 6px; align-items: flex-end; }
+.rank-details .rank-comment { flex: 1; min-width: 0; }
+.rank-count { flex: 0 0 58px; margin-top: 8px; }
+.rank-count span { display: block; font-size: 10px; color: var(--text-muted); text-align: center; }
+.rank-count input {
+  width: 100%;
+  font-size: 13px;
+  padding: 7px 4px;
+  border-radius: 8px;
+  text-align: center;
+}
+
+/* Предупреждения о несогласованном вводе (не блокируют отправку) */
+.warn-list {
+  margin: 10px 0 0;
+  padding: 8px 10px 8px 26px;
+  border: 1px solid var(--accent-2);
+  border-radius: var(--radius-sm);
+  background: rgba(240, 160, 75, 0.08);
+  color: var(--accent-2);
+  font-size: 13px;
+}
+.warn-list li + li { margin-top: 4px; }
 .rank-unlink {
   flex: none;
   width: 30px; height: 30px;
@@ -458,3 +487,93 @@ input:focus, select:focus, textarea:focus { border-color: var(--accent); }
 .toast-top-error { border-left-color: var(--danger); }
 .toast-top-title { font-weight: 700; }
 .toast-top-body { margin-top: 2px; font-size: 13px; color: var(--text-muted); }
+
+/* ─── Объявления администрации (#84) ─── */
+
+/* Окно (вариант E): заголовок — в плашке-шапке на всю ширину модалки. */
+.ann-modal { max-height: calc(100dvh - 48px); overflow-y: auto; }
+.ann-ribbon {
+  margin: -18px -18px 14px;
+  padding: 12px 18px;
+  background: var(--surface-2);
+  border-bottom: 1px solid var(--border);
+  border-radius: var(--radius) var(--radius) 0 0;
+}
+.ann-ribbon-title { font-weight: 700; font-size: 16px; line-height: 1.3; overflow-wrap: anywhere; }
+/* Пометка повторного показа — мелкой строкой под заголовком, красным. */
+.ann-updated { margin-top: 2px; font-size: 12px; color: var(--danger); }
+.ann-actions { margin-top: 16px; justify-content: space-between; align-items: center; }
+.ann-dots { display: flex; gap: 6px; align-items: center; }
+.ann-dots i { display: block; width: 6px; height: 6px; border-radius: 50%; background: var(--border); }
+.ann-dots i.on { background: var(--accent-2); }
+
+/* Текст объявления — и в окне, и в редакторе админки (там он выглядит так же). */
+.ann-body { font-size: 14px; line-height: 1.5; color: var(--text); overflow-wrap: anywhere; }
+.ann-body p { margin: 0; }
+.ann-body p + p { margin-top: 10px; }
+/* Акценты: золотой — цвет ссылок и бейджа «идёт», красный — для предупреждений. */
+.ann-body mark { background: none; color: var(--accent-2); font-weight: 600; }
+.ann-body mark.red { color: var(--danger); }
+
+/* Редактор (вариант R1) */
+.rte-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+  padding: 8px;
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  border-bottom: none;
+  border-radius: var(--radius-sm) var(--radius-sm) 0 0;
+}
+.rte-tool {
+  min-width: 32px;
+  height: 32px;
+  padding: 0 8px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--surface);
+  color: var(--text);
+  font-size: 14px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+.rte-tool:hover { border-color: var(--accent-2); }
+.rte-gold { color: var(--accent-2); font-weight: 700; }
+.rte-red { color: var(--danger); font-weight: 700; }
+.rte-sep { width: 1px; height: 22px; background: var(--border); }
+.rte-editor {
+  min-height: 130px;
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  border-radius: 0 0 var(--radius-sm) var(--radius-sm);
+  padding: 10px 12px;
+  outline: none;
+}
+.rte-editor:focus { border-color: var(--accent); }
+.rte-editor:empty::before { content: attr(data-placeholder); color: var(--text-muted); }
+.rte-emoji {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 6px;
+  padding: 8px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+}
+.rte-emoji button {
+  width: 34px;
+  height: 34px;
+  border: none;
+  background: none;
+  font-size: 18px;
+  border-radius: 8px;
+}
+.rte-emoji button:hover { background: var(--surface-2); }
+.rte-counter { font-size: 12px; color: var(--text-muted); margin-top: 4px; text-align: right; }
+.rte-counter.over { color: var(--danger); }
+/* Выделение текста в форме объявления — полупрозрачный --accent-2 вместо системного синего. */
+.ann-form ::selection { background: rgba(240, 160, 75, 0.35); }

frontend/src/styles/layout.css

@@ -115,7 +115,7 @@
 /* Таблица общей статистики (сортируемая, кликабельные строки) */
 .st-row, .st-head {
   display: grid;
-  grid-template-columns: 26px 1fr 40px 40px 48px 52px;
+  grid-template-columns: 26px 1fr 40px 48px 60px;
   align-items: center;
   gap: 8px;
   padding: 8px 2px;

run.ps1

@@ -1,11 +1,10 @@
 #!/usr/bin/env pwsh
-# Unified launcher for dev / test. APP_ENV in the root .env decides what to run.
+# Unified launcher for dev. APP_ENV in the root .env decides what to run.
 #   development -> uvicorn --reload (backend) + vite (frontend), native, two windows
-#   test        -> docker compose prod-clone (port 8080)
 #   production  -> NOT started by launcher (prod is separate: docker compose up -d on Pi)
 #
-# LOCAL_PUBLIC=vps (dev only) opens an SSH tunnel to the VPS, exposing dev at
-# https://forbidden-stars.ru. test/prod expose themselves via an in-container tunnel.
+# LOCAL_PUBLIC=vps opens an SSH tunnel to the VPS, exposing dev at
+# https://forbidden-stars.ru. Prod exposes itself via an in-container tunnel.
 #
 # Run:  .\run.ps1
 # If blocked by policy:  Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
@@ -129,42 +128,18 @@ switch ($appEnv) {
         if ($localPublic -eq "vps") {
             Start-VpsTunnel 5173
             Write-Host "  Public:   https://forbidden-stars.ru" -ForegroundColor Green
+            Write-Host "  WARNING: dev is public. Anyone can log in by nickname without a password," -ForegroundColor Yellow
+            Write-Host "  list/create players, hard-delete accounts and read Swagger." -ForegroundColor Yellow
+            Write-Host "  Do not keep a copy of production data in the dev database." -ForegroundColor Yellow
         }
     }
-    "test" {
-        $compose = Join-Path $root "docker-compose.test.yml"
-        docker info --format '{{.ServerVersion}}' *> $null
-        if ($LASTEXITCODE -ne 0) {
-            Write-Host "Docker daemon is not reachable. Start Docker Desktop, wait until it is running, then re-run .\run.ps1" -ForegroundColor Red
-            exit 1
-        }
-        $keyFile = Join-Path $root "deploy\tunnel\id_tunnel"
-        if (-not (Test-Path $keyFile -PathType Leaf)) {
-            if (Test-Path $keyFile -PathType Container) {
-                Write-Host "deploy\tunnel\id_tunnel is a DIRECTORY - Docker auto-created it because the key file was missing." -ForegroundColor Red
-                Write-Host "Remove it first:  Remove-Item -Recurse -Force deploy\tunnel\id_tunnel" -ForegroundColor Yellow
-            } else {
-                Write-Host "No SSH key at deploy\tunnel\id_tunnel (the tunnel container needs it)." -ForegroundColor Red
-            }
-            Write-Host "Add your VPS-authorized key:  Copy-Item `$env:USERPROFILE\.ssh\id_ed25519 deploy\tunnel\id_tunnel" -ForegroundColor Yellow
-            exit 1
-        }
-        Write-Host "Building and starting prod-clone in Docker (app + in-container tunnel)..." -ForegroundColor Green
-        docker compose -f $compose up --build -d
-        if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-        Write-Host ""
-        Write-Host "  Public: https://forbidden-stars.ru   (Swagger: /api/docs)" -ForegroundColor Green
-        Write-Host "  (no host port - reachable only via the domain; tunnel runs inside compose)"
-        Write-Host "  Logs:  docker compose -f docker-compose.test.yml logs -f"
-        Write-Host "  Stop:  docker compose -f docker-compose.test.yml down -v"
-    }
     "production" {
         Write-Host "production is not started by the launcher - prod is separate." -ForegroundColor Yellow
         Write-Host "Deploy on Pi (from main branch):  docker compose up -d --build"
         exit 1
     }
     default {
-        Write-Host "Unknown APP_ENV='$appEnv'. Allowed: development | test | production." -ForegroundColor Red
+        Write-Host "Unknown APP_ENV='$appEnv'. Allowed: development | production." -ForegroundColor Red
         exit 1
     }
 }

run.sh

@@ -1,13 +1,12 @@
 #!/usr/bin/env bash
 # ╔═══════════════════════════════════════════════════════════════════════════╗
-# ║  Единый лаунчер dev / test. Что запускать — решает APP_ENV из корневого .env ║
+# ║  Единый лаунчер dev. Что запускать — решает APP_ENV из корневого .env        ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 #   development → uvicorn --reload (бэк) + vite (фронт), нативно (Ctrl+C останавливает оба)
-#   test        → docker compose прод-клон (порт 8080)
 #   production  → лаунчером НЕ запускается (прод обособлен: docker compose up -d на Pi)
 #
-# LOCAL_PUBLIC=vps (только dev) поднимает SSH-туннель на VPS → https://forbidden-stars.ru
-# test/prod выставляют себя сами через туннель-контейнер (см. docker-compose*.yml).
+# LOCAL_PUBLIC=vps поднимает SSH-туннель на VPS → https://forbidden-stars.ru
+# Прод выставляет себя сам через туннель-контейнер (см. docker-compose.yml).
 #
 # Запуск:  ./run.sh   (при необходимости:  chmod +x run.sh)
 set -euo pipefail
@@ -76,25 +75,21 @@ case "$app_env" in
     trap 'kill "$back" 2>/dev/null || true' EXIT INT TERM
     echo "  Бэк:   http://127.0.0.1:8000   (Swagger: /api/docs)"
     echo "  Фронт: http://127.0.0.1:5173"
-    [ "$local_public" = "vps" ] && start_tunnel 5173
+    if [ "$local_public" = "vps" ]; then
+      start_tunnel 5173
+      echo "  ВНИМАНИЕ: dev опубликован. Любой посетитель может войти по нику без пароля,"
+      echo "  смотреть и создавать игроков, жёстко удалять аккаунты и читать Swagger."
+      echo "  Не держите в dev-базе копию прод-данных."
+    fi
     ( cd "$root/frontend" && npm run dev )
     ;;
-  test)
-    docker info >/dev/null 2>&1 || { echo "Docker-демон недоступен — запусти Docker и повтори ./run.sh"; exit 1; }
-    echo "Сборка и запуск прод-клона в Docker (app + туннель в контейнере)…"
-    docker compose -f "$root/docker-compose.test.yml" up --build -d
-    echo "  Публично: https://forbidden-stars.ru   (Swagger: /api/docs)"
-    echo "  (портов на хост нет — только через домен; туннель живёт внутри compose)"
-    echo "  Логи: docker compose -f docker-compose.test.yml logs -f"
-    echo "  Стоп: docker compose -f docker-compose.test.yml down -v"
-    ;;
   production)
     echo "production лаунчером не запускается — прод обособлен."
     echo "Деплой на Pi (из ветки main):  docker compose up -d --build"
     exit 1
     ;;
   *)
-    echo "Неизвестный APP_ENV='$app_env'. Допустимо: development | test | production."
+    echo "Неизвестный APP_ENV='$app_env'. Допустимо: development | production."
     exit 1
     ;;
 esac

scripts/export-prod.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Выгрузка ПРОДА: в целевую папку попадают только файлы, нужные для запуска
-# прод-контейнера (без тестов, dev-входа и тест-специфики).
+# прод-контейнера (без тестов, dev-входа и dev-лаунчера).
 #
 # Использование:  scripts/export-prod.sh <целевая-папка> [git-ref]
 #   git-ref по умолчанию HEAD; для прод-ветки:  scripts/export-prod.sh /srv/fs prod
@@ -13,8 +13,8 @@ mkdir -p "$DEST"
 # git archive уважает export-ignore из .gitattributes (тесты, dev-вход и т.п. отсеяны)
 git archive --format=tar "$REF" | tar -x -C "$DEST"
 
-# тест/dev-специфика в проде не нужна (тест-compose и лаунчер)
-rm -f "$DEST/docker-compose.test.yml" "$DEST/run.ps1" "$DEST/run.sh"
+# dev-специфика в проде не нужна (лаунчер)
+rm -f "$DEST/run.ps1" "$DEST/run.sh"
 
 echo "[export-prod] Прод выгружен в: $DEST"
 echo "  дальше:  cp .env.example .env  &&  docker compose up -d --build"

scripts/export-test.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-# Выгрузка ТЕСТА (прод-клон для локального контейнера на x86): в целевую папку
-# попадают только файлы, нужные для запуска тест-контейнера.
-#
-# Использование:  scripts/export-test.sh <целевая-папка> [git-ref]
-set -euo pipefail
-
-DEST="${1:?Укажите целевую папку: scripts/export-test.sh <dir> [ref]}"
-REF="${2:-HEAD}"
-
-mkdir -p "$DEST"
-git archive --format=tar "$REF" | tar -x -C "$DEST"
-
-# прод-compose в тест-папке не нужен (тест запускается своим docker-compose.test.yml)
-rm -f "$DEST/docker-compose.yml"
-
-echo "[export-test] Тест выгружен в: $DEST"
-echo "  дальше:  cp .env.example .env  (APP_ENV=test)  &&  docker compose -f docker-compose.test.yml up -d --build"

scripts/fs-backup.ps1

@@ -1,6 +1,5 @@
 # Forbidden Stars backups from the PC. Talks to the `backup` container of the prod on the Pi
-# over SSH, or (with -Target test) to the local test clone (docker-compose.test.yml).
-# Step-by-step guide: deploy/backup/README.md
+# over SSH. Step-by-step guide: deploy/backup/README.md
 #
 #   .\scripts\fs-backup.ps1 status                    backup state on the Pi
 #   .\scripts\fs-backup.ps1 list [-Repo vps]          snapshot history
@@ -8,9 +7,6 @@
 #   .\scripts\fs-backup.ps1 verify                    check data integrity in the repositories
 #   .\scripts\fs-backup.ps1 pull [-Snapshot <id>] [-Repo vps]
 #                                                     download a snapshot to backups\ (sha256 checked)
-#   .\scripts\fs-backup.ps1 restore-test -File backups\fs_....tar
-#                                                     practice restore into the local test clone
-#   add -Target test to run status/list/now/verify/pull against the local test clone
 #
 # Settings come from the root .env (an environment variable with the same name wins):
 #   BACKUP_PI_SSH   how to reach the Pi over SSH, e.g. pi@192.168.1.10 (or a Host alias)
@@ -19,15 +15,12 @@
 # Keep this file ASCII-only: Windows PowerShell 5.1 breaks on non-ASCII without a BOM.
 param(
     [Parameter(Position = 0)]
-    [ValidateSet("status", "list", "now", "verify", "pull", "restore-test", "help")]
+    [ValidateSet("status", "list", "now", "verify", "pull", "help")]
     [string]$Command = "help",
     [string]$Snapshot = "latest",
     [ValidateSet("local", "vps")]
     [string]$Repo = "local",
-    [string]$Tag = "",
-    [string]$File = "",
-    [ValidateSet("pi", "test")]
-    [string]$Target = "pi"
+    [string]$Tag = ""
 )
 $ErrorActionPreference = "Stop"
 # Native tools (ssh, scp, docker) write progress and warnings to stderr. Under "Stop" with a
@@ -35,7 +28,6 @@ $ErrorActionPreference = "Stop"
 # run under "Continue" and success is judged by $LASTEXITCODE only.
 $root = Split-Path -Parent $PSScriptRoot
 $envFile = Join-Path $root ".env"
-$testCompose = Join-Path $root "docker-compose.test.yml"
 
 # Read a key: environment variable first, then the root .env (last assignment wins).
 function Get-Setting([string]$name, [string]$default) {
@@ -56,7 +48,7 @@ function Fail([string]$msg) {
 }
 
 function Show-Help {
-    Get-Content $PSCommandPath -TotalCount 19 | ForEach-Object { $_ -replace '^# ?', '' }
+    Get-Content $PSCommandPath -TotalCount 15 | ForEach-Object { $_ -replace '^# ?', '' }
 }
 
 $piSsh = Get-Setting "BACKUP_PI_SSH" ""
@@ -77,29 +69,9 @@ function Invoke-Scp([string]$from, [string]$to) {
     & scp -o ConnectTimeout=15 $from $to
 }
 
-function Invoke-TestCompose([string[]]$composeArgs) {
-    $ErrorActionPreference = "Continue"
-    & docker compose -f $testCompose @composeArgs
-}
-
-# Make sure the backup container of the test clone is running (build it if needed).
-function Start-TestBackup {
-    $id = (Invoke-TestCompose @("ps", "-q", "backup")) | Select-Object -First 1
-    if (-not $id) {
-        Write-Host "Starting the backup container of the test clone..." -ForegroundColor Cyan
-        Invoke-TestCompose @("up", "-d", "--build", "backup") | Out-Host
-        if ($LASTEXITCODE -ne 0) { Fail "Could not start the test clone backup container." }
-    }
-}
-
-# Run fs-backup with arguments on the chosen target; output goes to the console.
+# Run fs-backup with arguments on the Pi; output goes to the console.
 function Invoke-FsBackup([string[]]$fsArgs) {
-    if ($Target -eq "test") {
-        Start-TestBackup
-        Invoke-TestCompose (@("exec", "-T", "backup", "fs-backup") + $fsArgs)
-    } else {
-        Invoke-Pi ("docker compose exec -T backup fs-backup " + ($fsArgs -join " "))
-    }
+    Invoke-Pi ("docker compose exec -T backup fs-backup " + ($fsArgs -join " "))
 }
 
 function Assert-LastExit([string]$what) {
@@ -126,31 +98,17 @@ function Invoke-Pull {
     Write-Host "Snapshot $id ($Repo) -> $local" -ForegroundColor Cyan
 
     $partial = "$local.part"
-    if ($Target -eq "test") {
-        Start-TestBackup
-        $tmp = "/tmp/fs-backup/export-$id.tar"
-        $hashLine = Invoke-TestCompose @("exec", "-T", "backup", "sh", "-c",
-            "fs-backup export $id --repo $Repo > $tmp && sha256sum $tmp") | Select-Object -Last 1
-        Assert-LastExit "Export"
-        try {
-            Invoke-TestCompose @("cp", "backup:$tmp", $partial)
-            Assert-LastExit "Copy from the container"
-        } finally {
-            Invoke-TestCompose @("exec", "-T", "backup", "rm", "-f", $tmp) | Out-Null
-        }
-    } else {
-        # Export into a file in the Pi user's home (binary data never passes through
-        # PowerShell pipes - they would corrupt it), then scp it and compare sha256.
-        $remote = "fs-export-$id.tar"
-        $hashLine = Invoke-Pi "docker compose exec -T backup fs-backup export $id --repo $Repo > ~/$remote && sha256sum ~/$remote" |
-            Select-Object -Last 1
-        Assert-LastExit "Export on the Pi"
-        try {
-            Invoke-Scp "${piSsh}:$remote" $partial
-            Assert-LastExit "scp"
-        } finally {
-            Invoke-Pi "rm -f ~/$remote"
-        }
+    # Export into a file in the Pi user's home (binary data never passes through
+    # PowerShell pipes - they would corrupt it), then scp it and compare sha256.
+    $remote = "fs-export-$id.tar"
+    $hashLine = Invoke-Pi "docker compose exec -T backup fs-backup export $id --repo $Repo > ~/$remote && sha256sum ~/$remote" |
+        Select-Object -Last 1
+    Assert-LastExit "Export on the Pi"
+    try {
+        Invoke-Scp "${piSsh}:$remote" $partial
+        Assert-LastExit "scp"
+    } finally {
+        Invoke-Pi "rm -f ~/$remote"
     }
 
     $expected = ("$hashLine".Trim() -split "\s+")[0].ToLower()
@@ -172,34 +130,6 @@ function Invoke-Pull {
     Write-Host "OK: $local ($sizeMb MB, $files files, sha256 verified)" -ForegroundColor Green
 }
 
-# -------------------------------------------------------------------- restore-test
-function Invoke-RestoreTest {
-    if (-not $File) { Fail "Specify the archive: -File backups\fs_....tar" }
-    if (-not (Test-Path $File -PathType Leaf)) { Fail "File not found: $File" }
-    $full = (Resolve-Path $File).Path
-    $inContainer = "/import/restore-test.archive"   # tar or tar.gz: fs-backup detects the format itself
-
-    Write-Host "Practice restore of $full into the LOCAL TEST CLONE (prod is not touched)." -ForegroundColor Cyan
-    Start-TestBackup
-    Invoke-TestCompose @("stop", "app")
-    Assert-LastExit "Stopping the test app"
-    Invoke-TestCompose @("cp", $full, "backup:$inContainer")
-    Assert-LastExit "Copy into the container"
-    try {
-        Invoke-TestCompose @("exec", "-T", "backup", "fs-backup", "import", $inContainer, "--yes")
-        $importExit = $LASTEXITCODE
-    } finally {
-        Invoke-TestCompose @("exec", "-T", "backup", "rm", "-f", $inContainer) | Out-Null
-    }
-    if ($importExit -ne 0) { Fail "Import failed (exit code $importExit). The test clone data was not changed." }
-
-    Invoke-TestCompose @("up", "-d", "app")
-    Assert-LastExit "Starting the test app"
-    Write-Host "Done. The test clone now runs on the restored data." -ForegroundColor Green
-    Write-Host "  See it on https://forbidden-stars.ru:  docker compose -f docker-compose.test.yml up -d   (or .\run.ps1 with APP_ENV=test)"
-    Write-Host "  Logs:  docker compose -f docker-compose.test.yml logs -f app"
-}
-
 # ---------------------------------------------------------------------------- main
 $prevEncoding = $null
 try {
@@ -218,7 +148,6 @@ try {
         }
         "verify" { Invoke-FsBackup @("verify"); Assert-LastExit "verify" }
         "pull" { Invoke-Pull }
-        "restore-test" { Invoke-RestoreTest }
         default { Show-Help }
     }
 } finally {

scripts/fs-backup.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Бэкапы Forbidden Stars с ПК (Linux / macOS / Git Bash). Команды уходят в контейнер backup
-# прода на Pi по SSH или (с --test) в локальный тест-клон (docker-compose.test.yml).
-# На Windows удобнее scripts/fs-backup.ps1 — поведение то же. Инструкция: deploy/backup/README.md
+# прода на Pi по SSH. На Windows удобнее scripts/fs-backup.ps1 — поведение то же.
+# Инструкция: deploy/backup/README.md
 #
 #   scripts/fs-backup.sh status                       состояние бэкапов на Pi
 #   scripts/fs-backup.sh list [vps]                   хронология снимков
@@ -9,9 +9,6 @@
 #   scripts/fs-backup.sh verify                       проверить целостность данных
 #   scripts/fs-backup.sh pull [<id>|latest] [--repo vps]
 #                                                     скачать снимок в backups/ (сверка sha256)
-#   scripts/fs-backup.sh restore-test <файл.tar|.tar.gz>
-#                                                     учебное восстановление в локальный тест-клон
-#   --test первым аргументом — status/list/now/verify/pull для локального тест-клона
 #
 # Настройки — из корневого .env (переменная окружения с тем же именем важнее):
 #   BACKUP_PI_SSH  как зайти на Pi по SSH, например pi@192.168.1.10 (или Host из ~/.ssh/config)
@@ -19,8 +16,6 @@
 set -euo pipefail
 
 PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-TEST_COMPOSE="$PROJECT_DIR/docker-compose.test.yml"
-export MSYS_NO_PATHCONV=1   # Git Bash: не переписывать /import/... в аргументах docker
 
 die() { echo "ОШИБКА: $*" >&2; exit 1; }
 
@@ -35,10 +30,7 @@ setting() {  # setting <ключ> <по умолчанию>: окружение,
 PI_SSH="$(setting BACKUP_PI_SSH "")"
 # shellcheck disable=SC2088  # тильда намеренно не раскрывается здесь — её раскроет shell на Pi
 PI_DIR="$(setting BACKUP_PI_DIR "~/forbidden-stars")"
-TARGET="pi"
-if [ "${1:-}" = "--test" ]; then TARGET="test"; shift; fi
 
-native_path() { if command -v cygpath >/dev/null 2>&1; then cygpath -w "$1"; else printf '%s' "$1"; fi; }
 sha256() { if command -v sha256sum >/dev/null 2>&1; then sha256sum "$1" | cut -d' ' -f1; else shasum -a 256 "$1" | cut -d' ' -f1; fi; }
 
 pi() {  # pi <shell-команда>: выполнить на Pi в папке прода
@@ -46,22 +38,8 @@ pi() {  # pi <shell-команда>: выполнить на Pi в папке п
   ssh -o ConnectTimeout=15 "$PI_SSH" "cd $PI_DIR && $1"
 }
 
-tc() { docker compose -f "$(native_path "$TEST_COMPOSE")" "$@"; }
-
-start_test_backup() {
-  if [ -z "$(tc ps -q backup 2>/dev/null)" ]; then
-    echo "Запускаю контейнер backup тест-клона…"
-    tc up -d --build backup
-  fi
-}
-
-fs() {  # fs <аргументы fs-backup…>
-  if [ "$TARGET" = test ]; then
-    start_test_backup
-    tc exec -T backup fs-backup "$@"
-  else
-    pi "docker compose exec -T backup fs-backup $*"
-  fi
+fs() {  # fs <аргументы fs-backup…>: выполнить fs-backup в контейнере backup на Pi
+  pi "docker compose exec -T backup fs-backup $*"
 }
 
 cmd_pull() {
@@ -84,18 +62,10 @@ cmd_pull() {
   partial="$local_file.part"
   echo "Снимок $id ($repo) -> $local_file"
 
-  if [ "$TARGET" = test ]; then
-    start_test_backup
-    local tmp="/tmp/fs-backup/export-$id.tar"
-    expected="$(tc exec -T backup sh -c "fs-backup export $id --repo $repo > $tmp && sha256sum $tmp" | tail -n 1 | cut -d' ' -f1)"
-    tc cp "backup:$tmp" "$(native_path "$partial")" || { tc exec -T backup rm -f "$tmp"; die "копирование из контейнера не удалось"; }
-    tc exec -T backup rm -f "$tmp"
-  else
-    local remote="fs-export-$id.tar"
-    expected="$(pi "docker compose exec -T backup fs-backup export $id --repo $repo > ~/$remote && sha256sum ~/$remote" | tail -n 1 | cut -d' ' -f1)"
-    scp -o ConnectTimeout=15 "$PI_SSH:$remote" "$partial" || { pi "rm -f ~/$remote"; die "scp не удался"; }
-    pi "rm -f ~/$remote"
-  fi
+  local remote="fs-export-$id.tar"
+  expected="$(pi "docker compose exec -T backup fs-backup export $id --repo $repo > ~/$remote && sha256sum ~/$remote" | tail -n 1 | cut -d' ' -f1)"
+  scp -o ConnectTimeout=15 "$PI_SSH:$remote" "$partial" || { pi "rm -f ~/$remote"; die "scp не удался"; }
+  pi "rm -f ~/$remote"
 
   actual="$(sha256 "$partial")"
   if [ "$expected" != "$actual" ]; then
@@ -107,24 +77,6 @@ cmd_pull() {
   echo "OK: $local_file ($(du -h "$local_file" | cut -f1), $(tar -tf "$local_file" | grep -vc '/$') файлов, sha256 сверена)"
 }
 
-cmd_restore_test() {
-  local file="${1:-}"
-  [ -n "$file" ] || die "укажите архив: scripts/fs-backup.sh restore-test backups/fs_....tar"
-  [ -f "$file" ] || die "файл не найден: $file"
-  local in_container=/import/restore-test.archive   # tar или tar.gz — формат fs-backup определит сам
-  echo "Учебное восстановление $file в ЛОКАЛЬНЫЙ ТЕСТ-КЛОН (прод не затрагивается)."
-  start_test_backup
-  tc stop app
-  tc cp "$(native_path "$file")" "backup:$in_container"
-  local rc=0
-  tc exec -T backup fs-backup import "$in_container" --yes || rc=$?
-  tc exec -T backup rm -f "$in_container"
-  [ "$rc" -eq 0 ] || die "импорт не удался (код $rc) — данные тест-клона не изменены."
-  tc up -d app
-  echo "Готово: тест-клон работает на восстановленных данных."
-  echo "  На https://forbidden-stars.ru:  docker compose -f docker-compose.test.yml up -d   (или ./run.sh при APP_ENV=test)"
-}
-
 cmd="${1:-help}"
 [ $# -eq 0 ] || shift
 case "$cmd" in
@@ -133,6 +85,5 @@ case "$cmd" in
   now) fs run "$@" ;;
   verify) fs verify ;;
   pull) cmd_pull "$@" ;;
-  restore-test) cmd_restore_test "$@" ;;
-  *) sed -n '2,19p' "$0" | sed 's/^# \{0,1\}//' ;;
+  *) sed -n '2,15p' "$0" | sed 's/^# \{0,1\}//' ;;
 esac