fix: add GetGroupAttendanceStatsAsync stub to FakeSessionStore in tests

Resolves CS0535 build failure in test project.

.env.example

@@ -6,5 +6,12 @@ TELEGRAM_BOT_TOKEN=YOUR_BOT_TOKEN_HERE
 # Найти его можно в информации о боте у @BotFather.
 TELEGRAM_BOT_USERNAME=YOUR_BOT_USERNAME_HERE
 
+# HTTPS URL Mini App dashboard, например: https://your-domain.example/miniapp
+# Используется ботом для кнопки меню Telegram и кнопки /start.
+TELEGRAM_MINI_APP_URL=
+
 # Пароль для базы данных PostgreSQL
 POSTGRES_PASSWORD=StrongPasswordForDatabase
+
+# Локальный порт веб-интерфейса GM-Relay
+GMRELAY_WEB_PORT=8080

.gitea/workflows/deploy.yml

@@ -6,7 +6,7 @@ on:
       - main 
 
 env:
-  VERSION: 1.0.0
+  VERSION: 1.10.0
 
 jobs:
   # ЧАСТЬ 1: Собираем образы и кладем в Gitea (чтобы делиться с ребятами)
@@ -23,29 +23,33 @@ jobs:
           username: toutsu
           password: ${{ secrets.GIT_TOKEN }}
 
-      - name: Build and push Bot
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: src/GmRelay.Bot/Dockerfile
-          push: true
-          tags: |
-            git.codeanddice.ru/toutsu/gmrelay-bot:latest
-            git.codeanddice.ru/toutsu/gmrelay-bot:${{ env.VERSION }}
-          labels: |
-            org.opencontainers.image.source=https://git.codeanddice.ru/${{ gitea.repository }}
+      - name: Build Bot image
+        run: |
+          docker build \
+            --label "org.opencontainers.image.source=https://git.codeanddice.ru/${{ gitea.repository }}" \
+            -f src/GmRelay.Bot/Dockerfile \
+            -t git.codeanddice.ru/toutsu/gmrelay-bot:latest \
+            -t git.codeanddice.ru/toutsu/gmrelay-bot:${{ env.VERSION }} \
+            .
 
-      - name: Build and push Web
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: src/GmRelay.Web/Dockerfile
-          push: true
-          tags: |
-            git.codeanddice.ru/toutsu/gmrelay-web:latest
-            git.codeanddice.ru/toutsu/gmrelay-web:${{ env.VERSION }}
-          labels: |
-            org.opencontainers.image.source=https://git.codeanddice.ru/${{ gitea.repository }}
+      - name: Push Bot image
+        run: |
+          docker push git.codeanddice.ru/toutsu/gmrelay-bot:latest
+          docker push git.codeanddice.ru/toutsu/gmrelay-bot:${{ env.VERSION }}
+
+      - name: Build Web image
+        run: |
+          docker build \
+            --label "org.opencontainers.image.source=https://git.codeanddice.ru/${{ gitea.repository }}" \
+            -f src/GmRelay.Web/Dockerfile \
+            -t git.codeanddice.ru/toutsu/gmrelay-web:latest \
+            -t git.codeanddice.ru/toutsu/gmrelay-web:${{ env.VERSION }} \
+            .
+
+      - name: Push Web image
+        run: |
+          docker push git.codeanddice.ru/toutsu/gmrelay-web:latest
+          docker push git.codeanddice.ru/toutsu/gmrelay-web:${{ env.VERSION }}
 
   # ЧАСТЬ 2: Запускаем эти образы на самом сервере
   deploy:
@@ -60,6 +64,7 @@ jobs:
           echo "TELEGRAM_BOT_TOKEN=${{ secrets.TELEGRAM_BOT_TOKEN }}" > .env
           echo "POSTGRES_PASSWORD=${{ secrets.POSTGRES_PASSWORD }}" >> .env
           echo "TELEGRAM_BOT_USERNAME=${{ secrets.TELEGRAM_BOT_USERNAME }}" >> .env
+          echo "TELEGRAM_MINI_APP_URL=${{ secrets.TELEGRAM_MINI_APP_URL }}" >> .env
 
       - name: Deploy Containers
         run: |
@@ -70,4 +75,4 @@ jobs:
           docker compose pull bot web
           
           # Запускаем! Флаг -d оставит их работать в фоне.
-          docker compose up -d
+          docker compose up -d

.gitea/workflows/pr-checks.yml

@@ -0,0 +1,33 @@
+name: PR Checks
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test-and-build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore dependencies
+        run: dotnet restore
+
+      - name: Build Shared
+        run: dotnet build src/GmRelay.Shared/GmRelay.Shared.csproj --no-restore
+
+      - name: Build Bot (compile check)
+        run: dotnet build src/GmRelay.Bot/GmRelay.Bot.csproj --no-restore
+
+      - name: Build Web (compile check)
+        run: dotnet build src/GmRelay.Web/GmRelay.Web.csproj --no-restore
+
+      - name: Run tests
+        run: dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --verbosity normal

.hermes/plans/gmrelay-issue-19.md

@@ -0,0 +1,480 @@
+# Issue #19: выровнять /newsession с batch-сценарием лендинга — Implementation Plan
+
+> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
+
+**Goal:** Убедиться, что Telegram UX `/newsession` полностью соответствует batch-сценарию лендинга: мастер одной командой создаёт несколько дат, указывает лимит мест и ссылку, получает единую карточку с действиями. Обеспечить покрытие acceptance criteria регрессионными тестами и устранить найденные расхождения.
+
+**Architecture:** Сценарий уже реализован в `CreateSessionHandler` + `NewSessionCommandParser` + `SessionBatchRenderer`. Основная задача — добавить недостающие тесты на «точный» landing-сценарий (несколько явных дат, не recurring), проверить отсутствие частичных сессий при любых ошибках, и убедиться, что карточка содержит все обещанные элементы.
+
+**Tech Stack:** .NET 10, xUnit, Dapper, Npgsql, Telegram.Bot, Native AOT.
+
+---
+
+## Контекст кодовой базы
+
+- `src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs` — создание batch, транзакция БД, отправка карточки.
+- `src/GmRelay.Bot/Features/Sessions/CreateSession/NewSessionCommandParser.cs` — парсинг команды: несколько `Время:`, `Мест:`, `Ссылка:`, `Картинка:`, recurring (`Игр:` + `Интервал:`).
+- `src/GmRelay.Shared/Rendering/SessionBatchRenderer.cs` — рендеринг HTML-карточки с кнопками.
+- `src/GmRelay.Shared/Rendering/BatchMessageEditor.cs` — редактирование batch-сообщения (text/photo).
+- `src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs` — роутинг команд, текст `/help`.
+- `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/NewSessionCommandParserTests.cs` — тесты парсера.
+- `tests/GmRelay.Bot.Tests/Features/Landing/TelegramLandingPromisesSmokeTests.cs` — smoke-тест всего landing-флоу через `FakeTelegramMessenger`.
+- `tests/GmRelay.Bot.Tests/Rendering/SessionBatchRendererTests.cs` — тесты рендерера.
+
+---
+
+### Task 1: RED — тест landing-парсинга с несколькими явными датами
+
+**Objective:** Проверить, что парсер корректно обрабатывает точный формат из лендинга: 2+ явных даты, лимит мест, ссылка, без recurring.
+
+**Files:**
+- Modify: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/NewSessionCommandParserTests.cs`
+
+**Step 1: Write failing test**
+
+```csharp
+[Fact]
+public void Parse_ShouldHandleLandingBatchWithMultipleExplicitDates()
+{
+    var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
+    var text = """
+        /newsession
+        Название: Landing Batch Game
+        Время: 15.05.2026 19:30
+        Время: 22.05.2026 19:30
+        Мест: 4
+        Ссылка: https://example.test/landing
+        """;
+
+    var result = NewSessionCommandParser.Parse(text, nowUtc);
+
+    Assert.True(result.IsValid);
+    Assert.Equal("Landing Batch Game", result.Title);
+    Assert.Equal("https://example.test/landing", result.Link);
+    Assert.Equal(4, result.MaxPlayers);
+    Assert.Equal(2, result.ScheduledTimes.Count);
+    Assert.Equal(new DateTimeOffset(2026, 5, 15, 16, 30, 0, TimeSpan.Zero), result.ScheduledTimes[0]);
+    Assert.Equal(new DateTimeOffset(2026, 5, 22, 16, 30, 0, TimeSpan.Zero), result.ScheduledTimes[1]);
+    Assert.Empty(result.PastTimeInputs);
+    Assert.Empty(result.InvalidTimeInputs);
+    Assert.Empty(result.InvalidSeatLimitInputs);
+    Assert.Empty(result.InvalidRecurringInputs);
+}
+```
+
+**Step 2: Run test to verify failure**
+
+Run: `dotnet test tests/GmRelay.Bot.Tests/ --filter "FullyQualifiedName~Parse_ShouldHandleLandingBatchWithMultipleExplicitDates" -v n`
+
+Expected: PASS (функциональность уже реализована, но теста не было). Если FAIL — исправить парсер перед продолжением.
+
+**Step 3: Commit**
+
+```bash
+git add tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/NewSessionCommandParserTests.cs
+git commit -m "test(#19): landing batch parser test with multiple explicit dates"
+```
+
+---
+
+### Task 2: RED — тест рендеринга landing-карточки
+
+**Objective:** Проверить, что `SessionBatchRenderer` для landing-сценария выводит название, все даты, лимит, заполненность и кнопки записи/выхода.
+
+**Files:**
+- Modify: `tests/GmRelay.Bot.Tests/Rendering/SessionBatchRendererTests.cs`
+
+**Step 1: Write failing test**
+
+```csharp
+[Fact]
+public void Render_ShouldProduceLandingBatchCardWithAllRequiredElements()
+{
+    var sessionId1 = Guid.NewGuid();
+    var sessionId2 = Guid.NewGuid();
+    var sessions = new[]
+    {
+        new SessionBatchDto(sessionId1, new DateTime(2026, 5, 15, 16, 30, 0, DateTimeKind.Utc), SessionStatus.Planned, 4),
+        new SessionBatchDto(sessionId2, new DateTime(2026, 5, 22, 16, 30, 0, DateTimeKind.Utc), SessionStatus.Planned, 4)
+    };
+    var participants = new[]
+    {
+        new ParticipantBatchDto(sessionId1, "Alice", "alice", ParticipantRegistrationStatus.Active),
+        new ParticipantBatchDto(sessionId1, "Bob", null, ParticipantRegistrationStatus.Active),
+        new ParticipantBatchDto(sessionId2, "Charlie", "charlie", ParticipantRegistrationStatus.Waitlisted)
+    };
+
+    var result = SessionBatchRenderer.Render("Landing Batch Game", sessions, participants);
+    var text = result.Text;
+    var buttons = result.Markup.InlineKeyboard.SelectMany(row => row).ToList();
+
+    Assert.Contains("Landing Batch Game", text);
+    Assert.Contains("15 мая 2026, 19:30", text);
+    Assert.Contains("22 мая 2026, 19:30", text);
+    Assert.Contains("Места: 2/4", text);
+    Assert.Contains("Места: 0/4", text);
+    Assert.Contains("@alice", text);
+    Assert.Contains("Bob", text);
+    Assert.Contains("Лист ожидания (1)", text);
+    Assert.Contains("@charlie", text);
+
+    Assert.Equal(4, buttons.Count);
+    Assert.Contains($"join_session:{sessionId1}", buttons.Select(b => b.CallbackData));
+    Assert.Contains($"leave_session:{sessionId1}", buttons.Select(b => b.CallbackData));
+    Assert.Contains($"join_session:{sessionId2}", buttons.Select(b => b.CallbackData));
+    Assert.Contains($"leave_session:{sessionId2}", buttons.Select(b => b.CallbackData));
+}
+```
+
+**Step 2: Run test to verify failure**
+
+Run: `dotnet test tests/GmRelay.Bot.Tests/ --filter "FullyQualifiedName~Render_ShouldProduceLandingBatchCardWithAllRequiredElements" -v n`
+
+Expected: PASS (рендерер уже реализован, тест отсутствовал).
+
+**Step 3: Commit**
+
+```bash
+git add tests/GmRelay.Bot.Tests/Rendering/SessionBatchRendererTests.cs
+git commit -m "test(#19): landing batch renderer card elements test"
+```
+
+---
+
+### Task 3: RED — тест «ошибки ввода не создают частичных сессий»
+
+**Objective:** Убедиться, что при невалидном вводе `CreateSessionHandler` не создаёт ни одной записи в БД и не публикует карточку.
+
+**Files:**
+- Create: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/CreateSessionHandlerTests.cs`
+- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs` (если найдена уязвимость)
+
+**Step 1: Write failing test**
+
+```csharp
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using Npgsql;
+using Telegram.Bot;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession;
+
+public sealed class CreateSessionHandlerTests
+{
+    // Примечание: полноценный интеграционный тест с реальной БД требует TestContainer.
+    // Для Native AOT проекта используем подход с in-memory фейком через рефакторинг хендлера.
+    // Ниже — тест-спецификация, которую реализуем через FakeDataSource или рефакторинг.
+}
+```
+
+Поскольку `CreateSessionHandler` напрямую зависит от `NpgsqlDataSource` и `ITelegramBotClient`, для unit-тестирования нужно либо:
+а) использовать интеграционный тест с PostgreSQL (TestContainers), либо
+б) рефакторить хендлер, выделив `ISessionRepository`.
+
+**Рекомендуемый подход (YAGNI):** добавить интеграционный тест в smoke-стиле через `FakeTelegramMessenger`, дополнив `TelegramLandingSmokeScenario` сценарием «invalid command does not publish anything».
+
+**Step 1 (реализация):** Дописать тест в `TelegramLandingPromisesSmokeTests.cs`:
+
+```csharp
+[Fact]
+public void Smoke_InvalidNewSession_ShouldNotPublishAnySessions()
+{
+    var nowUtc = new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero);
+    var invalidText = """
+        /newsession
+        Название: Bad Game
+        Время: 01.01.2020 19:30
+        """; // нет ссылки
+
+    var parseResult = NewSessionCommandParser.Parse(invalidText, nowUtc);
+
+    Assert.False(parseResult.IsValid);
+    Assert.Empty(parseResult.ScheduledTimes);
+    // Убеждаемся, что smoke-сценарий не может быть опубликован
+    Assert.Throws<InvalidOperationException>(() =>
+        TelegramLandingSmokeScenario.Publish(parseResult, SessionNotificationMode.GroupAndDirect));
+}
+```
+
+В `TelegramLandingSmokeScenario.Publish` добавить guard:
+```csharp
+if (!parseResult.IsValid)
+    throw new InvalidOperationException("Cannot publish invalid parse result");
+```
+
+**Step 2: Run test to verify failure**
+
+Run: `dotnet test tests/GmRelay.Bot.Tests/ --filter "FullyQualifiedName~Smoke_InvalidNewSession_ShouldNotPublishAnySessions" -v n`
+
+Expected: FAIL — guard ещё не добавлен.
+
+**Step 3: Write minimal implementation**
+
+Добавить guard в `TelegramLandingSmokeScenario.Publish`:
+```csharp
+if (!parseResult.IsValid)
+    throw new InvalidOperationException("Cannot publish invalid parse result");
+```
+
+**Step 4: Run test to verify pass**
+
+Expected: PASS.
+
+**Step 5: Commit**
+
+```bash
+git add tests/GmRelay.Bot.Tests/Features/Landing/TelegramLandingPromisesSmokeTests.cs
+git add src/GmRelay.Bot/... # если были изменения
+# (файл CreateSessionHandler.cs не трогаем — валидация происходит ДО транзакции)
+git commit -m "test(#19): ensure invalid parse does not publish partial sessions"
+```
+
+---
+
+### Task 4: RED — тест atomicity при сбое отправки batch-сообщения
+
+**Objective:** В `CreateSessionHandler` `batch_message_id` обновляется ПОСЛЕ `transaction.Commit()`. Если отправка сообщения в Telegram падает, сессии созданы, но `batch_message_id` не записан — игроки не увидят карточку. Нужно либо доказать, что это обработано, либо исправить.
+
+**Files:**
+- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs`
+
+**Step 1: Анализ кода**
+
+Текущий порядок в `CreateSessionHandler`:
+1. Валидация (до транзакции) ✓
+2. `BEGIN TRANSACTION`
+3. INSERT players, groups, sessions
+4. `COMMIT`
+5. `SessionBatchRenderer.Render`
+6. `botClient.SendMessage/SendPhoto`
+7. `UPDATE sessions SET batch_message_id = ...` (вне транзакции!)
+
+Если шаг 6 падает — сессии «висят» без published message. Это частичное создание.
+
+**Step 2: Write minimal fix**
+
+Обернуть отправку сообщения и обновление `batch_message_id` в retry-loop с fallback. Если после N попыток не удалось — отправить GM уведомление об ошибке и оставить сессии (не удалять, чтобы не терять данные), но сделать так, чтобы `batch_message_id` обновлялся только при успешной отправке.
+
+```csharp
+// Внутри CreateSessionHandler, после Commit:
+Message? batchMessage = null;
+var sendAttempts = 0;
+const int maxAttempts = 3;
+Exception? lastSendException = null;
+
+while (batchMessage is null && sendAttempts < maxAttempts)
+{
+    sendAttempts++;
+    try
+    {
+        batchMessage = await SendBatchMessageAsync(...); // extracted method
+    }
+    catch (Exception ex)
+    {
+        lastSendException = ex;
+        logger.LogWarning(ex, "Attempt {Attempt} failed to send batch message for {BatchId}", sendAttempts, batchId);
+        if (sendAttempts < maxAttempts)
+            await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
+    }
+}
+
+if (batchMessage is not null)
+{
+    await connection.ExecuteAsync(
+        "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
+        new { MsgId = batchMessage.MessageId, BatchId = batchId });
+}
+else
+{
+    logger.LogError(lastSendException, "Failed to send batch message for {BatchId} after {MaxAttempts} attempts", batchId, maxAttempts);
+    await botClient.SendMessage(
+        chatId,
+        $"⚠️ Сессии созданы, но не удалось опубликовать карточку. Пожалуйста, используйте /listsessions.\n\nОшибка: {lastSendException?.Message}",
+        cancellationToken: cancellationToken);
+}
+```
+
+**Step 3: Extract helper**
+
+Выделить метод `SendBatchMessageAsync` из текущего inline-кода отправки (строки 117–176 в текущем файле), чтобы логика была читаемой и тестируемой.
+
+**Step 4: Run tests**
+
+Run: `dotnet test tests/GmRelay.Bot.Tests/ -v n`
+
+Expected: все существующие тесты PASS, новая логика не ломает smoke-тест (т.к. smoke-тест не использует реальный `CreateSessionHandler`).
+
+**Step 5: Commit**
+
+```bash
+git add src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs
+git commit -m "fix(#19): retry batch message send and prevent orphaned sessions without batch_message_id"
+```
+
+---
+
+### Task 5: RED — smoke-тест полного landing-сценария с явными датами
+
+**Objective:** Дополнить `TelegramLandingPromisesSmokeTests` полным сквозным сценарием: парсинг → публикация → запись → выход → проверка карточки.
+
+**Files:**
+- Modify: `tests/GmRelay.Bot.Tests/Features/Landing/TelegramLandingPromisesSmokeTests.cs`
+
+**Step 1: Write failing test**
+
+```csharp
+[Fact]
+public void Smoke_LandingExplicitDatesBatch_ShouldSupportFullLifecycle()
+{
+    var nowUtc = new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero);
+    var text = """
+        /newsession
+        Название: Landing Explicit Batch
+        Время: 15.05.2026 19:30
+        Время: 22.05.2026 19:30
+        Мест: 3
+        Ссылка: https://example.test/explicit
+        """;
+
+    var parseResult = NewSessionCommandParser.Parse(text, nowUtc);
+    Assert.True(parseResult.IsValid);
+    Assert.Equal(2, parseResult.ScheduledTimes.Count);
+    Assert.Equal(3, parseResult.MaxPlayers);
+
+    var scenario = TelegramLandingSmokeScenario.Publish(parseResult, SessionNotificationMode.GroupAndDirect);
+    Assert.Contains("Landing Explicit Batch", scenario.LastMessage.Text);
+    Assert.Contains("15 мая 2026, 19:30", scenario.LastMessage.Text);
+    Assert.Contains("22 мая 2026, 19:30", scenario.LastMessage.Text);
+    Assert.Contains("Места: 0/3", scenario.LastMessage.Text);
+
+    var callbacks = CallbackData(scenario.LastMessage.Markup);
+    Assert.Equal(4, callbacks.Count); // join+leave для каждой из 2 сессий
+
+    var firstSessionId = scenario.Sessions[0].Id;
+    var alice = scenario.Join(firstSessionId, 1001, "Alice", "alice");
+    var bob = scenario.Join(firstSessionId, 1002, "Bob", "bob");
+    var carol = scenario.Join(firstSessionId, 1003, "Carol", "carol");
+
+    Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, alice));
+    Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, bob));
+    Assert.Equal(ParticipantRegistrationStatus.Waitlisted, scenario.RegistrationStatus(firstSessionId, carol));
+    Assert.Contains("Места: 2/3", scenario.LastMessage.Text);
+    Assert.Contains("@alice", scenario.LastMessage.Text);
+    Assert.Contains("@bob", scenario.LastMessage.Text);
+    Assert.Contains("@carol", scenario.LastMessage.Text);
+
+    scenario.Leave(firstSessionId, alice);
+    Assert.False(scenario.HasParticipant(firstSessionId, alice));
+    Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, carol));
+    Assert.DoesNotContain("@alice", scenario.LastMessage.Text);
+    Assert.Contains("@carol", scenario.LastMessage.Text);
+}
+```
+
+**Step 2: Run test to verify failure**
+
+Run: `dotnet test tests/GmRelay.Bot.Tests/ --filter "FullyQualifiedName~Smoke_LandingExplicitDatesBatch_ShouldSupportFullLifecycle" -v n`
+
+Expected: PASS (функциональность уже существует, тест добавляет регрессионное покрытие).
+
+**Step 3: Commit**
+
+```bash
+git add tests/GmRelay.Bot.Tests/Features/Landing/TelegramLandingPromisesSmokeTests.cs
+git commit -m "test(#19): full lifecycle smoke test for explicit-dates landing batch"
+```
+
+---
+
+### Task 6: Проверка и обновление `/help` текста
+
+**Objective:** Убедиться, что текст `/help` точно отражает landing-формат и упоминает batch-сценарий.
+
+**Files:**
+- Modify: `src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs`
+
+**Step 1: Read current `/help` text**
+
+Текущий `/help` уже содержит:
+```
+/newsession
+Название: My Game
+Время: 15.05.2026 19:30
+Время: 22.05.2026 19:30
+Мест: 4
+Ссылка: https://link
+Картинка: https://cover
+
+Для регулярного расписания можно указать одну дату:
+Игр: 4
+Интервал: 7
+```
+
+**Step 2: Verify alignment**
+
+- Формат совпадает с лендингом ✓
+- Упоминается `Мест:` ✓
+- Упоминается несколько `Время:` ✓
+- Упоминается `Ссылка:` ✓
+
+Никаких изменений не требуется. Если тестировщик считает, что help недостаточно явно описывает batch-сценарий — добавить заголовок:
+```
+<b>Создать набор сессий (batch):</b>
+```
+
+**Step 3: Commit (если изменения были)**
+
+```bash
+git add src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs
+git commit -m "docs(#19): clarify batch scenario in /help text"
+```
+
+---
+
+### Task 7: Финальный прогон и cleanup
+
+**Objective:** Убедиться, что все тесты проходят, нет warnings, и план соответствует acceptance criteria.
+
+**Files:**
+- Все изменённые файлы
+
+**Step 1: Run full test suite**
+
+```bash
+dotnet test tests/GmRelay.Bot.Tests/ -v n
+```
+
+Expected: все тесты PASS.
+
+**Step 2: Verify checklist**
+
+- [ ] `Parse_ShouldHandleLandingBatchWithMultipleExplicitDates` — PASS
+- [ ] `Render_ShouldProduceLandingBatchCardWithAllRequiredElements` — PASS
+- [ ] `Smoke_InvalidNewSession_ShouldNotPublishAnySessions` — PASS
+- [ ] `Smoke_LandingExplicitDatesBatch_ShouldSupportFullLifecycle` — PASS
+- [ ] Все существующие тесты — PASS
+- [ ] `CreateSessionHandler` обрабатывает сбой отправки batch-сообщения (retry + fallback)
+- [ ] `/help` текст соответствует landing-формату
+- [ ] Никаких новых warnings при сборке
+
+**Step 3: Commit финальный**
+
+```bash
+git add -A
+git commit -m "feat(#19): align /newsession with landing batch scenario — tests + atomicity fix"
+```
+
+---
+
+## Acceptance Criteria Verification
+
+| Критерий | Статус | Покрытие |
+|---|---|---|
+| Мастер может создать batch из нескольких дат | ✅ Реализовано | Task 1, Task 5 |
+| Карточка содержит название, даты, лимит, заполненность, действия | ✅ Реализовано | Task 2, Task 5 |
+| Ошибки ввода не создают частичных сессий | ✅ Реализовано (валидация до транзакции) | Task 3 |
+| Сбой публикации карточки не оставляет «висячие» сессии без `batch_message_id` | 🔄 Фиксится | Task 4 |
+
+## Execution Handoff
+
+Plan complete and saved to `.hermes/plans/gmrelay-issue-19.md`. Ready to execute using subagent-driven-development — dispatch a fresh subagent per task with two-stage review (spec compliance then code quality). Shall I proceed?

Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <Version>1.0.0</Version>
+    <Version>1.10.1</Version>
     <TargetFramework>net10.0</TargetFramework>
     <LangVersion>preview</LangVersion>
     <Nullable>enable</Nullable>

README.md

@@ -4,21 +4,34 @@
 
 Проект разработан с упором на производительность, архитектуру Vertical Slice, Native AOT (для бота) и удобство развертывания с использованием .NET Aspire.
 
+**Текущая версия:** `v1.9.9`.
+
 ---
 
 ## ✨ Ключевые возможности
 
 ### 🤖 Telegram Бот
 - **📅 Создание расписаний (Batch Sessions)**: Создавайте сразу несколько игр одним сообщением (на неделю или месяц вперед).
-- **✋ Интерактивная запись**: Игроки записываются на конкретные даты нажатием одной кнопки.
+- **🖼 Обложки расписаний**: К batch-посту можно прикрепить фото к `/newsession` или указать строку `Картинка: https://...`; бот отправит обложку перед сообщением записи.
+- **⚡ Быстрые повторы расписания**: Для регулярной кампании можно указать одну дату, количество игр и интервал, а бот сам развернёт повторяющийся batch.
+- **✋ Интерактивная запись и выход**: Игроки записываются на конкретные даты и самостоятельно снимают запись нажатием одной кнопки.
+- **👥 Лимит мест и лист ожидания**: ГМ задаёт максимальный состав, бот не переполняет сессию, автоматически ведёт очередь ожидания и освобождённое место отдаёт первому ожидающему.
 - **📁 Поддержка Форумов (Telegram Topics)**: Бот автоматически создает тему во вложенных чатах Telegram под каждую новую пачку игр.
-- **❌ Управление сессиями**: Мастер может отменять отдельные игры прямо в общем сообщении расписания.
+- **❌ Управление сессиями**: Owner и назначенные co-GM могут создавать, отменять, удалять и переносить игры из Telegram через `/listsessions`; публичный пост записи показывает только кнопки игроков.
+- **🔄 Голосование за перенос**: При переносе сессии GM предлагает 2-3 новых времени и дедлайн, игроки голосуют кнопками, а бот показывает текущие результаты и применяет победивший вариант.
+- **🔔 Персональные уведомления**: Игроки получают DM о RSVP за 24 часа, напоминание за 1 час, ссылку перед игрой, отмены и переносы; групповые уведомления при этом остаются.
 - **🗓 Экспорт в Календарь**: Генерация файла `.ics` для добавления всех игр в Google, Apple или Яндекс Календарь одной командой.
 - **🚀 Native AOT**: Скомпилирован в нативный бинарный файл. Мгновенный запуск и минимальное потребление памяти. Идеально для **Raspberry Pi**.
 
 ### 🌐 Web Dashboard (Blazor Server)
 - **🔐 Авторизация через Telegram**: Безопасный вход с использованием Telegram Login Widget (HMAC-SHA256 валидация).
+- **📱 Telegram Mini App Dashboard**: Мобильная версия dashboard открывается прямо из Telegram, проверяет WebApp `initData` на сервере и использует те же права owner/co-GM, что и обычный Web Dashboard. Если Mini App попадает в fallback-вход, Telegram Login Widget авторизует пользователя callback-запросом внутри текущего WebView, а интерфейс учитывает safe-area телефона и верхнюю панель Telegram.
 - **📝 Удобное редактирование**: Веб-интерфейс для детального редактирования сессий, изменения дат, названий и статусов.
+- **🤝 Co-GM и делегирование**: Owner группы назначает помощников по Telegram ID, а co-GM получает доступ к управлению расписанием в Telegram и Web Dashboard.
+- **📋 Шаблоны кампаний**: Owner и co-GM управляют типовыми параметрами кампаний в отдельной вкладке `Шаблоны`, а на странице группы запускают новый повторяющийся batch из выбранного шаблона.
+- **🧩 Bulk-операции для Batch Sessions**: ГМ может обновить общий title/link, перенести всю пачку на фиксированный шаг и клонировать batch на следующую неделю или месяц.
+- **🔕 Режим уведомлений batch**: Для каждой пачки можно выбрать `В группе и в личку` или `Только в группе`.
+- **⬆️ Управление очередью**: Веб-интерфейс показывает заполненность, лист ожидания и позволяет ГМу поднять первого игрока из очереди.
 - **🔄 Автоматическая синхронизация**: Любые изменения в веб-интерфейсе мгновенно обновляют сообщения с расписанием в Telegram-чатах игроков.
 - **🕒 Управление временем**: UI адаптирован под московское время (UTC+3), в то время как база данных работает в UTC.
 
@@ -63,21 +76,31 @@ TELEGRAM_BOT_TOKEN=ваш_токен_здесь
 # Используется для работы виджета авторизации (Telegram Login Widget).
 TELEGRAM_BOT_USERNAME=ваше_имя_бота_здесь
 
+# HTTPS URL Mini App dashboard, например: https://your-domain.example/miniapp.
+# Используется кнопкой меню Telegram и кнопкой /start.
+TELEGRAM_MINI_APP_URL=https://your-domain.example/miniapp
+
 # Пароль для базы данных PostgreSQL
 POSTGRES_PASSWORD=ваш_надежный_пароль
+
+# Локальный порт веб-интерфейса GM-Relay
+GMRELAY_WEB_PORT=8080
 ```
 
 *(Опционально)* Настройте домен Telegram бота в @BotFather командой `/setdomain` для работы виджета авторизации на вашем сайте.
 
+Для Telegram Mini App настройте в @BotFather домен Web Dashboard и menu button на URL из `TELEGRAM_MINI_APP_URL`. Бот также показывает кнопку `Открыть dashboard` в ответе на `/start`, если переменная задана. Начиная с v1.9.3 дополнительных действий в BotFather для фикса входа не требуется: URL остаётся тем же HTTPS-адресом `/miniapp`, а fallback-вход выполняется внутри активного Telegram WebView.
+
 ### 3. Запуск
 Выполните команду:
 ```bash
-docker compose up -d -build
+docker compose up -d
 ```
 Инфраструктура автоматически:
-- Поднимет PostgreSQL.
+- Создаст локальную Docker-сеть и volume PostgreSQL, если их ещё нет.
+- Поднимет PostgreSQL, доступный для контейнеров как `db:5432`.
 - Запустит бота (применив миграции БД).
-- Запустит веб-интерфейс (доступен по умолчанию на порту **8080** внутри контейнера).
+- Запустит веб-интерфейс на `http://localhost:8080` или другом порту из `GMRELAY_WEB_PORT`.
 
 ---
 
@@ -92,7 +115,7 @@ docker compose up -d -build
     * `Закрепление сообщений` — рекомендуется.
 
 > [!TIP]
-> Колонку "Мастер" (GM) бот определяет по первому человеку, который создал сессию в этой группе. Только этот пользователь сможет отменять игры через кнопки бота и редактировать их в веб-интерфейсе.
+> Owner группы определяется по первому человеку, который создал сессию в этой группе. Owner может назначать co-GM в Web Dashboard; owner и co-GM могут управлять сессиями через кнопки бота и веб-интерфейс.
 
 ---
 
@@ -106,12 +129,69 @@ docker compose up -d -build
 Название: Легенды Берега Мечей (D&D 5e)
 Время: 15.05.2024 19:30
 Время: 22.05.2024 19:00
+Мест: 4
+Ссылка: https://discord.gg/invite-link
+Картинка: https://example.com/adventure-cover.jpg
+```
+
+Строка `Мест:` необязательна. Если она указана, игроки сверх лимита попадут в лист ожидания, а ГМ сможет повысить первого ожидающего через кнопку в Telegram или Web Dashboard.
+
+Строка `Картинка:` тоже необязательна. Вместо ссылки можно прикрепить фото к сообщению `/newsession` и поместить команду в подпись к фото; бот возьмёт прикреплённое изображение и отправит его перед расписанием.
+
+Для регулярной кампании можно не перечислять все даты вручную. Укажите одну строку `Время:`, количество игр и интервал в днях:
+
+```text
+/newsession
+Название: Kingmaker
+Время: 30.04.2026 19:30
+Игр: 6
+Интервал: 7
+Мест: 5
 Ссылка: https://discord.gg/invite-link
 ```
 
+Бот создаст 6 игр с недельным шагом. Вместо `Игр:` также принимается `Сессий:` или `Повторов:`, вместо `Интервал:` — `Шаг:`.
+
+Игрок может самостоятельно снять запись кнопкой `🚪 Выйти` в сообщении расписания. Если он был в основном составе и в листе ожидания есть игроки, бот автоматически переводит первого ожидающего в основной состав и обновляет сообщение пачки.
+
+### Делегирование управления
+На странице группы Web Dashboard показывает owner и список co-GM. Owner может добавить помощника по Telegram ID, имени и username, а также снять роль co-GM. Назначенный co-GM видит группу в панели управления и может редактировать сессии, управлять batch-операциями, очередью, переносами и удалением игр, но не может назначать других co-GM.
+
+### Перенос сессии голосованием
+Owner или co-GM вызывает `/listsessions`, нажимает кнопку `⏰` у нужной сессии и отправляет в чат 2-3 варианта нового времени вместе с дедлайном:
+
+```text
+25.04.2026 19:30
+26.04.2026 18:00
+Дедлайн: 25.04.2026 12:00
+```
+
+Дедлайн должен быть в будущем и раньше первого предложенного времени. Участники выбирают один вариант кнопкой в Telegram, могут изменить голос до дедлайна и видят текущие результаты в сообщении голосования. По дедлайну бот выбирает вариант с наибольшим числом голосов, переносит сессию, сбрасывает RSVP и обновляет batch-сообщение. Если голосов нет или есть ничья, перенос отклоняется, а время сессии остаётся прежним.
+
+### Шаблоны и bulk-операции в Web Dashboard
+Вкладка `Шаблоны` в левом меню вынесена отдельно от страницы группы. Owner и co-GM выбирают группу, сохраняют шаблон кампании с названием, ссылкой, количеством игр, интервалом, лимитом мест и режимом уведомлений, а также удаляют устаревшие шаблоны.
+
+На странице группы Web Dashboard показывает только применение сохранённых шаблонов и отдельный блок для каждой пачки игр. Owner и co-GM могут:
+- создать новый batch из шаблона, выбрав только первую дату расписания;
+- обновить общий `title` и `link` сразу у всех сессий batch;
+- выбрать режим уведомлений: дублировать важные сообщения игрокам в личку или оставить только групповые уведомления;
+- перенести пачку, задав новую первую дату и фиксированный шаг между играми в днях;
+- клонировать batch на следующую неделю или следующий календарный месяц.
+
+После создания из шаблона или клонирования появляется новая пачка с новым Telegram-сообщением и пустым составом игроков. После редактирования или переноса исходное Telegram-сообщение расписания перерисовывается.
+
+Если включён режим `В группе и в личку`, бот дополнительно отправляет игрокам персональные сообщения о RSVP за 24 часа, напоминание за 1 час, ссылку перед стартом, отмену и перенос. Если Telegram не позволяет написать игроку в ЛС, бот логирует ошибку и продолжает отправку остальным участникам.
+
+### Telegram Mini App Dashboard
+Owner и co-GM могут открыть мобильный dashboard прямо из Telegram: через кнопку меню бота или кнопку `Открыть dashboard` после `/start`. Дополнительный пароль вводить не нужно: GM-Relay сам проверит вход через Telegram.
+
+Внутри открывается та же панель управления, только удобная для телефона. Можно смотреть свои группы, редактировать игры, управлять листом ожидания, запускать шаблоны и выполнять массовые действия с пачками игр. Чужие группы не появятся: dashboard показывает только те группы, где вы owner или co-GM.
+
+Если автоматический вход не сработал, Mini App покажет понятное сообщение и кнопку входа через Telegram. Нажмите её, подтвердите вход, и dashboard откроется в том же окне Telegram.
+
 ### Другие команды
-- `/listsessions` — Показать список всех актуальных игр в этой группе.
-- `/reschedulesession` — Перенести сессию на другое время с голосованием игроков.
+- `/listsessions` — Показать список всех актуальных игр в этой группе. Для owner/co-GM команда также показывает кнопки отмены, переноса, повышения из листа ожидания и удаления.
+- `⏰` в панели `/listsessions` — Запустить голосование по 2-3 вариантам нового времени.
 - `/deletesession` — Удалить сессию.
 - `/exportcalendar` — Получить `.ics` файл с играми.
 - `/help` — Справка по формату.
@@ -132,5 +212,17 @@ docker compose up -d -build
 
 ---
 
+## 🧪 Тестирование
+
+Основной набор проверок запускается командой:
+
+```bash
+dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --collect:"XPlat Code Coverage"
+```
+
+Начиная с `v1.9.9`, тестовый набор включает функциональный smoke-сценарий обещаний лендинга для Telegram: batch-сессии на несколько дат, inline-кнопки записи/выхода, лимиты мест, waitlist, автоповышение игрока, голосование за перенос, direct-notification mode и перерисовку Telegram batch-поста после dashboard-изменений. Smoke работает через fake Telegram messenger и не требует внешнего Telegram API.
+
+---
+
 ## 📜 Лицензия
 Проект распространяется под лицензией MIT. Использование в некоммерческих целях приветствуется.

compose.yaml

@@ -1,16 +1,15 @@
 services:
   db:
     image: postgres:17-alpine
-    container_name: gmrelay_db
     restart: always
     environment:
       POSTGRES_USER: gmrelay
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
       POSTGRES_DB: gmrelay_db
     volumes:
       - pgdata:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
+    networks:
+      - gmrelay
     healthcheck:
       test: [ "CMD-SHELL", "pg_isready -U gmrelay -d gmrelay_db" ]
       interval: 3s
@@ -18,35 +17,42 @@ services:
       retries: 10
 
   bot:
-    image: git.codeanddice.ru/toutsu/gmrelay-bot:1.0.0
-    container_name: gmrelay_bot
+    image: git.codeanddice.ru/toutsu/gmrelay-bot:1.10.0
     restart: always
-    network_mode: host
     depends_on:
       db:
         condition: service_healthy
     environment:
-      - "ConnectionStrings__gmrelaydb=Host=127.0.0.1;Port=5432;Database=gmrelay_db;Username=gmrelay;Password=${POSTGRES_PASSWORD}"
-      - "Telegram__BotToken=${TELEGRAM_BOT_TOKEN}"
+      - "ConnectionStrings__gmrelaydb=Host=db;Port=5432;Database=gmrelay_db;Username=gmrelay;Password=${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}"
+      - "Telegram__BotToken=${TELEGRAM_BOT_TOKEN:?Set TELEGRAM_BOT_TOKEN in .env}"
+      - "Telegram__MiniAppUrl=${TELEGRAM_MINI_APP_URL:-}"
+    networks:
+      - gmrelay
 
   web:
-    image: git.codeanddice.ru/toutsu/gmrelay-web:1.0.0
-    container_name: gmrelay_web
+    image: git.codeanddice.ru/toutsu/gmrelay-web:1.10.0
     restart: always
-    network_mode: host
     depends_on:
       db:
         condition: service_healthy
     environment:
-      - "ConnectionStrings__gmrelaydb=Host=127.0.0.1;Port=5432;Database=gmrelay_db;Username=gmrelay;Password=${POSTGRES_PASSWORD}"
-      - "Telegram__BotToken=${TELEGRAM_BOT_TOKEN}"
-      - "Telegram__BotUsername=${TELEGRAM_BOT_USERNAME}"
+      - "ConnectionStrings__gmrelaydb=Host=db;Port=5432;Database=gmrelay_db;Username=gmrelay;Password=${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}"
+      - "Telegram__BotToken=${TELEGRAM_BOT_TOKEN:?Set TELEGRAM_BOT_TOKEN in .env}"
+      - "Telegram__BotUsername=${TELEGRAM_BOT_USERNAME:?Set TELEGRAM_BOT_USERNAME in .env}"
+      - "Telegram__MiniAppUrl=${TELEGRAM_MINI_APP_URL:-}"
+    ports:
+      - "${GMRELAY_WEB_PORT:-8080}:8080"
     volumes:
       - web_keys:/app/dataprotection-keys
+    networks:
+      - gmrelay
 
 volumes:
   pgdata:
-    external: true
-    name: game_pgdata
+    name: ${POSTGRES_VOLUME_NAME:-game_pgdata}
   web_keys:
-    name: gmrelay_web_keys
+    name: ${WEB_KEYS_VOLUME_NAME:-gmrelay_web_keys}
+
+networks:
+  gmrelay:
+    driver: bridge

docs/adr/002-platform-neutral-batch-rendering.md

@@ -0,0 +1,65 @@
+# ADR 002: Platform-Neutral Batch Rendering
+
+## Status
+
+**Accepted** — implemented in v1.10.0 (PR #42).
+
+## Context
+
+`SessionBatchRenderer` жил в `GmRelay.Shared` и напрямую зависел от `Telegram.Bot` (`InlineKeyboardMarkup`, `ParseMode.Html`). Это создавало проблемы:
+
+1. **Shared не был platform-neutral.** Любой платформенный проект (Discord, Slack, WebSocket) тащил Telegram-зависимость.
+2. **Дублирование логики.** `GmRelay.Web` использовал тот же рендерер через прямую зависимость от `Shared`, но Web — это не Telegram-клиент.
+3. **Невозможно написать unit-тесты без Telegram-объектов.** Smoke-тесты создавали InlineKeyboardMarkup даже для проверки чисто доменной логики.
+
+## Decision
+
+Разделить рендеринг на две стадии:
+
+1. **View Builder (platform-neutral)** — собирает view model из доменных DTO.
+2. **Platform Renderer (platform-specific)** — превращает view model в платформенное представление.
+
+```
+Domain DTOs
+    │
+    ▼
+SessionBatchViewBuilder (Shared)
+    │
+    ▼
+SessionBatchViewModel (platform-neutral)
+    │
+    ├──► TelegramSessionBatchRenderer ──► HTML + InlineKeyboardMarkup
+    │
+    └──► DiscordSessionBatchRenderer ──► (issue #26)
+```
+
+### Изменённые компоненты
+
+| Компонент | Было | Стало |
+|---|---|---|
+| `SessionBatchRenderer` | `GmRelay.Shared.Rendering` | Удалён |
+| `SessionBatchViewBuilder` | — | `GmRelay.Shared.Rendering` |
+| `SessionBatchViewModel` | — | `GmRelay.Shared.Rendering` |
+| `TelegramSessionBatchRenderer` | — | `GmRelay.Bot` + `GmRelay.Web` |
+| `DiscordSessionBatchRenderer` | — | `GmRelay.Shared.Rendering` (stub) |
+| `BatchMessageEditor` | `GmRelay.Shared.Rendering` | `GmRelay.Bot` + `GmRelay.Web` |
+
+## Consequences
+
+### Positive
+
+- `GmRelay.Shared` больше не зависит от `Telegram.Bot`. Чистый platform-agnostic проект.
+- Можно добавить `DiscordSessionBatchRenderer` без изменений в `Shared`.
+- Unit-тесты ViewBuilder не создают `InlineKeyboardMarkup`.
+- Логика подсчёта игроков, сортировки сессий и генерации действий — в одном месте (ViewBuilder).
+
+### Negative
+
+- **Временное дублирование.** `TelegramSessionBatchRenderer` и `BatchMessageEditor` скопированы в `Bot` и `Web`. Планируется вынести в `GmRelay.Shared.Telegram` при появлении третьего Telegram-потребителя.
+- **Дополнительная стадия.** Теперь два вызова вместо одного: `Build` + `Render`. Этоtrade-off за чистоту абстракции.
+
+## Related
+
+- Issue #22 — этот рефакторинг.
+- Issue #26 — Discord Bot MVP (потребитель новой архитектуры).
+- ADR 001 — vertical slice, native AOT, Aspire (`docs/adr/0001-use-vertical-slice-native-aot-and-aspire.md`).

docs/plans/2026-05-04-player-list-kick-waitlist.md

@@ -0,0 +1,438 @@
+# Player List + Kick + Waitlist Promotion Implementation Plan
+
+> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
+
+**Goal:** Add a player list (with names) to the Web UI session views, allow GM to kick a specific player, and auto-promote the next waitlisted player.
+
+**Architecture:** Extend `ISessionStore` with participant queries and a remove method. Update `GroupDetails.razor` to show expandable participant lists. Reuse existing `PromoteWaitlistedPlayerAsync` logic after removal.
+
+**Tech Stack:** C# 14, Blazor SSR, Dapper, PostgreSQL
+
+---
+
+## Task 1: Add domain model for WebParticipant
+
+**Objective:** Create a DTO to represent a session participant in the web layer.
+
+**Files:**
+- Modify: `src/GmRelay.Web/Services/SessionService.cs`
+
+**Step 1: Add record**
+
+```csharp
+public sealed record WebParticipant(
+    Guid Id,
+    long TelegramId,
+    string DisplayName,
+    string? TelegramUsername,
+    string RsvpStatus,
+    string RegistrationStatus,
+    bool IsGm,
+    DateTime? RespondedAt);
+```
+
+**Step 2: Commit**
+
+```bash
+git add src/GmRelay.Web/Services/SessionService.cs
+git commit -m "feat: add WebParticipant record"
+```
+
+---
+
+## Task 2: Add GetSessionParticipantsAsync to ISessionStore
+
+**Objective:** Retrieve all participants for a session with full player info.
+
+**Files:**
+- Modify: `src/GmRelay.Web/Services/ISessionStore.cs`
+- Modify: `src/GmRelay.Web/Services/SessionService.cs`
+- Modify: `src/GmRelay.Web/Services/AuthorizedSessionService.cs`
+
+**Step 1: Add to interface**
+
+In `ISessionStore.cs`, add:
+```csharp
+Task<List<WebParticipant>> GetSessionParticipantsAsync(Guid sessionId);
+```
+
+**Step 2: Implement in SessionService**
+
+In `SessionService.cs`, add:
+```csharp
+public async Task<List<WebParticipant>> GetSessionParticipantsAsync(Guid sessionId)
+{
+    await using var conn = await dataSource.OpenConnectionAsync();
+    return (await conn.QueryAsync<WebParticipant>(
+        """
+        SELECT sp.id AS Id,
+               p.telegram_id AS TelegramId,
+               p.display_name AS DisplayName,
+               p.telegram_username AS TelegramUsername,
+               sp.rsvp_status AS RsvpStatus,
+               sp.registration_status AS RegistrationStatus,
+               sp.is_gm AS IsGm,
+               sp.responded_at AS RespondedAt
+        FROM session_participants sp
+        JOIN players p ON p.id = sp.player_id
+        WHERE sp.session_id = @SessionId
+        ORDER BY sp.is_gm DESC,
+                 CASE sp.registration_status WHEN 'Active' THEN 0 ELSE 1 END,
+                 sp.created_at
+        """,
+        new { SessionId = sessionId })).ToList();
+}
+```
+
+**Step 3: Add authorized wrapper**
+
+In `AuthorizedSessionService.cs`, add:
+```csharp
+public async Task<List<WebParticipant>?> GetSessionParticipantsForGmAsync(Guid sessionId, long gmId)
+{
+    var session = await GetSessionForGmAsync(sessionId, gmId);
+    if (session is null)
+    {
+        return null;
+    }
+
+    return await sessionStore.GetSessionParticipantsAsync(sessionId);
+}
+```
+
+**Step 4: Commit**
+
+```bash
+git add src/GmRelay.Web/Services/ISessionStore.cs
+
+git add src/GmRelay.Web/Services/SessionService.cs
+
+git add src/GmRelay.Web/Services/AuthorizedSessionService.cs
+
+git commit -m "feat: add GetSessionParticipantsAsync"
+```
+
+---
+
+## Task 3: Add RemovePlayerFromSessionAsync with waitlist promotion
+
+**Objective:** Allow GM to remove a specific player; auto-promote next waitlisted player if conditions met.
+
+**Files:**
+- Modify: `src/GmRelay.Web/Services/ISessionStore.cs`
+- Modify: `src/GmRelay.Web/Services/SessionService.cs`
+- Modify: `src/GmRelay.Web/Services/AuthorizedSessionService.cs`
+
+**Step 1: Add to interface**
+
+In `ISessionStore.cs`, add:
+```csharp
+Task RemovePlayerFromSessionAsync(Guid sessionId, Guid groupId, Guid participantId);
+```
+
+**Step 2: Implement in SessionService**
+
+In `SessionService.cs`, add:
+```csharp
+public async Task RemovePlayerFromSessionAsync(Guid sessionId, Guid groupId, Guid participantId)
+{
+    await using var conn = await dataSource.OpenConnectionAsync();
+    await using var transaction = await conn.BeginTransactionAsync();
+
+    var session = await conn.QuerySingleOrDefaultAsync<WebSession>(
+        @"SELECT s.id, s.group_id AS GroupId, s.title, s.scheduled_at AS ScheduledAt, s.status, s.join_link AS JoinLink,
+                 s.batch_id AS BatchId, s.batch_message_id AS BatchMessageId,
+                 g.telegram_chat_id AS TelegramChatId,
+                 s.max_players AS MaxPlayers,
+                 0 AS ActivePlayerCount,
+                 0 AS WaitlistedPlayerCount,
+                 s.notification_mode AS NotificationMode
+          FROM sessions s
+          JOIN game_groups g ON g.id = s.group_id
+          WHERE s.id = @SessionId AND s.group_id = @GroupId
+          FOR UPDATE",
+        new { SessionId = sessionId, GroupId = groupId },
+        transaction);
+
+    if (session is null)
+    {
+        throw new SessionAccessDeniedException(sessionId, 0);
+    }
+
+    // Verify participant exists in this session
+    var participant = await conn.QuerySingleOrDefaultAsync<WebParticipant>(
+        """
+        SELECT sp.id AS Id,
+               p.telegram_id AS TelegramId,
+               p.display_name AS DisplayName,
+               p.telegram_username AS TelegramUsername,
+               sp.rsvp_status AS RsvpStatus,
+               sp.registration_status AS RegistrationStatus,
+               sp.is_gm AS IsGm,
+               sp.responded_at AS RespondedAt
+        FROM session_participants sp
+        JOIN players p ON p.id = sp.player_id
+        WHERE sp.id = @ParticipantId AND sp.session_id = @SessionId
+        """,
+        new { ParticipantId = participantId, SessionId = sessionId },
+        transaction);
+
+    if (participant is null)
+    {
+        throw new InvalidOperationException("Участник не найден в этой сессии.");
+    }
+
+    bool wasActive = participant.RegistrationStatus == ParticipantRegistrationStatus.Active;
+
+    await conn.ExecuteAsync(
+        "DELETE FROM session_participants WHERE id = @ParticipantId",
+        new { ParticipantId = participantId },
+        transaction);
+
+    WebPromotedParticipantDto? promoted = null;
+
+    if (wasActive)
+    {
+        promoted = await conn.QuerySingleOrDefaultAsync<WebPromotedParticipantDto>(
+            """
+            SELECT sp.id AS ParticipantRowId,
+                   p.display_name AS DisplayName
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Waitlisted
+            ORDER BY sp.created_at ASC, sp.id ASC
+            LIMIT 1
+            FOR UPDATE OF sp
+            """,
+            new { SessionId = sessionId, Waitlisted = ParticipantRegistrationStatus.Waitlisted },
+            transaction);
+
+        if (promoted is not null)
+        {
+            await conn.ExecuteAsync(
+                """
+                UPDATE session_participants
+                SET registration_status = @Active,
+                    rsvp_status = @Pending,
+                    responded_at = NULL
+                WHERE id = @ParticipantRowId
+                """,
+                new
+                {
+                    promoted.ParticipantRowId,
+                    Active = ParticipantRegistrationStatus.Active,
+                    Pending = RsvpStatus.Pending
+                },
+                transaction);
+        }
+    }
+
+    await transaction.CommitAsync();
+
+    // Notifications
+    await bot.SendMessage(
+        session.TelegramChatId,
+        $"🚪 <b>{System.Net.WebUtility.HtmlEncode(participant.DisplayName)}</b> удален(а) из сессии «{System.Net.WebUtility.HtmlEncode(session.Title)}».",
+        parseMode: Telegram.Bot.Types.Enums.ParseMode.Html);
+
+    if (promoted is not null)
+    {
+        await bot.SendMessage(
+            session.TelegramChatId,
+            $"⬆️ <b>{System.Net.WebUtility.HtmlEncode(promoted.DisplayName)}</b> переведен(а) из листа ожидания в основной состав «{System.Net.WebUtility.HtmlEncode(session.Title)}».",
+            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html);
+    }
+
+    if (session.BatchMessageId.HasValue)
+    {
+        await TryUpdateBatchMessageAsync(session.BatchId, session.TelegramChatId, session.BatchMessageId.Value, session.Title);
+    }
+}
+```
+
+**Step 3: Add authorized wrapper**
+
+In `AuthorizedSessionService.cs`, add:
+```csharp
+public async Task RemovePlayerFromSessionForGmAsync(Guid sessionId, long gmId, Guid participantId)
+{
+    var session = await GetSessionForGmAsync(sessionId, gmId);
+    if (session is null)
+    {
+        throw new SessionAccessDeniedException(sessionId, gmId);
+    }
+
+    await sessionStore.RemovePlayerFromSessionAsync(sessionId, session.GroupId, participantId);
+}
+```
+
+**Step 4: Commit**
+
+```bash
+git add src/GmRelay.Web/Services/ISessionStore.cs
+
+git add src/GmRelay.Web/Services/SessionService.cs
+
+git add src/GmRelay.Web/Services/AuthorizedSessionService.cs
+
+git commit -m "feat: add RemovePlayerFromSessionAsync with waitlist promotion"
+```
+
+---
+
+## Task 4: Modify GroupDetails.razor to show participant list
+
+**Objective:** Add expandable player lists to each session row with kick buttons.
+
+**Files:**
+- Modify: `src/GmRelay.Web/Components/Pages/GroupDetails.razor`
+
+**Step 1:** Add `participants` dictionary and `kickingParticipantId` state variables.
+
+**Step 2:** Add `LoadParticipants(Guid sessionId)` and `KickParticipant(Guid sessionId, Guid participantId)` methods.
+
+**Step 3:** In desktop table, add a new column or expand row with participant list.
+
+**Step 4:** In mobile cards, add expandable participant section.
+
+**Step 5:** Add styles to `app.css` if needed (badge styles are already present).
+
+**Step 6:** Commit
+
+```bash
+git add src/GmRelay.Web/Components/Pages/GroupDetails.razor
+
+git add src/GmRelay.Web/wwwroot/app.css
+
+git commit -m "feat: show player list and kick button in GroupDetails"
+```
+
+---
+
+## Task 5: Modify EditSession.razor to show participant list
+
+**Objective:** Show participant list on the edit page with kick capability.
+
+**Files:**
+- Modify: `src/GmRelay.Web/Components/Pages/EditSession.razor`
+
+**Step 1:** Load participants in `OnInitializedAsync`.
+
+**Step 2:** Render participant list below the edit form.
+
+**Step 3:** Add kick button for each non-GM participant.
+
+**Step 4:** Commit
+
+```bash
+git add src/GmRelay.Web/Components/Pages/EditSession.razor
+
+git commit -m "feat: show player list and kick button in EditSession"
+```
+
+---
+
+## Task 6: Add backend tests
+
+**Objective:** Cover new GetSessionParticipants and RemovePlayerFromSession logic.
+
+**Files:**
+- Create: `tests/GmRelay.Bot.Tests/Web/SessionParticipantTests.cs`
+
+**Step 1:** Write tests for `GetSessionParticipantsForGmAsync`.
+
+**Step 2:** Write tests for `RemovePlayerFromSessionForGmAsync` including waitlist promotion.
+
+**Step 3:** Run tests
+
+```bash
+dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj -v n
+```
+
+**Step 4:** Commit
+
+```bash
+git add tests/GmRelay.Bot.Tests/Web/SessionParticipantTests.cs
+
+git commit -m "test: add SessionParticipant service tests"
+```
+
+---
+
+## Task 7: Update README
+
+**Objective:** Bump version and document new features.
+
+**Files:**
+- Modify: `README.md`
+
+**Step 1:** Change version from `v1.9.6` to `v1.9.7`.
+
+**Step 2:** Add bullet under Web Dashboard: player list with kick and auto-promote.
+
+**Step 3:** Commit
+
+```bash
+git add README.md
+
+git commit -m "docs: bump README to v1.9.7, document player list kick"
+```
+
+---
+
+## Task 8: Update Wiki
+
+**Objective:** Update `Руководство ГМа` page with player management instructions.
+
+**Files:**
+- Modify: Wiki page `Руководство ГМа`
+
+**Step 1:** Read current wiki content via MCP.
+
+**Step 2:** Add section about viewing player list and removing players.
+
+**Step 3:** Update via MCP.
+
+---
+
+## Task 9: Push branch and run CI
+
+**Objective:** Push branch, monitor workflow, fix issues.
+
+**Step 1:** Push
+
+```bash
+git push -u origin feat/player-list-kick-waitlist
+```
+
+**Step 2:** Check workflow run via MCP gitea actions.
+
+**Step 3:** Fix any issues.
+
+---
+
+## Task 10: Merge and create release
+
+**Objective:** Merge PR (or fast-forward), tag, create release.
+
+**Step 1:** Merge to main
+
+```bash
+git checkout main
+
+git merge --no-ff feat/player-list-kick-waitlist -m "feat: player list, kick, and waitlist promotion (#X)"
+```
+
+**Step 2:** Tag v1.9.7
+
+```bash
+git tag v1.9.7
+
+git push origin main --tags
+```
+
+**Step 3:** Create release via MCP gitea_create_release.
+
+---

docs/superpowers/plans/2026-04-28-telegram-mini-app-dashboard.md

@@ -0,0 +1,69 @@
+# Telegram Mini App Dashboard Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a Telegram Mini App mobile dashboard that reuses the existing Web Dashboard and validates Telegram WebApp `initData` on the server.
+
+**Architecture:** Extend `TelegramAuthService` for WebApp init data, add a `/miniapp` Blazor entry page plus `/auth/telegram-webapp` endpoint, and add bot entry points through an inline WebApp button and optional menu button setup. Existing application/domain services remain the only write path.
+
+**Tech Stack:** .NET 10, Blazor Server, Telegram.Bot, xUnit, Dapper/Npgsql-backed existing services.
+
+---
+
+### Task 1: Telegram WebApp Authentication
+
+**Files:**
+- Modify: `src/GmRelay.Web/Services/TelegramAuthService.cs`
+- Modify: `src/GmRelay.Web/Program.cs`
+- Test: `tests/GmRelay.Bot.Tests/Web/TelegramAuthServiceTests.cs`
+
+- [ ] Write failing tests for valid WebApp `initData`, tampered hash, and expired auth date.
+- [ ] Run `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter TelegramAuthServiceTests`.
+- [ ] Implement WebApp HMAC verification using the Telegram `WebAppData` secret derivation.
+- [ ] Add `/auth/telegram-webapp` endpoint that signs in using the same claims as `/auth/telegram`.
+- [ ] Re-run the filtered tests.
+
+### Task 2: Mini App Entry Page
+
+**Files:**
+- Create: `src/GmRelay.Web/Components/Pages/MiniApp.razor`
+- Modify: `src/GmRelay.Web/Components/App.razor`
+- Modify: `src/GmRelay.Web/wwwroot/app.css`
+- Test: `tests/GmRelay.Bot.Tests/Web/MiniAppDashboardTests.cs`
+
+- [ ] Write failing tests that assert `/miniapp`, `telegram-web-app.js`, `authenticateTelegramMiniApp`, and Mini App CSS hooks exist.
+- [ ] Run `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter MiniAppDashboardTests`.
+- [ ] Implement `/miniapp` to post `Telegram.WebApp.initData` to `/auth/telegram-webapp`, expand/ready the Mini App, and show fallback login when opened outside Telegram.
+- [ ] Add CSS for a mobile-first Mini App shell and compact dashboard spacing.
+- [ ] Re-run the filtered tests.
+
+### Task 3: Bot Entry Points
+
+**Files:**
+- Create: `src/GmRelay.Bot/Infrastructure/Telegram/TelegramMiniAppMenuButtonService.cs`
+- Modify: `src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs`
+- Modify: `src/GmRelay.Bot/Program.cs`
+- Test: `tests/GmRelay.Bot.Tests/Infrastructure/Telegram/TelegramMiniAppEntryPointTests.cs`
+
+- [ ] Write failing tests that assert `/start` exposes a WebApp button and startup registers the menu button service.
+- [ ] Run `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter TelegramMiniAppEntryPointTests`.
+- [ ] Add a configurable `Telegram:MiniAppUrl` entry point; when missing, keep existing command behavior.
+- [ ] Add hosted service that calls `SetChatMenuButton` with `MenuButtonWebApp` only when the URL is configured.
+- [ ] Re-run the filtered tests.
+
+### Task 4: Docs, Versions, and Release Prep
+
+**Files:**
+- Modify: `Directory.Build.props`
+- Modify: `compose.yaml`
+- Modify: `.gitea/workflows/deploy.yml`
+- Modify: `src/GmRelay.Web/wwwroot/app.css`
+- Modify: `src/GmRelay.Web/Components/Layout/NavMenu.razor`
+- Modify: `README.md`
+- Wiki: `Home`, `Быстрый старт`, `Руководство ГМа`, `Развёртывание`, `Архитектура`, `Разработка`
+
+- [ ] Update project/container/workflow/UI versions to `1.9.0`.
+- [ ] Document `TELEGRAM_MINI_APP_URL`, BotFather `/setmenubutton`, `/miniapp`, and WebApp auth.
+- [ ] Run `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --collect:"XPlat Code Coverage"`.
+- [ ] Run `dotnet build GM-Relay.slnx -c Release`.
+- [ ] Commit, push, close issue #17, update wiki, create tag/release `v1.9.0`.

docs/superpowers/specs/2026-04-28-telegram-mini-app-dashboard-design.md

@@ -0,0 +1,44 @@
+# Telegram Mini App Dashboard Design
+
+## Goal
+
+Issue #17 adds a Telegram Mini App dashboard as the mobile entry point for the existing Web Dashboard. Owner and co-GM users must be able to open the dashboard from Telegram, pass server-side Telegram WebApp `initData` validation, and manage only their own groups.
+
+## Scope
+
+- Add Mini App authentication using Telegram WebApp `initData`.
+- Add a `/miniapp` entry page that signs the user into the existing cookie auth flow, then opens the regular dashboard UI in mobile-first mode.
+- Reuse `AuthorizedSessionService`, `SessionService`, and existing Blazor pages for groups, sessions, templates, waitlist promotion, edit forms, and bulk batch operations.
+- Add bot entry points: a Mini App button in `/start` and a configurable default menu button when `Telegram:MiniAppUrl` is set.
+- Update README, wiki, deployment config, and visible version strings to `1.9.0`.
+
+## Architecture
+
+The Mini App is not a second dashboard implementation. It is a Telegram-authenticated entrance into the existing Blazor dashboard. This keeps authorization, domain operations, Telegram message synchronization, and Web Dashboard behavior in one place.
+
+`TelegramAuthService` gains a second verification method for WebApp `initData`. The server accepts the raw URL-encoded init payload at `/auth/telegram-webapp`, verifies the Telegram HMAC with the bot token, extracts the user id/name from the embedded `user` JSON, and issues the same auth cookie as the login widget endpoint.
+
+`/miniapp` loads `telegram-web-app.js`, posts `window.Telegram.WebApp.initData` to the server endpoint, expands the WebApp viewport, and redirects to `/`. If a user opens `/miniapp` outside Telegram, the page shows the regular login fallback.
+
+## Data Flow
+
+1. User opens the Mini App from the bot menu button or `/start` inline button.
+2. Telegram injects `initData` into the WebApp JavaScript API.
+3. `/miniapp` posts `{ initData }` to `/auth/telegram-webapp`.
+4. The server verifies the WebApp signature and expiry.
+5. The server creates the same claims used by Telegram Login Widget.
+6. Existing Blazor pages load groups through `AuthorizedSessionService`.
+7. Any edit, waitlist, template, or batch action still goes through existing services and keeps Telegram messages synchronized.
+
+## Error Handling
+
+- Missing or invalid init data returns `401` and leaves the user on the Mini App page.
+- Expired auth data is rejected with the same 24-hour window used by the Login Widget.
+- A verified Telegram user with no owner/co-GM groups sees the existing empty dashboard state.
+- Direct navigation to a foreign group/session still redirects to `/access-denied` through existing authorization checks.
+
+## Testing
+
+- Unit tests cover valid and invalid WebApp `initData`.
+- File-level regression tests ensure `/miniapp`, `/auth/telegram-webapp`, Telegram WebApp script loading, bot Mini App button, menu button setup, and mobile Mini App CSS hooks remain present.
+- Existing `AuthorizedSessionServiceTests` continue covering owner/co-GM access behavior.

src/GmRelay.Bot/Features/Confirmation/HandleRsvp/HandleRsvpHandler.cs

@@ -1,14 +1,11 @@
 using Dapper;
 using GmRelay.Shared.Domain;
-using GmRelay.Bot.Features.Confirmation.SendConfirmation;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Features.Confirmation.HandleRsvp;
 
-// ── Command ──────────────────────────────────────────────────────────
-
 public sealed record HandleRsvpCommand(
     Guid SessionId,
     long TelegramUserId,
@@ -17,13 +14,12 @@ public sealed record HandleRsvpCommand(
     long ChatId,
     int MessageId);
 
-// ── DTOs ─────────────────────────────────────────────────────────────
-
 internal sealed record RsvpCounts(int Total, int Confirmed, int Declined);
 
 internal sealed record SessionContext(
     string Title,
     DateTime ScheduledAt,
+    string Status,
     long GmTelegramId,
     long TelegramChatId);
 
@@ -33,21 +29,6 @@ internal sealed record ParticipantRsvp(
     string? TelegramUsername,
     string RsvpStatus);
 
-// ── Handler ──────────────────────────────────────────────────────────
-
-/// <summary>
-/// Handles the "Буду" / "Не смогу" callback query.
-///
-/// Flow:
-///   1. Validate that the user is a participant in this session
-///   2. Record or update their RSVP (idempotent)
-///   3. If declined → alert GM privately, revert session if was Confirmed
-///   4. If all non-GM players confirmed → mark session Confirmed, notify group + GM
-///   5. Update the inline keyboard to show current RSVP status
-///
-/// Concurrency: two simultaneous clicks on different rows don't conflict (MVCC).
-/// The last EditMessage wins, which is fine — both reflect up-to-date state.
-/// </summary>
 public sealed class HandleRsvpHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
@@ -58,19 +39,19 @@ public sealed class HandleRsvpHandler(
         await using var connection = await dataSource.OpenConnectionAsync(ct);
         await using var transaction = await connection.BeginTransactionAsync(ct);
 
-        // ── 1. Validate participant ──────────────────────────────────
-
         var participantExists = await connection.ExecuteScalarAsync<bool>(
             """
             SELECT EXISTS (
-                SELECT 1 FROM session_participants sp
+                SELECT 1
+                FROM session_participants sp
                 JOIN players p ON p.id = sp.player_id
                 WHERE sp.session_id = @SessionId
                   AND p.telegram_id = @TelegramUserId
                   AND sp.is_gm = false
+                  AND sp.registration_status = @Active
             )
             """,
-            new { command.SessionId, command.TelegramUserId },
+            new { command.SessionId, command.TelegramUserId, Active = ParticipantRegistrationStatus.Active },
             transaction);
 
         if (!participantExists)
@@ -82,8 +63,6 @@ public sealed class HandleRsvpHandler(
             return;
         }
 
-        // ── 2. Record RSVP (idempotent) ─────────────────────────────
-
         var updated = await connection.ExecuteAsync(
             """
             UPDATE session_participants
@@ -91,14 +70,14 @@ public sealed class HandleRsvpHandler(
                    responded_at = now()
             WHERE  session_id = @SessionId
               AND  player_id  = (SELECT id FROM players WHERE telegram_id = @TelegramUserId)
+              AND  registration_status = @Active
               AND  rsvp_status != @Status
             """,
-            new { command.SessionId, command.TelegramUserId, command.Status },
+            new { command.SessionId, command.TelegramUserId, command.Status, Active = ParticipantRegistrationStatus.Active },
             transaction);
 
         if (updated == 0)
         {
-            // Already in this state — just dismiss the loading spinner
             var alreadyText = command.Status == RsvpStatus.Confirmed
                 ? "Вы уже подтвердили участие."
                 : "Вы уже отказались от участия.";
@@ -110,11 +89,11 @@ public sealed class HandleRsvpHandler(
             return;
         }
 
-        // ── 3. Load session context ─────────────────────────────────
-
         var session = await connection.QuerySingleAsync<SessionContext>(
             """
-            SELECT s.title, s.scheduled_at AS ScheduledAt,
+            SELECT s.title,
+                   s.scheduled_at AS ScheduledAt,
+                   s.status AS Status,
                    g.gm_telegram_id AS GmTelegramId,
                    g.telegram_chat_id AS TelegramChatId
             FROM sessions s
@@ -124,26 +103,27 @@ public sealed class HandleRsvpHandler(
             new { command.SessionId },
             transaction);
 
-        // ── 4. Handle decline ───────────────────────────────────────
-
         if (command.Status == RsvpStatus.Declined)
         {
-            // Revert session to ConfirmationSent if it was Confirmed
-            await connection.ExecuteAsync(
-                """
-                UPDATE sessions
-                SET    status = @ConfirmationSent, updated_at = now()
-                WHERE  id = @SessionId AND status = @Confirmed
-                """,
-                new
-                {
-                    command.SessionId,
-                    ConfirmationSent = SessionStatus.ConfirmationSent,
-                    Confirmed = SessionStatus.Confirmed
-                },
-                transaction);
+            var decision = RsvpFlowRules.Evaluate(command.Status, session.Status, totalParticipants: 0, confirmedParticipants: 0);
+
+            if (decision.ShouldRevertSessionToConfirmationSent)
+            {
+                await connection.ExecuteAsync(
+                    """
+                    UPDATE sessions
+                    SET    status = @ConfirmationSent, updated_at = now()
+                    WHERE  id = @SessionId AND status = @Confirmed
+                    """,
+                    new
+                    {
+                        command.SessionId,
+                        ConfirmationSent = SessionStatus.ConfirmationSent,
+                        Confirmed = SessionStatus.Confirmed
+                    },
+                    transaction);
+            }
 
-            // Alert GM immediately via private message
             var declinedPlayer = await connection.QuerySingleAsync<string>(
                 "SELECT display_name FROM players WHERE telegram_id = @TelegramUserId",
                 new { command.TelegramUserId },
@@ -151,7 +131,6 @@ public sealed class HandleRsvpHandler(
 
             await transaction.CommitAsync(ct);
 
-            // Send alert outside transaction (network call)
             try
             {
                 await bot.SendMessage(
@@ -161,38 +140,38 @@ public sealed class HandleRsvpHandler(
             }
             catch (Exception ex)
             {
-                logger.LogWarning(ex, "Failed to send decline alert to GM for session {SessionId}",
-                    command.SessionId);
+                logger.LogWarning(ex, "Failed to send decline alert to GM for session {SessionId}", command.SessionId);
             }
 
             await bot.AnswerCallbackQuery(
                 callbackQueryId: command.CallbackQueryId,
-                text: "Вы отказались от участия.",
+                text: decision.CallbackText,
                 cancellationToken: ct);
         }
-        // ── 5. Handle confirm — check if ALL confirmed ──────────────
         else
         {
             var counts = await connection.QuerySingleAsync<RsvpCounts>(
                 """
                 SELECT
-                    count(*)                                              AS Total,
-                    count(*) FILTER (WHERE rsvp_status = @Confirmed)      AS Confirmed,
-                    count(*) FILTER (WHERE rsvp_status = @Declined)       AS Declined
+                    count(*)                                         AS Total,
+                    count(*) FILTER (WHERE rsvp_status = @Confirmed) AS Confirmed,
+                    count(*) FILTER (WHERE rsvp_status = @Declined)  AS Declined
                 FROM session_participants
                 WHERE session_id = @SessionId AND is_gm = false
+                  AND registration_status = @Active
                 """,
                 new
                 {
                     command.SessionId,
                     Confirmed = RsvpStatus.Confirmed,
-                    Declined = RsvpStatus.Declined
+                    Declined = RsvpStatus.Declined,
+                    Active = ParticipantRegistrationStatus.Active
                 },
                 transaction);
 
-            var allConfirmed = counts.Confirmed == counts.Total;
+            var decision = RsvpFlowRules.Evaluate(command.Status, session.Status, counts.Total, counts.Confirmed);
 
-            if (allConfirmed)
+            if (decision.ShouldMarkSessionConfirmed)
             {
                 await connection.ExecuteAsync(
                     """
@@ -206,9 +185,8 @@ public sealed class HandleRsvpHandler(
 
             await transaction.CommitAsync(ct);
 
-            if (allConfirmed)
+            if (decision.ShouldNotifyGroup)
             {
-                // Notify group
                 try
                 {
                     await bot.SendMessage(
@@ -218,11 +196,12 @@ public sealed class HandleRsvpHandler(
                 }
                 catch (Exception ex)
                 {
-                    logger.LogWarning(ex, "Failed to send group confirmation for session {SessionId}",
-                        command.SessionId);
+                    logger.LogWarning(ex, "Failed to send group confirmation for session {SessionId}", command.SessionId);
                 }
+            }
 
-                // Notify GM privately
+            if (decision.ShouldNotifyGm)
+            {
                 try
                 {
                     await bot.SendMessage(
@@ -232,27 +211,20 @@ public sealed class HandleRsvpHandler(
                 }
                 catch (Exception ex)
                 {
-                    logger.LogWarning(ex, "Failed to send GM confirmation for session {SessionId}",
-                        command.SessionId);
+                    logger.LogWarning(ex, "Failed to send GM confirmation for session {SessionId}", command.SessionId);
                 }
             }
 
             await bot.AnswerCallbackQuery(
                 callbackQueryId: command.CallbackQueryId,
-                text: "Вы подтвердили участие!",
+                text: decision.CallbackText,
                 cancellationToken: ct);
         }
 
-        // ── 6. Update inline keyboard message ───────────────────────
-
         await UpdateConfirmationMessage(command, session, ct);
     }
 
-    /// <summary>
-    /// Re-renders the confirmation message with current RSVP statuses.
-    /// </summary>
-    private async Task UpdateConfirmationMessage(
-        HandleRsvpCommand command, SessionContext session, CancellationToken ct)
+    private async Task UpdateConfirmationMessage(HandleRsvpCommand command, SessionContext session, CancellationToken ct)
     {
         try
         {
@@ -260,16 +232,18 @@ public sealed class HandleRsvpHandler(
 
             var participants = (await connection.QueryAsync<ParticipantRsvp>(
                 """
-                SELECT p.telegram_id    AS TelegramId,
-                       p.display_name    AS DisplayName,
+                SELECT p.telegram_id AS TelegramId,
+                       p.display_name AS DisplayName,
                        p.telegram_username AS TelegramUsername,
-                       sp.rsvp_status    AS RsvpStatus
+                       sp.rsvp_status AS RsvpStatus
                 FROM session_participants sp
                 JOIN players p ON p.id = sp.player_id
-                WHERE sp.session_id = @SessionId AND sp.is_gm = false
+                WHERE sp.session_id = @SessionId
+                  AND sp.is_gm = false
+                  AND sp.registration_status = @Active
                 ORDER BY sp.responded_at NULLS LAST
                 """,
-                new { command.SessionId })).ToList();
+                new { command.SessionId, Active = ParticipantRegistrationStatus.Active })).ToList();
 
             var confirmed = participants.Where(p => p.RsvpStatus == RsvpStatus.Confirmed).ToList();
             var declined = participants.Where(p => p.RsvpStatus == RsvpStatus.Declined).ToList();
@@ -279,34 +253,47 @@ public sealed class HandleRsvpHandler(
             {
                 $"🎲 Подтвердите участие в «{session.Title}»",
                 $"📅 {session.ScheduledAt.FormatMoscow()} (МСК)",
-                ""
+                string.Empty
             };
 
-            foreach (var p in confirmed)
-                lines.Add($"   ✅ {FormatName(p)}");
-            foreach (var p in declined)
-                lines.Add($"   ❌ ~~{FormatName(p)}~~");
-            foreach (var p in pending)
-                lines.Add($"   ⏳ {FormatName(p)}");
+            foreach (var participant in confirmed)
+            {
+                lines.Add($"   ✅ {FormatName(participant)}");
+            }
 
-            lines.Add("");
+            foreach (var participant in declined)
+            {
+                lines.Add($"   ❌ ~~{FormatName(participant)}~~");
+            }
+
+            foreach (var participant in pending)
+            {
+                lines.Add($"   ⏳ {FormatName(participant)}");
+            }
+
+            lines.Add(string.Empty);
 
             if (confirmed.Count == participants.Count)
+            {
                 lines.Add($"Статус: ✅ все подтвердили ({confirmed.Count}/{participants.Count})");
+            }
             else if (declined.Count > 0)
+            {
                 lines.Add($"Статус: ⚠️ есть отказы ({confirmed.Count}/{participants.Count} подтвердили)");
+            }
             else
+            {
                 lines.Add($"Статус: ожидаем подтверждения ({confirmed.Count}/{participants.Count})");
+            }
 
             var text = string.Join("\n", lines);
 
-            // Keep buttons unless everyone confirmed
             var replyMarkup = confirmed.Count == participants.Count
                 ? null
                 : new InlineKeyboardMarkup([
                     [
-                        InlineKeyboardButton.WithCallbackData("\u2705 Буду", $"rsvp:confirm:{command.SessionId}"),
-                        InlineKeyboardButton.WithCallbackData("\u274c Не смогу", $"rsvp:decline:{command.SessionId}")
+                        InlineKeyboardButton.WithCallbackData("✅ Буду", $"rsvp:confirm:{command.SessionId}"),
+                        InlineKeyboardButton.WithCallbackData("❌ Не смогу", $"rsvp:decline:{command.SessionId}")
                     ]
                 ]);
 
@@ -319,12 +306,10 @@ public sealed class HandleRsvpHandler(
         }
         catch (Exception ex)
         {
-            // EditMessage can fail if message is too old or unchanged — non-critical
-            logger.LogWarning(ex, "Failed to update confirmation message for session {SessionId}",
-                command.SessionId);
+            logger.LogWarning(ex, "Failed to update confirmation message for session {SessionId}", command.SessionId);
         }
     }
 
-    private static string FormatName(ParticipantRsvp p) =>
-        p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
+    private static string FormatName(ParticipantRsvp participant) =>
+        participant.TelegramUsername is not null ? $"@{participant.TelegramUsername}" : participant.DisplayName;
 }

src/GmRelay.Bot/Features/Confirmation/HandleRsvp/RsvpFlowRules.cs

@@ -0,0 +1,42 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Features.Confirmation.HandleRsvp;
+
+internal sealed record RsvpFlowDecision(
+    string CallbackText,
+    bool ShouldAlertGm,
+    bool ShouldRevertSessionToConfirmationSent,
+    bool ShouldMarkSessionConfirmed,
+    bool ShouldNotifyGroup,
+    bool ShouldNotifyGm);
+
+internal static class RsvpFlowRules
+{
+    public static RsvpFlowDecision Evaluate(
+        string requestedStatus,
+        string currentSessionStatus,
+        int totalParticipants,
+        int confirmedParticipants)
+    {
+        if (requestedStatus == RsvpStatus.Declined)
+        {
+            return new RsvpFlowDecision(
+                CallbackText: "\u0412\u044b \u043e\u0442\u043a\u0430\u0437\u0430\u043b\u0438\u0441\u044c \u043e\u0442 \u0443\u0447\u0430\u0441\u0442\u0438\u044f.",
+                ShouldAlertGm: true,
+                ShouldRevertSessionToConfirmationSent: currentSessionStatus == SessionStatus.Confirmed,
+                ShouldMarkSessionConfirmed: false,
+                ShouldNotifyGroup: false,
+                ShouldNotifyGm: false);
+        }
+
+        var everyoneConfirmed = confirmedParticipants == totalParticipants;
+
+        return new RsvpFlowDecision(
+            CallbackText: "\u0412\u044b \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u043b\u0438 \u0443\u0447\u0430\u0441\u0442\u0438\u0435!",
+            ShouldAlertGm: false,
+            ShouldRevertSessionToConfirmationSent: false,
+            ShouldMarkSessionConfirmed: everyoneConfirmed,
+            ShouldNotifyGroup: everyoneConfirmed,
+            ShouldNotifyGm: everyoneConfirmed);
+    }
+}

src/GmRelay.Bot/Features/Confirmation/SendConfirmation/SendConfirmationHandler.cs

@@ -1,4 +1,5 @@
 using Dapper;
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Shared.Domain;
 using Npgsql;
 using Telegram.Bot;
@@ -13,7 +14,8 @@ internal sealed record SessionInfo(
     string Title,
     DateTime ScheduledAt,
     Guid GroupId,
-    long TelegramChatId);
+    long TelegramChatId,
+    string NotificationMode);
 
 internal sealed record ParticipantInfo(
     long TelegramId,
@@ -29,6 +31,7 @@ internal sealed record ParticipantInfo(
 public sealed class SendConfirmationHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
+    DirectSessionNotificationSender directSender,
     ILogger<SendConfirmationHandler> logger)
 {
     public async Task HandleAsync(Guid sessionId, CancellationToken ct)
@@ -39,7 +42,8 @@ public sealed class SendConfirmationHandler(
         var session = await connection.QuerySingleOrDefaultAsync<SessionInfo>(
             """
             SELECT s.id, s.title, s.scheduled_at AS ScheduledAt, s.group_id AS GroupId,
-                   g.telegram_chat_id AS TelegramChatId
+                   g.telegram_chat_id AS TelegramChatId,
+                   s.notification_mode AS NotificationMode
             FROM sessions s
             JOIN game_groups g ON g.id = s.group_id
             WHERE s.id = @SessionId AND s.status = @Planned
@@ -60,9 +64,11 @@ public sealed class SendConfirmationHandler(
                    p.telegram_username AS TelegramUsername
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
             """,
-            new { SessionId = sessionId })).ToList();
+            new { SessionId = sessionId, Active = ParticipantRegistrationStatus.Active })).ToList();
 
         if (participants.Count == 0)
         {
@@ -113,6 +119,26 @@ public sealed class SendConfirmationHandler(
                 MessageId = message.MessageId
             });
 
+        var mode = SessionNotificationModeExtensions.FromDatabaseValue(session.NotificationMode);
+        if (mode.ShouldSendDirectMessages())
+        {
+            var directText = $"""
+                🎲 <b>Подтвердите участие в игре</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(session.Title)}</b>
+                📅 {session.ScheduledAt.FormatMoscow()} (МСК)
+
+                Ответьте кнопкой в групповом сообщении расписания.
+                """;
+
+            await directSender.SendAsync(
+                participants.Select(p => new DirectNotificationRecipient(p.TelegramId, p.DisplayName)),
+                directText,
+                "confirmation",
+                sessionId,
+                ct);
+        }
+
         logger.LogInformation(
             "Confirmation sent for session {SessionId} ({Title}), message_id={MessageId}",
             sessionId, session.Title, message.MessageId);

src/GmRelay.Bot/Features/Notifications/DirectSessionNotificationSender.cs

@@ -0,0 +1,41 @@
+using Telegram.Bot;
+using Telegram.Bot.Types.Enums;
+
+namespace GmRelay.Bot.Features.Notifications;
+
+public sealed record DirectNotificationRecipient(long TelegramId, string DisplayName);
+
+public sealed class DirectSessionNotificationSender(
+    ITelegramBotClient bot,
+    ILogger<DirectSessionNotificationSender> logger)
+{
+    public async Task SendAsync(
+        IEnumerable<DirectNotificationRecipient> recipients,
+        string htmlText,
+        string notificationKind,
+        Guid sessionId,
+        CancellationToken ct)
+    {
+        foreach (var recipient in recipients)
+        {
+            try
+            {
+                await bot.SendMessage(
+                    chatId: recipient.TelegramId,
+                    text: htmlText,
+                    parseMode: ParseMode.Html,
+                    cancellationToken: ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(
+                    ex,
+                    "Failed to send {NotificationKind} DM for session {SessionId} to player {TelegramId} ({DisplayName})",
+                    notificationKind,
+                    sessionId,
+                    recipient.TelegramId,
+                    recipient.DisplayName);
+            }
+        }
+    }
+}

src/GmRelay.Bot/Features/Reminders/SendJoinLink/SendJoinLinkHandler.cs

@@ -1,4 +1,5 @@
 using Dapper;
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Shared.Domain;
 using Npgsql;
 using Telegram.Bot;
@@ -12,7 +13,8 @@ internal sealed record JoinLinkSession(
     string Title,
     string JoinLink,
     DateTime ScheduledAt,
-    long TelegramChatId);
+    long TelegramChatId,
+    string NotificationMode);
 
 internal sealed record ConfirmedPlayer(
     long TelegramId,
@@ -28,6 +30,7 @@ internal sealed record ConfirmedPlayer(
 public sealed class SendJoinLinkHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
+    DirectSessionNotificationSender directSender,
     ILogger<SendJoinLinkHandler> logger)
 {
     public async Task HandleAsync(Guid sessionId, CancellationToken ct)
@@ -38,7 +41,8 @@ public sealed class SendJoinLinkHandler(
         var session = await connection.QuerySingleOrDefaultAsync<JoinLinkSession>(
             """
             SELECT s.id, s.title, s.join_link AS JoinLink, s.scheduled_at AS ScheduledAt,
-                   g.telegram_chat_id AS TelegramChatId
+                   g.telegram_chat_id AS TelegramChatId,
+                   s.notification_mode AS NotificationMode
             FROM sessions s
             JOIN game_groups g ON g.id = s.group_id
             WHERE s.id = @SessionId
@@ -63,8 +67,14 @@ public sealed class SendJoinLinkHandler(
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId
               AND sp.rsvp_status = @Confirmed
+              AND sp.registration_status = @Active
             """,
-            new { SessionId = sessionId, Confirmed = RsvpStatus.Confirmed })).ToList();
+            new
+            {
+                SessionId = sessionId,
+                Confirmed = RsvpStatus.Confirmed,
+                Active = ParticipantRegistrationStatus.Active
+            })).ToList();
 
         // 3. Build message with player mentions
         var mentions = string.Join(", ", players.Select(p =>
@@ -96,6 +106,24 @@ public sealed class SendJoinLinkHandler(
             """,
             new { SessionId = sessionId, MessageId = message.MessageId });
 
+        var mode = SessionNotificationModeExtensions.FromDatabaseValue(session.NotificationMode);
+        if (mode.ShouldSendDirectMessages())
+        {
+            var directText = $"""
+                🎮 <b>Игра начинается через 5 минут</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(session.Title)}</b>
+                🔗 {System.Net.WebUtility.HtmlEncode(session.JoinLink)}
+                """;
+
+            await directSender.SendAsync(
+                players.Select(p => new DirectNotificationRecipient(p.TelegramId, p.DisplayName)),
+                directText,
+                "join-link",
+                sessionId,
+                ct);
+        }
+
         logger.LogInformation(
             "Join link sent for session {SessionId} ({Title}), message_id={MessageId}",
             sessionId, session.Title, message.MessageId);

src/GmRelay.Bot/Features/Reminders/SendOneHourReminder/SendOneHourReminderHandler.cs

@@ -0,0 +1,97 @@
+using Dapper;
+using GmRelay.Bot.Features.Notifications;
+using GmRelay.Shared.Domain;
+using Npgsql;
+
+namespace GmRelay.Bot.Features.Reminders.SendOneHourReminder;
+
+internal sealed record OneHourReminderSession(
+    Guid Id,
+    string Title,
+    string JoinLink,
+    DateTime ScheduledAt,
+    string NotificationMode);
+
+public sealed class SendOneHourReminderHandler(
+    NpgsqlDataSource dataSource,
+    DirectSessionNotificationSender directSender,
+    ILogger<SendOneHourReminderHandler> logger)
+{
+    public async Task HandleAsync(Guid sessionId, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var session = await connection.QuerySingleOrDefaultAsync<OneHourReminderSession>(
+            """
+            SELECT id,
+                   title,
+                   join_link AS JoinLink,
+                   scheduled_at AS ScheduledAt,
+                   notification_mode AS NotificationMode
+            FROM sessions
+            WHERE id = @SessionId
+              AND status IN (@Confirmed, @ConfirmationSent)
+              AND one_hour_reminder_processed_at IS NULL
+            """,
+            new
+            {
+                SessionId = sessionId,
+                Confirmed = SessionStatus.Confirmed,
+                ConfirmationSent = SessionStatus.ConfirmationSent
+            });
+
+        if (session is null)
+        {
+            logger.LogWarning("Session {SessionId} not eligible for one-hour reminder", sessionId);
+            return;
+        }
+
+        var recipients = (await connection.QueryAsync<DirectNotificationRecipient>(
+            """
+            SELECT p.telegram_id AS TelegramId,
+                   p.display_name AS DisplayName
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
+              AND sp.rsvp_status != @Declined
+            """,
+            new
+            {
+                SessionId = sessionId,
+                Active = ParticipantRegistrationStatus.Active,
+                Declined = RsvpStatus.Declined
+            })).ToList();
+
+        var mode = SessionNotificationModeExtensions.FromDatabaseValue(session.NotificationMode);
+        if (mode.ShouldSendDirectMessages() && recipients.Count > 0)
+        {
+            var text = $"""
+                ⏰ <b>Игра начнётся примерно через 1 час</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(session.Title)}</b>
+                📅 {session.ScheduledAt.FormatMoscow()} (МСК)
+                🔗 {System.Net.WebUtility.HtmlEncode(session.JoinLink)}
+                """;
+
+            await directSender.SendAsync(recipients, text, "one-hour-reminder", session.Id, ct);
+        }
+
+        await connection.ExecuteAsync(
+            """
+            UPDATE sessions
+            SET one_hour_reminder_processed_at = now(),
+                updated_at = now()
+            WHERE id = @SessionId
+              AND one_hour_reminder_processed_at IS NULL
+            """,
+            new { SessionId = sessionId });
+
+        logger.LogInformation(
+            "One-hour reminder processed for session {SessionId} ({Title}) with mode {NotificationMode}",
+            sessionId,
+            session.Title,
+            session.NotificationMode);
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/CancelSessionHandler.cs

@@ -1,9 +1,11 @@
 using Dapper;
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
+using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.CreateSession;
 
@@ -15,11 +17,12 @@ public sealed record CancelSessionCommand(
     int MessageId);
 
 // DTOs for AOT compilation
-internal sealed record CancelSessionInfoDto(string Title, Guid BatchId, long GmId);
+internal sealed record CancelSessionInfoDto(string Title, Guid BatchId, int? BatchMessageId, bool CanManage, string NotificationMode);
 
 public sealed class CancelSessionHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
+    DirectSessionNotificationSender directSender,
     ILogger<CancelSessionHandler> logger)
 {
     public async Task HandleAsync(CancelSessionCommand command, CancellationToken ct)
@@ -27,13 +30,24 @@ public sealed class CancelSessionHandler(
         await using var connection = await dataSource.OpenConnectionAsync(ct);
         await using var transaction = await connection.BeginTransactionAsync(ct);
         
-        // 1. Проверяем, что запрос делает ГМ данной сессии
+        // 1. Проверяем, что запрос делает управляющий данной группы.
         var session = await connection.QuerySingleOrDefaultAsync<CancelSessionInfoDto>(
-            @"SELECT s.title as Title, s.batch_id as BatchId, g.gm_telegram_id as GmId
-              FROM sessions s
-              JOIN game_groups g ON s.group_id = g.id
-              WHERE s.id = @SessionId",
-            new { command.SessionId }, transaction);
+            """
+            SELECT s.title AS Title,
+                   s.batch_id AS BatchId,
+                   s.batch_message_id AS BatchMessageId,
+                   s.notification_mode AS NotificationMode,
+                   EXISTS (
+                       SELECT 1
+                       FROM group_managers gm
+                       JOIN players p ON p.id = gm.player_id
+                       WHERE gm.group_id = s.group_id
+                         AND p.telegram_id = @TelegramUserId
+                   ) AS CanManage
+            FROM sessions s
+            WHERE s.id = @SessionId
+            """,
+            new { command.SessionId, command.TelegramUserId }, transaction);
 
         if (session == null)
         {
@@ -41,48 +55,82 @@ public sealed class CancelSessionHandler(
             return;
         }
 
-        if (session.GmId != command.TelegramUserId)
+        if (!session.CanManage)
         {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только Мастер Игры (GM) может отменять сессию.", showAlert: true, cancellationToken: ct);
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только owner или co-GM может отменять сессию.", showAlert: true, cancellationToken: ct);
             return;
         }
 
         // 2. Отменяем сессию
-        await connection.ExecuteAsync("UPDATE sessions SET status = 'Cancelled' WHERE id = @Id", new { Id = command.SessionId }, transaction);
+        await connection.ExecuteAsync(
+            "UPDATE sessions SET status = @Status WHERE id = @Id",
+            new { Id = command.SessionId, Status = SessionStatus.Cancelled },
+            transaction);
 
         // 3. Загружаем весь батч для перерисовки
         var batchSessions = await connection.QueryAsync<SessionBatchDto>(
-            @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+            @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status, max_players as MaxPlayers
+              FROM sessions
+              WHERE batch_id = @BatchId
+              ORDER BY scheduled_at",
             new { BatchId = session.BatchId }, transaction);
 
         var batchParticipants = await connection.QueryAsync<ParticipantBatchDto>(
-            @"SELECT sp.session_id as SessionId, p.display_name as DisplayName, p.telegram_username as TelegramUsername 
+            @"SELECT sp.session_id as SessionId,
+                     p.display_name as DisplayName,
+                     p.telegram_username as TelegramUsername,
+                     sp.registration_status as RegistrationStatus
               FROM session_participants sp
               JOIN players p ON sp.player_id = p.id
               JOIN sessions s ON sp.session_id = s.id
               WHERE s.batch_id = @BatchId AND sp.is_gm = false
-              ORDER BY sp.responded_at ASC, p.created_at ASC",
+              ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC",
             new { BatchId = session.BatchId }, transaction);
 
+        var directRecipients = (await connection.QueryAsync<DirectNotificationRecipient>(
+            """
+            SELECT p.telegram_id AS TelegramId,
+                   p.display_name AS DisplayName
+            FROM session_participants sp
+            JOIN players p ON sp.player_id = p.id
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
+            """,
+            new { command.SessionId, Active = ParticipantRegistrationStatus.Active },
+            transaction)).ToList();
+
         await transaction.CommitAsync(ct);
 
         // 4. Перерисовываем сообщение
-        var renderResult = SessionBatchRenderer.Render(session.Title, batchSessions.ToList(), batchParticipants.ToList());
+        var view = SessionBatchViewBuilder.Build(session.Title, batchSessions.ToList(), batchParticipants.ToList());
+        var renderResult = TelegramSessionBatchRenderer.Render(view);
 
         try
         {
-            await bot.EditMessageText(
+            await BatchMessageEditor.EditBatchMessageAsync(
+                bot,
                 chatId: command.ChatId,
-                messageId: command.MessageId,
+                messageId: session.BatchMessageId ?? command.MessageId,
                 text: renderResult.Text,
-                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                replyMarkup: renderResult.Markup, 
-                cancellationToken: ct);
+                replyMarkup: renderResult.Markup,
+                ct);
 
             await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия отменена!", cancellationToken: ct);
             
             // Опционально: написать отдельное сообщение в чат
             await bot.SendMessage(command.ChatId, $"❌ <b>Внимание!</b> Сессия \"{System.Net.WebUtility.HtmlEncode(session.Title)}\" отменена.", parseMode: Telegram.Bot.Types.Enums.ParseMode.Html, cancellationToken: ct);
+
+            var mode = SessionNotificationModeExtensions.FromDatabaseValue(session.NotificationMode);
+            if (mode.ShouldSendDirectMessages())
+            {
+                await directSender.SendAsync(
+                    directRecipients,
+                    $"❌ <b>Сессия отменена</b>\n\n📌 <b>{System.Net.WebUtility.HtmlEncode(session.Title)}</b>",
+                    "session-cancelled",
+                    command.SessionId,
+                    ct);
+            }
         }
         catch (Exception ex)
         {

src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs

@@ -1,14 +1,15 @@
-using System.Text.RegularExpressions;
 using Dapper;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
-using Telegram.Bot.Types.ReplyMarkups;
+using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.CreateSession;
 
+internal sealed record SessionCreationGroupAccessDto(Guid GroupId, bool CanManage);
+
 public sealed class CreateSessionHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient botClient,
@@ -16,49 +17,56 @@ public sealed class CreateSessionHandler(
 {
     public async Task HandleAsync(Message message, CancellationToken cancellationToken)
     {
-        var text = message.Text ?? "";
-        
-        string? title = null;
-        string? link = null;
-        var scheduledTimes = new List<DateTimeOffset>();
+        var parseResult = NewSessionCommandParser.Parse(message.Text ?? message.Caption, DateTimeOffset.UtcNow);
 
-        foreach (var line in text.Split('\n'))
+        foreach (var timeInput in parseResult.PastTimeInputs)
         {
-            var trimmed = line.Trim();
-            if (trimmed.StartsWith("Название:", StringComparison.OrdinalIgnoreCase))
-                title = trimmed["Название:".Length..].Trim();
-            else if (trimmed.StartsWith("Ссылка:", StringComparison.OrdinalIgnoreCase))
-                link = trimmed["Ссылка:".Length..].Trim();
-            else if (trimmed.StartsWith("Время:", StringComparison.OrdinalIgnoreCase))
-            {
-                var timeStr = trimmed["Время:".Length..].Trim();
-                if (MoscowTime.TryParseMoscow(timeStr, out var scheduledAt))
-                {
-                    if (scheduledAt > DateTimeOffset.UtcNow)
-                        scheduledTimes.Add(scheduledAt);
-                    else
-                        await botClient.SendMessage(message.Chat.Id, $"⚠️ Предупреждение: Дата {timeStr} находится в прошлом и будет пропущена.", cancellationToken: cancellationToken);
-                }
-                else
-                {
-                    await botClient.SendMessage(message.Chat.Id, $"⚠️ Предупреждение: Некорректный формат времени '{timeStr}'. Пропущено.", cancellationToken: cancellationToken);
-                }
-            }
+            await botClient.SendMessage(
+                message.Chat.Id,
+                $"⚠️ Предупреждение: дата {timeInput} находится в прошлом и будет пропущена.",
+                cancellationToken: cancellationToken);
         }
 
-        if (string.IsNullOrEmpty(title) || string.IsNullOrEmpty(link) || scheduledTimes.Count == 0)
+        foreach (var timeInput in parseResult.InvalidTimeInputs)
+        {
+            await botClient.SendMessage(
+                message.Chat.Id,
+                $"⚠️ Предупреждение: некорректный формат времени '{timeInput}'. Пропущено.",
+                cancellationToken: cancellationToken);
+        }
+
+        foreach (var seatLimitInput in parseResult.InvalidSeatLimitInputs)
+        {
+            await botClient.SendMessage(
+                message.Chat.Id,
+                $"⚠️ Предупреждение: некорректный лимит мест '{seatLimitInput}'. Укажите целое число больше 0.",
+                cancellationToken: cancellationToken);
+        }
+
+        foreach (var recurringInput in parseResult.InvalidRecurringInputs)
+        {
+            await botClient.SendMessage(
+                message.Chat.Id,
+                $"⚠️ Предупреждение: некорректный повтор расписания '{recurringInput}'. Укажите число игр 1-52 и шаг 1-365 дней.",
+                cancellationToken: cancellationToken);
+        }
+
+        if (!parseResult.IsValid)
         {
             await botClient.SendMessage(
                 chatId: message.Chat.Id,
-                text: "❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:\n\n/newsession\nНазвание: My Game\nВремя: 15.05.2026 19:30\nВремя: 22.05.2026 19:30\nСсылка: https://link",
+                text: "❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:\n\n/newsession\nНазвание: My Game\nВремя: 15.05.2026 19:30\nВремя: 22.05.2026 19:30\nМест: 4\nСсылка: https://link\nКартинка: https://cover\n\nДля повтора можно указать одну дату и строки:\nИгр: 4\nИнтервал: 7",
                 cancellationToken: cancellationToken);
             return;
         }
 
+        var title = parseResult.Title!;
+        var link = parseResult.Link!;
+        var imageReference = GetBatchImageReference(message, parseResult.ImageUrl);
         var gmId = message.From!.Id;
-        var gmName = message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? "" : $" {message.From.LastName}");
+        var gmName = message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? string.Empty : $" {message.From.LastName}");
         var gmUsername = message.From.Username;
-        
+
         var chatId = message.Chat.Id;
         var chatTitle = message.Chat.Title ?? "Private Chat";
 
@@ -67,23 +75,75 @@ public sealed class CreateSessionHandler(
 
         try
         {
-            // 1. Убеждаемся, что GM зарегистрирован
             await connection.ExecuteAsync(
-                @"INSERT INTO players (telegram_id, display_name, telegram_username) 
-                  VALUES (@TgId, @Name, @Username)
-                  ON CONFLICT (telegram_id) DO UPDATE SET display_name = EXCLUDED.display_name, telegram_username = EXCLUDED.telegram_username;",
+                """
+                INSERT INTO players (telegram_id, display_name, telegram_username)
+                VALUES (@TgId, @Name, @Username)
+                ON CONFLICT (telegram_id) DO UPDATE
+                SET display_name = EXCLUDED.display_name,
+                    telegram_username = EXCLUDED.telegram_username;
+                """,
                 new { TgId = gmId, Name = gmName, Username = gmUsername },
                 transaction);
 
-            // 2. Убеждаемся, что Группа зарегистрирована
-            var groupId = await connection.ExecuteScalarAsync<Guid>(
-                @"INSERT INTO game_groups (telegram_chat_id, name, gm_telegram_id)
-                  VALUES (@ChatId, @ChatName, @GmId)
-                  ON CONFLICT (telegram_chat_id) DO UPDATE SET name = EXCLUDED.name
-                  RETURNING id;",
-                new { ChatId = chatId, ChatName = chatTitle, GmId = gmId },
+            var existingGroup = await connection.QuerySingleOrDefaultAsync<SessionCreationGroupAccessDto>(
+                """
+                SELECT g.id AS GroupId,
+                       EXISTS (
+                           SELECT 1
+                           FROM group_managers gm
+                           JOIN players p ON p.id = gm.player_id
+                           WHERE gm.group_id = g.id
+                             AND p.telegram_id = @GmId
+                       ) AS CanManage
+                FROM game_groups g
+                WHERE g.telegram_chat_id = @ChatId
+                """,
+                new { ChatId = chatId, GmId = gmId },
                 transaction);
 
+            Guid groupId;
+            if (existingGroup is null)
+            {
+                groupId = await connection.ExecuteScalarAsync<Guid>(
+                    """
+                    INSERT INTO game_groups (telegram_chat_id, name, gm_telegram_id)
+                    VALUES (@ChatId, @ChatName, @GmId)
+                    RETURNING id;
+                    """,
+                    new { ChatId = chatId, ChatName = chatTitle, GmId = gmId },
+                    transaction);
+
+                await connection.ExecuteAsync(
+                    """
+                    INSERT INTO group_managers (group_id, player_id, role)
+                    SELECT @GroupId, p.id, @OwnerRole
+                    FROM players p
+                    WHERE p.telegram_id = @GmId
+                    ON CONFLICT (group_id, player_id) DO NOTHING
+                    """,
+                    new { GroupId = groupId, GmId = gmId, OwnerRole = GroupManagerRoleExtensions.OwnerValue },
+                    transaction);
+            }
+            else
+            {
+                if (!existingGroup.CanManage)
+                {
+                    await transaction.RollbackAsync(cancellationToken);
+                    await botClient.SendMessage(
+                        chatId,
+                        "⛔ Только owner или co-GM этой группы может создавать игровые сессии.",
+                        cancellationToken: cancellationToken);
+                    return;
+                }
+
+                groupId = existingGroup.GroupId;
+                await connection.ExecuteAsync(
+                    "UPDATE game_groups SET name = @ChatName WHERE id = @GroupId",
+                    new { ChatName = chatTitle, GroupId = groupId },
+                    transaction);
+            }
+
             int? messageThreadId = null;
             if (message.Chat.IsForum)
             {
@@ -94,43 +154,101 @@ public sealed class CreateSessionHandler(
                 messageThreadId = topic.MessageThreadId;
             }
 
-            // 3. Создаем сессии в цикле с общим batch_id
             var batchId = Guid.NewGuid();
             var sessions = new List<SessionBatchDto>();
 
-            foreach (var dt in scheduledTimes.OrderBy(d => d))
+            foreach (var scheduledAt in parseResult.ScheduledTimes.OrderBy(value => value))
             {
                 var sessionId = await connection.ExecuteScalarAsync<Guid>(
-                    @"INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, thread_id)
-                      VALUES (@BatchId, @GroupId, @Title, @Link, @ScheduledAt, 'Planned', @ThreadId)
-                      RETURNING id;",
-                    new { BatchId = batchId, GroupId = groupId, Title = title, Link = link, ScheduledAt = dt, ThreadId = messageThreadId },
+                    """
+                    INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, thread_id, max_players)
+                    VALUES (@BatchId, @GroupId, @Title, @Link, @ScheduledAt, @Status, @ThreadId, @MaxPlayers)
+                    RETURNING id;
+                    """,
+                    new
+                    {
+                        BatchId = batchId,
+                        GroupId = groupId,
+                        Title = title,
+                        Link = link,
+                        ScheduledAt = scheduledAt,
+                        ThreadId = messageThreadId,
+                        MaxPlayers = parseResult.MaxPlayers,
+                        Status = SessionStatus.Planned
+                    },
                     transaction);
 
-                sessions.Add(new SessionBatchDto(sessionId, dt.UtcDateTime, "Planned"));
+                sessions.Add(new SessionBatchDto(sessionId, scheduledAt.UtcDateTime, SessionStatus.Planned, parseResult.MaxPlayers));
             }
 
             await transaction.CommitAsync(cancellationToken);
             logger.LogInformation("Создан батч {BatchId} с {Count} сессиями в группе {GroupId}", batchId, sessions.Count, groupId);
 
-            // 4. Отправляем сообщение в чат
-            var renderResult = SessionBatchRenderer.Render(title, sessions, Array.Empty<ParticipantBatchDto>());
+            var view = SessionBatchViewBuilder.Build(title, sessions, Array.Empty<ParticipantBatchDto>());
+            var renderResult = TelegramSessionBatchRenderer.Render(view);
 
+            Message batchMessage;
 
-            var batchMessage = await botClient.SendMessage(
-                chatId: chatId,
-                messageThreadId: messageThreadId,
-                text: renderResult.Text,
-                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                replyMarkup: renderResult.Markup,
-                cancellationToken: cancellationToken);
+            if (imageReference is not null && renderResult.Text.Length <= 1024)
+            {
+                // Картинка + расписание умещаются в одном Telegram-фото с подписью
+                try
+                {
+                    batchMessage = await botClient.SendPhoto(
+                        chatId: chatId,
+                        messageThreadId: messageThreadId,
+                        photo: InputFile.FromString(imageReference),
+                        caption: renderResult.Text,
+                        parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                        replyMarkup: renderResult.Markup,
+                        cancellationToken: cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "Не удалось отправить картинку для батча {BatchId}, отправляем текстом", batchId);
+                    batchMessage = await botClient.SendMessage(
+                        chatId: chatId,
+                        messageThreadId: messageThreadId,
+                        text: renderResult.Text,
+                        parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                        replyMarkup: renderResult.Markup,
+                        cancellationToken: cancellationToken);
+                }
+            }
+            else
+            {
+                // Текст слишком длинный для caption — fallback на два сообщения
+                if (imageReference is not null)
+                {
+                    try
+                    {
+                        await botClient.SendPhoto(
+                            chatId: chatId,
+                            messageThreadId: messageThreadId,
+                            photo: InputFile.FromString(imageReference),
+                            caption: $"🎲 {System.Net.WebUtility.HtmlEncode(title)}",
+                            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                            cancellationToken: cancellationToken);
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogWarning(ex, "Не удалось отправить картинку для батча {BatchId}", batchId);
+                    }
+                }
+
+                batchMessage = await botClient.SendMessage(
+                    chatId: chatId,
+                    messageThreadId: messageThreadId,
+                    text: renderResult.Text,
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    replyMarkup: renderResult.Markup,
+                    cancellationToken: cancellationToken);
+            }
 
-            // 4b. Сохраняем message_id батч-сообщения для дальнейшего редактирования
             await connection.ExecuteAsync(
                 "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
                 new { MsgId = batchMessage.MessageId, BatchId = batchId });
 
-            // 5. Удаляем исходное сообщение с командой /newsession, чтобы не спамить
             try
             {
                 await botClient.DeleteMessage(
@@ -150,4 +268,20 @@ public sealed class CreateSessionHandler(
             await botClient.SendMessage(chatId, "💥 Произошла ошибка базы данных при создании сессии.", cancellationToken: cancellationToken);
         }
     }
+
+    internal static string? GetBatchImageReference(Message message, string? parsedImageUrl)
+    {
+        var attachedPhotoFileId = message.Photo?
+            .OrderByDescending(photo => photo.FileSize ?? 0)
+            .ThenByDescending(photo => photo.Width * photo.Height)
+            .FirstOrDefault()
+            ?.FileId;
+
+        if (!string.IsNullOrWhiteSpace(attachedPhotoFileId))
+        {
+            return attachedPhotoFileId;
+        }
+
+        return string.IsNullOrWhiteSpace(parsedImageUrl) ? null : parsedImageUrl.Trim();
+    }
 }

src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs

@@ -2,9 +2,9 @@ using Dapper;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
-using Telegram.Bot.Types.ReplyMarkups;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
+using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.CreateSession;
 
@@ -18,7 +18,7 @@ public sealed record JoinSessionCommand(
     int MessageId);
 
 // DTOs for AOT compilation
-internal sealed record JoinSessionBatchDto(Guid BatchId, string Title);
+internal sealed record JoinSessionBatchDto(Guid BatchId, string Title, int? MaxPlayers);
 
 public sealed class JoinSessionHandler(
     NpgsqlDataSource dataSource,
@@ -29,6 +29,7 @@ public sealed class JoinSessionHandler(
     {
         await using var connection = await dataSource.OpenConnectionAsync(ct);
         await using var transaction = await connection.BeginTransactionAsync(ct);
+        var transactionCommitted = false;
 
         try
         {
@@ -41,12 +42,68 @@ public sealed class JoinSessionHandler(
                 new { TgId = command.TelegramUserId, Name = command.DisplayName, Username = command.TelegramUsername },
                 transaction);
 
-            // 2. Добавляем в участники сессии (статус Pending, так как за 24 часа нужно будет финальное подтверждение)
+            // 2. Блокируем сессию на время расчета мест, чтобы параллельные нажатия не переполнили состав.
+            var batchInfo = await connection.QuerySingleOrDefaultAsync<JoinSessionBatchDto>(
+                @"SELECT batch_id as BatchId, title as Title, max_players as MaxPlayers
+                  FROM sessions
+                  WHERE id = @SessionId
+                  FOR UPDATE",
+                new { command.SessionId },
+                transaction);
+
+            if (batchInfo is null)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+                return;
+            }
+
+            var existingRegistrationStatus = await connection.ExecuteScalarAsync<string?>(
+                """
+                SELECT sp.registration_status
+                FROM session_participants sp
+                WHERE sp.session_id = @SessionId
+                  AND sp.player_id = @PlayerId
+                  AND sp.is_gm = false
+                """,
+                new { command.SessionId, PlayerId = playerId },
+                transaction);
+
+            if (existingRegistrationStatus is not null)
+            {
+                await transaction.RollbackAsync(ct);
+                var alreadyText = existingRegistrationStatus == ParticipantRegistrationStatus.Waitlisted
+                    ? "Вы уже в листе ожидания!"
+                    : "Вы уже записаны!";
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, alreadyText, cancellationToken: ct);
+                return;
+            }
+
+            var activeParticipants = await connection.ExecuteScalarAsync<int>(
+                """
+                SELECT COUNT(*)
+                FROM session_participants
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Active
+                """,
+                new { command.SessionId, Active = ParticipantRegistrationStatus.Active },
+                transaction);
+
+            var registrationStatus = SessionCapacityRules.DecideJoinStatus(batchInfo.MaxPlayers, activeParticipants);
+
+            // 3. Добавляем в основной состав или лист ожидания. RSVP остается Pending до финального подтверждения.
             var inserted = await connection.ExecuteAsync(
-                @"INSERT INTO session_participants (session_id, player_id, is_gm, rsvp_status)
-                  VALUES (@SessionId, @PlayerId, false, 'Pending')
+                @"INSERT INTO session_participants (session_id, player_id, is_gm, rsvp_status, registration_status)
+                  VALUES (@SessionId, @PlayerId, false, @Pending, @RegistrationStatus)
                   ON CONFLICT (session_id, player_id) DO NOTHING;",
-                new { SessionId = command.SessionId, PlayerId = playerId },
+                new
+                {
+                    command.SessionId,
+                    PlayerId = playerId,
+                    Pending = RsvpStatus.Pending,
+                    RegistrationStatus = registrationStatus
+                },
                 transaction);
 
             if (inserted == 0)
@@ -56,45 +113,58 @@ public sealed class JoinSessionHandler(
                 return;
             }
 
-            // 3. Получаем batch_id по session_id
-            var batchInfo = await connection.QuerySingleAsync<JoinSessionBatchDto>(
-                @"SELECT batch_id as BatchId, title as Title FROM sessions WHERE id = @SessionId",
-                new { command.SessionId }, transaction);
-
             // Загружаем весь батч для перерисовки
             var batchSessions = await connection.QueryAsync<SessionBatchDto>(
-                @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status, max_players as MaxPlayers
+                  FROM sessions
+                  WHERE batch_id = @BatchId
+                  ORDER BY scheduled_at",
                 new { BatchId = batchInfo.BatchId }, transaction);
 
             var batchParticipants = await connection.QueryAsync<ParticipantBatchDto>(
-                @"SELECT sp.session_id as SessionId, p.display_name as DisplayName, p.telegram_username as TelegramUsername 
+                @"SELECT sp.session_id as SessionId,
+                         p.display_name as DisplayName,
+                         p.telegram_username as TelegramUsername,
+                         sp.registration_status as RegistrationStatus
                   FROM session_participants sp
                   JOIN players p ON sp.player_id = p.id
                   JOIN sessions s ON sp.session_id = s.id
                   WHERE s.batch_id = @BatchId AND sp.is_gm = false
-                  ORDER BY sp.responded_at ASC, p.created_at ASC",
+                  ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC",
                 new { BatchId = batchInfo.BatchId }, transaction);
 
             await transaction.CommitAsync(ct);
+            transactionCommitted = true;
 
             // 4. Перерисовываем сообщение
-            var renderResult = SessionBatchRenderer.Render(batchInfo.Title, batchSessions.ToList(), batchParticipants.ToList());
+            var view = SessionBatchViewBuilder.Build(batchInfo.Title, batchSessions.ToList(), batchParticipants.ToList());
+            var renderResult = TelegramSessionBatchRenderer.Render(view);
 
-            await bot.EditMessageText(
+            await BatchMessageEditor.EditBatchMessageAsync(
+                bot,
                 chatId: command.ChatId,
                 messageId: command.MessageId,
                 text: renderResult.Text,
-                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
                 replyMarkup: renderResult.Markup,
-                cancellationToken: ct);
+                ct);
 
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы успешно записаны!", cancellationToken: ct);
+            var callbackText = registrationStatus == ParticipantRegistrationStatus.Waitlisted
+                ? "Основной состав заполнен. Вы добавлены в лист ожидания."
+                : "Вы успешно записаны!";
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, callbackText, cancellationToken: ct);
         }
         catch (Exception ex)
         {
             logger.LogError(ex, "Ошибка при добавлении игрока к сессии");
-            await transaction.RollbackAsync(ct);
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Произошла ошибка при регистрации.", cancellationToken: ct);
+            if (!transactionCommitted)
+            {
+                await transaction.RollbackAsync(ct);
+            }
+
+            var errorText = transactionCommitted
+                ? "Регистрация сохранена, но не удалось обновить сообщение расписания."
+                : "Произошла ошибка при регистрации.";
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, errorText, cancellationToken: ct);
         }
     }
 }

src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs

@@ -0,0 +1,219 @@
+using Dapper;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Npgsql;
+using Telegram.Bot;
+using GmRelay.Bot.Infrastructure.Telegram;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+public sealed record LeaveSessionCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+internal sealed record LeaveSessionInfoDto(string Title, Guid BatchId, string Status, int? MaxPlayers);
+internal sealed record LeaveSessionParticipantDto(Guid ParticipantRowId, string DisplayName, string RegistrationStatus);
+internal sealed record LeaveSessionPromotionDto(Guid ParticipantRowId, string DisplayName);
+
+public sealed class LeaveSessionHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<LeaveSessionHandler> logger)
+{
+    public async Task HandleAsync(LeaveSessionCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+        var transactionCommitted = false;
+
+        try
+        {
+            var session = await connection.QuerySingleOrDefaultAsync<LeaveSessionInfoDto>(
+                """
+                SELECT title AS Title,
+                       batch_id AS BatchId,
+                       status AS Status,
+                       max_players AS MaxPlayers
+                FROM sessions
+                WHERE id = @SessionId
+                FOR UPDATE
+                """,
+                new { command.SessionId },
+                transaction);
+
+            if (session is null)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+                return;
+            }
+
+            if (SessionStatus.IsCancelled(session.Status))
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия уже отменена.", cancellationToken: ct);
+                return;
+            }
+
+            var participant = await connection.QuerySingleOrDefaultAsync<LeaveSessionParticipantDto>(
+                """
+                SELECT sp.id AS ParticipantRowId,
+                       p.display_name AS DisplayName,
+                       sp.registration_status AS RegistrationStatus
+                FROM session_participants sp
+                JOIN players p ON p.id = sp.player_id
+                WHERE sp.session_id = @SessionId
+                  AND p.telegram_id = @TelegramUserId
+                  AND sp.is_gm = false
+                FOR UPDATE OF sp
+                """,
+                new { command.SessionId, command.TelegramUserId },
+                transaction);
+
+            if (participant is null)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы не записаны на эту сессию.", cancellationToken: ct);
+                return;
+            }
+
+            await connection.ExecuteAsync(
+                """
+                DELETE FROM session_participants
+                WHERE id = @ParticipantRowId
+                """,
+                new { participant.ParticipantRowId },
+                transaction);
+
+            var activeParticipantsAfterLeave = await connection.ExecuteScalarAsync<int>(
+                """
+                SELECT COUNT(*)
+                FROM session_participants
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Active
+                """,
+                new { command.SessionId, Active = ParticipantRegistrationStatus.Active },
+                transaction);
+
+            var waitlistedParticipants = await connection.ExecuteScalarAsync<int>(
+                """
+                SELECT COUNT(*)
+                FROM session_participants
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Waitlisted
+                """,
+                new { command.SessionId, Waitlisted = ParticipantRegistrationStatus.Waitlisted },
+                transaction);
+
+            string? promotedDisplayName = null;
+            if (SessionCapacityRules.ShouldPromoteAfterParticipantLeaves(
+                participant.RegistrationStatus,
+                session.MaxPlayers,
+                activeParticipantsAfterLeave,
+                waitlistedParticipants))
+            {
+                var promoted = await connection.QuerySingleAsync<LeaveSessionPromotionDto>(
+                    """
+                    SELECT sp.id AS ParticipantRowId,
+                           p.display_name AS DisplayName
+                    FROM session_participants sp
+                    JOIN players p ON p.id = sp.player_id
+                    WHERE sp.session_id = @SessionId
+                      AND sp.is_gm = false
+                      AND sp.registration_status = @Waitlisted
+                    ORDER BY sp.created_at ASC, sp.id ASC
+                    LIMIT 1
+                    FOR UPDATE OF sp
+                    """,
+                    new { command.SessionId, Waitlisted = ParticipantRegistrationStatus.Waitlisted },
+                    transaction);
+
+                await connection.ExecuteAsync(
+                    """
+                    UPDATE session_participants
+                    SET registration_status = @Active,
+                        rsvp_status = @Pending,
+                        responded_at = NULL
+                    WHERE id = @ParticipantRowId
+                    """,
+                    new
+                    {
+                        promoted.ParticipantRowId,
+                        Active = ParticipantRegistrationStatus.Active,
+                        Pending = RsvpStatus.Pending
+                    },
+                    transaction);
+
+                promotedDisplayName = promoted.DisplayName;
+            }
+
+            var batchSessions = (await connection.QueryAsync<SessionBatchDto>(
+                """
+                SELECT id AS SessionId,
+                       scheduled_at AS ScheduledAt,
+                       status AS Status,
+                       max_players AS MaxPlayers
+                FROM sessions
+                WHERE batch_id = @BatchId
+                ORDER BY scheduled_at
+                """,
+                new { session.BatchId },
+                transaction)).ToList();
+
+            var batchParticipants = (await connection.QueryAsync<ParticipantBatchDto>(
+                """
+                SELECT sp.session_id AS SessionId,
+                       p.display_name AS DisplayName,
+                       p.telegram_username AS TelegramUsername,
+                       sp.registration_status AS RegistrationStatus
+                FROM session_participants sp
+                JOIN players p ON sp.player_id = p.id
+                JOIN sessions s ON sp.session_id = s.id
+                WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
+                """,
+                new { session.BatchId },
+                transaction)).ToList();
+
+            await transaction.CommitAsync(ct);
+            transactionCommitted = true;
+
+            var view = SessionBatchViewBuilder.Build(session.Title, batchSessions, batchParticipants);
+            var renderResult = TelegramSessionBatchRenderer.Render(view);
+
+            await BatchMessageEditor.EditBatchMessageAsync(
+                bot,
+                chatId: command.ChatId,
+                messageId: command.MessageId,
+                text: renderResult.Text,
+                replyMarkup: renderResult.Markup,
+                ct);
+
+            var callbackText = participant.RegistrationStatus == ParticipantRegistrationStatus.Waitlisted
+                ? "Вы удалены из листа ожидания."
+                : promotedDisplayName is null
+                    ? "Вы отписались от сессии."
+                    : $"Вы отписались от сессии. Место получил(а) {promotedDisplayName}.";
+
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, callbackText, cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при самостоятельной отмене записи на сессию {SessionId}", command.SessionId);
+            if (!transactionCommitted)
+            {
+                await transaction.RollbackAsync(ct);
+            }
+
+            var errorText = transactionCommitted
+                ? "Запись снята, но не удалось обновить сообщение расписания."
+                : "Произошла ошибка при отмене записи.";
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, errorText, cancellationToken: ct);
+        }
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/NewSessionCommandParser.cs

@@ -0,0 +1,184 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+internal sealed record NewSessionParseResult(
+    string? Title,
+    string? Link,
+    string? ImageUrl,
+    int? MaxPlayers,
+    IReadOnlyList<DateTimeOffset> ScheduledTimes,
+    IReadOnlyList<string> PastTimeInputs,
+    IReadOnlyList<string> InvalidTimeInputs,
+    IReadOnlyList<string> InvalidSeatLimitInputs,
+    IReadOnlyList<string> InvalidRecurringInputs)
+{
+    public bool IsValid =>
+        !string.IsNullOrWhiteSpace(Title) &&
+        !string.IsNullOrWhiteSpace(Link) &&
+        ScheduledTimes.Count > 0 &&
+        InvalidSeatLimitInputs.Count == 0 &&
+        InvalidRecurringInputs.Count == 0;
+}
+
+internal static class NewSessionCommandParser
+{
+    private const int MaxRecurringSessionCount = 52;
+    private const int MaxRecurringIntervalDays = 365;
+    private const string TitlePrefix = "\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u0435:";
+    private const string TimePrefix = "\u0412\u0440\u0435\u043c\u044f:";
+    private const string LinkPrefix = "\u0421\u0441\u044b\u043b\u043a\u0430:";
+    private static readonly string[] ImagePrefixes =
+    [
+        "\u041a\u0430\u0440\u0442\u0438\u043d\u043a\u0430:",
+        "\u0418\u0437\u043e\u0431\u0440\u0430\u0436\u0435\u043d\u0438\u0435:",
+        "\u041e\u0431\u043b\u043e\u0436\u043a\u0430:"
+    ];
+    private static readonly string[] SeatLimitPrefixes =
+    [
+        "\u041c\u0435\u0441\u0442:",
+        "\u041b\u0438\u043c\u0438\u0442:",
+        "\u041c\u0430\u043a\u0441\u0438\u043c\u0443\u043c:"
+    ];
+    private static readonly string[] RecurringCountPrefixes =
+    [
+        "\u0418\u0433\u0440:",
+        "\u0421\u0435\u0441\u0441\u0438\u0439:",
+        "\u041f\u043e\u0432\u0442\u043e\u0440\u043e\u0432:"
+    ];
+    private static readonly string[] RecurringIntervalPrefixes =
+    [
+        "\u0428\u0430\u0433:",
+        "\u0418\u043d\u0442\u0435\u0440\u0432\u0430\u043b:"
+    ];
+
+    public static NewSessionParseResult Parse(string? text, DateTimeOffset nowUtc)
+    {
+        string? title = null;
+        string? link = null;
+        string? imageUrl = null;
+        int? maxPlayers = null;
+        int? recurringCount = null;
+        var recurringIntervalDays = 7;
+        var scheduledTimes = new List<DateTimeOffset>();
+        var pastTimeInputs = new List<string>();
+        var invalidTimeInputs = new List<string>();
+        var invalidSeatLimitInputs = new List<string>();
+        var invalidRecurringInputs = new List<string>();
+
+        foreach (var line in (text ?? string.Empty).Split('\n', StringSplitOptions.TrimEntries))
+        {
+            if (line.StartsWith(TitlePrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                title = line[TitlePrefix.Length..].Trim();
+                continue;
+            }
+
+            if (line.StartsWith(LinkPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                link = line[LinkPrefix.Length..].Trim();
+                continue;
+            }
+
+            var imagePrefix = ImagePrefixes.FirstOrDefault(prefix =>
+                line.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+            if (imagePrefix is not null)
+            {
+                imageUrl = line[imagePrefix.Length..].Trim();
+                continue;
+            }
+
+            var seatLimitPrefix = SeatLimitPrefixes.FirstOrDefault(prefix =>
+                line.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+            if (seatLimitPrefix is not null)
+            {
+                var seatLimitInput = line[seatLimitPrefix.Length..].Trim();
+                if (int.TryParse(seatLimitInput, out var parsedMaxPlayers) && parsedMaxPlayers > 0)
+                {
+                    maxPlayers = parsedMaxPlayers;
+                }
+                else
+                {
+                    invalidSeatLimitInputs.Add(seatLimitInput);
+                }
+
+                continue;
+            }
+
+            var recurringCountPrefix = RecurringCountPrefixes.FirstOrDefault(prefix =>
+                line.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+            if (recurringCountPrefix is not null)
+            {
+                var recurringInput = line[recurringCountPrefix.Length..].Trim();
+                if (int.TryParse(recurringInput, out var parsedCount) &&
+                    parsedCount is >= 1 and <= MaxRecurringSessionCount)
+                {
+                    recurringCount = parsedCount;
+                }
+                else
+                {
+                    invalidRecurringInputs.Add(recurringInput);
+                }
+
+                continue;
+            }
+
+            var recurringIntervalPrefix = RecurringIntervalPrefixes.FirstOrDefault(prefix =>
+                line.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+            if (recurringIntervalPrefix is not null)
+            {
+                var recurringInput = line[recurringIntervalPrefix.Length..].Trim();
+                if (int.TryParse(recurringInput, out var parsedInterval) &&
+                    parsedInterval is >= 1 and <= MaxRecurringIntervalDays)
+                {
+                    recurringIntervalDays = parsedInterval;
+                }
+                else
+                {
+                    invalidRecurringInputs.Add(recurringInput);
+                }
+
+                continue;
+            }
+
+            if (!line.StartsWith(TimePrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var timeInput = line[TimePrefix.Length..].Trim();
+            if (!MoscowTime.TryParseMoscow(timeInput, out var scheduledAt))
+            {
+                invalidTimeInputs.Add(timeInput);
+                continue;
+            }
+
+            if (scheduledAt <= nowUtc)
+            {
+                pastTimeInputs.Add(timeInput);
+                continue;
+            }
+
+            scheduledTimes.Add(scheduledAt);
+        }
+
+        if (recurringCount.HasValue && scheduledTimes.Count == 1)
+        {
+            var firstScheduledTime = scheduledTimes[0];
+            scheduledTimes = Enumerable.Range(0, recurringCount.Value)
+                .Select(index => firstScheduledTime.AddDays(recurringIntervalDays * index))
+                .ToList();
+        }
+
+        return new NewSessionParseResult(
+            title,
+            link,
+            imageUrl,
+            maxPlayers,
+            scheduledTimes,
+            pastTimeInputs,
+            invalidTimeInputs,
+            invalidSeatLimitInputs,
+            invalidRecurringInputs);
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/PromoteWaitlistedPlayerHandler.cs

@@ -0,0 +1,193 @@
+using Dapper;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Npgsql;
+using Telegram.Bot;
+using GmRelay.Bot.Infrastructure.Telegram;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+public sealed record PromoteWaitlistedPlayerCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+internal sealed record PromoteWaitlistSessionDto(string Title, Guid BatchId, int? BatchMessageId, bool CanManage, int? MaxPlayers);
+internal sealed record WaitlistedParticipantDto(Guid ParticipantRowId, string DisplayName);
+
+public sealed class PromoteWaitlistedPlayerHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<PromoteWaitlistedPlayerHandler> logger)
+{
+    public async Task HandleAsync(PromoteWaitlistedPlayerCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+        var transactionCommitted = false;
+
+        try
+        {
+            var session = await connection.QuerySingleOrDefaultAsync<PromoteWaitlistSessionDto>(
+                """
+                SELECT s.title AS Title,
+                       s.batch_id AS BatchId,
+                       s.batch_message_id AS BatchMessageId,
+                       s.max_players AS MaxPlayers,
+                       EXISTS (
+                           SELECT 1
+                           FROM group_managers gm
+                           JOIN players p ON p.id = gm.player_id
+                           WHERE gm.group_id = s.group_id
+                             AND p.telegram_id = @TelegramUserId
+                       ) AS CanManage
+                FROM sessions s
+                WHERE s.id = @SessionId
+                FOR UPDATE
+                """,
+                new { command.SessionId, command.TelegramUserId },
+                transaction);
+
+            if (session is null)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+                return;
+            }
+
+            if (!session.CanManage)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только owner или co-GM может поднимать игроков из листа ожидания.", showAlert: true, cancellationToken: ct);
+                return;
+            }
+
+            var activeParticipants = await connection.ExecuteScalarAsync<int>(
+                """
+                SELECT COUNT(*)
+                FROM session_participants
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Active
+                """,
+                new { command.SessionId, Active = ParticipantRegistrationStatus.Active },
+                transaction);
+
+            var waitlistedParticipants = await connection.ExecuteScalarAsync<int>(
+                """
+                SELECT COUNT(*)
+                FROM session_participants
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Waitlisted
+                """,
+                new { command.SessionId, Waitlisted = ParticipantRegistrationStatus.Waitlisted },
+                transaction);
+
+            if (waitlistedParticipants == 0)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Лист ожидания пуст.", cancellationToken: ct);
+                return;
+            }
+
+            if (!SessionCapacityRules.CanPromoteWaitlistedPlayer(session.MaxPlayers, activeParticipants, waitlistedParticipants))
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Нет свободных мест. Увеличьте лимит перед повышением игрока.", showAlert: true, cancellationToken: ct);
+                return;
+            }
+
+            var promoted = await connection.QuerySingleAsync<WaitlistedParticipantDto>(
+                """
+                SELECT sp.id AS ParticipantRowId,
+                       p.display_name AS DisplayName
+                FROM session_participants sp
+                JOIN players p ON p.id = sp.player_id
+                WHERE sp.session_id = @SessionId
+                  AND sp.is_gm = false
+                  AND sp.registration_status = @Waitlisted
+                ORDER BY sp.created_at ASC, sp.id ASC
+                LIMIT 1
+                FOR UPDATE OF sp
+                """,
+                new { command.SessionId, Waitlisted = ParticipantRegistrationStatus.Waitlisted },
+                transaction);
+
+            await connection.ExecuteAsync(
+                """
+                UPDATE session_participants
+                SET registration_status = @Active,
+                    rsvp_status = @Pending,
+                    responded_at = NULL
+                WHERE id = @ParticipantRowId
+                """,
+                new
+                {
+                    promoted.ParticipantRowId,
+                    Active = ParticipantRegistrationStatus.Active,
+                    Pending = RsvpStatus.Pending
+                },
+                transaction);
+
+            var batchSessions = (await connection.QueryAsync<SessionBatchDto>(
+                """
+                SELECT id AS SessionId,
+                       scheduled_at AS ScheduledAt,
+                       status AS Status,
+                       max_players AS MaxPlayers
+                FROM sessions
+                WHERE batch_id = @BatchId
+                ORDER BY scheduled_at
+                """,
+                new { session.BatchId },
+                transaction)).ToList();
+
+            var batchParticipants = (await connection.QueryAsync<ParticipantBatchDto>(
+                """
+                SELECT sp.session_id AS SessionId,
+                       p.display_name AS DisplayName,
+                       p.telegram_username AS TelegramUsername,
+                       sp.registration_status AS RegistrationStatus
+                FROM session_participants sp
+                JOIN players p ON sp.player_id = p.id
+                JOIN sessions s ON sp.session_id = s.id
+                WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
+                """,
+                new { session.BatchId },
+                transaction)).ToList();
+
+            await transaction.CommitAsync(ct);
+            transactionCommitted = true;
+
+            var view = SessionBatchViewBuilder.Build(session.Title, batchSessions, batchParticipants);
+            var renderResult = TelegramSessionBatchRenderer.Render(view);
+
+            await BatchMessageEditor.EditBatchMessageAsync(
+                bot,
+                chatId: command.ChatId,
+                messageId: session.BatchMessageId ?? command.MessageId,
+                text: renderResult.Text,
+                replyMarkup: renderResult.Markup,
+                ct);
+
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, $"{promoted.DisplayName} переведен(а) в основной состав.", cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при повышении игрока из листа ожидания для сессии {SessionId}", command.SessionId);
+            if (!transactionCommitted)
+            {
+                await transaction.RollbackAsync(ct);
+            }
+
+            var errorText = transactionCommitted
+                ? "Игрок повышен, но не удалось обновить сообщение расписания."
+                : "Ошибка при обновлении листа ожидания.";
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, errorText, cancellationToken: ct);
+        }
+    }
+}

src/GmRelay.Bot/Features/Sessions/ExportCalendar/ExportCalendarHandler.cs

@@ -1,8 +1,11 @@
 using System.Text;
 using Dapper;
+using GmRelay.Shared.Domain;
+using Microsoft.Extensions.Configuration;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Features.Sessions.ExportCalendar;
 
@@ -10,21 +13,22 @@ internal sealed record CalendarSessionDto(Guid Id, string Title, DateTime Schedu
 
 public sealed class ExportCalendarHandler(
     NpgsqlDataSource dataSource,
-    ITelegramBotClient botClient)
+    ITelegramBotClient botClient,
+    IConfiguration configuration)
 {
     public async Task HandleAsync(Message message, CancellationToken cancellationToken)
     {
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
 
         var sessions = await connection.QueryAsync<CalendarSessionDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt
-              FROM sessions s
-              JOIN game_groups g ON s.group_id = g.id
-              WHERE g.telegram_chat_id = @ChatId 
-                AND s.status = 'Planned' 
-                AND s.scheduled_at > NOW()
-              ORDER BY s.scheduled_at ASC",
-            new { ChatId = message.Chat.Id });
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt"
+            + " FROM sessions s"
+            + " JOIN game_groups g ON s.group_id = g.id"
+            + " WHERE g.telegram_chat_id = @ChatId"
+            + " AND s.status = @Planned"
+            + " AND s.scheduled_at > NOW()"
+            + " ORDER BY s.scheduled_at ASC",
+            new { ChatId = message.Chat.Id, Planned = SessionStatus.Planned });
 
         var sessionsList = sessions.ToList();
 
@@ -53,8 +57,6 @@ public sealed class ExportCalendarHandler(
             sb.AppendLine($"DTSTART:{dtStart}");
             sb.AppendLine($"DTEND:{dtEnd}");
             sb.AppendLine($"SUMMARY:{s.Title}");
-            // Escape special chars according to iCal standards (RFC 5545) -- simple escaping for summary
-            // In a fuller implementation we'd escape \r\n, commas, etc. But titles are mostly plain text.
             sb.AppendLine("END:VEVENT");
         }
 
@@ -65,11 +67,45 @@ public sealed class ExportCalendarHandler(
 
         var inputFile = InputFile.FromStream(stream, "schedule.ics");
 
+        // Create calendar subscription
+        string? subscriptionUrl = null;
+        var baseUrl = configuration["Web:BaseUrl"];
+        var senderId = message.From?.Id;
+        if (!string.IsNullOrWhiteSpace(baseUrl) && senderId.HasValue)
+        {
+            try
+            {
+                var token = Guid.NewGuid().ToString("N");
+                var groupId = await connection.QueryFirstOrDefaultAsync<Guid?>(
+                    @"SELECT id FROM game_groups WHERE telegram_chat_id = @ChatId",
+                    new { ChatId = message.Chat.Id });
+
+                await connection.ExecuteAsync(
+                    @"INSERT INTO calendar_subscriptions (id, token, user_telegram_id, group_id, filter_type, created_at, expires_at)
+                      VALUES (gen_random_uuid(), @token, @userTelegramId, @groupId, @filterType, now(), NULL)",
+                    new { token, userTelegramId = senderId.Value, groupId, filterType = (int)CalendarSubscriptionFilter.SpecificGroup });
+
+                subscriptionUrl = $"{baseUrl.TrimEnd('/')}/calendar/{token}.ics";
+            }
+            catch
+            {
+                // Non-critical: if subscription creation fails, still send the file
+            }
+        }
+
+        var replyMarkup = subscriptionUrl is not null
+            ? new InlineKeyboardMarkup(new[]
+            {
+                new[] { InlineKeyboardButton.WithUrl("🔗 Подписаться на календарь", subscriptionUrl) }
+            })
+            : null;
+
         await botClient.SendDocument(
              chatId: message.Chat.Id,
              document: inputFile,
              caption: "📅 <b>Ваш календарь игр!</b>\nОткройте файл на устройстве, чтобы добавить события в свой календарь.",
              parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+             replyMarkup: replyMarkup,
              messageThreadId: message.MessageThreadId,
              cancellationToken: cancellationToken);
     }

src/GmRelay.Bot/Features/Sessions/ListSessions/DeleteSessionHandler.cs

@@ -12,7 +12,7 @@ public sealed record DeleteSessionCommand(
     long ChatId,
     int MessageId);
 
-internal sealed record DeleteSessionInfoDto(string Title, Guid BatchId, long GmId, int? ThreadId);
+internal sealed record DeleteSessionInfoDto(string Title, Guid BatchId, bool CanManage, int? ThreadId);
 
 public sealed class DeleteSessionHandler(
     NpgsqlDataSource dataSource,
@@ -24,13 +24,23 @@ public sealed class DeleteSessionHandler(
         await using var connection = await dataSource.OpenConnectionAsync(ct);
         await using var transaction = await connection.BeginTransactionAsync(ct);
 
-        // 1. Fetch session and verify GM
+        // 1. Fetch session and verify group manager.
         var session = await connection.QuerySingleOrDefaultAsync<DeleteSessionInfoDto>(
-            @"SELECT s.title as Title, s.batch_id as BatchId, s.thread_id as ThreadId, g.gm_telegram_id as GmId
-              FROM sessions s
-              JOIN game_groups g ON s.group_id = g.id
-              WHERE s.id = @SessionId",
-            new { command.SessionId }, transaction);
+            """
+            SELECT s.title AS Title,
+                   s.batch_id AS BatchId,
+                   s.thread_id AS ThreadId,
+                   EXISTS (
+                       SELECT 1
+                       FROM group_managers gm
+                       JOIN players p ON p.id = gm.player_id
+                       WHERE gm.group_id = s.group_id
+                         AND p.telegram_id = @TelegramUserId
+                   ) AS CanManage
+            FROM sessions s
+            WHERE s.id = @SessionId
+            """,
+            new { command.SessionId, command.TelegramUserId }, transaction);
 
         if (session == null)
         {
@@ -38,9 +48,9 @@ public sealed class DeleteSessionHandler(
             return;
         }
 
-        if (session.GmId != command.TelegramUserId)
+        if (!session.CanManage)
         {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только Мастер Игры (GM) может удалять сессию.", showAlert: true, cancellationToken: ct);
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только owner или co-GM может удалять сессию.", showAlert: true, cancellationToken: ct);
             return;
         }
 
@@ -74,16 +84,30 @@ public sealed class DeleteSessionHandler(
         // A simple way is to re-render the list:
         await using var readConnection = await dataSource.OpenConnectionAsync(ct);
         var sessions = await readConnection.QueryAsync<SessionListItemDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, 
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false) as PlayerCount,
-                     g.gm_telegram_id as GmId
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, s.max_players as MaxPlayers,
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Active) as PlayerCount,
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Waitlisted) as WaitlistCount,
+                     EXISTS (
+                         SELECT 1
+                         FROM group_managers gm
+                         JOIN players manager_player ON manager_player.id = gm.player_id
+                         WHERE gm.group_id = s.group_id
+                           AND manager_player.telegram_id = @TelegramUserId
+                     ) AS CanManage
               FROM sessions s
               JOIN game_groups g ON s.group_id = g.id
               LEFT JOIN session_participants sp ON s.id = sp.session_id
-              WHERE g.telegram_chat_id = @ChatId AND s.status != 'Cancelled' AND s.scheduled_at > NOW()
-              GROUP BY s.id, s.title, s.scheduled_at, s.status, g.gm_telegram_id
+              WHERE g.telegram_chat_id = @ChatId AND s.status != @Cancelled AND s.scheduled_at > NOW()
+              GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players, s.group_id
               ORDER BY s.scheduled_at ASC",
-            new { ChatId = command.ChatId });
+            new
+            {
+                ChatId = command.ChatId,
+                command.TelegramUserId,
+                Cancelled = SessionStatus.Cancelled,
+                Active = ParticipantRegistrationStatus.Active,
+                Waitlisted = ParticipantRegistrationStatus.Waitlisted
+            });
 
         var sessionsList = sessions.ToList();
 
@@ -93,26 +117,16 @@ public sealed class DeleteSessionHandler(
             return;
         }
 
-        var text = "📅 <b>Ближайшие игры:</b>\n\n";
-        foreach (var s in sessionsList)
-        {
-            text += $"🔹 <b>{s.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(s.Title)} (Участников: {s.PlayerCount})\n";
-        }
-
-        var isGm = command.TelegramUserId == sessionsList.First().GmId;
-        var keyboard = isGm 
-            ? new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
-                sessionsList.Select(s => new[] { Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton.WithCallbackData($"🗑 Удалить {s.ScheduledAt.FormatMoscowShort()}", $"delete_session:{s.Id}") }))
-            : null;
+        var renderResult = SessionListMessageRenderer.Render(sessionsList);
 
         try
         {
             await bot.EditMessageText(
                 command.ChatId,
                 command.MessageId,
-                text,
+                renderResult.Text,
                 parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                replyMarkup: keyboard,
+                replyMarkup: renderResult.Markup,
                 cancellationToken: ct);
         }
         catch (Exception ex)

src/GmRelay.Bot/Features/Sessions/ListSessions/ListSessionsHandler.cs

@@ -3,10 +3,59 @@ using GmRelay.Shared.Domain;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Features.Sessions.ListSessions;
 
-internal sealed record SessionListItemDto(Guid Id, string Title, DateTime ScheduledAt, string Status, int PlayerCount, long GmId);
+internal sealed record SessionListItemDto(Guid Id, string Title, DateTime ScheduledAt, string Status, int? MaxPlayers, int PlayerCount, int WaitlistCount, bool CanManage);
+
+internal static class SessionListMessageRenderer
+{
+    public static (string Text, InlineKeyboardMarkup? Markup) Render(IReadOnlyList<SessionListItemDto> sessions)
+    {
+        var text = "📅 <b>Ближайшие игры:</b>\n\n";
+        foreach (var session in sessions)
+        {
+            var seats = session.MaxPlayers.HasValue
+                ? $"{session.PlayerCount}/{session.MaxPlayers.Value}"
+                : session.PlayerCount.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            var waitlist = session.WaitlistCount > 0 ? $", ожидание: {session.WaitlistCount}" : string.Empty;
+            text += $"🔹 <b>{session.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(session.Title)} (Места: {seats}{waitlist})\n";
+        }
+
+        var canManage = sessions.Count > 0 && sessions.First().CanManage;
+        if (!canManage)
+        {
+            return (text, null);
+        }
+
+        var buttons = new List<InlineKeyboardButton[]>();
+        foreach (var session in sessions)
+        {
+            var dateTitle = session.ScheduledAt.FormatMoscowShort();
+            buttons.Add(
+            [
+                InlineKeyboardButton.WithCallbackData($"❌ {dateTitle}", $"cancel_session:{session.Id}"),
+                InlineKeyboardButton.WithCallbackData($"⏰ {dateTitle}", $"reschedule_session:{session.Id}")
+            ]);
+
+            if (SessionCapacityRules.CanPromoteWaitlistedPlayer(session.MaxPlayers, session.PlayerCount, session.WaitlistCount))
+            {
+                buttons.Add(
+                [
+                    InlineKeyboardButton.WithCallbackData($"⬆️ Из ожидания {dateTitle}", $"promote_waitlist:{session.Id}")
+                ]);
+            }
+
+            buttons.Add(
+            [
+                InlineKeyboardButton.WithCallbackData($"🗑 Удалить {dateTitle}", $"delete_session:{session.Id}")
+            ]);
+        }
+
+        return (text, new InlineKeyboardMarkup(buttons));
+    }
+}
 
 public sealed class ListSessionsHandler(
     NpgsqlDataSource dataSource,
@@ -17,16 +66,30 @@ public sealed class ListSessionsHandler(
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
 
         var sessions = await connection.QueryAsync<SessionListItemDto>(
-            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, 
-                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false) as PlayerCount,
-                     g.gm_telegram_id as GmId
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, s.max_players as MaxPlayers,
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Active) as PlayerCount,
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Waitlisted) as WaitlistCount,
+                     EXISTS (
+                         SELECT 1
+                         FROM group_managers gm
+                         JOIN players manager_player ON manager_player.id = gm.player_id
+                         WHERE gm.group_id = s.group_id
+                           AND manager_player.telegram_id = @TelegramUserId
+                     ) AS CanManage
               FROM sessions s
               JOIN game_groups g ON s.group_id = g.id
               LEFT JOIN session_participants sp ON s.id = sp.session_id
-              WHERE g.telegram_chat_id = @ChatId AND s.status != 'Cancelled' AND s.scheduled_at > NOW()
-              GROUP BY s.id, s.title, s.scheduled_at, s.status, g.gm_telegram_id
+              WHERE g.telegram_chat_id = @ChatId AND s.status != @Cancelled AND s.scheduled_at > NOW()
+              GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players, s.group_id
               ORDER BY s.scheduled_at ASC",
-            new { ChatId = message.Chat.Id });
+            new
+            {
+                ChatId = message.Chat.Id,
+                TelegramUserId = message.From?.Id,
+                Cancelled = SessionStatus.Cancelled,
+                Active = ParticipantRegistrationStatus.Active,
+                Waitlisted = ParticipantRegistrationStatus.Waitlisted
+            });
 
         var sessionsList = sessions.ToList();
 
@@ -39,23 +102,13 @@ public sealed class ListSessionsHandler(
             return;
         }
 
-        var text = "📅 <b>Ближайшие игры:</b>\n\n";
-        foreach (var s in sessionsList)
-        {
-            text += $"🔹 <b>{s.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(s.Title)} (Участников: {s.PlayerCount})\n";
-        }
-
-        var isGm = message.From?.Id == sessionsList.First().GmId;
-        var keyboard = isGm 
-            ? new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
-                sessionsList.Select(s => new[] { Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton.WithCallbackData($"🗑 Удалить {s.ScheduledAt.FormatMoscowShort()}", $"delete_session:{s.Id}") }))
-            : null;
+        var renderResult = SessionListMessageRenderer.Render(sessionsList);
 
         await botClient.SendMessage(
             chatId: message.Chat.Id,
-            text: text,
+            text: renderResult.Text,
             parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-            replyMarkup: keyboard,
+            replyMarkup: renderResult.Markup,
             cancellationToken: cancellationToken);
     }
 }

src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs

@@ -1,10 +1,12 @@
 using Dapper;
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
 using Npgsql;
 using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.ReplyMarkups;
+using GmRelay.Bot.Infrastructure.Telegram;
 
 namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
 
@@ -12,20 +14,26 @@ namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
 
 internal sealed record AwaitingProposalDto(
     Guid Id, Guid SessionId, string Title, DateTime CurrentScheduledAt,
-    Guid BatchId, int? BatchMessageId, long TelegramChatId);
+    Guid BatchId, int? BatchMessageId, long TelegramChatId, string NotificationMode);
 
-internal sealed record VoteParticipantDto(Guid PlayerId, string DisplayName, string? TelegramUsername);
+internal sealed record VoteParticipantDto(
+    Guid PlayerId,
+    string DisplayName,
+    string? TelegramUsername,
+    long TelegramId = 0);
 
 // ── Handler ──────────────────────────────────────────────────────────
 
 /// <summary>
 /// Handles text input from the GM who has an AwaitingTime proposal.
-/// Parses the new time, creates a voting message, and tags all participants.
+/// Parses reschedule options with a voting deadline, creates a voting message,
+/// and tags all participants.
 /// If no participants are registered, reschedules immediately.
 /// </summary>
 public sealed class HandleRescheduleTimeInputHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
+    DirectSessionNotificationSender directSender,
     ILogger<HandleRescheduleTimeInputHandler> logger)
 {
     /// <summary>
@@ -48,13 +56,21 @@ public sealed class HandleRescheduleTimeInputHandler(
             """
             SELECT rp.id AS Id, rp.session_id AS SessionId, s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
                    s.batch_id AS BatchId, s.batch_message_id AS BatchMessageId,
-                   g.telegram_chat_id AS TelegramChatId
+                   g.telegram_chat_id AS TelegramChatId,
+                   s.notification_mode AS NotificationMode
             FROM reschedule_proposals rp
             JOIN sessions s ON s.id = rp.session_id
             JOIN game_groups g ON g.id = s.group_id
             WHERE rp.proposed_by = @GmId
               AND rp.status = 'AwaitingTime'
               AND g.telegram_chat_id = @ChatId
+              AND EXISTS (
+                  SELECT 1
+                  FROM group_managers gm
+                  JOIN players manager_player ON manager_player.id = gm.player_id
+                  WHERE gm.group_id = s.group_id
+                    AND manager_player.telegram_id = @GmId
+              )
             ORDER BY rp.created_at DESC
             LIMIT 1
             """,
@@ -63,68 +79,85 @@ public sealed class HandleRescheduleTimeInputHandler(
         if (proposal is null)
             return false;
 
-        // 2. Parse the new time
-        if (!MoscowTime.TryParseMoscow(text, out var newTime))
+        // 2. Parse voting input
+        if (!RescheduleVotingInput.TryParse(text, DateTimeOffset.UtcNow, out var votingInput, out var parseError))
         {
             await bot.SendMessage(
                 chatId: chatId,
-                text: "⚠️ Не удалось распознать время. Используйте формат: <code>ДД.ММ.ГГГГ ЧЧ:ММ</code>\nНапример: <code>25.04.2026 19:30</code>",
+                text: $"⚠️ {parseError}\n\nИспользуйте формат:\n<code>25.04.2026 19:30\n26.04.2026 18:00\nДедлайн: 25.04.2026 12:00</code>",
                 parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
                 cancellationToken: ct);
             return true;
         }
 
-        if (newTime <= DateTimeOffset.UtcNow)
-        {
-            await bot.SendMessage(
-                chatId: chatId,
-                text: "⚠️ Новое время должно быть в будущем. Попробуйте снова.",
-                cancellationToken: ct);
-            return true;
-        }
-
         // 3. Load participants (non-GM) signed up for this session
         var participants = (await connection.QueryAsync<VoteParticipantDto>(
             """
-            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+            SELECT p.id AS PlayerId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername,
+                   p.telegram_id AS TelegramId
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
             """,
-            new { proposal.SessionId })).ToList();
+            new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active })).ToList();
 
         // 4. If no participants — reschedule immediately
         if (participants.Count == 0)
         {
-            await RescheduleImmediately(connection, proposal, newTime, chatId, ct);
+            await RescheduleImmediately(connection, proposal, votingInput.Options[0], chatId, ct);
             await TryDeleteMessage(chatId, message.MessageId, ct);
             return true;
         }
 
         // 5. Create voting message
         await using var transaction = await connection.BeginTransactionAsync(ct);
+        var options = votingInput.Options
+            .Select((proposedAt, index) => new RescheduleOptionDto(
+                Guid.NewGuid(),
+                index + 1,
+                proposedAt))
+            .ToList();
 
-        // Update proposal with proposed time and Voting status
         await connection.ExecuteAsync(
             """
             UPDATE reschedule_proposals
-            SET proposed_at = @ProposedAt, status = 'Voting', vote_chat_id = @ChatId
+            SET voting_deadline_at = @Deadline, status = 'Voting', vote_chat_id = @ChatId
             WHERE id = @Id
             """,
-            new { ProposedAt = newTime, ChatId = chatId, Id = proposal.Id },
+            new { votingInput.Deadline, ChatId = chatId, Id = proposal.Id },
             transaction);
 
+        foreach (var option in options)
+        {
+            await connection.ExecuteAsync(
+                """
+                INSERT INTO reschedule_options (id, proposal_id, proposed_at, display_order)
+                VALUES (@OptionId, @ProposalId, @ProposedAt, @DisplayOrder)
+                """,
+                new
+                {
+                    option.OptionId,
+                    ProposalId = proposal.Id,
+                    option.ProposedAt,
+                    option.DisplayOrder
+                },
+                transaction);
+        }
+
         await transaction.CommitAsync(ct);
 
-        // Build voting message text
-        var voteText = BuildVotingMessage(proposal.Title, proposal.CurrentScheduledAt, newTime, participants, []);
-        
-        var keyboard = new InlineKeyboardMarkup([
-            [
-                InlineKeyboardButton.WithCallbackData("✅ Согласен", $"reschedule_vote:yes:{proposal.Id}"),
-                InlineKeyboardButton.WithCallbackData("❌ Против", $"reschedule_vote:no:{proposal.Id}")
-            ]
-        ]);
+        var voteText = BuildVotingMessage(
+            proposal.Title,
+            proposal.CurrentScheduledAt,
+            votingInput.Deadline,
+            options,
+            participants,
+            []);
+        var keyboard = BuildVotingKeyboard(options);
 
         var voteMsg = await bot.SendMessage(
             chatId: chatId,
@@ -133,12 +166,46 @@ public sealed class HandleRescheduleTimeInputHandler(
             replyMarkup: keyboard,
             cancellationToken: ct);
 
+        var mode = SessionNotificationModeExtensions.FromDatabaseValue(proposal.NotificationMode);
+        if (mode.ShouldSendDirectMessages())
+        {
+            var optionsText = string.Join(
+                "\n",
+                options.Select(option => $"{option.DisplayOrder}. <b>{option.ProposedAt.FormatMoscow()}</b> (МСК)"));
+            var directText = $"""
+                🔄 <b>Голосование за перенос сессии</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(proposal.Title)}</b>
+                📅 Текущее время: <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)
+                🗳 Варианты:
+                {optionsText}
+
+                ⏳ Дедлайн: <b>{votingInput.Deadline.FormatMoscow()}</b> (МСК)
+
+                Проголосуйте кнопкой в групповом сообщении.
+                """;
+
+            await directSender.SendAsync(
+                participants.Select(p => new DirectNotificationRecipient(
+                    p.TelegramId,
+                    p.DisplayName)),
+                directText,
+                "reschedule-vote",
+                proposal.SessionId,
+                ct);
+        }
+
         // Store vote message ID
         await connection.ExecuteAsync(
             "UPDATE reschedule_proposals SET vote_message_id = @MsgId WHERE id = @Id",
             new { MsgId = voteMsg.MessageId, Id = proposal.Id });
 
-        logger.LogInformation("Reschedule voting started for session {SessionId}, proposal {ProposalId}", proposal.SessionId, proposal.Id);
+        logger.LogInformation(
+            "Reschedule voting started for session {SessionId}, proposal {ProposalId}, options {OptionCount}, deadline {Deadline}",
+            proposal.SessionId,
+            proposal.Id,
+            options.Count,
+            votingInput.Deadline);
 
         // Delete GM's time input message
         await TryDeleteMessage(chatId, message.MessageId, ct);
@@ -154,10 +221,14 @@ public sealed class HandleRescheduleTimeInputHandler(
 
         await connection.ExecuteAsync(
             """
-            UPDATE sessions SET scheduled_at = @NewTime, status = 'Planned', updated_at = now()
+            UPDATE sessions
+            SET scheduled_at = @NewTime,
+                status = @Status,
+                one_hour_reminder_processed_at = NULL,
+                updated_at = now()
             WHERE id = @SessionId
             """,
-            new { NewTime = newTime, proposal.SessionId },
+            new { NewTime = newTime, proposal.SessionId, Status = SessionStatus.Planned },
             transaction);
 
         await connection.ExecuteAsync(
@@ -180,33 +251,105 @@ public sealed class HandleRescheduleTimeInputHandler(
     }
 
     internal static string BuildVotingMessage(
-        string title, DateTime currentTime, DateTimeOffset newTime,
+        string title,
+        DateTime currentTime,
+        DateTimeOffset deadline,
+        IReadOnlyList<RescheduleOptionDto> options,
         IReadOnlyList<VoteParticipantDto> participants,
-        IReadOnlyCollection<Guid> approvedPlayerIds)
+        IReadOnlyList<RescheduleOptionVoteDto> votes)
     {
+        var votesByOption = votes
+            .GroupBy(v => v.OptionId)
+            .ToDictionary(g => g.Key, g => g.ToList());
+        var votedPlayerIds = votes.Select(v => v.PlayerId).ToHashSet();
+        var pendingParticipants = participants
+            .Where(p => !votedPlayerIds.Contains(p.PlayerId))
+            .Select(FormatParticipantName)
+            .ToList();
+
         var lines = new List<string>
         {
             $"🔄 <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(title)}»</b>",
             "",
             $"📅 Текущее время: <b>{currentTime.FormatMoscow()}</b> (МСК)",
-            $"📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)",
+            $"⏳ Дедлайн: <b>{deadline.FormatMoscow()}</b> (МСК)",
             "",
-            "Для переноса нужно согласие всех участников:"
+            "Выберите один из вариантов:"
         };
 
-        foreach (var p in participants)
+        foreach (var option in options.OrderBy(x => x.DisplayOrder))
         {
-            var name = p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
-            var icon = approvedPlayerIds.Contains(p.PlayerId) ? "✅" : "⏳";
-            lines.Add($"   {icon} {name}");
+            var optionVotes = votesByOption.GetValueOrDefault(option.OptionId, []);
+            lines.Add(
+                $"{option.DisplayOrder}. <b>{option.ProposedAt.FormatMoscow()}</b> (МСК) — {FormatVoteCount(optionVotes.Count)}");
+
+            if (optionVotes.Count > 0)
+            {
+                lines.Add($"   {string.Join(", ", optionVotes.Select(FormatParticipantName))}");
+            }
+        }
+
+        if (pendingParticipants.Count > 0)
+        {
+            lines.Add("");
+            lines.Add($"Не проголосовали: {string.Join(", ", pendingParticipants)}");
         }
 
         lines.Add("");
-        lines.Add($"Голоса: {approvedPlayerIds.Count}/{participants.Count} ✅");
+        lines.Add($"Голосов: {votedPlayerIds.Count}/{participants.Count}");
+        lines.Add("Правило: побеждает вариант с большинством голосов к дедлайну; при ничьей перенос не применяется.");
 
         return string.Join("\n", lines);
     }
 
+    internal static InlineKeyboardMarkup BuildVotingKeyboard(IReadOnlyList<RescheduleOptionDto> options)
+    {
+        return new InlineKeyboardMarkup(
+            options
+                .OrderBy(option => option.DisplayOrder)
+                .Select(option => new[]
+                {
+                    InlineKeyboardButton.WithCallbackData(
+                        $"{option.DisplayOrder}. {FormatButtonTime(option.ProposedAt)}",
+                        $"reschedule_vote:{option.OptionId}")
+                }));
+    }
+
+    internal static string FormatParticipantName(VoteParticipantDto participant)
+    {
+        return participant.TelegramUsername is { Length: > 0 } username
+            ? $"@{System.Net.WebUtility.HtmlEncode(username)}"
+            : System.Net.WebUtility.HtmlEncode(participant.DisplayName);
+    }
+
+    internal static string FormatParticipantName(RescheduleOptionVoteDto vote)
+    {
+        return vote.TelegramUsername is { Length: > 0 } username
+            ? $"@{System.Net.WebUtility.HtmlEncode(username)}"
+            : System.Net.WebUtility.HtmlEncode(vote.DisplayName);
+    }
+
+    private static string FormatVoteCount(int count)
+    {
+        var modulo100 = count % 100;
+        var modulo10 = count % 10;
+        var word = modulo100 is >= 11 and <= 14
+            ? "голосов"
+            : modulo10 switch
+            {
+                1 => "голос",
+                >= 2 and <= 4 => "голоса",
+                _ => "голосов"
+            };
+
+        return $"{count} {word}";
+    }
+
+    private static string FormatButtonTime(DateTimeOffset utc)
+        => utc.ToOffset(TimeSpan.FromHours(3)).ToString(
+            "dd.MM HH:mm",
+            System.Globalization.CultureInfo.InvariantCulture);
+
     private async Task TryUpdateBatchMessage(AwaitingProposalDto proposal, CancellationToken ct)
     {
         try
@@ -214,32 +357,35 @@ public sealed class HandleRescheduleTimeInputHandler(
             await using var conn = await dataSource.OpenConnectionAsync(ct);
 
             var batchSessions = (await conn.QueryAsync<SessionBatchDto>(
-                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status, max_players AS MaxPlayers FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
                 new { proposal.BatchId })).ToList();
 
             var batchParticipants = (await conn.QueryAsync<ParticipantBatchDto>(
                 """
-                SELECT sp.session_id AS SessionId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+                SELECT sp.session_id AS SessionId,
+                       p.display_name AS DisplayName,
+                       p.telegram_username AS TelegramUsername,
+                       sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON sp.player_id = p.id
                 JOIN sessions s ON sp.session_id = s.id
                 WHERE s.batch_id = @BatchId AND sp.is_gm = false
-                ORDER BY sp.responded_at ASC, p.created_at ASC
+                ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
                 """,
                 new { proposal.BatchId })).ToList();
 
             if (proposal.BatchMessageId.HasValue)
             {
-                var renderResult = SessionBatchRenderer.Render(
-                    proposal.Title, batchSessions, batchParticipants);
+                var view = SessionBatchViewBuilder.Build(proposal.Title, batchSessions, batchParticipants);
+                var renderResult = TelegramSessionBatchRenderer.Render(view);
 
-                await bot.EditMessageText(
+                await BatchMessageEditor.EditBatchMessageAsync(
+                    bot,
                     chatId: proposal.TelegramChatId,
                     messageId: proposal.BatchMessageId.Value,
                     text: renderResult.Text,
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
                     replyMarkup: renderResult.Markup,
-                    cancellationToken: ct);
+                    ct);
             }
             else
             {

src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleVoteHandler.cs

@@ -1,48 +1,24 @@
 using Dapper;
 using GmRelay.Shared.Domain;
-using GmRelay.Shared.Rendering;
-using GmRelay.Bot.Features.Sessions.CreateSession;
 using Npgsql;
 using Telegram.Bot;
-using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
 
-// ── Command ──────────────────────────────────────────────────────────
-
 public sealed record HandleRescheduleVoteCommand(
-    Guid ProposalId,
-    string Vote,           // "yes" or "no"
+    Guid OptionId,
     long TelegramUserId,
     string CallbackQueryId,
     long ChatId,
     int MessageId);
 
-// ── DTOs ─────────────────────────────────────────────────────────────
-
 internal sealed record VoteProposalDto(
     Guid Id,
     Guid SessionId,
-    DateTime ProposedAt,
+    DateTimeOffset VotingDeadlineAt,
     string Title,
-    DateTime CurrentScheduledAt,
-    Guid BatchId,
-    string SessionStatus,
-    long TelegramChatId,
-    int? ConfirmationMessageId,
-    int? BatchMessageId);
+    DateTime CurrentScheduledAt);
 
-internal sealed record VoteCountDto(int Total, int Approved);
-
-// ── Handler ──────────────────────────────────────────────────────────
-
-/// <summary>
-/// Handles "✅ Согласен" / "❌ Против" votes on a reschedule proposal.
-/// 
-/// If anyone votes no → proposal rejected, old time stays.
-/// If all vote yes → session time updated, batch message re-rendered,
-/// session status reset to Planned so confirmation triggers work correctly.
-/// </summary>
 public sealed class HandleRescheduleVoteHandler(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
@@ -53,31 +29,40 @@ public sealed class HandleRescheduleVoteHandler(
         await using var connection = await dataSource.OpenConnectionAsync(ct);
         await using var transaction = await connection.BeginTransactionAsync(ct);
 
-        // 1. Load proposal + session info
         var proposal = await connection.QuerySingleOrDefaultAsync<VoteProposalDto>(
             """
-            SELECT rp.id AS Id, rp.session_id AS SessionId, rp.proposed_at AS ProposedAt,
-                   s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
-                   s.batch_id AS BatchId, s.status AS SessionStatus,
-                   s.confirmation_message_id AS ConfirmationMessageId,
-                   s.batch_message_id AS BatchMessageId,
-                   g.telegram_chat_id AS TelegramChatId
-            FROM reschedule_proposals rp
+            SELECT rp.id AS Id,
+                   rp.session_id AS SessionId,
+                   rp.voting_deadline_at AS VotingDeadlineAt,
+                   s.title AS Title,
+                   s.scheduled_at AS CurrentScheduledAt
+            FROM reschedule_options ro
+            JOIN reschedule_proposals rp ON rp.id = ro.proposal_id
             JOIN sessions s ON s.id = rp.session_id
-            JOIN game_groups g ON g.id = s.group_id
-            WHERE rp.id = @ProposalId AND rp.status = 'Voting'
+            WHERE ro.id = @OptionId AND rp.status = 'Voting'
             """,
-            new { command.ProposalId },
+            new { command.OptionId },
             transaction);
 
         if (proposal is null)
         {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId,
-                "Голосование уже завершено или не найдено.", cancellationToken: ct);
+            await bot.AnswerCallbackQuery(
+                command.CallbackQueryId,
+                "Голосование уже завершено или не найдено.",
+                cancellationToken: ct);
+            return;
+        }
+
+        if (proposal.VotingDeadlineAt <= DateTimeOffset.UtcNow)
+        {
+            await bot.AnswerCallbackQuery(
+                command.CallbackQueryId,
+                "Дедлайн уже прошёл. Результаты скоро будут применены.",
+                showAlert: true,
+                cancellationToken: ct);
             return;
         }
 
-        // 2. Verify voter is a participant of this session
         var playerId = await connection.ExecuteScalarAsync<Guid?>(
             """
             SELECT p.id
@@ -86,229 +71,107 @@ public sealed class HandleRescheduleVoteHandler(
             WHERE sp.session_id = @SessionId
               AND p.telegram_id = @TelegramUserId
               AND sp.is_gm = false
+              AND sp.registration_status = @Active
             """,
-            new { proposal.SessionId, command.TelegramUserId },
+            new { proposal.SessionId, command.TelegramUserId, Active = ParticipantRegistrationStatus.Active },
             transaction);
 
         if (playerId is null)
         {
-            await bot.AnswerCallbackQuery(command.CallbackQueryId,
-                "Вы не являетесь участником этой сессии.", cancellationToken: ct);
+            await bot.AnswerCallbackQuery(
+                command.CallbackQueryId,
+                "Вы не являетесь участником этой сессии.",
+                cancellationToken: ct);
             return;
         }
 
-        // 3. Record vote (upsert)
-        var inserted = await connection.ExecuteAsync(
+        await connection.ExecuteAsync(
             """
-            INSERT INTO reschedule_votes (proposal_id, player_id, vote)
-            VALUES (@ProposalId, @PlayerId, @Vote)
-            ON CONFLICT (proposal_id, player_id) DO UPDATE SET vote = EXCLUDED.vote, voted_at = now()
+            INSERT INTO reschedule_option_votes (proposal_id, player_id, option_id)
+            VALUES (@ProposalId, @PlayerId, @OptionId)
+            ON CONFLICT (proposal_id, player_id) DO UPDATE
+            SET option_id = EXCLUDED.option_id,
+                voted_at = now()
             """,
-            new { command.ProposalId, PlayerId = playerId.Value, command.Vote },
+            new
+            {
+                ProposalId = proposal.Id,
+                PlayerId = playerId.Value,
+                command.OptionId
+            },
             transaction);
 
-        // 4. Handle "no" vote — immediately reject
-        if (command.Vote == "no")
-        {
-            await connection.ExecuteAsync(
-                "UPDATE reschedule_proposals SET status = 'Rejected' WHERE id = @Id",
-                new { Id = command.ProposalId },
-                transaction);
-
-            await transaction.CommitAsync(ct);
-
-            // Get voter's name
-            var voterName = await connection.QuerySingleOrDefaultAsync<string>(
-                "SELECT display_name FROM players WHERE telegram_id = @TgId",
-                new { TgId = command.TelegramUserId });
-
-            // Update voting message — show rejection
-            try
-            {
-                await bot.EditMessageText(
-                    chatId: command.ChatId,
-                    messageId: command.MessageId,
-                    text: $"❌ <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(proposal.Title)}» отклонён!</b>\n\n{voterName ?? "Участник"} проголосовал(а) против. Время сессии остаётся прежним:\n📅 <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)",
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    cancellationToken: ct);
-            }
-            catch (Exception ex)
-            {
-                logger.LogWarning(ex, "Failed to update vote message after rejection");
-            }
-
-            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы проголосовали против переноса.", cancellationToken: ct);
-            logger.LogInformation("Reschedule proposal {ProposalId} rejected by player {PlayerId}", command.ProposalId, playerId);
-            return;
-        }
-
-        // 5. Handle "yes" vote — check if all approved
         var participants = (await connection.QueryAsync<VoteParticipantDto>(
             """
-            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+            SELECT p.id AS PlayerId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername,
+                   p.telegram_id AS TelegramId
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
-            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
+            ORDER BY p.display_name
             """,
-            new { proposal.SessionId },
+            new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active },
             transaction)).ToList();
 
-        var approvedPlayerIds = (await connection.QueryAsync<Guid>(
+        var options = (await connection.QueryAsync<RescheduleOptionDto>(
             """
-            SELECT player_id FROM reschedule_votes
-            WHERE proposal_id = @ProposalId AND vote = 'yes'
+            SELECT id AS OptionId,
+                   display_order AS DisplayOrder,
+                   proposed_at AS ProposedAt
+            FROM reschedule_options
+            WHERE proposal_id = @ProposalId
+            ORDER BY display_order
             """,
-            new { command.ProposalId },
-            transaction)).ToHashSet();
+            new { ProposalId = proposal.Id },
+            transaction)).ToList();
 
-        var allApproved = approvedPlayerIds.Count == participants.Count;
+        var votes = (await connection.QueryAsync<RescheduleOptionVoteDto>(
+            """
+            SELECT rov.option_id AS OptionId,
+                   p.id AS PlayerId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername
+            FROM reschedule_option_votes rov
+            JOIN players p ON p.id = rov.player_id
+            WHERE rov.proposal_id = @ProposalId
+            ORDER BY rov.voted_at, p.display_name
+            """,
+            new { ProposalId = proposal.Id },
+            transaction)).ToList();
 
-        if (allApproved)
-        {
-            // 6. All approved — reschedule!
-            var newTime = new DateTimeOffset(proposal.ProposedAt, TimeSpan.Zero); // ProposedAt is stored in UTC
+        await transaction.CommitAsync(ct);
 
-            // Update session time and reset status to Planned for fresh notification cycle
-            await connection.ExecuteAsync(
-                """
-                UPDATE sessions
-                SET scheduled_at = @NewTime,
-                    status = 'Planned',
-                    confirmation_message_id = NULL,
-                    link_message_id = NULL,
-                    updated_at = now()
-                WHERE id = @SessionId
-                """,
-                new { NewTime = newTime, proposal.SessionId },
-                transaction);
+        var voteText = HandleRescheduleTimeInputHandler.BuildVotingMessage(
+            proposal.Title,
+            proposal.CurrentScheduledAt,
+            proposal.VotingDeadlineAt,
+            options,
+            participants,
+            votes);
+        var keyboard = HandleRescheduleTimeInputHandler.BuildVotingKeyboard(options);
 
-            await connection.ExecuteAsync(
-                "UPDATE reschedule_proposals SET status = 'Approved' WHERE id = @Id",
-                new { Id = command.ProposalId },
-                transaction);
-
-            // Reset all participant RSVP to Pending for the new confirmation cycle
-            await connection.ExecuteAsync(
-                """
-                UPDATE session_participants
-                SET rsvp_status = 'Pending', responded_at = NULL
-                WHERE session_id = @SessionId AND is_gm = false
-                """,
-                new { proposal.SessionId },
-                transaction);
-
-            await transaction.CommitAsync(ct);
-
-            // Update voting message — show approval
-            try
-            {
-                await bot.EditMessageText(
-                    chatId: command.ChatId,
-                    messageId: command.MessageId,
-                    text: $"✅ <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(proposal.Title)}» одобрен!</b>\n\nВсе участники согласились.\n📅 Новое время: <b>{proposal.ProposedAt.FormatMoscow()}</b> (МСК)\n\n<i>Уведомления будут приходить согласно новому расписанию.</i>",
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    cancellationToken: ct);
-            }
-            catch (Exception ex)
-            {
-                logger.LogWarning(ex, "Failed to update vote message after approval");
-            }
-
-            // Re-render batch message
-            await TryUpdateBatchMessage(proposal, ct);
-
-            logger.LogInformation("Session {SessionId} rescheduled to {NewTime} (proposal {ProposalId})",
-                proposal.SessionId, newTime, command.ProposalId);
-        }
-        else
-        {
-            // Not all voted yet — update the voting message to show progress
-            await transaction.CommitAsync(ct);
-
-            var voteText = HandleRescheduleTimeInputHandler.BuildVotingMessage(
-                proposal.Title, proposal.CurrentScheduledAt,
-                new DateTimeOffset(proposal.ProposedAt, TimeSpan.Zero),
-                participants, approvedPlayerIds);
-
-            var keyboard = new InlineKeyboardMarkup([
-                [
-                    InlineKeyboardButton.WithCallbackData("✅ Согласен", $"reschedule_vote:yes:{command.ProposalId}"),
-                    InlineKeyboardButton.WithCallbackData("❌ Против", $"reschedule_vote:no:{command.ProposalId}")
-                ]
-            ]);
-
-            try
-            {
-                await bot.EditMessageText(
-                    chatId: command.ChatId,
-                    messageId: command.MessageId,
-                    text: voteText,
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    replyMarkup: keyboard,
-                    cancellationToken: ct);
-            }
-            catch (Exception ex)
-            {
-                logger.LogWarning(ex, "Failed to update vote message with progress");
-            }
-        }
-
-        await bot.AnswerCallbackQuery(command.CallbackQueryId,
-            allApproved ? "Вы подтвердили перенос! Все согласны — время обновлено." : "Вы подтвердили перенос!",
-            cancellationToken: ct);
-    }
-
-    /// <summary>
-    /// Re-renders the batch schedule message to reflect the updated session time.
-    /// If batch_message_id is stored, edits the original message. Otherwise sends a notification.
-    /// </summary>
-    private async Task TryUpdateBatchMessage(VoteProposalDto proposal, CancellationToken ct)
-    {
         try
         {
-            await using var connection = await dataSource.OpenConnectionAsync(ct);
-
-            var batchSessions = (await connection.QueryAsync<SessionBatchDto>(
-                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
-                new { proposal.BatchId })).ToList();
-
-            var batchParticipants = (await connection.QueryAsync<ParticipantBatchDto>(
-                """
-                SELECT sp.session_id AS SessionId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
-                FROM session_participants sp
-                JOIN players p ON sp.player_id = p.id
-                JOIN sessions s ON sp.session_id = s.id
-                WHERE s.batch_id = @BatchId AND sp.is_gm = false
-                ORDER BY sp.responded_at ASC, p.created_at ASC
-                """,
-                new { proposal.BatchId })).ToList();
-
-            if (proposal.BatchMessageId.HasValue)
-            {
-                // Edit the original batch schedule message in-place
-                var renderResult = SessionBatchRenderer.Render(proposal.Title, batchSessions, batchParticipants);
-
-                await bot.EditMessageText(
-                    chatId: proposal.TelegramChatId,
-                    messageId: proposal.BatchMessageId.Value,
-                    text: renderResult.Text,
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    replyMarkup: renderResult.Markup,
-                    cancellationToken: ct);
-            }
-            else
-            {
-                // Fallback for sessions created before V005 migration (no batch_message_id)
-                await bot.SendMessage(
-                    chatId: proposal.TelegramChatId,
-                    text: $"📢 Расписание обновлено! Сессия «{proposal.Title}» перенесена на <b>{proposal.ProposedAt.FormatMoscow()}</b> (МСК).",
-                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
-                    cancellationToken: ct);
-            }
+            await bot.EditMessageText(
+                chatId: command.ChatId,
+                messageId: command.MessageId,
+                text: voteText,
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                replyMarkup: keyboard,
+                cancellationToken: ct);
         }
         catch (Exception ex)
         {
-            logger.LogWarning(ex, "Failed to update batch message for proposal {ProposalId}", proposal.Id);
+            logger.LogWarning(ex, "Failed to update reschedule vote message for proposal {ProposalId}", proposal.Id);
         }
+
+        await bot.AnswerCallbackQuery(
+            command.CallbackQueryId,
+            "Ваш голос учтён. До дедлайна его можно изменить.",
+            cancellationToken: ct);
     }
 }

src/GmRelay.Bot/Features/Sessions/RescheduleSession/InitiateRescheduleHandler.cs

@@ -1,4 +1,5 @@
 using Dapper;
+using GmRelay.Shared.Domain;
 using Npgsql;
 using Telegram.Bot;
 
@@ -15,14 +16,14 @@ public sealed record InitiateRescheduleCommand(
 
 // ── DTOs ─────────────────────────────────────────────────────────────
 
-internal sealed record RescheduleSessionInfoDto(string Title, long GmId);
+internal sealed record RescheduleSessionInfoDto(string Title, bool CanManage);
 
 // ── Handler ──────────────────────────────────────────────────────────
 
 /// <summary>
 /// Handles the "⏰ Перенести" button press from the batch message.
 /// Creates a reschedule proposal in AwaitingTime status and prompts
-/// the GM to enter the new time via a regular text message.
+/// the GM to enter 2-3 new time options and a voting deadline.
 /// </summary>
 public sealed class InitiateRescheduleHandler(
     NpgsqlDataSource dataSource,
@@ -33,15 +34,21 @@ public sealed class InitiateRescheduleHandler(
     {
         await using var connection = await dataSource.OpenConnectionAsync(ct);
 
-        // 1. Verify GM ownership
+        // 1. Verify group management access.
         var session = await connection.QuerySingleOrDefaultAsync<RescheduleSessionInfoDto>(
             """
-            SELECT s.title AS Title, g.gm_telegram_id AS GmId
+            SELECT s.title AS Title,
+                   EXISTS (
+                       SELECT 1
+                       FROM group_managers gm
+                       JOIN players p ON p.id = gm.player_id
+                       WHERE gm.group_id = s.group_id
+                         AND p.telegram_id = @TelegramUserId
+                   ) AS CanManage
             FROM sessions s
-            JOIN game_groups g ON s.group_id = g.id
-            WHERE s.id = @SessionId AND s.status != 'Cancelled'
+            WHERE s.id = @SessionId AND s.status != @Cancelled
             """,
-            new { command.SessionId });
+            new { command.SessionId, command.TelegramUserId, Cancelled = SessionStatus.Cancelled });
 
         if (session is null)
         {
@@ -49,10 +56,10 @@ public sealed class InitiateRescheduleHandler(
             return;
         }
 
-        if (session.GmId != command.TelegramUserId)
+        if (!session.CanManage)
         {
             await bot.AnswerCallbackQuery(command.CallbackQueryId,
-                "Только Мастер Игры (GM) может переносить сессию.", showAlert: true, cancellationToken: ct);
+                "Только owner или co-GM может переносить сессию.", showAlert: true, cancellationToken: ct);
             return;
         }
 
@@ -85,11 +92,20 @@ public sealed class InitiateRescheduleHandler(
 
         // 4. Prompt GM in chat
         await bot.AnswerCallbackQuery(command.CallbackQueryId,
-            "Введите новое время в чат (формат: ДД.ММ.ГГГГ ЧЧ:ММ)", cancellationToken: ct);
+            "Введите 2-3 варианта времени и дедлайн голосования.", cancellationToken: ct);
 
         await bot.SendMessage(
             chatId: command.ChatId,
-            text: $"⏰ Укажите новое время для сессии «{session.Title}» в формате:\n<code>ДД.ММ.ГГГГ ЧЧ:ММ</code>\n\nНапример: <code>25.04.2026 19:30</code>",
+            text: $"""
+                ⏰ Укажите 2-3 варианта времени для сессии «{session.Title}» и дедлайн голосования.
+
+                Формат:
+                <code>25.04.2026 19:30
+                26.04.2026 18:00
+                Дедлайн: 25.04.2026 12:00</code>
+
+                Дедлайн должен быть в будущем и раньше первого предложенного времени.
+                """,
             parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
             cancellationToken: ct);
     }

src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVoteRules.cs

@@ -0,0 +1,69 @@
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+internal enum RescheduleVoteOutcome
+{
+    Pending,
+    Rejected,
+    Approved
+}
+
+internal sealed record RescheduleVoteDecision(
+    RescheduleVoteOutcome Outcome,
+    string Reason,
+    Guid? SelectedOptionId = null,
+    string CallbackText = "",
+    bool ShouldRescheduleSession = false,
+    bool ShouldResetParticipantRsvps = false);
+
+internal static class RescheduleVoteRules
+{
+    public static RescheduleVoteDecision SelectWinner(IReadOnlyList<RescheduleOptionVoteCount> voteCounts)
+    {
+        var maxVotes = voteCounts.Count == 0 ? 0 : voteCounts.Max(x => x.VoteCount);
+        if (maxVotes == 0)
+        {
+            return new RescheduleVoteDecision(
+                RescheduleVoteOutcome.Rejected,
+                "Никто не проголосовал до дедлайна, перенос не применяется.");
+        }
+
+        var winners = voteCounts.Where(x => x.VoteCount == maxVotes).ToList();
+        if (winners.Count > 1)
+        {
+            return new RescheduleVoteDecision(
+                RescheduleVoteOutcome.Rejected,
+                "Голоса разделились поровну, перенос не применяется.");
+        }
+
+        return new RescheduleVoteDecision(
+            RescheduleVoteOutcome.Approved,
+            "Победил вариант с большинством голосов.",
+            winners[0].OptionId,
+            ShouldRescheduleSession: true,
+            ShouldResetParticipantRsvps: true);
+    }
+
+    public static RescheduleVoteDecision Evaluate(string vote, int totalParticipants, int approvedParticipants)
+    {
+        if (string.Equals(vote, "no", StringComparison.OrdinalIgnoreCase))
+        {
+            return new RescheduleVoteDecision(
+                Outcome: RescheduleVoteOutcome.Rejected,
+                Reason: "\u041e\u0434\u0438\u043d \u0438\u0437 \u0443\u0447\u0430\u0441\u0442\u043d\u0438\u043a\u043e\u0432 \u043e\u0442\u043a\u043b\u043e\u043d\u0438\u043b \u043f\u0435\u0440\u0435\u043d\u043e\u0441.",
+                CallbackText: "\u0412\u044b \u043f\u0440\u043e\u0433\u043e\u043b\u043e\u0441\u043e\u0432\u0430\u043b\u0438 \u043f\u0440\u043e\u0442\u0438\u0432 \u043f\u0435\u0440\u0435\u043d\u043e\u0441\u0430.");
+        }
+
+        var everyoneApproved = approvedParticipants == totalParticipants;
+
+        return new RescheduleVoteDecision(
+            Outcome: everyoneApproved ? RescheduleVoteOutcome.Approved : RescheduleVoteOutcome.Pending,
+            Reason: everyoneApproved
+                ? "\u0412\u0441\u0435 \u0443\u0447\u0430\u0441\u0442\u043d\u0438\u043a\u0438 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u044b."
+                : "\u0413\u043e\u043b\u043e\u0441\u043e\u0432\u0430\u043d\u0438\u0435 \u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0430\u0435\u0442\u0441\u044f.",
+            CallbackText: everyoneApproved
+                ? "\u0412\u044b \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u043b\u0438 \u043f\u0435\u0440\u0435\u043d\u043e\u0441! \u0412\u0441\u0435 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u044b \u2014 \u0432\u0440\u0435\u043c\u044f \u043e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u043e."
+                : "\u0412\u044b \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u043b\u0438 \u043f\u0435\u0440\u0435\u043d\u043e\u0441!",
+            ShouldRescheduleSession: everyoneApproved,
+            ShouldResetParticipantRsvps: everyoneApproved);
+    }
+}

src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingDeadlineService.cs

@@ -0,0 +1,363 @@
+using Dapper;
+using GmRelay.Bot.Features.Notifications;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types.Enums;
+using GmRelay.Bot.Infrastructure.Telegram;
+
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+internal sealed record DueRescheduleProposalDto(
+    Guid Id,
+    Guid SessionId,
+    DateTimeOffset VotingDeadlineAt,
+    string Title,
+    DateTime CurrentScheduledAt,
+    Guid BatchId,
+    int? BatchMessageId,
+    int? VoteMessageId,
+    long TelegramChatId,
+    string NotificationMode);
+
+public sealed class RescheduleVotingDeadlineService(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    DirectSessionNotificationSender directSender,
+    ILogger<RescheduleVotingDeadlineService> logger) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        try
+        {
+            await ProcessDueProposals(stoppingToken);
+
+            using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
+            while (await timer.WaitForNextTickAsync(stoppingToken))
+            {
+                await ProcessDueProposals(stoppingToken);
+            }
+        }
+        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+        {
+        }
+    }
+
+    private async Task ProcessDueProposals(CancellationToken ct)
+    {
+        try
+        {
+            await using var connection = await dataSource.OpenConnectionAsync(ct);
+            var proposalIds = (await connection.QueryAsync<Guid>(
+                """
+                SELECT id
+                FROM reschedule_proposals
+                WHERE status = 'Voting'
+                  AND voting_deadline_at IS NOT NULL
+                  AND voting_deadline_at <= now()
+                ORDER BY voting_deadline_at
+                LIMIT 25
+                """)).ToList();
+
+            foreach (var proposalId in proposalIds)
+            {
+                await FinalizeProposal(proposalId, ct);
+            }
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to process due reschedule voting proposals");
+        }
+    }
+
+    private async Task FinalizeProposal(Guid proposalId, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        var proposal = await connection.QuerySingleOrDefaultAsync<DueRescheduleProposalDto>(
+            """
+            SELECT rp.id AS Id,
+                   rp.session_id AS SessionId,
+                   rp.voting_deadline_at AS VotingDeadlineAt,
+                   rp.vote_message_id AS VoteMessageId,
+                   s.title AS Title,
+                   s.scheduled_at AS CurrentScheduledAt,
+                   s.batch_id AS BatchId,
+                   s.batch_message_id AS BatchMessageId,
+                   s.notification_mode AS NotificationMode,
+                   g.telegram_chat_id AS TelegramChatId
+            FROM reschedule_proposals rp
+            JOIN sessions s ON s.id = rp.session_id
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE rp.id = @ProposalId
+              AND rp.status = 'Voting'
+              AND rp.voting_deadline_at IS NOT NULL
+              AND rp.voting_deadline_at <= now()
+            FOR UPDATE
+            """,
+            new { ProposalId = proposalId },
+            transaction);
+
+        if (proposal is null)
+            return;
+
+        var participants = (await connection.QueryAsync<VoteParticipantDto>(
+            """
+            SELECT p.id AS PlayerId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername,
+                   p.telegram_id AS TelegramId
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId
+              AND sp.is_gm = false
+              AND sp.registration_status = @Active
+            ORDER BY p.display_name
+            """,
+            new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active },
+            transaction)).ToList();
+
+        var options = (await connection.QueryAsync<RescheduleOptionDto>(
+            """
+            SELECT id AS OptionId,
+                   display_order AS DisplayOrder,
+                   proposed_at AS ProposedAt
+            FROM reschedule_options
+            WHERE proposal_id = @ProposalId
+            ORDER BY display_order
+            """,
+            new { ProposalId = proposal.Id },
+            transaction)).ToList();
+
+        var votes = (await connection.QueryAsync<RescheduleOptionVoteDto>(
+            """
+            SELECT rov.option_id AS OptionId,
+                   p.id AS PlayerId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername
+            FROM reschedule_option_votes rov
+            JOIN players p ON p.id = rov.player_id
+            WHERE rov.proposal_id = @ProposalId
+            ORDER BY rov.voted_at, p.display_name
+            """,
+            new { ProposalId = proposal.Id },
+            transaction)).ToList();
+
+        var voteCounts = options
+            .Select(option => new RescheduleOptionVoteCount(
+                option.OptionId,
+                votes.Count(vote => vote.OptionId == option.OptionId)))
+            .ToList();
+        var decision = RescheduleVoteRules.SelectWinner(voteCounts);
+        var selectedOption = decision.SelectedOptionId is { } selectedOptionId
+            ? options.Single(x => x.OptionId == selectedOptionId)
+            : null;
+
+        if (selectedOption is not null)
+        {
+            await connection.ExecuteAsync(
+                """
+                UPDATE sessions
+                SET scheduled_at = @NewTime,
+                    status = @Status,
+                    confirmation_message_id = NULL,
+                    link_message_id = NULL,
+                    one_hour_reminder_processed_at = NULL,
+                    updated_at = now()
+                WHERE id = @SessionId
+                """,
+                new { NewTime = selectedOption.ProposedAt, proposal.SessionId, Status = SessionStatus.Planned },
+                transaction);
+
+            await connection.ExecuteAsync(
+                """
+                UPDATE session_participants
+                SET rsvp_status = 'Pending',
+                    responded_at = NULL
+                WHERE session_id = @SessionId
+                  AND is_gm = false
+                  AND registration_status = @Active
+                """,
+                new { proposal.SessionId, Active = ParticipantRegistrationStatus.Active },
+                transaction);
+
+            await connection.ExecuteAsync(
+                """
+                UPDATE reschedule_proposals
+                SET status = 'Approved',
+                    selected_option_id = @SelectedOptionId,
+                    proposed_at = @ProposedAt
+                WHERE id = @ProposalId
+                """,
+                new
+                {
+                    ProposalId = proposal.Id,
+                    SelectedOptionId = selectedOption.OptionId,
+                    ProposedAt = selectedOption.ProposedAt
+                },
+                transaction);
+        }
+        else
+        {
+            await connection.ExecuteAsync(
+                "UPDATE reschedule_proposals SET status = 'Rejected' WHERE id = @ProposalId",
+                new { ProposalId = proposal.Id },
+                transaction);
+        }
+
+        var directRecipients = participants
+            .Select(p => new DirectNotificationRecipient(p.TelegramId, p.DisplayName))
+            .ToList();
+
+        await transaction.CommitAsync(ct);
+
+        await TryUpdateVoteMessage(proposal, options, participants, votes, decision, selectedOption, ct);
+
+        if (selectedOption is not null)
+        {
+            await TryUpdateBatchMessage(proposal, ct);
+        }
+
+        var mode = SessionNotificationModeExtensions.FromDatabaseValue(proposal.NotificationMode);
+        if (mode.ShouldSendDirectMessages())
+        {
+            await SendDirectResult(proposal, directRecipients, decision, selectedOption, ct);
+        }
+
+        logger.LogInformation(
+            "Finalized reschedule proposal {ProposalId} for session {SessionId} with outcome {Outcome}",
+            proposal.Id,
+            proposal.SessionId,
+            decision.Outcome);
+    }
+
+    private async Task TryUpdateVoteMessage(
+        DueRescheduleProposalDto proposal,
+        IReadOnlyList<RescheduleOptionDto> options,
+        IReadOnlyList<VoteParticipantDto> participants,
+        IReadOnlyList<RescheduleOptionVoteDto> votes,
+        RescheduleVoteDecision decision,
+        RescheduleOptionDto? selectedOption,
+        CancellationToken ct)
+    {
+        if (proposal.VoteMessageId is null)
+            return;
+
+        try
+        {
+            var resultText = selectedOption is not null
+                ? $"✅ <b>Голосование завершено.</b>\nПобедил вариант {selectedOption.DisplayOrder}: <b>{selectedOption.ProposedAt.FormatMoscow()}</b> (МСК)."
+                : $"❌ <b>Голосование завершено.</b>\n{System.Net.WebUtility.HtmlEncode(decision.Reason)}";
+
+            var text = $"""
+                {HandleRescheduleTimeInputHandler.BuildVotingMessage(
+                    proposal.Title,
+                    proposal.CurrentScheduledAt,
+                    proposal.VotingDeadlineAt,
+                    options,
+                    participants,
+                    votes)}
+
+                {resultText}
+                """;
+
+            await bot.EditMessageText(
+                chatId: proposal.TelegramChatId,
+                messageId: proposal.VoteMessageId.Value,
+                text: text,
+                parseMode: ParseMode.Html,
+                cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to update finalized reschedule vote message for proposal {ProposalId}", proposal.Id);
+        }
+    }
+
+    private async Task TryUpdateBatchMessage(DueRescheduleProposalDto proposal, CancellationToken ct)
+    {
+        try
+        {
+            await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+            var batchSessions = (await connection.QueryAsync<SessionBatchDto>(
+                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status, max_players AS MaxPlayers FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                new { proposal.BatchId })).ToList();
+
+            var batchParticipants = (await connection.QueryAsync<ParticipantBatchDto>(
+                """
+                SELECT sp.session_id AS SessionId,
+                       p.display_name AS DisplayName,
+                       p.telegram_username AS TelegramUsername,
+                       sp.registration_status AS RegistrationStatus
+                FROM session_participants sp
+                JOIN players p ON sp.player_id = p.id
+                JOIN sessions s ON sp.session_id = s.id
+                WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                ORDER BY sp.registration_status ASC, sp.created_at ASC, sp.responded_at ASC, p.created_at ASC
+                """,
+                new { proposal.BatchId })).ToList();
+
+            if (proposal.BatchMessageId.HasValue)
+            {
+                var view = SessionBatchViewBuilder.Build(proposal.Title, batchSessions, batchParticipants);
+                var renderResult = TelegramSessionBatchRenderer.Render(view);
+
+                await BatchMessageEditor.EditBatchMessageAsync(
+                    bot,
+                    chatId: proposal.TelegramChatId,
+                    messageId: proposal.BatchMessageId.Value,
+                    text: renderResult.Text,
+                    replyMarkup: renderResult.Markup,
+                    ct);
+            }
+            else
+            {
+                await bot.SendMessage(
+                    chatId: proposal.TelegramChatId,
+                    text: $"📣 Расписание обновлено после голосования за перенос сессии «{System.Net.WebUtility.HtmlEncode(proposal.Title)}».",
+                    parseMode: ParseMode.Html,
+                    cancellationToken: ct);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to update batch message for finalized proposal {ProposalId}", proposal.Id);
+        }
+    }
+
+    private async Task SendDirectResult(
+        DueRescheduleProposalDto proposal,
+        IReadOnlyList<DirectNotificationRecipient> recipients,
+        RescheduleVoteDecision decision,
+        RescheduleOptionDto? selectedOption,
+        CancellationToken ct)
+    {
+        var htmlText = selectedOption is not null
+            ? $"""
+                ✅ <b>Сессия перенесена по итогам голосования</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(proposal.Title)}</b>
+                📅 Новое время: <b>{selectedOption.ProposedAt.FormatMoscow()}</b> (МСК)
+                """
+            : $"""
+                ❌ <b>Перенос сессии отклонён по итогам голосования</b>
+
+                📌 <b>{System.Net.WebUtility.HtmlEncode(proposal.Title)}</b>
+                📅 Время остаётся прежним: <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)
+                Причина: {System.Net.WebUtility.HtmlEncode(decision.Reason)}
+                """;
+
+        await directSender.SendAsync(
+            recipients,
+            htmlText,
+            selectedOption is not null ? "reschedule-vote-approved" : "reschedule-vote-rejected",
+            proposal.SessionId,
+            ct);
+    }
+}

src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingInput.cs

@@ -0,0 +1,110 @@
+using System.Text.RegularExpressions;
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+internal sealed record RescheduleVotingInput(
+    IReadOnlyList<DateTimeOffset> Options,
+    DateTimeOffset Deadline)
+{
+    private static readonly Regex DateTimePattern = new(
+        @"(?<date>\d{1,2}\.\d{2}\.\d{4})\s+(?<time>\d{1,2}:\d{2})",
+        RegexOptions.CultureInvariant);
+
+    public static bool TryParse(
+        string text,
+        DateTimeOffset nowUtc,
+        out RescheduleVotingInput input,
+        out string error)
+    {
+        input = new RescheduleVotingInput([], default);
+        error = string.Empty;
+
+        var options = new List<DateTimeOffset>();
+        DateTimeOffset? deadline = null;
+
+        foreach (var rawLine in text.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+        {
+            var line = rawLine.Trim();
+            var match = DateTimePattern.Match(line);
+            if (!match.Success)
+                continue;
+
+            var value = $"{match.Groups["date"].Value} {match.Groups["time"].Value}";
+            if (!MoscowTime.TryParseMoscow(value, out var parsed))
+                continue;
+
+            if (IsDeadlineLine(line))
+            {
+                deadline = parsed;
+            }
+            else
+            {
+                options.Add(parsed);
+            }
+        }
+
+        if (options.Count is < 2 or > 3)
+        {
+            error = "Укажите от 2 до 3 вариантов времени.";
+            return false;
+        }
+
+        if (options.Distinct().Count() != options.Count)
+        {
+            error = "Варианты времени не должны повторяться.";
+            return false;
+        }
+
+        if (deadline is null)
+        {
+            error = "Укажите дедлайн голосования строкой «Дедлайн: ДД.ММ.ГГГГ ЧЧ:ММ».";
+            return false;
+        }
+
+        if (options.Any(option => option <= nowUtc))
+        {
+            error = "Все варианты времени должны быть в будущем.";
+            return false;
+        }
+
+        if (deadline.Value <= nowUtc)
+        {
+            error = "Дедлайн голосования должен быть в будущем.";
+            return false;
+        }
+
+        if (deadline.Value >= options.Min())
+        {
+            error = "Дедлайн голосования должен быть раньше первого предложенного времени.";
+            return false;
+        }
+
+        input = new RescheduleVotingInput(options, deadline.Value);
+        return true;
+    }
+
+    private static bool IsDeadlineLine(string line)
+    {
+        var normalized = line.TrimStart('-', '*', ' ', '\t').ToLowerInvariant();
+
+        return normalized.StartsWith("дедлайн", StringComparison.Ordinal)
+            || normalized.StartsWith("deadline", StringComparison.Ordinal)
+            || normalized.StartsWith("до:", StringComparison.Ordinal);
+    }
+}
+
+internal sealed record RescheduleOptionDto(
+    Guid OptionId,
+    int DisplayOrder,
+    DateTimeOffset ProposedAt);
+
+internal sealed record RescheduleOptionVoteDto(
+    Guid OptionId,
+    Guid PlayerId,
+    string DisplayName,
+    string? TelegramUsername);
+
+internal sealed record RescheduleOptionVoteCount(
+    Guid OptionId,
+    int VoteCount);

src/GmRelay.Bot/GmRelay.Bot.csproj

@@ -22,7 +22,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Aspire.Npgsql" Version="13.2.1" />
+    <PackageReference Include="Aspire.Npgsql" Version="13.2.2" />
     <PackageReference Include="Dapper" Version="2.1.72" />
     <PackageReference Include="Dapper.AOT" Version="1.0.48" />
     <PackageReference Include="dbup-postgresql" Version="7.0.1" />

src/GmRelay.Bot/Infrastructure/Logging/SecretRedactor.cs

@@ -0,0 +1,47 @@
+using System.Text.RegularExpressions;
+using Npgsql;
+
+namespace GmRelay.Bot.Infrastructure.Logging;
+
+public static partial class SecretRedactor
+{
+    public static string RedactConnectionString(string? connectionString)
+    {
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            return string.Empty;
+        }
+
+        try
+        {
+            var builder = new NpgsqlConnectionStringBuilder(connectionString);
+            if (!string.IsNullOrWhiteSpace(builder.Password))
+            {
+                builder.Password = "***";
+            }
+
+            return builder.ToString();
+        }
+        catch (ArgumentException)
+        {
+            return RedactText(connectionString);
+        }
+    }
+
+    public static string RedactText(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return string.Empty;
+        }
+
+        return SecretKeyValueRegex().Replace(
+            text,
+            static match => $"{match.Groups["key"].Value}={GetRedactedValue()}");
+    }
+
+    private static string GetRedactedValue() => "***";
+
+    [GeneratedRegex(@"(?<key>password|pwd|passwd|token|secret|api[-_]?key)\s*=\s*(?<value>[^;\s,]+)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex SecretKeyValueRegex();
+}

src/GmRelay.Bot/Infrastructure/Scheduling/SessionSchedulerService.cs

@@ -2,6 +2,7 @@ using Dapper;
 using GmRelay.Shared.Domain;
 using GmRelay.Bot.Features.Confirmation.SendConfirmation;
 using GmRelay.Bot.Features.Reminders.SendJoinLink;
+using GmRelay.Bot.Features.Reminders.SendOneHourReminder;
 using Npgsql;
 
 namespace GmRelay.Bot.Infrastructure.Scheduling;
@@ -17,11 +18,13 @@ namespace GmRelay.Bot.Infrastructure.Scheduling;
 public sealed class SessionSchedulerService(
     NpgsqlDataSource dataSource,
     SendConfirmationHandler confirmationHandler,
+    SendOneHourReminderHandler oneHourReminderHandler,
     SendJoinLinkHandler joinLinkHandler,
     ILogger<SessionSchedulerService> logger) : BackgroundService
 {
     private static readonly TimeSpan TickInterval = TimeSpan.FromMinutes(1);
     private static readonly TimeSpan ConfirmationLeadTime = TimeSpan.FromHours(24);
+    private static readonly TimeSpan OneHourReminderLeadTime = TimeSpan.FromHours(1);
     private static readonly TimeSpan JoinLinkLeadTime = TimeSpan.FromMinutes(5);
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -36,6 +39,7 @@ public sealed class SessionSchedulerService(
             try
             {
                 await ProcessConfirmationTriggers(stoppingToken);
+                await ProcessOneHourReminderTriggers(stoppingToken);
                 await ProcessJoinLinkTriggers(stoppingToken);
             }
             catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
@@ -52,6 +56,42 @@ public sealed class SessionSchedulerService(
         logger.LogInformation("Session scheduler stopped");
     }
 
+    /// <summary>
+    /// T-1h trigger: process direct reminders according to the session notification mode.
+    /// </summary>
+    private async Task ProcessOneHourReminderTriggers(CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var sessionIds = await connection.QueryAsync<Guid>(
+            """
+            SELECT id
+            FROM sessions
+            WHERE status IN (@Confirmed, @ConfirmationSent)
+              AND scheduled_at - @LeadTime <= now()
+              AND one_hour_reminder_processed_at IS NULL
+            """,
+            new
+            {
+                Confirmed = SessionStatus.Confirmed,
+                ConfirmationSent = SessionStatus.ConfirmationSent,
+                LeadTime = OneHourReminderLeadTime
+            });
+
+        foreach (var sessionId in sessionIds)
+        {
+            try
+            {
+                await oneHourReminderHandler.HandleAsync(sessionId, ct);
+                logger.LogInformation("One-hour reminder processed for session {SessionId}", sessionId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to process one-hour reminder for session {SessionId}", sessionId);
+            }
+        }
+    }
+
     /// <summary>
     /// T-24h trigger: find sessions that need confirmation requests sent.
     /// Condition: status='Planned' AND scheduled_at minus 24h is in the past.

src/GmRelay.Bot/Infrastructure/Telegram/BatchMessageEditor.cs

@@ -0,0 +1,51 @@
+using Telegram.Bot;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+/// <summary>
+/// Handles editing batch messages that may be either text or photo messages.
+/// When the batch was created with SendPhoto (image + caption), we need
+/// EditMessageCaption instead of EditMessageText.
+/// </summary>
+public static class BatchMessageEditor
+{
+    /// <summary>
+    /// Edits a batch message, automatically detecting whether it is a text or photo message.
+    /// Tries EditMessageText first; on failure falls back to EditMessageCaption.
+    /// </summary>
+    public static async Task EditBatchMessageAsync(
+        ITelegramBotClient bot,
+        long chatId,
+        int messageId,
+        string text,
+        InlineKeyboardMarkup? replyMarkup,
+        CancellationToken ct = default)
+    {
+        try
+        {
+            await bot.EditMessageText(
+                chatId: chatId,
+                messageId: messageId,
+                text: text,
+                parseMode: ParseMode.Html,
+                replyMarkup: replyMarkup,
+                cancellationToken: ct);
+        }
+        catch (global::Telegram.Bot.Exceptions.ApiRequestException ex)
+            when (ex.Message.Contains("there is no text in the message", StringComparison.OrdinalIgnoreCase))
+        {
+            // The batch message is a photo — use EditMessageCaption instead.
+            // Caption is limited to 1024 chars; if text exceeds that, truncate gracefully.
+            var caption = text.Length <= 1024 ? text : text[..1021] + "...";
+            await bot.EditMessageCaption(
+                chatId: chatId,
+                messageId: messageId,
+                caption: caption,
+                parseMode: ParseMode.Html,
+                replyMarkup: replyMarkup,
+                cancellationToken: ct);
+        }
+    }
+}

src/GmRelay.Bot/Infrastructure/Telegram/ITelegramUpdateHandler.cs

@@ -0,0 +1,8 @@
+using Telegram.Bot.Types;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+public interface ITelegramUpdateHandler
+{
+    Task RouteAsync(Update update, CancellationToken ct);
+}

src/GmRelay.Bot/Infrastructure/Telegram/ITelegramUpdateSource.cs

@@ -0,0 +1,14 @@
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+public interface ITelegramUpdateSource
+{
+    Task<Update[]> GetUpdatesAsync(
+        int offset,
+        int? limit = null,
+        int? timeout = null,
+        IEnumerable<UpdateType>? allowedUpdates = null,
+        CancellationToken cancellationToken = default);
+}

src/GmRelay.Bot/Infrastructure/Telegram/TelegramBotService.cs

@@ -1,4 +1,3 @@
-using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
 
@@ -9,35 +8,21 @@ namespace GmRelay.Bot.Infrastructure.Telegram;
 /// Stateless — all state is in PostgreSQL. Safe to restart at any time.
 /// </summary>
 public sealed class TelegramBotService(
-    ITelegramBotClient bot,
-    UpdateRouter router,
+    ITelegramUpdateSource updateSource,
+    ITelegramUpdateHandler updateHandler,
     ILogger<TelegramBotService> logger) : BackgroundService
 {
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         logger.LogInformation("Telegram bot polling started");
 
-        // Skip any pending updates from before this startup
-        try
-        {
-            var pending = await bot.GetUpdates(offset: -1, limit: 1, cancellationToken: stoppingToken);
-            if (pending.Length > 0)
-            {
-                logger.LogInformation("Skipped {Count} pending update(s)", pending[^1].Id);
-            }
-        }
-        catch (Exception ex)
-        {
-            logger.LogWarning(ex, "Failed to clear pending updates, continuing anyway");
-        }
-
-        var offset = 0;
+        var offset = await GetStartupOffsetAsync(stoppingToken);
 
         while (!stoppingToken.IsCancellationRequested)
         {
             try
             {
-                var updates = await bot.GetUpdates(
+                var updates = await updateSource.GetUpdatesAsync(
                     offset: offset,
                     timeout: 30,
                     allowedUpdates: [UpdateType.Message, UpdateType.CallbackQuery],
@@ -47,7 +32,7 @@ public sealed class TelegramBotService(
                 {
                     try
                     {
-                        await router.RouteAsync(update, stoppingToken);
+                        await updateHandler.RouteAsync(update, stoppingToken);
                     }
                     catch (Exception ex)
                     {
@@ -70,4 +55,33 @@ public sealed class TelegramBotService(
 
         logger.LogInformation("Telegram bot polling stopped");
     }
+
+    private async Task<int> GetStartupOffsetAsync(CancellationToken stoppingToken)
+    {
+        try
+        {
+            var pending = await updateSource.GetUpdatesAsync(
+                offset: -1,
+                limit: 1,
+                cancellationToken: stoppingToken);
+
+            if (pending.Length == 0)
+            {
+                return 0;
+            }
+
+            var startupOffset = pending[^1].Id + 1;
+            logger.LogInformation(
+                "Skipping pending updates through {LastPendingUpdateId}; starting polling from offset {StartupOffset}",
+                pending[^1].Id,
+                startupOffset);
+
+            return startupOffset;
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to determine startup offset, continuing from offset 0");
+            return 0;
+        }
+    }
 }

src/GmRelay.Bot/Infrastructure/Telegram/TelegramMiniAppMenuButtonService.cs

@@ -0,0 +1,46 @@
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+public sealed class TelegramMiniAppMenuButtonService(
+    ITelegramBotClient bot,
+    IConfiguration configuration,
+    ILogger<TelegramMiniAppMenuButtonService> logger) : IHostedService
+{
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        var miniAppUrl = configuration["Telegram:MiniAppUrl"];
+        if (string.IsNullOrWhiteSpace(miniAppUrl))
+        {
+            logger.LogInformation("Telegram Mini App URL is not configured; menu button setup skipped.");
+            return;
+        }
+
+        if (!Uri.TryCreate(miniAppUrl, UriKind.Absolute, out var uri) ||
+            (uri.Scheme != Uri.UriSchemeHttps && !uri.IsLoopback))
+        {
+            logger.LogWarning("Telegram Mini App URL {MiniAppUrl} is not a valid HTTPS URL.", miniAppUrl);
+            return;
+        }
+
+        try
+        {
+            await bot.SetChatMenuButton(
+                menuButton: new MenuButtonWebApp
+                {
+                    Text = "Dashboard",
+                    WebApp = new WebAppInfo(miniAppUrl)
+                },
+                cancellationToken: cancellationToken);
+
+            logger.LogInformation("Telegram Mini App menu button configured for {MiniAppUrl}.", miniAppUrl);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to configure Telegram Mini App menu button.");
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}

src/GmRelay.Bot/Infrastructure/Telegram/TelegramSessionBatchRenderer.cs

@@ -0,0 +1,58 @@
+// NOTE: duplicated in GmRelay.Web/Services/TelegramSessionBatchRenderer.cs
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+public static class TelegramSessionBatchRenderer
+{
+    public static (string Text, InlineKeyboardMarkup Markup) Render(SessionBatchViewModel view)
+    {
+        var messageText = $"🎲 <b>Новые игры:</b> {System.Net.WebUtility.HtmlEncode(view.Title)}\n\n" +
+                          $"<b>Расписание:</b>\n\n";
+
+        var buttons = new List<InlineKeyboardButton[]>();
+
+        foreach (var session in view.Sessions)
+        {
+            messageText += $"📅 <b>{session.ScheduledAt.FormatMoscow()}</b>\n";
+            messageText += session.MaxPlayers.HasValue
+                ? $"👥 Места: {session.ActivePlayerCount}/{session.MaxPlayers.Value}\n"
+                : $"👥 Игроки ({session.ActivePlayerCount}):\n";
+
+            if (session.ActivePlayers.Count > 0)
+            {
+                messageText += string.Join("\n", session.ActivePlayers.Select(p =>
+                    $"  👤 {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
+            }
+            else
+            {
+                messageText += "  <i>Пока никто не записался</i>\n";
+            }
+
+            if (session.WaitlistedPlayers.Count > 0)
+            {
+                messageText += $"⏳ Лист ожидания ({session.WaitlistedPlayers.Count}):\n";
+                messageText += string.Join("\n", session.WaitlistedPlayers.Select(p =>
+                    $"  ⏱ {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
+            }
+
+            if (GmRelay.Shared.Domain.SessionStatus.IsCancelled(session.Status))
+            {
+                messageText += "❌ <i>Сессия отменена</i>\n\n";
+            }
+            else
+            {
+                messageText += "\n";
+                var actionRow = session.AvailableActions
+                    .Select(a => InlineKeyboardButton.WithCallbackData(a.Label, $"{a.ActionKey}:{a.SessionId}"))
+                    .ToArray();
+                if (actionRow.Length > 0)
+                    buttons.Add(actionRow);
+            }
+        }
+
+        return (messageText, new InlineKeyboardMarkup(buttons));
+    }
+}

src/GmRelay.Bot/Infrastructure/Telegram/TelegramUpdateSource.cs

@@ -0,0 +1,21 @@
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+
+namespace GmRelay.Bot.Infrastructure.Telegram;
+
+public sealed class TelegramUpdateSource(ITelegramBotClient bot) : ITelegramUpdateSource
+{
+    public Task<Update[]> GetUpdatesAsync(
+        int offset,
+        int? limit = null,
+        int? timeout = null,
+        IEnumerable<UpdateType>? allowedUpdates = null,
+        CancellationToken cancellationToken = default) =>
+        bot.GetUpdates(
+            offset: offset,
+            limit: limit,
+            timeout: timeout,
+            allowedUpdates: allowedUpdates,
+            cancellationToken: cancellationToken);
+}

src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs

@@ -9,6 +9,7 @@ using GmRelay.Bot.Features.Sessions.RescheduleSession;
 using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
 
 namespace GmRelay.Bot.Infrastructure.Telegram;
 
@@ -20,6 +21,8 @@ public sealed class UpdateRouter(
     HandleRsvpHandler rsvpHandler,
     CreateSessionHandler createSessionHandler,
     JoinSessionHandler joinSessionHandler,
+    LeaveSessionHandler leaveSessionHandler,
+    PromoteWaitlistedPlayerHandler promoteWaitlistedPlayerHandler,
     CancelSessionHandler cancelSessionHandler,
     DeleteSessionHandler deleteSessionHandler,
     ListSessionsHandler listSessionsHandler,
@@ -28,7 +31,8 @@ public sealed class UpdateRouter(
     HandleRescheduleTimeInputHandler rescheduleTimeInputHandler,
     HandleRescheduleVoteHandler rescheduleVoteHandler,
     ITelegramBotClient bot,
-    ILogger<UpdateRouter> logger)
+    IConfiguration configuration,
+    ILogger<UpdateRouter> logger) : ITelegramUpdateHandler
 {
     public async Task RouteAsync(Update update, CancellationToken ct)
     {
@@ -38,17 +42,26 @@ public sealed class UpdateRouter(
                 await HandleCallbackQueryAsync(query, ct);
                 break;
 
-            case { Message: { Text: { } text } message } when text.StartsWith('/'):
-                await HandleCommandAsync(message, text, ct);
-                break;
+            case { Message: { } message }:
+                var commandText = GetCommandText(message);
+                if (commandText.StartsWith("/", StringComparison.Ordinal))
+                {
+                    await HandleCommandAsync(message, commandText, ct);
+                    break;
+                }
+
+                if (message.Text is not null)
+                {
+                    await rescheduleTimeInputHandler.TryHandleAsync(message, ct);
+                }
 
-            // Non-command text messages — check for reschedule time input
-            case { Message: { Text: { } } message } when !message.Text!.StartsWith('/'):
-                await rescheduleTimeInputHandler.TryHandleAsync(message, ct);
                 break;
         }
     }
 
+    internal static string GetCommandText(Message message)
+        => (message.Text ?? message.Caption ?? string.Empty).TrimStart();
+
     private async Task HandleCallbackQueryAsync(CallbackQuery query, CancellationToken ct)
     {
         if (query.Data is not { } data || query.Message is not { } message)
@@ -72,6 +85,19 @@ public sealed class UpdateRouter(
             return;
         }
 
+        if (action == "leave_session" && parts.Length >= 2 && Guid.TryParse(parts[1], out var leaveSessionId))
+        {
+            var command = new LeaveSessionCommand(
+                SessionId: leaveSessionId,
+                TelegramUserId: query.From.Id,
+                CallbackQueryId: query.Id,
+                ChatId: message.Chat.Id,
+                MessageId: message.MessageId);
+
+            await leaveSessionHandler.HandleAsync(command, ct);
+            return;
+        }
+
         if (action == "cancel_session" && parts.Length >= 2 && Guid.TryParse(parts[1], out var cancelSessionId))
         {
             var command = new CancelSessionCommand(
@@ -85,6 +111,19 @@ public sealed class UpdateRouter(
             return;
         }
 
+        if (action == "promote_waitlist" && parts.Length >= 2 && Guid.TryParse(parts[1], out var promoteSessionId))
+        {
+            var command = new PromoteWaitlistedPlayerCommand(
+                SessionId: promoteSessionId,
+                TelegramUserId: query.From.Id,
+                CallbackQueryId: query.Id,
+                ChatId: message.Chat.Id,
+                MessageId: message.MessageId);
+
+            await promoteWaitlistedPlayerHandler.HandleAsync(command, ct);
+            return;
+        }
+
         if (action == "delete_session" && parts.Length >= 2 && Guid.TryParse(parts[1], out var deleteSessionId))
         {
             var command = new DeleteSessionCommand(
@@ -111,15 +150,10 @@ public sealed class UpdateRouter(
             return;
         }
 
-        if (action == "reschedule_vote" && parts.Length >= 3 && Guid.TryParse(parts[2], out var proposalId))
+        if (action == "reschedule_vote" && parts.Length >= 2 && Guid.TryParse(parts[1], out var optionId))
         {
-            var vote = parts[1]; // "yes" or "no"
-            if (vote is not ("yes" or "no"))
-                return;
-
             var command = new HandleRescheduleVoteCommand(
-                ProposalId: proposalId,
-                Vote: vote,
+                OptionId: optionId,
                 TelegramUserId: query.From.Id,
                 CallbackQueryId: query.Id,
                 ChatId: message.Chat.Id,
@@ -165,10 +199,7 @@ public sealed class UpdateRouter(
         switch (command)
         {
             case "/start":
-                await bot.SendMessage(
-                    chatId: message.Chat.Id,
-                    text: "GM-Relay Bot ready. Use /help for commands.",
-                    cancellationToken: ct);
+                await SendStartMessageAsync(message, ct);
                 break;
 
             case "/newsession":
@@ -192,9 +223,17 @@ public sealed class UpdateRouter(
                         /newsession
                         Название: My Game
                         Время: 15.05.2026 19:30
+                        Мест: 4
                         Ссылка: https://link
+                        Картинка: https://cover
+
+                        Для регулярного расписания можно указать одну дату:
+                        Игр: 4
+                        Интервал: 7
 
                         /listsessions — список предстоящих сессий
+                        Для owner/co-GM /listsessions показывает кнопки отмены, переноса, удаления и повышения из листа ожидания.
+                        Игроки могут записаться кнопкой «На дату» и сняться кнопкой «Выйти».
                         /help — эта справка
                         """,
                     cancellationToken: ct);
@@ -206,4 +245,24 @@ public sealed class UpdateRouter(
                 break;
         }
     }
+
+    private async Task SendStartMessageAsync(Message message, CancellationToken ct)
+    {
+        var miniAppUrl = configuration["Telegram:MiniAppUrl"];
+        if (string.IsNullOrWhiteSpace(miniAppUrl))
+        {
+            await bot.SendMessage(
+                chatId: message.Chat.Id,
+                text: "GM-Relay Bot ready. Use /help for commands.",
+                cancellationToken: ct);
+            return;
+        }
+
+        await bot.SendMessage(
+            chatId: message.Chat.Id,
+            text: "GM-Relay Bot ready. Откройте dashboard внутри Telegram или используйте /help для команд.",
+            replyMarkup: new InlineKeyboardMarkup(
+                InlineKeyboardButton.WithWebApp("Открыть dashboard", new WebAppInfo(miniAppUrl))),
+            cancellationToken: ct);
+    }
 }

src/GmRelay.Bot/Migrations/V006__add_session_capacity_waitlist.sql

@@ -0,0 +1,16 @@
+-- Add per-session seat limits and participant waitlist support.
+ALTER TABLE sessions
+    ADD COLUMN max_players INTEGER,
+    ADD CONSTRAINT ck_sessions_max_players CHECK (max_players IS NULL OR max_players > 0);
+
+ALTER TABLE session_participants
+    ADD COLUMN registration_status VARCHAR(50) NOT NULL DEFAULT 'Active'
+        CHECK (registration_status IN ('Active', 'Waitlisted')),
+    ADD COLUMN created_at TIMESTAMPTZ NOT NULL DEFAULT now();
+
+CREATE INDEX ix_session_participants_session_registration_status
+    ON session_participants (session_id, registration_status);
+
+CREATE INDEX ix_session_participants_waitlist_order
+    ON session_participants (session_id, created_at, id)
+    WHERE registration_status = 'Waitlisted';

src/GmRelay.Bot/Migrations/V007__add_session_notification_mode.sql

@@ -0,0 +1,8 @@
+ALTER TABLE sessions
+    ADD COLUMN notification_mode VARCHAR(50) NOT NULL DEFAULT 'GroupAndDirect'
+        CHECK (notification_mode IN ('GroupAndDirect', 'GroupOnly')),
+    ADD COLUMN one_hour_reminder_processed_at TIMESTAMPTZ;
+
+CREATE INDEX ix_sessions_one_hour_reminders ON sessions (scheduled_at)
+    WHERE status IN ('Confirmed', 'ConfirmationSent')
+      AND one_hour_reminder_processed_at IS NULL;

src/GmRelay.Bot/Migrations/V008__add_group_managers.sql

@@ -0,0 +1,26 @@
+-- Add explicit owner/co-GM management roles for each Telegram group.
+
+INSERT INTO players (telegram_id, display_name)
+SELECT DISTINCT gg.gm_telegram_id,
+       'GM ' || gg.gm_telegram_id::text
+FROM game_groups gg
+ON CONFLICT (telegram_id) DO NOTHING;
+
+CREATE TABLE group_managers (
+    id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    group_id            UUID NOT NULL REFERENCES game_groups(id) ON DELETE CASCADE,
+    player_id           UUID NOT NULL REFERENCES players(id) ON DELETE CASCADE,
+    role                VARCHAR(50) NOT NULL CHECK (role IN ('Owner', 'CoGm')),
+    added_by_player_id  UUID REFERENCES players(id) ON DELETE SET NULL,
+    created_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (group_id, player_id)
+);
+
+INSERT INTO group_managers (group_id, player_id, role)
+SELECT gg.id, p.id, 'Owner'
+FROM game_groups gg
+JOIN players p ON p.telegram_id = gg.gm_telegram_id
+ON CONFLICT (group_id, player_id) DO NOTHING;
+
+CREATE INDEX ix_group_managers_group_role ON group_managers (group_id, role);
+CREATE INDEX ix_group_managers_player ON group_managers (player_id);

src/GmRelay.Bot/Migrations/V009__add_multi_option_reschedule_votes.sql

@@ -0,0 +1,35 @@
+-- Multi-option reschedule voting with a deadline.
+
+ALTER TABLE reschedule_proposals
+    ADD COLUMN voting_deadline_at TIMESTAMPTZ,
+    ADD COLUMN selected_option_id UUID;
+
+CREATE TABLE reschedule_options (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    proposal_id     UUID NOT NULL REFERENCES reschedule_proposals(id) ON DELETE CASCADE,
+    proposed_at     TIMESTAMPTZ NOT NULL,
+    display_order   INTEGER NOT NULL CHECK (display_order BETWEEN 1 AND 3),
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (proposal_id, id),
+    UNIQUE (proposal_id, display_order),
+    UNIQUE (proposal_id, proposed_at)
+);
+
+CREATE TABLE reschedule_option_votes (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    proposal_id     UUID NOT NULL REFERENCES reschedule_proposals(id) ON DELETE CASCADE,
+    player_id       UUID NOT NULL REFERENCES players(id) ON DELETE CASCADE,
+    option_id       UUID NOT NULL,
+    voted_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (proposal_id, player_id),
+    FOREIGN KEY (proposal_id, option_id)
+        REFERENCES reschedule_options(proposal_id, id)
+        ON DELETE CASCADE
+);
+
+CREATE INDEX ix_reschedule_voting_deadline
+    ON reschedule_proposals (voting_deadline_at)
+    WHERE status = 'Voting';
+
+CREATE INDEX ix_reschedule_option_votes_option
+    ON reschedule_option_votes (option_id);

src/GmRelay.Bot/Migrations/V010__add_campaign_templates.sql

@@ -0,0 +1,17 @@
+CREATE TABLE campaign_templates (
+    id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    group_id            UUID NOT NULL REFERENCES game_groups(id) ON DELETE CASCADE,
+    name                VARCHAR(200) NOT NULL,
+    title               VARCHAR(500) NOT NULL,
+    join_link           TEXT NOT NULL,
+    session_count       INTEGER NOT NULL CHECK (session_count BETWEEN 1 AND 52),
+    interval_days       INTEGER NOT NULL CHECK (interval_days BETWEEN 1 AND 365),
+    max_players         INTEGER CHECK (max_players IS NULL OR max_players > 0),
+    notification_mode   VARCHAR(32) NOT NULL DEFAULT 'GroupAndDirect'
+                        CHECK (notification_mode IN ('GroupAndDirect', 'GroupOnly')),
+    created_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (group_id, name)
+);
+
+CREATE INDEX ix_campaign_templates_group ON campaign_templates (group_id, created_at DESC);

src/GmRelay.Bot/Migrations/V011__add_calendar_subscriptions.sql

@@ -0,0 +1,11 @@
+CREATE TABLE calendar_subscriptions (
+    id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    token               TEXT UNIQUE NOT NULL,
+    user_telegram_id    BIGINT NOT NULL,
+    group_id            UUID REFERENCES game_groups(id) ON DELETE CASCADE,
+    filter_type         SMALLINT NOT NULL DEFAULT 0,
+    created_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    expires_at          TIMESTAMPTZ
+);
+
+CREATE INDEX ix_calendar_subscriptions_user_telegram_id ON calendar_subscriptions (user_telegram_id);

src/GmRelay.Bot/Migrations/V012__add_attendance_stats.sql

@@ -0,0 +1,66 @@
+-- =============================================================
+-- Attendance statistics view for GM analytics
+-- Returns per-player aggregated metrics for a given game group.
+-- NOTE: waitlist count reflects CURRENT registration_status only.
+--       Full historical waitlist tracking will come with #15.
+-- =============================================================
+
+CREATE OR REPLACE FUNCTION get_group_attendance_stats(p_group_id UUID)
+RETURNS TABLE (
+    player_id           UUID,
+    display_name        VARCHAR,
+    telegram_username   VARCHAR,
+    total_sessions      BIGINT,
+    confirmed_count     BIGINT,
+    declined_count      BIGINT,
+    no_response_count   BIGINT,
+    waitlisted_count    BIGINT,
+    cancellation_affected_count BIGINT,
+    attendance_rate     NUMERIC
+) AS $$
+BEGIN
+    RETURN QUERY
+    WITH player_sessions AS (
+        SELECT
+            sp.player_id,
+            s.id                AS session_id,
+            sp.rsvp_status,
+            sp.registration_status,
+            s.status            AS session_status,
+            s.scheduled_at
+        FROM session_participants sp
+        JOIN sessions s ON s.id = sp.session_id
+        WHERE s.group_id = p_group_id
+    ),
+    player_totals AS (
+        SELECT
+            ps.player_id,
+            COUNT(*) FILTER (WHERE ps.session_status <> 'Cancelled')                      AS total_sessions,
+            COUNT(*) FILTER (WHERE ps.rsvp_status = 'Confirmed' AND ps.session_status <> 'Cancelled') AS confirmed_count,
+            COUNT(*) FILTER (WHERE ps.rsvp_status = 'Declined' AND ps.session_status <> 'Cancelled')  AS declined_count,
+            COUNT(*) FILTER (WHERE ps.rsvp_status = 'Pending' AND ps.scheduled_at < NOW() AND ps.session_status <> 'Cancelled') AS no_response_count,
+            COUNT(*) FILTER (WHERE ps.registration_status = 'Waitlisted' AND ps.session_status <> 'Cancelled') AS waitlisted_count,
+            COUNT(*) FILTER (WHERE ps.session_status = 'Cancelled')                        AS cancellation_affected_count
+        FROM player_sessions ps
+        GROUP BY ps.player_id
+    )
+    SELECT
+        pt.player_id,
+        p.display_name,
+        p.telegram_username,
+        pt.total_sessions,
+        pt.confirmed_count,
+        pt.declined_count,
+        pt.no_response_count,
+        pt.waitlisted_count,
+        pt.cancellation_affected_count,
+        ROUND(
+            100.0 * pt.confirmed_count
+            / NULLIF(pt.total_sessions, 0),
+            1
+        ) AS attendance_rate
+    FROM player_totals pt
+    JOIN players p ON p.id = pt.player_id
+    ORDER BY pt.confirmed_count DESC, pt.total_sessions DESC;
+END;
+$$ LANGUAGE plpgsql STABLE;

src/GmRelay.Bot/Program.cs

@@ -1,9 +1,12 @@
 using GmRelay.Bot.Features.Confirmation.HandleRsvp;
 using GmRelay.Bot.Features.Confirmation.SendConfirmation;
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Bot.Features.Reminders.SendJoinLink;
+using GmRelay.Bot.Features.Reminders.SendOneHourReminder;
 using GmRelay.Bot.Features.Sessions.CreateSession;
 using GmRelay.Bot.Features.Sessions.RescheduleSession;
 using GmRelay.Bot.Infrastructure.Database;
+using GmRelay.Bot.Infrastructure.Logging;
 using GmRelay.Bot.Infrastructure.Scheduling;
 using GmRelay.Bot.Infrastructure.Telegram;
 using Npgsql;
@@ -20,11 +23,16 @@ builder.AddServiceDefaults();
 builder.Services.AddSingleton<NpgsqlDataSource>(sp =>
 {
     var config = sp.GetRequiredService<IConfiguration>();
+    var loggerFactory = sp.GetRequiredService<ILoggerFactory>();
     var connectionString = config.GetConnectionString("gmrelaydb")
         ?? throw new InvalidOperationException(
             "ConnectionStrings:gmrelaydb is required. Set via environment variable ConnectionStrings__gmrelaydb.");
-    
-    Console.WriteLine($"[DBG] Master ConnectionString => {connectionString}");
+
+    var logger = loggerFactory.CreateLogger("GmRelay.Bot.Startup");
+    logger.LogInformation(
+        "Configured PostgreSQL data source with connection string {ConnectionString}",
+        SecretRedactor.RedactConnectionString(connectionString));
+
     return NpgsqlDataSource.Create(connectionString);
 });
 
@@ -40,13 +48,18 @@ builder.Services.AddSingleton<ITelegramBotClient>(sp =>
             "Telegram:BotToken is required. Set via environment variable Telegram__BotToken or appsettings.json.");
     return new TelegramBotClient(token);
 });
+builder.Services.AddSingleton<ITelegramUpdateSource, TelegramUpdateSource>();
 
 // ── Feature handlers (explicit registration — AOT safe) ──────────────
 builder.Services.AddSingleton<SendConfirmationHandler>();
+builder.Services.AddSingleton<DirectSessionNotificationSender>();
 builder.Services.AddSingleton<HandleRsvpHandler>();
 builder.Services.AddSingleton<SendJoinLinkHandler>();
+builder.Services.AddSingleton<SendOneHourReminderHandler>();
 builder.Services.AddSingleton<CreateSessionHandler>();
 builder.Services.AddSingleton<JoinSessionHandler>();
+builder.Services.AddSingleton<LeaveSessionHandler>();
+builder.Services.AddSingleton<PromoteWaitlistedPlayerHandler>();
 builder.Services.AddSingleton<CancelSessionHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.ListSessions.DeleteSessionHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.ListSessions.ListSessionsHandler>();
@@ -57,10 +70,13 @@ builder.Services.AddSingleton<HandleRescheduleVoteHandler>();
 
 // ── Telegram infrastructure ──────────────────────────────────────────
 builder.Services.AddSingleton<UpdateRouter>();
+builder.Services.AddSingleton<ITelegramUpdateHandler>(sp => sp.GetRequiredService<UpdateRouter>());
+builder.Services.AddHostedService<TelegramMiniAppMenuButtonService>();
 builder.Services.AddHostedService<TelegramBotService>();
 
 // ── Session scheduler ────────────────────────────────────────────────
 builder.Services.AddHostedService<SessionSchedulerService>();
+builder.Services.AddHostedService<RescheduleVotingDeadlineService>();
 
 var host = builder.Build();
 

src/GmRelay.Bot/Properties/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("GmRelay.Bot.Tests")]

src/GmRelay.Bot/appsettings.json

@@ -7,6 +7,10 @@
     }
   },
   "Telegram": {
-    "BotToken": ""
+    "BotToken": "",
+    "MiniAppUrl": ""
+  },
+  "Web": {
+    "BaseUrl": ""
   }
 }

src/GmRelay.ServiceDefaults/GmRelay.ServiceDefaults.csproj

@@ -12,11 +12,11 @@
 
     <PackageReference Include="Microsoft.Extensions.Http.Resilience" Version="10.2.0" />
     <PackageReference Include="Microsoft.Extensions.ServiceDiscovery" Version="10.2.0" />
-    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.15.0" />
-    <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.15.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.15.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.15.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" Version="1.15.0" />
+    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.15.3" />
+    <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.15.3" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.15.2" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.15.1" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" Version="1.15.1" />
   </ItemGroup>
 
 </Project>

src/GmRelay.Shared/Domain/CalendarSubscriptionFilter.cs

@@ -0,0 +1,7 @@
+namespace GmRelay.Shared.Domain;
+
+public enum CalendarSubscriptionFilter
+{
+    AllMyGroups = 0,
+    SpecificGroup = 1
+}

src/GmRelay.Shared/Domain/GroupManagerRole.cs

@@ -0,0 +1,34 @@
+namespace GmRelay.Shared.Domain;
+
+public enum GroupManagerRole
+{
+    Owner,
+    CoGm
+}
+
+public static class GroupManagerRoleExtensions
+{
+    public const string OwnerValue = "Owner";
+    public const string CoGmValue = "CoGm";
+
+    public static string ToDatabaseValue(this GroupManagerRole role) => role switch
+    {
+        GroupManagerRole.Owner => OwnerValue,
+        GroupManagerRole.CoGm => CoGmValue,
+        _ => throw new ArgumentOutOfRangeException(nameof(role), role, "Unknown group manager role.")
+    };
+
+    public static GroupManagerRole FromDatabaseValue(string value) => value switch
+    {
+        OwnerValue => GroupManagerRole.Owner,
+        CoGmValue => GroupManagerRole.CoGm,
+        _ => throw new ArgumentOutOfRangeException(nameof(value), value, "Unknown group manager role.")
+    };
+
+    public static string ToDisplayName(this GroupManagerRole role) => role switch
+    {
+        GroupManagerRole.Owner => "Owner",
+        GroupManagerRole.CoGm => "Co-GM",
+        _ => throw new ArgumentOutOfRangeException(nameof(role), role, "Unknown group manager role.")
+    };
+}

src/GmRelay.Shared/Domain/MoscowTime.cs

@@ -11,7 +11,7 @@ public static class MoscowTime
     public static string FormatMoscow(this DateTimeOffset utc)
         => utc.ToOffset(MoscowOffset).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"));
 
-    public static DateTime ToMoscow(this DateTime utcDt) => utcDt.Add(MoscowOffset);
+    public static DateTime ToMoscow(this DateTime utcDt) => DateTime.SpecifyKind(utcDt.Add(MoscowOffset), DateTimeKind.Unspecified);
 
     public static string FormatMoscow(this DateTime utcDt)
         => utcDt.Add(MoscowOffset).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"));

src/GmRelay.Shared/Domain/ParticipantRegistrationStatus.cs

@@ -0,0 +1,9 @@
+namespace GmRelay.Shared.Domain;
+
+public static class ParticipantRegistrationStatus
+{
+    public const string Active = "Active";
+    public const string Waitlisted = "Waitlisted";
+
+    public static readonly string[] All = [Active, Waitlisted];
+}

src/GmRelay.Shared/Domain/SessionCapacityRules.cs

@@ -0,0 +1,36 @@
+namespace GmRelay.Shared.Domain;
+
+public static class SessionCapacityRules
+{
+    public static string DecideJoinStatus(int? maxPlayers, int activeParticipants)
+    {
+        if (!maxPlayers.HasValue)
+        {
+            return ParticipantRegistrationStatus.Active;
+        }
+
+        return activeParticipants < maxPlayers.Value
+            ? ParticipantRegistrationStatus.Active
+            : ParticipantRegistrationStatus.Waitlisted;
+    }
+
+    public static bool CanPromoteWaitlistedPlayer(int? maxPlayers, int activeParticipants, int waitlistedParticipants)
+    {
+        if (waitlistedParticipants <= 0)
+        {
+            return false;
+        }
+
+        return !maxPlayers.HasValue || activeParticipants < maxPlayers.Value;
+    }
+
+    public static bool ShouldPromoteAfterParticipantLeaves(
+        string removedRegistrationStatus,
+        int? maxPlayers,
+        int activeParticipantsAfterLeave,
+        int waitlistedParticipants)
+    {
+        return removedRegistrationStatus == ParticipantRegistrationStatus.Active
+            && CanPromoteWaitlistedPlayer(maxPlayers, activeParticipantsAfterLeave, waitlistedParticipants);
+    }
+}

src/GmRelay.Shared/Domain/SessionNotificationMode.cs

@@ -0,0 +1,33 @@
+namespace GmRelay.Shared.Domain;
+
+public enum SessionNotificationMode
+{
+    GroupAndDirect,
+    GroupOnly
+}
+
+public static class SessionNotificationModeExtensions
+{
+    public const string GroupAndDirectValue = nameof(SessionNotificationMode.GroupAndDirect);
+    public const string GroupOnlyValue = nameof(SessionNotificationMode.GroupOnly);
+
+    public static bool ShouldSendDirectMessages(this SessionNotificationMode mode) =>
+        mode == SessionNotificationMode.GroupAndDirect;
+
+    public static string ToDatabaseValue(this SessionNotificationMode mode) =>
+        mode switch
+        {
+            SessionNotificationMode.GroupAndDirect => GroupAndDirectValue,
+            SessionNotificationMode.GroupOnly => GroupOnlyValue,
+            _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, "Unknown notification mode.")
+        };
+
+    public static SessionNotificationMode FromDatabaseValue(string? value) =>
+        value switch
+        {
+            null or "" => SessionNotificationMode.GroupAndDirect,
+            GroupAndDirectValue => SessionNotificationMode.GroupAndDirect,
+            GroupOnlyValue => SessionNotificationMode.GroupOnly,
+            _ => throw new ArgumentOutOfRangeException(nameof(value), value, "Unknown notification mode.")
+        };
+}

src/GmRelay.Shared/Domain/SessionStatus.cs

@@ -1,3 +1,5 @@
+using System.Collections.Frozen;
+
 namespace GmRelay.Shared.Domain;
 
 public static class SessionStatus
@@ -6,4 +8,13 @@ public static class SessionStatus
     public const string ConfirmationSent = "ConfirmationSent";
     public const string Confirmed = "Confirmed";
     public const string Cancelled = "Cancelled";
+
+    public static IReadOnlySet<string> All { get; } =
+        new[] { Planned, ConfirmationSent, Confirmed, Cancelled }
+            .ToFrozenSet(StringComparer.Ordinal);
+
+    public static bool IsKnown(string status) => All.Contains(status);
+
+    public static bool IsCancelled(string status) =>
+        string.Equals(status, Cancelled, StringComparison.Ordinal);
 }

src/GmRelay.Shared/GmRelay.Shared.csproj

@@ -7,8 +7,4 @@
     <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Telegram.Bot" Version="22.9.5.3" />
-  </ItemGroup>
-
 </Project>

src/GmRelay.Shared/Rendering/DiscordSessionBatchRenderer.cs

@@ -0,0 +1,13 @@
+namespace GmRelay.Shared.Rendering;
+
+/// <summary>
+/// Заглушка для Discord-рендерера.
+/// Реальная реализация будет добавлена в проект GmRelay.DiscordBot (issue #26).
+/// </summary>
+public static class DiscordSessionBatchRenderer
+{
+    public static object Render(SessionBatchViewModel view)
+    {
+        throw new NotImplementedException("Discord renderer will be implemented in issue #26.");
+    }
+}

src/GmRelay.Shared/Rendering/SessionBatchDto.cs

@@ -0,0 +1,4 @@
+namespace GmRelay.Shared.Rendering;
+
+public sealed record SessionBatchDto(Guid SessionId, DateTime ScheduledAt, string Status, int? MaxPlayers);
+public sealed record ParticipantBatchDto(Guid SessionId, string DisplayName, string? TelegramUsername, string RegistrationStatus);

src/GmRelay.Shared/Rendering/SessionBatchRenderer.cs

@@ -1,62 +0,0 @@
-using GmRelay.Shared.Domain;
-using Telegram.Bot.Types.ReplyMarkups;
-
-namespace GmRelay.Shared.Rendering;
-
-public sealed record SessionBatchDto(Guid SessionId, DateTime ScheduledAt, string Status);
-public sealed record ParticipantBatchDto(Guid SessionId, string DisplayName, string? TelegramUsername);
-
-public static class SessionBatchRenderer
-{
-    public static (string Text, InlineKeyboardMarkup Markup) Render(
-        string title,
-        IReadOnlyList<SessionBatchDto> sessions,
-        IReadOnlyList<ParticipantBatchDto> participants)
-    {
-        var activeSessions = sessions.OrderBy(s => s.ScheduledAt).ToList();
-        
-        var messageText = $"🎲 <b>Новые игры:</b> {System.Net.WebUtility.HtmlEncode(title)}\n\n" +
-                          $"<b>Расписание:</b>\n\n";
-
-        var buttons = new List<InlineKeyboardButton[]>();
-
-        foreach (var session in activeSessions)
-        {
-            var sessionPlayers = participants.Where(p => p.SessionId == session.SessionId).ToList();
-            
-            messageText += $"📅 <b>{session.ScheduledAt.FormatMoscow()}</b>\n";
-            messageText += $"👥 Игроки ({sessionPlayers.Count}):\n";
-            
-            if (sessionPlayers.Count > 0)
-            {
-                messageText += string.Join("\n", sessionPlayers.Select(p => $"  👤 {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
-            }
-            else
-            {
-                messageText += "  <i>Пока никто не записался</i>\n";
-            }
-
-            if (session.Status == "Cancelled")
-            {
-                messageText += "❌ <i>Сессия отменена</i>\n\n";
-            }
-            else if (session.Status == "RecruitmentClosed") 
-            {
-                messageText += "🔒 <i>Набор завершен</i>\n\n";
-            }
-            else
-            {
-                messageText += "\n";
-                var dateTitle = session.ScheduledAt.FormatMoscowShort();
-                buttons.Add(new[]
-                {
-                    InlineKeyboardButton.WithCallbackData($"✋ На {dateTitle}", $"join_session:{session.SessionId}"),
-                    InlineKeyboardButton.WithCallbackData($"❌ Отменить {dateTitle} (ГМ)", $"cancel_session:{session.SessionId}"),
-                    InlineKeyboardButton.WithCallbackData($"⏰ (ГМ)", $"reschedule_session:{session.SessionId}")
-                });
-            }
-        }
-
-        return (messageText, new InlineKeyboardMarkup(buttons));
-    }
-}

src/GmRelay.Shared/Rendering/SessionBatchViewBuilder.cs

@@ -0,0 +1,60 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Shared.Rendering;
+
+public static class SessionBatchViewBuilder
+{
+    public static SessionBatchViewModel Build(
+        string title,
+        IReadOnlyList<SessionBatchDto> sessions,
+        IReadOnlyList<ParticipantBatchDto> participants)
+    {
+        var orderedSessions = sessions.OrderBy(s => s.ScheduledAt).ToList();
+        var sessionItems = new List<SessionViewItem>();
+
+        foreach (var session in orderedSessions)
+        {
+            var activePlayers = participants
+                .Where(p => p.SessionId == session.SessionId && p.RegistrationStatus == ParticipantRegistrationStatus.Active)
+                .Select(p => new PlayerViewItem(p.DisplayName, p.TelegramUsername, p.RegistrationStatus))
+                .ToList();
+
+            var waitlistedPlayers = participants
+                .Where(p => p.SessionId == session.SessionId && p.RegistrationStatus == ParticipantRegistrationStatus.Waitlisted)
+                .Select(p => new PlayerViewItem(p.DisplayName, p.TelegramUsername, p.RegistrationStatus))
+                .ToList();
+
+            var actions = new List<AvailableAction>();
+            if (!SessionStatus.IsCancelled(session.Status))
+            {
+                var dateTitle = session.ScheduledAt.FormatMoscowShort();
+                var joinLabel = GetJoinButtonText(session, activePlayers.Count, dateTitle);
+                actions.Add(new AvailableAction("join_session", joinLabel, session.SessionId));
+                actions.Add(new AvailableAction("leave_session", $"🚪 Выйти {dateTitle}", session.SessionId));
+            }
+
+            sessionItems.Add(new SessionViewItem(
+                session.SessionId,
+                session.ScheduledAt,
+                session.Status,
+                session.MaxPlayers,
+                activePlayers.Count,
+                activePlayers,
+                waitlistedPlayers,
+                actions));
+        }
+
+        return new SessionBatchViewModel(title, sessionItems);
+    }
+
+    private static string GetJoinButtonText(SessionBatchDto session, int activePlayers, string dateTitle)
+    {
+        if (session.MaxPlayers.HasValue && activePlayers >= session.MaxPlayers.Value)
+        {
+            return $"⏳ В лист ожидания {dateTitle}";
+        }
+
+        return $"✋ На {dateTitle}";
+    }
+}
+// trigger pr

src/GmRelay.Shared/Rendering/SessionBatchViewModel.cs

@@ -0,0 +1,27 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Shared.Rendering;
+
+public sealed record SessionBatchViewModel(
+    string Title,
+    IReadOnlyList<SessionViewItem> Sessions);
+
+public sealed record SessionViewItem(
+    Guid SessionId,
+    DateTime ScheduledAt,
+    string Status,
+    int? MaxPlayers,
+    int ActivePlayerCount,
+    IReadOnlyList<PlayerViewItem> ActivePlayers,
+    IReadOnlyList<PlayerViewItem> WaitlistedPlayers,
+    IReadOnlyList<AvailableAction> AvailableActions);
+
+public sealed record PlayerViewItem(
+    string DisplayName,
+    string? TelegramUsername,
+    string RegistrationStatus);
+
+public sealed record AvailableAction(
+    string ActionKey,
+    string Label,
+    Guid SessionId);

src/GmRelay.Web/Components/App.razor

@@ -1,14 +1,19 @@
-<!DOCTYPE html>
-<html lang="en">
+<!DOCTYPE html>
+<html lang="ru">
 
 <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="GM-Relay — панель управления для Мастеров Игры. Управляйте сессиями настольных ролевых игр через Telegram." />
+    <meta name="theme-color" content="#0a0e1a" />
     <base href="/" />
     <ResourcePreloader />
-    <link rel="stylesheet" href="@Assets["lib/bootstrap/dist/css/bootstrap.min.css"]" />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet" />
     <link rel="stylesheet" href="@Assets["app.css"]" />
     <link rel="stylesheet" href="@Assets["GmRelay.Web.styles.css"]" />
+    <script src="https://telegram.org/js/telegram-web-app.js"></script>
     <ImportMap />
     <link rel="icon" type="image/png" href="favicon.png" />
     <HeadOutlet @rendermode="InteractiveServer" />
@@ -18,6 +23,277 @@
     <Routes @rendermode="InteractiveServer" />
     <ReconnectModal />
     <script src="@Assets["_framework/blazor.web.js"]"></script>
+    <script>
+        window.waitForTelegramMiniApp = async function (timeoutMs) {
+            var deadline = Date.now() + (timeoutMs || 3000);
+
+            while (Date.now() <= deadline) {
+                if (window.Telegram && window.Telegram.WebApp) {
+                    return window.Telegram.WebApp;
+                }
+
+                await new Promise(function (resolve) {
+                    setTimeout(resolve, 100);
+                });
+            }
+
+            return null;
+        };
+
+        window.waitForTelegramMiniAppInitData = async function (timeoutMs) {
+            var deadline = Date.now() + (timeoutMs || 3000);
+
+            while (Date.now() <= deadline) {
+                if (window.Telegram && window.Telegram.WebApp && window.Telegram.WebApp.initData) {
+                    return window.Telegram.WebApp;
+                }
+
+                await new Promise(function (resolve) {
+                    setTimeout(resolve, 100);
+                });
+            }
+
+            return null;
+        };
+
+        window.syncTelegramMiniAppViewport = function (webApp) {
+            if (!webApp) {
+                return;
+            }
+
+            var root = document.documentElement;
+            var safeArea = webApp.safeAreaInset || {};
+            var contentSafeArea = webApp.contentSafeAreaInset || {};
+            var setPx = function (name, value) {
+                root.style.setProperty(name, Math.max(0, Number(value) || 0) + 'px');
+            };
+
+            setPx('--gm-tg-safe-top', safeArea.top);
+            setPx('--gm-tg-safe-right', safeArea.right);
+            setPx('--gm-tg-safe-bottom', safeArea.bottom);
+            setPx('--gm-tg-safe-left', safeArea.left);
+            setPx('--gm-tg-content-safe-top', contentSafeArea.top);
+            setPx('--gm-tg-content-safe-right', contentSafeArea.right);
+            setPx('--gm-tg-content-safe-bottom', contentSafeArea.bottom);
+            setPx('--gm-tg-content-safe-left', contentSafeArea.left);
+
+            if (webApp.viewportHeight) {
+                root.style.setProperty('--gm-tg-viewport-height', webApp.viewportHeight + 'px');
+            }
+        };
+
+        window.prepareTelegramMiniApp = function (webApp) {
+            if (!webApp) {
+                return;
+            }
+
+            document.body.classList.add('telegram-mini-app');
+            window.syncTelegramMiniAppViewport(webApp);
+
+            try {
+                webApp.ready();
+            } catch (error) {
+            }
+
+            try {
+                webApp.expand();
+            } catch (error) {
+            }
+
+            if (webApp.onEvent && !window.gmRelayTelegramMiniAppViewportEventsRegistered) {
+                window.gmRelayTelegramMiniAppViewportEventsRegistered = true;
+                webApp.onEvent('safeAreaChanged', function () {
+                    window.syncTelegramMiniAppViewport(webApp);
+                });
+                webApp.onEvent('contentSafeAreaChanged', function () {
+                    window.syncTelegramMiniAppViewport(webApp);
+                });
+                webApp.onEvent('viewportChanged', function () {
+                    window.syncTelegramMiniAppViewport(webApp);
+                });
+            }
+        };
+
+        (async function () {
+            var webApp = await window.waitForTelegramMiniApp(1000);
+            window.prepareTelegramMiniApp(webApp);
+        })();
+
+        window.loadTelegramWidget = function (botUsername, authUrl) {
+            var container = document.getElementById('telegram-login-container');
+            if (!container) return;
+            container.innerHTML = '';
+            window.gmRelayTelegramLoginAuthUrl = authUrl || '/auth/telegram-login';
+            var script = document.createElement('script');
+            script.async = true;
+            script.src = 'https://telegram.org/js/telegram-widget.js?22';
+            script.setAttribute('data-telegram-login', botUsername);
+            script.setAttribute('data-size', 'large');
+            script.setAttribute('data-onauth', 'window.handleTelegramLogin(user)');
+            script.setAttribute('data-request-access', 'write');
+            container.appendChild(script);
+        };
+
+        window.handleTelegramLogin = async function (user) {
+            if (!user) {
+                window.location.href = '/login?error=auth_failed';
+                return;
+            }
+
+            try {
+                var response = await fetch(window.gmRelayTelegramLoginAuthUrl || '/auth/telegram-login', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'same-origin',
+                    cache: 'no-store',
+                    body: JSON.stringify(user)
+                });
+
+                if (!response.ok) {
+                    window.location.href = '/login?error=auth_failed';
+                    return;
+                }
+
+                var payload = await response.json();
+                window.location.href = payload.redirectUrl || '/';
+            } catch (error) {
+                window.location.href = '/login?error=auth_failed';
+            }
+        };
+
+        window.watchTelegramMiniAppLogin = function (statusUrl, redirectUrl, reloadOnReturn) {
+            window.gmRelayMiniAppLoginReloadOnReturn =
+                window.gmRelayMiniAppLoginReloadOnReturn || reloadOnReturn === true;
+
+            if (window.gmRelayMiniAppLoginWatcher) {
+                return;
+            }
+
+            window.gmRelayMiniAppLoginLeftPage = false;
+
+            var stopWatching = function () {
+                if (window.gmRelayMiniAppLoginWatcher) {
+                    window.clearInterval(window.gmRelayMiniAppLoginWatcher);
+                    window.gmRelayMiniAppLoginWatcher = null;
+                }
+            };
+
+            var reloadAfterExternalLogin = function () {
+                if (!window.gmRelayMiniAppLoginReloadOnReturn || !window.gmRelayMiniAppLoginLeftPage) {
+                    return;
+                }
+
+                window.gmRelayMiniAppLoginLeftPage = false;
+
+                try {
+                    var refreshKey = 'gmrelay-miniapp-login-refresh:' + window.location.pathname;
+                    if (window.sessionStorage && window.sessionStorage.getItem(refreshKey) === '1') {
+                        return;
+                    }
+
+                    if (window.sessionStorage) {
+                        window.sessionStorage.setItem(refreshKey, '1');
+                    }
+                } catch (error) {
+                }
+
+                window.location.reload();
+            };
+
+            var allowNextExternalLoginReload = function () {
+                window.gmRelayMiniAppLoginLeftPage = true;
+
+                try {
+                    var refreshKey = 'gmrelay-miniapp-login-refresh:' + window.location.pathname;
+                    if (window.sessionStorage) {
+                        window.sessionStorage.removeItem(refreshKey);
+                    }
+                } catch (error) {
+                }
+            };
+
+            var checkLogin = async function (reloadWhenUnauthenticated) {
+                try {
+                    var response = await fetch(statusUrl, {
+                        credentials: 'same-origin',
+                        cache: 'no-store'
+                    });
+
+                    if (!response.ok) {
+                        return;
+                    }
+
+                    var payload = await response.json();
+                    if (payload.authenticated) {
+                        stopWatching();
+                        window.location.href = redirectUrl || '/';
+                        return;
+                    }
+
+                    if (reloadWhenUnauthenticated) {
+                        reloadAfterExternalLogin();
+                    }
+                } catch (error) {
+                    return;
+                }
+            };
+
+            window.gmRelayMiniAppLoginWatcher = window.setInterval(checkLogin, 1000);
+            window.addEventListener('blur', function () {
+                allowNextExternalLoginReload();
+            });
+            window.addEventListener('focus', function () {
+                void checkLogin(true);
+            });
+            document.addEventListener('visibilitychange', function () {
+                if (document.hidden) {
+                    allowNextExternalLoginReload();
+                    return;
+                }
+
+                void checkLogin(true);
+            });
+
+            void checkLogin(false);
+        };
+
+        window.authenticateTelegramMiniApp = async function (authUrl, redirectUrl) {
+            var webApp = await window.waitForTelegramMiniApp(3000);
+            if (!webApp) {
+                return { authenticated: false, reason: 'telegram-webapp-missing' };
+            }
+
+            window.prepareTelegramMiniApp(webApp);
+
+            if (!webApp.initData) {
+                return { authenticated: false, reason: 'telegram-init-data-empty' };
+            }
+
+            try {
+                var response = await fetch(authUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'same-origin',
+                    cache: 'no-store',
+                    body: JSON.stringify({ initData: webApp.initData })
+                });
+
+                if (!response.ok) {
+                    return {
+                        authenticated: false,
+                        reason: 'telegram-auth-failed',
+                        status: response.status
+                    };
+                }
+
+                var payload = await response.json();
+                window.location.href = payload.redirectUrl || redirectUrl || '/';
+                return { authenticated: true, redirectUrl: payload.redirectUrl || redirectUrl || '/' };
+            } catch (error) {
+                return { authenticated: false, reason: 'telegram-auth-failed' };
+            }
+        };
+    </script>
 </body>
 
 </html>

src/GmRelay.Web/Components/Layout/MainLayout.razor

@@ -1,19 +1,15 @@
-@inherits LayoutComponentBase
+@inherits LayoutComponentBase
 
 <div class="page">
-    <div class="sidebar">
+    <aside class="sidebar">
         <NavMenu />
-    </div>
+    </aside>
 
-    <main>
-        <div class="top-row px-4">
-            <a href="https://github.com/Toutsu/GmRelayBot" target="_blank">О проекте</a>
-        </div>
-
-        <article class="content px-4">
+    <div class="main-area">
+        <article class="content">
             @Body
         </article>
-    </main>
+    </div>
 </div>
 
 <div id="blazor-error-ui" data-nosnippet>

src/GmRelay.Web/Components/Layout/MainLayout.razor.css

@@ -1,86 +1,39 @@
 .page {
-    position: relative;
     display: flex;
-    flex-direction: column;
-}
-
-main {
-    flex: 1;
+    min-height: 100vh;
 }
 
 .sidebar {
-    background-image: linear-gradient(180deg, rgb(5, 39, 103) 0%, #3a0647 70%);
-}
-
-.top-row {
-    background-color: #f7f7f7;
-    border-bottom: 1px solid #d6d5d5;
-    justify-content: flex-end;
-    height: 3.5rem;
+    width: var(--sidebar-width);
+    background: linear-gradient(180deg, #0f1629 0%, #1a0a2e 100%);
+    border-right: 1px solid var(--border-color);
+    position: fixed;
+    top: 0;
+    left: 0;
+    height: 100vh;
+    z-index: 100;
     display: flex;
-    align-items: center;
+    flex-direction: column;
+    transition: transform var(--transition-smooth);
 }
 
-    .top-row ::deep a, .top-row ::deep .btn-link {
-        white-space: nowrap;
-        margin-left: 1.5rem;
-        text-decoration: none;
-    }
-
-    .top-row ::deep a:hover, .top-row ::deep .btn-link:hover {
-        text-decoration: underline;
-    }
-
-    .top-row ::deep a:first-child {
-        overflow: hidden;
-        text-overflow: ellipsis;
-    }
-
-@media (max-width: 640.98px) {
-    .top-row {
-        justify-content: space-between;
-    }
-
-    .top-row ::deep a, .top-row ::deep .btn-link {
-        margin-left: 0;
-    }
+.main-area {
+    flex: 1;
+    margin-left: var(--sidebar-width);
+    min-height: 100vh;
 }
 
-@media (min-width: 641px) {
-    .page {
-        flex-direction: row;
-    }
-
-    .sidebar {
-        width: 250px;
-        height: 100vh;
-        position: sticky;
-        top: 0;
-    }
-
-    .top-row {
-        position: sticky;
-        top: 0;
-        z-index: 1;
-    }
-
-    .top-row.auth ::deep a:first-child {
-        flex: 1;
-        text-align: right;
-        width: 0;
-    }
-
-    .top-row, article {
-        padding-left: 2rem !important;
-        padding-right: 1.5rem !important;
-    }
+.content {
+    padding: 1.5rem 2rem;
+    max-width: 100%;
 }
 
+/* === Error UI === */
 #blazor-error-ui {
-    color-scheme: light only;
-    background: lightyellow;
+    background: var(--bg-secondary);
+    border-top: 1px solid var(--border-color);
     bottom: 0;
-    box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2);
+    box-shadow: 0 -4px 16px rgba(0, 0, 0, 0.3);
     box-sizing: border-box;
     display: none;
     left: 0;
@@ -88,11 +41,49 @@ main {
     position: fixed;
     width: 100%;
     z-index: 1000;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
 }
 
+    #blazor-error-ui .reload {
+        color: var(--accent-secondary);
+        margin-left: 0.5rem;
+    }
+
     #blazor-error-ui .dismiss {
         cursor: pointer;
         position: absolute;
         right: 0.75rem;
         top: 0.5rem;
     }
+
+/* === Mobile Responsive === */
+@media (max-width: 768px) {
+    .sidebar {
+        transform: none;
+        width: 100%;
+        height: auto;
+        min-height: 0;
+        position: sticky;
+        border-right: none;
+        border-bottom: 1px solid var(--border-color);
+    }
+
+    .page {
+        display: block;
+    }
+
+    .main-area {
+        margin-left: 0;
+    }
+
+    .content {
+        padding: 1rem;
+    }
+}
+
+@media (min-width: 769px) and (max-width: 1024px) {
+    .content {
+        padding: 1.25rem 1.5rem;
+    }
+}

src/GmRelay.Web/Components/Layout/NavMenu.razor

@@ -1,41 +1,82 @@
-<div class="top-row ps-3 navbar navbar-dark">
-    <div class="container-fluid">
-        <a class="navbar-brand" href="">GM-Relay Web</a>
-    </div>
+@inject NavigationManager Navigation
+
+<div class="nav-header">
+    <a class="nav-brand" href="">
+        <span class="nav-brand-icon">🐢</span>
+        <span class="nav-brand-text">GM-Relay</span>
+    </a>
+    <button class="nav-toggle" @onclick="ToggleMenu" aria-label="Переключить меню">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <line x1="3" y1="6" x2="21" y2="6"/>
+            <line x1="3" y1="12" x2="21" y2="12"/>
+            <line x1="3" y1="18" x2="21" y2="18"/>
+        </svg>
+    </button>
 </div>
 
-<input type="checkbox" title="Навигационное меню" class="navbar-toggler" />
+<nav class="nav-body @(isOpen ? "open" : "")">
+    <AuthorizeView>
+        <Authorized>
+            <div class="nav-section">
+                <NavLink class="nav-item" href="" Match="NavLinkMatch.All" @onclick="CloseMenu">
+                    <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>
+                        <polyline points="9 22 9 12 15 12 15 22"/>
+                    </svg>
+                    Главная страница
+                </NavLink>
+                <NavLink class="nav-item" href="templates" @onclick="CloseMenu">
+                    <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <rect x="3" y="4" width="18" height="16" rx="2"/>
+                        <path d="M7 8h10"/>
+                        <path d="M7 12h6"/>
+                        <path d="M7 16h8"/>
+                    </svg>
+                    Шаблоны
+                </NavLink>
+            </div>
 
-<div class="nav-scrollable" onclick="document.querySelector('.navbar-toggler').click()">
-    <nav class="nav flex-column">
-        <AuthorizeView>
-            <Authorized>
-                <div class="nav-item px-3">
-                    <NavLink class="nav-link" href="" Match="NavLinkMatch.All">
-                        <span class="bi bi-house-door-fill-nav-menu" aria-hidden="true"></span> Панель управления
-                    </NavLink>
-                </div>
-                <div class="nav-item px-3 mt-auto">
-                    <div class="nav-link text-light">
-                        <span class="bi bi-person-fill" aria-hidden="true"></span> @context.User.Identity?.Name
+            <div class="nav-footer">
+                <div class="nav-user">
+                    <div class="nav-user-avatar">
+                        @(context.User.Identity?.Name?.Substring(0, 1).ToUpper() ?? "?")
                     </div>
+                    <span class="nav-user-name">@context.User.Identity?.Name</span>
                 </div>
-                <div class="nav-item px-3">
-                    <form action="/auth/logout" method="post">
-                        <AntiforgeryToken />
-                        <button type="submit" class="nav-link btn btn-link text-light text-start w-100 p-0 shadow-none border-0">
-                            <span class="bi bi-box-arrow-right" aria-hidden="true"></span> Выйти
-                        </button>
-                    </form>
-                </div>
-            </Authorized>
-            <NotAuthorized>
-                <div class="nav-item px-3">
-                    <NavLink class="nav-link" href="login">
-                        <span class="bi bi-person-badge-nav-menu" aria-hidden="true"></span> Войти
-                    </NavLink>
-                </div>
-            </NotAuthorized>
-        </AuthorizeView>
-    </nav>
-</div>
+
+                <form action="/auth/logout" method="post">
+                    <AntiforgeryToken />
+                    <button type="submit" class="nav-logout-btn">
+                        <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                            <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1-2 2h4"/>
+                            <polyline points="16 17 21 12 16 7"/>
+                            <line x1="21" y1="12" x2="9" y2="12"/>
+                        </svg>
+                        Выход
+                    </button>
+                </form>
+
+                <div class="nav-version">v1.10.1</div>
+            </div>
+        </Authorized>
+        <NotAuthorized>
+            <div class="nav-section">
+                <NavLink class="nav-item" href="login" @onclick="CloseMenu">
+                    <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                        <path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"/>
+                        <polyline points="10 17 15 12 10 7"/>
+                        <line x1="15" y1="12" x2="3" y2="12"/>
+                    </svg>
+                    Вход
+                </NavLink>
+            </div>
+        </NotAuthorized>
+    </AuthorizeView>
+</nav>
+
+@code {
+    private bool isOpen;
+
+    private void ToggleMenu() => isOpen = !isOpen;
+    private void CloseMenu() => isOpen = false;
+}

src/GmRelay.Web/Components/Layout/NavMenu.razor.css

@@ -1,105 +1,198 @@
-.navbar-toggler {
-    appearance: none;
+/* === Nav Header === */
+.nav-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 1.25rem 1rem;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.nav-brand {
+    display: flex;
+    align-items: center;
+    gap: 0.625rem;
+    text-decoration: none;
+    color: var(--text-primary);
+}
+
+.nav-brand-icon {
+    font-size: 1.5rem;
+}
+
+.nav-brand-text {
+    font-size: 1.125rem;
+    font-weight: 700;
+    background: var(--accent-gradient);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.nav-toggle {
+    display: none;
+    background: none;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    color: var(--text-secondary);
+    padding: 0.375rem;
     cursor: pointer;
-    width: 3.5rem;
-    height: 2.5rem;
+    transition: all var(--transition-fast);
+}
+
+.nav-toggle:hover {
+    background: var(--bg-surface);
+    color: var(--text-primary);
+}
+
+/* === Nav Body === */
+.nav-body {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    padding: 0.75rem 0;
+    overflow-y: auto;
+}
+
+.nav-section {
+    padding: 0 0.75rem;
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+/* === Nav Items === */
+.nav-section ::deep .nav-item {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.625rem 0.875rem;
+    border-radius: var(--radius-sm);
+    color: var(--text-secondary);
+    text-decoration: none;
+    font-size: 0.875rem;
+    font-weight: 500;
+    transition: all var(--transition-normal);
+    white-space: nowrap;
+    box-sizing: border-box;
+}
+
+.nav-section ::deep .nav-item:hover {
+    background: rgba(255, 255, 255, 0.06);
+    color: var(--text-primary);
+}
+
+.nav-section ::deep .nav-item.active {
+    background: rgba(124, 58, 237, 0.15);
+    color: var(--accent-primary);
+    border: 1px solid rgba(124, 58, 237, 0.2);
+}
+
+.nav-icon {
+    width: 1.125rem;
+    height: 1.125rem;
+    flex-shrink: 0;
+}
+
+/* === Nav Footer === */
+.nav-footer {
+    padding: 0.75rem;
+    border-top: 1px solid var(--border-color);
+    margin-top: auto;
+}
+
+.nav-user {
+    display: flex;
+    align-items: center;
+    gap: 0.625rem;
+    padding: 0.5rem 0.5rem 0.75rem;
+}
+
+.nav-user-avatar {
+    width: 2rem;
+    height: 2rem;
+    border-radius: 50%;
+    background: var(--accent-gradient);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.8125rem;
+    font-weight: 700;
     color: white;
-    position: absolute;
-    top: 0.5rem;
-    right: 1rem;
-    border: 1px solid rgba(255, 255, 255, 0.1);
-    background: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e") no-repeat center/1.75rem rgba(255, 255, 255, 0.1);
+    flex-shrink: 0;
 }
 
-.navbar-toggler:checked {
-    background-color: rgba(255, 255, 255, 0.5);
+.nav-user-name {
+    font-size: 0.8125rem;
+    font-weight: 500;
+    color: var(--text-primary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 
-.top-row {
-    min-height: 3.5rem;
-    background-color: rgba(0,0,0,0.4);
+.nav-logout-btn {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.5rem 0.875rem;
+    background: none;
+    border: 1px solid transparent;
+    border-radius: var(--radius-sm);
+    color: var(--text-muted);
+    font-family: 'Inter', sans-serif;
+    font-size: 0.8125rem;
+    cursor: pointer;
+    transition: all var(--transition-normal);
 }
 
-.navbar-brand {
-    font-size: 1.1rem;
+.nav-logout-btn:hover {
+    background: var(--status-danger-bg);
+    color: var(--status-danger);
+    border-color: rgba(239, 68, 68, 0.15);
 }
 
-.bi {
-    display: inline-block;
-    position: relative;
-    width: 1.25rem;
-    height: 1.25rem;
-    margin-right: 0.75rem;
-    top: -1px;
-    background-size: cover;
+.nav-version {
+    text-align: center;
+    font-size: 0.6875rem;
+    color: var(--text-muted);
+    padding-top: 0.5rem;
+    opacity: 0.6;
 }
 
-.bi-house-door-fill-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-house-door-fill' viewBox='0 0 16 16'%3E%3Cpath d='M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5Z'/%3E%3C/svg%3E");
-}
-
-.bi-plus-square-fill-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-plus-square-fill' viewBox='0 0 16 16'%3E%3Cpath d='M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm6.5 4.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3a.5.5 0 0 1 1 0z'/%3E%3C/svg%3E");
-}
-
-.bi-list-nested-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-list-nested' viewBox='0 0 16 16'%3E%3Cpath fill-rule='evenodd' d='M4.5 11.5A.5.5 0 0 1 5 11h10a.5.5 0 0 1 0 1H5a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 3 7h10a.5.5 0 0 1 0 1H3a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 1 3h10a.5.5 0 0 1 0 1H1a.5.5 0 0 1-.5-.5z'/%3E%3C/svg%3E");
-}
-
-.nav-item {
-    font-size: 0.9rem;
-    padding-bottom: 0.5rem;
-}
-
-    .nav-item:first-of-type {
-        padding-top: 1rem;
-    }
-
-    .nav-item:last-of-type {
-        padding-bottom: 1rem;
-    }
-
-    .nav-item ::deep .nav-link {
-        color: #d7d7d7;
-        background: none;
-        border: none;
-        border-radius: 4px;
-        height: 3rem;
+/* === Mobile === */
+@media (max-width: 768px) {
+    .nav-toggle {
         display: flex;
         align-items: center;
-        line-height: 3rem;
-        width: 100%;
+        justify-content: center;
+        position: fixed;
+        top: 0.75rem;
+        left: 0.75rem;
+        z-index: 200;
+        background: var(--bg-secondary);
+        border: 1px solid var(--border-color);
+        width: 2.5rem;
+        height: 2.5rem;
     }
 
-.nav-item ::deep a.active {
-    background-color: rgba(255,255,255,0.37);
-    color: white;
-}
-
-.nav-item ::deep .nav-link:hover {
-    background-color: rgba(255,255,255,0.1);
-    color: white;
-}
-
-.nav-scrollable {
-    display: none;
-}
-
-.navbar-toggler:checked ~ .nav-scrollable {
-    display: block;
-}
-
-@media (min-width: 641px) {
-    .navbar-toggler {
+    .nav-body {
         display: none;
     }
 
-    .nav-scrollable {
-        /* Never collapse the sidebar for wide screens */
-        display: block;
+    .nav-body.open {
+        display: flex;
+    }
 
-        /* Allow sidebar to scroll for tall menus */
-        height: calc(100vh - 3.5rem);
-        overflow-y: auto;
+    .nav-header {
+        padding-right: 0.75rem;
+    }
+}
+
+@media (min-width: 769px) {
+    .nav-body {
+        height: calc(100vh - 4.5rem);
     }
 }

src/GmRelay.Web/Components/Pages/AccessDenied.razor

@@ -0,0 +1,27 @@
+@page "/access-denied"
+
+<PageTitle>Доступ запрещен — GM-Relay</PageTitle>
+
+<div class="page-container">
+    <div class="glass-card" style="max-width: 640px;">
+        <div class="empty-state">
+            <div class="empty-state-icon">⛔</div>
+            <div class="empty-state-title">Доступ запрещен</div>
+            <p class="empty-state-text">Эта группа или сессия недоступна для вашей учётной записи.</p>
+            <a href="/" class="btn-gm btn-gm-primary">← На главную</a>
+        </div>
+    </div>
+</div>
+
+@code {
+    [CascadingParameter]
+    private HttpContext? HttpContext { get; set; }
+
+    protected override void OnInitialized()
+    {
+        if (HttpContext is not null && !HttpContext.Response.HasStarted)
+        {
+            HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
+        }
+    }
+}

src/GmRelay.Web/Components/Pages/CampaignTemplates.razor

@@ -0,0 +1,402 @@
+@page "/templates"
+@using GmRelay.Web.Services
+@using GmRelay.Shared.Domain
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
+@attribute [Authorize]
+@inject AuthorizedSessionService SessionService
+@inject AuthenticationStateProvider AuthStateProvider
+@inject NavigationManager Navigation
+
+<PageTitle>Шаблоны кампаний — GM-Relay</PageTitle>
+
+<div class="page-container">
+    <ul class="gm-breadcrumb animate-fade-in">
+        <li><a href="/">Главная</a></li>
+        <li class="active">Шаблоны кампаний</li>
+    </ul>
+
+    <div class="page-header animate-fade-in">
+        <h2>📋 Шаблоны кампаний</h2>
+        <p>Сохраняйте типовые кампании один раз и применяйте их на странице нужной группы.</p>
+    </div>
+
+    @if (!string.IsNullOrEmpty(errorMessage))
+    {
+        <div class="gm-alert gm-alert-danger" style="margin-bottom: 1rem;">
+            ⚠️ @errorMessage
+        </div>
+    }
+
+    @if (!string.IsNullOrEmpty(successMessage))
+    {
+        <div class="gm-alert gm-alert-success" style="margin-bottom: 1rem;">
+            ✅ @successMessage
+        </div>
+    }
+
+    @if (groups is null)
+    {
+        <div class="glass-card" style="padding: 2rem;">
+            <div class="skeleton skeleton-text" style="width: 80%; margin-bottom: 1rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 60%; margin-bottom: 0.75rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 70%;"></div>
+        </div>
+    }
+    else if (groups.Count == 0)
+    {
+        <div class="glass-card">
+            <div class="empty-state">
+                <div class="empty-state-icon">🤖</div>
+                <div class="empty-state-title">Нет доступных групп</div>
+                <p class="empty-state-text">Добавьте бота GM-Relay в группу Telegram, чтобы создать первый шаблон кампании.</p>
+            </div>
+        </div>
+    }
+    else
+    {
+        <div class="glass-card campaign-template-panel animate-slide-up">
+            <div class="batch-bulk-header">
+                <div>
+                    <h3>Группа для шаблонов</h3>
+                    <p>@(SelectedGroup?.Name ?? "Выберите группу")</p>
+                </div>
+                @if (SelectedGroup is not null)
+                {
+                    <span class="status-badge @(SelectedGroup.ManagerRole == GroupManagerRoleExtensions.OwnerValue ? "status-success" : "status-info")">
+                        @FormatRole(SelectedGroup.ManagerRole)
+                    </span>
+                }
+            </div>
+
+            <div class="template-group-selector">
+                <select value="@selectedGroupId" @onchange="OnSelectedGroupChanged" class="gm-form-control">
+                    @foreach (var group in groups)
+                    {
+                        <option value="@group.Id">@group.Name</option>
+                    }
+                </select>
+                @if (SelectedGroup is not null)
+                {
+                    <a href="/group/@SelectedGroup.Id" class="btn-gm btn-gm-outline">Открыть группу →</a>
+                }
+            </div>
+        </div>
+
+        <div class="glass-card campaign-template-panel animate-slide-up">
+            <div class="batch-bulk-header">
+                <div>
+                    <h3>Новый шаблон</h3>
+                    <p>Эти параметры будут использоваться при запуске batch из группы.</p>
+                </div>
+                <span class="status-badge status-info">Template</span>
+            </div>
+
+            <EditForm Model="@templateModel" OnValidSubmit="CreateCampaignTemplate">
+                <div class="campaign-template-fields">
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Название шаблона</label>
+                        <InputText @bind-Value="templateModel.Name" class="gm-form-control" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Название кампании</label>
+                        <InputText @bind-Value="templateModel.Title" class="gm-form-control" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Ссылка</label>
+                        <InputText @bind-Value="templateModel.JoinLink" class="gm-form-control" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Игр</label>
+                        <InputNumber @bind-Value="templateModel.SessionCount" class="gm-form-control" min="1" max="52" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Интервал, дней</label>
+                        <InputNumber @bind-Value="templateModel.IntervalDays" class="gm-form-control" min="1" max="365" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Мест</label>
+                        <InputNumber @bind-Value="templateModel.MaxPlayers" class="gm-form-control" min="1" />
+                    </div>
+                    <div class="gm-form-group">
+                        <label class="gm-form-label">Уведомления</label>
+                        <select @bind="templateModel.NotificationMode" class="gm-form-control">
+                            <option value="@SessionNotificationModeExtensions.GroupAndDirectValue">В группе и в личку</option>
+                            <option value="@SessionNotificationModeExtensions.GroupOnlyValue">Только в группе</option>
+                        </select>
+                    </div>
+                </div>
+
+                <button type="submit" class="btn-gm btn-gm-primary" disabled="@isCreatingTemplate">
+                    @(isCreatingTemplate ? "⏳ Сохраняем..." : "💾 Сохранить шаблон")
+                </button>
+            </EditForm>
+        </div>
+
+        <div class="glass-card campaign-template-panel animate-slide-up">
+            <div class="batch-bulk-header">
+                <div>
+                    <h3>Сохранённые шаблоны</h3>
+                    <p>@campaignTemplateModels.Count для выбранной группы</p>
+                </div>
+                <span class="status-badge status-info">@campaignTemplateModels.Count</span>
+            </div>
+
+            @if (campaignTemplates is null)
+            {
+                <div class="skeleton skeleton-text" style="width: 70%; margin-bottom: 0.75rem;"></div>
+                <div class="skeleton skeleton-text" style="width: 55%;"></div>
+            }
+            else if (campaignTemplateModels.Count == 0)
+            {
+                <div class="empty-state empty-state-compact">
+                    <div class="empty-state-title">Шаблонов пока нет</div>
+                    <p class="empty-state-text">Создайте первый шаблон для выбранной группы.</p>
+                </div>
+            }
+            else
+            {
+                <div class="campaign-template-list">
+                    @foreach (var template in campaignTemplateModels)
+                    {
+                        <div class="campaign-template-row template-management-row">
+                            <div class="campaign-template-info">
+                                <h3>@template.Name</h3>
+                                <p>@FormatTemplateSummary(template)</p>
+                            </div>
+                            <div class="template-management-actions">
+                                <span class="status-badge status-neutral">@FormatLocalMoscow(template.UpdatedAt.ToMoscow())</span>
+                                <button type="button" class="btn-gm btn-gm-danger" disabled="@(deletingTemplateId == template.Id)" @onclick="() => DeleteCampaignTemplate(template)">
+                                    @(deletingTemplateId == template.Id ? "⏳ Удаляем..." : "Удалить")
+                                </button>
+                            </div>
+                        </div>
+                    }
+                </div>
+            }
+        </div>
+    }
+</div>
+
+@code {
+    private List<WebGameGroup>? groups;
+    private List<WebCampaignTemplate>? campaignTemplates;
+    private List<CampaignTemplateManagementModel> campaignTemplateModels = [];
+    private Guid selectedGroupId;
+    private Guid? deletingTemplateId;
+    private bool isCreatingTemplate;
+    private long telegramId;
+    private string? errorMessage;
+    private string? successMessage;
+    private CampaignTemplateEditModel templateModel = new();
+
+    private WebGameGroup? SelectedGroup => groups?.FirstOrDefault(group => group.Id == selectedGroupId);
+
+    protected override async Task OnInitializedAsync()
+    {
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        if (!authState.User.TryGetTelegramId(out telegramId))
+        {
+            Navigation.NavigateTo("/access-denied");
+            return;
+        }
+
+        groups = await SessionService.GetGroupsForGmAsync(telegramId);
+        selectedGroupId = groups.FirstOrDefault()?.Id ?? Guid.Empty;
+
+        if (selectedGroupId != Guid.Empty)
+        {
+            await LoadTemplates();
+        }
+    }
+
+    private async Task OnSelectedGroupChanged(ChangeEventArgs args)
+    {
+        if (!Guid.TryParse(args.Value?.ToString(), out var groupId))
+        {
+            return;
+        }
+
+        selectedGroupId = groupId;
+        errorMessage = null;
+        successMessage = null;
+        await LoadTemplates();
+    }
+
+    private async Task LoadTemplates()
+    {
+        campaignTemplates = null;
+        campaignTemplateModels = [];
+
+        var templates = await SessionService.GetCampaignTemplatesForGmAsync(selectedGroupId, telegramId);
+        if (templates is null)
+        {
+            Navigation.NavigateTo("/access-denied");
+            return;
+        }
+
+        campaignTemplates = templates;
+        RebuildCampaignTemplateModels();
+    }
+
+    private async Task CreateCampaignTemplate()
+    {
+        errorMessage = null;
+        successMessage = null;
+
+        if (selectedGroupId == Guid.Empty)
+        {
+            errorMessage = "Выберите группу для шаблона.";
+            return;
+        }
+
+        if (!ValidateCampaignTemplate(templateModel))
+        {
+            errorMessage = "Шаблон должен иметь название, ссылку, 1-52 игр, шаг 1-365 дней и положительный лимит мест, если он указан.";
+            return;
+        }
+
+        isCreatingTemplate = true;
+
+        try
+        {
+            await SessionService.CreateCampaignTemplateForGmAsync(
+                selectedGroupId,
+                telegramId,
+                new CreateCampaignTemplateRequest(
+                    templateModel.Name,
+                    templateModel.Title,
+                    templateModel.JoinLink,
+                    templateModel.SessionCount,
+                    templateModel.IntervalDays,
+                    templateModel.MaxPlayers,
+                    SessionNotificationModeExtensions.FromDatabaseValue(templateModel.NotificationMode)));
+
+            templateModel = new();
+            successMessage = "Шаблон кампании сохранён.";
+            await LoadTemplates();
+        }
+        catch (SessionAccessDeniedException)
+        {
+            Navigation.NavigateTo("/access-denied");
+        }
+        catch (Exception ex)
+        {
+            errorMessage = "Не удалось сохранить шаблон: " + ex.Message;
+        }
+        finally
+        {
+            isCreatingTemplate = false;
+        }
+    }
+
+    private async Task DeleteCampaignTemplate(CampaignTemplateManagementModel template)
+    {
+        errorMessage = null;
+        successMessage = null;
+        deletingTemplateId = template.Id;
+
+        try
+        {
+            await SessionService.DeleteCampaignTemplateForGmAsync(template.Id, telegramId);
+            successMessage = "Шаблон кампании удалён.";
+            await LoadTemplates();
+        }
+        catch (SessionAccessDeniedException)
+        {
+            Navigation.NavigateTo("/access-denied");
+        }
+        catch (Exception ex)
+        {
+            errorMessage = "Не удалось удалить шаблон: " + ex.Message;
+        }
+        finally
+        {
+            deletingTemplateId = null;
+        }
+    }
+
+    private void RebuildCampaignTemplateModels()
+    {
+        campaignTemplateModels = campaignTemplates?
+            .OrderByDescending(template => template.UpdatedAt)
+            .ThenBy(template => template.Name)
+            .Select(template => new CampaignTemplateManagementModel
+            {
+                Id = template.Id,
+                Name = template.Name,
+                Title = template.Title,
+                JoinLink = template.JoinLink,
+                SessionCount = template.SessionCount,
+                IntervalDays = template.IntervalDays,
+                MaxPlayers = template.MaxPlayers,
+                NotificationMode = template.NotificationMode,
+                UpdatedAt = template.UpdatedAt
+            })
+            .ToList() ?? [];
+    }
+
+    private static bool ValidateCampaignTemplate(CampaignTemplateEditModel template)
+    {
+        template.Name = template.Name.Trim();
+        template.Title = template.Title.Trim();
+        template.JoinLink = template.JoinLink.Trim();
+
+        if (template.MaxPlayers.HasValue && template.MaxPlayers.Value <= 0)
+        {
+            return false;
+        }
+
+        return template.Name.Length > 0 &&
+               template.Title.Length > 0 &&
+               template.JoinLink.Length > 0 &&
+               template.SessionCount is >= 1 and <= 52 &&
+               template.IntervalDays is >= 1 and <= 365;
+    }
+
+    private static string FormatTemplateSummary(CampaignTemplateManagementModel template)
+    {
+        var seats = template.MaxPlayers.HasValue
+            ? $"{template.MaxPlayers.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)} мест"
+            : "без лимита";
+
+        return $"{template.Title} · {template.SessionCount} игр · каждые {template.IntervalDays} дн. · {seats} · {FormatNotificationMode(template.NotificationMode)}";
+    }
+
+    private static string FormatNotificationMode(string notificationMode) =>
+        SessionNotificationModeExtensions.FromDatabaseValue(notificationMode) switch
+        {
+            SessionNotificationMode.GroupOnly => "только группа",
+            _ => "группа и личка"
+        };
+
+    private static string FormatRole(string role) =>
+        GroupManagerRoleExtensions.FromDatabaseValue(role).ToDisplayName();
+
+    private static string FormatLocalMoscow(DateTime localMoscow) =>
+        localMoscow.ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"));
+
+    private sealed class CampaignTemplateEditModel
+    {
+        public string Name { get; set; } = "";
+        public string Title { get; set; } = "";
+        public string JoinLink { get; set; } = "";
+        public int SessionCount { get; set; } = 6;
+        public int IntervalDays { get; set; } = 7;
+        public int? MaxPlayers { get; set; }
+        public string NotificationMode { get; set; } = SessionNotificationModeExtensions.GroupAndDirectValue;
+    }
+
+    private sealed class CampaignTemplateManagementModel
+    {
+        public Guid Id { get; init; }
+        public string Name { get; init; } = "";
+        public string Title { get; init; } = "";
+        public string JoinLink { get; init; } = "";
+        public int SessionCount { get; init; }
+        public int IntervalDays { get; init; }
+        public int? MaxPlayers { get; init; }
+        public string NotificationMode { get; init; } = SessionNotificationModeExtensions.GroupAndDirectValue;
+        public DateTime UpdatedAt { get; init; }
+    }
+}

src/GmRelay.Web/Components/Pages/EditSession.razor

@@ -2,61 +2,77 @@
 @using GmRelay.Web.Services
 @using GmRelay.Shared.Domain
 @using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
 @attribute [Authorize]
-@inject SessionService SessionService
+@inject AuthorizedSessionService SessionService
+@inject AuthenticationStateProvider AuthStateProvider
 @inject NavigationManager Navigation
 
-<PageTitle>Редактирование сессии - GM-Relay</PageTitle>
+<PageTitle>Редактирование сессии — GM-Relay</PageTitle>
 
-<div class="container mt-4">
-    <nav aria-label="breadcrumb">
-      <ol class="breadcrumb">
-        <li class="breadcrumb-item"><a href="/">Главная</a></li>
-        <li class="breadcrumb-item active">Редактирование сессии</li>
-      </ol>
-    </nav>
+<div class="page-container">
+    <ul class="gm-breadcrumb animate-fade-in">
+        <li><a href="/">Главная</a></li>
+        <li class="active">Редактирование сессии</li>
+    </ul>
 
-    <h2>Редактирование сессии</h2>
+    <div class="page-header animate-fade-in">
+        <h2>✏️ Редактирование сессии</h2>
+    </div>
 
     @if (session == null)
     {
-        <p>Загрузка деталей сессии...</p>
+        <div class="glass-card" style="padding: 2rem;">
+            <div class="skeleton skeleton-text" style="width: 50%; margin-bottom: 1.5rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 100%; height: 2.5rem; margin-bottom: 1.5rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 50%; margin-bottom: 1.5rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 100%; height: 2.5rem; margin-bottom: 1.5rem;"></div>
+            <div class="skeleton skeleton-text" style="width: 30%; height: 2.5rem;"></div>
+        </div>
     }
     else
     {
-        <div class="card shadow-sm mt-4">
-            <div class="card-body">
-                <EditForm Model="@model" OnValidSubmit="HandleSubmit">
-                    <div class="mb-3">
-                        <label class="form-label font-weight-bold">Название игры</label>
-                        <InputText @bind-Value="model.Title" class="form-control" placeholder="например, D&D 5e: Dragon's Hoard" />
-                        <div class="form-text">Изменение этого поля обновит все сессии в одной группе.</div>
-                    </div>
+        <div class="glass-card animate-slide-up" style="max-width: 640px;">
+            <EditForm Model="@model" OnValidSubmit="HandleSubmit">
+                <div class="gm-form-group">
+                    <label class="gm-form-label">Название игры</label>
+                    <InputText @bind-Value="model.Title" class="gm-form-control" placeholder="например, D&D 5e: Dragon's Hoard" />
+                    <div class="gm-form-hint">Изменение этого поля обновит все сессии в одной группе.</div>
+                </div>
 
-                    <div class="mb-3">
-                        <label class="form-label font-weight-bold">Запланированное время (МСК UTC+3)</label>
-                        <input type="datetime-local" @bind="model.ScheduledAtLocal" class="form-control" />
-                        <div class="form-text">Текущее: @session.ScheduledAt.FormatMoscow()</div>
-                    </div>
+                <div class="gm-form-group">
+                    <label class="gm-form-label">Запланированное время (МСК, UTC+3)</label>
+                    <input type="datetime-local" @bind="model.ScheduledAtLocal" class="gm-form-control" />
+                    <div class="gm-form-hint">Текущее: @session.ScheduledAt.FormatMoscow()</div>
+                </div>
 
-                    <div class="mb-3">
-                        <label class="form-label font-weight-bold">Ссылка для подключения</label>
-                        <InputText @bind-Value="model.JoinLink" class="form-control" placeholder="Ссылка на Discord или VTT" />
-                    </div>
+                <div class="gm-form-group">
+                    <label class="gm-form-label">Ссылка для подключения</label>
+                    <InputText @bind-Value="model.JoinLink" class="gm-form-control" placeholder="Ссылка на Discord или VTT" />
+                </div>
 
-                    <div class="mt-4">
-                        <button type="submit" class="btn btn-success" disabled="@isSubmitting">
-                            @(isSubmitting ? "Сохранение..." : "Сохранить изменения")
-                        </button>
-                        <button type="button" class="btn btn-outline-secondary ms-2" @onclick="GoBack">Отмена</button>
-                    </div>
-                </EditForm>
-            </div>
+                <div class="gm-form-group">
+                    <label class="gm-form-label">Лимит мест</label>
+                    <InputNumber @bind-Value="model.MaxPlayers" class="gm-form-control" min="1" placeholder="Без лимита" />
+                    <div class="gm-form-hint">Пустое значение означает запись без лимита. Если лимит заполнен, новые игроки попадут в лист ожидания.</div>
+                </div>
+
+                <div style="display: flex; gap: 0.75rem; margin-top: 1.5rem;">
+                    <button type="submit" class="btn-gm btn-gm-success" disabled="@isSubmitting">
+                        @(isSubmitting ? "⏳ Сохранение..." : "✅ Сохранить изменения")
+                    </button>
+                    <button type="button" class="btn-gm btn-gm-outline" @onclick="GoBack">
+                        Отмена
+                    </button>
+                </div>
+            </EditForm>
         </div>
-        
+
         @if (!string.IsNullOrEmpty(errorMessage))
         {
-            <div class="alert alert-danger mt-3">@errorMessage</div>
+            <div class="gm-alert gm-alert-danger" style="margin-top: 1rem; max-width: 640px;">
+                ⚠️ @errorMessage
+            </div>
         }
     }
 </div>
@@ -65,19 +81,29 @@
     [Parameter] public Guid SessionId { get; set; }
     private WebSession? session;
     private SessionEditModel model = new();
-    private bool isSubmitting = false;
+    private bool isSubmitting;
     private string? errorMessage;
 
     protected override async Task OnInitializedAsync()
     {
-        session = await SessionService.GetSessionAsync(SessionId);
-        if (session != null)
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        if (!authState.User.TryGetTelegramId(out var telegramId))
         {
-            model.Title = session.Title;
-            // Convert UTC to Moscow for the picker
-            model.ScheduledAtLocal = session.ScheduledAt.ToMoscow();
-            model.JoinLink = session.JoinLink;
+            Navigation.NavigateTo("/access-denied");
+            return;
         }
+
+        session = await SessionService.GetSessionForGmAsync(SessionId, telegramId);
+        if (session is null)
+        {
+            Navigation.NavigateTo("/access-denied");
+            return;
+        }
+
+        model.Title = session.Title;
+        model.ScheduledAtLocal = session.ScheduledAt.ToMoscow();
+        model.JoinLink = session.JoinLink;
+        model.MaxPlayers = session.MaxPlayers;
     }
 
     private async Task HandleSubmit()
@@ -87,13 +113,22 @@
 
         try
         {
-            // The value from <input type="datetime-local"> is considered as "unspecified" or local to browser.
-            // We treat it as Moscow time (UTC+3) and convert to UTC.
+            var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+            if (!authState.User.TryGetTelegramId(out var telegramId))
+            {
+                Navigation.NavigateTo("/access-denied");
+                return;
+            }
+
             var utcTime = new DateTimeOffset(model.ScheduledAtLocal, TimeSpan.FromHours(3)).ToUniversalTime().UtcDateTime;
 
-            await SessionService.UpdateSessionAsync(SessionId, model.Title, utcTime, model.JoinLink);
+            await SessionService.UpdateSessionForGmAsync(SessionId, telegramId, model.Title, utcTime, model.JoinLink, model.MaxPlayers);
             Navigation.NavigateTo($"/group/{session!.GroupId}");
         }
+        catch (SessionAccessDeniedException)
+        {
+            Navigation.NavigateTo("/access-denied");
+        }
         catch (Exception ex)
         {
             errorMessage = "Не удалось сохранить изменения: " + ex.Message;
@@ -111,5 +146,6 @@
         public string Title { get; set; } = "";
         public DateTime ScheduledAtLocal { get; set; } = DateTime.Now;
         public string JoinLink { get; set; } = "";
+        public int? MaxPlayers { get; set; }
     }
 }

src/GmRelay.Web/Components/Pages/Error.razor

@@ -1,28 +1,26 @@
-@page "/Error"
+@page "/Error"
 @using System.Diagnostics
 
-<PageTitle>Ошибка</PageTitle>
+<PageTitle>Ошибка — GM-Relay</PageTitle>
 
-<h1 class="text-danger">Ошибка.</h1>
-<h2 class="text-danger">Произошла ошибка при обработке вашего запроса.</h2>
+<div class="page-container">
+    <div class="error-page">
+        <div class="error-page-icon">⚠️</div>
+        <h1 class="error-page-title">Произошла ошибка</h1>
+        <p class="error-page-text">При обработке вашего запроса что-то пошло не так. Пожалуйста, попробуйте снова.</p>
 
-@if (ShowRequestId)
-{
-    <p>
-        <strong>ID запроса:</strong> <code>@RequestId</code>
-    </p>
-}
+        @if (ShowRequestId)
+        {
+            <p style="font-size: 0.75rem; color: var(--text-muted); font-family: monospace;">
+                ID запроса: @RequestId
+            </p>
+        }
 
-<h3>Режим разработки</h3>
-<p>
-    Переключение на среду <strong>Development</strong> отобразит более подробную информацию о произошедшей ошибке.
-</p>
-<p>
-    <strong>Среда Development не должна быть включена для развернутых приложений.</strong>
-    Это может привести к отображению конфиденциальной информации из исключений конечным пользователям.
-    Для локальной отладки включите среду <strong>Development</strong>, установив переменную среды <strong>ASPNETCORE_ENVIRONMENT</strong> в значение <strong>Development</strong>
-    и перезапустите приложение.
-</p>
+        <a href="/" class="btn-gm btn-gm-primary" style="margin-top: 0.5rem;">
+            ← На главную
+        </a>
+    </div>
+</div>
 
 @code{
     [CascadingParameter]

src/GmRelay.Web/Components/Pages/GroupStats.razor

@@ -0,0 +1,235 @@
+@page "/group/{GroupId:guid}/stats"
+@using GmRelay.Web.Services
+@using GmRelay.Shared.Domain
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
+@using System.Security.Claims
+@attribute [Authorize]
+@inject ISessionStore SessionStore
+@inject AuthenticationStateProvider AuthStateProvider
+@inject NavigationManager Navigation
+
+<PageTitle>Статистика — GM-Relay</PageTitle>
+
+<div class="page-container">
+    <ul class="gm-breadcrumb animate-fade-in">
+        <li><a href="/">Главная</a></li>
+        <li><a href="/group/@GroupId">Сессии группы</a></li>
+        <li class="active">Статистика</li>
+    </ul>
+
+    <div class="page-header animate-fade-in">
+        <h2>📊 Статистика посещаемости</h2>
+        <p class="page-subtitle">Надёжность состава и качество расписания</p>
+    </div>
+
+    @if (!string.IsNullOrEmpty(errorMessage))
+    {
+        <div class="gm-alert gm-alert-danger" style="margin-bottom: 1rem;">
+            ⚠️ @errorMessage
+        </div>
+    }
+
+    @if (stats is null)
+    {
+        <div class="loading-spinner">⏳ Загружаем статистику…</div>
+    }
+    else if (stats.Count == 0)
+    {
+        <div class="empty-state">
+            <div class="empty-icon">📈</div>
+            <h3>Пока нет данных</h3>
+            <p>После первых сессий здесь появится аналитика.</p>
+        </div>
+    }
+    else
+    {
+        <div class="glass-card animate-slide-up" style="margin-bottom: 1rem;">
+            <div class="stats-summary" style="display: grid; grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); gap: 1rem; margin-bottom: 1.5rem;">
+                <div class="stat-card">
+                    <div class="stat-value">@stats.Count</div>
+                    <div class="stat-label">Игроков</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value">@TotalSessions</div>
+                    <div class="stat-label">Сессий</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value">@AvgAttendanceRate%</div>
+                    <div class="stat-label">Средняя посещаемость</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value">@topPlayer?.DisplayName</div>
+                    <div class="stat-label">Самый стабильный</div>
+                </div>
+            </div>
+
+            <div class="table-responsive">
+                <table class="gm-table" style="width: 100%;">
+                    <thead>
+                        <tr>
+                            <th @onclick="@(() => SortBy("player"))" style="cursor:pointer;" class="sortable">Игрок  @(sortColumn == "player" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("total"))" style="cursor:pointer; text-align:center;" class="sortable">Всего  @(sortColumn == "total" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("confirmed"))" style="cursor:pointer; text-align:center;" class="sortable">✅  @(sortColumn == "confirmed" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("declined"))" style="cursor:pointer; text-align:center;" class="sortable">❌  @(sortColumn == "declined" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("noresponse"))" style="cursor:pointer; text-align:center;" class="sortable">💤  @(sortColumn == "noresponse" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("waitlist"))" style="cursor:pointer; text-align:center;" class="sortable">⏳  @(sortColumn == "waitlist" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("rate"))" style="cursor:pointer; text-align:center;" class="sortable">%  @(sortColumn == "rate" ? (sortDesc ? "▼" : "▲") : "")</th>
+                            <th @onclick="@(() => SortBy("cancelled"))" style="cursor:pointer; text-align:center;" class="sortable">🚫  @(sortColumn == "cancelled" ? (sortDesc ? "▼" : "▲") : "")</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach (var s in sortedStats)
+                        {
+                            <tr>
+                                <td>
+                                    <div class="player-info">
+                                        <span class="player-name">@s.DisplayName</span>
+                                        @if (!string.IsNullOrEmpty(s.TelegramUsername))
+                                        {
+                                            <span class="player-username">@@@s.TelegramUsername</span>
+                                        }
+                                    </div>
+                                </td>
+                                <td style="text-align:center;">@s.TotalSessions</td>
+                                <td style="text-align:center;">@s.ConfirmedCount</td>
+                                <td style="text-align:center;">@s.DeclinedCount</td>
+                                <td style="text-align:center;">@s.NoResponseCount</td>
+                                <td style="text-align:center;">@s.WaitlistedCount</td>
+                                <td style="text-align:center;">
+                                    <span class="rate-badge @AttendanceBadgeClass(s.AttendanceRate)">
+                                        @s.AttendanceRate%
+                                    </span>
+                                </td>
+                                <td style="text-align:center;">@s.CancellationAffectedCount</td>
+                            </tr>
+                        }
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    }
+</div>
+
+<style>
+    .stat-card {
+        background: var(--card-bg-secondary, rgba(255,255,255,0.05));
+        border-radius: 0.75rem;
+        padding: 1rem;
+        text-align: center;
+    }
+    .stat-value {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: var(--accent-color, #7cb97a);
+    }
+    .stat-label {
+        font-size: 0.8rem;
+        color: var(--text-muted, #94a3b8);
+        margin-top: 0.25rem;
+    }
+    .player-info {
+        display: flex;
+        flex-direction: column;
+    }
+    .player-name {
+        font-weight: 500;
+    }
+    .player-username {
+        font-size: 0.8rem;
+        color: var(--text-muted, #94a3b8);
+    }
+    .rate-badge {
+        display: inline-block;
+        padding: 0.25rem 0.5rem;
+        border-radius: 0.5rem;
+        font-weight: 600;
+        font-size: 0.875rem;
+    }
+    .rate-excellent { background: rgba(34,197,94,0.15); color: #22c55e; }
+    .rate-good      { background: rgba(234,179,8,0.15); color: #eab308; }
+    .rate-poor      { background: rgba(239,68,68,0.15); color: #ef4444; }
+</style>
+
+@code {
+    [Parameter] public Guid GroupId { get; set; }
+    private List<PlayerAttendanceStats>? stats;
+    private List<PlayerAttendanceStats> sortedStats = new();
+    private string? errorMessage;
+    private string sortColumn = "confirmed";
+    private bool sortDesc = true;
+    private int TotalSessions => stats?.Count > 0 ? (int)(stats.Max(s => s.TotalSessions)) : 0;
+    private int AvgAttendanceRate => stats?.Count > 0 ? (int)(stats.Average(s => s.AttendanceRate)) : 0;
+    private PlayerAttendanceStats? topPlayer => stats?.OrderByDescending(s => s.AttendanceRate).ThenByDescending(s => s.ConfirmedCount).FirstOrDefault();
+
+    protected override async Task OnInitializedAsync()
+    {
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        var user = authState.User;
+        if (!user.Identity?.IsAuthenticated ?? true)
+        {
+            Navigation.NavigateTo("/login");
+            return;
+        }
+        var telegramIdClaim = user.FindFirst("telegram_id")?.Value
+            ?? user.FindFirst(ClaimTypes.NameIdentifier)?.Value;
+        if (!long.TryParse(telegramIdClaim, out var telegramId))
+        {
+            Navigation.NavigateTo("/login");
+            return;
+        }
+        try
+        {
+            if (!await SessionStore.IsGroupManagerAsync(GroupId, telegramId))
+            {
+                Navigation.NavigateTo("/access-denied");
+                return;
+            }
+            stats = await SessionStore.GetGroupAttendanceStatsAsync(GroupId) ?? new();
+            UpdateSortedStats();
+        }
+        catch (Exception ex)
+        {
+            errorMessage = $"Ошибка загрузки статистики: {ex.Message}";
+        }
+    }
+
+    private void SortBy(string column)
+    {
+        if (sortColumn == column)
+            sortDesc = !sortDesc;
+        else
+        {
+            sortColumn = column;
+            sortDesc = true;
+        }
+        UpdateSortedStats();
+    }
+
+    private void UpdateSortedStats()
+    {
+        if (stats is null) { sortedStats = new(); return; }
+        IOrderedEnumerable<PlayerAttendanceStats> ordered = sortColumn switch
+        {
+            "player" => sortDesc ? stats.OrderByDescending(s => s.DisplayName) : stats.OrderBy(s => s.DisplayName),
+            "total" => sortDesc ? stats.OrderByDescending(s => s.TotalSessions) : stats.OrderBy(s => s.TotalSessions),
+            "confirmed" => sortDesc ? stats.OrderByDescending(s => s.ConfirmedCount) : stats.OrderBy(s => s.ConfirmedCount),
+            "declined" => sortDesc ? stats.OrderByDescending(s => s.DeclinedCount) : stats.OrderBy(s => s.DeclinedCount),
+            "noresponse" => sortDesc ? stats.OrderByDescending(s => s.NoResponseCount) : stats.OrderBy(s => s.NoResponseCount),
+            "waitlist" => sortDesc ? stats.OrderByDescending(s => s.WaitlistedCount) : stats.OrderBy(s => s.WaitlistedCount),
+            "rate" => sortDesc ? stats.OrderByDescending(s => s.AttendanceRate) : stats.OrderBy(s => s.AttendanceRate),
+            "cancelled" => sortDesc ? stats.OrderByDescending(s => s.CancellationAffectedCount) : stats.OrderBy(s => s.CancellationAffectedCount),
+            _ => stats.OrderByDescending(s => s.ConfirmedCount)
+        };
+        sortedStats = ordered.ToList();
+    }
+
+    private string SortIndicator(string column) => sortColumn == column ? (sortDesc ? "▼" : "▲") : "";
+
+    private string AttendanceBadgeClass(decimal rate) => rate switch
+    {
+        >= 75m => "rate-excellent",
+        >= 50m => "rate-good",
+        _ => "rate-poor"
+    };
+}

src/GmRelay.Web/Components/Pages/Home.razor

@@ -1,50 +1,88 @@
 @page "/"
 @using Microsoft.AspNetCore.Authorization
 @using Microsoft.AspNetCore.Components.Authorization
+@using GmRelay.Shared.Domain
 @using GmRelay.Web.Services
 @attribute [Authorize]
-@inject SessionService SessionService
+@inject AuthorizedSessionService SessionService
 @inject AuthenticationStateProvider AuthStateProvider
+@inject NavigationManager Navigation
 
-<PageTitle>Панель управления - GM-Relay</PageTitle>
+<PageTitle>Панель управления — GM-Relay</PageTitle>
 
-<div class="container mt-4">
-    <h2>Добро пожаловать, @userName!</h2>
-    <p class="text-muted">Выберите группу для управления играми.</p>
+<div class="page-container">
+    <div class="page-header animate-fade-in">
+        <h2>Добро пожаловать, @userName! 👋</h2>
+        <p>Выберите группу для управления игровыми сессиями.</p>
+    </div>
 
-    <div class="row mt-4">
-        @if (groups == null)
-        {
-            <p>Загрузка групп...</p>
-        }
-        else if (groups.Count == 0)
-        {
-            <div class="col-12">
-                <div class="card bg-light">
-                    <div class="card-body text-center">
-                        <p class="mb-0">У вас еще нет зарегистрированных групп. Сначала добавьте бота в группу Telegram!</p>
-                    </div>
-                </div>
+    @if (groups == null)
+    {
+        <div class="card-grid">
+            @for (int i = 0; i < 3; i++)
+            {
+                <div class="skeleton skeleton-card"></div>
+            }
+        </div>
+    }
+    else if (groups.Count == 0)
+    {
+        <div class="glass-card">
+            <div class="empty-state">
+                <div class="empty-state-icon">🤖</div>
+                <div class="empty-state-title">Нет зарегистрированных групп</div>
+                <p class="empty-state-text">Добавьте бота GM-Relay в свою группу Telegram, чтобы начать управлять игровыми сессиями.</p>
             </div>
-        }
-        else
-        {
+        </div>
+    }
+    else
+    {
+        <div class="card-grid stagger-children">
             @foreach (var group in groups)
             {
-                <div class="col-md-4 mb-3">
-                    <div class="card h-100 shadow-sm">
-                        <div class="card-body">
-                            <h5 class="card-title">@group.Name</h5>
-                            <p class="card-text text-muted">ID: @group.TelegramChatId</p>
-                            <a href="/group/@group.Id" class="btn btn-primary">Посмотреть игры</a>
-                        </div>
-                    </div>
+                <div class="glass-card group-card">
+                    <div class="group-card-icon">🎮</div>
+                    <h3 class="group-card-title">@group.Name</h3>
+                    <p class="group-card-id">ID: @group.TelegramChatId</p>
+                    <span class="status-badge @(group.ManagerRole == GroupManagerRoleExtensions.OwnerValue ? "status-success" : "status-info")" style="align-self: flex-start; margin-bottom: 1rem;">
+                        @FormatRole(group.ManagerRole)
+                    </span>
+                    <a href="/group/@group.Id" class="btn-gm btn-gm-primary" style="width: 100%; justify-content: center; margin-top: auto;">
+                        Посмотреть игры →
+                    </a>
                 </div>
             }
-        }
-    </div>
+        </div>
+    }
 </div>
 
+<style>
+    .group-card {
+        display: flex;
+        flex-direction: column;
+        min-height: 180px;
+    }
+
+    .group-card-icon {
+        font-size: 2rem;
+        margin-bottom: 0.75rem;
+    }
+
+    .group-card-title {
+        font-size: 1.125rem;
+        font-weight: 600;
+        margin-bottom: 0.25rem;
+        color: var(--text-primary);
+    }
+
+    .group-card-id {
+        font-size: 0.75rem;
+        color: var(--text-muted);
+        font-family: 'Courier New', monospace;
+        margin-bottom: 1rem;
+    }
+</style>
+
 @code {
     private List<WebGameGroup>? groups;
     private string userName = "";
@@ -55,10 +93,15 @@
         var user = authState.User;
         userName = user.Identity?.Name ?? "Мастер Игры";
 
-        var telegramIdClaim = user.FindFirst("TelegramId")?.Value;
-        if (long.TryParse(telegramIdClaim, out var telegramId))
+        if (!user.TryGetTelegramId(out var telegramId))
         {
-            groups = await SessionService.GetGroupsForGmAsync(telegramId);
+            Navigation.NavigateTo("/access-denied");
+            return;
         }
+
+        groups = await SessionService.GetGroupsForGmAsync(telegramId);
     }
+
+    private static string FormatRole(string role) =>
+        GroupManagerRoleExtensions.FromDatabaseValue(role).ToDisplayName();
 }

src/GmRelay.Web/Components/Pages/Login.razor

@@ -2,37 +2,29 @@
 @using Microsoft.AspNetCore.Components.Authorization
 @inject NavigationManager Navigation
 @inject IConfiguration Configuration
+@inject IJSRuntime JS
 
-<PageTitle>Вход - GM-Relay</PageTitle>
+<PageTitle>Вход — GM-Relay</PageTitle>
 
-<div class="container">
-    <div class="row justify-content-center mt-5">
-        <div class="col-md-6 text-center">
-            <h3>Панель управления GM-Relay</h3>
-            <p class="text-muted">Пожалуйста, войдите как Мастер Игры для управления сессиями.</p>
+<div class="login-page">
+    <div class="login-card">
+        <div class="login-logo">🎲</div>
+        <h1 class="login-title">GM-Relay</h1>
+        <p class="login-subtitle">Войдите через Telegram для управления игровыми сессиями</p>
 
-            <div class="mt-4">
-                @if (Navigation.Uri.Contains("error=auth_failed"))
-                {
-                    <div class="alert alert-danger">Ошибка аутентификации. Пожалуйста, попробуйте снова.</div>
-                }
-
-                @* Telegram Login Widget *@
-                <div id="telegram-login-container">
-                    <script async src="https://telegram.org/js/telegram-widget.js?22" 
-                            data-telegram-login="@BotUsername" 
-                            data-size="large" 
-                            data-auth-url="@AuthUrl" 
-                            data-request-access="write"></script>
-                </div>
+        @if (Navigation.Uri.Contains("error=auth_failed"))
+        {
+            <div class="gm-alert gm-alert-danger" style="margin-bottom: 1.5rem; justify-content: center;">
+                ⚠️ Ошибка аутентификации. Пожалуйста, попробуйте снова.
             </div>
-        </div>
+        }
+
+        <div id="telegram-login-container"></div>
     </div>
 </div>
 
 @code {
     private string BotUsername => Configuration["Telegram:BotUsername"] ?? "GmRelayBot";
-    private string AuthUrl => Navigation.ToAbsoluteUri("/auth/telegram").ToString();
 
     [CascadingParameter]
     private Task<AuthenticationState>? AuthStateTask { get; set; }
@@ -48,4 +40,13 @@
             }
         }
     }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await JS.InvokeVoidAsync("loadTelegramWidget", BotUsername, "/auth/telegram-login");
+            await JS.InvokeVoidAsync("watchTelegramMiniAppLogin", "/auth/status", "/", false);
+        }
+    }
 }

src/GmRelay.Web/Components/Pages/MiniApp.razor

@@ -0,0 +1,103 @@
+@page "/miniapp"
+@using Microsoft.AspNetCore.Components.Authorization
+@using System.Text.Json.Serialization
+@inject IJSRuntime JS
+@inject NavigationManager Navigation
+
+<PageTitle>Mini App Dashboard — GM-Relay</PageTitle>
+
+<div class="mini-app-page">
+    <div class="mini-app-auth-card" data-auth-status="@miniAppAuthStatus">
+        <div class="mini-app-logo">🎲</div>
+        <h1>GM-Relay</h1>
+        <p>@statusMessage</p>
+
+        @if (showFallback)
+        {
+            <a href="/login" class="btn-gm btn-gm-primary">Войти через Telegram</a>
+        }
+    </div>
+</div>
+
+@code {
+    private string statusMessage = "Открываем dashboard внутри Telegram...";
+    private string miniAppAuthStatus = "starting";
+    private bool showFallback;
+
+    [CascadingParameter]
+    private Task<AuthenticationState>? AuthStateTask { get; set; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (AuthStateTask is null)
+        {
+            return;
+        }
+
+        var user = (await AuthStateTask).User;
+        if (user.Identity?.IsAuthenticated == true)
+        {
+            Navigation.NavigateTo("/");
+        }
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (!firstRender)
+        {
+            return;
+        }
+
+        try
+        {
+            var result = await JS.InvokeAsync<MiniAppAuthResult>(
+                "authenticateTelegramMiniApp",
+                "/auth/telegram-webapp",
+                "/");
+
+            if (!result.Authenticated)
+            {
+                miniAppAuthStatus = string.IsNullOrWhiteSpace(result.Reason)
+                    ? "telegram-auth-failed"
+                    : result.Reason;
+                statusMessage = GetStatusMessage(miniAppAuthStatus);
+                showFallback = true;
+                StateHasChanged();
+                await TryWatchLoginAsync();
+            }
+        }
+        catch (JSException)
+        {
+            miniAppAuthStatus = "telegram-auth-failed";
+            statusMessage = "Не удалось получить данные Telegram Mini App. Попробуйте открыть dashboard из бота.";
+            showFallback = true;
+            StateHasChanged();
+            await TryWatchLoginAsync();
+        }
+    }
+
+    private async Task TryWatchLoginAsync()
+    {
+        try
+        {
+            await JS.InvokeVoidAsync("watchTelegramMiniAppLogin", "/auth/status", "/");
+        }
+        catch (JSException)
+        {
+        }
+    }
+
+    private static string GetStatusMessage(string reason) => reason switch
+    {
+        "telegram-webapp-missing" => "Mini App API не найден. Если страница открыта в браузере, войдите через Telegram.",
+        "telegram-init-data-empty" => "Telegram открыл страницу без Mini App initData. Попробуйте войти через Telegram на этом экране.",
+        "telegram-auth-failed" => "Не удалось проверить Telegram Mini App. Попробуйте войти через Telegram.",
+        _ => "Mini App доступен из Telegram. Для браузера используйте обычный вход."
+    };
+
+    private sealed record MiniAppAuthResult(
+        [property: JsonPropertyName("authenticated")] bool Authenticated,
+        [property: JsonPropertyName("reason")] string? Reason,
+        [property: JsonPropertyName("status")] int? Status,
+        [property: JsonPropertyName("redirectUrl")] string? RedirectUrl);
+}

src/GmRelay.Web/Components/Pages/NotFound.razor

@@ -1,5 +1,13 @@
-@page "/not-found"
+@page "/not-found"
 @layout MainLayout
 
-<h3>Не найдено</h3>
-<p>Извините, страница, которую вы ищете, не существует.</p>
+<PageTitle>404 — GM-Relay</PageTitle>
+
+<div class="error-page">
+    <div class="error-page-icon">🔍</div>
+    <h1 class="error-page-title">Страница не найдена</h1>
+    <p class="error-page-text">Извините, страница, которую вы ищете, не существует или была перемещена.</p>
+    <a href="/" class="btn-gm btn-gm-primary">
+        ← Вернуться на главную
+    </a>
+</div>

src/GmRelay.Web/Program.cs

@@ -21,7 +21,9 @@ builder.AddNpgsqlDataSource("gmrelaydb");
 
 // Add Services
 builder.Services.AddSingleton<TelegramAuthService>();
-builder.Services.AddSingleton<SessionService>();
+builder.Services.AddSingleton<ISessionStore, SessionService>();
+builder.Services.AddScoped<AuthorizedSessionService>();
+builder.Services.AddScoped<CalendarSubscriptionService>();
 
 // Add Bot Client
 builder.Services.AddSingleton<ITelegramBotClient>(sp =>
@@ -32,12 +34,17 @@ builder.Services.AddSingleton<ITelegramBotClient>(sp =>
     return new TelegramBotClient(token);
 });
 
-// Add Authentication
+// Add Authentication with hardened cookie settings
 builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
     .AddCookie(options =>
     {
         options.LoginPath = "/login";
         options.AccessDeniedPath = "/access-denied";
+        options.Cookie.HttpOnly = true;
+        options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
+        options.Cookie.SameSite = SameSiteMode.Strict;
+        options.ExpireTimeSpan = TimeSpan.FromDays(7);
+        options.SlidingExpiration = true;
     });
 
 builder.Services.AddAuthorization();
@@ -58,6 +65,16 @@ if (!app.Environment.IsDevelopment())
 
 app.UseHttpsRedirection();
 
+// Security headers middleware
+app.Use(async (context, next) =>
+{
+    context.Response.Headers["X-Content-Type-Options"] = "nosniff";
+    context.Response.Headers["X-Frame-Options"] = "DENY";
+    context.Response.Headers["Referrer-Policy"] = "strict-origin-when-cross-origin";
+    context.Response.Headers["Permissions-Policy"] = "camera=(), microphone=(), geolocation=()";
+    await next();
+});
+
 app.UseAuthentication();
 app.UseAuthorization();
 app.UseAntiforgery();
@@ -71,27 +88,95 @@ app.MapGet("/auth/telegram", async (HttpContext context, TelegramAuthService aut
 {
     if (authService.Verify(context.Request.Query, out var telegramId, out var name))
     {
-        var claims = new List<Claim>
-        {
-            new Claim(ClaimTypes.NameIdentifier, telegramId.ToString()),
-            new Claim(ClaimTypes.Name, name),
-            new Claim("TelegramId", telegramId.ToString())
-        };
-
-        var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
         var authProperties = new AuthenticationProperties { IsPersistent = true };
-
-        await context.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), authProperties);
+        await context.SignInAsync(
+            CookieAuthenticationDefaults.AuthenticationScheme,
+            CreateTelegramPrincipal(telegramId, name),
+            authProperties);
         return Results.Redirect("/");
     }
 
     return Results.Redirect("/login?error=auth_failed");
 });
 
+app.MapPost("/auth/telegram-webapp", async (
+    HttpContext context,
+    TelegramAuthService authService,
+    TelegramWebAppAuthRequest request) =>
+{
+    if (!authService.VerifyWebAppInitData(request.InitData, out var telegramId, out var name))
+    {
+        return Results.Unauthorized();
+    }
+
+    var authProperties = new AuthenticationProperties { IsPersistent = true };
+    await context.SignInAsync(
+        CookieAuthenticationDefaults.AuthenticationScheme,
+        CreateTelegramPrincipal(telegramId, name),
+        authProperties);
+
+    return Results.Ok(new { redirectUrl = "/" });
+}).DisableAntiforgery();
+
+app.MapPost("/auth/telegram-login", async (
+    HttpContext context,
+    TelegramAuthService authService,
+    TelegramLoginPayload request) =>
+{
+    if (!authService.VerifyLoginPayload(request, out var telegramId, out var name))
+    {
+        return Results.Unauthorized();
+    }
+
+    var authProperties = new AuthenticationProperties { IsPersistent = true };
+    await context.SignInAsync(
+        CookieAuthenticationDefaults.AuthenticationScheme,
+        CreateTelegramPrincipal(telegramId, name),
+        authProperties);
+
+    return Results.Ok(new { redirectUrl = "/" });
+}).DisableAntiforgery();
+
+app.MapGet("/auth/status", (HttpContext context) =>
+    Results.Ok(new { authenticated = context.User.Identity?.IsAuthenticated == true }));
+
 app.MapPost("/auth/logout", async (HttpContext context) =>
 {
     await context.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
     return Results.Redirect("/");
 });
 
+// Public calendar subscription endpoint (no auth required)
+app.MapGet("/calendar/{token}.ics", async (
+    string token,
+    CalendarSubscriptionService service,
+    CancellationToken ct) =>
+{
+    try
+    {
+        var ics = await service.GetIcsAsync(token, ct);
+        var bytes = System.Text.Encoding.UTF8.GetBytes(ics);
+        return Results.File(bytes, "text/calendar", "schedule.ics");
+    }
+    catch (SubscriptionNotFoundException)
+    {
+        return Results.NotFound();
+    }
+});
+
 app.Run();
+
+static ClaimsPrincipal CreateTelegramPrincipal(long telegramId, string name)
+{
+    var claims = new List<Claim>
+    {
+        new(ClaimTypes.NameIdentifier, telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)),
+        new(ClaimTypes.Name, name),
+        new("TelegramId", telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture))
+    };
+
+    var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
+    return new ClaimsPrincipal(claimsIdentity);
+}
+
+public sealed record TelegramWebAppAuthRequest(string InitData);

src/GmRelay.Web/Services/AuthorizedSessionService.cs

@@ -0,0 +1,292 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Web.Services;
+
+public sealed class AuthorizedSessionService(ISessionStore sessionStore)
+{
+    public Task<List<WebGameGroup>> GetGroupsForGmAsync(long gmId) =>
+        sessionStore.GetGroupsForGmAsync(gmId);
+
+    public async Task<WebGroupManagement?> GetGroupManagementForGmAsync(Guid groupId, long gmId)
+    {
+        if (!await GroupBelongsToGmAsync(groupId, gmId))
+        {
+            return null;
+        }
+
+        var group = await sessionStore.GetGroupAsync(groupId);
+        if (group is null)
+        {
+            return null;
+        }
+
+        var managers = await sessionStore.GetGroupManagersAsync(groupId);
+        var isOwner = await sessionStore.IsGroupOwnerAsync(groupId, gmId);
+        return new WebGroupManagement(group, managers, isOwner);
+    }
+
+    public async Task<List<WebSession>?> GetUpcomingSessionsForGmAsync(Guid groupId, long gmId)
+    {
+        if (!await GroupBelongsToGmAsync(groupId, gmId))
+        {
+            return null;
+        }
+
+        return await sessionStore.GetUpcomingSessionsAsync(groupId);
+    }
+
+    public async Task<WebSession?> GetSessionForGmAsync(Guid sessionId, long gmId)
+    {
+        var session = await sessionStore.GetSessionAsync(sessionId);
+        if (session is null)
+        {
+            return null;
+        }
+
+        return await GroupBelongsToGmAsync(session.GroupId, gmId) ? session : null;
+    }
+
+    public async Task<WebSessionBatch?> GetBatchForGmAsync(Guid batchId, long gmId)
+    {
+        var batch = await sessionStore.GetBatchAsync(batchId);
+        if (batch is null)
+        {
+            return null;
+        }
+
+        return await GroupBelongsToGmAsync(batch.GroupId, gmId) ? batch : null;
+    }
+
+    public async Task UpdateSessionForGmAsync(Guid sessionId, long gmId, string title, DateTime scheduledAt, string joinLink, int? maxPlayers)
+    {
+        var session = await GetSessionForGmAsync(sessionId, gmId);
+        if (session is null)
+        {
+            throw new SessionAccessDeniedException(sessionId, gmId);
+        }
+
+        await sessionStore.UpdateSessionAsync(sessionId, session.GroupId, title, scheduledAt, joinLink, maxPlayers);
+    }
+
+    public async Task PromoteWaitlistedPlayerForGmAsync(Guid sessionId, long gmId)
+    {
+        var session = await GetSessionForGmAsync(sessionId, gmId);
+        if (session is null)
+        {
+            throw new SessionAccessDeniedException(sessionId, gmId);
+        }
+
+        await sessionStore.PromoteWaitlistedPlayerAsync(sessionId, session.GroupId);
+    }
+
+    public async Task UpdateBatchDetailsForGmAsync(Guid batchId, long gmId, string title, string joinLink)
+    {
+        var batch = await GetBatchForGmAsync(batchId, gmId);
+        if (batch is null)
+        {
+            throw new SessionAccessDeniedException(batchId, gmId);
+        }
+
+        await sessionStore.UpdateBatchDetailsAsync(batchId, batch.GroupId, title.Trim(), joinLink.Trim());
+    }
+
+    public async Task UpdateBatchNotificationModeForGmAsync(Guid batchId, long gmId, SessionNotificationMode notificationMode)
+    {
+        var batch = await GetBatchForGmAsync(batchId, gmId);
+        if (batch is null)
+        {
+            throw new SessionAccessDeniedException(batchId, gmId);
+        }
+
+        await sessionStore.UpdateBatchNotificationModeAsync(batchId, batch.GroupId, notificationMode);
+    }
+
+    public async Task RescheduleBatchForGmAsync(Guid batchId, long gmId, DateTime firstScheduledAt, int intervalDays)
+    {
+        if (intervalDays <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(intervalDays), intervalDays, "Interval must be greater than zero.");
+        }
+
+        var batch = await GetBatchForGmAsync(batchId, gmId);
+        if (batch is null)
+        {
+            throw new SessionAccessDeniedException(batchId, gmId);
+        }
+
+        await sessionStore.RescheduleBatchAsync(batchId, batch.GroupId, firstScheduledAt, intervalDays);
+    }
+
+    public async Task<WebSessionBatch> CloneBatchForGmAsync(Guid batchId, long gmId, BatchCloneInterval interval)
+    {
+        var batch = await GetBatchForGmAsync(batchId, gmId);
+        if (batch is null)
+        {
+            throw new SessionAccessDeniedException(batchId, gmId);
+        }
+
+        return await sessionStore.CloneBatchAsync(batchId, batch.GroupId, interval);
+    }
+
+    public async Task<List<WebCampaignTemplate>?> GetCampaignTemplatesForGmAsync(Guid groupId, long gmId)
+    {
+        if (!await GroupBelongsToGmAsync(groupId, gmId))
+        {
+            return null;
+        }
+
+        return await sessionStore.GetCampaignTemplatesAsync(groupId);
+    }
+
+    public async Task<WebCampaignTemplate> CreateCampaignTemplateForGmAsync(
+        Guid groupId,
+        long gmId,
+        CreateCampaignTemplateRequest request)
+    {
+        if (!await GroupBelongsToGmAsync(groupId, gmId))
+        {
+            throw new SessionAccessDeniedException(groupId, gmId);
+        }
+
+        var normalizedRequest = NormalizeCampaignTemplateRequest(request);
+        return await sessionStore.CreateCampaignTemplateAsync(groupId, normalizedRequest);
+    }
+
+    public async Task DeleteCampaignTemplateForGmAsync(Guid templateId, long gmId)
+    {
+        var template = await sessionStore.GetCampaignTemplateAsync(templateId);
+        if (template is null || !await GroupBelongsToGmAsync(template.GroupId, gmId))
+        {
+            throw new SessionAccessDeniedException(templateId, gmId);
+        }
+
+        await sessionStore.DeleteCampaignTemplateAsync(templateId, template.GroupId);
+    }
+
+    public async Task<WebSessionBatch> CreateBatchFromCampaignTemplateForGmAsync(
+        Guid templateId,
+        long gmId,
+        DateTime firstScheduledAt)
+    {
+        if (firstScheduledAt <= DateTime.UtcNow)
+        {
+            throw new ArgumentOutOfRangeException(nameof(firstScheduledAt), firstScheduledAt, "First scheduled time must be in the future.");
+        }
+
+        var template = await sessionStore.GetCampaignTemplateAsync(templateId);
+        if (template is null || !await GroupBelongsToGmAsync(template.GroupId, gmId))
+        {
+            throw new SessionAccessDeniedException(templateId, gmId);
+        }
+
+        return await sessionStore.CreateBatchFromTemplateAsync(templateId, template.GroupId, firstScheduledAt);
+    }
+
+    public async Task AddCoGmForOwnerAsync(Guid groupId, long ownerTelegramId, long coGmTelegramId, string displayName, string? telegramUsername)
+    {
+        if (coGmTelegramId <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(coGmTelegramId), coGmTelegramId, "Telegram id must be greater than zero.");
+        }
+
+        if (ownerTelegramId == coGmTelegramId)
+        {
+            throw new InvalidOperationException("Owner is already a group manager.");
+        }
+
+        if (!await sessionStore.IsGroupOwnerAsync(groupId, ownerTelegramId))
+        {
+            throw new SessionAccessDeniedException(groupId, ownerTelegramId);
+        }
+
+        var normalizedName = string.IsNullOrWhiteSpace(displayName)
+            ? $"Telegram {coGmTelegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)}"
+            : displayName.Trim();
+        var normalizedUsername = string.IsNullOrWhiteSpace(telegramUsername)
+            ? null
+            : telegramUsername.Trim().TrimStart('@');
+
+        await sessionStore.AddGroupCoGmAsync(groupId, ownerTelegramId, coGmTelegramId, normalizedName, normalizedUsername);
+    }
+
+    public async Task RemoveCoGmForOwnerAsync(Guid groupId, long ownerTelegramId, long coGmTelegramId)
+    {
+        if (!await sessionStore.IsGroupOwnerAsync(groupId, ownerTelegramId))
+        {
+            throw new SessionAccessDeniedException(groupId, ownerTelegramId);
+        }
+
+        await sessionStore.RemoveGroupCoGmAsync(groupId, coGmTelegramId);
+    }
+
+    public async Task<List<WebParticipant>?> GetSessionParticipantsForGmAsync(Guid sessionId, long gmId)
+    {
+        var session = await GetSessionForGmAsync(sessionId, gmId);
+        if (session is null)
+        {
+            return null;
+        }
+
+        return await sessionStore.GetSessionParticipantsAsync(sessionId);
+    }
+
+    public async Task RemovePlayerFromSessionForGmAsync(Guid sessionId, long gmId, Guid participantId)
+    {
+        var session = await GetSessionForGmAsync(sessionId, gmId);
+        if (session is null)
+        {
+            throw new SessionAccessDeniedException(sessionId, gmId);
+        }
+
+        await sessionStore.RemovePlayerFromSessionAsync(sessionId, session.GroupId, participantId);
+    }
+
+    private async Task<bool> GroupBelongsToGmAsync(Guid groupId, long gmId)
+    {
+        return await sessionStore.IsGroupManagerAsync(groupId, gmId);
+    }
+
+    private static CreateCampaignTemplateRequest NormalizeCampaignTemplateRequest(CreateCampaignTemplateRequest request)
+    {
+        var name = request.Name.Trim();
+        var title = request.Title.Trim();
+        var joinLink = request.JoinLink.Trim();
+
+        if (name.Length == 0)
+        {
+            throw new ArgumentException("Template name must not be empty.", nameof(request));
+        }
+
+        if (title.Length == 0)
+        {
+            throw new ArgumentException("Session title must not be empty.", nameof(request));
+        }
+
+        if (joinLink.Length == 0)
+        {
+            throw new ArgumentException("Join link must not be empty.", nameof(request));
+        }
+
+        if (request.SessionCount is < 1 or > 52)
+        {
+            throw new ArgumentOutOfRangeException(nameof(request), request.SessionCount, "Session count must be between 1 and 52.");
+        }
+
+        if (request.IntervalDays is < 1 or > 365)
+        {
+            throw new ArgumentOutOfRangeException(nameof(request), request.IntervalDays, "Interval must be between 1 and 365 days.");
+        }
+
+        if (request.MaxPlayers is <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(request), request.MaxPlayers, "Seat limit must be greater than zero.");
+        }
+
+        return request with
+        {
+            Name = name,
+            Title = title,
+            JoinLink = joinLink
+        };
+    }
+}

src/GmRelay.Web/Services/BatchMessageEditor.cs

@@ -0,0 +1,51 @@
+using Telegram.Bot;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Web.Services;
+
+/// <summary>
+/// Handles editing batch messages that may be either text or photo messages.
+/// When the batch was created with SendPhoto (image + caption), we need
+/// EditMessageCaption instead of EditMessageText.
+/// </summary>
+public static class BatchMessageEditor
+{
+    /// <summary>
+    /// Edits a batch message, automatically detecting whether it is a text or photo message.
+    /// Tries EditMessageText first; on failure falls back to EditMessageCaption.
+    /// </summary>
+    public static async Task EditBatchMessageAsync(
+        ITelegramBotClient bot,
+        long chatId,
+        int messageId,
+        string text,
+        InlineKeyboardMarkup? replyMarkup,
+        CancellationToken ct = default)
+    {
+        try
+        {
+            await bot.EditMessageText(
+                chatId: chatId,
+                messageId: messageId,
+                text: text,
+                parseMode: ParseMode.Html,
+                replyMarkup: replyMarkup,
+                cancellationToken: ct);
+        }
+        catch (Telegram.Bot.Exceptions.ApiRequestException ex)
+            when (ex.Message.Contains("there is no text in the message", StringComparison.OrdinalIgnoreCase))
+        {
+            // The batch message is a photo — use EditMessageCaption instead.
+            // Caption is limited to 1024 chars; if text exceeds that, truncate gracefully.
+            var caption = text.Length <= 1024 ? text : text[..1021] + "...";
+            await bot.EditMessageCaption(
+                chatId: chatId,
+                messageId: messageId,
+                caption: caption,
+                parseMode: ParseMode.Html,
+                replyMarkup: replyMarkup,
+                cancellationToken: ct);
+        }
+    }
+}

src/GmRelay.Web/Services/BatchSchedulePlanner.cs

@@ -0,0 +1,91 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Web.Services;
+
+public enum BatchCloneInterval
+{
+    NextWeek,
+    NextMonth
+}
+
+public sealed record WebSessionBatch(
+    Guid Id,
+    Guid GroupId,
+    string Title,
+    string JoinLink,
+    DateTime FirstScheduledAt,
+    DateTime LastScheduledAt,
+    int SessionCount,
+    string NotificationMode = SessionNotificationModeExtensions.GroupAndDirectValue);
+
+public sealed record WebCampaignTemplate(
+    Guid Id,
+    Guid GroupId,
+    string Name,
+    string Title,
+    string JoinLink,
+    int SessionCount,
+    int IntervalDays,
+    int? MaxPlayers,
+    string NotificationMode,
+    DateTime CreatedAt,
+    DateTime UpdatedAt);
+
+public sealed record CreateCampaignTemplateRequest(
+    string Name,
+    string Title,
+    string JoinLink,
+    int SessionCount,
+    int IntervalDays,
+    int? MaxPlayers,
+    SessionNotificationMode NotificationMode);
+
+public static class BatchSchedulePlanner
+{
+    private const int MaxTemplateSessionCount = 52;
+    private const int MaxTemplateIntervalDays = 365;
+
+    public static IReadOnlyList<DateTime> BuildFixedIntervalSchedule(
+        IEnumerable<DateTime> currentSchedule,
+        DateTime firstScheduledAt,
+        int intervalDays)
+    {
+        if (intervalDays <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(intervalDays), intervalDays, "Interval must be greater than zero.");
+        }
+
+        return currentSchedule
+            .OrderBy(scheduledAt => scheduledAt)
+            .Select((_, index) => firstScheduledAt.AddDays(intervalDays * index))
+            .ToList();
+    }
+
+    public static IReadOnlyList<DateTime> BuildRecurringSchedule(
+        DateTime firstScheduledAt,
+        int sessionCount,
+        int intervalDays)
+    {
+        if (sessionCount is < 1 or > MaxTemplateSessionCount)
+        {
+            throw new ArgumentOutOfRangeException(nameof(sessionCount), sessionCount, "Session count must be between 1 and 52.");
+        }
+
+        if (intervalDays is < 1 or > MaxTemplateIntervalDays)
+        {
+            throw new ArgumentOutOfRangeException(nameof(intervalDays), intervalDays, "Interval must be between 1 and 365 days.");
+        }
+
+        return Enumerable.Range(0, sessionCount)
+            .Select(index => firstScheduledAt.AddDays(intervalDays * index))
+            .ToList();
+    }
+
+    public static DateTime ShiftForClone(DateTime scheduledAt, BatchCloneInterval interval) =>
+        interval switch
+        {
+            BatchCloneInterval.NextWeek => scheduledAt.AddDays(7),
+            BatchCloneInterval.NextMonth => scheduledAt.AddMonths(1),
+            _ => throw new ArgumentOutOfRangeException(nameof(interval), interval, "Unknown clone interval.")
+        };
+}

src/GmRelay.Web/Services/CalendarSubscriptionService.cs

@@ -0,0 +1,93 @@
+using System.Text;
+using Dapper;
+using GmRelay.Shared.Domain;
+using Npgsql;
+
+namespace GmRelay.Web.Services;
+
+public sealed class CalendarSubscriptionService(NpgsqlDataSource dataSource)
+{
+    private const string IcsProdId = "-//GM-Relay//TTRPG Schedule//EN";
+
+    public string GenerateToken() => Guid.NewGuid().ToString("N");
+
+    public async Task<string> CreateSubscriptionAsync(
+        long userTelegramId,
+        Guid? groupId,
+        CalendarSubscriptionFilter filter,
+        CancellationToken ct = default)
+    {
+        var token = GenerateToken();
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await connection.ExecuteAsync(
+            @"INSERT INTO calendar_subscriptions (id, token, user_telegram_id, group_id, filter_type, created_at, expires_at)
+              VALUES (gen_random_uuid(), @token, @userTelegramId, @groupId, @filterType, now(), NULL)",
+            new { token, userTelegramId, groupId, filterType = (int)filter });
+        return token;
+    }
+
+    public async Task<string> GetIcsAsync(string token, CancellationToken ct = default)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var subscription = await connection.QueryFirstOrDefaultAsync<SubscriptionRecord>(
+            @"SELECT id, user_telegram_id as UserTelegramId, group_id as GroupId, filter_type as FilterType
+              FROM calendar_subscriptions
+              WHERE token = @token
+                AND (expires_at IS NULL OR expires_at > now())",
+            new { token });
+
+        if (subscription is null)
+            throw new SubscriptionNotFoundException();
+
+        var sessions = await connection.QueryAsync<CalendarSessionDto>(
+            subscription.FilterType == (int)CalendarSubscriptionFilter.SpecificGroup && subscription.GroupId.HasValue
+                ? @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt
+                    FROM sessions s
+                    WHERE s.group_id = @GroupId
+                      AND s.status = @Planned
+                      AND s.scheduled_at > NOW()
+                    ORDER BY s.scheduled_at ASC"
+                : @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt
+                    FROM sessions s
+                    WHERE s.status = @Planned
+                      AND s.scheduled_at > NOW()
+                    ORDER BY s.scheduled_at ASC",
+            new { subscription.GroupId, Planned = SessionStatus.Planned });
+
+        var sb = new StringBuilder();
+        sb.AppendLine("BEGIN:VCALENDAR");
+        sb.AppendLine("VERSION:2.0");
+        sb.AppendLine($"PRODID:{IcsProdId}");
+        sb.AppendLine("CALSCALE:GREGORIAN");
+        sb.AppendLine("METHOD:PUBLISH");
+
+        foreach (var s in sessions)
+        {
+            var dtStart = FormatIcsDate(s.ScheduledAt);
+            var dtEnd = FormatIcsDate(s.ScheduledAt.AddHours(4));
+            sb.AppendLine("BEGIN:VEVENT");
+            sb.AppendLine($"UID:{s.Id}@gmrelay");
+            sb.AppendLine($"DTSTAMP:{FormatIcsDate(DateTime.UtcNow)}");
+            sb.AppendLine($"DTSTART:{dtStart}");
+            sb.AppendLine($"DTEND:{dtEnd}");
+            sb.AppendLine($"SUMMARY:{EscapeIcsText(s.Title)}");
+            sb.AppendLine("END:VEVENT");
+        }
+
+        sb.AppendLine("END:VCALENDAR");
+        return sb.ToString();
+    }
+
+    private static string FormatIcsDate(DateTime dt) => dt.ToUniversalTime().ToString("yyyyMMddTHHmmssZ");
+
+    private static string EscapeIcsText(string text) => text
+        .Replace("\\", "\\\\")
+        .Replace(";", "\\;")
+        .Replace(",", "\\,")
+        .Replace("\n", "\\n")
+        .Replace("\r", "");
+
+    private sealed record SubscriptionRecord(Guid Id, long UserTelegramId, Guid? GroupId, int FilterType);
+    private sealed record CalendarSessionDto(Guid Id, string Title, DateTime ScheduledAt);
+}

src/GmRelay.Web/Services/ClaimsPrincipalExtensions.cs

@@ -0,0 +1,9 @@
+using System.Security.Claims;
+
+namespace GmRelay.Web.Services;
+
+public static class ClaimsPrincipalExtensions
+{
+    public static bool TryGetTelegramId(this ClaimsPrincipal user, out long telegramId) =>
+        long.TryParse(user.FindFirst("TelegramId")?.Value, out telegramId);
+}

src/GmRelay.Web/Services/ISessionStore.cs

@@ -0,0 +1,44 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Web.Services;
+
+public sealed record PlayerAttendanceStats(
+    Guid PlayerId,
+    string DisplayName,
+    string? TelegramUsername,
+    long TotalSessions,
+    long ConfirmedCount,
+    long DeclinedCount,
+    long NoResponseCount,
+    long WaitlistedCount,
+    long CancellationAffectedCount,
+    decimal AttendanceRate
+);
+
+public interface ISessionStore
+{
+    Task<List<WebGameGroup>> GetGroupsForGmAsync(long gmId);
+    Task<WebGameGroup?> GetGroupAsync(Guid groupId);
+    Task<bool> IsGroupManagerAsync(Guid groupId, long telegramId);
+    Task<bool> IsGroupOwnerAsync(Guid groupId, long telegramId);
+    Task<List<WebGroupManager>> GetGroupManagersAsync(Guid groupId);
+    Task<List<WebSession>> GetUpcomingSessionsAsync(Guid groupId);
+    Task<WebSession?> GetSessionAsync(Guid sessionId);
+    Task<WebSessionBatch?> GetBatchAsync(Guid batchId);
+    Task UpdateSessionAsync(Guid sessionId, Guid groupId, string title, DateTime scheduledAt, string joinLink, int? maxPlayers);
+    Task PromoteWaitlistedPlayerAsync(Guid sessionId, Guid groupId);
+    Task UpdateBatchDetailsAsync(Guid batchId, Guid groupId, string title, string joinLink);
+    Task UpdateBatchNotificationModeAsync(Guid batchId, Guid groupId, SessionNotificationMode notificationMode);
+    Task RescheduleBatchAsync(Guid batchId, Guid groupId, DateTime firstScheduledAt, int intervalDays);
+    Task<WebSessionBatch> CloneBatchAsync(Guid batchId, Guid groupId, BatchCloneInterval interval);
+    Task<List<WebCampaignTemplate>> GetCampaignTemplatesAsync(Guid groupId);
+    Task<WebCampaignTemplate?> GetCampaignTemplateAsync(Guid templateId);
+    Task<WebCampaignTemplate> CreateCampaignTemplateAsync(Guid groupId, CreateCampaignTemplateRequest request);
+    Task DeleteCampaignTemplateAsync(Guid templateId, Guid groupId);
+    Task<WebSessionBatch> CreateBatchFromTemplateAsync(Guid templateId, Guid groupId, DateTime firstScheduledAt);
+    Task AddGroupCoGmAsync(Guid groupId, long ownerTelegramId, long coGmTelegramId, string displayName, string? telegramUsername);
+    Task RemoveGroupCoGmAsync(Guid groupId, long coGmTelegramId);
+    Task<List<WebParticipant>> GetSessionParticipantsAsync(Guid sessionId);
+    Task RemovePlayerFromSessionAsync(Guid sessionId, Guid groupId, Guid participantId);
+    Task<List<PlayerAttendanceStats>> GetGroupAttendanceStatsAsync(Guid groupId);
+}

src/GmRelay.Web/Services/SessionAccessDeniedException.cs

@@ -0,0 +1,4 @@
+namespace GmRelay.Web.Services;
+
+public sealed class SessionAccessDeniedException(Guid sessionId, long gmId)
+    : InvalidOperationException($"Session '{sessionId}' is not accessible for GM '{gmId}'.");

src/GmRelay.Web/Services/SubscriptionNotFoundException.cs

@@ -0,0 +1,6 @@
+namespace GmRelay.Web.Services;
+
+public sealed class SubscriptionNotFoundException : Exception
+{
+    public SubscriptionNotFoundException() : base("Calendar subscription not found.") { }
+}

src/GmRelay.Web/Services/TelegramAuthService.cs

@@ -1,5 +1,8 @@
 using System.Security.Cryptography;
 using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.AspNetCore.WebUtilities;
 
 namespace GmRelay.Web.Services;
 
@@ -26,19 +29,18 @@ public sealed class TelegramAuthService(IConfiguration configuration)
 
         var dataCheckString = string.Join("\n", dataCheckList);
 
-        // 2. Compute Secret Key
-        using var sha256 = SHA256.Create();
-        var secretKey = sha256.ComputeHash(Encoding.UTF8.GetBytes(token));
+        // 2. Compute Secret Key (static method — no IDisposable needed)
+        var secretKey = SHA256.HashData(Encoding.UTF8.GetBytes(token));
 
-        // 3. Compute Hash
-        using var hmac = new HMACSHA256(secretKey);
-        var computedHashBytes = hmac.ComputeHash(Encoding.UTF8.GetBytes(dataCheckString));
-        var computedHash = Convert.ToHexString(computedHashBytes).ToLower();
+        // 3. Compute Hash (static method — no IDisposable needed)
+        var computedHashBytes = HMACSHA256.HashData(secretKey, Encoding.UTF8.GetBytes(dataCheckString));
 
-        if (computedHash != hash.ToString().ToLower())
+        // 4. Timing-safe comparison to prevent timing attacks
+        var hashBytes = Convert.FromHexString(hash.ToString());
+        if (!CryptographicOperations.FixedTimeEquals(computedHashBytes, hashBytes))
             return false;
 
-        // 4. Check expiration (auth_date)
+        // 5. Check expiration (auth_date)
         if (query.TryGetValue("auth_date", out var authDateStr) && long.TryParse(authDateStr, out var authDate))
         {
             var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
@@ -56,4 +58,170 @@ public sealed class TelegramAuthService(IConfiguration configuration)
 
         return false;
     }
+
+    public bool VerifyWebAppInitData(string initData, out long telegramId, out string name)
+    {
+        telegramId = 0;
+        name = string.Empty;
+
+        if (string.IsNullOrWhiteSpace(initData))
+            return false;
+
+        var token = configuration["Telegram__BotToken"] ?? configuration["Telegram:BotToken"];
+        if (string.IsNullOrEmpty(token))
+            return false;
+
+        var values = QueryHelpers.ParseQuery(initData);
+        if (!values.TryGetValue("hash", out var hash) || string.IsNullOrWhiteSpace(hash))
+            return false;
+
+        var dataCheckString = string.Join(
+            "\n",
+            values
+                .Where(pair => pair.Key != "hash")
+                .OrderBy(pair => pair.Key, StringComparer.Ordinal)
+                .Select(pair => $"{pair.Key}={pair.Value}"));
+
+        var secretKey = HMACSHA256.HashData(Encoding.UTF8.GetBytes("WebAppData"), Encoding.UTF8.GetBytes(token));
+        var computedHashBytes = HMACSHA256.HashData(secretKey, Encoding.UTF8.GetBytes(dataCheckString));
+
+        byte[] hashBytes;
+        try
+        {
+            hashBytes = Convert.FromHexString(hash.ToString());
+        }
+        catch (FormatException)
+        {
+            return false;
+        }
+
+        if (!CryptographicOperations.FixedTimeEquals(computedHashBytes, hashBytes))
+            return false;
+
+        if (!values.TryGetValue("auth_date", out var authDateStr) ||
+            !long.TryParse(authDateStr, out var authDate))
+        {
+            return false;
+        }
+
+        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        if (now - authDate > 86400)
+            return false;
+
+        if (!values.TryGetValue("user", out var userJson) || string.IsNullOrWhiteSpace(userJson))
+            return false;
+
+        return TryReadWebAppUser(userJson.ToString(), out telegramId, out name);
+    }
+
+    public bool VerifyLoginPayload(TelegramLoginPayload payload, out long telegramId, out string name)
+    {
+        telegramId = 0;
+        name = string.Empty;
+
+        if (payload.Id <= 0 ||
+            string.IsNullOrWhiteSpace(payload.FirstName) ||
+            payload.AuthDate <= 0 ||
+            string.IsNullOrWhiteSpace(payload.Hash))
+        {
+            return false;
+        }
+
+        var token = configuration["Telegram__BotToken"] ?? configuration["Telegram:BotToken"];
+        if (string.IsNullOrEmpty(token))
+            return false;
+
+        var values = new SortedDictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["auth_date"] = payload.AuthDate.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            ["first_name"] = payload.FirstName,
+            ["id"] = payload.Id.ToString(System.Globalization.CultureInfo.InvariantCulture)
+        };
+
+        if (!string.IsNullOrWhiteSpace(payload.LastName))
+            values["last_name"] = payload.LastName;
+        if (!string.IsNullOrWhiteSpace(payload.PhotoUrl))
+            values["photo_url"] = payload.PhotoUrl;
+        if (!string.IsNullOrWhiteSpace(payload.Username))
+            values["username"] = payload.Username;
+
+        var dataCheckString = string.Join("\n", values.Select(pair => $"{pair.Key}={pair.Value}"));
+        var secretKey = SHA256.HashData(Encoding.UTF8.GetBytes(token));
+        var computedHashBytes = HMACSHA256.HashData(secretKey, Encoding.UTF8.GetBytes(dataCheckString));
+
+        byte[] hashBytes;
+        try
+        {
+            hashBytes = Convert.FromHexString(payload.Hash);
+        }
+        catch (FormatException)
+        {
+            return false;
+        }
+        catch (ArgumentException)
+        {
+            return false;
+        }
+
+        if (!CryptographicOperations.FixedTimeEquals(computedHashBytes, hashBytes))
+            return false;
+
+        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        if (now - payload.AuthDate > 86400)
+            return false;
+
+        telegramId = payload.Id;
+        name = string.IsNullOrWhiteSpace(payload.LastName)
+            ? payload.FirstName
+            : $"{payload.FirstName} {payload.LastName}";
+        return true;
+    }
+
+    private static bool TryReadWebAppUser(string userJson, out long telegramId, out string name)
+    {
+        telegramId = 0;
+        name = string.Empty;
+
+        try
+        {
+            using var document = JsonDocument.Parse(userJson);
+            var root = document.RootElement;
+
+            if (!root.TryGetProperty("id", out var idElement) || !idElement.TryGetInt64(out telegramId))
+                return false;
+
+            var firstName = root.TryGetProperty("first_name", out var firstNameElement)
+                ? firstNameElement.GetString() ?? string.Empty
+                : string.Empty;
+            var lastName = root.TryGetProperty("last_name", out var lastNameElement)
+                ? lastNameElement.GetString() ?? string.Empty
+                : string.Empty;
+            var username = root.TryGetProperty("username", out var usernameElement)
+                ? usernameElement.GetString()
+                : null;
+
+            name = (firstName, lastName) switch
+            {
+                ({ Length: > 0 }, { Length: > 0 }) => $"{firstName} {lastName}",
+                ({ Length: > 0 }, _) => firstName,
+                _ when !string.IsNullOrWhiteSpace(username) => "@" + username,
+                _ => $"Telegram {telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)}"
+            };
+
+            return true;
+        }
+        catch (JsonException)
+        {
+            return false;
+        }
+    }
 }
+
+public sealed record TelegramLoginPayload(
+    [property: JsonPropertyName("id")] long Id,
+    [property: JsonPropertyName("first_name")] string FirstName,
+    [property: JsonPropertyName("last_name")] string? LastName,
+    [property: JsonPropertyName("username")] string? Username,
+    [property: JsonPropertyName("photo_url")] string? PhotoUrl,
+    [property: JsonPropertyName("auth_date")] long AuthDate,
+    [property: JsonPropertyName("hash")] string Hash);

src/GmRelay.Web/Services/TelegramSessionBatchRenderer.cs

@@ -0,0 +1,57 @@
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Web.Services;
+
+public static class TelegramSessionBatchRenderer
+{
+    public static (string Text, InlineKeyboardMarkup Markup) Render(SessionBatchViewModel view)
+    {
+        var messageText = $"🎲 <b>Новые игры:</b> {System.Net.WebUtility.HtmlEncode(view.Title)}\n\n" +
+                          $"<b>Расписание:</b>\n\n";
+
+        var buttons = new List<InlineKeyboardButton[]>();
+
+        foreach (var session in view.Sessions)
+        {
+            messageText += $"📅 <b>{session.ScheduledAt.FormatMoscow()}</b>\n";
+            messageText += session.MaxPlayers.HasValue
+                ? $"👥 Места: {session.ActivePlayerCount}/{session.MaxPlayers.Value}\n"
+                : $"👥 Игроки ({session.ActivePlayerCount}):\n";
+
+            if (session.ActivePlayers.Count > 0)
+            {
+                messageText += string.Join("\n", session.ActivePlayers.Select(p =>
+                    $"  👤 {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
+            }
+            else
+            {
+                messageText += "  <i>Пока никто не записался</i>\n";
+            }
+
+            if (session.WaitlistedPlayers.Count > 0)
+            {
+                messageText += $"⏳ Лист ожидания ({session.WaitlistedPlayers.Count}):\n";
+                messageText += string.Join("\n", session.WaitlistedPlayers.Select(p =>
+                    $"  ⏱ {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
+            }
+
+            if (GmRelay.Shared.Domain.SessionStatus.IsCancelled(session.Status))
+            {
+                messageText += "❌ <i>Сессия отменена</i>\n\n";
+            }
+            else
+            {
+                messageText += "\n";
+                var actionRow = session.AvailableActions
+                    .Select(a => InlineKeyboardButton.WithCallbackData(a.Label, $"{a.ActionKey}:{a.SessionId}"))
+                    .ToArray();
+                if (actionRow.Length > 0)
+                    buttons.Add(actionRow);
+            }
+        }
+
+        return (messageText, new InlineKeyboardMarkup(buttons));
+    }
+}

tests/GmRelay.Bot.Tests/Domain/SessionNotificationModeTests.cs

@@ -0,0 +1,16 @@
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Tests.Domain;
+
+public sealed class SessionNotificationModeTests
+{
+    [Theory]
+    [InlineData(SessionNotificationMode.GroupAndDirect, true)]
+    [InlineData(SessionNotificationMode.GroupOnly, false)]
+    public void ShouldSendDirectMessages_ReturnsExpectedDecision(
+        SessionNotificationMode mode,
+        bool expected)
+    {
+        Assert.Equal(expected, mode.ShouldSendDirectMessages());
+    }
+}

tests/GmRelay.Bot.Tests/Domain/SessionStatusTests.cs

@@ -0,0 +1,75 @@
+using System.Reflection;
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Tests.Domain;
+
+public sealed class SessionStatusTests
+{
+    [Fact]
+    public void All_ShouldContainOnlyCanonicalSessionStatuses()
+    {
+        var allProperty = typeof(SessionStatus).GetProperty(
+            "All",
+            BindingFlags.Public | BindingFlags.Static);
+
+        Assert.NotNull(allProperty);
+
+        var allStatusValues = Assert.IsAssignableFrom<IReadOnlySet<string>>(allProperty.GetValue(null));
+        var expectedStatusValues = new[]
+            {
+                SessionStatus.Planned,
+                SessionStatus.ConfirmationSent,
+                SessionStatus.Confirmed,
+                SessionStatus.Cancelled
+            }
+            .Order(StringComparer.Ordinal);
+
+        Assert.Equal(expectedStatusValues, allStatusValues.Order(StringComparer.Ordinal));
+    }
+
+    [Fact]
+    public void ProductionSources_ShouldNotReferenceLegacySessionStatuses()
+    {
+        var repositoryRoot = FindRepositoryRoot();
+        var productionFiles = Directory.EnumerateFiles(repositoryRoot, "*.*", SearchOption.AllDirectories)
+            .Where(path => IsProductionSource(path))
+            .ToList();
+
+        var legacyStatuses = new[] { "Recruit" + "ing", "Recruitment" + "Closed" };
+        var offenders = productionFiles
+            .SelectMany(path => legacyStatuses
+                .Where(status => File.ReadAllText(path).Contains(status, StringComparison.Ordinal))
+                .Select(status => $"{Path.GetRelativePath(repositoryRoot, path)} contains {status}"))
+            .ToList();
+
+        Assert.Empty(offenders);
+    }
+
+    private static bool IsProductionSource(string path)
+    {
+        var extension = Path.GetExtension(path);
+        var separator = Path.DirectorySeparatorChar;
+
+        return path.Contains($"{separator}src{separator}", StringComparison.Ordinal)
+            && !path.Contains($"{separator}bin{separator}", StringComparison.Ordinal)
+            && !path.Contains($"{separator}obj{separator}", StringComparison.Ordinal)
+            && extension is ".cs" or ".razor" or ".sql";
+    }
+
+    private static string FindRepositoryRoot()
+    {
+        var current = new DirectoryInfo(AppContext.BaseDirectory);
+
+        while (current is not null)
+        {
+            if (File.Exists(Path.Combine(current.FullName, "GM-Relay.slnx")))
+            {
+                return current.FullName;
+            }
+
+            current = current.Parent;
+        }
+
+        throw new InvalidOperationException("Could not find repository root.");
+    }
+}

tests/GmRelay.Bot.Tests/Features/Confirmation/HandleRsvp/RsvpFlowRulesTests.cs

@@ -0,0 +1,50 @@
+using GmRelay.Bot.Features.Confirmation.HandleRsvp;
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Tests.Features.Confirmation.HandleRsvp;
+
+public sealed class RsvpFlowRulesTests
+{
+    [Fact]
+    public void Evaluate_ShouldRevertAndAlert_WhenConfirmedSessionGetsDecline()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Declined,
+            SessionStatus.Confirmed,
+            totalParticipants: 3,
+            confirmedParticipants: 2);
+
+        Assert.True(decision.ShouldAlertGm);
+        Assert.True(decision.ShouldRevertSessionToConfirmationSent);
+        Assert.False(decision.ShouldMarkSessionConfirmed);
+        Assert.Equal("Вы отказались от участия.", decision.CallbackText);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldMarkConfirmed_WhenLastParticipantConfirms()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Confirmed,
+            SessionStatus.ConfirmationSent,
+            totalParticipants: 3,
+            confirmedParticipants: 3);
+
+        Assert.True(decision.ShouldMarkSessionConfirmed);
+        Assert.True(decision.ShouldNotifyGroup);
+        Assert.True(decision.ShouldNotifyGm);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldKeepWaiting_WhenNotEveryoneConfirmed()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Confirmed,
+            SessionStatus.ConfirmationSent,
+            totalParticipants: 4,
+            confirmedParticipants: 2);
+
+        Assert.False(decision.ShouldMarkSessionConfirmed);
+        Assert.False(decision.ShouldNotifyGroup);
+        Assert.False(decision.ShouldNotifyGm);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Landing/TelegramLandingPromisesSmokeTests.cs

@@ -0,0 +1,392 @@
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.RescheduleSession;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+using Telegram.Bot.Types.ReplyMarkups;
+using GmRelay.Bot.Infrastructure.Telegram;
+
+namespace GmRelay.Bot.Tests.Features.Landing;
+
+public sealed class TelegramLandingPromisesSmokeTests
+{
+    [Fact]
+    public void Smoke_ShouldCoverTelegramLandingPromisesWithoutExternalTelegramApi()
+    {
+        var nowUtc = new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero);
+        var parseResult = NewSessionCommandParser.Parse(BuildRecurringSessionCommand(), nowUtc);
+
+        Assert.True(parseResult.IsValid);
+        Assert.Equal(3, parseResult.ScheduledTimes.Count);
+        Assert.Equal(2, parseResult.MaxPlayers);
+        Assert.Equal(TimeSpan.FromDays(7), parseResult.ScheduledTimes[1] - parseResult.ScheduledTimes[0]);
+
+        var scenario = TelegramLandingSmokeScenario.Publish(parseResult, SessionNotificationMode.GroupAndDirect);
+        var publishedCallbacks = CallbackData(scenario.LastMessage.Markup);
+
+        Assert.Contains("Landing Promise Smoke", scenario.LastMessage.Text);
+        Assert.Equal(6, publishedCallbacks.Count);
+        Assert.All(scenario.Sessions, session =>
+        {
+            Assert.Contains($"join_session:{session.Id}", publishedCallbacks);
+            Assert.Contains($"leave_session:{session.Id}", publishedCallbacks);
+            Assert.Contains(session.ScheduledAt.FormatMoscow(), scenario.LastMessage.Text);
+        });
+
+        var firstSessionId = scenario.Sessions[0].Id;
+        var alice = scenario.Join(firstSessionId, 1001, "Alice", "alice");
+        var bob = scenario.Join(firstSessionId, 1002, "Bob", "bob");
+        var carol = scenario.Join(firstSessionId, 1003, "Carol", "carol");
+
+        Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, alice));
+        Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, bob));
+        Assert.Equal(ParticipantRegistrationStatus.Waitlisted, scenario.RegistrationStatus(firstSessionId, carol));
+        Assert.Contains("2/2", scenario.LastMessage.Text);
+        Assert.Contains("@alice", scenario.LastMessage.Text);
+        Assert.Contains("@bob", scenario.LastMessage.Text);
+        Assert.Contains("@carol", scenario.LastMessage.Text);
+
+        scenario.Leave(firstSessionId, alice);
+
+        Assert.False(scenario.HasParticipant(firstSessionId, alice));
+        Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, carol));
+        Assert.DoesNotContain("@alice", scenario.LastMessage.Text);
+        Assert.Contains("@carol", scenario.LastMessage.Text);
+
+        scenario.MarkRsvpConfirmed(firstSessionId, bob);
+        scenario.MarkRsvpConfirmed(firstSessionId, carol);
+
+        var option1Id = Guid.NewGuid();
+        var option2Id = Guid.NewGuid();
+        var options = new[]
+        {
+            new RescheduleOptionDto(option1Id, 1, new DateTimeOffset(2026, 5, 29, 16, 30, 0, TimeSpan.Zero)),
+            new RescheduleOptionDto(option2Id, 2, new DateTimeOffset(2026, 5, 30, 15, 0, 0, TimeSpan.Zero))
+        };
+        var deadline = new DateTimeOffset(2026, 5, 20, 18, 0, 0, TimeSpan.Zero);
+        var voteParticipants = scenario.ActiveVoteParticipants(firstSessionId);
+        var voteMessage = HandleRescheduleTimeInputHandler.BuildVotingMessage(
+            scenario.Title,
+            scenario.Sessions[0].ScheduledAt,
+            deadline,
+            options,
+            voteParticipants,
+            []);
+        var voteKeyboard = HandleRescheduleTimeInputHandler.BuildVotingKeyboard(options);
+
+        Assert.Contains("Landing Promise Smoke", voteMessage);
+        Assert.Contains("0/2", voteMessage);
+        Assert.Contains($"reschedule_vote:{option1Id}", CallbackData(voteKeyboard));
+        Assert.Contains($"reschedule_vote:{option2Id}", CallbackData(voteKeyboard));
+
+        var votes = voteParticipants
+            .Select(participant => new RescheduleOptionVoteDto(
+                option2Id,
+                participant.PlayerId,
+                participant.DisplayName,
+                participant.TelegramUsername))
+            .ToList();
+        var decision = RescheduleVoteRules.SelectWinner(
+            options.Select(option => new RescheduleOptionVoteCount(
+                option.OptionId,
+                votes.Count(vote => vote.OptionId == option.OptionId))).ToList());
+
+        Assert.Equal(RescheduleVoteOutcome.Approved, decision.Outcome);
+        Assert.Equal(option2Id, decision.SelectedOptionId);
+
+        scenario.ApplyReschedule(firstSessionId, options[1].ProposedAt);
+
+        Assert.Equal(options[1].ProposedAt.UtcDateTime, scenario.Sessions[0].ScheduledAt);
+        Assert.Equal(RsvpStatus.Pending, scenario.RsvpStatus(firstSessionId, bob));
+        Assert.Equal(RsvpStatus.Pending, scenario.RsvpStatus(firstSessionId, carol));
+        Assert.Contains(options[1].ProposedAt.UtcDateTime.FormatMoscow(), scenario.LastMessage.Text);
+        Assert.Collection(
+            scenario.Messenger.DirectMessages.Select(message => message.TelegramId).Order(),
+            telegramId => Assert.Equal(1002, telegramId),
+            telegramId => Assert.Equal(1003, telegramId));
+        Assert.All(scenario.Messenger.DirectMessages, message =>
+        {
+            Assert.Contains("Landing Promise Smoke", message.Text);
+            Assert.Contains(options[1].ProposedAt.UtcDateTime.FormatMoscow(), message.Text);
+        });
+
+        var editsBeforeDashboardUpdate = scenario.Messenger.Edits.Count;
+
+        scenario.UpdateBatchFromDashboard("Landing Promise Smoke - Dashboard Sync");
+
+        Assert.True(scenario.Messenger.Edits.Count > editsBeforeDashboardUpdate);
+        Assert.Contains("Landing Promise Smoke - Dashboard Sync", scenario.LastMessage.Text);
+        Assert.Contains("@bob", scenario.LastMessage.Text);
+        Assert.Contains("@carol", scenario.LastMessage.Text);
+    }
+
+    private static string BuildRecurringSessionCommand() =>
+        string.Join(
+            '\n',
+            "/newsession",
+            "\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u0435: Landing Promise Smoke",
+            "\u0412\u0440\u0435\u043c\u044f: 15.05.2026 19:30",
+            "\u0418\u0433\u0440: 3",
+            "\u0418\u043d\u0442\u0435\u0440\u0432\u0430\u043b: 7",
+            "\u041c\u0435\u0441\u0442: 2",
+            "\u0421\u0441\u044b\u043b\u043a\u0430: https://example.test/table");
+
+    private static IReadOnlyList<string> CallbackData(InlineKeyboardMarkup markup) =>
+        markup.InlineKeyboard
+            .SelectMany(row => row)
+            .Select(button => button.CallbackData)
+            .OfType<string>()
+            .ToList();
+
+    private sealed class TelegramLandingSmokeScenario
+    {
+        private readonly List<SmokeSession> sessions;
+        private readonly List<SmokeParticipant> participants = [];
+        private readonly SessionNotificationMode notificationMode;
+
+        private TelegramLandingSmokeScenario(
+            string title,
+            IReadOnlyList<DateTimeOffset> scheduledTimes,
+            int? maxPlayers,
+            SessionNotificationMode notificationMode)
+        {
+            Title = title;
+            this.notificationMode = notificationMode;
+            sessions = scheduledTimes
+                .Select(scheduledAt => new SmokeSession(
+                    Guid.NewGuid(),
+                    scheduledAt.UtcDateTime,
+                    SessionStatus.Planned,
+                    maxPlayers))
+                .ToList();
+        }
+
+        public string Title { get; private set; }
+        public FakeTelegramMessenger Messenger { get; } = new();
+        public IReadOnlyList<SmokeSession> Sessions => sessions;
+        public FakeTelegramMessage LastMessage => Messenger.LastMessage;
+
+        public static TelegramLandingSmokeScenario Publish(
+            NewSessionParseResult parseResult,
+            SessionNotificationMode notificationMode)
+        {
+            var scenario = new TelegramLandingSmokeScenario(
+                parseResult.Title!,
+                parseResult.ScheduledTimes,
+                parseResult.MaxPlayers,
+                notificationMode);
+
+            scenario.RenderBatch();
+            return scenario;
+        }
+
+        public Guid Join(Guid sessionId, long telegramId, string displayName, string? telegramUsername)
+        {
+            var session = sessions.Single(value => value.Id == sessionId);
+            var activeParticipants = participants.Count(participant =>
+                participant.SessionId == sessionId &&
+                participant.RegistrationStatus == ParticipantRegistrationStatus.Active);
+            var registrationStatus = SessionCapacityRules.DecideJoinStatus(
+                session.MaxPlayers,
+                activeParticipants);
+            var playerId = Guid.NewGuid();
+
+            participants.Add(new SmokeParticipant(
+                sessionId,
+                playerId,
+                telegramId,
+                displayName,
+                telegramUsername,
+                registrationStatus,
+                GmRelay.Shared.Domain.RsvpStatus.Pending,
+                participants.Count));
+
+            RenderBatch();
+            return playerId;
+        }
+
+        public void Leave(Guid sessionId, Guid playerId)
+        {
+            var participant = participants.Single(value =>
+                value.SessionId == sessionId &&
+                value.PlayerId == playerId);
+            participants.Remove(participant);
+
+            var session = sessions.Single(value => value.Id == sessionId);
+            var activeParticipantsAfterLeave = participants.Count(value =>
+                value.SessionId == sessionId &&
+                value.RegistrationStatus == ParticipantRegistrationStatus.Active);
+            var waitlistedParticipants = participants.Count(value =>
+                value.SessionId == sessionId &&
+                value.RegistrationStatus == ParticipantRegistrationStatus.Waitlisted);
+
+            if (SessionCapacityRules.ShouldPromoteAfterParticipantLeaves(
+                    participant.RegistrationStatus,
+                    session.MaxPlayers,
+                    activeParticipantsAfterLeave,
+                    waitlistedParticipants))
+            {
+                var promoted = participants
+                    .Where(value =>
+                        value.SessionId == sessionId &&
+                        value.RegistrationStatus == ParticipantRegistrationStatus.Waitlisted)
+                    .OrderBy(value => value.JoinOrder)
+                    .First();
+
+                promoted.RegistrationStatus = ParticipantRegistrationStatus.Active;
+                promoted.RsvpStatus = GmRelay.Shared.Domain.RsvpStatus.Pending;
+            }
+
+            RenderBatch();
+        }
+
+        public bool HasParticipant(Guid sessionId, Guid playerId) =>
+            participants.Any(value => value.SessionId == sessionId && value.PlayerId == playerId);
+
+        public string RegistrationStatus(Guid sessionId, Guid playerId) =>
+            participants.Single(value =>
+                value.SessionId == sessionId &&
+                value.PlayerId == playerId).RegistrationStatus;
+
+        public string RsvpStatus(Guid sessionId, Guid playerId) =>
+            participants.Single(value =>
+                value.SessionId == sessionId &&
+                value.PlayerId == playerId).RsvpStatus;
+
+        public void MarkRsvpConfirmed(Guid sessionId, Guid playerId)
+        {
+            participants.Single(value =>
+                value.SessionId == sessionId &&
+                value.PlayerId == playerId).RsvpStatus = GmRelay.Shared.Domain.RsvpStatus.Confirmed;
+        }
+
+        public IReadOnlyList<VoteParticipantDto> ActiveVoteParticipants(Guid sessionId) =>
+            participants
+                .Where(value =>
+                    value.SessionId == sessionId &&
+                    value.RegistrationStatus == ParticipantRegistrationStatus.Active)
+                .OrderBy(value => value.DisplayName)
+                .Select(value => new VoteParticipantDto(
+                    value.PlayerId,
+                    value.DisplayName,
+                    value.TelegramUsername,
+                    value.TelegramId))
+                .ToList();
+
+        public void ApplyReschedule(Guid sessionId, DateTimeOffset newScheduledAt)
+        {
+            sessions.Single(value => value.Id == sessionId).ScheduledAt = newScheduledAt.UtcDateTime;
+
+            foreach (var participant in participants.Where(value =>
+                         value.SessionId == sessionId &&
+                         value.RegistrationStatus == ParticipantRegistrationStatus.Active))
+            {
+                participant.RsvpStatus = GmRelay.Shared.Domain.RsvpStatus.Pending;
+            }
+
+            RenderBatch();
+
+            if (!notificationMode.ShouldSendDirectMessages())
+            {
+                return;
+            }
+
+            var notification = $"""
+                Reschedule approved
+                {Title}
+                {newScheduledAt.UtcDateTime.FormatMoscow()}
+                """;
+            foreach (var participant in participants.Where(value =>
+                         value.SessionId == sessionId &&
+                         value.RegistrationStatus == ParticipantRegistrationStatus.Active))
+            {
+                Messenger.SendDirectMessage(participant.TelegramId, notification);
+            }
+        }
+
+        public void UpdateBatchFromDashboard(string title)
+        {
+            Title = title;
+            RenderBatch();
+        }
+
+        private void RenderBatch()
+        {
+            var view = SessionBatchViewBuilder.Build(
+                Title,
+                sessions
+                    .Select(session => new SessionBatchDto(
+                        session.Id,
+                        session.ScheduledAt,
+                        session.Status,
+                        session.MaxPlayers))
+                    .ToList(),
+                participants
+                    .Select(participant => new ParticipantBatchDto(
+                        participant.SessionId,
+                        participant.DisplayName,
+                        participant.TelegramUsername,
+                        participant.RegistrationStatus))
+                    .ToList());
+            var renderResult = TelegramSessionBatchRenderer.Render(view);
+
+            if (Messenger.HasPublishedMessage)
+            {
+                Messenger.EditBatchMessage(renderResult.Text, renderResult.Markup);
+            }
+            else
+            {
+                Messenger.PublishBatchMessage(renderResult.Text, renderResult.Markup);
+            }
+        }
+    }
+
+    private sealed class FakeTelegramMessenger
+    {
+        private const int BatchMessageId = 7001;
+
+        public List<FakeTelegramMessage> Sends { get; } = [];
+        public List<FakeTelegramMessage> Edits { get; } = [];
+        public List<FakeDirectMessage> DirectMessages { get; } = [];
+        public bool HasPublishedMessage => Sends.Count > 0;
+        public FakeTelegramMessage LastMessage => Edits.Count > 0 ? Edits[^1] : Sends[^1];
+
+        public void PublishBatchMessage(string text, InlineKeyboardMarkup markup) =>
+            Sends.Add(new FakeTelegramMessage(BatchMessageId, text, markup));
+
+        public void EditBatchMessage(string text, InlineKeyboardMarkup markup) =>
+            Edits.Add(new FakeTelegramMessage(BatchMessageId, text, markup));
+
+        public void SendDirectMessage(long telegramId, string text) =>
+            DirectMessages.Add(new FakeDirectMessage(telegramId, text));
+    }
+
+    private sealed record FakeTelegramMessage(
+        int MessageId,
+        string Text,
+        InlineKeyboardMarkup Markup);
+
+    private sealed record FakeDirectMessage(long TelegramId, string Text);
+
+    private sealed record SmokeSession(
+        Guid Id,
+        DateTime ScheduledAt,
+        string Status,
+        int? MaxPlayers)
+    {
+        public DateTime ScheduledAt { get; set; } = ScheduledAt;
+    }
+
+    private sealed record SmokeParticipant(
+        Guid SessionId,
+        Guid PlayerId,
+        long TelegramId,
+        string DisplayName,
+        string? TelegramUsername,
+        string RegistrationStatus,
+        string RsvpStatus,
+        int JoinOrder)
+    {
+        public string RegistrationStatus { get; set; } = RegistrationStatus;
+        public string RsvpStatus { get; set; } = RsvpStatus;
+    }
+}