release: версия 0.0.19

Задачи B1/B2 добавили в тулбар «Рука» и «Очередь» (до 11 кнопок вместо
исходных 8) — на промежуточных ширинах (~600–1100px) кнопки вылезали за
края тулбара: жёсткого мобильного брейкпоинта (≤600px, скрывает три
кнопки) не хватало, а до него сжатия не было вовсе.

Иконка/отступы/зазоры/шрифт кнопок теперь плавно уменьшаются на диапазоне
1200px → 600px через `clamp()` с явной линейной интерполяцией (обычный
`clamp(min, Nvw, max)` не подошёл — подобранный N упирался в потолок уже на
довольно широких экранах, сжатие получалось резким скачком заметно раньше
нужной ширины, а не плавным). Нижние границы совпадают с тем, что жёстко
выставляет мобильный медиа-запрос на 600px — переход в него визуально
бесшовный.

Побочный эффект сжатия: подпись «Мини-окно» на промежуточных ширинах
переносилась на 2 строки и делала эту кнопку выше соседних. Ниже 1200px
показываем короткое «Мини» вместо полной подписи — кнопка остаётся
однострочной; aria-label по-прежнему несёт полный смысл для скринридеров.

.env.example

@@ -112,7 +112,7 @@ SMTP_TIMEOUT_S=30
 # --- Версия инстанса (релиз v0.0.1) ---
 # install.sh копирует значение из корневого файла VERSION при каждой
 # установке/обновлении — руками менять не нужно.
-VIDCONF_VERSION=0.0.14
+VIDCONF_VERSION=0.0.19
 
 # --- Профили compose. Дефолт ниже (`media,monitoring`) — только для ручного
 # `docker compose up` БЕЗ install.sh: медиа (LiveKit+coturn) + мониторинг,

CHANGELOG.md

