release: версия 0.0.18

Два бага в одном месте, оба вскрылись на нагрузочном тесте 31.07.2026.

1. Ключ лимита строился по `request.client.host`. Backend стоит за nginx,
   поэтому это адрес КОНТЕЙНЕРА NGINX, одинаковый для всех пользователей.
   Проверено на проде: в Redis лежал единственный ключ
   `rate_limit:resolve:172.18.0.13`. То есть лимит «10 запросов в минуту»
   действовал на весь инстанс разом, а не на клиента.

2. Считались все запросы подряд, включая успешные. Одиннадцатый человек,
   открывший ссылку на конференцию в течение минуты, получал 429 — и видел
   «Не удалось найти конференцию» для существующей и активной конференции.
   Люди попадали внутрь с пятой-десятой попытки, попадая в новое окно.

Что изменилось:
- адрес клиента берётся из `X-Real-IP` (nginx его уже передаёт). Именно
  `X-Real-IP`, а не первый элемент `X-Forwarded-For`: последний заполняется
  через `$proxy_add_x_forwarded_for`, то есть дописывается к присланному
  клиентом, и лимит обходился бы одним заголовком;
- жёсткий счётчик (10/мин, как было) теперь считает только ПРОМАХИ:
  конференция не найдена или пароль неверен. Именно так выглядит перебор
  номера, от которого лимит и защищает по ADR-001, п.4;
- на общий поток с адреса оставлен мягкий потолок 300/мин — против тупого
  флуда. Офис за общим NAT это один адрес, поэтому потолок заведомо выше
  правдоподобного числа участников одной конференции.

Тесты: успешные резолвы и гостевые входы не упираются в лимит (50 и 30
подряд); перебор номера, несуществующий идентификатор и подбор пароля
по-прежнему упираются; лимит одного клиента не задевает другого.

.env.example

@@ -81,6 +81,20 @@ LIVEKIT_NODE_IP=127.0.0.1
 # с точкой монтирования тома в обоих сервисах.
 RECORDINGS_DIR=/recordings
 
+# --- Производительность backend ---
+# Число процессов uvicorn. Один процесс означает, что любой блокирующий вызов
+# в обработчике останавливает весь event loop: параллельные входы в конференцию
+# и WS-чат всех участников встают в очередь. Дефолт 2 рассчитан на 4-ядерный
+# сервер, где ядра делятся с LiveKit (медиа важнее API).
+UVICORN_WORKERS=2
+# Пул соединений с БД НА КАЖДЫЙ воркер. Общий расход инстанса —
+# UVICORN_WORKERS × (DB_POOL_SIZE + DB_MAX_OVERFLOW), плюс соединения Celery
+# и alembic. Держите сумму заметно ниже max_connections у Postgres (по
+# умолчанию 100), иначе вместо понятной ошибки приложения получите отказ БД.
+DB_POOL_SIZE=10
+DB_MAX_OVERFLOW=10
+DB_POOL_TIMEOUT=10
+
 # --- Email (рассылка саммари + .ics-приглашения) ---
 # `console` — дефолт для dev (письмо только логируется, ссылка подтверждения
 # email берётся из логов); `smtp` — реальная отправка через aiosmtplib.
@@ -98,7 +112,7 @@ SMTP_TIMEOUT_S=30
 # --- Версия инстанса (релиз v0.0.1) ---
 # install.sh копирует значение из корневого файла VERSION при каждой
 # установке/обновлении — руками менять не нужно.
-VIDCONF_VERSION=0.0.10
+VIDCONF_VERSION=0.0.18
 
 # --- Профили compose. Дефолт ниже (`media,monitoring`) — только для ручного
 # `docker compose up` БЕЗ install.sh: медиа (LiveKit+coturn) + мониторинг,

CHANGELOG.md