@@ -3,6 +3,114 @@
 Формат основан на [Keep a Changelog](https://keepachangelog.com/ru/1.1.0/),
 проект придерживается [семантического версионирования](https://semver.org/lang/ru/).
 
+## [0.0.19] — 2026-08-02
+
+Правки по замечаниям к части B (комната конференции).
+
+### Исправлено
+- Очередь поднятых рук открывалась боковой панелью во весь экран на
+  мобильном — теперь компактный поповер над кнопкой (как «Вид»), размер
+  подстраивается под число записей, после ~10 строк список скроллится.
+- Кнопки нижнего тулбара при сужении окна вылезали за края блока (задачи
+  B1/B2 добавили «Рука»/«Очередь», в тулбаре стало до 11 кнопок вместо
+  восьми) — теперь плавно уменьшаются на диапазоне 1200–600px вместо
+  жёсткого скачка на мобильный вид.
+- Подпись «Мини-окно» на промежуточных ширинах переносилась на 2 строки и
+  делала эту кнопку выше соседних — ниже 1200px показывается короткое
+  «Мини».
+- Эмодзи-поповер в чате красил все свои кнопки в зелёный цвет кнопки
+  «Отправить» (гонка специфичности CSS-селекторов) — исправлено; заодно
+  сетка приведена к ровным 5×6 без неполной строки, добавлены
+  🦾 🚀 🦞 💯 🤷‍♂️.
+
+## [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.

VERSION

@@ -1 +1 @@
-0.0.14
+0.0.19

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/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/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/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

@@ -27,6 +27,7 @@ from repositories.conferences import (
     ConferenceRepository,
     ConferenceSessionRepository,
 )
+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
@@ -154,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(
@@ -308,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

@@ -34,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
 
@@ -130,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)
@@ -217,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:

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,7 @@ services:
       MEDIA_ROOT: ${MEDIA_ROOT:-/app/media}
       # Версия инстанса (релиз v0.0.1) — install.sh копирует значение
       # из файла VERSION (корень репозитория) в .env; отдаётся в GET /api/health.
-      VIDCONF_VERSION: ${VIDCONF_VERSION:-0.0.14}
+      VIDCONF_VERSION: ${VIDCONF_VERSION:-0.0.19}
       # Число процессов uvicorn (см. backend/Dockerfile). Дефолт 2 рассчитан
       # на 4-ядерный сервер, где ядра делятся с LiveKit. Поднимая значение,
       # проверьте бюджет соединений с БД: каждый воркер держит свой пул
@@ -664,6 +671,16 @@ 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

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,21 @@
 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'
+
+/**
+ * Небольшой собственный набор популярных эмодзи — вместо библиотеки-пикера на
+ * сотни килобайт ради десятка кнопок в поповере. Ровно 30 штук (6×5 —
+ * `.chat-emoji-popover` в room.css рассчитан на эту сетку без остатка;
+ * добавляя/убирая эмодзи, держи кратность 5).
+ */
+const EMOJI_OPTIONS = [
+  '😀', '😂', '😊', '😉', '😍', '🤔', '😅', '😢',
+  '😮', '😎', '🙌', '👍', '👎', '👏', '🙏', '❤️',
+  '🔥', '🎉', '✅', '❌', '⚠️', '💡', '👀', '🤝',
+  '🐎', '🦾', '🚀', '🦞', '💯', '🤷‍♂️',
+]
 
 interface ChatPanelProps {
   messages: ChatMessageOut[]
@@ -38,12 +52,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 +78,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 +141,7 @@ export function ChatPanel({ messages, status, statusMessage, onSend, onClose }:
           handleSend()
         }}
       >
+        <EmojiPickerButton onSelect={insertEmoji} disabled={status !== 'open'} />
         <textarea
           ref={textareaRef}
           rows={1}
@@ -118,3 +159,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/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/HandQueueMenu.tsx

@@ -0,0 +1,99 @@
+import { useEffect, useRef, useState } from 'react'
+import { Hand, ListOrdered } from 'lucide-react'
+import { useIsOrganizer } from '@/hooks/useIsOrganizer'
+import type { HandQueueEntry } from '@/hooks/useChat'
+
+interface HandQueueMenuProps {
+  queue: HandQueueEntry[]
+  onLower: (identity: string) => void
+}
+
+/**
+ * Кнопка «Очередь» в тулбаре с поповером над ней — видна только организатору
+ * (задача B1). Тот же самодостаточный паттерн, что и `StageViewMenu` («Вид»):
+ * собственное состояние открытия, закрытие по клику вне/Escape, поповер
+ * `.tb-menu` над кнопкой — а не боковая панель на весь экран (как чат):
+ * очередь рук — короткий список, а не история переписки, разворачивать её
+ * во весь экран незачем и на мобильном.
+ *
+ * Размер поповера подстраивается под число записей — `.hand-queue-list`
+ * растёт вместе со списком и не даёт пустого места при 1–2 поднятых руках,
+ * но не бесконечно: после ~10 строк список упирается в `max-height` и дальше
+ * скроллится (см. room.css) — иначе организатор на энергичной встрече
+ * получил бы поповер выше экрана.
+ */
+export function HandQueueMenu({ queue, onLower }: HandQueueMenuProps) {
+  const isOrganizer = useIsOrganizer()
+  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])
+
+  if (!isOrganizer) return null
+
+  return (
+    <div className="tb-menu-wrap" ref={wrapRef}>
+      <button
+        type="button"
+        className={`tb-btn${open ? ' is-panel-open' : ''}`}
+        aria-pressed={open}
+        aria-expanded={open}
+        aria-haspopup="dialog"
+        aria-label={open ? 'Свернуть очередь поднятых рук' : 'Открыть очередь поднятых рук'}
+        onClick={() => setOpen((v) => !v)}
+      >
+        <span className="icon-shell">
+          <ListOrdered className="lucide" aria-hidden="true" />
+          {queue.length > 0 && (
+            <span className="badge-count">{queue.length > 9 ? '9+' : queue.length}</span>
+          )}
+        </span>
+        <span className="label">Очередь</span>
+      </button>
+      {open && (
+        <div className="tb-menu hand-queue-menu" role="dialog" aria-label="Очередь поднятых рук">
+          {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>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}

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,5 +1,5 @@
 import { useEffect, useState, type ReactNode } from 'react'
-import { EyeOff, Users } from 'lucide-react'
+import { EyeOff, Mic, MicOff, Users } from 'lucide-react'
 import { Track, type Participant } from 'livekit-client'
 import {
   CarouselLayout,
@@ -8,6 +8,7 @@ import {
   isTrackReference,
   useRoomContext,
   useSpeakingParticipants,
+  useTrackToggle,
   useTracks,
   type TrackReferenceOrPlaceholder,
 } from '@livekit/components-react'
@@ -93,6 +94,29 @@ 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 при нескольких
@@ -179,6 +203,9 @@ export function RoomStage({
   onHideOthers,
   initialFocusKey = null,
   onFocusKeyChange,
+  onPinFocus,
+  raisedHandIdentities,
+  conferenceId,
 }: {
   variant?: 'full' | 'pip'
   /** Выбранный пользователем режим показа; игнорируется при `variant="pip"`. */
@@ -193,6 +220,18 @@ export function RoomStage({
   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()
@@ -337,9 +376,16 @@ export function RoomStage({
    * Закрепить/открепить плитку: повторное нажатие на уже закреплённой снимает
    * закрепление. Ключ приходит из самой плитки (она знает свой трек из
    * контекста — в карусели/гриде плитки рендерятся шаблоном, без пропсов).
+   *
+   * Закрепление доступно из ЛЮБОГО режима показа (задача 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?.()
   }
 
   // Мини-плеер показывает ТОЛЬКО активное окно — без карусели/
@@ -350,6 +396,7 @@ export function RoomStage({
     return (
       <section className="stage room-single-tile">
         {focusTrack && <RoomParticipantTile trackRef={focusTrack} onStopSharing={handleStopSharing} />}
+        <PipMicToggle />
         <RoomAudioRenderer />
       </section>
     )
@@ -372,23 +419,25 @@ export function RoomStage({
           : []
         : carouselTracks
   const showCarousel = !hideOthers && sideTracks.length > 0
-  // Закрепление имеет смысл только там, где есть «крупная плитка» —
-  // в плиточных режимах фокуса нет, поэтому и булавки на плитках нет.
-  const pinProps =
-    effectiveMode === 'standard' ? { pinnedKey, onTogglePin: handleTogglePin } : {}
+  // Булавка закрепления есть на КАЖДОЙ плитке во всех режимах (задача 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 />
+          <RoomParticipantTile {...tileProps} />
         </StageGrid>
       )
     }
     if (effectiveMode === 'live-tiles') {
       return (
         <StageGrid tracks={liveCameraTracks.length > 0 ? liveCameraTracks : cameraTracks}>
-          <RoomParticipantTile />
+          <RoomParticipantTile {...tileProps} />
         </StageGrid>
       )
     }
@@ -397,7 +446,7 @@ export function RoomStage({
     if (sideTracks.length === 0 && !hideOthers) {
       return (
         <StageGrid tracks={tracks}>
-          <RoomParticipantTile {...pinProps} />
+          <RoomParticipantTile {...tileProps} />
         </StageGrid>
       )
     }
@@ -405,7 +454,7 @@ export function RoomStage({
     // (см. её исходник), поэтому вместо неё используем свою обёртку
     // напрямую с тем же trackRef (аватар в фокус-плитке).
     return (
-      focusTrack && <RoomParticipantTile trackRef={focusTrack} onStopSharing={handleStopSharing} {...pinProps} />
+      focusTrack && <RoomParticipantTile trackRef={focusTrack} onStopSharing={handleStopSharing} {...tileProps} />
     )
   }
 
@@ -429,7 +478,7 @@ export function RoomStage({
               </button>
             )}
             <CarouselLayout tracks={sideTracks}>
-              <RoomParticipantTile {...pinProps} />
+              <RoomParticipantTile {...tileProps} />
             </CarouselLayout>
           </div>
           {renderMain()}

frontend/src/components/room/RoomToolbar.tsx

@@ -1,4 +1,5 @@
 import {
+  Hand,
   LogOut,
   Maximize,
   MessageSquare,
@@ -13,10 +14,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 type { HandQueueEntry } from '@/hooks/useChat'
 import { StageViewMenu, type StageViewProps } from '@/components/room/StageViewOptions'
+import { HandQueueMenu } from '@/components/room/HandQueueMenu'
 
 /**
  * Опции захвата демонстрации экрана: `audio: true` — звук
@@ -55,18 +58,35 @@ interface RoomToolbarProps extends StageViewProps {
   pipSupported: boolean
   pipActive: boolean
   onTogglePiP: () => void
+  /**
+   * Очередь поднятых рук целиком (задача B1, `useChat().handQueue`) — сама
+   * решает, поднята ли СВОЯ рука (сравнивая с `localParticipant.identity`
+   * через `useLocalParticipant`), и показывает бейдж общего счётчика.
+   */
+  handQueue: HandQueueEntry[]
+  onRaiseHand: () => void
+  onLowerHand: () => void
+  /** Опустить ЧУЖУЮ руку по identity — только организатору (панель очереди, `HandQueueMenu`). */
+  onLowerHandById: (identity: string) => void
 }
 
 /**
- * Нижний тулбар комнаты: микрофон/камера/демонстрация экрана/вид сцены/
- * настройки устройств/полноэкранный режим/мини-плеер/чат/выход — собственные
- * кнопки на хуках LiveKit (useTrackToggle/DisconnectButton) и панели чата,
- * стилизованные по design/mockups/room.html.
+ * Нижний тулбар комнаты: микрофон/камера/демонстрация экрана/рука/очередь
+ * рук/вид сцены/настройки устройств/полноэкранный режим/мини-плеер/чат/выход —
+ * собственные кнопки на хуках LiveKit (useTrackToggle/DisconnectButton) и
+ * панели чата, стилизованные по design/mockups/room.html.
  *
  * Кнопка «Вид» (режимы показа и скрытие остальных) рендерится ТОЛЬКО на
  * широком экране — условным рендерингом, а не скрытием через CSS: тулбар на
- * мобильном и так ужат до пяти кнопок, а те же настройки там доступны секцией
- * «Вид» в шторке настроек (`DeviceSettingsDialog`).
+ * мобильном и так ужат до пяти «безусловных» кнопок (демонстрация/
+ * полноэкранный режим/мини-плеер скрыты на узком экране через CSS, см.
+ * `styles/room.css`), а те же настройки там доступны секцией «Вид» в шторке
+ * настроек (`DeviceSettingsDialog`). «Рука» — сознательное исключение из этой
+ * экономии: поднять руку посреди разговора — действие со временем жизни в
+ * секунды, прятать его в шторку настроек означало бы делать его практически
+ * недоступным с телефона. «Очередь» показывается только организатору —
+ * встречается редко, но по той же причине оставлена в тулбаре, а не в
+ * шторке: организатору с телефона тоже нужно видеть очередь сразу.
  */
 export function RoomToolbar({
   chatVisible,
@@ -80,6 +100,10 @@ export function RoomToolbar({
   pipSupported,
   pipActive,
   onTogglePiP,
+  handQueue,
+  onRaiseHand,
+  onLowerHand,
+  onLowerHandById,
   layoutMode,
   onLayoutModeChange,
   hideOthers,
@@ -87,6 +111,8 @@ export function RoomToolbar({
 }: RoomToolbarProps) {
   const toast = useToast()
   const isCompact = useIsCompactViewport()
+  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({
@@ -152,6 +178,24 @@ 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>
+
+      <HandQueueMenu queue={handQueue} onLower={onLowerHandById} />
+
       {!isCompact && (
         <StageViewMenu
           layoutMode={layoutMode}
@@ -203,7 +247,14 @@ export function RoomToolbar({
           <span className="icon-shell">
             <PictureInPicture2 className="lucide" aria-hidden="true" />
           </span>
-          <span className="label">Мини-окно</span>
+          {/* На узком экране («Мини-окно» иначе переносится на 2 строки и
+              кнопка становится выше соседних, см. .label-full/.label-short
+              в room.css) — только «Мини». Текст, не структура: aria-label
+              выше уже несёт полный смысл независимо от видимой подписи. */}
+          <span className="label">
+            <span className="label-full">Мини-окно</span>
+            <span className="label-short">Мини</span>
+          </span>
         </button>
       )}
 

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/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/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/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,6 +16,7 @@ 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 { ForcedMuteWatcher } from '@/components/room/ForcedMuteWatcher'
 import { DeviceSettingsDialog } from '@/components/room/DeviceSettingsDialog'
 import { loadAudioOutputDeviceId } from '@/lib/audioOutputDevice'
 import { loadStageLayoutMode, saveStageLayoutMode, type StageLayoutMode } from '@/lib/stageLayoutMode'
@@ -23,7 +24,8 @@ import { loadStageLayoutMode, saveStageLayoutMode, type StageLayoutMode } from '
 interface RoomJoinState {
   livekitUrl: string
   token: string
-  roomName: string
+  /** Название конференции (`ConferenceOut.title`/`ResolveOut.title`) — для топбара, см. `RoomTopbar` и задачу A6. */
+  title?: string | null
   conferenceId?: string
   /** Номер конференции — для инвайт-чипа в топбаре (см. RoomTopbar). Есть только сразу после создания. */
   number?: string
@@ -92,7 +94,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,
           })
@@ -144,6 +146,13 @@ export function RoomPage() {
   // изначально JoinOut.chat_enabled был true (рассинхрон с админкой в моменте).
   const chatVisible = Boolean(joinState?.chatEnabled) && !chat.unavailable
 
+  // 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)
@@ -168,6 +177,15 @@ export function RoomPage() {
     saveStageLayoutMode(mode)
   }, [])
 
+  // Закрепление участника из плиточного режима переключает вид на «Стандарт»
+  // (см. докстринг `RoomStage`, `onPinFocus`) — но это НЕ то же самое, что
+  // явный выбор пользователя: переключение не сохраняется в localStorage
+  // (в отличие от `handleLayoutModeChange`), иначе разовое закрепление в этой
+  // встрече поменяло бы устойчивое предпочтение режима для всех следующих.
+  const handlePinFocus = useCallback(() => {
+    setLayoutMode('standard')
+  }, [])
+
   // Ключ трека, который сцена показывает крупно. Живёт ЗДЕСЬ, а не только
   // внутри `RoomStage`, потому что при открытии мини-плеера сцена
   // размонтируется в основном окне и монтируется заново в PiP-окне (портал
@@ -240,13 +258,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 ниже) —
@@ -266,6 +284,9 @@ export function RoomPage() {
                 onHideOthers={() => setHideOthers(true)}
                 initialFocusKey={stageFocusKey}
                 onFocusKeyChange={setStageFocusKey}
+                onPinFocus={handlePinFocus}
+                raisedHandIdentities={raisedHandIdentities}
+                conferenceId={joinState.conferenceId}
               />
             )}
             {chatVisible && chatOpen && (
@@ -290,6 +311,10 @@ export function RoomPage() {
             pipSupported={pip.supported}
             pipActive={pip.active}
             onTogglePiP={pip.toggle}
+            handQueue={chat.handQueue}
+            onRaiseHand={chat.raiseHand}
+            onLowerHand={() => chat.lowerHand()}
+            onLowerHandById={(identity) => chat.lowerHand(identity)}
             layoutMode={layoutMode}
             onLayoutModeChange={handleLayoutModeChange}
             hideOthers={hideOthers}
@@ -316,6 +341,7 @@ export function RoomPage() {
             <RoomStage variant="pip" initialFocusKey={stageFocusKey} onFocusKeyChange={setStageFocusKey} />,
             pip.pipWindow.document.body,
           )}
+        <ForcedMuteWatcher event={chat.lastForcedMute} />
       </LiveKitRoom>
     </div>
   )

frontend/src/styles/room.css

@@ -133,9 +133,32 @@ 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` — вместо самой карусели, потому что над
@@ -254,32 +277,54 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 .stage-show-others svg { width: 18px; height: 18px; flex-shrink: 0; }
 
 /* Нижний тулбар: свои кнопки на хуках LiveKit (TrackToggle/DisconnectButton) */
+/*
+ * Кнопки тулбара плавно уменьшаются (иконка/отступы/шрифт/зазор) на всём
+ * диапазоне 1200px → 600px — до этого тулбар стал шире, чем при исходном
+ * проектировании (задачи B1/B2 добавили «Рука»/«Очередь», раньше помещались
+ * без сжатия 8 кнопок, теперь до 11 — без этого блока получался
+ * горизонтальный оверфлоу вплоть до самого мобильного брейкпоинта, кнопки
+ * вылезали за края тулбара).
+ *
+ * Обычный `clamp(min, Nvw, max)` тут не подходит: подобранный `N`
+ * дотягивается до `max` уже на довольно узких экранах (например,
+ * `3vw` = 24px ровно на 800px viewport) и дальше просто стоит на потолке —
+ * получается не плавное сжатие в нужном диапазоне, а резкий скачок сильно
+ * раньше нужной ширины (поймали именно так на первой версии этого блока).
+ * Вместо этого — явная линейная интерполяция между двумя точками
+ * (600px→минимум, 1200px→максимум): `calc(MIN + (MAX-MIN) * (100vw - 600px)
+ * / 600)`, снаружи в `clamp()` только чтобы намертво остановиться на
+ * границах диапазона. Нижние границы — те же значения, что жёстко
+ * выставляет мобильный медиа-запрос ниже (`max-width: 600px`), поэтому
+ * переход в него на 600px визуально бесшовный.
+ */
 .room-toolbar {
   display: flex;
   align-items: center;
   justify-content: center;
-  gap: var(--space-2);
+  gap: clamp(2px, calc(2px + (100vw - 600px) * 6 / 600), var(--space-2));
   background: var(--color-room-surface);
   border-top: 1px solid var(--color-room-tile-border);
-  padding: var(--space-3) var(--space-6);
+  padding: var(--space-3) clamp(8px, calc(8px + (100vw - 600px) * 16 / 600), var(--space-6));
   flex-shrink: 0;
 }
 .tb-btn {
   display: flex;
   flex-direction: column;
   align-items: center;
-  gap: 4px;
+  gap: clamp(2px, calc(2px + (100vw - 600px) * 2 / 600), 4px);
   background: transparent;
   border: none;
-  padding: 8px 18px;
+  padding:
+    clamp(6px, calc(6px + (100vw - 600px) * 2 / 600), 8px)
+    clamp(6px, calc(6px + (100vw - 600px) * 12 / 600), 18px);
   border-radius: var(--radius-md);
   color: var(--color-room-text-primary);
-  min-width: 76px;
+  min-width: clamp(0px, calc((100vw - 600px) * 76 / 600), 76px);
   cursor: pointer;
 }
 .tb-btn .icon-shell {
-  width: 48px;
-  height: 48px;
+  width: clamp(40px, calc(40px + (100vw - 600px) * 8 / 600), 48px);
+  height: clamp(40px, calc(40px + (100vw - 600px) * 8 / 600), 48px);
   border-radius: 50%;
   display: flex;
   align-items: center;
@@ -288,9 +333,27 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
   background: var(--color-room-tile);
   color: var(--color-room-text-primary);
 }
-.tb-btn span.label { font: var(--text-caption); text-transform: none; letter-spacing: normal; color: var(--color-room-text-secondary); font-weight: 500; }
+.tb-btn span.label {
+  font: var(--text-caption);
+  font-size: clamp(11px, calc(11px + (100vw - 600px) * 1 / 600), 12px);
+  text-transform: none;
+  letter-spacing: normal;
+  color: var(--color-room-text-secondary);
+  font-weight: 500;
+}
 .tb-btn:hover .icon-shell { background: var(--color-room-tile-hover); }
 
+/* Короткая подпись мини-окна (см. RoomToolbar.tsx) — «Мини-окно» на узком
+   экране переносится на 2 строки и делает эту кнопку выше соседних; ниже
+   порога, где начинается перенос, прячем длинный вариант и показываем
+   короткий «Мини» — кнопка остаётся однострочной и той же высоты, что и
+   остальные. */
+.tb-btn .label-short { display: none; }
+@media (max-width: 1200px) {
+  .tb-btn .label-full { display: none; }
+  .tb-btn .label-short { display: inline; }
+}
+
 .tb-btn.is-off .icon-shell { background: var(--color-room-mic-off); border-color: var(--color-room-mic-off); color: #3a0f16; }
 .tb-btn.is-off span.label { color: var(--color-room-mic-off); font-weight: 700; }
 
@@ -300,6 +363,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; }
@@ -497,6 +566,62 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
 }
 .chat-input-row button:disabled { opacity: 0.5; cursor: default; }
 
+/* Триггер и опции эмодзи-поповера лежат внутри `.chat-input-row` (форма
+   отправки) — тот же контейнер, что у круглой зелёной кнопки «Отправить»
+   (`.chat-input-row button`, специфичность 0,1,1). Голого класса
+   (`.chat-emoji-trigger`/`.chat-emoji-option`, 0,1,0) для победы над ней не
+   хватает — ЛЮБАЯ кнопка внутри формы (включая кнопки в самом поповере,
+   он тоже в этом поддереве) красилась в зелёный независимо от порядка
+   правил в файле. Каждый селектор ниже уточнён родительским классом ровно
+   затем, чтобы обойти именно эту гонку специфичности. */
+.chat-emoji-wrap { position: relative; display: flex; flex-shrink: 0; }
+.chat-emoji-wrap .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-wrap .chat-emoji-trigger:hover { color: var(--color-room-text-primary); }
+.chat-emoji-wrap .chat-emoji-trigger.is-open { color: var(--color-room-mic-on); border-color: var(--color-room-speaker-ring); }
+.chat-emoji-wrap .chat-emoji-trigger:disabled { opacity: 0.5; cursor: default; }
+
+/* 5 колонок × 6 строк — ровно 30 эмодзи в EMOJI_OPTIONS (ChatPanel.tsx), без
+   неполной последней строки. */
+.chat-emoji-popover {
+  position: absolute;
+  bottom: calc(100% + var(--space-2));
+  left: 0;
+  z-index: 50;
+  width: 220px;
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+  gap: 4px;
+  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-popover .chat-emoji-option {
+  aspect-ratio: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: none;
+  border: none;
+  font-size: 20px;
+  line-height: 1;
+  border-radius: var(--radius-md);
+  cursor: pointer;
+}
+.chat-emoji-popover .chat-emoji-option:hover { background: var(--color-room-tile); }
+
 @media (max-width: 900px) {
   .chat-panel {
     position: fixed;
@@ -508,6 +633,72 @@ video[data-lk-source='screen_share'] { object-fit: contain; background: #000; }
   }
 }
 
+/* ---------- Поповер очереди поднятых рук (`HandQueueMenu`, задача B1) ----------
+ * Контейнер — `.tb-menu` (тот же поповер над кнопкой, что у «Вида»), не
+ * `.chat-panel`: очередь — короткий список, а не история переписки,
+ * разворачивать её на весь экран/боковой панелью незачем даже на мобильном. */
+.hand-queue-menu { width: 300px; padding: var(--space-3); }
+.hand-queue-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+  /* Высота растёт вместе со списком (при 1–2 записях поповер компактный), но
+     не безгранично — после ~10 строк упирается в потолок и скроллится
+     дальше, иначе на энергичной встрече поповер вылез бы выше экрана. */
+  max-height: 460px;
+  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 — собран из
@@ -696,6 +887,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;