@@ -3,6 +3,223 @@
 Формат основан на [Keep a Changelog](https://keepachangelog.com/ru/1.1.0/),
 проект придерживается [семантического версионирования](https://semver.org/lang/ru/).
 
+## [0.0.18] — 2026-08-01
+
+Ограничение частоты запросов больше не блокирует вход целой конференции.
+
+### Исправлено
+- Лимит на резолв конференции и гостевой вход считался по адресу контейнера
+  nginx, а не клиента, — то есть «10 запросов в минуту» действовали на весь
+  сервер разом. Одиннадцатый человек, открывший ссылку в течение минуты,
+  получал отказ и видел «Не удалось найти конференцию» для существующей и
+  активной конференции. Теперь адрес берётся из заголовка, который nginx уже
+  передаёт.
+- Счётчик считает только неудачные попытки — конференция не найдена или
+  пароль неверен. Именно так выглядит перебор номера, от которого защищает
+  ограничение; массовый вход по рабочей ссылке к нему отношения не имеет.
+  На общий поток с адреса оставлен потолок в 300 запросов в минуту.
+
+## [0.0.17] — 2026-08-01
+
+Массовый вход в систему и в конференцию перестаёт упираться в проверку пароля.
+
+### Исправлено
+- Проверка пароля больше не останавливает весь backend. Хэширование argon2 —
+  это десятки миллисекунд счёта, и выполнялось оно синхронно внутри
+  асинхронного обработчика: пока считался один пароль, процесс не обслуживал
+  ничего другого. На нагрузочном тесте 31.07 с примерно семью десятками
+  одновременных входов это дало p95 логина 7.28 секунды, p95 входа в
+  конференцию 7.06 секунды и 33 соединения к базе, висящих в открытой
+  транзакции при одном активном запросе. Страдали и посторонние запросы —
+  вход в конференцию отказывал, хотя пароль там не проверялся вовсе.
+  Теперь хэширование считается в пуле потоков.
+- Параметры argon2id приведены к рекомендации OWASP (t=2, m=19 МБ, p=1)
+  вместо дефолтов библиотеки (t=3, m=64 МБ, p=4): 95 мс против 42 мс на
+  проверку. Прежнее значение `parallelism=4` вдобавок занимало все четыре
+  ядра сервера — те же, на которых работает медиа-сервер.
+- Пароли, сохранённые со старыми параметрами, продолжают работать и
+  перевыпускаются автоматически при первом успешном входе.
+
+## [0.0.16] — 2026-08-01
+
+Роль организатора в комнате: поднятие руки с очередью и принудительный мьют.
+
+### Добавлено
+- Роль организатора прокинута в комнату — метаданные LiveKit-токена несут
+  подсказку `is_organizer` для UI (владелец конференции/администратор);
+  любое серверное действие организатора перепроверяется по владельцу
+  конференции в БД, метаданным токена для авторизации не доверяем.
+- Поднятие руки: кнопка «Рука» в тулбаре (у всех участников, с общим
+  счётчиком), бейдж на плитке говорящего, видимый всем, и панель «Очередь»
+  для организатора — участники в порядке поднятия руки, с возможностью
+  опустить любую руку. Состояние — в Redis (не в БД): очередь существует
+  ровно во время звонка. Участник, вышедший из конференции, автоматически
+  исчезает из очереди; переподключение место не теряет.
+- Принудительный мьют: организатор может выключить микрофон или камеру
+  любого участника — кнопки на его плитке. Участник получает уведомление,
+  что его выключил организатор, и может включить себя обратно сразу тем же
+  тулбаром.
+- Эмодзи скачущего коня 🐎 в наборе смайликов чата.
+
+### Изменено
+- Транспорт чата (`WS /conferences/{id}/chat`) расширен: очередь поднятых
+  рук и уведомления о мьюте едут по тому же аутентифицированному
+  соединению, что и сообщения чата — без нового эндпоинта.
+
+Миграций БД нет — новое состояние (очередь поднятых рук) хранится в Redis,
+не в Postgres.
+
+## [0.0.15] — 2026-07-30
+
+Шесть доработок UI комнаты конференции.
+
+### Добавлено
+- Выбор эмодзи в чате — поповер с небольшим собственным набором популярных
+  эмодзи (без библиотеки-пикера), вставка в позицию курсора.
+- Кнопка микрофона в мини-окне (Document PiP) — раньше в PiP не было
+  никакого способа замьютить себя, не разворачивая основное окно.
+- Закрепление участника доступно из любого режима показа («Стандарт»,
+  «Плитки», «Живые плитки») — раньше булавка рендерилась только в
+  «Стандарте». Само закрепление автоматически переключает вид на «Стандарт»
+  (закреплённого иначе негде показать крупно); открепление вид назад не
+  меняет.
+
+### Изменено
+- Участник заходит в конференцию с выключенными микрофоном и камерой,
+  включает их сам уже в комнате.
+- В топбаре комнаты вместо технического `room_name` LiveKit (вида
+  `hC-Dmos9KEM`) показывается название конференции; при его отсутствии —
+  «Конференция без названия». Номер и ссылка-приглашение не задеты.
+
+## [0.0.14] — 2026-07-28
+
+TURN-фолбэк для участников из сетей с жёстким NAT.
+
+### Исправлено
+- LiveKit теперь анонсирует клиентам внешний TURN-сервер (`rtc.turn_servers`
+  в конфигурации, UDP и TCP на 3478). Раньше coturn поднимался и был healthy,
+  но клиенты о нём не знали: внешний TURN в конфиге объявлен не был, встроенный
+  выключен, а фронтенд `iceServers` не задаёт. За всё время работы в логах
+  coturn не было ни одной аллокации — то есть relay не использовался никогда,
+  и участники из сетей, где прямое UDP-соединение не проходит, теряли связь
+  (`PEER_CONNECTION_DISCONNECTED`). На нагрузочном тесте 28.07 все такие
+  разрывы пришлись на внешних участников и ни одного — на офисных.
+- Credentials TURN генерируются по механизму TURN REST API из общего
+  `TURN_STATIC_AUTH_SECRET`, то есть тот же секрет, что и у coturn.
+
+### Изменено
+- `deploy/render-templates.sh` подставляет `TURN_EXTERNAL_IP` и
+  `TURN_STATIC_AUTH_SECRET` также в конфигурацию LiveKit.
+- Раздел 8 руководства по развёртыванию переписан: TURN больше не «план на
+  будущее», а рабочая конфигурация. Отдельно описано правило ufw для
+  relay-диапазона `49160:49200/udp` — без него TURN отвечает на запросы, но
+  релей не работает, причём в логах coturn при этом тишина.
+
+TURN over TLS (5349/443) по-прежнему не настроен: требует монтирования
+сертификата в coturn. Неработающий `turns:` намеренно не анонсируется, иначе
+клиент ждал бы таймаута перед переходом к рабочему кандидату.
+
+## [0.0.13] — 2026-07-28
+
+Снижение нагрузки на сеть: клиент перестаёт получать полное качество всех
+чужих камер независимо от того, какого размера плитка на экране.
+
+### Изменено
+- Включены `adaptiveStream` и `dynacast` в опциях комнаты. Оба флага в LiveKit
+  выключены по умолчанию, из-за чего каждый участник был подписан на полное
+  качество всех чужих треков, а каждый паблишер слал все слои симулкаста, даже
+  когда их никто не смотрит. Теперь качество подписки выбирается по фактическому
+  размеру плитки, а неотрисованные треки уходят в паузу. На локальном стенде
+  (9 участников, паблишеры 720p) входящий поток одного клиента упал с
+  11 110 до 778 кбит/с.
+
+  Вместе с этим начинает экономить уже написанный код, который до сих пор не
+  давал выигрыша: «скрыть остальных» не рендерит карусель (исходящий трафик
+  LiveKit 0.76 → 0.03 Мбит/с), пагинация сетки участников рендерит только
+  текущую страницу, а пауза чужого видео в свёрнутой вкладке работает лишь
+  при включённом `adaptiveStream`.
+- Контейнеры больше не пересобирают окружение Python при запуске: во все
+  вызовы `uv run` в прод-путях (CMD образа, `command`/`entrypoint`/`healthcheck`
+  сервисов, миграции и seed в `install.sh`) добавлен `--no-sync`. Раньше
+  окружение, собранное на этапе build с `--no-dev`, при каждом старте
+  синхронизировалось заново и подтягивало dev-группу: ~26 МБ загрузок,
+  замедленный старт и ruff/mypy/pytest в рантайме. Healthcheck'и делали то же
+  самое каждые 15 секунд всю жизнь контейнера. Размер `/app/.venv` после
+  запуска: 574 → 456 МБ. Локальная разработка не затронута — там dev-группа
+  нужна и ставится как раньше.
+
+## [0.0.12] — 2026-07-28
+
+Разблокировка backend под нагрузкой: вход в конференцию перестаёт отваливаться,
+когда участники включают микрофоны.
+
+### Исправлено
+- Обработчик webhook `track_published` больше не запускает Track Egress внутри
+  своей транзакции. Раньше каждый опубликованный микрофон уходил в сетевой
+  вызов, а на инстансе без профиля `transcribe` (egress-сервиса в деплое нет)
+  этот вызов висел 20–25 секунд, всё это время удерживая соединение с БД. На
+  нагрузочном тесте с 19 участниками пул соединений выгребался за секунды, и
+  вход в конференцию начинал отвечать 500. Теперь запуск уходит в фоновую
+  задачу со своей сессией, а webhook отвечает сразу — LiveKit перестаёт копить
+  очередь доставки и терять события.
+- Track Egress не запускается вовсе, если транскрибация выключена в настройках
+  инстанса — тот же guard, что уже был в обработчике `room_finished`.
+- Запуск Track Egress ограничен таймаутом (по умолчанию 3 секунды) вместо
+  ожидания собственного таймаута LiveKit.
+
+### Изменено
+- Пул соединений с БД задаётся явно (`DB_POOL_SIZE`, `DB_MAX_OVERFLOW`,
+  `DB_POOL_TIMEOUT`) вместо дефолта SQLAlchemy 5 + 10. Считайте бюджет на весь
+  инстанс: каждый воркер держит свой пул, и сумма должна оставаться заметно
+  ниже `max_connections` у Postgres.
+- Backend запускается с несколькими процессами uvicorn (`UVICORN_WORKERS`,
+  по умолчанию 2). Одиночный процесс означал, что любой блокирующий вызов
+  останавливает и параллельные запросы, и WS-чат всех участников. Дефолт 2, а
+  не по числу ядер: на четырёхъядерном сервере ядра делятся с LiveKit.
+
+## [0.0.11] — 2026-07-28
+
+Выбор режима показа участников в конференции, скрытие остальных и круглая
+иконка участника при выключенной камере.
+
+### Добавлено
+- Выбор режима показа участников на сцене вместо автоматической раскладки:
+  «Стандарт» (крупная плитка плюс карусель остальных сбоку, как было),
+  «Плитки» (все участники равными плитками) и «Живые плитки» (плитками —
+  только те, у кого включена камера, остальные в карусели). Кто именно
+  показан крупно в «Стандарте», по-прежнему решает прежняя логика фокуса
+  (новая демонстрация → закреплённый → говорящий с видео → говорящий).
+  Выбор сохраняется между заходами в комнату.
+- Скрытие остальных участников — на сцене остаётся только основная плитка.
+  Скрыть можно из меню «Вид», из шторки настроек на мобильном и кнопкой над
+  колонкой миниатюр; вернуть — кнопкой «Показать остальных (N)», которая
+  видна всё время, пока кто-то скрыт. В режиме «Плитки» скрывать нечего,
+  переключатель там заблокирован.
+- Переключатель вида: кнопка «Вид» с поповером в тулбаре на широком экране;
+  на мобильном — секция «Вид» в шторке настроек, чтобы не добавлять шестую
+  кнопку в уже ужатый тулбар.
+
+### Изменено
+- Демонстрация экрана временно перебивает выбранный режим: пока идёт шэр,
+  сцена ведёт себя как «Стандарт», а по его завершении возвращается к
+  выбранному виду.
+- Равномерная сетка плиток стала пригодна для телефона: 2 колонки от 360px
+  ширины и портретная раскладка 2×3 вместо двух плиток на страницу, которые
+  давал набор раскладок библиотеки. Лишние участники уходят на следующую
+  страницу — листается свайпом и стрелками.
+
+### Исправлено
+- Иконка участника при выключенной камере больше не превращается в эллипс:
+  размер считается от узкой стороны плитки (container-запросы), а не как
+  проценты от разных сторон. В крупной плитке иконка занимает примерно её
+  половину, в миниатюрах карусели — всю узкую сторону с отступом 5px; на
+  большой плитке фокуса иконка больше не упирается в прежний потолок 96px.
+- Мини-плеер в Chrome открывался на самом пользователе вместо того, что он
+  видел крупно: сцена в PiP-окне — отдельный экземпляр компонента и выбирала
+  фокус с нуля, доходя до фолбэка «показать себя». Теперь ключ фокуса
+  переживает переезд в мини-окно и обратно. В Safari (video-фолбэк вместо
+  Document PiP) поведение не менялось.
+
 ## [0.0.10] — 2026-07-28
 
 Разбивка метрик по контейнерам в Grafana и плашка с характеристиками сервера.

VERSION

@@ -1 +1 @@
-0.0.10
+0.0.18

backend/Dockerfile

@@ -37,4 +37,20 @@ EXPOSE 8000
 HEALTHCHECK --interval=10s --timeout=5s --retries=10 --start-period=15s \
     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health')" || exit 1
 
-CMD ["uv", "run", "uvicorn", "main:create_app", "--factory", "--host", "0.0.0.0", "--port", "8000"]
+# Число воркеров — из окружения (`UVICORN_WORKERS`, см. docker-compose.yml).
+# Один процесс означает, что любой блокирующий вызов в обработчике
+# останавливает весь event loop: параллельные запросы и WS-чат всех
+# участников встают в очередь. Дефолт 2, а не «по числу ядер»: медиа
+# важнее API, и на 4-ядерном сервере LiveKit в пике забирает 1.6 ядра.
+#
+# `sh -c` нужен ради подстановки переменной (exec-форма её не делает),
+# `exec` — чтобы uvicorn получил PID 1 и корректно принимал SIGTERM.
+#
+# `--no-sync`: окружение уже собрано выше (`uv sync --frozen --no-dev`), и
+# пересобирать его в рантайме незачем. Без флага `uv run` перед каждым
+# запуском заново синхронизирует venv И ПОДТЯГИВАЕТ dev-группу (ruff, mypy,
+# pytest — ~30 МБ загрузок на каждый старт контейнера, dev-инструменты в
+# проде и раздутый venv). То же касается healthcheck'ов в
+# deploy/docker-compose.yml, которые дёргают `uv run` каждые 15 секунд.
+CMD ["sh", "-c", \
+     "exec uv run --no-sync uvicorn main:create_app --factory --host 0.0.0.0 --port 8000 --workers ${UVICORN_WORKERS:-2}"]

backend/api/admin.py

@@ -217,7 +217,7 @@ async def create_user(
     user = await repo.create(
         email=data.email,
         name_user=data.name_user,
-        password_hash=hash_password(data.password),
+        password_hash=await hash_password(data.password),
         team_id=data.team_id,
     )
     user.email_verified = True

backend/api/chat.py

@@ -1,10 +1,17 @@
-"""WS-роутер текстового чата конференции: `WS /api/v1/conferences/{id}/chat`.
+"""WS-роутер комнаты конференции: `WS /api/v1/conferences/{id}/chat`.
 
 Протокол: `connect` -> `accept()` -> клиент шлёт `{"type":"auth","token":...}`
 первым сообщением (таймаут 10 с; токен не query-параметр — не палим его в
 логах nginx) -> сервер проверяет тоггл `chat.enabled` и LiveKit-токен ->
-история последних 50 сообщений открытой сессии -> двунаправленный обмен
-`{"type":"message","text":...}` через Redis pub/sub (echo отправителю тоже).
+история последних 50 сообщений чата + текущая очередь поднятых рук ->
+двунаправленный обмен: `{"type":"message","text":...}` (чат, Redis pub/sub,
+echo отправителю тоже), `{"type":"raise_hand"}`/`{"type":"lower_hand"}`
+(очередь рук, задача B1 — состояние в Redis, см. `services/hand_queue.py`,
+НЕ в БД: это эфемерное состояние звонка, а не история). Название файла и
+эндпоинта («чат») оставлено как есть — эндпоинт исторически первый и
+единственный аутентифицированный WS комнаты, поэтому очередь рук едет по
+нему же, а не заводит отдельное соединение (дешевле: сервер уже держит
+это соединение на каждого участника).
 """
 
 import asyncio
@@ -13,7 +20,7 @@ import uuid
 from typing import Annotated
 
 from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
-from pydantic import ValidationError
+from pydantic import Field, TypeAdapter, ValidationError
 from redis.asyncio.client import PubSub
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -28,6 +35,8 @@ from schemas.chat import (
     ChatMessageIn,
     ChatMessageOut,
 )
+from schemas.room_events import LowerHandIn, RaiseHandIn
+from services import hand_queue
 from services.chat import ChatAuthError, ChatIdentity, ChatService, InvalidTokenError, chat_channel
 
 logger = logging.getLogger(__name__)
@@ -37,6 +46,14 @@ router = APIRouter(prefix="/api/v1/conferences", tags=["chat"])
 # Таймаут ожидания первого (auth) сообщения клиента.
 AUTH_TIMEOUT_SECONDS = 10.0
 
+# Дискриминированное объединение сообщений клиента ПОСЛЕ auth — по полю `type`.
+_ClientEnvelope = Annotated[
+    ChatMessageIn | RaiseHandIn | LowerHandIn, Field(discriminator="type")
+]
+_client_envelope_adapter: TypeAdapter[ChatMessageIn | RaiseHandIn | LowerHandIn] = TypeAdapter(
+    _ClientEnvelope
+)
+
 
 @router.websocket("/{conference_id}/chat")
 async def chat_websocket(
@@ -44,7 +61,7 @@ async def chat_websocket(
     conference_id: uuid.UUID,
     session: Annotated[AsyncSession, Depends(get_session)],
 ) -> None:
-    """WS-эндпоинт текстового чата конференции — единая аутентификация LiveKit-токеном."""
+    """WS-эндпоинт комнаты конференции — единая аутентификация LiveKit-токеном."""
     await websocket.accept()
     service = ChatService(session)
 
@@ -57,21 +74,26 @@ async def chat_websocket(
 
     pubsub = redis_client.pubsub()
     channel = chat_channel(conference.id)
-    # Подписка ДО чтения истории: сообщение,
-    # опубликованное другим клиентом в окне между SELECT истории и
-    # subscribe, иначе теряется для подключающегося клиента — Redis начинает
+    room_channel = hand_queue.hand_queue_channel(conference.id)
+    # Подписка ДО чтения истории/снапшота очереди: событие,
+    # опубликованное другим клиентом в окне между SELECT/HGETALL и subscribe,
+    # иначе теряется для подключающегося клиента — Redis начинает
     # буферизовать входящие publish для этого соединения сразу после
     # subscribe, до первого вызова `get_message`. На стыке возможен дубликат
-    # (то же сообщение и в history, и в первом pub/sub-сообщении) — безопаснее
-    # дедуплицировать по `id`, чем потерять сообщение.
-    await pubsub.subscribe(channel)
+    # (то же сообщение чата и в history, и в первом pub/sub-сообщении) —
+    # безопаснее дедуплицировать по `id`, чем потерять сообщение; снапшот
+    # очереди дублировать безвредно (полная замена состояния на клиенте).
+    await pubsub.subscribe(channel, room_channel)
     try:
         history = await service.history(conference)
         await websocket.send_json(ChatHistoryOut(messages=history).model_dump(mode="json"))
         seen_ids = {item.id for item in history}
 
+        queue_out = await hand_queue.get_snapshot_out(conference.id)
+        await websocket.send_json(queue_out.model_dump(mode="json"))
+
         async with asyncio.TaskGroup() as tg:
-            tg.create_task(_pump_pubsub_to_websocket(websocket, pubsub, seen_ids))
+            tg.create_task(_pump_pubsub_to_websocket(websocket, pubsub, channel, seen_ids))
             tg.create_task(_pump_websocket_to_service(websocket, service, conference, identity))
     except* WebSocketDisconnect:
         # Штатное закрытие соединения клиентом — не ошибка.
@@ -91,7 +113,7 @@ async def chat_websocket(
     finally:
         # Всегда отписываемся и закрываем pubsub-соединение, иначе при частых
         # обрывах соединений копятся забытые подписки на стороне Redis.
-        await pubsub.unsubscribe(channel)
+        await pubsub.unsubscribe(channel, room_channel)
         # `PubSub.aclose` в redis-py не аннотирован (untyped def) несмотря на
         # `py.typed` пакета — узкий игнор именно этого вызова.
         await pubsub.aclose()  # type: ignore[no-untyped-call]
@@ -111,37 +133,71 @@ async def _authenticate(websocket: WebSocket, service: ChatService) -> ChatIdent
 
 
 async def _pump_pubsub_to_websocket(
-    websocket: WebSocket, pubsub: PubSub, seen_ids: set[int]
+    websocket: WebSocket, pubsub: PubSub, chat_channel_name: str, seen_ids: set[int]
 ) -> None:
-    """Читать сообщения Redis pub/sub канала чата и пересылать их подключённому клиенту.
+    """Читать оба Redis pub/sub канала комнаты (чат + очередь рук) и пересылать клиенту.
 
-    `seen_ids` — id сообщений, уже отправленных клиенту в `history` (на
+    `seen_ids` — id сообщений чата, уже отправленных клиенту в `history` (на
     стыке подписки и SELECT истории возможен дубликат, см. докстринг
-    `chat_websocket`) — такие сообщения не пересылаются повторно.
+    `chat_websocket`) — такие сообщения не пересылаются повторно. Снапшоты
+    очереди рук такой дедупликации не требуют (полная замена состояния).
     """
     while True:
         raw = await pubsub.get_message(ignore_subscribe_messages=True, timeout=None)
         if raw is None:
             continue
-        message = ChatMessageOut.model_validate_json(raw["data"])
-        if message.id in seen_ids:
-            continue
-        seen_ids.add(message.id)
-        await websocket.send_json(ChatMessageEventOut(message=message).model_dump(mode="json"))
+        if raw["channel"] == chat_channel_name:
+            message = ChatMessageOut.model_validate_json(raw["data"])
+            if message.id in seen_ids:
+                continue
+            seen_ids.add(message.id)
+            await websocket.send_json(
+                ChatMessageEventOut(message=message).model_dump(mode="json")
+            )
+        else:
+            # Канал комнаты (`hand_queue.hand_queue_channel`) — уже готовый
+            # JSON исходящего конверта (`HandQueueOut`/`ForcedMuteOut`,
+            # см. `services/hand_queue.py::publish_snapshot` и эндпоинт мьюта
+            # в `api/conferences.py`), пересылаем как есть без пересборки.
+            await websocket.send_text(raw["data"])
 
 
 async def _pump_websocket_to_service(
     websocket: WebSocket, service: ChatService, conference: Conference, identity: ChatIdentity
 ) -> None:
-    """Читать текстовые сообщения клиента, валидировать и сохранять+публиковать их."""
+    """Читать сообщения клиента (текст чата / поднять-опустить руку), валидировать и обработать."""
+    is_organizer = conference.owner_id is not None and conference.owner_id == identity.user_id
     while True:
         raw = await websocket.receive_text()
         try:
-            envelope = ChatMessageIn.model_validate_json(raw)
+            envelope = _client_envelope_adapter.validate_json(raw)
         except ValidationError:
             await websocket.send_json(ChatErrorOut(code="invalid_message").model_dump(mode="json"))
             continue
-        await service.persist_and_publish(conference, identity=identity, text=envelope.text)
+
+        if isinstance(envelope, ChatMessageIn):
+            await service.persist_and_publish(conference, identity=identity, text=envelope.text)
+        elif isinstance(envelope, RaiseHandIn):
+            await hand_queue.raise_hand(
+                conference.id, identity=_identity_key(identity), name=identity.author_name
+            )
+            await hand_queue.publish_snapshot(conference.id)
+        else:
+            target = envelope.identity or _identity_key(identity)
+            if target != _identity_key(identity) and not is_organizer:
+                await websocket.send_json(
+                    ChatErrorOut(code="forbidden").model_dump(mode="json")
+                )
+                continue
+            await hand_queue.lower_hand(conference.id, identity=target)
+            await hand_queue.publish_snapshot(conference.id)
+
+
+def _identity_key(identity: ChatIdentity) -> str:
+    """Identity участника в формате LiveKit/очереди рук — `str(user_id)` либо `guest:{id}`."""
+    if identity.user_id is not None:
+        return str(identity.user_id)
+    return f"guest:{identity.guest_access_id}"
 
 
 async def _close_quietly(websocket: WebSocket, code: int) -> None:

backend/api/conferences.py

@@ -9,7 +9,12 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from api.deps import get_current_user
 from core.db import get_session
-from core.rate_limit import enforce_rate_limit
+from core.rate_limit import (
+    RATE_LIMIT_MISS_MAX_REQUESTS,
+    RATE_LIMIT_SOFT_MAX_REQUESTS,
+    client_ip,
+    enforce_rate_limit,
+)
 from models.user import User
 from schemas.conferences import (
     ConferenceCreateIn,
@@ -18,6 +23,8 @@ from schemas.conferences import (
     GuestJoinIn,
     JoinIn,
     JoinOut,
+    MuteParticipantIn,
+    MuteParticipantOut,
     OccurrenceOut,
     ResolveOut,
 )
@@ -34,6 +41,7 @@ from services.conferences import (
     InviteeUserNotFoundError,
     NotConferenceOwnerError,
 )
+from services.room_control import ParticipantNotInRoomError
 
 router = APIRouter(prefix="/api/v1/conferences", tags=["conferences"])
 
@@ -100,10 +108,18 @@ async def resolve_conference(
     п.4, уточнение резолва): вход в неё невозможен в любом случае (410 у
     join/guest-join), а признак закрытости неактуален для мёртвой конференции.
     """
-    await enforce_rate_limit(f"resolve:{_client_ip(request)}")
+    ip = client_ip(request)
+    # Мягкий потолок против флуда: успешные резолвы легитимны и массовы —
+    # вся конференция открывает ссылку в одну минуту.
+    await enforce_rate_limit(f"resolve:{ip}", max_requests=RATE_LIMIT_SOFT_MAX_REQUESTS)
     service = ConferenceService(session)
     conference = await service.resolve(q)
     if conference is None:
+        # Жёсткий счётчик — только на промахи: перебор номера конференции
+        # выглядит именно так (см. core/rate_limit.py и ADR-001, п.4).
+        await enforce_rate_limit(
+            f"resolve_miss:{ip}", max_requests=RATE_LIMIT_MISS_MAX_REQUESTS
+        )
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="not_found")
     if conference.status == "ended":
         return ResolveOut(id=conference.id, title=conference.title, status=conference.status)
@@ -151,11 +167,15 @@ async def guest_join_conference(
     session: Annotated[AsyncSession, Depends(get_session)],
 ) -> JoinOut:
     """Войти гостем: представиться (имя обязательно, email факультативен) — без auth, rate limit."""
-    await enforce_rate_limit(f"guest_join:{_client_ip(request)}")
+    ip = client_ip(request)
+    # Мягкий потолок: успешный гостевой вход — обычное дело для всей
+    # конференции сразу, ограничивать его числом «10 в минуту» нельзя.
+    await enforce_rate_limit(f"guest_join:{ip}", max_requests=RATE_LIMIT_SOFT_MAX_REQUESTS)
     service = ConferenceService(session)
     try:
         return await service.join_as_guest(conference_id, data=data)
     except ConferenceNotFoundError as exc:
+        await _count_guest_join_miss(ip)
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="conference_not_found"
         ) from exc
@@ -166,11 +186,45 @@ async def guest_join_conference(
             status_code=status.HTTP_403_FORBIDDEN, detail="password_required"
         ) from exc
     except InvalidPasswordError as exc:
+        # Подбор пароля закрытой конференции — тот же класс атаки, что и
+        # перебор номера, поэтому считается жёстким счётчиком.
+        await _count_guest_join_miss(ip)
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN, detail="invalid_password"
         ) from exc
 
 
+@router.post("/{conference_id}/mute-participant", response_model=MuteParticipantOut)
+async def mute_participant(
+    conference_id: uuid.UUID,
+    data: MuteParticipantIn,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+) -> MuteParticipantOut:
+    """Принудительно выключить микрофон/камеру участника (задача B2) — владелец/администратор.
+
+    Права проверяются ЗАНОВО по владельцу конференции в БД
+    (`ConferenceService.mute_participant`), а не по метаданным LiveKit-токена
+    вызывающего — те лишь подсказка для UI и потенциально подделываемы клиентом.
+    """
+    service = ConferenceService(session)
+    try:
+        muted = await service.mute_participant(
+            conference_id, actor=user, target_identity=data.identity, source=data.source
+        )
+    except ConferenceNotFoundError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="conference_not_found"
+        ) from exc
+    except NotConferenceOwnerError as exc:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="not_owner") from exc
+    except ParticipantNotInRoomError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="participant_not_in_room"
+        ) from exc
+    return MuteParticipantOut(muted=muted)
+
+
 @router.get("/{conference_id}", response_model=ConferenceOut)
 async def get_conference(
     conference_id: uuid.UUID,
@@ -250,6 +304,11 @@ def _require_utc(value: datetime) -> datetime:
     return value.astimezone(UTC)
 
 
-def _client_ip(request: Request) -> str:
-    """IP-адрес клиента для rate limit (без auth — ключ по IP, а не по пользователю)."""
-    return request.client.host if request.client else "unknown"
+async def _count_guest_join_miss(ip: str) -> None:
+    """Учесть неудачную попытку гостевого входа в жёстком счётчике.
+
+    Вынесено отдельно, потому что вызывается из двух веток обработки ошибок
+    (несуществующая конференция и неверный пароль) и обязано бросать 429
+    ровно так же, как обычный `enforce_rate_limit`.
+    """
+    await enforce_rate_limit(f"guest_join_miss:{ip}", max_requests=RATE_LIMIT_MISS_MAX_REQUESTS)

backend/api/livekit_webhook.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Annotated, Any, cast
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Request, status
+from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, Request, status
 from livekit import api
 from sqlalchemy import CursorResult
 from sqlalchemy.dialects.postgresql import insert as pg_insert
@@ -22,6 +22,7 @@ router = APIRouter(prefix="/api/v1/livekit", tags=["livekit"])
 @router.post("/webhook")
 async def receive_webhook(
     request: Request,
+    background: BackgroundTasks,
     session: Annotated[AsyncSession, Depends(get_session)],
     authorization: Annotated[str | None, Header()] = None,
 ) -> dict[str, str]:
@@ -30,6 +31,11 @@ async def receive_webhook(
     Дедупликация по `event.id`: `INSERT ... ON CONFLICT DO NOTHING` в
     `livekit_webhook_events` в одной транзакции с эффектами обработчика —
     при конфликте (дубль) эффекты пропускаются, но ответ всё равно 200.
+
+    Всё, что требует сети (запуск Track Egress), уходит в `background` и
+    выполняется уже после ответа: обработчик держит соединение с БД и
+    открытую транзакцию, а LiveKit при медленном ответе копит очередь
+    доставки и в итоге дропает события (см. `services.egress.run_track_egress`).
     """
     settings = get_settings()
     raw_body = await request.body()
@@ -57,7 +63,7 @@ async def receive_webhook(
         await session.commit()
         return {"status": "duplicate"}
 
-    dispatcher = WebhookDispatcher(session)
+    dispatcher = WebhookDispatcher(session, schedule=background.add_task)
     await dispatcher.dispatch(event)
     await session.commit()
     return {"status": "ok"}

backend/api/users.py

@@ -101,11 +101,11 @@ async def change_current_user_password(
     вместе со сбросом пароля по email (v0.1.0, см. ADR-005
     `docs/architecture/adr/005-password-reset-deferred.md`).
     """
-    if not verify_password(data.current_password, user.password_hash):
+    if not await verify_password(data.current_password, user.password_hash):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST, detail="invalid_current_password"
         )
-    user.password_hash = hash_password(data.new_password)
+    user.password_hash = await hash_password(data.new_password)
     await session.commit()
 
 

backend/core/config.py

@@ -20,6 +20,24 @@ class Settings(BaseSettings):
     redis_url: str = "redis://localhost:6379/0"
     plugins_config_path: str = "../config/plugins.yaml"
 
+    # --- Пул соединений с БД ---
+    # Дефолт SQLAlchemy (5 + 10) на нагрузочном тесте 28.07.2026 выгребался
+    # за секунды: 226 ошибок `QueuePool limit of size 5 overflow 10 reached`
+    # и 37 ответов 500 на путях входа в конференцию.
+    #
+    # ⚠️ Бюджет соединений считается на ВЕСЬ инстанс, а не на процесс: каждый
+    # воркер uvicorn (`UVICORN_WORKERS`) держит собственный пул, плюс
+    # соединения нужны Celery-воркерам и alembic при миграциях. При
+    # `max_connections=100` у Postgres и двух воркерах 2 × (10 + 10) = 40
+    # оставляет запас. Поднимая значения на более крупном сервере, поднимайте
+    # и `max_connections` — иначе вместо понятной ошибки приложения получите
+    # отказ Postgres, который диагностируется куда хуже.
+    db_pool_size: int = 10
+    db_max_overflow: int = 10
+    # 10 секунд вместо дефолтных 30 — сознательно: пусть запрос падает быстро
+    # и показывает проблему, а не висит полминуты, делая вид, что всё живо.
+    db_pool_timeout: int = 10
+
     # --- Версия инстанса (релиз v0.0.1) ---
     # install.sh копирует значение из файла `VERSION` (корень репозитория) в
     # `.env` при каждой установке/обновлении — здесь только чтение готового
@@ -59,6 +77,13 @@ class Settings(BaseSettings):
     # (см. `deploy/docker-compose.yml`); в тестах переопределяется на `tmp_path`.
     recordings_dir: str = "/recordings"
 
+    # Таймаут запуска Track Egress. Когда egress-сервиса в деплое нет (профиль
+    # `transcribe` не поднят), LiveKit ждёт ответа воркера через Redis до
+    # собственного таймаута psrpc — на тесте 28.07.2026 это давало по 20–25
+    # секунд на каждый вызов. Ждать столько бессмысленно: если egress жив, он
+    # отвечает за доли секунды.
+    egress_start_timeout_s: float = 3.0
+
     # --- Email (SMTP-бэкенд) ---
     # `console` — дефолт для dev (письмо только логируется); `smtp` — реальная
     # отправка через aiosmtplib. Секреты SMTP — только в `.env` (инвариант №6),

backend/core/db.py

@@ -13,7 +13,16 @@ from core.config import get_settings
 
 settings = get_settings()
 
-engine: AsyncEngine = create_async_engine(settings.database_url, pool_pre_ping=True)
+engine: AsyncEngine = create_async_engine(
+    settings.database_url,
+    pool_pre_ping=True,
+    # Параметры пула — в настройках (`core/config.py`, там же расчёт бюджета
+    # соединений на инстанс). Дефолт SQLAlchemy 5 + 10 под нагрузкой
+    # выгребался за секунды.
+    pool_size=settings.db_pool_size,
+    max_overflow=settings.db_max_overflow,
+    pool_timeout=settings.db_pool_timeout,
+)
 
 async_session_maker = async_sessionmaker(engine, expire_on_commit=False)
 

backend/core/rate_limit.py

@@ -3,15 +3,59 @@
 Используется резолвом конференций и гостевым входом (`api/conferences.py`) —
 эндпоинтами без аутентификации, уязвимыми к перебору номера/ссылки конференции
 (см. ADR-001, п.4 — оценка энтропии и рекомендуемый лимит 10 запросов/мин на IP).
+
+## Два счётчика вместо одного (0.0.18)
+
+Прежняя схема считала ВСЕ запросы подряд с лимитом 10/мин. На нагрузочном
+тесте 31.07.2026 это остановило вход целой конференции: люди открывали ссылку
+одновременно, одиннадцатый получал 429, а фронтенд показывал «Не удалось найти
+конференцию» — при том что конференция существовала и была активна.
+
+Смысл лимита по ADR-001 — защита от ПЕРЕБОРА номера конференции. Перебор — это
+поток промахов; легитимный участник открывает существующую ссылку и получает
+успех. Поэтому:
+
+- `RATE_LIMIT_MISS_MAX_REQUESTS` — жёсткий счётчик промахов (конференция не
+  найдена, неверный пароль). Именно он защищает от перебора, и он остался
+  прежним — 10/мин;
+- `RATE_LIMIT_SOFT_MAX_REQUESTS` — мягкий потолок на общее число обращений с
+  одного адреса. Нужен только против тупого флуда; рассчитан так, чтобы сотня
+  человек из офиса за общим NAT спокойно зашла в одну конференцию.
 """
 
-from fastapi import HTTPException, status
+from fastapi import HTTPException, Request, status
 
 from core.redis import redis_client
 
 RATE_LIMIT_MAX_REQUESTS = 10
 RATE_LIMIT_WINDOW_SECONDS = 60
 
+# Промахи: перебор номера/ссылки или подбор пароля конференции.
+RATE_LIMIT_MISS_MAX_REQUESTS = 10
+# Общий поток с одного IP. Офис за общим NAT — это ОДИН адрес, поэтому потолок
+# заведомо выше правдоподобного числа участников одной конференции.
+RATE_LIMIT_SOFT_MAX_REQUESTS = 300
+
+
+def client_ip(request: Request) -> str:
+    """IP клиента для rate limit — с учётом того, что backend стоит за nginx.
+
+    `request.client.host` — это TCP-peer, то есть контейнер nginx, один и тот же
+    для всех пользователей. С ним лимит превращался в общий на весь инстанс:
+    на проде в Redis лежал единственный ключ `rate_limit:resolve:172.18.0.13`,
+    и десяти запросов в минуту хватало, чтобы заблокировать вход всем сразу.
+
+    Берём `X-Real-IP`, а НЕ первый элемент `X-Forwarded-For`: nginx заполняет
+    его через `$proxy_add_x_forwarded_for`, то есть ДОПИСЫВАЕТ к присланному
+    клиентом. Первый элемент там подделывается одним заголовком, и лимит
+    обходился бы тривиально. `X-Real-IP` nginx всегда перезаписывает своим
+    `$remote_addr` (см. deploy/nginx/nginx.conf.template).
+    """
+    real_ip = request.headers.get("x-real-ip")
+    if real_ip:
+        return real_ip.strip()
+    return request.client.host if request.client else "unknown"
+
 
 async def enforce_rate_limit(
     key: str,

backend/core/security.py

@@ -1,33 +1,85 @@
 """Хэширование паролей (argon2) и выпуск/проверка JWT (access + refresh)."""
 
+import asyncio
 import uuid
 from datetime import UTC, datetime, timedelta
 from typing import Any
 
 import jwt
 from argon2 import PasswordHasher
-from argon2.exceptions import VerifyMismatchError
+from argon2.exceptions import InvalidHashError, VerifyMismatchError
 
 from core.config import get_settings
 
 JWT_ALGORITHM = "HS256"
 
-_hasher = PasswordHasher()
+# Параметры argon2id по рекомендации OWASP (Password Storage Cheat Sheet):
+# t=2, m=19 МБ, p=1. Раньше использовались дефолты argon2-cffi
+# (t=3, m=64 МБ, p=4) — это был не выбор, а «что было в коробке».
+#
+# Замер на боевом сервере (4 ядра): 95 мс против 42 мс на одну проверку.
+# Отдельно важен `parallelism`: при p=4 ОДНА проверка пароля занимала все
+# четыре ядра, конкурируя с LiveKit за то же железо ровно в момент, когда
+# люди массово заходят в конференцию.
+#
+# Существующие хэши не ломаются: параметры хранятся внутри самой строки хэша
+# и читаются при verify. Старые хэши перевыпускаются постепенно — см.
+# `needs_rehash` и его использование при успешном входе.
+_hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
 
 
-def hash_password(password: str) -> str:
-    """Захэшировать пароль алгоритмом argon2 для хранения в БД."""
+def _hash_password_sync(password: str) -> str:
     return _hasher.hash(password)
 
 
-def verify_password(password: str, password_hash: str) -> bool:
-    """Сверить пароль с сохранённым argon2-хэшем; пароль/хэш никогда не логируются."""
+def _verify_password_sync(password: str, password_hash: str) -> bool:
     try:
         return _hasher.verify(password_hash, password)
     except VerifyMismatchError:
         return False
 
 
+async def hash_password(password: str) -> str:
+    """Захэшировать пароль алгоритмом argon2 для хранения в БД.
+
+    Считается в отдельном потоке — argon2 это CPU-bound работа на десятки
+    миллисекунд, и в event loop ей не место (см. `verify_password`).
+    """
+    return await asyncio.to_thread(_hash_password_sync, password)
+
+
+async def verify_password(password: str, password_hash: str) -> bool:
+    """Сверить пароль с сохранённым argon2-хэшем; пароль/хэш никогда не логируются.
+
+    Выполняется в пуле потоков, а не в event loop. Причина — нагрузочный тест
+    31.07.2026: синхронный вызов останавливал весь процесс на 95–155 мс, и при
+    массовом входе (около 70 человек разом) это давало p95 логина 7.28 секунды,
+    33 соединения к БД в состоянии `idle in transaction` при одном активном
+    запросе и отказы на совершенно посторонних ручках — включая вход в
+    конференцию, где никакого пароля не проверялось.
+
+    Потоки здесь работают по-настоящему параллельно: argon2-cffi — это
+    C-расширение, освобождающее GIL на время вычисления.
+    """
+    return await asyncio.to_thread(_verify_password_sync, password, password_hash)
+
+
+def needs_rehash(password_hash: str) -> bool:
+    """Проверить, что хэш выпущен устаревшими параметрами argon2.
+
+    Дешёвая операция: разбор строки хэша, без вычислений. Вызывается после
+    успешной проверки пароля — только тогда у нас на руках открытый пароль,
+    которым можно перевыпустить хэш.
+
+    Невалидную строку считаем требующей перевыпуска: если в базе оказался
+    мусор, лучше заменить его корректным хэшем, чем падать при каждом входе.
+    """
+    try:
+        return _hasher.check_needs_rehash(password_hash)
+    except InvalidHashError:
+        return True
+
+
 def create_access_token(user_id: uuid.UUID, role: str) -> str:
     """Выпустить access-токен: `sub`=user_id, `role`=роль, TTL из настроек."""
     settings = get_settings()

backend/schemas/conferences.py

@@ -6,6 +6,7 @@ from datetime import UTC, datetime, timedelta
 from pydantic import BaseModel, EmailStr, Field, field_serializer, field_validator, model_validator
 
 from core.plugins.config import SummaryRecipientsMode
+from schemas.room_events import ForcedMuteSource
 from services.recurrence import RecurrenceRule
 
 # Допуск в прошлое при плановом создании/правке — небольшой запас на задержку
@@ -210,3 +211,21 @@ class GuestJoinIn(BaseModel):
     display_name: str = Field(min_length=1, max_length=255)
     email: EmailStr | None = None
     password: str | None = None
+
+
+class MuteParticipantIn(BaseModel):
+    """Тело запроса принудительного мьюта участника организатором (задача B2).
+
+    `identity` — тот же формат, что и `Participant.identity` в LiveKit
+    (`str(user_id)` либо `guest:{id}`); клиент берёт его из `useParticipants()`
+    LiveKit, не подбирает вручную.
+    """
+
+    identity: str = Field(min_length=1)
+    source: ForcedMuteSource
+
+
+class MuteParticipantOut(BaseModel):
+    """Ответ на принудительный мьют — `muted=False`, если трек и так не был опубликован."""
+
+    muted: bool

backend/schemas/room_events.py

@@ -0,0 +1,61 @@
+"""Pydantic-схемы событий комнаты, мультиплексируемых поверх WS-чата (`api/chat.py`).
+
+Отдельный протокол от собственно чата (`schemas/chat.py`): очередь поднятых
+рук и уведомления о принудительном мьюте — эфемерное состояние звонка
+(Redis, не БД, см. `services/hand_queue.py`) и не должны попадать в
+персистентную историю сообщений чата, хотя и едут по тому же соединению.
+"""
+
+from datetime import UTC, datetime
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_serializer
+
+
+class RaiseHandIn(BaseModel):
+    """Клиент поднимает свою руку."""
+
+    type: Literal["raise_hand"]
+
+
+class LowerHandIn(BaseModel):
+    """Клиент опускает руку — свою (без `identity`) либо, только для организатора, чужую."""
+
+    type: Literal["lower_hand"]
+    identity: str | None = None
+
+
+class HandQueueEntryOut(BaseModel):
+    """Один участник в очереди поднятых рук."""
+
+    identity: str
+    name: str
+    raised_at: datetime
+
+    @field_serializer("raised_at")
+    def _serialize_raised_at(self, value: datetime) -> str:
+        return value.astimezone(UTC).isoformat().replace("+00:00", "Z")
+
+
+class HandQueueOut(BaseModel):
+    """Снапшот очереди поднятых рук — рассылается всем участникам при любом изменении."""
+
+    type: Literal["hand_queue"] = "hand_queue"
+    queue: list[HandQueueEntryOut] = Field(default_factory=list)
+
+
+ForcedMuteSource = Literal["microphone", "camera"]
+
+
+class ForcedMuteOut(BaseModel):
+    """Организатор принудительно выключил трек участника (задача B2) — уведомление всем.
+
+    Рассылается всем (не только затронутому), как и `HandQueueOut`: канал —
+    общий broadcast, а не адресная доставка одному соединению; получатели,
+    для которых `identity` не совпадает с их собственной, событие
+    игнорируют.
+    """
+
+    type: Literal["forced_mute"] = "forced_mute"
+    identity: str
+    source: ForcedMuteSource

backend/services/auth.py

@@ -24,6 +24,7 @@ from core.security import (
     create_refresh_token,
     decode_token,
     hash_password,
+    needs_rehash,
     verify_password,
 )
 from models.email_verification import EmailVerificationToken
@@ -131,7 +132,7 @@ class AuthService:
         user = await self._users.create(
             email=email,
             name_user=name_user,
-            password_hash=hash_password(password),
+            password_hash=await hash_password(password),
             team_id=team_id,
         )
         reply_to = cfg.contact_email if cfg.contact_email_enabled else None
@@ -161,10 +162,21 @@ class AuthService:
     async def login(self, *, email: str, password: str) -> TokenPair:
         """Проверить учётные данные и выдать пару access/refresh токенов."""
         user = await self._users.get_by_email(email)
-        if user is None or not verify_password(password, user.password_hash):
+        if user is None or not await verify_password(password, user.password_hash):
             raise InvalidCredentialsError
         if not user.email_verified:
             raise EmailNotVerifiedError
+
+        # Постепенная миграция на актуальные параметры argon2 (см. core/security.py):
+        # параметры зашиты в саму строку хэша, поэтому старые записи так и
+        # проверялись бы вдвое дольше. Открытый пароль есть только здесь и
+        # только сейчас — другого места для перевыпуска не будет.
+        if needs_rehash(user.password_hash):
+            user.password_hash = await hash_password(password)
+            # Явный commit: выдача токенов идёт через Redis и БД не трогает,
+            # поэтому без него перевыпущенный хэш откатился бы вместе с сессией.
+            await self._session.commit()
+
         return await self._issue_token_pair(user.id, user.role)
 
     async def refresh(self, refresh_token: str) -> TokenPair:

backend/services/conference_access.py

@@ -27,7 +27,7 @@ class InvalidPasswordError(Exception):
     """Указанный пароль не совпадает с паролем закрытой конференции."""
 
 
-def ensure_joinable(conference: Conference, *, password: str | None) -> None:
+async def ensure_joinable(conference: Conference, *, password: str | None) -> None:
     """Проверить, что в конференцию можно войти прямо сейчас.
 
     Бросает `ConferenceEndedError` для терминального статуса `ended`
@@ -42,7 +42,7 @@ def ensure_joinable(conference: Conference, *, password: str | None) -> None:
         return
     if conference.password_hash is None or password is None:
         raise PasswordRequiredError
-    if not verify_password(password, conference.password_hash):
+    if not await verify_password(password, conference.password_hash):
         raise InvalidPasswordError
 
 
@@ -53,19 +53,31 @@ def build_join(
     name: str,
     chat_enabled: bool,
     avatar_url: str | None = None,
+    is_organizer: bool = False,
 ) -> JoinOut:
     """Построить ответ join: LiveKit access-токен для входа в комнату конференции.
 
     Имя LiveKit-комнаты всегда равно `conference.slug` (ADR-001, п.4).
     `chat_enabled` — снятый вызывающей стороной тоггл `instance_settings`:
     читается здесь параметром, а не заново из БД, чтобы не плодить
-    отдельный запрос настроек на каждый join. `avatar_url` прокидывается
-    в метаданные токена как JSON
-    `{"avatar_url": ...}`; `None` (гость либо пользователь без аватара) —
-    метаданные не выставляются вовсе.
+    отдельный запрос настроек на каждый join. `avatar_url`/`is_organizer`
+    прокидываются в метаданные токена как JSON `{"avatar_url": ..., "is_organizer": true}`
+    — поля добавляются, только если заданы (гость без аватара и не-организатор
+    получают токен вовсе без метаданных, как и раньше).
+
+    ⚠️ `is_organizer` в метаданных — только подсказка для UI клиента (показать/
+    скрыть кнопки организатора). Метаданным токена доверять для АВТОРИЗАЦИИ
+    нельзя — участник технически может их подделать на своей стороне. Любое
+    серверное действие организатора (например, принудительный мьют) обязано
+    заново проверяться по `conference.owner_id` в БД, а не по этому полю.
     """
     settings = get_settings()
-    metadata = json.dumps({"avatar_url": avatar_url}) if avatar_url else None
+    metadata_payload: dict[str, object] = {}
+    if avatar_url:
+        metadata_payload["avatar_url"] = avatar_url
+    if is_organizer:
+        metadata_payload["is_organizer"] = True
+    metadata = json.dumps(metadata_payload) if metadata_payload else None
     token = create_room_access_token(
         room_name=conference.slug, identity=identity, name=name, metadata=metadata
     )

backend/services/conferences.py

@@ -33,12 +33,14 @@ from schemas.conferences import (
     JoinOut,
     OccurrenceOut,
 )
+from services import hand_queue
 from services.avatars import avatar_url as resolve_avatar_url
 from services.conference_access import build_join, ensure_joinable
 from services.conference_ids import generate_number, generate_slug
 from services.instance_settings import InstanceSettingsService
 from services.invitations_producer import enqueue_invitations
 from services.recurrence import RecurrenceRule, expand_occurrences
+from services.room_control import MuteSource, mute_participant_track
 
 logger = logging.getLogger(__name__)
 
@@ -99,7 +101,7 @@ class ConferenceService:
         повторением без явного `scheduled_at` — плановая конференция,
         ожидающая своего первого вхождения, а не мгновенный вход.
         """
-        password_hash = hash_password(data.password) if data.password else None
+        password_hash = await hash_password(data.password) if data.password else None
         is_instant = data.scheduled_at is None and data.recurrence is None
         conference_status = "active" if is_instant else "scheduled"
         recurrence_json = data.recurrence.model_dump(mode="json") if data.recurrence else None
@@ -154,6 +156,7 @@ class ConferenceService:
                 name=owner_name,
                 chat_enabled=chat_enabled,
                 avatar_url=resolve_avatar_url(self._media_root, owner_avatar_path),
+                is_organizer=True,
             )
         else:
             # Плановая (разовая) либо закреплённая с повторением/датой — есть
@@ -239,7 +242,7 @@ class ConferenceService:
     ) -> JoinOut:
         """Войти в конференцию зарегистрированным пользователем."""
         conference = await self._get_or_raise(conference_id)
-        ensure_joinable(conference, password=password)
+        await ensure_joinable(conference, password=password)
         chat_enabled = (await InstanceSettingsService(self._session).get()).chat.enabled
         return build_join(
             conference,
@@ -247,12 +250,13 @@ class ConferenceService:
             name=user.name_user,
             chat_enabled=chat_enabled,
             avatar_url=resolve_avatar_url(self._media_root, user.avatar_path),
+            is_organizer=conference.owner_id is not None and conference.owner_id == user.id,
         )
 
     async def join_as_guest(self, conference_id: uuid.UUID, *, data: GuestJoinIn) -> JoinOut:
         """Войти в конференцию гостем: создать `GuestAccess` и выдать токен."""
         conference = await self._get_or_raise(conference_id)
-        ensure_joinable(conference, password=data.password)
+        await ensure_joinable(conference, password=data.password)
 
         guest = GuestAccess(
             conference_id=conference.id, display_name=data.display_name, email=data.email
@@ -269,6 +273,36 @@ class ConferenceService:
             chat_enabled=chat_enabled,
         )
 
+    async def mute_participant(
+        self,
+        conference_id: uuid.UUID,
+        *,
+        actor: User,
+        target_identity: str,
+        source: MuteSource,
+    ) -> bool:
+        """Принудительно замьютить трек участника (задача B2); владелец/администратор.
+
+        Права — ТОЛЬКО отсюда (`_ensure_owner_or_admin` по `conference.owner_id`
+        в БД), не по метаданным LiveKit-токена вызывающего: те лишь подсказка
+        для UI (см. `services/conference_access.py::build_join`) и потенциально
+        подделываемы клиентом. `target_identity` НИКАК не валидируется против
+        состава участников заранее — если его сейчас нет в комнате LiveKit,
+        `mute_participant_track` бросит `ParticipantNotInRoomError` (ловит
+        API-роутер).
+        """
+        conference = await self._get_or_raise(conference_id)
+        self._ensure_owner_or_admin(conference, actor)
+
+        muted = await mute_participant_track(
+            conference.slug, identity=target_identity, source=source
+        )
+        if muted:
+            await hand_queue.publish_forced_mute(
+                conference.id, identity=target_identity, source=source
+            )
+        return muted
+
     async def update(
         self, conference_id: uuid.UUID, *, actor: User, data: ConferenceUpdateIn
     ) -> Conference:
@@ -296,7 +330,7 @@ class ConferenceService:
         if data.is_closed is not None:
             conference.is_closed = data.is_closed
         if data.password is not None:
-            conference.password_hash = hash_password(data.password)
+            conference.password_hash = await hash_password(data.password)
         if "summary_recipients" in data.model_fields_set:
             # Явная передача (в т.ч. `null`) — сбросить/установить
             # переопределение; отсутствие поля в запросе значение не трогает.

backend/services/egress.py

@@ -5,14 +5,24 @@
 транскодирования в `.ogg` на общий volume `recordings_dir`. Финализация
 результата (итоговый `location`/ошибка) приходит асинхронно через webhook
 `egress_ended` — здесь только сам запуск и `egress_id`/`started_at` из ответа.
+
+Запуск вынесен из тела webhook-обработчика в фоновую задачу
+(`run_track_egress`) — см. докстринг этой функции.
 """
 
+import asyncio
+import logging
+import uuid
 from dataclasses import dataclass
 from datetime import UTC, datetime
 
 from livekit import api
 
 from core.config import get_settings
+from core.db import async_session_maker
+from repositories.conferences import AudioTrackRepository
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass(frozen=True, slots=True)
@@ -37,13 +47,17 @@ async def start_track_egress(room_name: str, track_sid: str, filepath: str) -> E
         api_secret=settings.livekit_api_secret,
     )
     try:
-        info = await lkapi.egress.start_track_egress(
-            api.TrackEgressRequest(
-                room_name=room_name,
-                track_id=track_sid,
-                file=api.DirectFileOutput(filepath=filepath),
+        # Без таймаута вызов висит до собственного таймаута psrpc LiveKit
+        # (20–25 с, когда egress-воркера в деплое нет). `TimeoutError`
+        # ловит вызывающая сторона наравне с прочими ошибками запуска.
+        async with asyncio.timeout(settings.egress_start_timeout_s):
+            info = await lkapi.egress.start_track_egress(
+                api.TrackEgressRequest(
+                    room_name=room_name,
+                    track_id=track_sid,
+                    file=api.DirectFileOutput(filepath=filepath),
+                )
             )
-        )
     finally:
         await lkapi.aclose()
 
@@ -56,3 +70,65 @@ async def start_track_egress(room_name: str, track_sid: str, filepath: str) -> E
         else datetime.now(UTC)
     )
     return EgressStartResult(egress_id=info.egress_id, started_at=started_at)
+
+
+async def run_track_egress(
+    *,
+    room_name: str,
+    track_sid: str,
+    filepath: str,
+    session_id: uuid.UUID,
+    participant_id: uuid.UUID,
+) -> None:
+    """Запустить Track Egress и записать строку трека — ФОНОВАЯ задача вебхука.
+
+    Почему не внутри обработчика. `POST /api/v1/livekit/webhook` держит
+    соединение с БД и открытую транзакцию всё время своей работы (INSERT в
+    `livekit_webhook_events` сделан, commit — после обработчика). Пока здесь
+    жил сетевой вызов к egress, каждое событие `track_published` занимало
+    соединение на 20–25 секунд, и на нагрузочном тесте 28.07.2026 пул
+    выгребался за секунды: 226 ошибок `QueuePool limit`, 37 ответов 500 на
+    путях входа в конференцию, 33 `dropped webhook` со стороны LiveKit
+    (очередь доставки росла до 56 секунд).
+
+    Поэтому обработчик отвечает 200 сразу, а сюда попадает только то, что
+    требует сети. Своя сессия БД (`async_session_maker`) обязательна: сессия
+    запроса к этому моменту уже закрыта вместе с ответом.
+
+    Идемпотентность сохраняется: `AudioTrackRepository.create` — это
+    `INSERT ... ON CONFLICT DO NOTHING` по `uq_session_track`, а проверка
+    «трек уже пишется» осталась в обработчике.
+    """
+    try:
+        result = await start_track_egress(room_name, track_sid, filepath)
+    except Exception as exc:  # noqa: BLE001 — недоступность egress не должна ронять фон
+        # Деплой-профиль (блок D): egress — необязательный сервис профиля
+        # `transcribe`; без него запись просто не стартует для этого трека.
+        # Строку `session_audio_tracks` не создаём — у нас нет `egress_id`,
+        # по которому её мог бы финализировать `egress_ended`.
+        logger.warning(
+            "track_published: не удалось запустить egress для трека %s сеанса %s: %s",
+            track_sid,
+            session_id,
+            exc,
+        )
+        return
+
+    async with async_session_maker() as session:
+        await AudioTrackRepository(session).create(
+            session_id=session_id,
+            participant_id=participant_id,
+            track_sid=track_sid,
+            egress_id=result.egress_id,
+            file_path=filepath,
+            started_at=result.started_at,
+        )
+        await session.commit()
+
+    logger.info(
+        "track_published: сеанс=%s участник=%s трек=%s egress=%s",
+        session_id,
+        participant_id,
+        track_sid,
+        result.egress_id,
+    )

backend/services/hand_queue.py

@@ -0,0 +1,144 @@
+"""Очередь поднятых рук конференции — состояние в Redis, не в Postgres (задача B1).
+
+Транспорт для клиентов — тот же аутентифицированный WS чата (`api/chat.py`):
+переиспользуем уже открытые и держащиеся сервером соединения вместо отдельного
+эндпоинта. Хранение — Redis, а не БД: очередь существует ровно во время звонка
+и не должна переживать его завершение (в отличие от истории чата), а два
+процесса uvicorn (`UVICORN_WORKERS`) делают наивное состояние в памяти одного
+процесса недостаточным — организатор и участник могут оказаться на разных
+воркерах.
+
+Один Redis-ключ (HASH) на конференцию: поле — identity участника (тот же
+формат, что в LiveKit-токене и вебхуках — `str(user_id)` или
+`guest:{guest_access.id}`), значение — JSON `{"name": ..., "raised_at": <unix
+epoch>}`. `HSETNX` даёт атомарное «добавить, только если ещё нет» — повторное
+поднятие уже поднятой руки НЕ сбрасывает её место в очереди (идемпотентно).
+Порядок — сортировкой по `raised_at` при чтении снапшота (участников в одной
+конференции — единицы-десятки, сортировка в Python здесь дешевле, чем держать
+вторую структуру (ZSET) синхронно с первой).
+"""
+
+import json
+import time
+import uuid
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from core.redis import redis_client
+from schemas.room_events import ForcedMuteOut, ForcedMuteSource, HandQueueEntryOut, HandQueueOut
+
+# TTL ключа очереди — подстраховка на случай пропущенного webhook
+# `room_finished` (см. `services/webhook_handlers.py::_on_room_finished`,
+# который чистит очередь явно при штатном завершении). Сама конференция
+# столько не длится ни при каких сценариях.
+HAND_QUEUE_TTL_SECONDS = 24 * 60 * 60
+
+
+def hand_queue_key(conference_id: uuid.UUID) -> str:
+    """Redis-ключ HASH очереди поднятых рук конкретной конференции."""
+    return f"hand_queue:{conference_id}"
+
+
+def hand_queue_channel(conference_id: uuid.UUID) -> str:
+    """Redis pub/sub канал событий комнаты (очередь рук + принудительный мьют, задача B2)."""
+    return f"room_events:{conference_id}"
+
+
+@dataclass(frozen=True, slots=True)
+class HandQueueEntry:
+    """Один участник в очереди поднятых рук."""
+
+    identity: str
+    name: str
+    raised_at: float
+
+
+async def raise_hand(conference_id: uuid.UUID, *, identity: str, name: str) -> bool:
+    """Поднять руку участника; `True` — рука реально поднялась (не была поднята раньше).
+
+    `HSETNX` — атомарная проверка-и-запись: если участник уже в очереди,
+    ничего не меняет (в т.ч. НЕ обновляет `raised_at`) — переподключение и
+    повторный клик не переставляют его в конец очереди.
+    """
+    key = hand_queue_key(conference_id)
+    payload = json.dumps({"name": name, "raised_at": time.time()})
+    added = await redis_client.hsetnx(key, identity, payload)
+    await redis_client.expire(key, HAND_QUEUE_TTL_SECONDS)
+    return bool(added)
+
+
+async def lower_hand(conference_id: uuid.UUID, *, identity: str) -> bool:
+    """Опустить руку участника; `True` — рука была поднята и теперь снята."""
+    removed = await redis_client.hdel(hand_queue_key(conference_id), identity)
+    return bool(removed)
+
+
+async def snapshot(conference_id: uuid.UUID) -> list[HandQueueEntry]:
+    """Текущая очередь, упорядоченная по времени поднятия (раньше — раньше в списке)."""
+    raw = await redis_client.hgetall(hand_queue_key(conference_id))
+    entries = []
+    for identity, payload in raw.items():
+        try:
+            data = json.loads(payload)
+            entries.append(
+                HandQueueEntry(
+                    identity=str(identity), name=data["name"], raised_at=data["raised_at"]
+                )
+            )
+        except (ValueError, KeyError, TypeError):
+            # Побитый/устаревшего формата элемент — пропускаем, а не роняем всю очередь.
+            continue
+    entries.sort(key=lambda entry: entry.raised_at)
+    return entries
+
+
+async def clear(conference_id: uuid.UUID) -> None:
+    """Полностью снести очередь конференции (штатное завершение — `room_finished`)."""
+    await redis_client.delete(hand_queue_key(conference_id))
+
+
+def _to_out(entries: list[HandQueueEntry]) -> HandQueueOut:
+    """Собрать исходящий снапшот из внутренних записей очереди."""
+    return HandQueueOut(
+        queue=[
+            HandQueueEntryOut(
+                identity=entry.identity,
+                name=entry.name,
+                raised_at=datetime.fromtimestamp(entry.raised_at, tz=UTC),
+            )
+            for entry in entries
+        ]
+    )
+
+
+async def get_snapshot_out(conference_id: uuid.UUID) -> HandQueueOut:
+    """Текущая очередь в исходящем формате — для отправки сразу после подключения к WS."""
+    return _to_out(await snapshot(conference_id))
+
+
+async def publish_snapshot(conference_id: uuid.UUID) -> None:
+    """Опубликовать текущий снапшот очереди всем подписчикам канала комнаты.
+
+    Вызывается после любого изменения очереди (`raise_hand`/`lower_hand` —
+    из `api/chat.py`, а также `participant_left`/`room_finished` — из
+    `services/webhook_handlers.py`), чтобы у всех участников (и особенно у
+    организатора, зашедшего позже) была всегда актуальная картина.
+    """
+    payload = _to_out(await snapshot(conference_id))
+    await redis_client.publish(hand_queue_channel(conference_id), payload.model_dump_json())
+
+
+async def publish_forced_mute(
+    conference_id: uuid.UUID, *, identity: str, source: ForcedMuteSource
+) -> None:
+    """Оповестить всех участников комнаты о принудительном мьюте (задача B2).
+
+    Тот же канал, что и у очереди рук (`hand_queue_channel`) — `api/chat.py`
+    пересылает с него ЛЮБОЙ JSON как есть, различая события по полю `type`
+    (см. `_pump_pubsub_to_websocket`). Рассылается ВСЕМ, а не адресно
+    затронутому участнику: канал общий на конференцию, адресной доставки
+    одному соединению тут нет, поэтому клиент сам сверяет `identity` со
+    своей (см. `ForcedMuteOut` в `schemas/room_events.py`).
+    """
+    payload = ForcedMuteOut(identity=identity, source=source)
+    await redis_client.publish(hand_queue_channel(conference_id), payload.model_dump_json())

backend/services/room_control.py

@@ -0,0 +1,81 @@
+"""Управление комнатой LiveKit от имени организатора (задача B2): принудительный мьют.
+
+Тонкая обёртка над `RoomServiceClient` — тот же паттерн, что и
+`services/egress.py` (единственная точка мокирования в тестах, свой
+`api.LiveKitAPI` на вызов, аутентификация СЕРВЕРНЫМИ `api_key`/`api_secret`,
+а не токеном организатора). Именно поэтому организатору не нужен отдельный
+LiveKit-грант в собственном access-токене под это действие — мьютит backend
+от своего имени, клиент лишь инициирует вызов, а право на это проверяется
+по владельцу конференции в БД (`services/conferences.py::mute_participant`),
+ДО обращения сюда.
+"""
+
+import logging
+
+from livekit import api
+from livekit.protocol.models import TrackSource
+
+from core.config import get_settings
+from schemas.room_events import ForcedMuteSource
+
+logger = logging.getLogger(__name__)
+
+# Переэкспорт под более общим именем — этот модуль не завязан на протокол WS
+# (`schemas/room_events.py`), которому концептуально принадлежит `ForcedMuteSource`.
+MuteSource = ForcedMuteSource
+
+_TRACK_SOURCE_BY_NAME: dict[MuteSource, int] = {
+    "microphone": TrackSource.MICROPHONE,
+    "camera": TrackSource.CAMERA,
+}
+
+
+class ParticipantNotInRoomError(Exception):
+    """Участника с таким identity сейчас нет в комнате LiveKit (уже вышел/не заходил)."""
+
+
+async def mute_participant_track(room_name: str, *, identity: str, source: MuteSource) -> bool:
+    """Принудительно замьютить опубликованный трек участника; `True` — трек реально замьючен.
+
+    Если трек данного `source` сейчас не опубликован — не ошибка, а no-op:
+    искомое состояние («трек не идёт») уже достигнуто. Обычный случай с
+    0.0.15 — участники заходят с выключенными микрофоном/камерой (задача
+    A1), трек попросту не существует, пока человек не включит его сам;
+    мьютить в этот момент нечего, и это НЕ повод отвечать клиенту ошибкой.
+    """
+    settings = get_settings()
+    lkapi = api.LiveKitAPI(
+        settings.livekit_url,
+        api_key=settings.livekit_api_key,
+        api_secret=settings.livekit_api_secret,
+    )
+    try:
+        try:
+            participant = await lkapi.room.get_participant(
+                api.RoomParticipantIdentity(room=room_name, identity=identity)
+            )
+        except api.TwirpError as exc:
+            if exc.status == 404:
+                raise ParticipantNotInRoomError from exc
+            raise
+
+        target_source = _TRACK_SOURCE_BY_NAME[source]
+        track = next((t for t in participant.tracks if t.source == target_source), None)
+        if track is None or track.muted:
+            return False
+
+        await lkapi.room.mute_published_track(
+            api.MuteRoomTrackRequest(
+                room=room_name, identity=identity, track_sid=track.sid, muted=True
+            )
+        )
+        logger.info(
+            "room_control: принудительный мьют — комната=%s identity=%s source=%s трек=%s",
+            room_name,
+            identity,
+            source,
+            track.sid,
+        )
+        return True
+    finally:
+        await lkapi.aclose()

backend/services/webhook_handlers.py

@@ -13,6 +13,7 @@
 
 import logging
 import uuid
+from collections.abc import Callable
 from datetime import UTC, datetime
 
 from livekit.protocol.egress import EgressStatus
@@ -26,7 +27,8 @@ from repositories.conferences import (
     ConferenceRepository,
     ConferenceSessionRepository,
 )
-from services.egress import start_track_egress
+from services import hand_queue
+from services.egress import run_track_egress
 from services.instance_settings import InstanceSettingsService
 from services.pipeline_producer import enqueue_pipeline
 
@@ -53,13 +55,27 @@ def _egress_ns_to_datetime(nanoseconds: int) -> datetime | None:
 
 
 class WebhookDispatcher:
-    """Диспатчит `WebhookEvent` на обработчик по типу события."""
+    """Диспатчит `WebhookEvent` на обработчик по типу события.
 
-    def __init__(self, session: AsyncSession) -> None:
+    `schedule` — планировщик фоновых задач: вызывается как
+    `schedule(coro_func, **kwargs)` и обязан вернуть управление немедленно,
+    не дожидаясь выполнения. В приложении это `BackgroundTasks.add_task`
+    FastAPI (задача стартует после отправки ответа), в тестах — вызовы
+    просто записываются. Через него уходит запуск Track Egress: сетевому
+    вызову не место внутри транзакции вебхука (см. `_on_track_published`).
+    """
+
+    def __init__(
+        self,
+        session: AsyncSession,
+        *,
+        schedule: Callable[..., object],
+    ) -> None:
         self._conferences = ConferenceRepository(session)
         self._sessions = ConferenceSessionRepository(session)
         self._audio_tracks = AudioTrackRepository(session)
         self._instance_settings = InstanceSettingsService(session)
+        self._schedule = schedule
 
     async def dispatch(self, event: WebhookEvent) -> None:
         """Обработать одно webhook-событие; неизвестный тип события — no-op."""
@@ -139,6 +155,17 @@ class WebhookDispatcher:
             return
         user_id, guest_id = identity
 
+        # Очередь поднятых рук живёт в Redis по `conference.id`, независимо
+        # от `ConferenceSession` (задача B1) — снимаем руку СРАЗУ, до guard'а
+        # на отсутствующий открытый сеанс ниже: пропущенный/задержанный
+        # `room_started` не должен оставлять фантомную запись в очереди у
+        # реально вышедшего участника. Не путать с обрывом WS-соединения
+        # самой очереди рук — то живёт своей жизнью и переживается без
+        # потери места (см. `services/hand_queue.py`).
+        removed = await hand_queue.lower_hand(conference.id, identity=event.participant.identity)
+        if removed:
+            await hand_queue.publish_snapshot(conference.id)
+
         session_record = await self._sessions.get_open_by_conference(conference.id)
         if session_record is None:
             logger.warning(
@@ -161,15 +188,32 @@ class WebhookDispatcher:
         )
 
     async def _on_track_published(self, event: WebhookEvent) -> None:
-        """Запустить Track Egress для опубликованного аудиотрека микрофона (ADR-002).
+        """Запланировать Track Egress для опубликованного аудиотрека микрофона (ADR-002).
 
         Видео/скриншеринг и т.п. — no-op (диаризация не нужна: транскрибируем
         только речь, трек = спикер). Идемпотентно: если строка трека уже
         существует (гонка повторной доставки), egress повторно не запускается.
+
+        Сам запуск уходит в фоновую задачу (`services.egress.run_track_egress`):
+        здесь остаются только быстрые проверки по БД, потому что обработчик
+        выполняется внутри открытой транзакции вебхука. Обоснование с цифрами —
+        в докстринге `run_track_egress`.
         """
         if event.track.type != TrackType.AUDIO or event.track.source != TrackSource.MICROPHONE:
             return
 
+        # Транскрибация выключена — записывать нечего. Тот же guard, что и в
+        # `_on_room_finished`: без него на инстансе без профиля `transcribe`
+        # (egress-контейнера в деплое нет) каждый микрофон превращался в
+        # заведомо безнадёжный сетевой вызов длиной в 20–25 секунд.
+        cfg = await self._instance_settings.get()
+        if not cfg.transcriber.enabled:
+            logger.debug(
+                "livekit webhook track_published: транскрибация выключена — трек %s пропущен",
+                event.track.sid,
+            )
+            return
+
         conference = await self._conferences.get_by_slug(event.room.name)
         if conference is None:
             logger.warning(
@@ -216,37 +260,13 @@ class WebhookDispatcher:
         filepath = (
             f"{settings.recordings_dir}/{session_record.id}/{participant.id}_{event.track.sid}.ogg"
         )
-        try:
-            result = await start_track_egress(event.room.name, event.track.sid, filepath)
-        except Exception as exc:  # noqa: BLE001 — недоступность egress не должна ронять webhook
-            # Деплой-профиль (блок D): egress — необязательный сервис профиля
-            # `transcribe`; без него запись просто не стартует для этого трека
-            # (риск «Потерян webhook track_published»).
-            # Строку `session_audio_tracks` не создаём — у нас нет `egress_id`,
-            # по которому её мог бы финализировать `egress_ended`.
-            logger.warning(
-                "livekit webhook track_published: не удалось запустить egress для трека %s "
-                "сеанса %s: %s",
-                event.track.sid,
-                session_record.id,
-                exc,
-            )
-            return
-
-        await self._audio_tracks.create(
+        self._schedule(
+            run_track_egress,
+            room_name=event.room.name,
+            track_sid=event.track.sid,
+            filepath=filepath,
             session_id=session_record.id,
             participant_id=participant.id,
-            track_sid=event.track.sid,
-            egress_id=result.egress_id,
-            file_path=filepath,
-            started_at=result.started_at,
-        )
-        logger.info(
-            "livekit webhook track_published: сеанс=%s участник=%s трек=%s egress=%s",
-            session_record.id,
-            participant.id,
-            event.track.sid,
-            result.egress_id,
         )
 
     async def _on_egress_ended(self, event: WebhookEvent) -> None:
@@ -300,6 +320,10 @@ class WebhookDispatcher:
         now = datetime.now(UTC)
         await self._sessions.close(session_record, t_end=now)
         await self._sessions.close_all_open_participants(session_id=session_record.id, left_at=now)
+        # Очередь поднятых рук — состояние звонка, не история; следующий
+        # заход (в т.ч. у закреплённой конференции) должен начинать с чистой
+        # очереди, а не наследовать поднятые руки из прошлого раза.
+        await hand_queue.clear(conference.id)
 
         # Незакреплённая умирает по завершении (история/саммари остаются);
         # закреплённая возвращается в ожидание следующего вхождения (ADR-001, п.2).

backend/tests/test_admin_api.py

@@ -33,7 +33,7 @@ async def _make_user(session: AsyncSession, *, role: str = "user") -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Admin API Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
         role=role,
     )

backend/tests/test_admin_teams.py

@@ -20,7 +20,7 @@ async def _make_user(session: AsyncSession, *, role: str = "user") -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Team API Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
         role=role,
     )

backend/tests/test_auth.py

@@ -9,6 +9,7 @@ from typing import Annotated
 
 import httpx
 import pytest_asyncio
+from argon2 import PasswordHasher
 from fastapi import Depends, FastAPI
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -16,6 +17,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from api.auth import get_auth_service
 from core.db import get_session
 from core.redis import redis_client
+from core.security import needs_rehash
 from models.team import Team
 from models.user import User
 from services.auth import AuthService
@@ -491,3 +493,35 @@ async def test_register_no_reply_to_when_contact_email_disabled(
 
     assert response.status_code == 201, response.text
     assert email_backend.reply_to[-1] is None
+
+
+async def test_login_rehashes_legacy_password(
+    client: httpx.AsyncClient, db_session: AsyncSession, email_backend: _CapturingEmailBackend
+) -> None:
+    """Вход с паролем, захэшированным старыми параметрами, перевыпускает хэш.
+
+    Параметры argon2 зашиты в саму строку хэша, поэтому смена настроек
+    (0.0.17: дефолты библиотеки → рекомендации OWASP) сама по себе не ускоряет
+    проверку уже существующих паролей. Миграция идёт лениво — при первом
+    успешном входе, когда открытый пароль есть на руках.
+    """
+    email = "legacy-hash@example.com"
+    password = "supersecret1"
+    await _register_and_verify(client, email_backend, email=email, password=password)
+
+    # Подменяем хэш на выданный прежними параметрами (t=3, m=64 МБ, p=4).
+    legacy_hash = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4).hash(password)
+    user = await db_session.scalar(select(User).where(User.email == email))
+    assert user is not None
+    user.password_hash = legacy_hash
+    await db_session.commit()
+
+    response = await client.post(
+        "/api/v1/auth/token", data={"username": email, "password": password}
+    )
+    assert response.status_code == 200, response.text
+
+    await db_session.refresh(user)
+    assert user.password_hash != legacy_hash, "старый хэш не был перевыпущен"
+    assert "m=19456" in user.password_hash
+    assert needs_rehash(user.password_hash) is False

backend/tests/test_chat_ws.py

@@ -44,7 +44,7 @@ async def _make_user(session: AsyncSession, *, name: str = "Chat Tester") -> Use
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user=name,
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)
@@ -85,11 +85,19 @@ def _guest_token(conference: Conference, guest: GuestAccess) -> str:
 
 
 async def _connect_and_auth(session: ASGIWebSocketSession, token: str) -> dict[str, Any]:
-    """Подключиться, аутентифицироваться и вернуть первое сообщение (`history`)."""
+    """Подключиться, аутентифицироваться и вернуть первое сообщение (`history`).
+
+    После `history` сервер сразу шлёт снапшот очереди поднятых рук
+    (`{"type":"hand_queue",...}`, задача B1) — здесь он молча вычитывается
+    и отбрасывается, чтобы не путать существующие тесты чата, которым он
+    не интересен (см. `tests/test_hand_queue_ws.py` для тестов самой очереди).
+    """
     accept = await session.connect()
     assert accept["type"] == "websocket.accept"
     await session.send_json({"type": "auth", "token": token})
-    return await session.receive_json()
+    history = await session.receive_json()
+    await session.receive_json()
+    return history
 
 
 # --- Основной сценарий: обмен сообщениями + история -------------------------

backend/tests/test_conference_invitees.py

@@ -19,7 +19,7 @@ async def _make_user(session: AsyncSession) -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Invitee Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)

backend/tests/test_conference_service.py

@@ -25,7 +25,7 @@ async def _make_user(session: AsyncSession, *, name: str = "Service Tester") ->
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user=name,
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)

backend/tests/test_conferences_api.py

@@ -33,7 +33,7 @@ async def _make_user(session: AsyncSession, *, role: str = "user") -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Conference Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
         role=role,
     )
@@ -67,7 +67,7 @@ async def _make_conference(
         status=status,
         is_pinned=is_pinned,
         is_closed=is_closed,
-        password_hash=hash_password(password) if password else None,
+        password_hash=await hash_password(password) if password else None,
         ended_at=ended_at,
         scheduled_at=scheduled_at,
         duration_minutes=duration_minutes,
@@ -573,17 +573,75 @@ async def test_resolve_unknown_returns_uniform_404(client: httpx.AsyncClient) ->
     assert response.json()["detail"] == "not_found"
 
 
-async def test_resolve_is_rate_limited_after_10_requests_per_minute(
-    client: httpx.AsyncClient,
-) -> None:
+def _ip_headers() -> dict[str, str]:
+    """Уникальный `X-Real-IP` на каждый тест.
+
+    Счётчики rate limit живут в Redis 60 секунд и общие для всего инстанса,
+    поэтому без изоляции тесты влияли бы друг на друга через остаточные ключи.
+    Заодно это проверяет, что заголовок вообще читается: раньше ключ строился
+    по `request.client.host`, то есть по адресу nginx, одинаковому для всех.
+    """
+    return {"X-Real-IP": f"198.51.100.{uuid.uuid4().int % 250 + 1}-{uuid.uuid4().hex[:8]}"}
+
+
+async def test_resolve_misses_are_rate_limited(client: httpx.AsyncClient) -> None:
+    """Перебор номера конференции упирается в жёсткий лимит промахов (ADR-001, п.4)."""
+    headers = _ip_headers()
     for _ in range(10):
-        response = await client.get("/api/v1/conferences/resolve", params={"q": "irrelevant-query"})
+        response = await client.get(
+            "/api/v1/conferences/resolve", params={"q": "irrelevant-query"}, headers=headers
+        )
         assert response.status_code == 404
 
-    limited = await client.get("/api/v1/conferences/resolve", params={"q": "irrelevant-query"})
+    limited = await client.get(
+        "/api/v1/conferences/resolve", params={"q": "irrelevant-query"}, headers=headers
+    )
     assert limited.status_code == 429
 
 
+async def test_successful_resolves_are_not_limited_by_miss_counter(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    """Вся конференция может открыть ссылку одновременно (регресс теста 31.07.2026).
+
+    Прежняя схема считала любые запросы с лимитом 10/мин, и одиннадцатый
+    участник получал 429 — фронтенд показывал «Не удалось найти конференцию»
+    для существующей и активной конференции.
+    """
+    conference = await _make_conference(db_session)
+    await db_session.commit()
+    headers = _ip_headers()
+
+    for _ in range(50):
+        response = await client.get(
+            "/api/v1/conferences/resolve", params={"q": conference.slug}, headers=headers
+        )
+        assert response.status_code == 200, response.text
+
+
+async def test_rate_limit_is_per_client_ip(client: httpx.AsyncClient) -> None:
+    """Счётчик привязан к адресу клиента, а не к адресу nginx.
+
+    Исчерпав лимит промахов с одного адреса, с другого по-прежнему можно
+    работать. До исправления ключ был общим на весь инстанс.
+    """
+    first, second = _ip_headers(), _ip_headers()
+    for _ in range(11):
+        await client.get(
+            "/api/v1/conferences/resolve", params={"q": "no-such-conference"}, headers=first
+        )
+
+    exhausted = await client.get(
+        "/api/v1/conferences/resolve", params={"q": "no-such-conference"}, headers=first
+    )
+    assert exhausted.status_code == 429
+
+    other = await client.get(
+        "/api/v1/conferences/resolve", params={"q": "no-such-conference"}, headers=second
+    )
+    assert other.status_code == 404, "лимит одного клиента не должен задевать другого"
+
+
 # --- Вход зарегистрированным пользователем ---------------------------------------
 
 
@@ -708,6 +766,38 @@ async def test_join_metadata_absent_for_user_without_avatar(
     assert "metadata" not in payload
 
 
+async def test_join_metadata_contains_is_organizer_for_owner(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    owner = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    response = await client.post(
+        f"/api/v1/conferences/{conference.id}/join", headers=_auth_headers(owner)
+    )
+    assert response.status_code == 200, response.text
+    payload = _decode_livekit_token(response.json()["token"])
+    metadata = json.loads(str(payload["metadata"]))
+    assert metadata["is_organizer"] is True
+
+
+async def test_join_metadata_absent_is_organizer_for_non_owner(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    owner = await _make_user(db_session)
+    other = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    response = await client.post(
+        f"/api/v1/conferences/{conference.id}/join", headers=_auth_headers(other)
+    )
+    assert response.status_code == 200, response.text
+    payload = _decode_livekit_token(response.json()["token"])
+    assert "metadata" not in payload
+
+
 async def test_guest_join_metadata_is_absent(
     client: httpx.AsyncClient, db_session: AsyncSession
 ) -> None:
@@ -803,21 +893,69 @@ async def test_guest_join_ended_conference_returns_410(
     assert response.json()["detail"] == "conference_ended"
 
 
-async def test_guest_join_is_rate_limited_after_10_requests_per_minute(
+async def test_guest_join_allows_a_whole_conference_to_enter(
     client: httpx.AsyncClient, db_session: AsyncSession
 ) -> None:
+    """Успешные гостевые входы не упираются в лимит промахов.
+
+    На нагрузочном тесте 31.07.2026 конференцию из семи десятков человек не
+    пускало внутрь именно это ограничение — счётчик не различал легитимный
+    массовый вход и перебор.
+    """
     conference = await _make_conference(db_session)
     await db_session.commit()
+    headers = _ip_headers()
+
+    for i in range(30):
+        response = await client.post(
+            f"/api/v1/conferences/{conference.id}/guest-join",
+            json={"display_name": f"Guest {i}"},
+            headers=headers,
+        )
+        assert response.status_code == 200, response.text
+
+
+async def test_guest_join_misses_are_rate_limited(client: httpx.AsyncClient) -> None:
+    """Перебор идентификатора конференции по-прежнему упирается в лимит."""
+    headers = _ip_headers()
+    missing_id = uuid.uuid4()
+
+    for _ in range(10):
+        response = await client.post(
+            f"/api/v1/conferences/{missing_id}/guest-join",
+            json={"display_name": "Bruteforce"},
+            headers=headers,
+        )
+        assert response.status_code == 404
+
+    limited = await client.post(
+        f"/api/v1/conferences/{missing_id}/guest-join",
+        json={"display_name": "Bruteforce"},
+        headers=headers,
+    )
+    assert limited.status_code == 429
+
+
+async def test_guest_join_wrong_password_is_rate_limited(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    """Подбор пароля закрытой конференции считается тем же жёстким счётчиком."""
+    conference = await _make_conference(db_session, is_closed=True, password="right-password")
+    await db_session.commit()
+    headers = _ip_headers()
 
     for _ in range(10):
         response = await client.post(
             f"/api/v1/conferences/{conference.id}/guest-join",
-            json={"display_name": "Repeat Guest"},
+            json={"display_name": "Guesser", "password": "wrong"},
+            headers=headers,
         )
-        assert response.status_code == 200
+        assert response.status_code == 403
 
     limited = await client.post(
-        f"/api/v1/conferences/{conference.id}/guest-join", json={"display_name": "Repeat Guest"}
+        f"/api/v1/conferences/{conference.id}/guest-join",
+        json={"display_name": "Guesser", "password": "wrong"},
+        headers=headers,
     )
     assert limited.status_code == 429
 

backend/tests/test_hand_queue_ws.py

@@ -0,0 +1,272 @@
+"""Тесты очереди поднятых рук поверх WS комнаты (`WS /api/v1/conferences/{id}/chat`, задача B1).
+
+Протокол и аутентификация — общие с чатом (`api/chat.py`), поэтому структура
+тестов и хелперы намеренно зеркалят `tests/test_chat_ws.py`.
+"""
+
+import uuid
+from collections.abc import Callable
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.security import hash_password
+from models.conference import Conference
+from models.guest import GuestAccess
+from models.user import User
+from services.conference_ids import generate_number, generate_slug
+from services.livekit_tokens import create_room_access_token
+from tests.conftest import ASGIWebSocketSession
+
+WSFactory = Callable[[str], ASGIWebSocketSession]
+
+
+# --- Хелперы (см. tests/test_chat_ws.py) ------------------------------------
+
+
+async def _make_user(session: AsyncSession, *, name: str = "Hand Tester") -> User:
+    user = User(
+        email=f"{uuid.uuid4()}@example.com",
+        name_user=name,
+        password_hash=await hash_password("password123"),
+        email_verified=True,
+    )
+    session.add(user)
+    await session.flush()
+    return user
+
+
+async def _make_conference(
+    session: AsyncSession, *, owner_id: uuid.UUID | None = None, status: str = "active"
+) -> Conference:
+    conference = Conference(
+        number=generate_number(),
+        slug=generate_slug(),
+        title="Hand Queue Test",
+        status=status,
+        owner_id=owner_id,
+    )
+    session.add(conference)
+    await session.flush()
+    return conference
+
+
+async def _make_guest(session: AsyncSession, conference: Conference, *, name: str) -> GuestAccess:
+    guest = GuestAccess(conference_id=conference.id, display_name=name)
+    session.add(guest)
+    await session.flush()
+    return guest
+
+
+def _chat_path(conference_id: uuid.UUID) -> str:
+    return f"/api/v1/conferences/{conference_id}/chat"
+
+
+def _user_token(conference: Conference, user: User) -> str:
+    return create_room_access_token(
+        room_name=conference.slug, identity=str(user.id), name=user.name_user
+    )
+
+
+def _guest_token(conference: Conference, guest: GuestAccess) -> str:
+    return create_room_access_token(
+        room_name=conference.slug, identity=f"guest:{guest.id}", name=guest.display_name
+    )
+
+
+async def _connect_auth_and_queue(
+    session: ASGIWebSocketSession, token: str
+) -> dict[str, Any]:
+    """Подключиться, аутентифицироваться, вычитать `history` и вернуть снапшот очереди."""
+    accept = await session.connect()
+    assert accept["type"] == "websocket.accept"
+    await session.send_json({"type": "auth", "token": token})
+    await session.receive_json()  # history — не интересен этим тестам
+    return await session.receive_json()
+
+
+def _identities(queue_frame: dict[str, Any]) -> list[str]:
+    return [entry["identity"] for entry in queue_frame["queue"]]
+
+
+# --- Поднять/опустить свою руку -----------------------------------------------
+
+
+async def test_raise_and_lower_own_hand_broadcasts_to_everyone(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    conference = await _make_conference(db_session)
+    alice = await _make_user(db_session, name="Alice")
+    bob = await _make_user(db_session, name="Bob")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws1 = ws_client(path)
+    await _connect_auth_and_queue(ws1, _user_token(conference, alice))
+    ws2 = ws_client(path)
+    initial2 = await _connect_auth_and_queue(ws2, _user_token(conference, bob))
+    assert initial2 == {"type": "hand_queue", "queue": []}
+
+    await ws1.send_json({"type": "raise_hand"})
+
+    queue1 = await ws1.receive_json()
+    assert _identities(queue1) == [str(alice.id)]
+    assert queue1["queue"][0]["name"] == "Alice"
+    assert queue1["queue"][0]["raised_at"].endswith("Z")
+
+    queue2 = await ws2.receive_json()
+    assert queue2 == queue1
+
+    await ws1.send_json({"type": "lower_hand"})
+    queue1_after = await ws1.receive_json()
+    assert queue1_after == {"type": "hand_queue", "queue": []}
+    queue2_after = await ws2.receive_json()
+    assert queue2_after == queue1_after
+
+
+async def test_raise_hand_order_is_preserved(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    """Порядок в очереди — по времени поднятия, не по алфавиту/подключению."""
+    conference = await _make_conference(db_session)
+    alice = await _make_user(db_session, name="Alice")
+    bob = await _make_user(db_session, name="Bob")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws1 = ws_client(path)
+    await _connect_auth_and_queue(ws1, _user_token(conference, alice))
+    ws2 = ws_client(path)
+    await _connect_auth_and_queue(ws2, _user_token(conference, bob))
+
+    # Боб поднимает руку ПЕРВЫМ, хотя подключился вторым — он и должен
+    # оказаться первым в очереди.
+    await ws2.send_json({"type": "raise_hand"})
+    await ws2.receive_json()
+    await ws1.receive_json()
+
+    await ws1.send_json({"type": "raise_hand"})
+    queue = await ws1.receive_json()
+
+    assert _identities(queue) == [str(bob.id), str(alice.id)]
+
+
+async def test_re_raising_hand_does_not_move_position(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    """Повторное поднятие уже поднятой руки — идемпотентно, место в очереди не меняется."""
+    conference = await _make_conference(db_session)
+    alice = await _make_user(db_session, name="Alice")
+    bob = await _make_user(db_session, name="Bob")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws1 = ws_client(path)
+    await _connect_auth_and_queue(ws1, _user_token(conference, alice))
+    ws2 = ws_client(path)
+    await _connect_auth_and_queue(ws2, _user_token(conference, bob))
+
+    await ws1.send_json({"type": "raise_hand"})
+    first = await ws1.receive_json()
+    await ws2.receive_json()
+
+    await ws2.send_json({"type": "raise_hand"})
+    await ws2.receive_json()
+    await ws1.receive_json()
+
+    # Алиса (уже в очереди первой) поднимает руку ещё раз.
+    await ws1.send_json({"type": "raise_hand"})
+    repeated = await ws1.receive_json()
+    await ws2.receive_json()
+
+    assert _identities(repeated) == [str(alice.id), str(bob.id)]
+    assert repeated["queue"][0]["raised_at"] == first["queue"][0]["raised_at"]
+
+
+async def test_guest_can_raise_hand(db_session: AsyncSession, ws_client: WSFactory) -> None:
+    conference = await _make_conference(db_session)
+    guest = await _make_guest(db_session, conference, name="Guest Carl")
+    await db_session.commit()
+
+    ws = ws_client(_chat_path(conference.id))
+    await _connect_auth_and_queue(ws, _guest_token(conference, guest))
+
+    await ws.send_json({"type": "raise_hand"})
+    queue = await ws.receive_json()
+    assert _identities(queue) == [f"guest:{guest.id}"]
+    assert queue["queue"][0]["name"] == "Guest Carl"
+
+
+# --- Права организатора -------------------------------------------------------
+
+
+async def test_non_organizer_cannot_lower_someone_elses_hand(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    owner = await _make_user(db_session, name="Owner")
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    alice = await _make_user(db_session, name="Alice")
+    bob = await _make_user(db_session, name="Bob")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws1 = ws_client(path)
+    await _connect_auth_and_queue(ws1, _user_token(conference, alice))
+    ws2 = ws_client(path)
+    await _connect_auth_and_queue(ws2, _user_token(conference, bob))
+
+    await ws1.send_json({"type": "raise_hand"})
+    await ws1.receive_json()
+    await ws2.receive_json()
+
+    # Боб (обычный участник, не организатор) пытается опустить руку Алисы.
+    await ws2.send_json({"type": "lower_hand", "identity": str(alice.id)})
+    error = await ws2.receive_json()
+    assert error == {"type": "error", "code": "forbidden"}
+
+
+async def test_organizer_can_lower_someone_elses_hand(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    owner = await _make_user(db_session, name="Owner")
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    alice = await _make_user(db_session, name="Alice")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws_alice = ws_client(path)
+    await _connect_auth_and_queue(ws_alice, _user_token(conference, alice))
+    ws_owner = ws_client(path)
+    await _connect_auth_and_queue(ws_owner, _user_token(conference, owner))
+
+    await ws_alice.send_json({"type": "raise_hand"})
+    await ws_alice.receive_json()
+    await ws_owner.receive_json()
+
+    await ws_owner.send_json({"type": "lower_hand", "identity": str(alice.id)})
+    queue_owner = await ws_owner.receive_json()
+    queue_alice = await ws_alice.receive_json()
+
+    assert queue_owner == {"type": "hand_queue", "queue": []}
+    assert queue_alice == queue_owner
+
+
+async def test_organizer_joining_late_sees_already_raised_hands(
+    db_session: AsyncSession, ws_client: WSFactory
+) -> None:
+    """Организатор зашёл позже, когда руки уже подняты, — видит актуальную очередь сразу."""
+    owner = await _make_user(db_session, name="Owner")
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    alice = await _make_user(db_session, name="Alice")
+    await db_session.commit()
+
+    path = _chat_path(conference.id)
+    ws_alice = ws_client(path)
+    await _connect_auth_and_queue(ws_alice, _user_token(conference, alice))
+    await ws_alice.send_json({"type": "raise_hand"})
+    await ws_alice.receive_json()
+
+    ws_owner = ws_client(path)
+    initial_queue = await _connect_auth_and_queue(ws_owner, _user_token(conference, owner))
+
+    assert _identities(initial_queue) == [str(alice.id)]

backend/tests/test_livekit_webhook.py

@@ -3,9 +3,13 @@
 цикл закреплённой/незакреплённой конференции — на фикстурах payload'ов LiveKit.
 """
 
+import asyncio
 import base64
 import hashlib
+import json
 import uuid
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from unittest.mock import AsyncMock, Mock
@@ -13,10 +17,13 @@ from unittest.mock import AsyncMock, Mock
 import httpx
 import jwt
 import pytest
+from google.protobuf.json_format import ParseDict
+from livekit.protocol.webhook import WebhookEvent
 from sqlalchemy import select
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession
 
+import services.egress as egress_module
 import services.webhook_handlers as webhook_handlers_module
 from core.config import get_settings
 from core.security import hash_password
@@ -27,6 +34,7 @@ from models.instance_setting import InstanceSetting
 from models.participant import ConferenceParticipant
 from models.session import ConferenceSession
 from models.user import User
+from services import hand_queue
 from services.conference_ids import generate_number, generate_slug
 from services.egress import EgressStartResult
 
@@ -54,6 +62,52 @@ def _sign(body: bytes) -> str:
     return jwt.encode(payload, settings.livekit_api_secret, algorithm="HS256")
 
 
+def _parse_fixture_event(name: str, **placeholders: str) -> WebhookEvent:
+    """Разобрать фикстуру в `WebhookEvent` — для тестов диспатчера без HTTP-слоя."""
+    return ParseDict(json.loads(_load_fixture(name, **placeholders)), WebhookEvent())
+
+
+async def _set_transcriber_enabled(session: AsyncSession, *, enabled: bool) -> None:
+    """Выставить `instance_settings.transcriber.enabled`.
+
+    Пишется тем же `db_session` (savepoint), что и обработчик webhook (подмена
+    `get_session` в фикстуре `app`) — видна обработчику без реального коммита
+    в dev-БД. Тесты, которым важен `track_published`, обязаны выставлять флаг
+    ЯВНО: значение в dev-БД непредсказуемо, а обработчик с версии 0.0.12
+    выходит на выключенной транскрибации раньше всех остальных проверок.
+    """
+    value: dict[str, object] = {
+        "enabled": enabled,
+        "provider": "faster_whisper_cpu" if enabled else "null",
+        "model": "small" if enabled else None,
+        "language": "ru",
+        "options": {},
+    }
+    await session.execute(
+        pg_insert(InstanceSetting)
+        .values(key="transcriber", value=value)
+        .on_conflict_do_update(index_elements=["key"], set_={"value": value})
+    )
+
+
+def _use_test_session_in_background(
+    monkeypatch: pytest.MonkeyPatch, db_session: AsyncSession
+) -> None:
+    """Заставить фоновую задачу egress работать с тестовой (savepoint) сессией.
+
+    `run_track_egress` намеренно берёт СВОЮ сессию (`async_session_maker`):
+    в бою сессия запроса к моменту фоновой задачи уже закрыта. В тестах такое
+    подключение шло бы мимо откатываемой транзакции и не увидело бы ни
+    конференции, ни участника — поэтому подменяем фабрику на тестовую сессию.
+    """
+
+    @asynccontextmanager
+    async def _maker() -> AsyncGenerator[AsyncSession, None]:
+        yield db_session
+
+    monkeypatch.setattr(egress_module, "async_session_maker", _maker)
+
+
 async def _post_webhook(client: httpx.AsyncClient, body: bytes) -> httpx.Response:
     return await client.post(
         WEBHOOK_URL,
@@ -77,7 +131,7 @@ async def _make_user(session: AsyncSession, email: str) -> User:
     user = User(
         email=email,
         name_user="Participant",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)
@@ -164,6 +218,53 @@ async def test_full_cycle_joined_left_finished(
     assert conference.ended_at is not None
 
 
+async def test_participant_left_removes_raised_hand_from_queue(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    """Задача B1: участник с поднятой рукой вышел из конференции — рука исчезает из очереди."""
+    conference = await _make_conference(db_session, generate_slug())
+    user = await _make_user(db_session, "webhook-hand-1@example.com")
+    await db_session.commit()
+
+    identity = str(user.id)
+    await hand_queue.raise_hand(conference.id, identity=identity, name=user.name_user)
+    assert [e.identity for e in await hand_queue.snapshot(conference.id)] == [identity]
+
+    left = _load_fixture(
+        "participant_left.json",
+        event_id=f"evt-{uuid.uuid4()}",
+        room_name=conference.slug,
+        identity=identity,
+    )
+    resp = await _post_webhook(client, left)
+    assert resp.status_code == 200
+
+    assert await hand_queue.snapshot(conference.id) == []
+
+
+async def test_room_finished_clears_hand_queue(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    """Задача B1: очередь поднятых рук — состояние звонка, не переживает его завершение."""
+    conference = await _make_conference(db_session, generate_slug())
+    await db_session.commit()
+
+    started = _load_fixture(
+        "room_started.json", event_id=f"evt-{uuid.uuid4()}", room_name=conference.slug
+    )
+    assert (await _post_webhook(client, started)).status_code == 200
+
+    await hand_queue.raise_hand(conference.id, identity="guest:leftover", name="Leftover Guest")
+    assert len(await hand_queue.snapshot(conference.id)) == 1
+
+    finished = _load_fixture(
+        "room_finished.json", event_id=f"evt-{uuid.uuid4()}", room_name=conference.slug
+    )
+    assert (await _post_webhook(client, finished)).status_code == 200
+
+    assert await hand_queue.snapshot(conference.id) == []
+
+
 async def test_pinned_conference_returns_to_scheduled_on_finish(
     client: httpx.AsyncClient, db_session: AsyncSession
 ) -> None:
@@ -319,8 +420,10 @@ async def test_track_published_by_guest_starts_egress_and_creates_track_row(
     mock_start = AsyncMock(
         return_value=EgressStartResult(egress_id="EG_guest_track", started_at=started_at)
     )
-    monkeypatch.setattr(webhook_handlers_module, "start_track_egress", mock_start)
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+    _use_test_session_in_background(monkeypatch, db_session)
 
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     guest = await _make_guest(db_session, conference)
     await db_session.commit()
@@ -382,8 +485,10 @@ async def test_track_published_survives_egress_unavailable(
 ) -> None:
     """Недоступность egress не должна ронять webhook (блок D): 200 + warning, без строки трека."""
     mock_start = AsyncMock(side_effect=RuntimeError("egress service unavailable"))
-    monkeypatch.setattr(webhook_handlers_module, "start_track_egress", mock_start)
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+    _use_test_session_in_background(monkeypatch, db_session)
 
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     user = await _make_user(db_session, "webhook-track-egress-down@example.com")
     await db_session.commit()
@@ -417,13 +522,169 @@ async def test_track_published_survives_egress_unavailable(
     assert tracks == []
 
 
+async def test_track_published_skips_egress_when_transcription_disabled(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Транскрибация выключена → egress не дёргается вовсе (релиз 0.0.12).
+
+    Симметрично guard'у в `_on_room_finished`. Без него на инстансе без профиля
+    `transcribe` (egress-контейнера в деплое нет) каждый микрофонный трек
+    превращался в заведомо безнадёжный вызов длиной в таймаут psrpc LiveKit —
+    20–25 секунд внутри открытой транзакции вебхука. На нагрузочном тесте
+    28.07.2026 это выгребало пул соединений и роняло вход в конференцию в 500.
+    """
+    mock_start = AsyncMock()
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+    _use_test_session_in_background(monkeypatch, db_session)
+
+    await _set_transcriber_enabled(db_session, enabled=False)
+    conference = await _make_conference(db_session, generate_slug())
+    user = await _make_user(db_session, "webhook-track-transcriber-off@example.com")
+    await db_session.commit()
+
+    joined = _load_fixture(
+        "participant_joined.json",
+        event_id=f"evt-{uuid.uuid4()}",
+        room_name=conference.slug,
+        identity=str(user.id),
+    )
+    assert (await _post_webhook(client, joined)).status_code == 200
+
+    track_sid = "TR_transcriber_off"
+    published = _load_fixture(
+        "track_published.json",
+        event_id=f"evt-{uuid.uuid4()}",
+        room_name=conference.slug,
+        identity=str(user.id),
+        track_sid=track_sid,
+    )
+    assert (await _post_webhook(client, published)).status_code == 200
+
+    mock_start.assert_not_awaited()
+    tracks = (
+        await db_session.scalars(
+            select(SessionAudioTrack).where(SessionAudioTrack.track_sid == track_sid)
+        )
+    ).all()
+    assert tracks == []
+
+
+async def test_track_published_does_not_call_egress_inside_transaction(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Запуск egress уходит в фон, а не выполняется внутри обработчика (релиз 0.0.12).
+
+    Проверяется не время ответа (в тестах ASGI-транспорт дожидается фоновых
+    задач), а сама суть: пока открыта транзакция вебхука, сетевого вызова не
+    происходит — обработчик только планирует задачу. Именно это разгружает пул
+    соединений: до правки вызов жил внутри транзакции и держал соединение
+    20–25 секунд, когда egress-сервиса в деплое нет.
+    """
+    mock_start = AsyncMock(
+        return_value=EgressStartResult(egress_id="EG_bg", started_at=datetime.now(UTC))
+    )
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+
+    scheduled: list[tuple[object, dict[str, object]]] = []
+
+    def _schedule(func: object, **kwargs: object) -> None:
+        scheduled.append((func, kwargs))
+
+    await _set_transcriber_enabled(db_session, enabled=True)
+    conference = await _make_conference(db_session, generate_slug())
+    user = await _make_user(db_session, "webhook-track-background@example.com")
+    await db_session.commit()
+
+    dispatcher = webhook_handlers_module.WebhookDispatcher(db_session, schedule=_schedule)
+    joined_event = _parse_fixture_event(
+        "participant_joined.json",
+        event_id=f"evt-{uuid.uuid4()}",
+        room_name=conference.slug,
+        identity=str(user.id),
+    )
+    await dispatcher.dispatch(joined_event)
+
+    track_sid = "TR_background"
+    published_event = _parse_fixture_event(
+        "track_published.json",
+        event_id=f"evt-{uuid.uuid4()}",
+        room_name=conference.slug,
+        identity=str(user.id),
+        track_sid=track_sid,
+    )
+    await dispatcher.dispatch(published_event)
+
+    # Сеть не тронута: обработчик только запланировал задачу.
+    mock_start.assert_not_awaited()
+    assert len(scheduled) == 1
+    func, kwargs = scheduled[0]
+    assert func is egress_module.run_track_egress
+    assert kwargs["room_name"] == conference.slug
+    assert kwargs["track_sid"] == track_sid
+
+    session_record = await db_session.scalar(
+        select(ConferenceSession).where(ConferenceSession.conference_id == conference.id)
+    )
+    assert session_record is not None
+    assert kwargs["session_id"] == session_record.id
+
+    # А вот запущенная задача действительно ходит в egress и пишет строку.
+    _use_test_session_in_background(monkeypatch, db_session)
+    await egress_module.run_track_egress(**kwargs)  # type: ignore[arg-type]
+    mock_start.assert_awaited_once()
+
+    track_row = await db_session.scalar(
+        select(SessionAudioTrack).where(SessionAudioTrack.track_sid == track_sid)
+    )
+    assert track_row is not None
+    assert track_row.egress_id == "EG_bg"
+
+
+async def test_start_track_egress_gives_up_on_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Запуск egress не ждёт дольше `egress_start_timeout_s` (релиз 0.0.12).
+
+    Когда egress-воркера нет, LiveKit держит вызов до собственного таймаута
+    psrpc — на тесте 28.07.2026 это было 20–25 секунд на каждый микрофонный
+    трек. Живой egress отвечает за доли секунды, ждать столько незачем.
+    """
+    settings = get_settings()
+    monkeypatch.setattr(settings, "egress_start_timeout_s", 0.05, raising=False)
+
+    closed = False
+
+    class _HangingEgress:
+        async def start_track_egress(self, _request: object) -> object:
+            await asyncio.sleep(5)
+            raise AssertionError("вызов должен был прерваться по таймауту")
+
+    class _HangingApi:
+        def __init__(self, *_args: object, **_kwargs: object) -> None:
+            self.egress = _HangingEgress()
+
+        async def aclose(self) -> None:
+            nonlocal closed
+            closed = True
+
+    # Строковая форма: `api` в `services.egress` — реэкспорт из livekit SDK,
+    # обращение к нему атрибутом mypy считает неявным экспортом.
+    monkeypatch.setattr("services.egress.api.LiveKitAPI", _HangingApi)
+
+    with pytest.raises(TimeoutError):
+        await egress_module.start_track_egress("room", "TR_hang", "/recordings/x.ogg")
+
+    # Клиент закрывается и на неуспешном пути — иначе утекали бы соединения.
+    assert closed is True
+
+
 async def test_track_published_video_is_noop(
     client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """№9 плана (часть 1): video-трек — no-op, egress не запускается."""
     mock_start = AsyncMock()
-    monkeypatch.setattr(webhook_handlers_module, "start_track_egress", mock_start)
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+    _use_test_session_in_background(monkeypatch, db_session)
 
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     user = await _make_user(db_session, "webhook-track-video@example.com")
     await db_session.commit()
@@ -462,8 +723,10 @@ async def test_track_published_repeated_webhook_creates_single_row(
     mock_start = AsyncMock(
         return_value=EgressStartResult(egress_id="EG_repeat", started_at=datetime.now(UTC))
     )
-    monkeypatch.setattr(webhook_handlers_module, "start_track_egress", mock_start)
+    monkeypatch.setattr(egress_module, "start_track_egress", mock_start)
+    _use_test_session_in_background(monkeypatch, db_session)
 
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     user = await _make_user(db_session, "webhook-track-repeat@example.com")
     await db_session.commit()
@@ -508,6 +771,8 @@ async def test_egress_ended_finalizes_track_success_and_failure(
     client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """№10 плана (часть 1): `egress_ended` — 'recorded' на успехе, 'failed' на ошибке."""
+    _use_test_session_in_background(monkeypatch, db_session)
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     user = await _make_user(db_session, "webhook-egress-ended@example.com")
     await db_session.commit()
@@ -527,7 +792,7 @@ async def test_egress_ended_finalizes_track_success_and_failure(
     # Успешная запись.
     ok_started = datetime.now(UTC)
     monkeypatch.setattr(
-        webhook_handlers_module,
+        egress_module,
         "start_track_egress",
         AsyncMock(return_value=EgressStartResult(egress_id="EG_ok", started_at=ok_started)),
     )
@@ -559,7 +824,7 @@ async def test_egress_ended_finalizes_track_success_and_failure(
 
     # Ошибка записи.
     monkeypatch.setattr(
-        webhook_handlers_module,
+        egress_module,
         "start_track_egress",
         AsyncMock(
             return_value=EgressStartResult(egress_id="EG_fail", started_at=datetime.now(UTC))
@@ -597,6 +862,10 @@ async def test_room_finished_enqueues_pipeline(
     mock_enqueue = Mock()
     monkeypatch.setattr(webhook_handlers_module, "enqueue_pipeline", mock_enqueue)
 
+    # Флаг выставляется явно: `_on_room_finished` ставит задачу в очередь только
+    # при включённой транскрибации, а состояние `instance_settings` в dev-БД
+    # непредсказуемо (тест падал, если в базе оставалось `enabled: false`).
+    await _set_transcriber_enabled(db_session, enabled=True)
     conference = await _make_conference(db_session, generate_slug())
     await db_session.commit()
 

backend/tests/test_mute_participant_api.py

@@ -0,0 +1,245 @@
+"""Тесты `POST /api/v1/conferences/{id}/mute-participant` (задача B2).
+
+`mute_participant_track` (реальный вызов LiveKit `RoomServiceClient`) мокается
+на уровне `services.conferences` — тот же паттерн, что и `start_track_egress`
+в `tests/test_livekit_webhook.py`: сетевой вызов к LiveKit в тестах не нужен,
+важна только бизнес-логика (права, маршрутизация ошибок, broadcast).
+"""
+
+import asyncio
+import uuid
+from typing import Any
+from unittest.mock import AsyncMock
+
+import httpx
+import pytest
+from redis.asyncio.client import PubSub
+from sqlalchemy.ext.asyncio import AsyncSession
+
+import services.conferences as conferences_module
+from core.redis import redis_client
+from core.security import create_access_token, hash_password
+from models.conference import Conference
+from models.user import User
+from services.conference_ids import generate_number, generate_slug
+from services.hand_queue import hand_queue_channel
+from services.room_control import ParticipantNotInRoomError
+
+MUTE_URL = "{base}/mute-participant"
+
+
+async def _receive_within(pubsub: PubSub, *, max_wait: float) -> dict[str, Any] | None:
+    """Дождаться СОДЕРЖАТЕЛЬНОГО сообщения канала в пределах `max_wait` секунд.
+
+    `ignore_subscribe_messages=True` у `get_message` фильтрует служебное
+    подтверждение подписки, но при этом всё равно может вернуть `None` для
+    ЭТОГО конкретного вызова (см. `api/chat.py::_pump_pubsub_to_websocket`,
+    ровно поэтому там `while True: ... if raw is None: continue`) — здесь тот
+    же цикл, но с общим дедлайном вместо бесконечного ожидания.
+    """
+    deadline = asyncio.get_event_loop().time() + max_wait
+    while True:
+        remaining = deadline - asyncio.get_event_loop().time()
+        if remaining <= 0:
+            return None
+        raw: dict[str, Any] | None = await pubsub.get_message(
+            ignore_subscribe_messages=True, timeout=remaining
+        )
+        if raw is not None:
+            return raw
+
+
+async def _make_user(session: AsyncSession, *, role: str = "user") -> User:
+    user = User(
+        email=f"{uuid.uuid4()}@example.com",
+        name_user="Mute Tester",
+        password_hash=await hash_password("password123"),
+        email_verified=True,
+        role=role,
+    )
+    session.add(user)
+    await session.flush()
+    return user
+
+
+async def _make_conference(
+    session: AsyncSession, *, owner_id: uuid.UUID | None = None
+) -> Conference:
+    conference = Conference(
+        number=generate_number(),
+        slug=generate_slug(),
+        title="Mute Test",
+        status="active",
+        owner_id=owner_id,
+    )
+    session.add(conference)
+    await session.flush()
+    return conference
+
+
+def _auth_headers(user: User) -> dict[str, str]:
+    return {"Authorization": f"Bearer {create_access_token(user.id, user.role)}"}
+
+
+def _url(conference_id: uuid.UUID) -> str:
+    return MUTE_URL.format(base=f"/api/v1/conferences/{conference_id}")
+
+
+async def test_owner_can_mute_participant_and_broadcast_is_published(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    owner = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    mock_mute = AsyncMock(return_value=True)
+    monkeypatch.setattr(conferences_module, "mute_participant_track", mock_mute)
+
+    pubsub = redis_client.pubsub()
+    channel = hand_queue_channel(conference.id)
+    await pubsub.subscribe(channel)
+    try:
+        response = await client.post(
+            _url(conference.id),
+            json={"identity": "some-identity", "source": "microphone"},
+            headers=_auth_headers(owner),
+        )
+        assert response.status_code == 200, response.text
+        assert response.json() == {"muted": True}
+        mock_mute.assert_awaited_once_with(
+            conference.slug, identity="some-identity", source="microphone"
+        )
+
+        raw = await _receive_within(pubsub, max_wait=2)
+        assert raw is not None
+        assert raw["data"] == (
+            '{"type":"forced_mute","identity":"some-identity","source":"microphone"}'
+        )
+    finally:
+        await pubsub.unsubscribe(channel)
+        await pubsub.aclose()  # type: ignore[no-untyped-call]
+
+
+async def test_mute_already_off_does_not_broadcast(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Трек не был опубликован (камера/мьют и так выключены, задача A1) — не ошибка.
+
+    Ответ `muted=false` (искомое состояние уже достигнуто), без broadcast'а.
+    """
+    owner = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    monkeypatch.setattr(
+        conferences_module, "mute_participant_track", AsyncMock(return_value=False)
+    )
+
+    pubsub = redis_client.pubsub()
+    channel = hand_queue_channel(conference.id)
+    await pubsub.subscribe(channel)
+    try:
+        response = await client.post(
+            _url(conference.id),
+            json={"identity": "some-identity", "source": "camera"},
+            headers=_auth_headers(owner),
+        )
+        assert response.status_code == 200, response.text
+        assert response.json() == {"muted": False}
+
+        raw = await _receive_within(pubsub, max_wait=0.5)
+        assert raw is None
+    finally:
+        await pubsub.unsubscribe(channel)
+        await pubsub.aclose()  # type: ignore[no-untyped-call]
+
+
+async def test_admin_can_mute_participant_of_someone_elses_conference(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    owner = await _make_user(db_session)
+    admin = await _make_user(db_session, role="admin")
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    monkeypatch.setattr(conferences_module, "mute_participant_track", AsyncMock(return_value=True))
+
+    response = await client.post(
+        _url(conference.id),
+        json={"identity": "some-identity", "source": "microphone"},
+        headers=_auth_headers(admin),
+    )
+    assert response.status_code == 200, response.text
+
+
+async def test_regular_participant_cannot_mute_someone_else(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    owner = await _make_user(db_session)
+    other = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    mock_mute = AsyncMock()
+    monkeypatch.setattr(conferences_module, "mute_participant_track", mock_mute)
+
+    response = await client.post(
+        _url(conference.id),
+        json={"identity": str(owner.id), "source": "microphone"},
+        headers=_auth_headers(other),
+    )
+    assert response.status_code == 403
+    assert response.json()["detail"] == "not_owner"
+    mock_mute.assert_not_awaited()
+
+
+async def test_mute_conference_not_found(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    user = await _make_user(db_session)
+    await db_session.commit()
+
+    response = await client.post(
+        _url(uuid.uuid4()),
+        json={"identity": "some-identity", "source": "microphone"},
+        headers=_auth_headers(user),
+    )
+    assert response.status_code == 404
+    assert response.json()["detail"] == "conference_not_found"
+
+
+async def test_mute_participant_not_in_room_returns_404(
+    client: httpx.AsyncClient, db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    owner = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    monkeypatch.setattr(
+        conferences_module,
+        "mute_participant_track",
+        AsyncMock(side_effect=ParticipantNotInRoomError()),
+    )
+
+    response = await client.post(
+        _url(conference.id),
+        json={"identity": "ghost", "source": "microphone"},
+        headers=_auth_headers(owner),
+    )
+    assert response.status_code == 404
+    assert response.json()["detail"] == "participant_not_in_room"
+
+
+async def test_mute_rejects_invalid_source(
+    client: httpx.AsyncClient, db_session: AsyncSession
+) -> None:
+    owner = await _make_user(db_session)
+    conference = await _make_conference(db_session, owner_id=owner.id)
+    await db_session.commit()
+
+    response = await client.post(
+        _url(conference.id),
+        json={"identity": "some-identity", "source": "screen_share"},
+        headers=_auth_headers(owner),
+    )
+    assert response.status_code == 422

backend/tests/test_password_hashing.py

@@ -0,0 +1,128 @@
+"""Проверка пароля не должна блокировать event loop (регресс после теста 31.07.2026).
+
+Синхронный `verify_password` останавливал весь процесс backend на 95–155 мс.
+При массовом входе (около 70 человек разом) это давало p95 логина 7.28 секунды,
+33 соединения к БД в состоянии `idle in transaction` при одном активном запросе
+и отказы на посторонних ручках — включая вход в конференцию, где пароль вообще
+не проверялся. Разбор — `.forcc/LOGIN-BOTTLENECK.md`.
+
+Тесты ниже проверяют не скорость (она зависит от железа), а **свойства**:
+event loop остаётся живым, проверки идут параллельно, старые хэши мигрируют.
+"""
+
+import asyncio
+import time
+
+from argon2 import PasswordHasher
+
+from core.security import hash_password, needs_rehash, verify_password
+
+PASSWORD = "correct-horse-battery-staple"
+
+
+async def test_verify_password_does_not_block_event_loop() -> None:
+    """Пока считается argon2, event loop продолжает обслуживать другие задачи.
+
+    Это главное свойство правки. Фоновая корутина тикает каждую миллисекунду;
+    если проверка пароля выполняется синхронно в loop, тиков за её время будет
+    ноль или единицы — именно так и вело себя приложение до исправления.
+    """
+    password_hash = await hash_password(PASSWORD)
+
+    ticks = 0
+    stop = False
+
+    async def ticker() -> None:
+        nonlocal ticks
+        while not stop:
+            ticks += 1
+            await asyncio.sleep(0.001)
+
+    ticker_task = asyncio.create_task(ticker())
+    await asyncio.sleep(0.005)  # даём тикеру стартовать
+
+    ticks_before = ticks
+    assert await verify_password(PASSWORD, password_hash) is True
+    ticks_during = ticks - ticks_before
+
+    stop = True
+    await ticker_task
+
+    # Даже на быстром железе argon2 занимает десятки миллисекунд — за это время
+    # loop обязан прокрутить заметное число тиков. Порог намеренно щадящий:
+    # при блокировке тиков будет 0–1, а не «мало».
+    assert ticks_during >= 5, (
+        f"event loop простоял во время проверки пароля: {ticks_during} тиков — "
+        "похоже, argon2 снова считается синхронно"
+    )
+
+
+async def test_parallel_verifications_are_concurrent() -> None:
+    """Параллельные проверки идут одновременно, а не выстраиваются в очередь.
+
+    argon2-cffi — C-расширение и освобождает GIL, поэтому пул потоков даёт
+    настоящий параллелизм. Проверяем, что 8 проверок занимают заметно меньше,
+    чем 8 последовательных: иначе массовый вход снова упрётся в сериализацию.
+    """
+    password_hash = await hash_password(PASSWORD)
+
+    start = time.perf_counter()
+    await verify_password(PASSWORD, password_hash)
+    single = time.perf_counter() - start
+
+    start = time.perf_counter()
+    results = await asyncio.gather(*(verify_password(PASSWORD, password_hash) for _ in range(8)))
+    parallel = time.perf_counter() - start
+
+    assert all(results)
+    # На 4-ядерном сервере 8 проверок идеально легли бы в 2×single; берём 5×
+    # с большим запасом на шум CI и разное железо — важно лишь то, что это
+    # НЕ 8× (последовательное выполнение).
+    assert parallel < single * 5, (
+        f"8 параллельных проверок заняли {parallel:.3f} с при {single:.3f} с на одну — "
+        "похоже, они выполняются последовательно"
+    )
+
+
+async def test_wrong_password_is_rejected() -> None:
+    """Асинхронная обёртка не сломала саму проверку."""
+    password_hash = await hash_password(PASSWORD)
+    assert await verify_password(PASSWORD, password_hash) is True
+    assert await verify_password("wrong-password", password_hash) is False
+
+
+async def test_hasher_uses_owasp_parameters() -> None:
+    """Параметры argon2id — по рекомендации OWASP, а не дефолт библиотеки.
+
+    Дефолт argon2-cffi (t=3, m=64 МБ, p=4) стоил 95 мс на проверку, причём
+    `parallelism=4` занимал все четыре ядра сервера — те же, на которых
+    работает LiveKit.
+    """
+    password_hash = await hash_password(PASSWORD)
+    # Параметры зашиты в саму строку хэша: $argon2id$v=19$m=19456,t=2,p=1$...
+    assert "m=19456" in password_hash
+    assert "t=2" in password_hash
+    assert "p=1" in password_hash
+
+
+async def test_legacy_hash_is_verified_and_marked_for_rehash() -> None:
+    """Хэш со старыми параметрами проверяется, но помечается на перевыпуск.
+
+    Гарантия обратной совместимости: пароли, выданные до смены параметров,
+    продолжают работать. `AuthService.login` перевыпускает такой хэш при
+    первом же успешном входе — другого момента, когда открытый пароль есть
+    на руках, не будет.
+    """
+    legacy_hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
+    legacy_hash = legacy_hasher.hash(PASSWORD)
+
+    assert await verify_password(PASSWORD, legacy_hash) is True
+    assert needs_rehash(legacy_hash) is True
+
+    fresh_hash = await hash_password(PASSWORD)
+    assert needs_rehash(fresh_hash) is False
+
+
+async def test_broken_hash_is_marked_for_rehash() -> None:
+    """Мусор вместо хэша не роняет вход, а помечается на замену."""
+    assert needs_rehash("not-a-valid-argon2-hash") is True

backend/tests/test_rbac.py

@@ -20,7 +20,7 @@ async def _make_user(session: AsyncSession, *, role: str = "user") -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Test User",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         role=role,
         email_verified=True,
     )

backend/tests/test_teams_api.py

@@ -18,7 +18,7 @@ async def _make_user(session: AsyncSession) -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="Teams API Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)

backend/tests/test_users_api.py

@@ -24,7 +24,7 @@ async def _make_user(session: AsyncSession) -> User:
     user = User(
         email=f"{uuid.uuid4()}@example.com",
         name_user="List Tester",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     session.add(user)
@@ -98,7 +98,7 @@ async def test_get_me_with_reserved_tld_email_does_not_500(
     user = User(
         email=legacy_email,
         name_user="Legacy Admin",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
         role="admin",
     )
@@ -380,7 +380,7 @@ async def test_list_users_search_by_q_filters_by_name_or_email(
     match = User(
         email=f"{unique_marker}@example.com",
         name_user=f"Findable {unique_marker}",
-        password_hash=hash_password("password123"),
+        password_hash=await hash_password("password123"),
         email_verified=True,
     )
     db_session.add(match)

deploy/docker-compose.yml

@@ -1,10 +1,17 @@
 name: vidconf
 
+# Глубина логов рассчитана на РАЗБОР ИНЦИДЕНТОВ, а не только на просмотр
+# последних сообщений. При 10 МБ × 3 (прежнее значение) логи LiveKit на
+# конференции в полсотни человек перезаписывались за часы — а именно по ним
+# восстанавливаются вещи, которых нет в метриках: сколько камер было включено
+# одновременно, кого и почему отключило, какие события congestion шли.
+# 50 МБ × 5 = 250 МБ на контейнер; на сервере с 15 ГБ свободного места это
+# незаметно, зато ретроспектива живёт неделями.
 x-logging: &default-logging
   driver: json-file
   options:
-    max-size: "10m"
-    max-file: "3"
+    max-size: "50m"
+    max-file: "5"
 
 services:
   postgres:
@@ -82,7 +89,12 @@ services:
       MEDIA_ROOT: ${MEDIA_ROOT:-/app/media}
       # Версия инстанса (релиз v0.0.1) — install.sh копирует значение
       # из файла VERSION (корень репозитория) в .env; отдаётся в GET /api/health.
-      VIDCONF_VERSION: ${VIDCONF_VERSION:-0.0.10}
+      VIDCONF_VERSION: ${VIDCONF_VERSION:-0.0.18}
+      # Число процессов uvicorn (см. backend/Dockerfile). Дефолт 2 рассчитан
+      # на 4-ядерный сервер, где ядра делятся с LiveKit. Поднимая значение,
+      # проверьте бюджет соединений с БД: каждый воркер держит свой пул
+      # (DB_POOL_SIZE + DB_MAX_OVERFLOW), а у Postgres есть max_connections.
+      UVICORN_WORKERS: ${UVICORN_WORKERS:-2}
     # config/ лежит в корне репозитория и не попадает в образ (контекст сборки —
     # только backend/), поэтому plugins.yaml монтируется отдельно.
     volumes:
@@ -120,7 +132,13 @@ services:
       context: ../backend
       dockerfile: Dockerfile
     restart: unless-stopped
-    command: ["uv", "run", "celery", "-A", "workers.celery_app", "worker", "-B",
+    # `--no-sync` во ВСЕХ вызовах `uv run` в этом файле: окружение собрано на
+    # этапе build образа (`uv sync --frozen --no-dev`, backend/Dockerfile), а
+    # без флага `uv run` синхронизирует venv заново при каждом запуске — и
+    # тянет dev-группу (ruff, mypy, pytest), которой в проде делать нечего.
+    # Для healthcheck'ов это особенно дорого: они дёргаются каждые 15 секунд
+    # всю жизнь контейнера.
+    command: ["uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "worker", "-B",
                "-Q", "celery,summarize,notify", "--loglevel=info"]
     env_file:
       - ../.env
@@ -147,7 +165,7 @@ services:
     # нет HTTP-сервера на 8000. Проверяем воркер через `celery ... inspect
     # ping`, как рекомендует документация Celery.
     healthcheck:
-      test: ["CMD", "uv", "run", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5"]
+      test: ["CMD", "uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5"]
       interval: 15s
       timeout: 10s
       retries: 5
@@ -181,7 +199,7 @@ services:
     build:
       context: ../backend
       dockerfile: Dockerfile
-    entrypoint: ["uv", "run", "python", "/download-model.py"]
+    entrypoint: ["uv", "run", "--no-sync", "python", "/download-model.py"]
     environment:
       WHISPER_MODEL: ${WHISPER_MODEL:-small}
       WHISPER_MODELS_ROOT: /models/whisper
@@ -216,7 +234,7 @@ services:
     # `worker`, и `celery inspect ping` без `--destination` опросит ВЕСЬ
     # кластер — упавший worker-transcriber остался бы "healthy", потому что
     # ответил бы базовый worker.
-    command: ["uv", "run", "celery", "-A", "workers.celery_app", "worker",
+    command: ["uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "worker",
                "-Q", "transcription", "--pool=solo", "--concurrency=1",
                "--hostname=worker-transcriber@localhost", "--loglevel=info"]
     env_file:
@@ -247,7 +265,7 @@ services:
     # HTTP-эндпоинта нет — пинг celery, но именно этого узла (см. --hostname
     # в command выше), а не первого ответившего в общем кластере.
     healthcheck:
-      test: ["CMD", "uv", "run", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5", "--destination", "worker-transcriber@localhost"]
+      test: ["CMD", "uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5", "--destination", "worker-transcriber@localhost"]
       interval: 15s
       timeout: 10s
       retries: 5
@@ -272,7 +290,7 @@ services:
       args:
         WITH_GPU_EXTRA: "true"
     restart: unless-stopped
-    command: ["uv", "run", "celery", "-A", "workers.celery_app", "worker",
+    command: ["uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "worker",
                "-Q", "transcription", "--pool=solo", "--concurrency=1",
                "--hostname=worker-transcriber-gpu@localhost", "--loglevel=info"]
     env_file:
@@ -305,7 +323,7 @@ services:
       whisper-model-init:
         condition: service_completed_successfully
     healthcheck:
-      test: ["CMD", "uv", "run", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5", "--destination", "worker-transcriber-gpu@localhost"]
+      test: ["CMD", "uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "inspect", "ping", "--timeout", "5", "--destination", "worker-transcriber-gpu@localhost"]
       interval: 15s
       timeout: 10s
       retries: 5
@@ -653,10 +671,26 @@ services:
     # Тег закреплён по версии (не `:latest`) — та же причина, что и у llm-образов.
     image: prom/prometheus:v3.13.1
     restart: unless-stopped
+    # Первые два флага — дефолт образа; повторяем их явно, потому что
+    # `command` перекрывает CMD целиком. Третий — срок хранения: дефолтных
+    # 15 суток мало, когда нагрузку набирают неделями (наблюдение за
+    # реальными конференциями вместо разового теста), и разбирать её потом
+    # приходится задним числом. 30 суток при нынешних 100 МБ TSDB стоят
+    # копеек — база растёт медленнее, чем кажется.
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--storage.tsdb.retention.time=30d'
     volumes:
       - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
       - ./monitoring/alerts.yml:/etc/prometheus/alerts.yml:ro
       - prometheus_data:/prometheus
+    # node-exporter живёт в host-сети (см. комментарий у него) и по имени
+    # сервиса в docker-сети больше не резолвится. `host-gateway` — штатный
+    # способ дать контейнеру адрес хоста, не завязываясь на конкретный IP
+    # docker-моста.
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
     # Loopback-only: админ-доступ по ssh-туннелю, наружу не публикуется.
     ports:
       - "127.0.0.1:9090:9090"
@@ -706,13 +740,27 @@ services:
 
   node-exporter:
     # Метрики железа хоста (CPU, память, диск, сеть, load average) — то,
-    # чего нет ни в одном из приложенческих экспортеров выше. Без
-    # `network_mode: host` (не нужен: читаем /proc,/sys,/ хоста через
-    # bind-mount, а Prometheus достаёт их по имени сервиса во внутренней
-    # сети compose — так безопаснее, не расширяет сетевой доступ контейнера).
+    # чего нет ни в одном из приложенческих экспортеров выше.
+    #
+    # `network_mode: host` ОБЯЗАТЕЛЕН, и вот почему (проверено 2026-07-28,
+    # до этого экспортер работал в bridge-сети и отдавал неверные данные).
+    # Bind-mount'а `/proc` достаточно для CPU, памяти и диска, но НЕ для сети:
+    # `/proc/net` — это симлинк на `self/net`, который резолвится в сетевом
+    # namespace ЧИТАЮЩЕГО процесса. В bridge-сети экспортер видел собственные
+    # `lo` и `eth0` (56 МБ трафика) вместо хостового `enp3s0` (39.8 ГБ), то
+    # есть `node_network_*` показывал трафик контейнера, а не сервера. При
+    # разборе нагрузочного теста 28.07 сетевых метрик хоста не оказалось
+    # вовсе — см. .forcc/LOAD-FINDINGS.md.
+    #
+    # Порт 9100 при этом слушается на хосте. Наружу он не торчит: ufw
+    # пропускает только 22/80/443/3478/7881/51820 и UDP-диапазон LiveKit
+    # (проверено `ufw status`). Prometheus обращается к нему через
+    # `host.docker.internal` (см. `extra_hosts` у сервиса prometheus и
+    # таргет `node` в deploy/monitoring/prometheus.yml).
     image: prom/node-exporter:v1.8.2
     restart: unless-stopped
     pid: host
+    network_mode: host
     volumes:
       - /proc:/host/proc:ro
       - /sys:/host/sys:ro
@@ -722,9 +770,8 @@ services:
       - '--path.sysfs=/host/sys'
       - '--path.rootfs=/rootfs'
       - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
-    # Не публикуем порт наружу вообще (не 127.0.0.1:9100, а совсем без
-    # ports) — Prometheus ходит к нему по внутренней сети compose
-    # (`node-exporter:9100`), публикация на хост для этого не нужна.
+    # Секции `ports` нет и с host-сетью быть не может: контейнер слушает
+    # прямо на интерфейсах хоста. От внешнего мира порт закрывает ufw.
     healthcheck:
       test: ["CMD-SHELL", "wget -q -O- http://127.0.0.1:9100/metrics >/dev/null || exit 1"]
       interval: 10s

deploy/livekit/livekit.yaml.template

@@ -32,6 +32,40 @@ rtc:
   use_external_ip: ${LIVEKIT_USE_EXTERNAL_IP}
   node_ip: ${LIVEKIT_NODE_IP}
 
+  # Внешний TURN (сервис coturn, профиль `media`) — АНОНС КЛИЕНТАМ.
+  # Сам SFU через эти серверы не ходит: LiveKit лишь отдаёт их браузеру в
+  # списке ICE-серверов при подключении (см. iceServersForParticipant в
+  # pkg/service/roommanager.go), а клиент уже решает, нужен ли ему relay.
+  #
+  # Зачем. До 28.07.2026 coturn работал, но КЛИЕНТЫ О НЁМ НЕ ЗНАЛИ: секция
+  # `turn` ниже выключена (встроенный TURN не поднимаем), внешний в конфиге
+  # объявлен не был, а фронтенд `iceServers` не задаёт. За всё время работы
+  # в логах coturn — ноль ALLOCATE. Итог: у клиентов из сетей с жёстким NAT
+  # не было relay-фолбэка вообще, только прямой UDP и TCP 7881. Именно так
+  # объясняются `PEER_CONNECTION_DISCONNECTED` на нагрузочном тесте — все
+  # у внешних участников, ни одного у офисных (.forcc/LOAD-FINDINGS.md,
+  # причина C).
+  #
+  # `secret` обязан совпадать с `static-auth-secret` в turnserver.conf —
+  # оба рендерятся из одного TURN_STATIC_AUTH_SECRET (deploy/render-templates.sh).
+  # Логин/пароль LiveKit генерирует сам по механизму TURN REST API.
+  #
+  # UDP и TCP на 3478 — оба порта уже открыты в ufw. TLS (5349) намеренно не
+  # объявляем: в turnserver.conf сертификаты не смонтированы, и анонс
+  # неработающего `turns:` заставил бы клиента впустую ждать таймаута,
+  # прежде чем перейти к рабочему кандидату.
+  turn_servers:
+    - host: ${TURN_EXTERNAL_IP}
+      port: 3478
+      protocol: udp
+      secret: ${TURN_STATIC_AUTH_SECRET}
+      ttl: 14400
+    - host: ${TURN_EXTERNAL_IP}
+      port: 3478
+      protocol: tcp
+      secret: ${TURN_STATIC_AUTH_SECRET}
+      ttl: 14400
+
 # Redis обязателен для сервиса egress (см. deploy/egress/) — он использует
 # его как pub/sub и key-value хранилище состояния запущенных записей;
 # без него egress не может получать room/track-события от LiveKit

deploy/monitoring/prometheus.yml

@@ -38,9 +38,16 @@ scrape_configs:
   # — сервис node-exporter). Единственный источник, который покажет
   # нехватку памяти/CPU на сервере, если она не проявится как рост
   # латентности API (см. дашборд host.json).
+  #
+  # Адрес `host.docker.internal`, а не `node-exporter:9100`: с 2026-07-28
+  # экспортер работает в host-сети и по имени сервиса в docker-сети не
+  # резолвится. Причина перевода — сетевые метрики: `/proc/net` это симлинк
+  # на `self/net`, поэтому в bridge-сети экспортер отдавал трафик
+  # собственного `eth0` вместо хостового `enp3s0`. Имя резолвится через
+  # `extra_hosts: host-gateway` у сервиса prometheus (deploy/docker-compose.yml).
   - job_name: node
     static_configs:
-      - targets: ["node-exporter:9100"]
+      - targets: ["host.docker.internal:9100"]
 
   # Метрики по каждому контейнеру (CPU/память/сеть отдельно у backend,
   # worker, postgres и т.д. — профиль monitoring, сервис
@@ -53,6 +60,32 @@ scrape_configs:
     static_configs:
       - targets: ["container-exporter:9419"]
 
+  # LiveKit SFU (профиль `media`). Порт объявлен в самом LiveKit —
+  # `deploy/livekit/livekit.yaml.template`, секция `prometheus: port: 6789`;
+  # наружу он не публикуется, скрейп идёт по имени сервиса внутри docker-сети.
+  #
+  # Почему это важно отдельно от `container-exporter`: тот показывает CPU,
+  # память и суммарный трафик контейнера, но ничего не знает о том, ЧТО внутри
+  # этого трафика. Разбор нагрузочного теста 28.07.2026 пришлось делать по
+  # логам именно потому, что job'а здесь не было (см. .forcc/LOAD-FINDINGS.md).
+  #
+  # Ключевое, что отсюда появляется:
+  #   livekit_track_subscribed_total / livekit_track_published_total —
+  #     подписки против публикаций, то есть прямой эффект adaptiveStream;
+  #   livekit_participant_total, livekit_room_total — нагрузка в участниках;
+  #   livekit_quality_score, livekit_packet_loss_percent, livekit_rtt_ms,
+  #     livekit_jitter_us, livekit_nack_total, livekit_pli_total — качество
+  #     связи у клиентов, а не догадки по событиям congestion в логах;
+  #   livekit_webhook_queue_length, livekit_webhook_dispatch_total — очередь
+  #     доставки вебхуков в backend (на тесте она росла до 56 секунд).
+  #
+  # Профиль `media` входит в дефолтный набор COMPOSE_PROFILES (см. .env.example),
+  # поэтому job включён, а не закомментирован, как `llm`. На инсталляции без
+  # профиля `media` таргет не резолвится — закомментируйте секцию.
+  - job_name: livekit
+    static_configs:
+      - targets: ["livekit:6789"]
+
   # Локальный LLM-сервер (llama.cpp, LLAMA_ARG_ENDPOINT_METRICS=1). Адрес
   # `llm:8080` разрешается ОДНИМ из двух compose-сервисов в зависимости от
   # выбранного при установке пресета — `llm` (CPU, профиль `llm`, уровни

deploy/render-templates.sh

@@ -49,7 +49,10 @@ envsubst '${TURN_STATIC_AUTH_SECRET} ${TURN_REALM} ${TURN_EXTERNAL_IP}' \
     < "$SCRIPT_DIR/coturn/turnserver.conf.template" > "$SCRIPT_DIR/coturn/turnserver.conf"
 echo "[render] deploy/coturn/turnserver.conf готов"
 
-envsubst '${LIVEKIT_USE_EXTERNAL_IP} ${LIVEKIT_NODE_IP} ${LIVEKIT_API_KEY} ${REDIS_PASSWORD}' \
+# TURN_EXTERNAL_IP и TURN_STATIC_AUTH_SECRET нужны и здесь: с 0.0.14 LiveKit
+# анонсирует клиентам внешний coturn (секция `rtc.turn_servers`), и секрет
+# обязан совпадать с `static-auth-secret` в turnserver.conf выше.
+envsubst '${LIVEKIT_USE_EXTERNAL_IP} ${LIVEKIT_NODE_IP} ${LIVEKIT_API_KEY} ${REDIS_PASSWORD} ${TURN_EXTERNAL_IP} ${TURN_STATIC_AUTH_SECRET}' \
     < "$SCRIPT_DIR/livekit/livekit.yaml.template" > "$SCRIPT_DIR/livekit/livekit.yaml"
 echo "[render] deploy/livekit/livekit.yaml готов"
 

docs/deploy/DEPLOYMENT.md

@@ -82,9 +82,25 @@ ufw allow 80/tcp     # HTTP (редирект на HTTPS + ACME-challenge)
 ufw allow 443/tcp    # HTTPS
 ufw allow 7881/tcp   # LiveKit RTC TCP fallback (профиль media)
 ufw allow 54000:54100/udp   # LiveKit WebRTC media (ICE), см. docker-compose.yml
-# TURN (coturn) — только если включаете раздел 8:
+# TURN (coturn) — только если включаете раздел 8. Нужны ОБА пункта:
+# сигнальные порты И диапазон relay-аллокаций (min-port/max-port из
+# deploy/coturn/turnserver.conf). Без второго TURN отвечает на запросы, но
+# сам релей не работает — клиент получает кандидата и не может им
+# воспользоваться, а в логах coturn при этом тишина.
 # ufw allow 3478/tcp
 # ufw allow 3478/udp
+# ufw allow 49160:49200/udp
+
+# Мониторинг (профиль `monitoring`): node-exporter работает в host-сети —
+# иначе он отдаёт сетевые метрики собственного контейнера вместо метрик
+# сервера (`/proc/net` — симлинк на `self/net`, bind-mount `/proc` этого не
+# обходит; см. комментарий у сервиса в deploy/docker-compose.yml). Порт
+# слушается на хосте, поэтому Prometheus в docker-сети упирается в
+# политику ufw по умолчанию. Правило разрешает скрейп ТОЛЬКО из внутренних
+# docker-подсетей — снаружи 9100 остаётся закрыт (172.16.0.0/12 не
+# маршрутизируется в интернете):
+ufw allow from 172.16.0.0/12 to any port 9100 proto tcp comment 'node-exporter: скрейп Prometheus из docker-сети'
+
 ufw enable
 ```
 
@@ -309,29 +325,48 @@ firewall) хватает для подавляющего большинства
 (характерный симптом — конференция подключается по signaling, `connection
 state: connected`, но собеседник не видит видео/не слышит звук).
 
-По умолчанию `deploy/livekit/livekit.yaml.template` содержит
-`turn.enabled: false`, и `rtc.turn_servers` не задан — standalone coturn
-поднимается (профиль `media`), но LiveKit не раздаёт его клиентам как
-ICE-фолбэк.
+**С версии 0.0.14 LiveKit анонсирует coturn клиентам** — секция
+`rtc.turn_servers` в `deploy/livekit/livekit.yaml.template` (UDP и TCP на
+3478, credentials по механизму TURN REST API из общего
+`TURN_STATIC_AUTH_SECRET`). Встроенный TURN LiveKit при этом остаётся
+выключенным (`turn.enabled: false`), чтобы не поднимать два TURN-сервера.
 
-Включение (правки шаблона `deploy/livekit/livekit.yaml.template` +
-редеплой; **код-фикс не входит в это руководство без запроса** — обсудите
-с командой перед изменением):
+⚠️ **Чем это было до 0.0.14, если вы обновляетесь со старой версии.** coturn
+поднимался и был healthy, но клиенты о нём не знали: в конфиге LiveKit
+внешний TURN объявлен не был, а фронтенд `iceServers` не задаёт. За всё
+время работы в логах coturn не было ни одного ALLOCATE — то есть relay не
+использовался никогда, и участники из сетей с жёстким NAT просто теряли
+соединение (`PEER_CONNECTION_DISCONNECTED`).
 
-1. Открыть 443 для TURN/TLS (наиболее надёжный фолбэк — TURN через тот же
-   порт, что и остальной HTTPS-трафик, редко блокируется firewall'ами):
-   потребует отдельного TLS-сертификата для coturn (`cert-file`/`pkey-file`
-   в `deploy/coturn/turnserver.conf.template`) — можно переиспользовать тот
-   же Let's Encrypt сертификат, что и nginx (тот же `/etc/letsencrypt`, уже
-   смонтированный в nginx — coturn сейчас его не монтирует, потребуется
-   доп. volume).
-2. В `livekit.yaml.template` включить `turn.enabled: true` и/или явно
-   прописать `rtc.turn_servers` со статическими credentials
-   (`TURN_STATIC_AUTH_SECRET` уже есть в `.env`).
-3. `ufw allow 3478/tcp` + `ufw allow 3478/udp` (шаг 1, закомментированные
-   строки) — сейчас coturn поднят, но порт не проверялся как обязательный.
-4. Передеплой (`docker compose ... up -d --force-recreate livekit coturn`)
-   и повторный кросс-сетевой тест именно с проблемной сетью.
+Что нужно проверить на своей инсталляции:
+
+1. **Порты в ufw — оба пункта** (см. шаг 1): `3478/tcp` + `3478/udp` для
+   сигнализации и `49160:49200/udp` для relay-аллокаций. Диапазон должен
+   совпадать с `min-port`/`max-port` в
+   `deploy/coturn/turnserver.conf.template`. Без него TURN отвечает на
+   запросы, но релей не работает — самый неприятный вариант, потому что в
+   логах coturn при этом тишина.
+2. **`TURN_EXTERNAL_IP` в `.env`** — реальный внешний IP или домен сервера.
+   Именно это значение уезжает клиентам как адрес TURN-сервера, поэтому
+   `127.0.0.1` из dev-дефолта сделает анонс бесполезным.
+3. После правок — `./deploy/render-templates.sh` (перерендерит конфиги из
+   шаблонов), затем `docker compose ... up -d --force-recreate livekit`.
+   ⚠️ Перезапуск LiveKit **разрывает все активные конференции** — выбирайте
+   окно.
+4. Проверка, что релей заработал: провести звонок из проблемной сети и
+   убедиться, что в логах появились аллокации:
+   `docker logs vidconf-coturn-1 --since 10m 2>&1 | grep -ci allocate`.
+   Ноль при живом звонке из-за NAT означает, что до coturn не дошли —
+   смотрите ufw и `TURN_EXTERNAL_IP`.
+
+**TURN over TLS (порт 5349 или 443) — не настроен.** Это самый надёжный
+фолбэк (проходит там, где режут UDP и нестандартные порты), но требует
+смонтировать в coturn TLS-сертификат: раскомментировать `cert`/`pkey` в
+`deploy/coturn/turnserver.conf.template`, добавить volume с
+`/etc/letsencrypt` (nginx его уже монтирует, coturn — нет), открыть порт и
+не забыть про перезапуск coturn при обновлении сертификата. Пока этого нет,
+`turns:` намеренно не анонсируется: анонс неработающего адреса заставил бы
+клиента ждать таймаута перед переходом к рабочему кандидату.
 
 ---
 
@@ -389,7 +424,7 @@ docker exec vidconf-postgres-1 pg_dump -U vidconf vidconf | gzip > db-$(date +%F
 ```bash
 gunzip -c db-2026-07-25.sql.gz | docker exec -i vidconf-postgres-1 psql -U vidconf vidconf
 # Догнать миграции, если бэкап снят на более старой версии кода:
-docker compose -f deploy/docker-compose.yml --env-file .env run --rm backend uv run alembic upgrade head
+docker compose -f deploy/docker-compose.yml --env-file .env run --rm backend uv run --no-sync alembic upgrade head
 docker compose -f deploy/docker-compose.yml --env-file .env restart backend worker
 ```
 

docs/deploy/install.md

@@ -63,7 +63,7 @@ CPU-only — отдельного GPU-варианта профилей для
 
 Поведение:
 - **Дефолт (Enter):** применяет матрицу выбранного пресета к настройкам БД
-  (defs: `docker compose exec -T backend uv run python -m scripts.apply_preset_settings --force`)
+  (defs: `docker compose exec -T backend uv run --no-sync python -m scripts.apply_preset_settings --force`)
 - **Отказ (`n`):** сохраняет ручные правки админа; переменные `BOOTSTRAP_*` в `.env`
   обновляются, но скрипт применения настроек НЕ запускается
 - **Флаг `--yes`:** автоматически применяет пресет без вопроса (для CI/CD)
@@ -111,7 +111,7 @@ Grafana/Prometheus не поднимаются автоматически — с
    собирает фронтенд-SPA и вкомпилирует статику, `frontend/Dockerfile`).
 4. Поднимает `postgres`/`redis` (`up -d --wait`) и применяет **до старта
    backend** миграции и seed одноразовыми контейнерами:
-   `docker compose run --rm backend uv run alembic upgrade head` +
+   `docker compose run --rm backend uv run --no-sync alembic upgrade head` +
    `... python -m scripts.seed`. Порядок критичен: `backend.lifespan`
    бутстрапит `instance_settings` при каждом старте приложения, поэтому на
    чистой БД таблицы обязаны существовать до первого запуска backend — иначе
@@ -122,9 +122,8 @@ Grafana/Prometheus не поднимаются автоматически — с
    настройки инстанса не перетираются).
 5. Поднимает остальной стек: `docker compose <--profile ...> up -d --wait`
    (backend, worker, nginx с фронтом + сервисы активных профилей). Команда
-   идемпотентна и обёрнута в ретрай (до 3 попыток): первый старт backend/worker
-   включает `uv run` (синхронизация окружения + компиляция байткода), и на
-   слабой/загруженной машине healthcheck может не успеть за отведённые
+   идемпотентна и обёрнута в ретрай (до 3 попыток): на слабой/загруженной
+   машине healthcheck может не успеть за отведённые
    retries — повтор лишь дожидается уже стартующих контейнеров.
 6. Печатает сводку: URL фронтенда/бэкенда, учётные данные администратора,
    команда для `--profile monitoring`.

docs/deploy/scaling.md

@@ -63,7 +63,7 @@ services:
       dockerfile: Dockerfile
     restart: unless-stopped
     # Без -B: beat уже запущен на базовом worker (см. правило выше).
-    command: ["uv", "run", "celery", "-A", "workers.celery_app", "worker",
+    command: ["uv", "run", "--no-sync", "celery", "-A", "workers.celery_app", "worker",
                "-Q", "summarize", "--hostname=worker-summarize-%h@%h", "--loglevel=info"]
     env_file:
       - ../.env

frontend/src/api/conferences.ts

@@ -145,6 +145,14 @@ export interface ConferenceGuestJoinPayload {
   password?: string
 }
 
+/** Источник трека, который организатор может принудительно выключить (задача B2). */
+export type MuteSource = 'microphone' | 'camera'
+
+/** Ответ на принудительный мьют — `false`, если трек и так не был опубликован (нечего было мьютить). */
+export interface MuteParticipantResult {
+  muted: boolean
+}
+
 /** Тело частичного обновления конференции — те же поля, что и при создании, все опциональны. */
 export type ConferenceUpdatePayload = Partial<ConferenceCreatePayload>
 
@@ -202,6 +210,23 @@ export async function guestJoinConference(
   })
 }
 
+/**
+ * Принудительно выключить микрофон/камеру участника (задача B2) — только
+ * владелец конференции/администратор, иначе 403 (`not_owner`). 404
+ * (`participant_not_in_room`) — участника с таким `identity` сейчас нет в
+ * комнате LiveKit.
+ */
+export async function muteParticipant(
+  conferenceId: string,
+  identity: string,
+  source: MuteSource,
+): Promise<MuteParticipantResult> {
+  return apiRequest<MuteParticipantResult>(`/conferences/${conferenceId}/mute-participant`, {
+    method: 'POST',
+    body: { identity, source },
+  })
+}
+
 /** Список «моих» конференций — закреплённые (повторяющиеся) и предстоящие разовые владельца. */
 export async function getMyConferences(): Promise<ConferenceOut[]> {
   return apiRequest<ConferenceOut[]>('/conferences/my')

frontend/src/components/room/ChatPanel.tsx

@@ -1,7 +1,19 @@
 import { useEffect, useRef, useState, type ChangeEvent, type KeyboardEvent } from 'react'
-import { AlertCircle, Send, X } from 'lucide-react'
+import { AlertCircle, Send, SmilePlus, X } from 'lucide-react'
 import type { ChatConnectionStatus, ChatMessageOut } from '@/hooks/useChat'
 import { formatLocalTime } from '@/lib/localTime'
+import { useModalDismiss } from '@/hooks/useModalDismiss'
+
+/**
+ * Небольшой собственный набор популярных эмодзи — вместо библиотеки-пикера на
+ * сотни килобайт ради десятка кнопок в поповере.
+ */
+const EMOJI_OPTIONS = [
+  '😀', '😂', '😊', '😉', '😍', '🤔', '😅', '😢',
+  '😮', '😎', '🙌', '👍', '👎', '👏', '🙏', '❤️',
+  '🔥', '🎉', '✅', '❌', '⚠️', '💡', '👀', '🤝',
+  '🐎',
+]
 
 interface ChatPanelProps {
   messages: ChatMessageOut[]
@@ -38,12 +50,21 @@ export function ChatPanel({ messages, status, statusMessage, onSend, onClose }:
     }
   }, [messages])
 
+  // Авторасширение textarea до 4 строк, дальше — внутренний скролл. Эффектом,
+  // а не только в обработчике ввода, — так пересчёт срабатывает и после
+  // программной вставки эмодзи, и после очистки поля отправкой.
+  useEffect(() => {
+    const el = textareaRef.current
+    if (!el) return
+    el.style.height = 'auto'
+    el.style.height = `${Math.min(el.scrollHeight, 96)}px`
+  }, [draft])
+
   function handleSend() {
     const text = draft.trim()
     if (!text || status !== 'open') return
     onSend(text)
     setDraft('')
-    if (textareaRef.current) textareaRef.current.style.height = 'auto'
   }
 
   function handleKeyDown(event: KeyboardEvent<HTMLTextAreaElement>) {
@@ -55,10 +76,27 @@ export function ChatPanel({ messages, status, statusMessage, onSend, onClose }:
 
   function handleDraftChange(event: ChangeEvent<HTMLTextAreaElement>) {
     setDraft(event.target.value)
-    // Авторасширение textarea до 4 строк, дальше — внутренний скролл.
-    const el = event.target
-    el.style.height = 'auto'
-    el.style.height = `${Math.min(el.scrollHeight, 96)}px`
+  }
+
+  // Вставка эмодзи в позицию курсора, а не в конец поля, — ожидаемое поведение
+  // при редактировании текста в середине.
+  function insertEmoji(emoji: string) {
+    const el = textareaRef.current
+    if (!el) {
+      setDraft((current) => current + emoji)
+      return
+    }
+    const start = el.selectionStart ?? draft.length
+    const end = el.selectionEnd ?? draft.length
+    setDraft(draft.slice(0, start) + emoji + draft.slice(end))
+    // value обновится реальным React-рендером только на следующий тик —
+    // курсор возвращаем после него, иначе setSelectionRange встанет на
+    // ещё старую (более короткую) строку.
+    requestAnimationFrame(() => {
+      const pos = start + emoji.length
+      el.focus()
+      el.setSelectionRange(pos, pos)
+    })
   }
 
   return (
@@ -101,6 +139,7 @@ export function ChatPanel({ messages, status, statusMessage, onSend, onClose }:
           handleSend()
         }}
       >
+        <EmojiPickerButton onSelect={insertEmoji} disabled={status !== 'open'} />
         <textarea
           ref={textareaRef}
           rows={1}
@@ -118,3 +157,77 @@ export function ChatPanel({ messages, status, statusMessage, onSend, onClose }:
     </aside>
   )
 }
+
+interface EmojiPickerButtonProps {
+  onSelect: (emoji: string) => void
+  disabled: boolean
+}
+
+/**
+ * Кнопка с поповером выбора эмодзи слева от поля ввода. Поповер открывается
+ * ВВЕРХ от кнопки (как `.tb-menu` тулбара) — на мобильном чат-панель занята
+ * полем ввода снизу, а место над тулбаром свободно, так поповер никогда не
+ * перекрывает textarea.
+ */
+function EmojiPickerButton({ onSelect, disabled }: EmojiPickerButtonProps) {
+  const [open, setOpen] = useState(false)
+  const wrapRef = useRef<HTMLDivElement>(null)
+
+  // Закрытие по клику вне — тем же паттерном, что меню «Вид» (StageViewMenu):
+  // слушатель на document, пока поповер открыт.
+  useEffect(() => {
+    if (!open) return
+    function handlePointerDown(event: MouseEvent) {
+      if (wrapRef.current && !wrapRef.current.contains(event.target as Node)) {
+        setOpen(false)
+      }
+    }
+    document.addEventListener('mousedown', handlePointerDown)
+    return () => document.removeEventListener('mousedown', handlePointerDown)
+  }, [open])
+
+  return (
+    <div className="chat-emoji-wrap" ref={wrapRef}>
+      <button
+        type="button"
+        className={`chat-emoji-trigger${open ? ' is-open' : ''}`}
+        aria-label="Вставить эмодзи"
+        aria-expanded={open}
+        aria-haspopup="dialog"
+        disabled={disabled}
+        onClick={() => setOpen((v) => !v)}
+      >
+        <SmilePlus className="lucide" aria-hidden="true" />
+      </button>
+      {open && (
+        <EmojiPopover
+          onSelect={(emoji) => {
+            onSelect(emoji)
+            setOpen(false)
+          }}
+          onClose={() => setOpen(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+interface EmojiPopoverProps {
+  onSelect: (emoji: string) => void
+  onClose: () => void
+}
+
+/** Отдельный компонент — чтобы `useModalDismiss` (Escape + возврат фокуса) жил ровно то время, пока поповер открыт. */
+function EmojiPopover({ onSelect, onClose }: EmojiPopoverProps) {
+  useModalDismiss(onClose)
+
+  return (
+    <div className="chat-emoji-popover" role="dialog" aria-label="Выбор эмодзи">
+      {EMOJI_OPTIONS.map((emoji) => (
+        <button key={emoji} type="button" className="chat-emoji-option" onClick={() => onSelect(emoji)}>
+          {emoji}
+        </button>
+      ))}
+    </div>
+  )
+}

frontend/src/components/room/DeviceSettingsDialog.tsx

@@ -1,16 +1,16 @@
-import { useEffect, useRef, useState } from 'react'
+import { useRef, useState } from 'react'
 import { X } from 'lucide-react'
 import { useMediaDeviceSelect, usePersistentUserChoices } from '@livekit/components-react'
 import { useToast } from '@/components/ui/ToastProvider'
+import { useIsCompactViewport } from '@/hooks/useIsCompactViewport'
 import { useModalDismiss } from '@/hooks/useModalDismiss'
+import { StageViewOptions, type StageViewProps } from '@/components/room/StageViewOptions'
 import { isAudioOutputSelectable, saveAudioOutputDeviceId } from '@/lib/audioOutputDevice'
 
-interface DeviceSettingsDialogProps {
+interface DeviceSettingsDialogProps extends StageViewProps {
   onClose: () => void
 }
 
-/** Совпадает с мобильным брейкпоинтом комнаты (`room.css`, `max-width: 600px`) — ниже него панель рендерится шторкой снизу вместо модалки. */
-const COMPACT_VIEWPORT_QUERY = '(max-width: 600px)'
 /** Свайп ручки шторки вниз дальше этого порога (px) закрывает панель, меньше — она возвращается на место. */
 const SHEET_DISMISS_THRESHOLD_PX = 80
 
@@ -19,20 +19,6 @@ function deviceLabel(device: MediaDeviceInfo, index: number, fallback: string):
   return device.label || `${fallback} ${index + 1}`
 }
 
-/** Живое отслеживание мобильной ширины — та же схема, что системная тема в `useTheme.ts` (matchMedia + change-листенер). */
-function useIsCompactViewport(): boolean {
-  const [isCompact, setIsCompact] = useState(() => window.matchMedia(COMPACT_VIEWPORT_QUERY).matches)
-
-  useEffect(() => {
-    const media = window.matchMedia(COMPACT_VIEWPORT_QUERY)
-    const handleChange = (event: MediaQueryListEvent) => setIsCompact(event.matches)
-    media.addEventListener('change', handleChange)
-    return () => media.removeEventListener('change', handleChange)
-  }, [])
-
-  return isCompact
-}
-
 /**
  * Панель «Настройки устройств» — три селекта на хуках `@livekit/components-react`:
  * список устройств и переключение целиком в `useMediaDeviceSelect` (сама
@@ -47,12 +33,23 @@ function useIsCompactViewport(): boolean {
  * модалки — по клику вне, Escape (`useModalDismiss`) и свайпу вниз за ручку.
  * Десктоп не меняется.
  *
+ * Там же, и только там, первой секцией идёт «Вид» (режим показа участников и
+ * скрытие остальных): на мобильном тулбар ужат до пяти кнопок, отдельной
+ * кнопки «Вид» там нет — см. `RoomToolbar`. Поэтому и заголовок панели на
+ * мобильном шире по смыслу («Настройки», а не «Настройки устройств»).
+ *
  * ДОЛЖЕН рендериться внутри `<LiveKitRoom>`: `useMediaDeviceSelect` без явно
  * переданного `room` берёт активную комнату из `RoomContext` — вне контекста
  * он создал бы отдельный, ни с чем не связанный `Room()` и переключал бы
  * устройство «в никуда».
  */
-export function DeviceSettingsDialog({ onClose }: DeviceSettingsDialogProps) {
+export function DeviceSettingsDialog({
+  onClose,
+  layoutMode,
+  onLayoutModeChange,
+  hideOthers,
+  onHideOthersChange,
+}: DeviceSettingsDialogProps) {
   const toast = useToast()
   const { saveAudioInputDeviceId, saveVideoInputDeviceId } = usePersistentUserChoices()
   const mic = useMediaDeviceSelect({ kind: 'audioinput' })
@@ -143,12 +140,26 @@ export function DeviceSettingsDialog({ onClose }: DeviceSettingsDialogProps) {
         )}
 
         <div className="room-modal-head">
-          <h2 id="device-settings-title">Настройки устройств</h2>
+          <h2 id="device-settings-title">{isCompact ? 'Настройки' : 'Настройки устройств'}</h2>
           <button type="button" className="room-modal-close" aria-label="Закрыть" onClick={onClose}>
             <X className="lucide" style={{ width: 16, height: 16 }} aria-hidden="true" />
           </button>
         </div>
 
+        {/* Обёртка НЕ `.room-field`: там `label { display: block }` со
+            специфичностью выше, чем у `.stage-view-mode` — пункты режимов
+            рассыпались бы в столбик (кружок отдельно, текст под ним). */}
+        {isCompact && (
+          <div className="stage-view-section">
+            <StageViewOptions
+              layoutMode={layoutMode}
+              onLayoutModeChange={onLayoutModeChange}
+              hideOthers={hideOthers}
+              onHideOthersChange={onHideOthersChange}
+            />
+          </div>
+        )}
+
         <div className="room-field">
           <label htmlFor="device-settings-mic">Микрофон</label>
           <select

frontend/src/components/room/ForcedMuteWatcher.tsx

@@ -0,0 +1,40 @@
+import { useEffect } from 'react'
+import { useLocalParticipant } from '@livekit/components-react'
+import { useToast } from '@/components/ui/ToastProvider'
+import type { ForcedMuteEvent } from '@/hooks/useChat'
+
+/**
+ * Уведомляет ЛОКАЛЬНОГО участника тостом, когда организатор принудительно
+ * выключил его микрофон/камеру (задача B2). Рендерится безусловно внутри
+ * `<LiveKitRoom>` — `useLocalParticipant` недоступен снаружи (`RoomPage`
+ * сам вне контекста LiveKit, см. докстринг `useIsOrganizer`).
+ *
+ * Само выключение трека организатор делает СЕРВЕРНЫМ вызовом LiveKit API
+ * (`services/room_control.py`) — тулбарные кнопки (useTrackToggle) сами
+ * отразят новое состояние по родному событию LiveKit `TrackMuted`, этот
+ * компонент только поясняет ПОЧЕМУ: без тоста человек не отличил бы
+ * действие организатора от случайного глюка. Участник может включить себя
+ * обратно сразу тем же тулбаром — сервер это не блокирует (см. докстринг B2
+ * в CHANGELOG/коммите).
+ */
+export function ForcedMuteWatcher({ event }: { event: ForcedMuteEvent | null }) {
+  const { localParticipant } = useLocalParticipant()
+  const toast = useToast()
+
+  useEffect(() => {
+    if (!event || event.identity !== localParticipant.identity) return
+    toast.show(
+      event.source === 'microphone'
+        ? 'Организатор выключил ваш микрофон'
+        : 'Организатор выключил вашу камеру',
+      'info',
+    )
+    // `event` (включая `nonce`) — единственная зависимость, которая должна
+    // повторно показывать тост; `localParticipant`/`toast` стабильны в
+    // рамках подключения и намеренно не входят в список, чтобы их
+    // пересоздание (если когда-нибудь случится) не дублировало уведомление.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [event])
+
+  return null
+}

frontend/src/components/room/HandQueuePanel.tsx

@@ -0,0 +1,60 @@
+import { Hand, X } from 'lucide-react'
+import { useIsOrganizer } from '@/hooks/useIsOrganizer'
+import type { HandQueueEntry } from '@/hooks/useChat'
+
+interface HandQueuePanelProps {
+  queue: HandQueueEntry[]
+  onLower: (identity: string) => void
+  onClose: () => void
+}
+
+/**
+ * Панель очереди поднятых рук — видна только организатору (задача B1).
+ * Визуально — тот же боковой контейнер, что и `ChatPanel` (`.chat-panel`,
+ * включая мобильное поведение «во весь экран» на ≤900px), содержимое своё:
+ * упорядоченный список с позицией и кнопкой «Опустить» на каждой строке —
+ * организатору разрешено опускать чужую руку (решение оператора, задача B1).
+ *
+ * `RoomPage` гейтит рендер по `handQueueOpen` (как и `ChatPanel` по
+ * `chatOpen`) — свой `useIsOrganizer()` здесь ДОПОЛНИТЕЛЬНАЯ, а не
+ * единственная защита: `RoomToolbar` уже не показывает кнопку открытия
+ * не-организатору, это подстраховка на случай прямого рендера.
+ */
+export function HandQueuePanel({ queue, onLower, onClose }: HandQueuePanelProps) {
+  const isOrganizer = useIsOrganizer()
+  if (!isOrganizer) return null
+
+  return (
+    <aside className="chat-panel hand-queue-panel">
+      <div className="chat-head">
+        <h2>Поднятые руки</h2>
+        <button type="button" aria-label="Закрыть очередь" onClick={onClose}>
+          <X className="lucide" aria-hidden="true" />
+        </button>
+      </div>
+
+      {queue.length === 0 ? (
+        <p className="chat-empty">Пока никто не поднял руку</p>
+      ) : (
+        <ol className="hand-queue-list">
+          {queue.map((entry, index) => (
+            <li className="hand-queue-item" key={entry.identity}>
+              <span className="hand-queue-position">{index + 1}</span>
+              <span className="hand-queue-name">
+                <Hand className="lucide" aria-hidden="true" />
+                {entry.name}
+              </span>
+              <button
+                type="button"
+                className="hand-queue-lower"
+                onClick={() => onLower(entry.identity)}
+              >
+                Опустить
+              </button>
+            </li>
+          ))}
+        </ol>
+      )}
+    </aside>
+  )
+}

frontend/src/components/room/RoomParticipantTile.tsx

@@ -1,4 +1,4 @@
-import { Pin, PinOff, ScreenShare } from 'lucide-react'
+import { Hand, Mic, Pin, PinOff, ScreenShare, Video } from 'lucide-react'
 import { Track } from 'livekit-client'
 import {
   AudioTrack,
@@ -20,21 +20,79 @@ import {
 } from '@livekit/components-react'
 import { Avatar } from '@/components/ui/Avatar'
 import { stageTrackKey } from '@/components/room/stageFocus'
+import { parseParticipantMetadata } from '@/lib/participantMetadata'
+import { useIsOrganizer } from '@/hooks/useIsOrganizer'
+import { useToast } from '@/components/ui/ToastProvider'
+import { muteParticipant } from '@/api/conferences'
 
-/** Метаданные участника из LiveKit access-токена (см. `AccessToken.with_metadata` на backend) — JSON `{"avatar_url": "..."}`; у гостей отсутствуют. */
-interface ParticipantMetadata {
-  avatar_url?: string | null
+/** Достаёт URL аватара из метаданных участника — `null`, если поля нет (гость/без аватара). */
+function parseAvatarUrl(metadata: string | undefined): string | null {
+  const parsed = parseParticipantMetadata(metadata)
+  return typeof parsed.avatar_url === 'string' && parsed.avatar_url ? parsed.avatar_url : null
 }
 
-/** Разбирает `participant.metadata` в URL аватара — `null`, если поля нет, метаданные пусты или невалидны (гость). */
-function parseAvatarUrl(metadata: string | undefined): string | null {
-  if (!metadata) return null
-  try {
-    const parsed = JSON.parse(metadata) as ParticipantMetadata
-    return typeof parsed.avatar_url === 'string' && parsed.avatar_url ? parsed.avatar_url : null
-  } catch {
-    return null
+/**
+ * Кнопки принудительного мьюта организатором (задача B2) — микрофон/камера
+ * ЧУЖОГО участника. Видны только организатору (`useIsOrganizer`, подсказка
+ * UI — сервер перепроверяет права по владельцу конференции в БД) и только на
+ * чужой плитке камеры (на своей — обычный тулбарный toggle, мьютить себя
+ * через «принудительное» действие не нужно).
+ *
+ * Не проверяют текущее состояние мьюта заранее (усложнило бы плитку ради
+ * малополезной оптимизации): клик по уже выключенному треку — не ошибка, а
+ * no-op на backend (`muted: false` в ответе, см. `services/room_control.py`).
+ */
+function OrganizerMuteControls({
+  conferenceId,
+  identity,
+  displayName,
+}: {
+  conferenceId: string
+  identity: string
+  displayName: string
+}) {
+  const toast = useToast()
+
+  async function handleMute(source: 'microphone' | 'camera') {
+    try {
+      const result = await muteParticipant(conferenceId, identity, source)
+      if (!result.muted) {
+        toast.show(
+          source === 'microphone' ? 'Микрофон и так выключен' : 'Камера и так выключена',
+          'info',
+        )
+      }
+    } catch {
+      toast.show('Не удалось выключить трек участника', 'error')
+    }
   }
+
+  return (
+    <div className="room-organizer-controls">
+      <button
+        type="button"
+        title={`Выключить микрофон: ${displayName}`}
+        aria-label={`Выключить микрофон: ${displayName}`}
+        onClick={(e) => {
+          e.stopPropagation()
+          void handleMute('microphone')
+        }}
+      >
+        <Mic aria-hidden="true" />
+      </button>
+      <button
+        type="button"
+        title={`Выключить камеру: ${displayName}`}
+        aria-label={`Выключить камеру: ${displayName}`}
+        onClick={(e) => {
+          e.stopPropagation()
+          void handleMute('camera')
+        }}
+      >
+        <Video aria-hidden="true" />
+      </button>
+    </div>
+  )
 }
 
 /**
@@ -44,8 +102,15 @@ function parseAvatarUrl(metadata: string | undefined): string | null {
  * разметке (см. `node_modules/@livekit/components-react/src/components/participant/ParticipantTile.tsx`,
  * версия 2.9.23 — источник этой копии).
  */
-function TileBody({ onStopSharing, pinnedKey, onTogglePin }: TileControlsProps) {
+function TileBody({
+  onStopSharing,
+  pinnedKey,
+  onTogglePin,
+  raisedHandIdentities,
+  conferenceId,
+}: TileControlsProps) {
   const trackReference = useEnsureTrackRef()
+  const isOrganizer = useIsOrganizer()
   const isEncrypted = useIsEncrypted(trackReference.participant)
   const autoManageSubscription = useFeatureContext()?.autoSubscription
   // useParticipantInfo — реактивные name/metadata участника (переподписка на
@@ -67,6 +132,18 @@ function TileBody({ onStopSharing, pinnedKey, onTogglePin }: TileControlsProps)
   // рендерятся шаблоном без пропсов, снаружи «какая это плитка» не передать.
   const tileKey = stageTrackKey(trackReference)
   const isPinned = pinnedKey === tileKey
+  // Бейдж поднятой руки (задача B1) — только на плитке КАМЕРЫ участника, не
+  // на плитке его демонстрации экрана (рука — про человека, не про экран).
+  const isHandRaised =
+    trackReference.source === Track.Source.Camera &&
+    Boolean(raisedHandIdentities?.has(trackReference.participant.identity))
+  // Кнопки принудительного мьюта (задача B2) — организатору, только на
+  // чужой плитке камеры (см. докстринг `OrganizerMuteControls`).
+  const showOrganizerMuteControls =
+    isOrganizer &&
+    Boolean(conferenceId) &&
+    trackReference.source === Track.Source.Camera &&
+    !trackReference.participant.isLocal
 
   return (
     <>
@@ -88,6 +165,11 @@ function TileBody({ onStopSharing, pinnedKey, onTogglePin }: TileControlsProps)
       <div className="lk-participant-placeholder">
         <Avatar name={displayName} avatarUrl={avatarUrl} className="room-tile-avatar" />
       </div>
+      {isHandRaised && (
+        <div className="room-hand-badge" title={`${displayName}: поднята рука`}>
+          <Hand className="lucide" aria-hidden="true" />
+        </div>
+      )}
       <div className="lk-participant-metadata">
         <div className="lk-participant-metadata-item">
           {trackReference.source === Track.Source.Camera ? (
@@ -141,6 +223,13 @@ function TileBody({ onStopSharing, pinnedKey, onTogglePin }: TileControlsProps)
           </button>
         </div>
       )}
+      {showOrganizerMuteControls && conferenceId && (
+        <OrganizerMuteControls
+          conferenceId={conferenceId}
+          identity={trackReference.participant.identity}
+          displayName={displayName}
+        />
+      )}
     </>
   )
 }
@@ -166,6 +255,17 @@ interface TileControlsProps {
    * Не передан — кнопки-булавки на плитке нет (мини-плеер: плитка одна).
    */
   onTogglePin?: (key: string) => void
+  /**
+   * Identity участников с поднятой рукой прямо сейчас (задача B1, из
+   * `useChat().handQueue`) — плитка сама решает, её ли это identity. Не
+   * передан — бейдж нигде не рендерится (мини-плеер).
+   */
+  raisedHandIdentities?: Set<string>
+  /**
+   * Id конференции (не slug/номер) — нужен для вызова эндпоинта мьюта
+   * (задача B2). Не передан — кнопок мьюта на плитке нет (мини-плеер).
+   */
+  conferenceId?: string
 }
 
 interface RoomParticipantTileProps extends TileControlsProps {
@@ -197,6 +297,8 @@ export function RoomParticipantTile({
   onStopSharing,
   pinnedKey,
   onTogglePin,
+  raisedHandIdentities,
+  conferenceId,
 }: RoomParticipantTileProps) {
   return (
     <ParticipantTile
@@ -204,7 +306,13 @@ export function RoomParticipantTile({
       disableSpeakingIndicator={disableSpeakingIndicator}
       onParticipantClick={onParticipantClick}
     >
-      <TileBody onStopSharing={onStopSharing} pinnedKey={pinnedKey} onTogglePin={onTogglePin} />
+      <TileBody
+        onStopSharing={onStopSharing}
+        pinnedKey={pinnedKey}
+        onTogglePin={onTogglePin}
+        raisedHandIdentities={raisedHandIdentities}
+        conferenceId={conferenceId}
+      />
     </ParticipantTile>
   )
 }

frontend/src/components/room/RoomStage.tsx

@@ -1,18 +1,22 @@
-import { useEffect, useState } from 'react'
+import { useEffect, useState, type ReactNode } from 'react'
+import { EyeOff, Mic, MicOff, Users } from 'lucide-react'
 import { Track, type Participant } from 'livekit-client'
 import {
   CarouselLayout,
   FocusLayoutContainer,
-  GridLayout,
   RoomAudioRenderer,
   isTrackReference,
   useRoomContext,
   useSpeakingParticipants,
+  useTrackToggle,
   useTracks,
   type TrackReferenceOrPlaceholder,
 } from '@livekit/components-react'
 import { RoomParticipantTile } from '@/components/room/RoomParticipantTile'
+import { StageGrid } from '@/components/room/StageGrid'
+import { useIsCompactViewport } from '@/hooks/useIsCompactViewport'
 import { pickStageFocus, stageTrackKey } from '@/components/room/stageFocus'
+import type { StageLayoutMode } from '@/lib/stageLayoutMode'
 
 /**
  * Стабильная (модульная, не пересоздаётся на каждый рендер) ссылка на
@@ -80,10 +84,80 @@ function useSteadySpeakers(speakers: Participant[], holdMs: number): Participant
   return holdMs <= 0 ? speakers : steady
 }
 
+/**
+ * Есть ли у трека ЖИВОЕ видео: это настоящий трек (не плейсхолдер выключенной
+ * камеры) и он не в мьюте. По этому признаку режим «Живые плитки» делит
+ * участников на сетку и карусель, а `pickStageFocus` отдаёт предпочтение
+ * говорящему с картинкой.
+ */
+function hasLiveVideo(track: TrackReferenceOrPlaceholder): boolean {
+  return isTrackReference(track) && !track.publication.isMuted
+}
+
+/**
+ * Кнопка микрофона поверх единственной плитки мини-плеера (задача A5): в
+ * Document PiP своего тулбара нет вовсе, а звонок продолжается — без неё
+ * замьютить себя можно, только развернув основное окно. `useTrackToggle` —
+ * тот же хук, что и в `RoomToolbar`, читает/меняет состояние ЧЕРЕЗ
+ * `RoomContext`, а не через DOM, поэтому работает одинаково что в основном
+ * окне, что в портале, рендерящем эту сцену внутрь `pipWindow.document.body`
+ * (React-контекст порталом не разрывается, в отличие от DOM-дерева).
+ */
+function PipMicToggle() {
+  const mic = useTrackToggle({ source: Track.Source.Microphone })
+  return (
+    <button
+      type="button"
+      {...mic.buttonProps}
+      className={`room-pip-mic-toggle${mic.enabled ? '' : ' is-off'}`}
+      aria-label={mic.enabled ? 'Выключить микрофон' : 'Включить микрофон'}
+    >
+      {mic.enabled ? <Mic className="lucide" aria-hidden="true" /> : <MicOff className="lucide" aria-hidden="true" />}
+    </button>
+  )
+}
+
 /**
  * Основная сцена конференции: превью остальных участников + крупная плитка
  * активного спикера (FocusLayoutContainer + CarouselLayout при нескольких
- * участниках, GridLayout при одном/двух).
+ * участниках, равномерная сетка при одном/двух).
+ *
+ * РЕЖИМЫ ПОКАЗА (`layoutMode`, выбор пользователя, см. `lib/stageLayoutMode.ts`):
+ *   - `standard` — как было до 0.0.11: крупная плитка (кого показать, решает
+ *     `pickStageFocus`) + карусель остальных сбоку;
+ *   - `tiles` — все участники равными плитками (`StageGrid`), без фокуса;
+ *   - `live-tiles` — сетка только из участников с включённой камерой,
+ *     остальные (плейсхолдер/мьют, см. `hasLiveVideo`) — в карусели сбоку.
+ *     Если камеру не включил никто, сетка была бы пустой, поэтому в этом
+ *     случае показываем всех — режим вырождается в `tiles`.
+ *
+ * ДЕМОНСТРАЦИЯ ЭКРАНА перебивает выбранный режим: пока в комнате есть хоть
+ * одна активная демонстрация, сцена ведёт себя как `standard` (демонстрация
+ * крупно, все камеры в карусели). Это сознательно: смысл плиточных режимов —
+ * равноправие участников, а демонстрация по определению неравноправна, ради
+ * неё её и включают. Режим при этом не меняется — он живёт в состоянии
+ * `RoomPage`, поэтому по завершении демонстрации сцена сама возвращается к
+ * выбранному пользователем виду.
+ *
+ * СКРЫТИЕ ОСТАЛЬНЫХ (`hideOthers`): карусель не рендерится вовсе, основная
+ * область занимает всю сцену. Скрыть можно тремя способами — меню «Вид»,
+ * шторка настроек на мобильном и кнопка «Скрыть» прямо над колонкой миниатюр
+ * (`onHideOthers`, только широкий экран). Вернуть — кнопкой «Показать
+ * остальных» на сцене (`onShowOthers`): она видна всегда, пока кто-то скрыт,
+ * чтобы участники не «потерялись» без понятного способа их вернуть. В режиме
+ * `tiles` скрывать нечего (карусели нет), переключатель там заблокирован —
+ * см. `StageViewOptions`.
+ *
+ * ФОКУС ПЕРЕЖИВАЕТ ПЕРЕЕЗД В МИНИ-ПЛЕЕР. Сцена в мини-плеере — ОТДЕЛЬНЫЙ
+ * экземпляр этого компонента (портал в PiP-окно), и своё состояние фокуса он
+ * начинал с нуля: демонстрации нет, никто прямо сейчас не говорит — и
+ * `pickStageFocus` доходил до последнего фолбэка `localKey`, то есть мини-окно
+ * открывалось на самом пользователе вместо того, что он видел крупно. В Safari
+ * бага не было видно: там Document PiP не используется, а video-фолбэк
+ * (`useRoomPiP`) берёт `<video>` прямо из фокус-плитки основного окна. Лечится
+ * передачей ключа наружу и обратно: `onFocusKeyChange` → состояние в
+ * `RoomPage` → `initialFocusKey` следующего экземпляра. Работает в обе стороны
+ * — возврат из мини-плеера тоже не сбрасывает фокус.
  *
  * Раскладка — вертикальная колонка миниатюр слева от основной сцены (не
  * горизонтальная лента, см. design/mockups/room.html после правки: узкая
@@ -111,7 +185,8 @@ function useSteadySpeakers(speakers: Participant[], holdMs: number): Participant
  *
  * Проп `variant="pip"` — для рендера
  * ВНУТРИ мини-плеера (Document PiP, портал в `RoomPage.tsx`). В этом режиме
- * показываем ТОЛЬКО одну крупную плитку активного окна — без карусели/грида.
+ * показываем ТОЛЬКО одну крупную плитку активного окна — без карусели/грида;
+ * режимы показа и скрытие остальных на мини-плеер не влияют вовсе.
  *
  * Фокус следует за активным спикером в ОБОИХ вариантах (`followSpeaker` у
  * `pickStageFocus`; для основного окна — с 0.0.6, задача 3.2), но по-разному:
@@ -120,8 +195,46 @@ function useSteadySpeakers(speakers: Participant[], holdMs: number): Participant
  * фокуса живую демонстрацию экрана (`holdScreenShare`) и умеет закрепление
  * участника (`pinnedKey`, задача 3.1) — кнопка-булавка на плитке.
  */
-export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
+export function RoomStage({
+  variant = 'full',
+  layoutMode = 'standard',
+  hideOthers = false,
+  onShowOthers,
+  onHideOthers,
+  initialFocusKey = null,
+  onFocusKeyChange,
+  onPinFocus,
+  raisedHandIdentities,
+  conferenceId,
+}: {
+  variant?: 'full' | 'pip'
+  /** Выбранный пользователем режим показа; игнорируется при `variant="pip"`. */
+  layoutMode?: StageLayoutMode
+  /** Скрыть карусель остальных участников; игнорируется при `variant="pip"`. */
+  hideOthers?: boolean
+  /** Вернуть скрытых участников — кнопка на сцене (см. докстринг выше). */
+  onShowOthers?: () => void
+  /** Скрыть остальных — кнопка над каруселью (только широкий экран). */
+  onHideOthers?: () => void
+  /** Чем инициализировать фокус при монтировании — см. докстринг про мини-плеер. */
+  initialFocusKey?: string | null
+  /** Сообщать наружу текущий фокус, чтобы его пережил переезд сцены в мини-плеер и обратно. */
+  onFocusKeyChange?: (key: string | null) => void
+  /**
+   * Участника только что закрепили (не открепили) в режиме без крупной
+   * плитки — сцена сама переключиться не может (режим живёт в `RoomPage`),
+   * поэтому просит переключить на `standard`, где закреплённого есть куда
+   * показать крупно. Открепление НЕ вызывает колбэк — вид назад не
+   * переключаем (см. докстринг `RoomPage`, обоснование решения в коммите).
+   */
+  onPinFocus?: () => void
+  /** Identity участников с поднятой рукой (задача B1) — бейдж на плитке; игнорируется при `variant="pip"`. */
+  raisedHandIdentities?: Set<string>
+  /** Id конференции (задача B2) — кнопки принудительного мьюта на чужих плитках; игнорируется при `variant="pip"`. */
+  conferenceId?: string
+}) {
   const room = useRoomContext()
+  const isCompact = useIsCompactViewport()
   const tracks = useTracks(STAGE_TRACK_SOURCES, {
     onlySubscribed: false,
   })
@@ -167,7 +280,10 @@ export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
   // `pickStageFocus` меняют результат без изменения самих треков.
   const [prevTracks, setPrevTracks] = useState(tracks)
   const [prevSpeakingParticipants, setPrevSpeakingParticipants] = useState(speakingParticipants)
-  const [focusKey, setFocusKey] = useState<string | null>(null)
+  // Стартовое значение — фокус, доставшийся от предыдущего экземпляра сцены
+  // (см. `initialFocusKey` и докстринг про мини-плеер). Дальше живёт своей
+  // жизнью: `pickStageFocus` пересчитывает его на каждое значимое изменение.
+  const [focusKey, setFocusKey] = useState<string | null>(initialFocusKey)
   // Закрепление живёт в состоянии сцены (задача 3.1): ключ `identity:source`
   // плитки, которую пользователь закрепил булавкой; `null` — закрепления нет.
   // Только для основного окна — в PiP плитка одна и закреплять нечего.
@@ -211,10 +327,7 @@ export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
       speakingCameraKeys,
       // Приоритет «говорящий с камерой выше говорящего без камеры» — только
       // основному окну: PiP по договорённости ведёт себя ровно как раньше.
-      cameraKeysWithVideo:
-        variant === 'pip'
-          ? []
-          : cameraTracks.filter((t) => isTrackReference(t) && !t.publication.isMuted).map(stageTrackKey),
+      cameraKeysWithVideo: variant === 'pip' ? [] : cameraTracks.filter(hasLiveVideo).map(stageTrackKey),
       prevKeys,
       prevFocusKey: focusKey,
       pinnedKey: pinnedAlive ? pinnedKey : null,
@@ -228,6 +341,14 @@ export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
     }
   }
 
+  // Отдаём фокус наружу (в `RoomPage`), чтобы он пережил размонтирование этой
+  // сцены и достался следующей — см. `initialFocusKey`. Именно эффект, а не
+  // вызов в теле рендера: setState ЧУЖОГО компонента во время рендера React
+  // запрещает.
+  useEffect(() => {
+    onFocusKeyChange?.(focusKey)
+  }, [focusKey, onFocusKeyChange])
+
   const focusTrack = tracks.find((t) => stageTrackKey(t) === focusKey) ?? screenShareTracks[0] ?? cameraTracks[0]
   const focusTrackKey = focusTrack ? stageTrackKey(focusTrack) : null
   // При активной демонстрации карусель — ВСЕ камеры (включая демонстратора) И
@@ -255,9 +376,16 @@ export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
    * Закрепить/открепить плитку: повторное нажатие на уже закреплённой снимает
    * закрепление. Ключ приходит из самой плитки (она знает свой трек из
    * контекста — в карусели/гриде плитки рендерятся шаблоном, без пропсов).
+   *
+   * Закрепление доступно из ЛЮБОГО режима показа (задача 3.1 → 3.3): в
+   * плиточных режимах крупной плитки нет, поэтому само закрепление (не
+   * открепление) просит `RoomPage` переключить вид на `standard` —
+   * закреплённого иначе негде показать крупно.
    */
   function handleTogglePin(key: string) {
-    setPinnedKey((prev) => (prev === key ? null : key))
+    const willPin = pinnedKey !== key
+    setPinnedKey(willPin ? key : null)
+    if (willPin) onPinFocus?.()
   }
 
   // Мини-плеер показывает ТОЛЬКО активное окно — без карусели/
@@ -268,34 +396,102 @@ export function RoomStage({ variant = 'full' }: { variant?: 'full' | 'pip' }) {
     return (
       <section className="stage room-single-tile">
         {focusTrack && <RoomParticipantTile trackRef={focusTrack} onStopSharing={handleStopSharing} />}
+        <PipMicToggle />
         <RoomAudioRenderer />
       </section>
     )
   }
 
+  // Демонстрация экрана перебивает выбранный режим (обоснование — в докстринге).
+  const effectiveMode: StageLayoutMode = hasScreenShare ? 'standard' : layoutMode
+  const liveCameraTracks = cameraTracks.filter(hasLiveVideo)
+
+  // Кого показываем сбоку в карусели. В «плитках» — никого (все равноправны),
+  // в «живых плитках» — тех, у кого камера выключена (а если камеры нет ни у
+  // кого, карусель пуста: все ушли в сетку), в «стандарте» — всех, кроме
+  // плитки в фокусе.
+  const sideTracks: TrackReferenceOrPlaceholder[] =
+    effectiveMode === 'tiles'
+      ? []
+      : effectiveMode === 'live-tiles'
+        ? liveCameraTracks.length > 0
+          ? cameraTracks.filter((t) => !hasLiveVideo(t))
+          : []
+        : carouselTracks
+  const showCarousel = !hideOthers && sideTracks.length > 0
+  // Булавка закрепления есть на КАЖДОЙ плитке во всех режимах (задача 3.3):
+  // сама кнопка вызывает переключение на `standard`, где закреплённый и
+  // попадёт в фокус (см. `handleTogglePin`/`onPinFocus`). Бейдж поднятой
+  // руки (задача B1) и кнопки принудительного мьюта (задача B2) едут тем же
+  // спредом — тоже нужны на КАЖДОЙ плитке.
+  const tileProps = { pinnedKey, onTogglePin: handleTogglePin, raisedHandIdentities, conferenceId }
+
+  function renderMain(): ReactNode {
+    if (effectiveMode === 'tiles') {
+      return (
+        <StageGrid tracks={tracks}>
+          <RoomParticipantTile {...tileProps} />
+        </StageGrid>
+      )
+    }
+    if (effectiveMode === 'live-tiles') {
+      return (
+        <StageGrid tracks={liveCameraTracks.length > 0 ? liveCameraTracks : cameraTracks}>
+          <RoomParticipantTile {...tileProps} />
+        </StageGrid>
+      )
+    }
+    // «Стандарт» с единственным участником (карусель пуста и скрывать нечего) —
+    // прежнее поведение: равномерная сетка на всю сцену, а не фокус-плитка.
+    if (sideTracks.length === 0 && !hideOthers) {
+      return (
+        <StageGrid tracks={tracks}>
+          <RoomParticipantTile {...tileProps} />
+        </StageGrid>
+      )
+    }
+    // FocusLayout оригинала — лёгкая обёртка ровно над ParticipantTile
+    // (см. её исходник), поэтому вместо неё используем свою обёртку
+    // напрямую с тем же trackRef (аватар в фокус-плитке).
+    return (
+      focusTrack && <RoomParticipantTile trackRef={focusTrack} onStopSharing={handleStopSharing} {...tileProps} />
+    )
+  }
+
   return (
     <section className="stage">
-      {!hasScreenShare && (!focusTrack || carouselTracks.length === 0) ? (
-        <GridLayout tracks={tracks} className="stage-tiles">
-          <RoomParticipantTile pinnedKey={pinnedKey} onTogglePin={handleTogglePin} />
-        </GridLayout>
-      ) : (
+      {showCarousel ? (
         <FocusLayoutContainer className="stage-tiles">
-          <CarouselLayout tracks={carouselTracks}>
-            <RoomParticipantTile pinnedKey={pinnedKey} onTogglePin={handleTogglePin} />
-          </CarouselLayout>
-          {/* FocusLayout оригинала — лёгкая обёртка ровно над ParticipantTile
-              (см. её исходник), поэтому вместо неё используем свою обёртку
-              напрямую с тем же trackRef (аватар в фокус-плитке). */}
-          {focusTrack && (
-            <RoomParticipantTile
-              trackRef={focusTrack}
-              onStopSharing={handleStopSharing}
-              pinnedKey={pinnedKey}
-              onTogglePin={handleTogglePin}
-            />
-          )}
+          {/* Обёртка колонки миниатюр: сама карусель не может быть прямым
+              ребёнком грида, потому что над ней стоит кнопка «Скрыть». Из-за
+              этого мобильный `.lk-carousel{order:1}` библиотеки перестаёт
+              действовать — порядок переносим на `.stage-side` (см. room.css). */}
+          <div className="stage-side">
+            {/* Быстрый способ убрать карусель, не открывая меню «Вид». Только
+                на широком экране: на мобильном колонка превращается в узкую
+                полосу снизу, где кнопке не место, — там переключатель живёт в
+                шторке настроек. Вернуть участников можно кнопкой на сцене. */}
+            {!isCompact && onHideOthers && (
+              <button type="button" className="stage-side-hide" onClick={onHideOthers}>
+                <EyeOff className="lucide" aria-hidden="true" />
+                <span>Скрыть</span>
+              </button>
+            )}
+            <CarouselLayout tracks={sideTracks}>
+              <RoomParticipantTile {...tileProps} />
+            </CarouselLayout>
+          </div>
+          {renderMain()}
         </FocusLayoutContainer>
+      ) : (
+        // Карусели нет — основная область занимает сцену целиком.
+        <div className="stage-tiles stage-main-only">{renderMain()}</div>
+      )}
+      {hideOthers && sideTracks.length > 0 && (
+        <button type="button" className="stage-show-others" onClick={onShowOthers}>
+          <Users className="lucide" aria-hidden="true" />
+          <span>Показать остальных ({sideTracks.length})</span>
+        </button>
       )}
       <RoomAudioRenderer />
     </section>

frontend/src/components/room/RoomToolbar.tsx

@@ -1,4 +1,6 @@
 import {
+  Hand,
+  ListOrdered,
   LogOut,
   Maximize,
   MessageSquare,
@@ -13,8 +15,12 @@ import {
   VideoOff,
 } from 'lucide-react'
 import { Track, type ScreenShareCaptureOptions } from 'livekit-client'
-import { DisconnectButton, useTrackToggle } from '@livekit/components-react'
+import { DisconnectButton, useLocalParticipant, useTrackToggle } from '@livekit/components-react'
 import { useToast } from '@/components/ui/ToastProvider'
+import { useIsCompactViewport } from '@/hooks/useIsCompactViewport'
+import { useIsOrganizer } from '@/hooks/useIsOrganizer'
+import type { HandQueueEntry } from '@/hooks/useChat'
+import { StageViewMenu, type StageViewProps } from '@/components/room/StageViewOptions'
 
 /**
  * Опции захвата демонстрации экрана: `audio: true` — звук
@@ -36,7 +42,7 @@ const SCREEN_SHARE_CAPTURE_OPTIONS: ScreenShareCaptureOptions = {
   systemAudio: 'include',
 }
 
-interface RoomToolbarProps {
+interface RoomToolbarProps extends StageViewProps {
   /** Показывать ли кнопку чата — `JoinOut.chat_enabled` И чат не помечен недоступным (close-код 4404). */
   chatVisible: boolean
   chatOpen: boolean
@@ -53,13 +59,35 @@ interface RoomToolbarProps {
   pipSupported: boolean
   pipActive: boolean
   onTogglePiP: () => void
+  /**
+   * Очередь поднятых рук целиком (задача B1, `useChat().handQueue`) — сама
+   * решает, поднята ли СВОЯ рука (сравнивая с `localParticipant.identity`
+   * через `useLocalParticipant`), и показывает бейдж общего счётчика.
+   */
+  handQueue: HandQueueEntry[]
+  onRaiseHand: () => void
+  onLowerHand: () => void
+  handQueueOpen: boolean
+  onToggleHandQueue: () => void
 }
 
 /**
- * Нижний тулбар комнаты: микрофон/камера/демонстрация экрана/
- * настройки устройств/полноэкранный режим/мини-плеер/чат/выход — собственные
- * кнопки на хуках LiveKit (useTrackToggle/DisconnectButton) и панели чата,
- * стилизованные по design/mockups/room.html.
+ * Нижний тулбар комнаты: микрофон/камера/демонстрация экрана/рука/очередь
+ * рук/вид сцены/настройки устройств/полноэкранный режим/мини-плеер/чат/выход —
+ * собственные кнопки на хуках LiveKit (useTrackToggle/DisconnectButton) и
+ * панели чата, стилизованные по design/mockups/room.html.
+ *
+ * Кнопка «Вид» (режимы показа и скрытие остальных) рендерится ТОЛЬКО на
+ * широком экране — условным рендерингом, а не скрытием через CSS: тулбар на
+ * мобильном и так ужат до пяти «безусловных» кнопок (демонстрация/
+ * полноэкранный режим/мини-плеер скрыты на узком экране через CSS, см.
+ * `styles/room.css`), а те же настройки там доступны секцией «Вид» в шторке
+ * настроек (`DeviceSettingsDialog`). «Рука» — сознательное исключение из этой
+ * экономии: поднять руку посреди разговора — действие со временем жизни в
+ * секунды, прятать его в шторку настроек означало бы делать его практически
+ * недоступным с телефона. «Очередь» показывается только организатору —
+ * встречается редко, но по той же причине оставлена в тулбаре, а не в
+ * шторке: организатору с телефона тоже нужно видеть очередь сразу.
  */
 export function RoomToolbar({
   chatVisible,
@@ -73,8 +101,21 @@ export function RoomToolbar({
   pipSupported,
   pipActive,
   onTogglePiP,
+  handQueue,
+  onRaiseHand,
+  onLowerHand,
+  handQueueOpen,
+  onToggleHandQueue,
+  layoutMode,
+  onLayoutModeChange,
+  hideOthers,
+  onHideOthersChange,
 }: RoomToolbarProps) {
   const toast = useToast()
+  const isCompact = useIsCompactViewport()
+  const isOrganizer = useIsOrganizer()
+  const { localParticipant } = useLocalParticipant()
+  const handRaised = handQueue.some((entry) => entry.identity === localParticipant.identity)
   const mic = useTrackToggle({ source: Track.Source.Microphone })
   const camera = useTrackToggle({ source: Track.Source.Camera })
   const screenShare = useTrackToggle({
@@ -140,6 +181,49 @@ export function RoomToolbar({
         <span className="label">Демонстрация</span>
       </button>
 
+      <button
+        type="button"
+        className={`tb-btn${handRaised ? ' is-hand-raised' : ''}`}
+        aria-pressed={handRaised}
+        aria-label={handRaised ? 'Опустить руку' : 'Поднять руку'}
+        onClick={() => (handRaised ? onLowerHand() : onRaiseHand())}
+      >
+        <span className="icon-shell">
+          <Hand className="lucide" aria-hidden="true" />
+          {handQueue.length > 0 && (
+            <span className="badge-count">{handQueue.length > 9 ? '9+' : handQueue.length}</span>
+          )}
+        </span>
+        <span className="label">Рука</span>
+      </button>
+
+      {isOrganizer && (
+        <button
+          type="button"
+          className={`tb-btn${handQueueOpen ? ' is-panel-open' : ''}`}
+          aria-pressed={handQueueOpen}
+          aria-label={handQueueOpen ? 'Свернуть очередь поднятых рук' : 'Открыть очередь поднятых рук'}
+          onClick={onToggleHandQueue}
+        >
+          <span className="icon-shell">
+            <ListOrdered className="lucide" aria-hidden="true" />
+            {handQueue.length > 0 && (
+              <span className="badge-count">{handQueue.length > 9 ? '9+' : handQueue.length}</span>
+            )}
+          </span>
+          <span className="label">Очередь</span>
+        </button>
+      )}
+
+      {!isCompact && (
+        <StageViewMenu
+          layoutMode={layoutMode}
+          onLayoutModeChange={onLayoutModeChange}
+          hideOthers={hideOthers}
+          onHideOthersChange={onHideOthersChange}
+        />
+      )}
+
       <button
         type="button"
         className="tb-btn"

frontend/src/components/room/RoomTopbar.tsx

@@ -4,7 +4,14 @@ import { useState } from 'react'
 import { pluralizeParticipants } from '@/lib/pluralize'
 
 interface RoomTopbarProps {
-  roomName: string
+  /**
+   * Название конференции (`ConferenceOut.title`/`ResolveOut.title`) —
+   * `null`/не задано, если организатор его не указал. НЕ путать с
+   * `JoinOut.room_name` (техническое имя комнаты LiveKit вида `hC-Dmos9KEM`,
+   * которое сюда раньше и попадало по ошибке, см. задачу A6) — тот нужен
+   * только серверу и в UI показывать нечего.
+   */
+  title: string | null
   /** Slug/номер конференции из адреса — для инвайт-чипа (копирование ссылки). */
   slug?: string
   number?: string
@@ -19,7 +26,7 @@ interface RoomTopbarProps {
  * тёмных токенов темы `room` (см. `--color-room-tile*`), без новых
  * цветов и форм.
  */
-export function RoomTopbar({ roomName, slug, number }: RoomTopbarProps) {
+export function RoomTopbar({ title, slug, number }: RoomTopbarProps) {
   const participants = useParticipants()
   const [copied, setCopied] = useState(false)
 
@@ -39,7 +46,7 @@ export function RoomTopbar({ roomName, slug, number }: RoomTopbarProps) {
   return (
     <header className="room-topbar">
       <div className="room-title-block">
-        <h1>{roomName}</h1>
+        <h1>{title ?? 'Конференция без названия'}</h1>
         <p>
           <span className="rec-dot" aria-hidden="true" />
           Конференция активна · <Users className="lucide" style={{ width: 14, height: 14 }} aria-hidden="true" />{' '}

frontend/src/components/room/StageGrid.tsx

@@ -0,0 +1,113 @@
+import { useRef, type ReactNode, type RefObject } from 'react'
+import { ChevronLeft, ChevronRight } from 'lucide-react'
+import {
+  TrackLoop,
+  useGridLayout,
+  usePagination,
+  useSwipe,
+  type GridLayoutDefinition,
+  type TrackReferenceOrPlaceholder,
+} from '@livekit/components-react'
+
+/**
+ * Раскладки равномерной сетки — расширенный набор поверх библиотечного
+ * `GRID_LAYOUTS` (@livekit/components-core, `helper/grid-layouts.ts`).
+ *
+ * Зачем свой набор. Библиотечный требует `minWidth: 560` уже для сетки 2×2,
+ * поэтому на телефоне (~390px) максимальной раскладкой оказывается `1×2` — две
+ * плитки на страницу, и десяток участников превращается в пять страниц
+ * листания. Здесь добавлены два портретных варианта под узкий экран (2×2 и
+ * 2×3): плитка шириной ~190px с именем и аватаром читается нормально, а
+ * страниц становится втрое меньше.
+ *
+ * Как это читает `selectGridLayout` (см. её исходник): раскладки сортируются
+ * по `maxTiles` (при равенстве — по `minWidth`), берётся первая, вмещающая всех
+ * участников, при этом раскладка пропускается, если ДАЛЬШЕ есть другая с тем же
+ * `maxTiles` и подходящей ориентацией контейнера. Отсюда пары «портрет/
+ * ландшафт» на одно и то же число плиток: 1×2 / 2×1 и 2×3 / 3×2 — на широком
+ * экране выигрывает горизонтальный вариант, на узком вертикальный. Если
+ * контейнер не дотягивает до `minWidth`/`minHeight`, функция рекурсивно
+ * спускается к меньшей раскладке, а лишние участники уходят на следующую
+ * страницу (`usePagination`).
+ */
+const STAGE_GRID_LAYOUTS: GridLayoutDefinition[] = [
+  { columns: 1, rows: 1 },
+  { columns: 1, rows: 2, orientation: 'portrait' },
+  { columns: 2, rows: 1, orientation: 'landscape' },
+  // 4 плитки помещаются и на телефоне: 390px / 2 ≈ 190px на плитку.
+  { columns: 2, rows: 2, minWidth: 360 },
+  { columns: 2, rows: 3, minWidth: 360, minHeight: 480, orientation: 'portrait' },
+  { columns: 3, rows: 2, minWidth: 700, orientation: 'landscape' },
+  { columns: 3, rows: 3, minWidth: 700 },
+  { columns: 4, rows: 4, minWidth: 960 },
+  { columns: 5, rows: 5, minWidth: 1100 },
+]
+
+interface StageGridProps {
+  tracks: TrackReferenceOrPlaceholder[]
+  /** Шаблон плитки — рендерится для каждого трека страницы (как у `GridLayout`, через `TrackLoop`). */
+  children: ReactNode
+}
+
+/**
+ * Равномерная сетка плиток с пагинацией — собственная сборка вместо
+ * библиотечного `GridLayout`.
+ *
+ * Причина ровно одна: `GridLayout` не пробрасывает `gridLayouts` в
+ * `useGridLayout`, то есть набор раскладок у неё жёстко зашит (см.
+ * `STAGE_GRID_LAYOUTS` выше). Всё остальное — те же публичные хуки, что
+ * использует оригинал (`useGridLayout` + `usePagination` + `useSwipe` +
+ * `TrackLoop`) и тот же класс `.lk-grid-layout`, поэтому и стили библиотеки, и
+ * `useVisualStableUpdate` внутри пагинации работают как раньше. Отличается
+ * только элемент управления страницами: библиотечные `PaginationIndicator`/
+ * `PaginationControl` из пакета не экспортируются, вместо них — свой
+ * `.stage-grid-pages` (кнопки со стрелками + счётчик, доступен и мышью, и с
+ * клавиатуры; на тач-экране страницы листаются ещё и свайпом).
+ */
+export function StageGrid({ tracks, children }: StageGridProps) {
+  const gridEl = useRef<HTMLDivElement | null>(null)
+  // Хуки библиотеки объявлены с `RefObject<HTMLDivElement>` (типы React 18, где
+  // `current` был readonly и тип вёл себя ковариантно). В типах React 19
+  // `current` мутабельный, поэтому `RefObject<HTMLDivElement | null>` в такой
+  // параметр уже не присваивается — приведение безопасно: оба хука только
+  // читают `.current` (ResizeObserver и слушатели touch-событий).
+  const gridRef = gridEl as RefObject<HTMLDivElement>
+  const { layout } = useGridLayout(gridRef, tracks.length, { gridLayouts: STAGE_GRID_LAYOUTS })
+  const pagination = usePagination(layout.maxTiles, tracks)
+
+  useSwipe(gridRef, {
+    onLeftSwipe: pagination.nextPage,
+    onRightSwipe: pagination.prevPage,
+  })
+
+  const hasPages = pagination.totalPageCount > 1
+
+  return (
+    <div ref={gridEl} className="lk-grid-layout stage-grid" data-lk-pagination={hasPages}>
+      <TrackLoop tracks={pagination.tracks}>{children}</TrackLoop>
+      {hasPages && (
+        <div className="stage-grid-pages">
+          <button
+            type="button"
+            aria-label="Предыдущая страница участников"
+            disabled={pagination.currentPage <= 1}
+            onClick={pagination.prevPage}
+          >
+            <ChevronLeft className="lucide" aria-hidden="true" />
+          </button>
+          <span aria-live="polite">
+            {pagination.currentPage} / {pagination.totalPageCount}
+          </span>
+          <button
+            type="button"
+            aria-label="Следующая страница участников"
+            disabled={pagination.currentPage >= pagination.totalPageCount}
+            onClick={pagination.nextPage}
+          >
+            <ChevronRight className="lucide" aria-hidden="true" />
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/components/room/StageViewOptions.tsx

@@ -0,0 +1,130 @@
+import { useEffect, useId, useRef, useState } from 'react'
+import { LayoutGrid } from 'lucide-react'
+import { STAGE_LAYOUT_MODE_OPTIONS, type StageLayoutMode } from '@/lib/stageLayoutMode'
+
+export interface StageViewProps {
+  layoutMode: StageLayoutMode
+  onLayoutModeChange: (mode: StageLayoutMode) => void
+  /** Карусель остальных участников скрыта — на сцене только основная область. */
+  hideOthers: boolean
+  onHideOthersChange: (hide: boolean) => void
+}
+
+/**
+ * Блок выбора вида сцены: режим показа (три варианта) + скрытие остальных
+ * участников. Один и тот же блок рендерится в двух местах — в поповере кнопки
+ * «Вид» на десктопе (`StageViewMenu` ниже) и секцией внутри мобильной шторки
+ * настроек (`DeviceSettingsDialog`), поэтому вынесен отдельно.
+ *
+ * «Скрыть остальных» в режиме «Плитки» заблокировано, а не спрятано: все
+ * плитки там равноправны, скрывать нечего, но исчезающий на ровном месте
+ * переключатель читался бы как баг — вместо этого он выключен с пояснением.
+ */
+export function StageViewOptions({
+  layoutMode,
+  onLayoutModeChange,
+  hideOthers,
+  onHideOthersChange,
+}: StageViewProps) {
+  // Радиогруппе нужно имя, уникальное на документ: блок может оказаться на
+  // странице дважды (десктопный поповер и шторка живут в разных ветках
+  // рендера, но полагаться на это не стоит).
+  const groupName = useId()
+  const hideOthersDisabled = layoutMode === 'tiles'
+
+  return (
+    <div className="stage-view-options">
+      <fieldset className="stage-view-modes">
+        <legend>Режим показа</legend>
+        {STAGE_LAYOUT_MODE_OPTIONS.map((option) => (
+          <label
+            key={option.mode}
+            className={`stage-view-mode${layoutMode === option.mode ? ' is-active' : ''}`}
+          >
+            <input
+              type="radio"
+              name={groupName}
+              value={option.mode}
+              checked={layoutMode === option.mode}
+              onChange={() => onLayoutModeChange(option.mode)}
+            />
+            <span className="stage-view-mode-text">
+              <span className="stage-view-mode-title">{option.title}</span>
+              <span className="stage-view-mode-hint">{option.hint}</span>
+            </span>
+          </label>
+        ))}
+      </fieldset>
+
+      <label className={`stage-view-toggle${hideOthersDisabled ? ' is-disabled' : ''}`}>
+        <input
+          type="checkbox"
+          checked={hideOthers}
+          disabled={hideOthersDisabled}
+          onChange={(e) => onHideOthersChange(e.target.checked)}
+        />
+        <span>Скрыть остальных участников</span>
+      </label>
+      {hideOthersDisabled && (
+        <p className="stage-view-note">В режиме «Плитки» все участники равноправны — скрывать нечего.</p>
+      )}
+    </div>
+  )
+}
+
+/**
+ * Кнопка «Вид» в тулбаре с поповером над ней — десктопный вход в
+ * `StageViewOptions`. На мобильном не рендерится вовсе (см. `RoomToolbar`):
+ * там тулбар и так ужат до пяти кнопок, а те же настройки доступны секцией
+ * «Вид» в шторке настроек.
+ *
+ * Закрытие по клику вне и Escape — тем же паттерном, что меню пользователя в
+ * `ShellTopbar` (слушатели на document, пока меню открыто).
+ */
+export function StageViewMenu(props: StageViewProps) {
+  const [open, setOpen] = useState(false)
+  const wrapRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    if (!open) return
+
+    function handlePointerDown(event: MouseEvent) {
+      if (wrapRef.current && !wrapRef.current.contains(event.target as Node)) {
+        setOpen(false)
+      }
+    }
+    function handleKeydown(event: KeyboardEvent) {
+      if (event.key === 'Escape') setOpen(false)
+    }
+
+    document.addEventListener('mousedown', handlePointerDown)
+    document.addEventListener('keydown', handleKeydown)
+    return () => {
+      document.removeEventListener('mousedown', handlePointerDown)
+      document.removeEventListener('keydown', handleKeydown)
+    }
+  }, [open])
+
+  return (
+    <div className="tb-menu-wrap" ref={wrapRef}>
+      <button
+        type="button"
+        className={`tb-btn${open ? ' is-panel-open' : ''}`}
+        aria-label="Вид сцены"
+        aria-expanded={open}
+        aria-haspopup="dialog"
+        onClick={() => setOpen((v) => !v)}
+      >
+        <span className="icon-shell">
+          <LayoutGrid className="lucide" aria-hidden="true" />
+        </span>
+        <span className="label">Вид</span>
+      </button>
+      {open && (
+        <div className="tb-menu" role="dialog" aria-label="Вид сцены">
+          <StageViewOptions {...props} />
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/hooks/useChat.ts

@@ -24,10 +24,44 @@ export interface ChatMessageOut {
  */
 export type ChatConnectionStatus = 'connecting' | 'open' | 'closed' | 'error'
 
+/**
+ * Один участник в очереди поднятых рук (задача B1) — 1:1 с pydantic-схемой
+ * `HandQueueEntryOut` backend. `identity` — тот же формат, что и
+ * `Participant.identity` в LiveKit (`str(user_id)` либо `guest:{id}`),
+ * пригоден для прямого сравнения с `localParticipant.identity`/
+ * `participant.identity` на сцене.
+ */
+export interface HandQueueEntry {
+  identity: string
+  name: string
+  raised_at: string
+}
+
+/** Источник трека, принудительно выключенного организатором (задача B2). */
+export type ForcedMuteSource = 'microphone' | 'camera'
+
+/**
+ * Одно событие принудительного мьюта (задача B2) — рассылается ВСЕМ
+ * участникам конференции (канал общий, адресной доставки нет), поэтому
+ * несёт `identity` затронутого: получатель сам решает, про него ли это
+ * (см. `ForcedMuteWatcher` — сравнивает с `localParticipant.identity`).
+ * `nonce` — счётчик хука, растёт на каждое полученное событие: тот же
+ * `source`/`identity` два раза подряд (например, повторный клик
+ * организатора на уже выключенный трек) должен переоткрыть тост, а не
+ * молча схлопнуться в один и тот же объект по `useEffect`-сравнению.
+ */
+export interface ForcedMuteEvent {
+  identity: string
+  source: ForcedMuteSource
+  nonce: number
+}
+
 type IncomingFrame =
   | { type: 'history'; messages: ChatMessageOut[] }
   | { type: 'message'; message: ChatMessageOut }
   | { type: 'error'; code: string }
+  | { type: 'hand_queue'; queue: HandQueueEntry[] }
+  | { type: 'forced_mute'; identity: string; source: ForcedMuteSource }
 
 interface UseChatOptions {
   /** id конференции — пока не известен (страница ещё не подключилась к LiveKit), WS не открываем. */
@@ -47,6 +81,23 @@ interface UseChatResult {
   unavailable: boolean
   /** Отправить сообщение (1..2000 символов после strip, пустое/слишком длинное — игнорируется). */
   sendMessage: (text: string) => void
+  /**
+   * Очередь поднятых рук, упорядоченная по времени поднятия — сервер
+   * присылает полный снапшот при любом изменении (см. `schemas/room_events.py`
+   * backend), поэтому клиенту не нужно вести собственное состояние очереди.
+   * Пуста, пока WS не открыт/не пришёл первый снапшот.
+   */
+  handQueue: HandQueueEntry[]
+  /** Поднять СВОЮ руку — повторный вызов на уже поднятой руке безвреден (идемпотентно на сервере). */
+  raiseHand: () => void
+  /**
+   * Опустить руку — свою (без аргумента) либо чужую по `identity` (только
+   * организатору, иначе сервер отклонит `{type:"error",code:"forbidden"}`,
+   * см. `statusMessage`).
+   */
+  lowerHand: (identity?: string) => void
+  /** Последнее событие принудительного мьюта (задача B2) — `null` до первого. */
+  lastForcedMute: ForcedMuteEvent | null
 }
 
 /** Close-коды сервера — см. зафиксированный протокол WS. */
@@ -61,16 +112,30 @@ function buildChatWsUrl(conferenceId: string): string {
 }
 
 /**
- * WS-клиент чата комнаты конференции. Реализует зафиксированный протокол:
- * connect → `{type:"auth"}` → `{type:"history"}` → далее входящие
- * `{type:"message"}`/`{type:"error"}`.
+ * WS-клиент комнаты конференции (несмотря на имя — не только чат, задача
+ * B1). Реализует зафиксированный протокол: connect → `{type:"auth"}` →
+ * `{type:"history"}` → `{type:"hand_queue"}` → далее входящие
+ * `{type:"message"}`/`{type:"hand_queue"}`/`{type:"error"}`.
  *
- * Optimistic-append собственных сообщений НЕ делается: сервер всегда
+ * Очередь поднятых рук (`raiseHand`/`lowerHand`/`handQueue`) едет по тому же
+ * соединению, что и чат, — переиспользование уже открытого аутентифицированного
+ * WS дешевле отдельного эндпоинта (см. `backend/api/chat.py`). Следствие:
+ * поднять руку нельзя, если чат выключен настройкой инстанса (`enabled=false`,
+ * соединение вообще не открывается) — принятый компромисс, обоснование в
+ * коммите задачи B1.
+ *
+ * Optimistic-append собственных сообщений чата НЕ делается: сервер всегда
  * присылает наше же сообщение обратно echo-фреймом `message` — если
  * добавлять его на клиенте сразу при отправке, оно задублируется в списке.
+ * Очередь рук устроена иначе: сервер шлёт ПОЛНЫЙ снапшот на каждое
+ * изменение, поэтому `raiseHand`/`lowerHand` ничего не трогают в состоянии
+ * сами — ждут снапшот.
  */
 export function useChat({ conferenceId, token, enabled }: UseChatOptions): UseChatResult {
   const [messages, setMessages] = useState<ChatMessageOut[]>([])
+  const [handQueue, setHandQueue] = useState<HandQueueEntry[]>([])
+  const [lastForcedMute, setLastForcedMute] = useState<ForcedMuteEvent | null>(null)
+  const forcedMuteNonceRef = useRef(0)
   // `wsStatus` меняется ТОЛЬКО из колбэков реального WS-соединения (см. ниже) —
   // никогда синхронно в теле эффекта, иначе react-hooks/set-state-in-effect
   // (эффект без активной подписки, только синхронизирующий производное
@@ -106,6 +171,7 @@ export function useChat({ conferenceId, token, enabled }: UseChatOptions): UseCh
     ws.onopen = () => {
       if (stale) return
       setMessages([])
+      setHandQueue([])
       setStatusMessage(null)
       setUnavailable(false)
       setWsStatus('open')
@@ -124,9 +190,19 @@ export function useChat({ conferenceId, token, enabled }: UseChatOptions): UseCh
         setMessages(frame.messages)
       } else if (frame.type === 'message') {
         setMessages((prev) => [...prev, frame.message])
+      } else if (frame.type === 'hand_queue') {
+        setHandQueue(frame.queue)
+      } else if (frame.type === 'forced_mute') {
+        forcedMuteNonceRef.current += 1
+        setLastForcedMute({
+          identity: frame.identity,
+          source: frame.source,
+          nonce: forcedMuteNonceRef.current,
+        })
       } else if (frame.type === 'error') {
-        // Ошибка отдельной операции (например, отклонённое сообщение) — соединение
-        // не рвётся, просто короткое пояснение пользователю.
+        // Ошибка отдельной операции (например, отклонённое сообщение или
+        // запрет опустить чужую руку не-организатору, code:"forbidden") —
+        // соединение не рвётся, просто короткое пояснение пользователю.
         setStatusMessage(`Ошибка чата: ${frame.code}`)
       }
     }
@@ -168,10 +244,32 @@ export function useChat({ conferenceId, token, enabled }: UseChatOptions): UseCh
     ws.send(JSON.stringify({ type: 'message', text: trimmed }))
   }, [])
 
+  const raiseHand = useCallback(() => {
+    const ws = wsRef.current
+    if (!ws || ws.readyState !== WebSocket.OPEN) return
+    ws.send(JSON.stringify({ type: 'raise_hand' }))
+  }, [])
+
+  const lowerHand = useCallback((identity?: string) => {
+    const ws = wsRef.current
+    if (!ws || ws.readyState !== WebSocket.OPEN) return
+    ws.send(JSON.stringify({ type: 'lower_hand', identity: identity ?? null }))
+  }, [])
+
   // Наружу — производный статус: пока подключаться нечем (выключено/нет
   // conferenceId/token), всегда `closed`, даже если внутренний `wsStatus`
   // ещё хранит значение от предыдущего подключения.
   const status: ChatConnectionStatus = canConnect ? wsStatus : 'closed'
 
-  return { messages, status, statusMessage, unavailable, sendMessage }
+  return {
+    messages,
+    status,
+    statusMessage,
+    unavailable,
+    sendMessage,
+    handQueue,
+    raiseHand,
+    lowerHand,
+    lastForcedMute,
+  }
 }

frontend/src/hooks/useIsCompactViewport.ts

@@ -0,0 +1,27 @@
+import { useEffect, useState } from 'react'
+
+/** Совпадает с мобильным брейкпоинтом комнаты (`room.css`, `max-width: 600px`). */
+const COMPACT_VIEWPORT_QUERY = '(max-width: 600px)'
+
+/**
+ * Живое отслеживание мобильной ширины — та же схема, что системная тема в
+ * `useTheme.ts` (matchMedia + change-листенер).
+ *
+ * Нужен там, где мобильный вариант — это ДРУГАЯ разметка, а не другие стили:
+ * шторка вместо модалки (`DeviceSettingsDialog`) и условный рендеринг кнопок
+ * тулбара (`RoomToolbar`). Прятать элементы новым CSS-правилом поверх
+ * медиазапроса в `room.css` намеренно не стали — там уже была битва
+ * специфичности (см. комментарий в конце `room.css`).
+ */
+export function useIsCompactViewport(): boolean {
+  const [isCompact, setIsCompact] = useState(() => window.matchMedia(COMPACT_VIEWPORT_QUERY).matches)
+
+  useEffect(() => {
+    const media = window.matchMedia(COMPACT_VIEWPORT_QUERY)
+    const handleChange = (event: MediaQueryListEvent) => setIsCompact(event.matches)
+    media.addEventListener('change', handleChange)
+    return () => media.removeEventListener('change', handleChange)
+  }, [])
+
+  return isCompact
+}

frontend/src/hooks/useIsOrganizer.ts

@@ -0,0 +1,13 @@
+import { useLocalParticipant } from '@livekit/components-react'
+import { parseParticipantMetadata } from '@/lib/participantMetadata'
+
+/**
+ * Организатор ли ТЕКУЩИЙ (локальный) участник комнаты — читает подсказку
+ * `is_organizer` из метаданных собственного LiveKit-токена (см.
+ * `lib/participantMetadata.ts`). Только для UI (показать/скрыть кнопки
+ * организатора) — серверные действия перепроверяют права по БД сами.
+ */
+export function useIsOrganizer(): boolean {
+  const { localParticipant } = useLocalParticipant()
+  return Boolean(parseParticipantMetadata(localParticipant.metadata).is_organizer)
+}

frontend/src/lib/participantMetadata.ts

@@ -0,0 +1,26 @@
+/**
+ * Метаданные участника из LiveKit access-токена (см. `AccessToken.with_metadata`
+ * на backend, `services/conference_access.py::build_join`) — JSON
+ * `{"avatar_url"?: string, "is_organizer"?: true}`. У гостей и участников без
+ * аватара/прав организатора соответствующие поля отсутствуют.
+ */
+export interface ParticipantMetadata {
+  avatar_url?: string | null
+  /**
+   * Подсказка для UI — организатор ли участник. НЕ источник авторизации:
+   * метаданные читает и потенциально может подделать сам клиент. Любое
+   * серверное действие организатора (например, принудительный мьют)
+   * перепроверяется backend'ом по владельцу конференции в БД.
+   */
+  is_organizer?: boolean
+}
+
+/** Разобрать `participant.metadata` — пустой объект, если поля нет, метаданные пусты или невалидны. */
+export function parseParticipantMetadata(metadata: string | undefined): ParticipantMetadata {
+  if (!metadata) return {}
+  try {
+    return JSON.parse(metadata) as ParticipantMetadata
+  } catch {
+    return {}
+  }
+}

frontend/src/lib/stageLayoutMode.ts

@@ -0,0 +1,55 @@
+const STORAGE_KEY = 'vidconf-stage-layout-mode'
+
+/**
+ * Режим показа участников на сцене конференции — выбирается пользователем
+ * явно (до 0.0.11 раскладка выбиралась автоматически по наличию демонстрации
+ * экрана и числу участников).
+ *
+ * - `standard` — один крупный участник (фокус) + остальные в карусели сбоку;
+ *   кто именно в фокусе, по-прежнему решает `pickStageFocus`.
+ * - `tiles` — все участники равными плитками, без выделенного крупного.
+ * - `live-tiles` — равномерная сетка ТОЛЬКО из участников с включённой
+ *   камерой, остальные (камера выключена) — в карусели сбоку.
+ */
+export type StageLayoutMode = 'standard' | 'tiles' | 'live-tiles'
+
+/** Порядок и подписи режимов в переключателе (единый источник для тулбара и мобильной шторки). */
+export const STAGE_LAYOUT_MODE_OPTIONS: readonly {
+  mode: StageLayoutMode
+  title: string
+  hint: string
+}[] = [
+  { mode: 'standard', title: 'Стандарт', hint: 'Крупно — активный участник, остальные сбоку' },
+  { mode: 'tiles', title: 'Плитки', hint: 'Все участники равными плитками' },
+  { mode: 'live-tiles', title: 'Живые плитки', hint: 'Плитками — только с камерой, остальные сбоку' },
+]
+
+function isStageLayoutMode(value: string | null): value is StageLayoutMode {
+  return value === 'standard' || value === 'tiles' || value === 'live-tiles'
+}
+
+/**
+ * Сохранённый режим показа — читается при входе в комнату.
+ *
+ * Персист сделан своим модулем (как `lib/audioOutputDevice.ts`), а не через
+ * `usePersistentUserChoices` LiveKit: их `LocalUserChoices` — фиксированная
+ * структура про устройства и имя, поля для нашей раскладки там нет и добавить
+ * его нельзя. Схема хранения та же: одна строка в localStorage, любые сбои
+ * доступа к нему гасятся (приватный режим/политики браузера).
+ */
+export function loadStageLayoutMode(): StageLayoutMode {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY)
+    return isStageLayoutMode(stored) ? stored : 'standard'
+  } catch {
+    return 'standard'
+  }
+}
+
+export function saveStageLayoutMode(mode: StageLayoutMode): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, mode)
+  } catch {
+    // Сохранение недоступно — выбор продержится до конца сессии в комнате.
+  }
+}

frontend/src/pages/JoinPage.tsx

@@ -143,7 +143,7 @@ export function JoinPage() {
         state: {
           livekitUrl: data.livekit_url,
           token: data.token,
-          roomName: data.room_name,
+          title: resolved.title,
           conferenceId: data.conference_id,
           chatEnabled: data.chat_enabled,
         },

frontend/src/pages/LobbyPage.tsx

@@ -40,7 +40,7 @@ export function LobbyPage() {
         state: {
           livekitUrl: conference.join.livekit_url,
           token: conference.join.token,
-          roomName: conference.join.room_name,
+          title: conference.title,
           conferenceId: conference.join.conference_id,
           chatEnabled: conference.join.chat_enabled,
           number: conference.number,

frontend/src/pages/RoomPage.tsx

@@ -16,13 +16,17 @@ import { RoomTopbar } from '@/components/room/RoomTopbar'
 import { RoomStage } from '@/components/room/RoomStage'
 import { RoomToolbar } from '@/components/room/RoomToolbar'
 import { ChatPanel } from '@/components/room/ChatPanel'
+import { HandQueuePanel } from '@/components/room/HandQueuePanel'
+import { ForcedMuteWatcher } from '@/components/room/ForcedMuteWatcher'
 import { DeviceSettingsDialog } from '@/components/room/DeviceSettingsDialog'
 import { loadAudioOutputDeviceId } from '@/lib/audioOutputDevice'
+import { loadStageLayoutMode, saveStageLayoutMode, type StageLayoutMode } from '@/lib/stageLayoutMode'
 
 interface RoomJoinState {
   livekitUrl: string
   token: string
-  roomName: string
+  /** Название конференции (`ConferenceOut.title`/`ResolveOut.title`) — для топбара, см. `RoomTopbar` и задачу A6. */
+  title?: string | null
   conferenceId?: string
   /** Номер конференции — для инвайт-чипа в топбаре (см. RoomTopbar). Есть только сразу после создания. */
   number?: string
@@ -91,7 +95,7 @@ export function RoomPage() {
           setJoinState({
             livekitUrl: result.livekit_url,
             token: result.token,
-            roomName: result.room_name,
+            title: info.title,
             conferenceId: result.conference_id,
             chatEnabled: result.chat_enabled,
           })
@@ -143,6 +147,18 @@ export function RoomPage() {
   // изначально JoinOut.chat_enabled был true (рассинхрон с админкой в моменте).
   const chatVisible = Boolean(joinState?.chatEnabled) && !chat.unavailable
 
+  // Панель очереди поднятых рук — открыта/закрыта организатором (задача B1).
+  // Саму видимость кнопки/панели решает `useIsOrganizer()` внутри
+  // `RoomToolbar`/`HandQueuePanel` (эти компоненты — дети `LiveKitRoom`, а
+  // `RoomPage` — нет, `useLocalParticipant` здесь не вызвать).
+  const [handQueueOpen, setHandQueueOpen] = useState(false)
+  // Identity участников с поднятой рукой — множеством, для дешёвого `.has()`
+  // на каждой плитке сцены (см. `RoomParticipantTile`).
+  const raisedHandIdentities = useMemo(
+    () => new Set(chat.handQueue.map((entry) => entry.identity)),
+    [chat.handQueue],
+  )
+
   // Корневой контейнер комнаты — цель для fullscreen и источник video-элемента
   // для video-PiP-фолбэка.
   const roomRootRef = useRef<HTMLDivElement>(null)
@@ -150,6 +166,39 @@ export function RoomPage() {
   const pip = useRoomPiP(roomRootRef)
   const [settingsOpen, setSettingsOpen] = useState(false)
 
+  // Вид сцены живёт здесь, а не в `RoomStage`: переключатели — в тулбаре и в
+  // шторке настроек, а сцена их только читает (общий предок).
+  //
+  // Режим показа персистится между заходами в комнату (`lib/stageLayoutMode.ts`,
+  // localStorage) — это устойчивое предпочтение: кто любит «плитки», хочет их
+  // и завтра. А вот «скрыть остальных» намеренно НЕ сохраняется: это разовое
+  // действие по ходу разговора, и войти в новую конференцию сразу без половины
+  // участников — сюрприз, а не удобство. Сбрасывается вместе с уходом со
+  // страницы комнаты.
+  const [layoutMode, setLayoutMode] = useState<StageLayoutMode>(loadStageLayoutMode)
+  const [hideOthers, setHideOthers] = useState(false)
+
+  const handleLayoutModeChange = useCallback((mode: StageLayoutMode) => {
+    setLayoutMode(mode)
+    saveStageLayoutMode(mode)
+  }, [])
+
+  // Закрепление участника из плиточного режима переключает вид на «Стандарт»
+  // (см. докстринг `RoomStage`, `onPinFocus`) — но это НЕ то же самое, что
+  // явный выбор пользователя: переключение не сохраняется в localStorage
+  // (в отличие от `handleLayoutModeChange`), иначе разовое закрепление в этой
+  // встрече поменяло бы устойчивое предпочтение режима для всех следующих.
+  const handlePinFocus = useCallback(() => {
+    setLayoutMode('standard')
+  }, [])
+
+  // Ключ трека, который сцена показывает крупно. Живёт ЗДЕСЬ, а не только
+  // внутри `RoomStage`, потому что при открытии мини-плеера сцена
+  // размонтируется в основном окне и монтируется заново в PiP-окне (портал
+  // ниже) — без этого мостика новый экземпляр начинал бы выбор фокуса с нуля и
+  // открывал мини-окно на самом пользователе. Подробнее — докстринг `RoomStage`.
+  const [stageFocusKey, setStageFocusKey] = useState<string | null>(null)
+
   // Сохранённый выбор устройств — читаем через собственный вызов
   // usePersistentUserChoices (независимый от того, что использует
   // DeviceSettingsDialog: там свой вызов хука со своим состоянием). ВАЖНО:
@@ -162,6 +211,22 @@ export function RoomPage() {
   const { userChoices } = usePersistentUserChoices()
   const roomOptions = useMemo<RoomOptions>(
     () => ({
+      // Оба флага в LiveKit по умолчанию выключены, и без них каждый клиент
+      // подписан на полное качество всех чужих треков независимо от размера
+      // плитки, а каждый паблишер шлёт все слои симулкаста, даже если их никто
+      // не смотрит. На тесте 28.07.2026 (19 участников, ~8 камер) это дало
+      // устойчивые 140–169 Мбит/с исходящего трафика при пике 240, 662 события
+      // `remote bwe: channel congestion detected` и 146 переходов аллокатора
+      // STABLE → DEFICIENT — то есть видимый участникам лаг.
+      //
+      // adaptiveStream: подписка на слой по фактическому размеру плитки на
+      // экране + пауза треков, которые сейчас не отрисованы. Именно на нём
+      // начинает экономить уже написанный код: «скрыть остальных»
+      // (RoomStage) не рендерит карусель, а пагинация StageGrid рендерит
+      // только текущую страницу — неприаттаченные треки считаются невидимыми.
+      // dynacast: паблишер прекращает отдавать слои, на которые нет подписчиков.
+      adaptiveStream: true,
+      dynacast: true,
       audioCaptureDefaults: { deviceId: userChoices.audioDeviceId || undefined },
       videoCaptureDefaults: { deviceId: userChoices.videoDeviceId || undefined },
       // Аудиовыход (колонки/наушники/bluetooth) — отдельный персист, не через
@@ -199,13 +264,13 @@ export function RoomPage() {
         serverUrl={joinState.livekitUrl}
         token={joinState.token}
         connect
-        audio
-        video
+        audio={false}
+        video={false}
         options={roomOptions}
         onDisconnected={handleDisconnected}
       >
         <div data-lk-theme="default" className="room-shell">
-          <RoomTopbar roomName={joinState.roomName} slug={slug} number={joinState.number} />
+          <RoomTopbar title={joinState.title ?? null} slug={slug} number={joinState.number} />
           <div className="room-main">
             {pip.mode === 'document' ? (
               // Сцена сейчас рисуется в PiP-окне (через createPortal ниже) —
@@ -218,7 +283,17 @@ export function RoomPage() {
                 </button>
               </div>
             ) : (
-              <RoomStage />
+              <RoomStage
+                layoutMode={layoutMode}
+                hideOthers={hideOthers}
+                onShowOthers={() => setHideOthers(false)}
+                onHideOthers={() => setHideOthers(true)}
+                initialFocusKey={stageFocusKey}
+                onFocusKeyChange={setStageFocusKey}
+                onPinFocus={handlePinFocus}
+                raisedHandIdentities={raisedHandIdentities}
+                conferenceId={joinState.conferenceId}
+              />
             )}
             {chatVisible && chatOpen && (
               <ChatPanel
@@ -229,6 +304,13 @@ export function RoomPage() {
                 onClose={() => setChatOpen(false)}
               />
             )}
+            {handQueueOpen && (
+              <HandQueuePanel
+                queue={chat.handQueue}
+                onLower={(identity) => chat.lowerHand(identity)}
+                onClose={() => setHandQueueOpen(false)}
+              />
+            )}
           </div>
           <RoomToolbar
             chatVisible={chatVisible}
@@ -242,15 +324,38 @@ export function RoomPage() {
             pipSupported={pip.supported}
             pipActive={pip.active}
             onTogglePiP={pip.toggle}
+            handQueue={chat.handQueue}
+            onRaiseHand={chat.raiseHand}
+            onLowerHand={() => chat.lowerHand()}
+            handQueueOpen={handQueueOpen}
+            onToggleHandQueue={() => setHandQueueOpen((open) => !open)}
+            layoutMode={layoutMode}
+            onLayoutModeChange={handleLayoutModeChange}
+            hideOthers={hideOthers}
+            onHideOthersChange={setHideOthers}
           />
         </div>
-        {settingsOpen && <DeviceSettingsDialog onClose={() => setSettingsOpen(false)} />}
+        {settingsOpen && (
+          <DeviceSettingsDialog
+            onClose={() => setSettingsOpen(false)}
+            layoutMode={layoutMode}
+            onLayoutModeChange={handleLayoutModeChange}
+            hideOthers={hideOthers}
+            onHideOthersChange={setHideOthers}
+          />
+        )}
         {/* Портал внутрь LiveKitRoom (не как сосед снаружи!) — RoomStage,
             рендерящийся в PiP-окне, продолжает читать RoomContext/треки.
             `variant="pip"` — мини-плеер
             показывает только активное окно (одну плитку), без карусели/грида
-            основного окна. */}
-        {pip.pipWindow && createPortal(<RoomStage variant="pip" />, pip.pipWindow.document.body)}
+            основного окна. `initialFocusKey` — то, что было крупно в основном
+            окне: без него мини-окно открывалось на самом пользователе. */}
+        {pip.pipWindow &&
+          createPortal(
+            <RoomStage variant="pip" initialFocusKey={stageFocusKey} onFocusKeyChange={setStageFocusKey} />,
+            pip.pipWindow.document.body,
+          )}
+        <ForcedMuteWatcher event={chat.lastForcedMute} />
       </LiveKitRoom>
     </div>
   )

frontend/src/styles/room.css

@@ -47,7 +47,9 @@
 .room-invite-chip span { font: var(--text-mono-sm); color: var(--color-room-text-secondary); }
 
 .room-main { display: flex; flex: 1; min-height: 0; }
-.stage { flex: 1; display: flex; flex-direction: column; padding: var(--space-5) var(--space-6); gap: var(--space-4); min-width: 0; }
+/* `position: relative` — якорь для кнопки «Показать остальных» (`.stage-show-others`),
+   которая висит оверлеем над сценой, см. её правило ниже. */
+.stage { flex: 1; display: flex; flex-direction: column; padding: var(--space-5) var(--space-6); gap: var(--space-4); min-width: 0; position: relative; }
 
 /*
  * Демонстрация экрана: `object-fit: cover` (дефолт VideoTrack для
@@ -115,6 +117,10 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 @media (max-width: 600px) {
   .stage-tiles.lk-focus-layout { grid-template-columns: 1fr; }
   .stage { padding: var(--space-3) var(--space-4); gap: var(--space-3); }
+  /* Их `.lk-carousel{order:1}` (ставит миниатюры ПОД спикера) больше не
+     действует: прямой ребёнок грида теперь обёртка `.stage-side`, а не сама
+     карусель — переносим порядок на неё, иначе миниатюры уезжают наверх. */
+  .stage-side { order: 1; }
 }
 
 /*
@@ -127,9 +133,149 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
  * `.stage-tiles` в основном окне) плюс подстраховочный `min-height`, чтобы
  * плитка не схлопывалась, если видео ещё не выдало реальные размеры.
  */
-.room-single-tile { flex: 1; min-height: 0; display: flex; }
+.room-single-tile { position: relative; flex: 1; min-height: 0; display: flex; }
 .room-single-tile .lk-participant-tile { flex: 1; min-height: 220px; width: 100%; }
 
+/* Кнопка микрофона мини-плеера (задача A5) — своего тулбара в PiP нет,
+   кнопка лежит поверх единственной плитки левым нижним углом (правый занят
+   штатным `.lk-focus-toggle-button`/нашей булавкой закрепления — тут её нет,
+   в PiP закреплять нечего, но геометрия зеркалит `.room-pin-toggle`). */
+.room-pip-mic-toggle {
+  position: absolute;
+  left: 0.5rem;
+  bottom: 0.5rem;
+  z-index: 5;
+  width: 36px;
+  height: 36px;
+  border-radius: 50%;
+  border: none;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--color-room-mic-on);
+  color: #10331f;
+  cursor: pointer;
+}
+.room-pip-mic-toggle svg { width: 18px; height: 18px; }
+.room-pip-mic-toggle.is-off { background: var(--color-room-danger-bg); color: #fff; }
+
+/*
+ * ---------- Колонка миниатюр (кнопка «Скрыть» + карусель) ----------
+ * Прямой ребёнок `.lk-focus-layout` — вместо самой карусели, потому что над
+ * ней стоит кнопка «Скрыть» (см. `RoomStage`). Карусель занимает весь остаток
+ * колонки: ей важны собственные размеры — `CarouselLayout` по ним и решает,
+ * вертикальная она или горизонтальная (см. комментарий в `RoomStage`).
+ * `min-height: 0` обязателен — иначе flex-элемент не даёт себя сжать и
+ * колонка вылезает за высоту сцены.
+ */
+.stage-side { display: flex; flex-direction: column; gap: var(--space-2); min-width: 0; min-height: 0; }
+.stage-side .lk-carousel { flex: 1; min-height: 0; }
+.stage-side-hide {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  flex-shrink: 0;
+  padding: 6px 10px;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-room-tile-border);
+  background: var(--color-room-tile);
+  color: var(--color-room-text-secondary);
+  font: var(--text-caption);
+  text-transform: none;
+  letter-spacing: normal;
+  cursor: pointer;
+}
+.stage-side-hide:hover { background: var(--color-room-tile-hover); color: var(--color-room-text-primary); }
+.stage-side-hide svg { width: 14px; height: 14px; flex-shrink: 0; }
+
+/*
+ * ---------- Основная область без карусели ----------
+ * `.stage-main-only` — сцена, где карусель не рендерится вовсе: плиточные
+ * режимы («Плитки» всегда, «Живые плитки» когда камеры выключены не у кого),
+ * «Стандарт» с единственным участником и любой режим при включённом «скрыть
+ * остальных». Единственный ребёнок (плитка фокуса или сетка `.stage-grid`)
+ * занимает всё место — тем же приёмом, что `.room-single-tile` выше, но без
+ * `min-height` мини-плеера: в основном окне высота приходит от `.room-main`.
+ */
+.stage-main-only { display: flex; }
+.stage-main-only > * { flex: 1; min-width: 0; min-height: 0; }
+
+/*
+ * ---------- Равномерная сетка плиток (`StageGrid`) ----------
+ * Класс `.lk-grid-layout` библиотеки на месте (оттуда вся геометрия сетки:
+ * `--lk-col-count`/`--lk-row-count`, gap, padding), здесь — только то, чего у
+ * неё нет: сброс минимальных размеров (сетка может жить внутри grid-ячейки
+ * `.lk-focus-layout`, где без `min-*: 0` она распирала бы колонку) и якорь для
+ * собственного переключателя страниц.
+ */
+.stage-grid { position: relative; min-width: 0; min-height: 0; }
+.stage-grid-pages {
+  position: absolute;
+  bottom: calc(var(--lk-grid-gap) / 2);
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 5;
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  padding: 2px;
+  border-radius: var(--radius-full);
+  background: rgba(30, 30, 30, 0.85);
+  border: 1px solid var(--color-room-tile-border);
+  color: var(--color-room-text-primary);
+  font: var(--text-caption);
+}
+.stage-grid-pages button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border: none;
+  border-radius: 50%;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+}
+.stage-grid-pages button:hover:not(:disabled) { background: var(--color-room-tile-hover); }
+.stage-grid-pages button:disabled { opacity: 0.35; cursor: default; }
+.stage-grid-pages svg { width: 16px; height: 16px; }
+.stage-grid-pages span { padding: 0 4px; font-variant-numeric: tabular-nums; }
+
+/*
+ * ---------- Кнопка «Показать остальных» ----------
+ * Единственный видимый способ вернуть скрытую карусель, поэтому висит прямо на
+ * сцене, а не только в меню «Вид»: пользователь не должен «терять» участников
+ * без понятного способа их вернуть. Внизу по центру — там у плиток пусто
+ * (`.lk-participant-metadata` прижата к левому и правому углам).
+ */
+.stage-show-others {
+  position: absolute;
+  bottom: var(--space-5);
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 10;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 16px;
+  border-radius: var(--radius-full);
+  border: 1px solid var(--color-room-tile-border);
+  background: rgba(30, 30, 30, 0.9);
+  color: var(--color-room-text-primary);
+  font: var(--text-body);
+  font-weight: 600;
+  /* Иначе на узком экране подпись ломается на две строки и кнопка вырастает
+     в высоту вдвое (поймали на 390px). */
+  white-space: nowrap;
+  box-shadow: var(--shadow-md);
+  cursor: pointer;
+}
+.stage-show-others:hover { background: var(--color-room-tile-hover); }
+.stage-show-others svg { width: 18px; height: 18px; flex-shrink: 0; }
+
 /* Нижний тулбар: свои кнопки на хуках LiveKit (TrackToggle/DisconnectButton) */
 .room-toolbar {
   display: flex;
@@ -177,6 +323,12 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 .tb-btn.is-sharing span.label { color: var(--color-room-mic-on); font-weight: 700; }
 .tb-btn:disabled { opacity: 0.6; cursor: default; }
 
+/* Кнопка «Рука» — та же зелёная подсветка активного состояния, что у
+   «Демонстрации» (задача B1): своя поднятая рука — такой же позитивный
+   индикатор «я сейчас что-то сигнализирую комнате». */
+.tb-btn.is-hand-raised .icon-shell { background: var(--color-room-mic-on); border-color: var(--color-room-mic-on); color: #10331f; }
+.tb-btn.is-hand-raised span.label { color: var(--color-room-mic-on); font-weight: 700; }
+
 .tb-btn.danger .icon-shell { border-color: var(--color-room-danger); color: var(--color-room-danger); background: transparent; }
 .tb-btn.danger:hover .icon-shell { background: var(--color-room-danger-bg); color: #fff; border-color: var(--color-room-danger-bg); }
 .tb-btn.danger span.label { color: var(--color-room-danger); font-weight: 700; }
@@ -200,6 +352,75 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
   justify-content: center;
 }
 
+/*
+ * ---------- Кнопка «Вид» и её поповер (десктоп) ----------
+ * Обёртка вокруг кнопки тулбара — якорь для всплывающей панели над ней
+ * (`StageViewMenu`). На мобильном ни кнопки, ни поповера нет вовсе: там блок
+ * настроек вида рендерится секцией внутри шторки (условный рендеринг в React,
+ * а не скрытие через CSS, — см. `RoomToolbar`).
+ */
+.tb-menu-wrap { position: relative; display: flex; }
+.tb-menu {
+  position: absolute;
+  bottom: calc(100% + var(--space-2));
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 50;
+  width: 280px;
+  padding: var(--space-4);
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--color-room-tile-border);
+  background: var(--color-room-surface-raised);
+  box-shadow: var(--shadow-room-panel);
+}
+
+/*
+ * ---------- Блок «Вид сцены» (`StageViewOptions`) ----------
+ * Общий для десктопного поповера и мобильной шторки — отсюда нейтральная
+ * геометрия без привязки к контейнеру (ширину задаёт родитель).
+ */
+.stage-view-options { display: flex; flex-direction: column; gap: var(--space-3); }
+/* Секция «Вид» внутри шторки настроек — отбивка как у `.room-field` (свой
+   класс, а не `.room-field`, см. комментарий в `DeviceSettingsDialog`). */
+.stage-view-section { margin-bottom: var(--space-5); }
+.stage-view-modes { display: flex; flex-direction: column; gap: 4px; margin: 0; padding: 0; border: none; }
+.stage-view-modes legend {
+  padding: 0 0 var(--space-2);
+  font: var(--text-caption);
+  color: var(--color-room-text-tertiary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.stage-view-mode {
+  display: flex;
+  align-items: flex-start;
+  gap: 10px;
+  padding: 8px 10px;
+  border-radius: var(--radius-md);
+  border: 1px solid transparent;
+  cursor: pointer;
+}
+.stage-view-mode:hover { background: var(--color-room-tile); }
+.stage-view-mode.is-active { background: var(--color-room-tile); border-color: var(--color-room-speaker-ring); }
+.stage-view-mode input { margin-top: 3px; accent-color: var(--color-room-mic-on); flex-shrink: 0; }
+.stage-view-mode-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.stage-view-mode-title { font: var(--text-body); font-weight: 600; color: var(--color-room-text-primary); }
+.stage-view-mode-hint { font: var(--text-caption); text-transform: none; letter-spacing: normal; color: var(--color-room-text-secondary); }
+
+.stage-view-toggle {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding-top: var(--space-3);
+  border-top: 1px solid var(--color-room-tile-border);
+  font: var(--text-body);
+  color: var(--color-room-text-primary);
+  cursor: pointer;
+}
+.stage-view-toggle input { accent-color: var(--color-room-mic-on); flex-shrink: 0; }
+.stage-view-toggle.is-disabled { color: var(--color-room-text-tertiary); cursor: default; }
+.stage-view-note { margin: 0; font: var(--text-caption); text-transform: none; letter-spacing: normal; color: var(--color-room-text-tertiary); }
+
 /* ---------- Панель чата (см. design/mockups/room.html, .chat-panel) ---------- */
 .chat-panel {
   width: 320px;
@@ -305,6 +526,49 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 }
 .chat-input-row button:disabled { opacity: 0.5; cursor: default; }
 
+.chat-emoji-wrap { position: relative; display: flex; flex-shrink: 0; }
+.chat-emoji-trigger {
+  width: 42px;
+  height: 42px;
+  border-radius: 50%;
+  background: var(--color-room-tile);
+  border: 1px solid var(--color-room-tile-border);
+  color: var(--color-room-text-secondary);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+}
+.chat-emoji-trigger:hover { color: var(--color-room-text-primary); }
+.chat-emoji-trigger.is-open { color: var(--color-room-mic-on); border-color: var(--color-room-speaker-ring); }
+.chat-emoji-trigger:disabled { opacity: 0.5; cursor: default; }
+
+.chat-emoji-popover {
+  position: absolute;
+  bottom: calc(100% + var(--space-2));
+  left: 0;
+  z-index: 50;
+  width: 224px;
+  display: grid;
+  grid-template-columns: repeat(6, 1fr);
+  gap: 2px;
+  padding: var(--space-3);
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--color-room-tile-border);
+  background: var(--color-room-surface-raised);
+  box-shadow: var(--shadow-room-panel);
+}
+.chat-emoji-option {
+  background: none;
+  border: none;
+  font-size: 20px;
+  line-height: 1;
+  padding: 6px;
+  border-radius: var(--radius-md);
+  cursor: pointer;
+}
+.chat-emoji-option:hover { background: var(--color-room-tile); }
+
 @media (max-width: 900px) {
   .chat-panel {
     position: fixed;
@@ -316,6 +580,66 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
   }
 }
 
+/* ---------- Панель очереди поднятых рук (`HandQueuePanel`, задача B1) ----------
+ * Контейнер — `.chat-panel` (та же геометрия и мобильное поведение), список
+ * — свой. */
+.hand-queue-list {
+  list-style: none;
+  margin: 0;
+  padding: var(--space-3);
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+  overflow-y: auto;
+}
+.hand-queue-item {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 12px;
+  border-radius: var(--radius-md);
+  background: var(--color-room-tile);
+}
+.hand-queue-position {
+  flex-shrink: 0;
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  background: var(--color-room-mic-on);
+  color: #10331f;
+  font: var(--text-caption);
+  font-weight: 700;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.hand-queue-name {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font: var(--text-body);
+  color: var(--color-room-text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.hand-queue-name svg { width: 16px; height: 16px; flex-shrink: 0; color: var(--color-room-mic-on); }
+.hand-queue-lower {
+  flex-shrink: 0;
+  padding: 6px 10px;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-room-tile-border);
+  background: transparent;
+  color: var(--color-room-text-secondary);
+  font: var(--text-caption);
+  text-transform: none;
+  letter-spacing: normal;
+  cursor: pointer;
+}
+.hand-queue-lower:hover { background: var(--color-room-tile-hover); color: var(--color-room-text-primary); }
+
 /*
  * ---------- Диалог «Настройки устройств» ----------
  * Нет отдельного макета для диалога в design/mockups/room.html — собран из
@@ -504,6 +828,54 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
   outline-offset: -2px;
 }
 
+/* Бейдж поднятой руки (задача B1) — левый верхний угол, зеркально булавке
+   закрепления (правый верхний). В отличие от булавки ВСЕГДА видим, пока
+   рука поднята, — это статус для ВСЕХ участников, а не собственный
+   элемент управления, видимый по наведению. */
+.room-hand-badge {
+  position: absolute;
+  top: 0.25rem;
+  left: 0.25rem;
+  z-index: 5;
+  display: flex;
+  padding: 0.25rem;
+  border-radius: calc(var(--lk-border-radius, 0.5rem) / 2);
+  background: var(--color-room-mic-on);
+  color: #10331f;
+}
+.room-hand-badge svg { width: 18px; height: 18px; }
+
+/* Кнопки принудительного мьюта организатором (задача B2) — нижний правый
+   угол чужой плитки, видны по наведению (как булавка закрепления) —
+   элемент управления, а не статус, прятать по умолчанию уместно. */
+.room-organizer-controls {
+  position: absolute;
+  bottom: 0.25rem;
+  right: 0.25rem;
+  z-index: 5;
+  display: flex;
+  gap: 4px;
+  opacity: 0;
+  transition: opacity 0.2s ease-in-out;
+  transition-delay: 0.2s;
+}
+.lk-participant-tile:hover .room-organizer-controls,
+.lk-participant-tile:focus-within .room-organizer-controls { opacity: 1; transition-delay: 0s; }
+@media (hover: none) {
+  .room-organizer-controls { opacity: 1; transition-delay: 0s; }
+}
+.room-organizer-controls button {
+  display: flex;
+  padding: 0.25rem;
+  border: none;
+  border-radius: calc(var(--lk-border-radius, 0.5rem) / 2);
+  background: rgba(0, 0, 0, 0.5);
+  color: var(--color-room-text-primary);
+  cursor: pointer;
+}
+.room-organizer-controls button:hover { background: var(--color-room-danger-bg); color: #fff; }
+.room-organizer-controls svg { width: 18px; height: 18px; }
+
 /* ---------- Заглушка «конференция в мини-окне» (Document PiP) ---------- */
 .room-pip-placeholder {
   flex: 1;
@@ -518,17 +890,50 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 }
 .room-pip-placeholder svg { width: 48px; height: 48px; color: var(--color-room-text-tertiary); }
 
-/* ---------- Аватар вместо иконки-заглушки при выключенной камере ---------- */
+/* ---------- Аватар вместо иконки-заглушки при выключенной камере ----------
+ * Размер считается от УЗКОЙ стороны плитки, а не от ширины и высоты по
+ * отдельности. Раньше здесь было `width: 40%; height: 40%` — проценты от
+ * РАЗНЫХ сторон, а круглым `.avatar` делает только `border-radius: 50%`
+ * (shell.css), поэтому на неквадратной плитке (а они почти всегда такие)
+ * получался эллипс. Плюс `max-*: 96px` не давал иконке вырасти на большой
+ * плитке фокуса.
+ *
+ * Механика: контейнером container-запросов делаем `.lk-participant-placeholder`
+ * — блок библиотеки, который `position: absolute; inset: 0`, то есть в
+ * точности повторяет плитку и уже имеет обе размерности (обязательное условие
+ * для `container-type: size`). Контейнер именно на нём, а не на самой
+ * `.lk-participant-tile`: `container-type: size` включает size containment, и
+ * на плитке он отрезал бы её содержимое (видео, метаданные) от влияния на
+ * авторазмер — на placeholder-обёртке внутри ничего, кроме аватара, нет,
+ * ломать нечему.
+ *
+ * `cqmin` — минимум из ширины и высоты контейнера, буквально «узкая сторона»:
+ *   - основная (крупная) плитка — 50cqmin, примерно половина плитки;
+ *   - плитки карусели — во всю узкую сторону минус отступ 5px с каждого края.
+ * `aspect-ratio: 1` + `height: auto` гарантируют круг при любой форме плитки:
+ * диаметр никогда не больше меньшей стороны, дальше иконка уменьшается
+ * пропорционально вместе с плиткой. `min-width: 32px` оставлен — на совсем
+ * крошечной плитке инициалы должны оставаться читаемыми (сжатие плитки ниже
+ * этого порога и так означает, что показывать там нечего).
+ */
+.lk-participant-tile .lk-participant-placeholder {
+  container-type: size;
+}
 .room-tile-avatar {
-  width: 40%;
-  height: 40%;
+  width: 50cqmin;
+  height: auto;
+  aspect-ratio: 1;
   min-width: 32px;
-  min-height: 32px;
-  max-width: 96px;
-  max-height: 96px;
-  font-size: clamp(12px, 3vw, 28px);
+  min-height: 0;
+  max-width: none;
+  max-height: none;
+  font-size: clamp(12px, 20cqmin, 44px);
   font-weight: 700;
 }
+.lk-carousel .room-tile-avatar {
+  width: calc(100cqmin - 10px);
+  font-size: clamp(12px, 34cqmin, 28px);
+}
 
 .room-loader, .room-error {
   display: flex;

install.sh

@@ -526,13 +526,14 @@ docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" up -d --wait postgres r
 # exist" и healthcheck (--wait) никогда не проходит. `compose run` запускает
 # одноразовый контейнер с нужной командой, не поднимая uvicorn/lifespan.
 echo "[install] Применяю миграции Alembic и seed (админ/справочники) — до старта backend"
-docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" run --rm backend uv run alembic upgrade head
-docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" run --rm backend uv run python -m scripts.seed
+# `--no-sync`: окружение собрано в образе, повторная синхронизация в рантайме
+# только тянула бы dev-группу (см. комментарий в backend/Dockerfile).
+docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" run --rm backend uv run --no-sync alembic upgrade head
+docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" run --rm backend uv run --no-sync python -m scripts.seed
 
 echo "[install] docker compose up -d --wait (backend/worker/nginx и остальные сервисы профиля)"
-# Первый старт backend/worker включает `uv run` (синхронизация окружения +
-# компиляция байткода) — на слабой/загруженной машине healthcheck может не
-# успеть пройти за отведённые retries, и `--wait` вернёт "container is
+# На слабой/загруженной машине healthcheck может не успеть пройти за отведённые
+# retries, и `--wait` вернёт "container is
 # unhealthy", хотя сервис через несколько секунд становится healthy. Команда
 # идемпотентна, поэтому повторяем её несколько раз: повтор лишь дожидается
 # уже стартующих контейнеров, ничего не пересоздавая.
@@ -573,7 +574,7 @@ if [ "$FRESH_ENV" != "1" ]; then
     fi
     if [ "$APPLY_PRESET_SETTINGS" = "1" ]; then
         echo "[install] Применяю настройки модулей инстанса под пресет ${PRESET}"
-        docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" exec -T backend uv run python -m scripts.apply_preset_settings --force
+        docker compose -f "$COMPOSE_FILE" --env-file "$ENV_FILE" exec -T backend uv run --no-sync python -m scripts.apply_preset_settings --force
     else
         echo "[install] Настройки модулей инстанса НЕ изменены — сохранены ручные правки администратора"
     fi