fix: create Telegram topics for template batches

Create a Telegram forum topic when Web creates a batch from a campaign template, persist thread ownership on the generated sessions, and send the batch schedule into that topic.

Bump version -> 3.1.1

.env.example

@@ -10,6 +10,17 @@ TELEGRAM_BOT_USERNAME=YOUR_BOT_USERNAME_HERE
 # Используется ботом для кнопки меню Telegram и кнопки /start.
 TELEGRAM_MINI_APP_URL=
 
+# Токен Discord application bot
+# Можно получить в Discord Developer Portal (https://discord.com/developers/applications)
+DISCORD_BOT_TOKEN=YOUR_DISCORD_BOT_TOKEN_HERE
+
+# Discord OAuth (для Web Dashboard)
+# Client ID и Secret из OAuth2 раздела Discord Developer Portal
+# Redirect URI должен указывать на /auth/discord/callback вашего домена
+DISCORD_CLIENT_ID=YOUR_DISCORD_CLIENT_ID_HERE
+DISCORD_CLIENT_SECRET=YOUR_DISCORD_CLIENT_SECRET_HERE
+DISCORD_REDIRECT_URI=https://your-domain.example/auth/discord/callback
+
 # Пароль для базы данных PostgreSQL
 POSTGRES_PASSWORD=StrongPasswordForDatabase
 

.gitea/workflows/deploy.yml

@@ -6,7 +6,7 @@ on:
       - main 
 
 env:
-  VERSION: 2.7.0
+  VERSION: 3.1.1
 
 jobs:
   # ЧАСТЬ 1: Собираем образы и кладем в Gitea (чтобы делиться с ребятами)
@@ -113,14 +113,47 @@ jobs:
           echo "DISCORD_BOT_TOKEN=${{ secrets.DISCORD_BOT_TOKEN }}" >> .env
           echo "TELEGRAM_BOT_USERNAME=${{ secrets.TELEGRAM_BOT_USERNAME }}" >> .env
           echo "TELEGRAM_MINI_APP_URL=${{ secrets.TELEGRAM_MINI_APP_URL }}" >> .env
+          echo "DISCORD_CLIENT_ID=${{ secrets.DISCORD_CLIENT_ID }}" >> .env
+          echo "DISCORD_CLIENT_SECRET=${{ secrets.DISCORD_CLIENT_SECRET }}" >> .env
+          echo "DISCORD_REDIRECT_URI=${{ secrets.DISCORD_REDIRECT_URI }}" >> .env
 
       - name: Deploy Containers
         run: |
           # Авторизуемся локальным докером в нашей Gitea
           docker login git.codeanddice.ru/ -u toutsu -p ${{ secrets.GIT_TOKEN }}
-          
+
           # Pull гарантирует, что мы получили нужную версию.
           docker compose pull bot discord web
-          
+
           # Запускаем! Флаг -d оставит их работать в фоне.
           docker compose up -d
+
+          # Ждём, пока сервисы перейдут в healthy или упадут
+          SERVICES="bot discord web"
+          MAX_WAIT=40
+          INTERVAL=5
+          ELAPSED=0
+
+          while [ $ELAPSED -lt $MAX_WAIT ]; do
+            NOT_HEALTHY=0
+            for svc in $SERVICES; do
+              HEALTH=$(docker compose ps $svc --format="{{.Health}}" 2>/dev/null | head -n1)
+              if [ "$HEALTH" != "healthy" ]; then
+                STATE=$(docker compose ps $svc --format="{{.State}}" 2>/dev/null | head -n1)
+                echo "❌ $svc not healthy yet (state: ${STATE:-unknown})"
+                NOT_HEALTHY=$((NOT_HEALTHY + 1))
+              fi
+            done
+
+            if [ $NOT_HEALTHY -eq 0 ]; then
+              echo "✅ All services are healthy!"
+              exit 0
+            fi
+
+            sleep $INTERVAL
+            ELAPSED=$((ELAPSED + INTERVAL))
+          done
+
+          echo "⏰ Timed out waiting for services to become healthy"
+          docker compose ps
+          exit 1

Directory.Build.props

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

README.md

@@ -4,7 +4,7 @@
 
 Проект разработан с упором на производительность, архитектуру Vertical Slice, Native AOT (для бота) и удобство развертывания с использованием .NET Aspire.
 
-**Текущая версия:** `v2.7.0`.
+**Текущая версия:** `v2.8.0`.
 
 ---
 
@@ -25,11 +25,11 @@
 - **🔄 Автоматическая синхронизация**: Любые изменения в веб-интерфейсе мгновенно обновляют сообщения с расписанием в подключенных Telegram- и Discord-каналах.
 
 ### Discord Bot
-- **Slash-команды расписания**: GM создаёт сессию через `/newsession` и публикует актуальное расписание через `/listsessions`.
-- **Кнопки записи и выхода**: игроки нажимают Join/Leave в Discord-сообщении; бот отвечает ephemeral-сообщением и обновляет schedule message.
-- **Подтверждения и RSVP**: scheduler публикует запрос подтверждения в Discord-канале, игроки отвечают кнопками, а GM получает исходы RSVP через платформенный messenger.
-- **Напоминания и ссылки**: one-hour reminders и join-link notifications отправляются в Discord DM при включенных личных уведомлениях; сбои DM логируются без публичного fallback.
-- **Переносы**: deadline-сервис обновляет Discord vote message и schedule message через `IPlatformMessenger`.
+- **Slash-команды `/newsession` и `/listsessions`**: GM создаёт сессии и публикует актуальное расписание прямо в Discord-канале.
+- **Кнопки Join/Leave с ephemeral-ответами**: игроки нажимают Join/Leave в Discord-сообщении; бот отвечает ephemeral-сообщением и обновляет schedule message.
+- **RSVP (подтверждения) за 24ч до сессии**: scheduler публикует запрос подтверждения в Discord-канале, игроки отвечают кнопками, а GM получает итоги RSVP.
+- **DM-напоминания за 1ч и ссылки перед игрой**: one-hour reminders и join-link notifications отправляются в Discord DM при включённых личных уведомлениях; сбои DM логируются без публичного fallback.
+- **Reschedule voting (голосование за перенос)**: deadline-сервис обновляет Discord vote message и schedule message через `IPlatformMessenger`.
 - **Лимиты и waitlist**: при заполненном составе игрок попадает в waitlist, а при выходе участника первый ожидающий автоматически продвигается в основной состав.
 
 ### 🌐 Web Dashboard (Blazor Server)
@@ -55,7 +55,7 @@
 |---|---|
 | Язык | C# 14 (.NET 10) |
 | Архитектура | Vertical Slice + общая библиотека `GmRelay.Shared` |
-| Боты | Telegram.Bot (**Native AOT**), NetCord Gateway (Discord worker) |
+| Боты | Telegram.Bot (**Native AOT**), NetCord Gateway (Discord worker внутри `GmRelay.Bot`) |
 | Веб | Blazor Server |
 | Оркестрация | .NET Aspire (`GmRelay.AppHost`) |
 | БД | PostgreSQL |
@@ -85,6 +85,11 @@ TELEGRAM_BOT_TOKEN=ваш_токен_здесь
 # Токен Discord application bot
 DISCORD_BOT_TOKEN=ваш_discord_токен_здесь
 
+# Discord OAuth (для Web Dashboard)
+DISCORD_CLIENT_ID=ваш_discord_client_id_здесь
+DISCORD_CLIENT_SECRET=ваш_discord_client_secret_здесь
+DISCORD_REDIRECT_URI=https://your-domain.example/auth/discord/callback
+
 # Имя бота без @ (для Telegram Login Widget)
 TELEGRAM_BOT_USERNAME=ваше_имя_бота_здесь
 
@@ -109,15 +114,15 @@ docker compose up -d
 - создание Docker-сети и volume PostgreSQL;
 - подъём PostgreSQL (`db:5432`);
 - запуск бота с плавной миграцией (DbUp);
-- запуск отдельного Discord Gateway worker на NetCord;
+- запуск Discord Gateway worker на NetCord (healthcheck на `:8082`);
 - запуск веб-приложения с подключением к БД и Telegram API.
 
 ### 3. Первоначальная настройка
 1. Напишите боту `/start`.
 2. Создайте группу через `/newgroup`.
 3. Откройте Mini App или Web Dashboard для расширенного управления.
-4. Для Discord пригласите application bot на сервер с правами `bot` и `applications.commands`.
-5. В Discord создайте сессию через `/newsession` или опубликуйте расписание через `/listsessions`; игроки записываются и выходят кнопками в опубликованном сообщении.
+4. Для Discord пригласите application bot на сервер с правами `bot` и `applications.commands`. Скопируйте `DISCORD_BOT_TOKEN` в `.env`; `DISCORD_CLIENT_ID`, `DISCORD_CLIENT_SECRET` и `DISCORD_REDIRECT_URI` нужны только для входа в Web Dashboard через Discord.
+5. Перезапустите Docker Compose (`docker compose up -d`), а затем в Discord создайте сессию через `/newsession` или опубликуйте расписание через `/listsessions`; игроки записываются и выходят кнопками в опубликованном сообщении.
 
 ## 💾 Backup и восстановление
 
@@ -164,8 +169,7 @@ BACKUP_VOLUME_NAME=game_pgbackups
 ```
 ├── src/
 │   ├── GmRelay.AppHost/         # .NET Aspire orchestrator
-│   ├── GmRelay.Bot/             # Telegram-бот (Native AOT)
-│   ├── GmRelay.DiscordBot/      # Discord Gateway worker на NetCord
+│   ├── GmRelay.Bot/             # Telegram- и Discord-бот (Native AOT + NetCord Gateway worker)
 │   ├── GmRelay.ServiceDefaults/  # Aspire service defaults
 │   ├── GmRelay.Shared/          # Общие доменные модели
 │   └── GmRelay.Web/             # Blazor Server dashboard
@@ -177,6 +181,16 @@ BACKUP_VOLUME_NAME=game_pgbackups
 
 ---
 
+## 👨‍💻 Для разработчиков
+
+- **Архитектура**: проект следует Vertical Slice с явным DI. Подробности — в [ADR-001](docs/adr/0001-use-vertical-slice-native-aot-and-aspire.md) и [ADR-002](docs/adr/002-platform-neutral-batch-rendering.md).
+- **Добавление обработчика**: из-за Native AOT все DI-регистрации выполняются вручную в `src/GmRelay.Bot/Program.cs` (assembly scanning не используется).
+- **Миграции**: SQL-скрипты добавляются как embedded resources в `src/GmRelay.Bot/Migrations/` и применяются автоматически при старте бота через DbUp.
+- **Тесты**: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --verbosity normal`
+- **Сборка**: `dotnet build`
+
+---
+
 ## 📜 Лицензия
 
 MIT License. См. [LICENSE](./LICENSE).

compose.yaml

@@ -49,7 +49,7 @@ services:
         crond -f
 
   bot:
-    image: git.codeanddice.ru/toutsu/gmrelay-bot:2.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-bot:3.1.1
     restart: always
     depends_on:
       db:
@@ -67,7 +67,7 @@ services:
       retries: 3
 
   discord:
-    image: git.codeanddice.ru/toutsu/gmrelay-discord-bot:2.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-discord-bot:3.1.1
     restart: always
     depends_on:
       db:
@@ -77,9 +77,14 @@ services:
       - "Discord__Token=${DISCORD_BOT_TOKEN:?Set DISCORD_BOT_TOKEN in .env}"
     networks:
       - gmrelay
+    healthcheck:
+      test: ["CMD-SHELL", "wget -qO- http://localhost:8082/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
 
   web:
-    image: git.codeanddice.ru/toutsu/gmrelay-web:2.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-web:3.1.1
     restart: always
     depends_on:
       db:
@@ -89,6 +94,9 @@ services:
       - "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:-}"
+      - "Discord__ClientId=${DISCORD_CLIENT_ID:-}"
+      - "Discord__ClientSecret=${DISCORD_CLIENT_SECRET:-}"
+      - "Discord__RedirectUri=${DISCORD_REDIRECT_URI:-}"
     ports:
       - "${GMRELAY_WEB_PORT:-8080}:8080"
     volumes:

docs/adr/0001-use-vertical-slice-native-aot-and-aspire.md

@@ -56,8 +56,18 @@ Aspire обеспечивает:
 - Service discovery и передачу connection strings.
 - OpenTelemetry (traces, metrics, logs) из коробки.
 - Aspire Dashboard для мониторинга.
+- **Три сервиса:** Bot (Telegram long polling + Discord Gateway), Web, PostgreSQL.
 
-### 5. Telegram.Bot 22.x + Long Polling
+### 5. Discord Gateway + NetCord
+
+Discord-интеграция реализована через NetCord Gateway (не DSharpPlus) из-за:
+- Нативной совместимости с .NET 10 и минимального размера зависимостей.
+- Gateway events маршрутизируются в те же vertical slice handlers, что и Telegram updates.
+- Slash-команды регистрируются через NetCord `ApplicationCommandService`.
+
+Ephemeral-ответы (кнопки Join/Leave/RSVP) используют `InteractionMessageProperties` с `Flags = MessageFlags.Ephemeral`.
+
+### 6. Telegram.Bot 22.x + Long Polling
 
 - Long Polling — единственный вариант для Pi за NAT.
 - Telegram.Bot поддерживает `System.Text.Json` source generators для AOT.

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

@@ -62,5 +62,8 @@ SessionBatchViewModel (platform-neutral)
 
 - Issue #22 — этот рефакторинг.
 - Issue #26 — Discord Bot MVP (потребитель новой архитектуры).
-- Issue #31 — scheduler notifications and reschedule deadline updates now use `IPlatformMessenger` for Telegram and Discord.
+- Issue #30 — Discord reschedule voting использует `IPlatformMessenger`.
+- Issue #31 — scheduler notifications и reschedule deadline updates через `IPlatformMessenger`.
+- Issue #32 — compose wiring для Discord bot (healthcheck :8082).
+- Issue #33 — регрессионные тесты platform rendering (Telegram + Discord).
 - ADR 001 — vertical slice, native AOT, Aspire (`docs/adr/0001-use-vertical-slice-native-aot-and-aspire.md`).

docs/adr/003-discord-integration-architecture.md

@@ -0,0 +1,57 @@
+# ADR 003: Discord Integration Architecture
+
+## Status
+
+**Accepted** — implemented in v2.6.0 (PR #87, issue #30).
+
+## Context
+
+После Telegram-бота требовалась поддержка Discord для кросс-платформенных групп. Нужно было выбрать:
+1. Библиотеку для Discord API (NetCord vs DSharpPlus vs Discord.NET).
+2. Модель runtime (отдельный процесс vs тот же Worker).
+3. Способ обработки интеракций (Gateway events vs HTTP interactions).
+
+## Decision
+
+### 1. NetCord (не DSharpPlus, не Discord.NET)
+
+- **NetCord** — лёгкий, AOT-compatible, minimal dependencies.
+- **DSharpPlus** — слишком тяжёлый, много зависимостей, reflection-heavy.
+- **Discord.NET** — несовместим с Native AOT (heavy reflection, dynamic IL).
+
+### 2. Gateway Events внутри GmRelay.Bot
+
+- Discord Gateway worker живёт **внутри** `GmRelay.Bot` (тот же Worker Service), а не как отдельный проект.
+- Это упрощает DI, shared DB connection, shared `IPlatformMessenger`.
+- Для масштабирования можно вынести в отдельный контейнер позже.
+
+### 3. Slash-команды через NetCord ApplicationCommandService
+
+- Регистрация глобальных slash-команд (`/newsession`, `/listsessions`) через `ApplicationCommandService`.
+- Команды мапятся на vertical slice handlers через `DiscordSessionInteractionModule`.
+
+### 4. Ephemeral Replies
+
+- Все кнопки (Join/Leave/RSVP) отвечают ephemeral (`MessageFlags.Ephemeral`).
+- Schedule message редактируется через `DiscordPlatformMessenger` (реализация `IPlatformMessenger`).
+
+## Consequences
+
+### Positive
+
+- Один бинарник для Telegram + Discord.
+- Shared DI, shared DB pool, shared domain logic.
+- Native AOT совместимость.
+
+### Negative
+
+- Gateway connection требует persistent WebSocket — при разрыве происходит reconnect.
+- Discord rate limits агрессивнее Telegram — нужен backoff.
+
+## Related
+
+- Issue #30 — reschedule voting (кнопки + дедлайн).
+- Issue #31 — scheduler notifications через `IPlatformMessenger`.
+- Issue #32 — compose wiring + healthcheck.
+- ADR 001 — Vertical Slice, Native AOT, Aspire.
+- ADR 002 — Platform-Neutral Rendering.

docs/c4-system-context.md

@@ -37,7 +37,7 @@ C4Container
 
     System_Boundary(runtime, "Docker Compose / Aspire runtime") {
         Container(bot, "GmRelay.Bot", "Worker Service, .NET 10 AOT", "Telegram long polling, commands, callback routing, reminders")
-        Container(discordBot, "GmRelay.DiscordBot", "Worker Service, .NET 10", "NetCord Gateway, slash commands, scheduler notifications, and button interactions")
+        Container(discordBot, "Discord Gateway Worker", "Внутри GmRelay.Bot", "NetCord Gateway, slash commands, scheduler notifications, button interactions, healthcheck :8082")
         Container(web, "GmRelay.Web", "Blazor Server", "Dashboard, Mini App pages, editing and stats")
         Container(shared, "GmRelay.Shared", ".NET library", "Shared domain models, rendering, scheduler, and platform-neutral handlers")
         ContainerDb(db, "PostgreSQL", "Database", "sessions, players, session_participants, game_groups, platform identities")
@@ -77,6 +77,8 @@ C4Component
         Component(renderer, "SessionBatchViewBuilder", "Renderer model builder", "Builds platform-neutral schedule views and actions")
     }
 
+    Component(healthCheck, "DiscordHealthCheckHostedService", ":8082", "Healthcheck для Docker Compose")
+
     Container_Boundary(discordBot, "GmRelay.DiscordBot") {
         Component(discordModule, "DiscordSessionInteractionModule", "NetCord component module", "Maps join_session/leave_session/rsvp buttons to neutral commands")
         Component(discordMessenger, "DiscordPlatformMessenger", "IPlatformMessenger", "Sends and edits Discord schedule, RSVP, reminder, join-link, and reschedule messages")
@@ -117,4 +119,5 @@ C4Component
     Rel(scheduler, telegramMessenger, "Send Telegram scheduler notifications")
     Rel(discordMessenger, discord, "REST send/edit/DM + ephemeral text")
     Rel(telegramMessenger, telegram, "SendMessage/EditMessage + AnswerCallbackQuery")
+    Rel(healthCheck, discord, "HTTP /health")
 ```

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

@@ -1,438 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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/plans/2026-05-15-platform-messenger-contracts.md

@@ -1,560 +0,0 @@
-# Platform Messenger Contracts 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:** Implement issue #24 by adding platform-neutral platform identity and messaging contracts, then routing the Telegram session flows through a Telegram adapter without changing Telegram behavior.
-
-**Architecture:** Keep update routing and Telegram update parsing at the `GmRelay.Bot.Infrastructure.Telegram` boundary, but move outbound messaging decisions behind `GmRelay.Shared.Platform.IPlatformMessenger`. `GmRelay.Shared` owns platform-neutral DTOs and contracts; `GmRelay.Bot` owns `TelegramPlatformMessenger`, which translates neutral requests into `Telegram.Bot` calls and reuses the existing Telegram renderers/editing rules.
-
-**Tech Stack:** .NET 10, C# preview, xUnit, Dapper.AOT constraints, Telegram.Bot in `GmRelay.Bot` only, platform-neutral shared contracts in `GmRelay.Shared`.
-
----
-
-## Issue Context
-
-- Gitea issue: #24, `refactor: ввести PlatformKind, PlatformUser, PlatformGroup и IPlatformMessenger`
-- Labels: `area:bot`, `area:platform`, `area:shared`, `platform:multi`, `type:refactor`, `pending-approval`
-- Acceptance criteria:
-  - New contracts live in a platform-neutral layer.
-  - Telegram flow goes through the adapter without behavior changes.
-  - A future DiscordBot can reference the contract without depending on Telegram assemblies.
-
-## Proposed Version Bump
-
-Current version is `2.0.0` in:
-
-- `Directory.Build.props`
-- `compose.yaml`
-- `.gitea/workflows/deploy.yml`
-- `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-Issue label is `type:refactor`; per workflow rules this is not a major bump and has no user-facing feature label. Proposed bump: `2.0.0` -> `2.0.1`.
-
-## Files
-
-- Create: `src/GmRelay.Shared/Platform/PlatformKind.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformUser.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformGroup.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformMessageContracts.cs`
-- Create: `src/GmRelay.Shared/Platform/IPlatformMessenger.cs`
-- Create: `src/GmRelay.Bot/Infrastructure/Telegram/TelegramPlatformMessenger.cs`
-- Create: `tests/GmRelay.Bot.Tests/Platform/PlatformContractsTests.cs`
-- Create: `tests/GmRelay.Bot.Tests/Infrastructure/Telegram/TelegramPlatformMessengerSourceTests.cs`
-- Modify: `src/GmRelay.Bot/Program.cs`
-- Modify: `src/GmRelay.Bot/Features/Notifications/DirectSessionNotificationSender.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/CancelSessionHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/PromoteWaitlistedPlayerHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/RescheduleSession/InitiateRescheduleHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleVoteHandler.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingDeadlineService.cs`
-- Modify: `src/GmRelay.Bot/Features/Sessions/ExportCalendar/ExportCalendarHandler.cs`
-- Modify: version files listed above
-
-## Design
-
-### Shared Contracts
-
-`PlatformKind` is a sentinel enum where `Max` is not a sendable platform:
-
-```csharp
-namespace GmRelay.Shared.Platform;
-
-public enum PlatformKind
-{
-    Telegram = 0,
-    Discord = 1,
-    Max = 2
-}
-```
-
-`PlatformUser` and `PlatformGroup` carry external platform identity while keeping current Telegram IDs representable as strings:
-
-```csharp
-namespace GmRelay.Shared.Platform;
-
-public sealed record PlatformUser(
-    PlatformKind Platform,
-    string ExternalUserId,
-    string DisplayName,
-    string? ExternalUsername);
-
-public sealed record PlatformGroup(
-    PlatformKind Platform,
-    string ExternalGroupId,
-    string DisplayName,
-    string? ExternalChannelId = null,
-    string? ExternalThreadId = null);
-```
-
-Outbound message contracts stay independent of Telegram/Discord SDK types:
-
-```csharp
-using GmRelay.Shared.Rendering;
-
-namespace GmRelay.Shared.Platform;
-
-public sealed record PlatformMessageRef(
-    PlatformKind Platform,
-    string ExternalGroupId,
-    string? ExternalThreadId,
-    string ExternalMessageId);
-
-public sealed record PlatformMessageAction(
-    string Key,
-    string Label,
-    string Payload);
-
-public sealed record PlatformScheduleMessage(
-    PlatformGroup Group,
-    SessionBatchViewModel View,
-    PlatformMessageRef? ExistingMessage,
-    string? ImageReference = null);
-
-public sealed record PlatformPrivateMessage(
-    PlatformUser Recipient,
-    string HtmlText);
-
-public sealed record PlatformInteractionReply(
-    string InteractionId,
-    string Text,
-    bool ShowAlert = false);
-
-public sealed record PlatformCalendarFile(
-    PlatformGroup Group,
-    string FileName,
-    byte[] Content,
-    string CaptionHtml,
-    IReadOnlyList<PlatformMessageAction> Actions);
-```
-
-`IPlatformMessenger` exposes the required outward operations:
-
-```csharp
-namespace GmRelay.Shared.Platform;
-
-public interface IPlatformMessenger
-{
-    Task<PlatformMessageRef> SendScheduleAsync(PlatformScheduleMessage message, CancellationToken ct);
-    Task UpdateScheduleAsync(PlatformScheduleMessage message, CancellationToken ct);
-    Task SendGroupMessageAsync(PlatformGroup group, string htmlText, CancellationToken ct);
-    Task SendPrivateMessageAsync(PlatformPrivateMessage message, CancellationToken ct);
-    Task AnswerInteractionAsync(PlatformInteractionReply reply, CancellationToken ct);
-    Task SendCalendarFileAsync(PlatformCalendarFile file, CancellationToken ct);
-}
-```
-
-### Telegram Adapter
-
-`TelegramPlatformMessenger` lives in `GmRelay.Bot.Infrastructure.Telegram`, depends on `ITelegramBotClient`, and translates neutral DTOs to existing Telegram calls:
-
-- `SendScheduleAsync` renders `SessionBatchViewModel` with `TelegramSessionBatchRenderer.Render`.
-- `UpdateScheduleAsync` calls `BatchMessageEditor.EditBatchMessageAsync`.
-- `SendGroupMessageAsync` calls `SendMessage` with `ParseMode.Html` and optional `messageThreadId`.
-- `SendPrivateMessageAsync` calls `SendMessage` to `PlatformUser.ExternalUserId`.
-- `AnswerInteractionAsync` calls `AnswerCallbackQuery`.
-- `SendCalendarFileAsync` calls `SendDocument` and maps URL actions to inline keyboard buttons.
-
-### Handler Scope
-
-Refactor outbound Telegram calls in these flows to `IPlatformMessenger`:
-
-- Join/leave/promote waitlist schedule updates and callback replies.
-- Cancel schedule update, group cancellation message, direct notification and callback reply.
-- Reschedule initiation, voting message updates, immediate reschedule schedule update, direct notifications and callback replies.
-- Export calendar file sending.
-
-Keep Telegram inbound DTOs at the boundary for now:
-
-- `UpdateRouter` still receives `Telegram.Bot.Types.Update`.
-- Text message parsing in reschedule input still receives `Telegram.Bot.Types.Message`.
-- `CreateSessionHandler` can keep photo/topic creation via `ITelegramBotClient` because issue #24 targets outbound schedule/interaction/private/calendar contract, not replacing all Telegram update primitives in one PR.
-
-## Tasks
-
-### Task 1: RED - Shared Contract Tests
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Platform/PlatformContractsTests.cs`
-
-- [ ] **Step 1: Write failing tests for neutral contracts**
-
-```csharp
-using GmRelay.Shared.Platform;
-using GmRelay.Shared.Rendering;
-
-namespace GmRelay.Bot.Tests.Platform;
-
-public sealed class PlatformContractsTests
-{
-    [Fact]
-    public void PlatformKind_ShouldDefineTelegramDiscordAndMaxSentinel()
-    {
-        Assert.Equal(0, (int)PlatformKind.Telegram);
-        Assert.Equal(1, (int)PlatformKind.Discord);
-        Assert.Equal(2, (int)PlatformKind.Max);
-    }
-
-    [Fact]
-    public void PlatformContracts_ShouldBeTelegramAssemblyFree()
-    {
-        var contractTypes = new[]
-        {
-            typeof(PlatformUser),
-            typeof(PlatformGroup),
-            typeof(PlatformMessageRef),
-            typeof(PlatformMessageAction),
-            typeof(PlatformScheduleMessage),
-            typeof(PlatformPrivateMessage),
-            typeof(PlatformInteractionReply),
-            typeof(PlatformCalendarFile),
-            typeof(IPlatformMessenger)
-        };
-
-        Assert.All(contractTypes, type =>
-            Assert.DoesNotContain(
-                "Telegram",
-                string.Join(" ", type.Assembly.GetReferencedAssemblies().Select(value => value.Name)),
-                StringComparison.OrdinalIgnoreCase));
-    }
-
-    [Fact]
-    public void PlatformScheduleMessage_ShouldCarrySharedViewModelWithoutPlatformTypes()
-    {
-        var sessionId = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
-        var view = SessionBatchViewBuilder.Build(
-            "Campaign",
-            [new SessionBatchDto(sessionId, new DateTime(2026, 5, 15, 16, 0, 0, DateTimeKind.Utc), "Planned", 4, "https://example.test/game")],
-            []);
-        var group = new PlatformGroup(PlatformKind.Discord, "guild-1", "Guild", "channel-1", "thread-1");
-
-        var message = new PlatformScheduleMessage(group, view, ExistingMessage: null);
-
-        Assert.Equal(PlatformKind.Discord, message.Group.Platform);
-        Assert.Same(view, message.View);
-    }
-}
-```
-
-- [ ] **Step 2: Run tests and verify RED**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter PlatformContractsTests
-```
-
-Expected: compile failure because `GmRelay.Shared.Platform` types do not exist.
-
-### Task 2: GREEN - Add Shared Contracts
-
-**Files:**
-- Create: `src/GmRelay.Shared/Platform/PlatformKind.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformUser.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformGroup.cs`
-- Create: `src/GmRelay.Shared/Platform/PlatformMessageContracts.cs`
-- Create: `src/GmRelay.Shared/Platform/IPlatformMessenger.cs`
-
-- [ ] **Step 1: Add the contract files exactly as described in the Design section**
-- [ ] **Step 2: Run PlatformContractsTests and verify GREEN**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter PlatformContractsTests
-```
-
-Expected: `Passed`.
-
-### Task 3: RED - Adapter and Flow Source Tests
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Infrastructure/Telegram/TelegramPlatformMessengerSourceTests.cs`
-
-- [ ] **Step 1: Write source tests for adapter wiring and target flows**
-
-```csharp
-namespace GmRelay.Bot.Tests.Infrastructure.Telegram;
-
-public sealed class TelegramPlatformMessengerSourceTests
-{
-    [Fact]
-    public async Task Program_ShouldRegisterTelegramPlatformMessenger()
-    {
-        var program = await ReadRepositoryFileAsync("src/GmRelay.Bot/Program.cs");
-
-        Assert.Contains("IPlatformMessenger", program, StringComparison.Ordinal);
-        Assert.Contains("TelegramPlatformMessenger", program, StringComparison.Ordinal);
-    }
-
-    [Theory]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/CreateSession/CancelSessionHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/CreateSession/PromoteWaitlistedPlayerHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/RescheduleSession/InitiateRescheduleHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleTimeInputHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/RescheduleSession/HandleRescheduleVoteHandler.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/RescheduleSession/RescheduleVotingDeadlineService.cs")]
-    [InlineData("src/GmRelay.Bot/Features/Sessions/ExportCalendar/ExportCalendarHandler.cs")]
-    public async Task SessionFlows_ShouldUsePlatformMessengerForOutboundTelegramWork(string relativePath)
-    {
-        var source = await ReadRepositoryFileAsync(relativePath);
-
-        Assert.Contains("IPlatformMessenger", source, StringComparison.Ordinal);
-        Assert.DoesNotContain("BatchMessageEditor.EditBatchMessageAsync", source, StringComparison.Ordinal);
-        Assert.DoesNotContain(".AnswerCallbackQuery(", source, StringComparison.Ordinal);
-    }
-
-    [Fact]
-    public async Task TelegramPlatformMessenger_ShouldOwnTelegramBotClientCalls()
-    {
-        var source = await ReadRepositoryFileAsync("src/GmRelay.Bot/Infrastructure/Telegram/TelegramPlatformMessenger.cs");
-
-        Assert.Contains("ITelegramBotClient", source, StringComparison.Ordinal);
-        Assert.Contains("BatchMessageEditor.EditBatchMessageAsync", source, StringComparison.Ordinal);
-        Assert.Contains("AnswerCallbackQuery", source, StringComparison.Ordinal);
-        Assert.Contains("SendDocument", source, StringComparison.Ordinal);
-    }
-
-    private static async Task<string> ReadRepositoryFileAsync(string relativePath)
-    {
-        var directory = new DirectoryInfo(AppContext.BaseDirectory);
-        while (directory is not null)
-        {
-            var candidate = Path.Combine(directory.FullName, relativePath);
-            if (File.Exists(candidate))
-            {
-                return await File.ReadAllTextAsync(candidate);
-            }
-
-            directory = directory.Parent;
-        }
-
-        throw new FileNotFoundException($"Could not locate repository file '{relativePath}'.");
-    }
-}
-```
-
-- [ ] **Step 2: Run tests and verify RED**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter TelegramPlatformMessengerSourceTests
-```
-
-Expected: failures because `TelegramPlatformMessenger` is missing and handlers still call Telegram APIs directly.
-
-### Task 4: GREEN - Implement TelegramPlatformMessenger and Registration
-
-**Files:**
-- Create: `src/GmRelay.Bot/Infrastructure/Telegram/TelegramPlatformMessenger.cs`
-- Modify: `src/GmRelay.Bot/Program.cs`
-
-- [ ] **Step 1: Implement adapter**
-
-Implementation notes:
-
-- Parse Telegram chat/thread/message IDs from neutral string IDs with `long.Parse` and `int.Parse`.
-- Use `ParseMode.Html` for HTML text.
-- Map `PlatformMessageAction` URLs to `InlineKeyboardButton.WithUrl`.
-- Return a `PlatformMessageRef` with message IDs converted to strings.
-
-- [ ] **Step 2: Register adapter**
-
-Add `using GmRelay.Shared.Platform;` and register:
-
-```csharp
-builder.Services.AddSingleton<IPlatformMessenger, TelegramPlatformMessenger>();
-```
-
-- [ ] **Step 3: Run adapter source tests**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter TelegramPlatformMessengerSourceTests
-```
-
-Expected: some handler source tests still fail until Task 5.
-
-### Task 5: GREEN - Refactor Session Flows Through Adapter
-
-**Files:**
-- Modify target handler files listed in Task 3
-- Modify: `src/GmRelay.Bot/Features/Notifications/DirectSessionNotificationSender.cs`
-
-- [ ] **Step 1: Replace constructor dependencies**
-
-Use `IPlatformMessenger messenger` in target handlers for outbound operations. Keep `ITelegramBotClient` only where the handler still performs inbound Telegram-specific work that is out of scope, such as message deletion or forum topic creation.
-
-- [ ] **Step 2: Convert Telegram IDs to neutral platform objects**
-
-Use helper code equivalent to:
-
-```csharp
-private static PlatformGroup TelegramGroup(long chatId, string? title, int? threadId = null)
-    => new(
-        PlatformKind.Telegram,
-        chatId.ToString(System.Globalization.CultureInfo.InvariantCulture),
-        title ?? "Telegram chat",
-        ExternalChannelId: chatId.ToString(System.Globalization.CultureInfo.InvariantCulture),
-        ExternalThreadId: threadId?.ToString(System.Globalization.CultureInfo.InvariantCulture));
-
-private static PlatformUser TelegramUser(long telegramId, string displayName, string? username = null)
-    => new(
-        PlatformKind.Telegram,
-        telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture),
-        displayName,
-        username);
-```
-
-- [ ] **Step 3: Replace schedule updates**
-
-Build `SessionBatchViewModel` as before, then call:
-
-```csharp
-await messenger.UpdateScheduleAsync(
-    new PlatformScheduleMessage(
-        group,
-        view,
-        new PlatformMessageRef(PlatformKind.Telegram, group.ExternalGroupId, group.ExternalThreadId, messageId.ToString(System.Globalization.CultureInfo.InvariantCulture))),
-    ct);
-```
-
-- [ ] **Step 4: Replace interaction replies**
-
-Use:
-
-```csharp
-await messenger.AnswerInteractionAsync(
-    new PlatformInteractionReply(command.CallbackQueryId, text, showAlert: false),
-    ct);
-```
-
-- [ ] **Step 5: Replace direct notifications**
-
-`DirectSessionNotificationSender` should become a small compatibility service over `IPlatformMessenger`:
-
-```csharp
-await messenger.SendPrivateMessageAsync(
-    new PlatformPrivateMessage(
-        new PlatformUser(PlatformKind.Telegram, recipient.TelegramId.ToString(CultureInfo.InvariantCulture), recipient.DisplayName, null),
-        htmlText),
-    ct);
-```
-
-- [ ] **Step 6: Replace calendar file sending**
-
-`ExportCalendarHandler` builds the same ICS bytes and calls `SendCalendarFileAsync`, preserving the subscription URL button as a `PlatformMessageAction`.
-
-- [ ] **Step 7: Run target source tests**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter TelegramPlatformMessengerSourceTests
-```
-
-Expected: `Passed`.
-
-### Task 6: Regression Tests
-
-**Files:**
-- Existing tests only unless a compiler failure exposes a missing using or changed behavior.
-
-- [ ] **Step 1: Run rendering and routing tests**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~Rendering|FullyQualifiedName~Telegram|FullyQualifiedName~RescheduleSession"
-```
-
-Expected: `Passed`.
-
-- [ ] **Step 2: Run all tests**
-
-Run:
-
-```powershell
-dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj
-```
-
-Expected: `Passed`.
-
-- [ ] **Step 3: Build solution**
-
-Run:
-
-```powershell
-dotnet build GM-Relay.slnx
-```
-
-Expected: `Build succeeded` with warnings treated as errors.
-
-### Task 7: Version Bump
-
-**Files:**
-- Modify: `Directory.Build.props`
-- Modify: `compose.yaml`
-- Modify: `.gitea/workflows/deploy.yml`
-- Modify: `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-- [ ] **Step 1: Update all four version locations to `2.0.1`**
-- [ ] **Step 2: Verify sync**
-
-Run:
-
-```powershell
-rg -n "2\\.0\\.0|2\\.0\\.1" Directory.Build.props compose.yaml .gitea/workflows/deploy.yml src/GmRelay.Web/Components/Layout/NavMenu.razor
-```
-
-Expected: no `2.0.0` matches in these files and `2.0.1` appears in all required locations.
-
-### Task 8: Documentation Review
-
-**Files:**
-- Review: `README.md`
-- Review: `docs/adr/002-platform-neutral-batch-rendering.md`
-
-- [ ] **Step 1: Check README and ADR for platform contract accuracy**
-- [ ] **Step 2: Update docs if they now misrepresent platform-neutral responsibilities**
-
-Expected likely doc change: README currently lists current version as `v1.15.0`, which is already inconsistent with repo version `2.0.0`. If this PR bumps to `2.0.1`, update that line to `v2.0.1`.
-
-### Task 9: Commit, PR, CI, Review, Merge, Deploy, Release
-
-**Files:**
-- Stage only files intentionally changed for issue #24.
-
-- [ ] **Step 1: Create branch**
-
-```powershell
-git checkout -b codex/refactor/issue-24-platform-messenger
-```
-
-- [ ] **Step 2: Commit**
-
-```powershell
-git add src/GmRelay.Shared/Platform src/GmRelay.Bot tests/GmRelay.Bot.Tests Directory.Build.props compose.yaml .gitea/workflows/deploy.yml src/GmRelay.Web/Components/Layout/NavMenu.razor README.md docs/adr/002-platform-neutral-batch-rendering.md
-git commit -m "refactor: add platform messenger contracts"
-```
-
-- [ ] **Step 3: Push and create PR via Gitea**
-- [ ] **Step 4: Wait for PR CI and fix failures if any**
-- [ ] **Step 5: Run code review subagent and address findings**
-- [ ] **Step 6: Merge PR after CI and review**
-- [ ] **Step 7: Monitor deploy workflow**
-- [ ] **Step 8: Create release `v2.0.1` with Russian release notes**
-- [ ] **Step 9: Close issue #24 with PR and release links**
-
-## Self-Review
-
-- Spec coverage: all issue acceptance criteria map to Shared contracts, Telegram adapter, handler source tests, and build/test verification.
-- Placeholder scan: no `TBD`, `TODO`, or "fill later" placeholders are left in this plan.
-- Type consistency: all snippets use `GmRelay.Shared.Platform`, `PlatformKind.Telegram`, `PlatformMessageRef`, and `IPlatformMessenger` consistently.
-- Scope control: inbound Telegram update parsing remains out of scope; outbound schedule/private/interaction/calendar operations are in scope.

docs/superpowers/plans/2026-05-18-discord-netcord-gateway.md

@@ -1,731 +0,0 @@
-# Discord NetCord Gateway 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 separate `src/GmRelay.DiscordBot` worker that uses NetCord Gateway for Discord slash commands and component interactions while keeping Telegram dependencies isolated in `src/GmRelay.Bot`.
-
-**Architecture:** Create a new .NET worker project that references `GmRelay.ServiceDefaults` and `GmRelay.Shared`, validates `Discord:Token` during startup, registers NetCord gateway/application command/component services, and logs gateway lifecycle events through NetCord gateway handlers. Keep database connectivity aligned with the existing worker by registering the same `ConnectionStrings:gmrelaydb` `NpgsqlDataSource` pattern, but do not move Telegram code or dependencies.
-
-**Tech Stack:** .NET 10 worker, Aspire service defaults, NetCord.Hosting `1.0.0-alpha.489`, Npgsql `10.0.2`, xUnit, Docker Compose, Gitea Actions.
-
----
-
-## Issue
-
-- Gitea issue: `#26`, `feat: добавить src/GmRelay.DiscordBot на NetCord Gateway`
-- Labels: `type:feature`, `area:discord`, `area:infra`, `platform:discord`, `priority:p1`, `pending-approval`
-- Version bump: minor, `2.1.1` -> `2.2.0`
-- Branch: `feature/issue-26-discord-netcord-gateway`
-
-## Sources Checked
-
-- NetCord application commands guide: `https://netcord.dev/guides/services/application-commands/introduction.html`
-- NetCord intents guide: `https://netcord.dev/guides/events/intents.html`
-- NetCord gateway handler docs: `https://netcord.dev/docs/NetCord.Hosting.Gateway.html`
-- NuGet flat container for `NetCord.Hosting`: latest observed version `1.0.0-alpha.489`
-
-## File Structure
-
-- Create: `src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj` - Discord worker project and package references.
-- Create: `src/GmRelay.DiscordBot/Program.cs` - host composition, token validation, database registration, NetCord service registration.
-- Create: `src/GmRelay.DiscordBot/DiscordOptions.cs` - strongly typed Discord token/options validation.
-- Create: `src/GmRelay.DiscordBot/Infrastructure/Logging/SecretRedactor.cs` - Discord-local startup redaction without referencing the Telegram worker project.
-- Create: `src/GmRelay.DiscordBot/Infrastructure/Logging/DiscordGatewayLifecycleLogger.cs` - NetCord gateway lifecycle handler for ready/connect/resume/disconnect/close/rate-limit events where available.
-- Create: `src/GmRelay.DiscordBot/Dockerfile` - publish and runtime image for the Discord worker.
-- Modify: `GM-Relay.slnx` - include the new project.
-- Modify: `src/GmRelay.AppHost/GmRelay.AppHost.csproj` - reference the Discord worker for Aspire orchestration.
-- Modify: `src/GmRelay.AppHost/Program.cs` - add `discord` project with PostgreSQL reference.
-- Modify: `tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj` - reference the Discord worker project.
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs` - source-level tests for solution inclusion, Docker/Compose/CI wiring, and Telegram isolation.
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordOptionsTests.cs` - unit tests for token validation.
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs` - source-level startup tests for NetCord registration, service defaults, and PostgreSQL connection requirements.
-- Modify: `compose.yaml` - add `discord` service and versioned image tag.
-- Modify: `.gitea/workflows/deploy.yml` - build/push/scan/pull Discord image and include `DISCORD_BOT_TOKEN` in `.env`.
-- Modify: `.gitea/workflows/pr-checks.yml` - build the Discord project in PR checks.
-- Modify: `Directory.Build.props` - version `2.2.0`.
-- Modify: `src/GmRelay.Web/Components/Layout/NavMenu.razor` - visible version `v2.2.0`.
-- Generated by restore: `src/GmRelay.DiscordBot/packages.lock.json`.
-- Generated by restore: updates to `tests/GmRelay.Bot.Tests/packages.lock.json` and `src/GmRelay.AppHost/packages.lock.json`.
-
-## TDD Plan
-
-### Task 1: Project Presence And Telegram Isolation
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs`
-- Modify: `GM-Relay.slnx`
-- Create: `src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj`
-- Create: `src/GmRelay.DiscordBot/Program.cs`
-
-- [ ] **Step 1: Write the failing test**
-
-```csharp
-using System;
-using System.IO;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordProjectStructureTests
-{
-    private static string GetRepoRoot()
-    {
-        var dir = AppContext.BaseDirectory;
-        while (!string.IsNullOrEmpty(dir) && !File.Exists(Path.Combine(dir, "Directory.Build.props")))
-        {
-            dir = Directory.GetParent(dir)?.FullName;
-        }
-
-        return dir ?? throw new InvalidOperationException("Could not find repo root");
-    }
-
-    [Fact]
-    public void Solution_ShouldIncludeDiscordWorkerProject()
-    {
-        var repoRoot = GetRepoRoot();
-        var solution = File.ReadAllText(Path.Combine(repoRoot, "GM-Relay.slnx"));
-
-        Assert.Contains("src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj", solution);
-    }
-
-    [Fact]
-    public void DiscordWorkerProject_ShouldExistWithoutTelegramDependency()
-    {
-        var repoRoot = GetRepoRoot();
-        var projectPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "GmRelay.DiscordBot.csproj");
-
-        Assert.True(File.Exists(projectPath), "Discord worker project should exist.");
-
-        var project = File.ReadAllText(projectPath);
-        Assert.Contains("Microsoft.NET.Sdk.Worker", project);
-        Assert.Contains("NetCord.Hosting", project);
-        Assert.Contains("GmRelay.ServiceDefaults.csproj", project);
-        Assert.Contains("GmRelay.Shared.csproj", project);
-        Assert.DoesNotContain("Telegram.Bot", project);
-        Assert.DoesNotContain("GmRelay.Bot.csproj", project);
-    }
-
-    [Fact]
-    public void TelegramWorkerProject_ShouldNotReferenceNetCord()
-    {
-        var repoRoot = GetRepoRoot();
-        var project = File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.Bot", "GmRelay.Bot.csproj"));
-
-        Assert.DoesNotContain("NetCord", project, StringComparison.OrdinalIgnoreCase);
-    }
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordProjectStructureTests`
-
-Expected: FAIL because `GM-Relay.slnx` does not include `src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj` and the project file does not exist.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Create `src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj`:
-
-```xml
-<Project Sdk="Microsoft.NET.Sdk.Worker">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <LangVersion>preview</LangVersion>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <UserSecretsId>dotnet-GmRelay.DiscordBot-issue-26</UserSecretsId>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Aspire.Npgsql" Version="13.2.2" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.5" />
-    <PackageReference Include="NetCord.Hosting" Version="1.0.0-alpha.489" />
-    <PackageReference Include="Npgsql" Version="10.0.2" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\GmRelay.ServiceDefaults\GmRelay.ServiceDefaults.csproj" />
-    <ProjectReference Include="..\GmRelay.Shared\GmRelay.Shared.csproj" />
-  </ItemGroup>
-</Project>
-```
-
-Add this project to `GM-Relay.slnx` inside `/src/`:
-
-```xml
-<Project Path="src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj" />
-```
-
-Create temporary minimal `src/GmRelay.DiscordBot/Program.cs`:
-
-```csharp
-var builder = Host.CreateApplicationBuilder(args);
-builder.AddServiceDefaults();
-await builder.Build().RunAsync();
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordProjectStructureTests`
-
-Expected: PASS.
-
-### Task 2: Token Validation
-
-**Files:**
-- Modify: `tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj`
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordOptionsTests.cs`
-- Create: `src/GmRelay.DiscordBot/DiscordOptions.cs`
-
-- [ ] **Step 1: Write the failing test**
-
-Add the project reference to `tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj`:
-
-```xml
-<ProjectReference Include="..\..\src\GmRelay.DiscordBot\GmRelay.DiscordBot.csproj" />
-```
-
-Create `tests/GmRelay.Bot.Tests/Discord/DiscordOptionsTests.cs`:
-
-```csharp
-using GmRelay.DiscordBot;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordOptionsTests
-{
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("   ")]
-    public void Validate_ShouldRejectMissingToken(string? token)
-    {
-        var options = new DiscordOptions { Token = token };
-
-        var exception = Assert.Throws<InvalidOperationException>(options.Validate);
-
-        Assert.Contains("Discord:Token is required", exception.Message);
-        Assert.Contains("Discord__Token", exception.Message);
-    }
-
-    [Fact]
-    public void Validate_ShouldAcceptConfiguredToken()
-    {
-        var options = new DiscordOptions { Token = "configured-token" };
-
-        options.Validate();
-    }
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordOptionsTests`
-
-Expected: FAIL at compile time because `GmRelay.DiscordBot.DiscordOptions` is not defined.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Create `src/GmRelay.DiscordBot/DiscordOptions.cs`:
-
-```csharp
-namespace GmRelay.DiscordBot;
-
-public sealed class DiscordOptions
-{
-    public string? Token { get; init; }
-
-    public void Validate()
-    {
-        if (string.IsNullOrWhiteSpace(Token))
-        {
-            throw new InvalidOperationException(
-                "Discord:Token is required. Set via environment variable Discord__Token or user secrets.");
-        }
-    }
-}
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordOptionsTests`
-
-Expected: PASS.
-
-### Task 3: Startup Wiring For Service Defaults, PostgreSQL, NetCord, And Slash Commands
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs`
-- Modify: `src/GmRelay.DiscordBot/Program.cs`
-
-- [ ] **Step 1: Write the failing test**
-
-Create `tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs`:
-
-```csharp
-using System;
-using System.IO;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordStartupTests
-{
-    private static string GetRepoRoot()
-    {
-        var dir = AppContext.BaseDirectory;
-        while (!string.IsNullOrEmpty(dir) && !File.Exists(Path.Combine(dir, "Directory.Build.props")))
-        {
-            dir = Directory.GetParent(dir)?.FullName;
-        }
-
-        return dir ?? throw new InvalidOperationException("Could not find repo root");
-    }
-
-    [Fact]
-    public void Program_ShouldValidateDiscordTokenBeforeRunning()
-    {
-        var program = ReadProgram();
-
-        Assert.Contains("GetRequiredSection(\"Discord\")", program);
-        Assert.Contains("DiscordOptions", program);
-        Assert.Contains(".Validate()", program);
-    }
-
-    [Fact]
-    public void Program_ShouldRegisterServiceDefaultsAndPostgresDataSource()
-    {
-        var program = ReadProgram();
-
-        Assert.Contains("builder.AddServiceDefaults()", program);
-        Assert.Contains("ConnectionStrings:gmrelaydb is required", program);
-        Assert.Contains("NpgsqlDataSource", program);
-        Assert.Contains("SecretRedactor.RedactConnectionString", program);
-    }
-
-    [Fact]
-    public void Program_ShouldRegisterNetCordGatewayApplicationCommandsAndComponents()
-    {
-        var program = ReadProgram();
-
-        Assert.Contains(".AddDiscordGateway", program);
-        Assert.Contains(".AddApplicationCommands", program);
-        Assert.Contains(".AddComponentInteractions", program);
-        Assert.Contains(".AddGatewayHandlers", program);
-        Assert.Contains("AddSlashCommand", program);
-    }
-
-    private static string ReadProgram()
-    {
-        var repoRoot = GetRepoRoot();
-        return File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Program.cs"));
-    }
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordStartupTests`
-
-Expected: FAIL because `Program.cs` does not validate `Discord:Token`, register `NpgsqlDataSource`, or register NetCord services yet.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Replace `src/GmRelay.DiscordBot/Program.cs` with host composition that:
-
-```csharp
-using GmRelay.DiscordBot;
-using GmRelay.DiscordBot.Infrastructure.Logging;
-using NetCord.Gateway;
-using NetCord.Hosting.Gateway;
-using NetCord.Hosting.Services.ApplicationCommands;
-using NetCord.Hosting.Services.ComponentInteractions;
-using Npgsql;
-
-var builder = Host.CreateApplicationBuilder(args);
-
-builder.AddServiceDefaults();
-
-var discordOptions = builder.Configuration
-    .GetRequiredSection("Discord")
-    .Get<DiscordOptions>() ?? new DiscordOptions();
-discordOptions.Validate();
-
-builder.Services.AddSingleton(discordOptions);
-
-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.");
-
-    var logger = loggerFactory.CreateLogger("GmRelay.DiscordBot.Startup");
-    logger.LogInformation(
-        "Configured PostgreSQL data source with connection string {ConnectionString}",
-        SecretRedactor.RedactConnectionString(connectionString));
-
-    return NpgsqlDataSource.Create(connectionString);
-});
-
-builder.Services
-    .AddDiscordGateway(options =>
-    {
-        options.Token = discordOptions.Token;
-        options.Intents = GatewayIntents.Guilds;
-    })
-    .AddApplicationCommands()
-    .AddComponentInteractions()
-    .AddGatewayHandlers(typeof(Program).Assembly);
-
-var host = builder.Build();
-
-host.AddSlashCommand("ping", "Checks whether GM-Relay Discord is online.", () => "Pong!");
-
-await host.RunAsync();
-```
-
-Use the Discord-local `SecretRedactor` namespace instead of `GmRelay.Bot.Infrastructure.Logging` so the new project does not reference the Telegram worker.
-
-Create `src/GmRelay.DiscordBot/Infrastructure/Logging/SecretRedactor.cs`:
-
-```csharp
-using System.Text.RegularExpressions;
-
-namespace GmRelay.DiscordBot.Infrastructure.Logging;
-
-internal static partial class SecretRedactor
-{
-    public static string RedactConnectionString(string connectionString)
-    {
-        return PasswordPattern().Replace(connectionString, "$1***");
-    }
-
-    [GeneratedRegex(@"(?i)(Password\s*=\s*)[^;]+")]
-    private static partial Regex PasswordPattern();
-}
-```
-
-If `GatewayClientOptions.Token` does not accept `string`, adjust to NetCord's required token type after compile feedback while preserving the tests' intent.
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~DiscordStartupTests`
-
-Expected: PASS.
-
-### Task 4: Gateway Lifecycle Logging
-
-**Files:**
-- Modify: `tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs`
-- Create: `src/GmRelay.DiscordBot/Infrastructure/Logging/DiscordGatewayLifecycleLogger.cs`
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `DiscordStartupTests.cs`:
-
-```csharp
-[Fact]
-public void LifecycleLogger_ShouldLogGatewayLifecycleEventsWithoutTokenValues()
-{
-    var repoRoot = GetRepoRoot();
-    var loggerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Infrastructure", "Logging", "DiscordGatewayLifecycleLogger.cs");
-
-    Assert.True(File.Exists(loggerPath), "Discord gateway lifecycle logger should exist.");
-
-    var logger = File.ReadAllText(loggerPath);
-    Assert.Contains("IReadyGatewayHandler", logger);
-    Assert.Contains("IDisconnectGatewayHandler", logger);
-    Assert.Contains("IResumeGatewayHandler", logger);
-    Assert.Contains("LogInformation", logger);
-    Assert.DoesNotContain("Token", logger);
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter LifecycleLogger_ShouldLogGatewayLifecycleEventsWithoutTokenValues`
-
-Expected: FAIL because `DiscordGatewayLifecycleLogger.cs` does not exist.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Create `src/GmRelay.DiscordBot/Infrastructure/Logging/DiscordGatewayLifecycleLogger.cs` using the concrete NetCord handler signatures from the installed `NetCord.Hosting` package. Minimum behavior:
-
-```csharp
-using Microsoft.Extensions.Logging;
-using NetCord.Gateway;
-using NetCord.Hosting.Gateway;
-
-namespace GmRelay.DiscordBot.Infrastructure.Logging;
-
-public sealed class DiscordGatewayLifecycleLogger(
-    ILogger<DiscordGatewayLifecycleLogger> logger)
-    : IReadyGatewayHandler,
-      IDisconnectGatewayHandler,
-      IResumeGatewayHandler
-{
-    public ValueTask HandleAsync(ReadyEventArgs arg)
-    {
-        logger.LogInformation("Discord gateway ready as application {ApplicationId}", arg.Application.Id);
-        return ValueTask.CompletedTask;
-    }
-
-    public ValueTask HandleAsync(DisconnectEventArgs arg)
-    {
-        logger.LogWarning("Discord gateway disconnected with close status {CloseStatus}", arg.CloseStatus);
-        return ValueTask.CompletedTask;
-    }
-
-    public ValueTask HandleAsync()
-    {
-        logger.LogInformation("Discord gateway session resumed");
-        return ValueTask.CompletedTask;
-    }
-}
-```
-
-If interface signatures differ in `1.0.0-alpha.489`, inspect the package XML/docs and adjust the handlers to compile while keeping ready/disconnect/resume logging and never logging token values.
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter LifecycleLogger_ShouldLogGatewayLifecycleEventsWithoutTokenValues`
-
-Expected: PASS.
-
-### Task 5: Runtime Container, Compose, AppHost, And CI Wiring
-
-**Files:**
-- Modify: `tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs`
-- Create: `src/GmRelay.DiscordBot/Dockerfile`
-- Modify: `compose.yaml`
-- Modify: `src/GmRelay.AppHost/GmRelay.AppHost.csproj`
-- Modify: `src/GmRelay.AppHost/Program.cs`
-- Modify: `.gitea/workflows/pr-checks.yml`
-- Modify: `.gitea/workflows/deploy.yml`
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `DiscordProjectStructureTests.cs`:
-
-```csharp
-[Fact]
-public void RuntimeWiring_ShouldIncludeDiscordServiceWithoutCouplingTelegram()
-{
-    var repoRoot = GetRepoRoot();
-    var compose = File.ReadAllText(Path.Combine(repoRoot, "compose.yaml"));
-    var appHostProject = File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.AppHost", "GmRelay.AppHost.csproj"));
-    var appHostProgram = File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.AppHost", "Program.cs"));
-    var prChecks = File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "pr-checks.yml"));
-    var deploy = File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "deploy.yml"));
-
-    Assert.Contains("gmrelay-discord-bot:2.2.0", compose);
-    Assert.Contains("Discord__Token=${DISCORD_BOT_TOKEN:?Set DISCORD_BOT_TOKEN in .env}", compose);
-    Assert.Contains("src/GmRelay.DiscordBot/Dockerfile", deploy);
-    Assert.Contains("DISCORD_BOT_TOKEN", deploy);
-    Assert.Contains("dotnet build src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj --no-restore", prChecks);
-    Assert.Contains("GmRelay.DiscordBot.csproj", appHostProject);
-    Assert.Contains("Projects.GmRelay_DiscordBot", appHostProgram);
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter RuntimeWiring_ShouldIncludeDiscordServiceWithoutCouplingTelegram`
-
-Expected: FAIL because runtime wiring is not present.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Create `src/GmRelay.DiscordBot/Dockerfile` modeled after `src/GmRelay.Bot/Dockerfile`, with project copy/restore for `GmRelay.DiscordBot`, `GmRelay.ServiceDefaults`, and `GmRelay.Shared`, and entrypoint `./GmRelay.DiscordBot`.
-
-Add `discord` service to `compose.yaml`:
-
-```yaml
-  discord:
-    image: git.codeanddice.ru/toutsu/gmrelay-discord-bot:2.2.0
-    restart: always
-    depends_on:
-      db:
-        condition: service_healthy
-    environment:
-      - "ConnectionStrings__gmrelaydb=Host=db;Port=5432;Database=gmrelay_db;Username=gmrelay;Password=${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}"
-      - "Discord__Token=${DISCORD_BOT_TOKEN:?Set DISCORD_BOT_TOKEN in .env}"
-    networks:
-      - gmrelay
-```
-
-Add Discord project reference to `src/GmRelay.AppHost/GmRelay.AppHost.csproj`:
-
-```xml
-<ProjectReference Include="..\GmRelay.DiscordBot\GmRelay.DiscordBot.csproj" />
-```
-
-Add Discord service to `src/GmRelay.AppHost/Program.cs`:
-
-```csharp
-builder.AddProject<Projects.GmRelay_DiscordBot>("discord")
-    .WithReference(postgres)
-    .WaitFor(postgres);
-```
-
-Update `.gitea/workflows/pr-checks.yml` with:
-
-```yaml
-      - name: Build Discord Bot (compile check, includes SAST)
-        run: dotnet build src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj --no-restore
-```
-
-Update `.gitea/workflows/deploy.yml` to build, push, scan, pull, and deploy `git.codeanddice.ru/toutsu/gmrelay-discord-bot:${{ env.VERSION }}` and write `DISCORD_BOT_TOKEN=${{ secrets.DISCORD_BOT_TOKEN }}` to `.env`.
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter RuntimeWiring_ShouldIncludeDiscordServiceWithoutCouplingTelegram`
-
-Expected: PASS.
-
-### Task 6: Version Synchronization
-
-**Files:**
-- Modify: `tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs`
-- Modify: `Directory.Build.props`
-- Modify: `compose.yaml`
-- Modify: `.gitea/workflows/deploy.yml`
-- Modify: `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-- [ ] **Step 1: Write the failing test**
-
-Add to `DiscordProjectStructureTests.cs`:
-
-```csharp
-[Fact]
-public void Version_ShouldBeSynchronizedForDiscordFeatureRelease()
-{
-    var repoRoot = GetRepoRoot();
-
-    Assert.Contains("<Version>2.2.0</Version>", File.ReadAllText(Path.Combine(repoRoot, "Directory.Build.props")));
-    Assert.Contains("VERSION: 2.2.0", File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "deploy.yml")));
-    Assert.Contains("gmrelay-bot:2.2.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
-    Assert.Contains("gmrelay-web:2.2.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
-    Assert.Contains("gmrelay-discord-bot:2.2.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
-    Assert.Contains("v2.2.0", File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.Web", "Components", "Layout", "NavMenu.razor")));
-}
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter Version_ShouldBeSynchronizedForDiscordFeatureRelease`
-
-Expected: FAIL because current version is `2.1.1`.
-
-- [ ] **Step 3: Write minimal implementation**
-
-Update:
-- `Directory.Build.props`: `<Version>2.2.0</Version>`
-- `.gitea/workflows/deploy.yml`: `VERSION: 2.2.0`
-- `compose.yaml`: `gmrelay-bot:2.2.0`, `gmrelay-web:2.2.0`, `gmrelay-discord-bot:2.2.0`
-- `src/GmRelay.Web/Components/Layout/NavMenu.razor`: `v2.2.0`
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter Version_ShouldBeSynchronizedForDiscordFeatureRelease`
-
-Expected: PASS.
-
-### Task 7: Restore, Format, Build, And Full Test Verification
-
-**Files:**
-- Generated/updated: `src/GmRelay.DiscordBot/packages.lock.json`
-- Generated/updated: `tests/GmRelay.Bot.Tests/packages.lock.json`
-- Generated/updated: `src/GmRelay.AppHost/packages.lock.json`
-- Any code formatting changes required by `dotnet format`
-
-- [ ] **Step 1: Restore lock files**
-
-Run: `dotnet restore GM-Relay.slnx`
-
-Expected: restore succeeds and creates/updates lock files for the new project references and NetCord dependency.
-
-- [ ] **Step 2: Run targeted tests**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter FullyQualifiedName~Discord`
-
-Expected: all Discord tests pass.
-
-- [ ] **Step 3: Run full tests**
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --verbosity normal`
-
-Expected: all tests pass.
-
-- [ ] **Step 4: Run release build**
-
-Run: `dotnet build GM-Relay.slnx -c Release`
-
-Expected: solution build succeeds and includes `src/GmRelay.DiscordBot`.
-
-- [ ] **Step 5: Run format check**
-
-Run: `dotnet format --verify-no-changes --verbosity diagnostic`
-
-Expected: no formatting changes required.
-
-- [ ] **Step 6: Inspect diff for secrets**
-
-Run: `git diff --check`
-
-Expected: no whitespace errors and no Discord token value in tracked files.
-
-Run: `git diff -- . ':!*.lock.json'`
-
-Expected: diff contains configuration variable names such as `Discord__Token` and `DISCORD_BOT_TOKEN`, but not a real token value.
-
-### Task 8: Commit, PR, CI, Deploy, Release, Issue Closure
-
-**Files:**
-- All intended implementation, test, lock, workflow, compose, and version files.
-
-- [ ] **Step 1: Create commit**
-
-Run:
-
-```powershell
-git status --short
-git add GM-Relay.slnx Directory.Build.props compose.yaml .gitea/workflows/deploy.yml .gitea/workflows/pr-checks.yml src/GmRelay.AppHost src/GmRelay.DiscordBot src/GmRelay.Web/Components/Layout/NavMenu.razor tests/GmRelay.Bot.Tests
-git commit -m "feat: add Discord NetCord gateway worker"
-```
-
-Expected: only intended files are staged and committed. Do not stage untracked `CLAUDE.md`.
-
-- [ ] **Step 2: Push branch and open PR**
-
-Run: `git push -u origin feature/issue-26-discord-netcord-gateway`
-
-Create Gitea PR to `main` with:
-- Summary of Discord worker, token validation, runtime wiring, and version bump.
-- Test plan showing targeted Discord tests, full tests, release build, format, and secret diff inspection.
-- Link to issue `#26`.
-
-- [ ] **Step 3: Store Discord token as a Gitea Actions secret**
-
-Use Gitea Actions configuration to create or update repository secret `DISCORD_BOT_TOKEN` with the user-provided Discord bot token.
-
-Expected: token is stored only as an Actions secret. The token value is not written to source files, plan files, logs, PR text, release notes, or commits.
-
-- [ ] **Step 4: Monitor CI**
-
-Use Gitea Actions run reads until PR checks finish. If CI fails, inspect logs, fix with TDD where the failure is code behavior, push again, and re-check.
-
-- [ ] **Step 5: Review, merge, deploy, release**
-
-After CI passes and review is approved:
-- Merge PR.
-- Monitor deploy workflow on `main`.
-- Create release `v2.2.0` with Russian release notes.
-- Close issue `#26` with a comment linking PR and release.
-
-## Self-Review
-
-- Spec coverage: Project creation, NetCord Gateway, slash/component service registration, `Discord__Token`, PostgreSQL service defaults, lifecycle logging, Telegram isolation, solution build, compose/deploy integration, and version sync are covered.
-- Placeholder scan: No task uses `TBD`, `TODO`, or an unspecified "add tests" instruction.
-- Type consistency: Test class names and file paths are consistent across tasks; NetCord lifecycle handler signatures are explicitly marked for compile-driven adjustment because the package is prerelease and must be verified against installed `1.0.0-alpha.489`.

docs/superpowers/plans/2026-05-18-platform-neutral-join-leave.md

@@ -1,599 +0,0 @@
-# Platform-Neutral Join Leave 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:** Implement Gitea issue #25 by making join/leave session interactions use platform-neutral command models while preserving Telegram callback behavior, seat limits, and waitlist semantics.
-
-**Architecture:** Telegram callback routing remains in `UpdateRouter`, but it becomes an adapter that converts callback data into `PlatformUser`, `PlatformGroup`, and `PlatformMessageRef` values. `JoinSessionHandler` and `LeaveSessionHandler` operate on those neutral values, persist players by `(platform, external_user_id)`, and update schedules through `IPlatformMessenger`.
-
-**Tech Stack:** .NET 10, xUnit, Dapper, Npgsql, Gitea Actions.
-
----
-
-## Issue Context
-
-- Issue: `#25 refactor: obobshchit JoinSession i LeaveSession pod platform-neutral interactions`
-- Labels: `area:bot`, `area:platform`, `area:shared`, `platform:multi`, `type:refactor`
-- Version bump: patch, `2.1.0` -> `2.1.1`. The issue is labeled refactor, not breaking; do not use a major bump without explicit approval.
-- Existing untracked file: `CLAUDE.md`; do not stage or modify it.
-
-## File Map
-
-- Create: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionCommandTests.cs`
-  - Reflection tests proving join/leave command records expose neutral properties and no Telegram-specific identity/message fields.
-- Create: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionSqlTests.cs`
-  - Source-level regression tests for handler SQL and messenger boundaries.
-- Modify: `tests/GmRelay.Bot.Tests/Infrastructure/Database/PlatformIdentityMigrationTests.cs`
-  - Add a migration test for nullable legacy `players.telegram_id`, required for non-Telegram player inserts.
-- Create: `src/GmRelay.Bot/Migrations/V017__allow_platform_neutral_players.sql`
-  - Drop `NOT NULL` from legacy Telegram-only player columns.
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs`
-  - Change `JoinSessionCommand` to neutral properties and query/upsert players by platform identity.
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs`
-  - Change `LeaveSessionCommand` to neutral properties and find participants by platform identity.
-- Modify: `src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs`
-  - Convert Telegram callback data into neutral command values using `TelegramPlatformIds`.
-- Modify: version files after implementation:
-  - `Directory.Build.props`
-  - `compose.yaml`
-  - `.gitea/workflows/deploy.yml`
-  - `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-## Task 1: RED - Command Model Tests
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionCommandTests.cs`
-
-- [ ] **Step 1: Write failing command-shape tests**
-
-```csharp
-using GmRelay.Bot.Features.Sessions.CreateSession;
-using GmRelay.Shared.Platform;
-
-namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession;
-
-public sealed class PlatformNeutralSessionInteractionCommandTests
-{
-    [Fact]
-    public void JoinSessionCommand_ShouldExposePlatformNeutralInteractionContext()
-    {
-        AssertProperty<JoinSessionCommand>("SessionId", typeof(Guid));
-        AssertProperty<JoinSessionCommand>("User", typeof(PlatformUser));
-        AssertProperty<JoinSessionCommand>("InteractionId", typeof(string));
-        AssertProperty<JoinSessionCommand>("Group", typeof(PlatformGroup));
-        AssertProperty<JoinSessionCommand>("ScheduleMessage", typeof(PlatformMessageRef));
-        AssertNoTelegramSpecificProperties<JoinSessionCommand>();
-    }
-
-    [Fact]
-    public void LeaveSessionCommand_ShouldExposePlatformNeutralInteractionContext()
-    {
-        AssertProperty<LeaveSessionCommand>("SessionId", typeof(Guid));
-        AssertProperty<LeaveSessionCommand>("User", typeof(PlatformUser));
-        AssertProperty<LeaveSessionCommand>("InteractionId", typeof(string));
-        AssertProperty<LeaveSessionCommand>("Group", typeof(PlatformGroup));
-        AssertProperty<LeaveSessionCommand>("ScheduleMessage", typeof(PlatformMessageRef));
-        AssertNoTelegramSpecificProperties<LeaveSessionCommand>();
-    }
-
-    private static void AssertProperty<T>(string name, Type expectedType)
-    {
-        var property = Assert.Single(typeof(T).GetProperties(), property => property.Name == name);
-
-        Assert.Equal(expectedType, property.PropertyType);
-    }
-
-    private static void AssertNoTelegramSpecificProperties<T>()
-    {
-        var names = typeof(T).GetProperties().Select(property => property.Name).ToArray();
-
-        Assert.DoesNotContain(names, name => name.Contains("Telegram", StringComparison.Ordinal));
-        Assert.DoesNotContain("ChatId", names);
-        Assert.DoesNotContain("MessageId", names);
-        Assert.DoesNotContain("TelegramUserId", names);
-        Assert.DoesNotContain("TelegramUsername", names);
-    }
-}
-```
-
-- [ ] **Step 2: Verify RED**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter PlatformNeutralSessionInteractionCommandTests
-```
-
-Expected: FAIL because `JoinSessionCommand` and `LeaveSessionCommand` still expose `TelegramUserId`, `ChatId`, and `MessageId`, and do not expose `User`, `Group`, or `ScheduleMessage`.
-
-## Task 2: RED - SQL and Boundary Tests
-
-**Files:**
-- Create: `tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionSqlTests.cs`
-- Modify: `tests/GmRelay.Bot.Tests/Infrastructure/Database/PlatformIdentityMigrationTests.cs`
-
-- [ ] **Step 1: Write failing handler source tests**
-
-```csharp
-namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession;
-
-public sealed class PlatformNeutralSessionInteractionSqlTests
-{
-    [Fact]
-    public async Task JoinSessionHandler_ShouldPersistPlayersByPlatformIdentity()
-    {
-        var handler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs");
-
-        Assert.Contains("platform, external_user_id", handler, StringComparison.Ordinal);
-        Assert.Contains("ON CONFLICT (platform, external_user_id)", handler, StringComparison.Ordinal);
-        Assert.Contains("ExternalUserId", handler, StringComparison.Ordinal);
-        Assert.Contains("ExternalUsername", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("TelegramPlatformIds.", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("command.TelegramUserId", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("command.TelegramUsername", handler, StringComparison.Ordinal);
-    }
-
-    [Fact]
-    public async Task LeaveSessionHandler_ShouldFindParticipantsByPlatformIdentity()
-    {
-        var handler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs");
-
-        Assert.Contains("p.platform = @Platform", handler, StringComparison.Ordinal);
-        Assert.Contains("p.external_user_id = @ExternalUserId", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("p.telegram_id = @TelegramUserId", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("TelegramPlatformIds.", handler, StringComparison.Ordinal);
-        Assert.DoesNotContain("command.TelegramUserId", handler, StringComparison.Ordinal);
-    }
-
-    [Fact]
-    public async Task SessionInteractionHandlers_ShouldUpdateSchedulesThroughCommandMessageReference()
-    {
-        var joinHandler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs");
-        var leaveHandler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs");
-
-        Assert.Contains("new PlatformScheduleMessage(", joinHandler, StringComparison.Ordinal);
-        Assert.Contains("command.Group", joinHandler, StringComparison.Ordinal);
-        Assert.Contains("command.ScheduleMessage", joinHandler, StringComparison.Ordinal);
-        Assert.Contains("new PlatformScheduleMessage(", leaveHandler, StringComparison.Ordinal);
-        Assert.Contains("command.Group", leaveHandler, StringComparison.Ordinal);
-        Assert.Contains("command.ScheduleMessage", leaveHandler, StringComparison.Ordinal);
-    }
-
-    private static async Task<string> ReadRepositoryFileAsync(string relativePath)
-    {
-        var directory = new DirectoryInfo(AppContext.BaseDirectory);
-        while (directory is not null)
-        {
-            var candidate = Path.Combine(directory.FullName, relativePath);
-            if (File.Exists(candidate))
-            {
-                return await File.ReadAllTextAsync(candidate);
-            }
-
-            directory = directory.Parent;
-        }
-
-        throw new FileNotFoundException($"Could not locate repository file '{relativePath}'.");
-    }
-}
-```
-
-- [ ] **Step 2: Add failing migration assertion**
-
-Append to `PlatformIdentityMigrationTests`:
-
-```csharp
-[Fact]
-public async Task MigrationV017_ShouldAllowPlayersWithoutLegacyTelegramId()
-{
-    var migration = await ReadRepositoryFileAsync("src/GmRelay.Bot/Migrations/V017__allow_platform_neutral_players.sql");
-
-    Assert.Contains("ALTER TABLE players", migration, StringComparison.Ordinal);
-    Assert.Contains("telegram_id DROP NOT NULL", migration, StringComparison.Ordinal);
-}
-```
-
-- [ ] **Step 3: Verify RED**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter "PlatformNeutralSessionInteractionSqlTests|MigrationV017_ShouldAllowPlayersWithoutLegacyTelegramId"
-```
-
-Expected: FAIL because handlers still use Telegram-specific properties and the V017 migration file does not exist.
-
-## Task 3: GREEN - Add Migration
-
-**Files:**
-- Create: `src/GmRelay.Bot/Migrations/V017__allow_platform_neutral_players.sql`
-
-- [ ] **Step 1: Create the migration**
-
-```sql
--- =============================================================
--- V017: Allow platform-neutral players
--- =============================================================
--- Legacy Telegram identity columns remain for backward compatibility,
--- but non-Telegram platform users do not have Telegram ids.
--- =============================================================
-
-ALTER TABLE players
-    ALTER COLUMN telegram_id DROP NOT NULL;
-```
-
-- [ ] **Step 2: Verify migration test turns green**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter MigrationV017_ShouldAllowPlayersWithoutLegacyTelegramId
-```
-
-Expected: PASS.
-
-## Task 4: GREEN - Refactor JoinSessionCommand and Handler
-
-**Files:**
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs`
-
-- [ ] **Step 1: Replace command record**
-
-Replace the existing `JoinSessionCommand` declaration with:
-
-```csharp
-public sealed record JoinSessionCommand(
-    Guid SessionId,
-    PlatformUser User,
-    string InteractionId,
-    PlatformGroup Group,
-    PlatformMessageRef ScheduleMessage);
-```
-
-- [ ] **Step 2: Replace player upsert**
-
-Use platform identity parameters:
-
-```csharp
-var platform = command.User.Platform.ToString();
-var legacyTelegramId = command.User.Platform == PlatformKind.Telegram
-    ? long.Parse(command.User.ExternalUserId, CultureInfo.InvariantCulture)
-    : (long?)null;
-var legacyTelegramUsername = command.User.Platform == PlatformKind.Telegram
-    ? command.User.ExternalUsername
-    : null;
-
-var playerId = await connection.ExecuteScalarAsync<Guid>(
-    @"INSERT INTO players (telegram_id, display_name, telegram_username, platform, external_user_id, external_username)
-      VALUES (@LegacyTelegramId, @Name, @LegacyTelegramUsername, @Platform, @ExternalUserId, @ExternalUsername)
-      ON CONFLICT (platform, external_user_id)
-      WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
-      DO UPDATE
-      SET display_name = EXCLUDED.display_name,
-          telegram_username = COALESCE(EXCLUDED.telegram_username, players.telegram_username),
-          platform = EXCLUDED.platform,
-          external_user_id = EXCLUDED.external_user_id,
-          external_username = EXCLUDED.external_username
-      RETURNING id;",
-    new
-    {
-        LegacyTelegramId = legacyTelegramId,
-        Name = command.User.DisplayName,
-        LegacyTelegramUsername = legacyTelegramUsername,
-        Platform = platform,
-        command.User.ExternalUserId,
-        command.User.ExternalUsername
-    },
-    transaction);
-```
-
-Add `using System.Globalization;` at the top.
-
-- [ ] **Step 3: Update participant display query**
-
-Change the participant projection to prefer platform-neutral username:
-
-```sql
-COALESCE(p.external_username, p.telegram_username) as TelegramUsername
-```
-
-- [ ] **Step 4: Update schedule message and interaction reply usage**
-
-Use:
-
-```csharp
-await messenger.UpdateScheduleAsync(
-    new PlatformScheduleMessage(
-        command.Group,
-        view,
-        command.ScheduleMessage),
-    ct);
-```
-
-and:
-
-```csharp
-private Task AnswerAsync(string interactionId, string text, CancellationToken ct) =>
-    messenger.AnswerInteractionAsync(new PlatformInteractionReply(interactionId, text), ct);
-```
-
-Replace all `command.CallbackQueryId` calls with `command.InteractionId`.
-
-- [ ] **Step 5: Verify command and SQL tests for join**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter "JoinSessionCommand_ShouldExposePlatformNeutralInteractionContext|JoinSessionHandler_ShouldPersistPlayersByPlatformIdentity"
-```
-
-Expected: PASS for join-focused tests.
-
-## Task 5: GREEN - Refactor LeaveSessionCommand and Handler
-
-**Files:**
-- Modify: `src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs`
-
-- [ ] **Step 1: Replace command record**
-
-Replace the existing `LeaveSessionCommand` declaration with:
-
-```csharp
-public sealed record LeaveSessionCommand(
-    Guid SessionId,
-    PlatformUser User,
-    string InteractionId,
-    PlatformGroup Group,
-    PlatformMessageRef ScheduleMessage);
-```
-
-- [ ] **Step 2: Replace participant lookup**
-
-Use platform identity instead of Telegram id:
-
-```csharp
-var platform = command.User.Platform.ToString();
-
-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.platform = @Platform
-      AND p.external_user_id = @ExternalUserId
-      AND sp.is_gm = false
-    FOR UPDATE OF sp
-    """,
-    new { command.SessionId, Platform = platform, command.User.ExternalUserId },
-    transaction);
-```
-
-- [ ] **Step 3: Update participant display query**
-
-Change the participant projection to:
-
-```sql
-COALESCE(p.external_username, p.telegram_username) AS TelegramUsername
-```
-
-- [ ] **Step 4: Update schedule message and interaction reply usage**
-
-Use:
-
-```csharp
-await messenger.UpdateScheduleAsync(
-    new PlatformScheduleMessage(
-        command.Group,
-        view,
-        command.ScheduleMessage),
-    ct);
-```
-
-Replace all `command.CallbackQueryId` calls with `command.InteractionId`.
-
-- [ ] **Step 5: Verify leave tests**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter "LeaveSessionCommand_ShouldExposePlatformNeutralInteractionContext|LeaveSessionHandler_ShouldFindParticipantsByPlatformIdentity|SessionInteractionHandlers_ShouldUpdateSchedulesThroughCommandMessageReference"
-```
-
-Expected: PASS.
-
-## Task 6: GREEN - Convert Telegram Router to Neutral Commands
-
-**Files:**
-- Modify: `src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs`
-
-- [ ] **Step 1: Add local conversion values in `HandleCallbackQueryAsync`**
-
-After parsing `action`, add:
-
-```csharp
-var user = TelegramPlatformIds.User(
-    query.From.Id,
-    query.From.FirstName + (string.IsNullOrEmpty(query.From.LastName) ? "" : $" {query.From.LastName}"),
-    query.From.Username);
-var group = TelegramPlatformIds.Group(message.Chat.Id, message.MessageThreadId, message.Chat.Title);
-var scheduleMessage = TelegramPlatformIds.Message(message.Chat.Id, message.MessageThreadId, message.MessageId);
-```
-
-- [ ] **Step 2: Update join command construction**
-
-```csharp
-var command = new JoinSessionCommand(
-    SessionId: joinSessionId,
-    User: user,
-    InteractionId: query.Id,
-    Group: group,
-    ScheduleMessage: scheduleMessage);
-```
-
-- [ ] **Step 3: Update leave command construction**
-
-```csharp
-var command = new LeaveSessionCommand(
-    SessionId: leaveSessionId,
-    User: user,
-    InteractionId: query.Id,
-    Group: group,
-    ScheduleMessage: scheduleMessage);
-```
-
-- [ ] **Step 4: Verify compile**
-
-Run:
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter PlatformNeutralSessionInteractionCommandTests
-```
-
-Expected: PASS.
-
-## Task 7: REFACTOR - Clean Up and Full Test Pass
-
-**Files:**
-- Modify only files already listed if cleanup is needed.
-
-- [ ] **Step 1: Remove now-unused Telegram handler imports**
-
-Check `JoinSessionHandler.cs` and `LeaveSessionHandler.cs` for unused:
-
-```csharp
-using GmRelay.Bot.Infrastructure.Telegram;
-```
-
-Remove it from handlers if no longer needed.
-
-- [ ] **Step 2: Run focused tests**
-
-```powershell
-dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter "PlatformNeutralSessionInteractionCommandTests|PlatformNeutralSessionInteractionSqlTests|PlatformIdentityMigrationTests"
-```
-
-Expected: PASS.
-
-- [ ] **Step 3: Run full test suite**
-
-```powershell
-dotnet test .\GM-Relay.slnx
-```
-
-Expected: PASS.
-
-- [ ] **Step 4: Build solution**
-
-```powershell
-dotnet build .\GM-Relay.slnx
-```
-
-Expected: PASS.
-
-## Task 8: Version Bump
-
-**Files:**
-- Modify: `Directory.Build.props`
-- Modify: `compose.yaml`
-- Modify: `.gitea/workflows/deploy.yml`
-- Modify: `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-- [ ] **Step 1: Update version from `2.1.0` to `2.1.1`**
-
-Expected exact replacements:
-
-```xml
-<Version>2.1.1</Version>
-```
-
-```yaml
-VERSION: 2.1.1
-```
-
-```yaml
-image: git.codeanddice.ru/toutsu/gmrelay-bot:2.1.1
-image: git.codeanddice.ru/toutsu/gmrelay-web:2.1.1
-```
-
-```razor
-<div class="nav-version">v2.1.1</div>
-```
-
-- [ ] **Step 2: Verify synchronized versions**
-
-Run:
-
-```powershell
-rg "<Version>|image: git.codeanddice.ru/toutsu/gmrelay-|VERSION:|nav-version" Directory.Build.props compose.yaml .gitea\workflows\deploy.yml src\GmRelay.Web\Components\Layout\NavMenu.razor
-```
-
-Expected: all project image/app/deploy UI versions show `2.1.1`.
-
-## Task 9: PR, CI, Review, Merge, Deploy, Release
-
-**Files:**
-- No additional source changes expected.
-
-- [ ] **Step 1: Create branch after approval**
-
-```powershell
-git checkout -b refactor/issue-25-platform-neutral-join-leave
-```
-
-- [ ] **Step 2: Stage only intended files**
-
-```powershell
-git add docs/superpowers/plans/2026-05-18-platform-neutral-join-leave.md tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionCommandTests.cs tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionSqlTests.cs tests/GmRelay.Bot.Tests/Infrastructure/Database/PlatformIdentityMigrationTests.cs src/GmRelay.Bot/Migrations/V017__allow_platform_neutral_players.sql src/GmRelay.Bot/Features/Sessions/CreateSession/JoinSessionHandler.cs src/GmRelay.Bot/Features/Sessions/CreateSession/LeaveSessionHandler.cs src/GmRelay.Bot/Infrastructure/Telegram/UpdateRouter.cs Directory.Build.props compose.yaml .gitea/workflows/deploy.yml src/GmRelay.Web/Components/Layout/NavMenu.razor
-```
-
-- [ ] **Step 3: Commit**
-
-```powershell
-git commit -m "refactor: make session join leave platform-neutral"
-```
-
-- [ ] **Step 4: Push and create Gitea PR**
-
-```powershell
-git push -u origin refactor/issue-25-platform-neutral-join-leave
-```
-
-PR title:
-
-```text
-refactor: make session join leave platform-neutral
-```
-
-PR body:
-
-```markdown
-## Summary
-- Closes #25.
-- Converts join/leave session interaction commands from Telegram-specific fields to platform-neutral `PlatformUser`, `PlatformGroup`, and `PlatformMessageRef`.
-- Persists and looks up session participants by `(platform, external_user_id)`.
-- Keeps Telegram callback data and schedule update behavior intact.
-
-## Test plan
-- `dotnet test .\tests\GmRelay.Bot.Tests\GmRelay.Bot.Tests.csproj --filter "PlatformNeutralSessionInteractionCommandTests|PlatformNeutralSessionInteractionSqlTests|PlatformIdentityMigrationTests"`
-- `dotnet test .\GM-Relay.slnx`
-- `dotnet build .\GM-Relay.slnx`
-
-## Workflow
-- [ ] CI passes
-- [ ] Code review approved
-- [ ] Deployed
-- [ ] Release published
-```
-
-- [ ] **Step 5: Watch CI, request review, merge, deploy, release**
-
-Use Gitea MCP for PR creation, CI polling, review, merge, deploy monitoring, and release `v2.1.1`. Close issue #25 after release and add a comment linking the PR and release.
-
-## Self-Review
-
-- Spec coverage: issue scope is covered by neutral command records, Telegram adapter conversion, platform identity SQL, messenger-based schedule updates, and tests.
-- Placeholder scan: no `TBD`, `TODO`, or "fill later" steps remain.
-- Type consistency: commands consistently use `PlatformUser User`, `string InteractionId`, `PlatformGroup Group`, and `PlatformMessageRef ScheduleMessage`.

docs/superpowers/plans/2026-05-19-discord-newsession-listsessions.md

@@ -1,984 +0,0 @@
-# Discord /newsession и /listsessions — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:test-driven-development (TDD) for every task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Реализовать slash-команды `/newsession` и `/listsessions` в Discord-боте, позволяющие создавать батчи сессий и просматривать расписание без Web Dashboard.
-
-**Architecture:** Каждая команда — отдельный vertical slice в `GmRelay.DiscordBot`: парсер входных данных → handler с SQL (через Dapper) → отправка через NetCord REST API. Рендеринг переиспользует существующий `DiscordSessionBatchRenderer`. Данные пишутся в общую PostgreSQL модель через platform-agnostic колонки (`platform`, `external_group_id`, `external_user_id`).
-
-**Tech Stack:** .NET 10, NetCord 1.0.0-alpha.489, NetCord.Hosting.Services, Dapper, Npgsql, xUnit.
-
-**Version Bump:** minor (2.3.0 → 2.4.0) — новый функционал.
-
----
-
-## File Structure
-
-| File | Responsibility |
-|------|--------------|
-| `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionCommand.cs` | Slash-команда `/newsession` с параметрами (title, time, seats, link) |
-| `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionHandler.cs` | Handler создания batch + sessions в БД, проверка прав |
-| `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsCommand.cs` | Slash-команда `/listsessions` |
-| `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsHandler.cs` | Handler запроса активных сессий и публикации embed |
-| `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPermissionChecker.cs` | Проверка прав пользователя в guild (owner/admin/manager) |
-| `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs` | Реализация `IPlatformMessenger` для отправки/обновления расписания в Discord |
-| `tests/GmRelay.Bot.Tests/Discord/DiscordNewSessionHandlerTests.cs` | TDD-тесты создания сессий из Discord |
-| `tests/GmRelay.Bot.Tests/Discord/DiscordListSessionsHandlerTests.cs` | TDD-тесты вывода расписания |
-| `tests/GmRelay.Bot.Tests/Discord/DiscordPermissionCheckerTests.cs` | TDD-тесты проверки прав |
-| `src/GmRelay.DiscordBot/Program.cs` | Регистрация DI: handlers, permission checker, platform messenger |
-
----
-
-## Task 1: DiscordPermissionChecker
-
-**Files:**
-- Create: `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPermissionChecker.cs`
-- Test: `tests/GmRelay.Bot.Tests/Discord/DiscordPermissionCheckerTests.cs`
-
-**Context:** Discord использует guild-роли. Для MVP достаточно проверки: пользователь — owner guild, имеет роль `Administrator`, или записан как `group_managers` в БД для данной `game_groups`.
-
-### Step 1.1: Write the failing test
-
-```csharp
-using GmRelay.DiscordBot.Infrastructure.Discord;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordPermissionCheckerTests
-{
-    [Fact]
-    public void CanManageSchedule_WhenUserIsGuildOwner_ReturnsTrue()
-    {
-        var checker = new DiscordPermissionChecker();
-        var result = checker.CanManageSchedule(
-            guildOwnerId: 123456789ul,
-            userId: 123456789ul,
-            userRoles: Array.Empty<ulong>(),
-            dbManagerUserIds: Array.Empty<ulong>());
-
-        Assert.True(result);
-    }
-
-    [Fact]
-    public void CanManageSchedule_WhenUserHasAdministratorRole_ReturnsTrue()
-    {
-        var checker = new DiscordPermissionChecker();
-        var adminRole = 999ul;
-        var result = checker.CanManageSchedule(
-            guildOwnerId: 123456789ul,
-            userId: 987654321ul,
-            userRoles: new[] { adminRole },
-            dbManagerUserIds: Array.Empty<ulong>());
-
-        Assert.True(result);
-    }
-
-    [Fact]
-    public void CanManageSchedule_WhenUserIsDbManager_ReturnsTrue()
-    {
-        var checker = new DiscordPermissionChecker();
-        var managerId = 555ul;
-        var result = checker.CanManageSchedule(
-            guildOwnerId: 123456789ul,
-            userId: managerId,
-            userRoles: Array.Empty<ulong>(),
-            dbManagerUserIds: new[] { managerId });
-
-        Assert.True(result);
-    }
-
-    [Fact]
-    public void CanManageSchedule_WhenRegularUser_ReturnsFalse()
-    {
-        var checker = new DiscordPermissionChecker();
-        var result = checker.CanManageSchedule(
-            guildOwnerId: 123456789ul,
-            userId: 111ul,
-            userRoles: Array.Empty<ulong>(),
-            dbManagerUserIds: new[] { 222ul });
-
-        Assert.False(result);
-    }
-}
-```
-
-### Step 1.2: Run test to verify it fails
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordPermissionCheckerTests" --verbosity normal`
-Expected: FAIL — `DiscordPermissionChecker` not found.
-
-### Step 1.3: Write minimal implementation
-
-Create `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPermissionChecker.cs`:
-
-```csharp
-namespace GmRelay.DiscordBot.Infrastructure.Discord;
-
-public sealed class DiscordPermissionChecker
-{
-    // Discord Administrator permission bitflag
-    private const ulong AdministratorPermission = 0x8;
-
-    public bool CanManageSchedule(
-        ulong guildOwnerId,
-        ulong userId,
-        IEnumerable<ulong> userRoles,
-        IEnumerable<ulong> dbManagerUserIds)
-    {
-        if (userId == guildOwnerId)
-            return true;
-
-        if (dbManagerUserIds.Contains(userId))
-            return true;
-
-        // NetCord provides permission resolution via GuildUser.Permissions;
-        // here we accept pre-resolved flag for simplicity.
-        // Actual command handler will pass resolved permissions.
-        return false;
-    }
-
-    public bool CanManageSchedule(ulong guildOwnerId, ulong userId, IEnumerable<ulong> dbManagerUserIds, ulong resolvedPermissions)
-    {
-        if (userId == guildOwnerId)
-            return true;
-
-        if (dbManagerUserIds.Contains(userId))
-            return true;
-
-        return (resolvedPermissions & AdministratorPermission) == AdministratorPermission;
-    }
-}
-```
-
-### Step 1.4: Run test to verify it passes
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordPermissionCheckerTests" --verbosity normal`
-Expected: PASS (4/4).
-
-### Step 1.5: Commit
-
-```bash
-git add src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPermissionChecker.cs tests/GmRelay.Bot.Tests/Discord/DiscordPermissionCheckerTests.cs
-git commit -m "feat(discord): add DiscordPermissionChecker for session management rights
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: DiscordListSessionsHandler + Command
-
-**Files:**
-- Create: `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsHandler.cs`
-- Create: `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsCommand.cs`
-- Test: `tests/GmRelay.Bot.Tests/Discord/DiscordListSessionsHandlerTests.cs`
-
-**Context:** Handler должен:
-1. Найти `game_groups` по `external_group_id` = `guild_id`.
-2. Выбрать предстоящие сессии (`scheduled_at > NOW()`, `status != Cancelled`).
-3. Собрать участников.
-4. Построить view через `SessionBatchViewBuilder`.
-5. Отрендерить через `DiscordSessionBatchRenderer`.
-6. Отправить embed + buttons в Discord channel.
-
-### Step 2.1: Write the failing test
-
-Create `tests/GmRelay.Bot.Tests/Discord/DiscordListSessionsHandlerTests.cs`:
-
-```csharp
-using GmRelay.DiscordBot.Features.Sessions;
-using GmRelay.Shared.Domain;
-using GmRelay.Shared.Rendering;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordListSessionsHandlerTests
-{
-    [Fact]
-    public void BuildSchedule_WithSessions_ReturnsEmbedsAndButtons()
-    {
-        var sessionId = Guid.NewGuid();
-        var sessions = new[]
-        {
-            new SessionBatchDto(sessionId, DateTime.UtcNow.AddDays(1), SessionStatus.Planned, 4, "https://example.com")
-        };
-        var participants = Array.Empty<ParticipantBatchDto>();
-
-        var view = SessionBatchViewBuilder.Build("Test Campaign", sessions, participants);
-        var (embeds, actionRows) = GmRelay.DiscordBot.Rendering.DiscordSessionBatchRenderer.Render(view);
-
-        Assert.Single(embeds);
-        Assert.Single(actionRows);
-    }
-
-    [Fact]
-    public void BuildSchedule_WithCancelledSession_SkipsActionRows()
-    {
-        var cancelledSessionId = Guid.NewGuid();
-        var sessions = new[] { new SessionBatchDto(cancelledSessionId, DateTime.UtcNow.AddDays(1), SessionStatus.Cancelled, null, "") };
-        var participants = Array.Empty<ParticipantBatchDto>();
-
-        var view = SessionBatchViewBuilder.Build("Test Campaign", sessions, participants);
-        var (embeds, actionRows) = GmRelay.DiscordBot.Rendering.DiscordSessionBatchRenderer.Render(view);
-
-        Assert.Single(embeds);
-        Assert.Empty(actionRows);
-    }
-}
-```
-
-### Step 2.2: Run test — verify RED
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordListSessionsHandlerTests" --verbosity normal`
-Expected: FAIL — `DiscordListSessionsHandler` not found.
-
-### Step 2.3: Write minimal implementation
-
-Create `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsHandler.cs`:
-
-```csharp
-using Dapper;
-using GmRelay.Shared.Domain;
-using GmRelay.Shared.Rendering;
-using NetCord.Rest;
-using Npgsql;
-
-namespace GmRelay.DiscordBot.Features.Sessions;
-
-internal sealed record DiscordSessionListItemDto(
-    Guid Id, string Title, DateTime ScheduledAt, string Status, int? MaxPlayers,
-    int PlayerCount, int WaitlistCount);
-
-public sealed class DiscordListSessionsHandler(NpgsqlDataSource dataSource)
-{
-    public async Task<SessionBatchViewModel?> BuildScheduleAsync(
-        string guildId,
-        string channelId,
-        CancellationToken cancellationToken)
-    {
-        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
-
-        var sessions = await connection.QueryAsync<DiscordSessionListItemDto>(
-            @"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
-              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.platform = 'Discord'
-                AND g.external_group_id = @GuildId
-                AND s.status != @Cancelled
-                AND s.scheduled_at > NOW()
-              GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players
-              ORDER BY s.scheduled_at ASC",
-            new
-            {
-                GuildId = guildId,
-                Cancelled = SessionStatus.Cancelled,
-                Active = ParticipantRegistrationStatus.Active,
-                Waitlisted = ParticipantRegistrationStatus.Waitlisted
-            });
-
-        var sessionList = sessions.ToList();
-        if (sessionList.Count == 0)
-            return null;
-
-        var sessionIds = sessionList.Select(s => s.Id).ToList();
-        var participants = await connection.QueryAsync<ParticipantBatchDto>(
-            @"SELECT sp.session_id as SessionId,
-                     p.display_name as DisplayName,
-                     COALESCE(p.external_username, p.telegram_username) as TelegramUsername,
-                     sp.registration_status as RegistrationStatus
-              FROM session_participants sp
-              JOIN players p ON p.id = sp.player_id
-              WHERE sp.session_id = ANY(@SessionIds) AND sp.is_gm = false
-              ORDER BY sp.registration_status ASC, sp.created_at ASC",
-            new { SessionIds = sessionIds });
-
-        var firstTitle = sessionList.First().Title;
-        var batchDtos = sessionList.Select(s => new SessionBatchDto(
-            s.Id, s.ScheduledAt, s.Status, s.MaxPlayers, "")).ToList();
-
-        return SessionBatchViewBuilder.Build(firstTitle, batchDtos, participants.ToList());
-    }
-}
-```
-
-Create `src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsCommand.cs`:
-
-```csharp
-using NetCord.Rest;
-using NetCord.Services.ApplicationCommands;
-
-namespace GmRelay.DiscordBot.Features.Sessions;
-
-[SlashCommand("listsessions", "Show upcoming game sessions in this server")]
-public class DiscordListSessionsCommand : SlashCommandModule<SlashCommandContext>
-{
-    private readonly DiscordListSessionsHandler _handler;
-
-    public DiscordListSessionsCommand(DiscordListSessionsHandler handler)
-    {
-        _handler = handler;
-    }
-
-    public override async Task ExecuteAsync()
-    {
-        var guildId = Context.Guild?.Id.ToString()
-            ?? throw new InvalidOperationException("This command can only be used in a guild.");
-        var channelId = Context.Channel.Id.ToString();
-
-        var view = await _handler.BuildScheduleAsync(guildId, channelId, Context.CancellationToken);
-
-        if (view is null)
-        {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message("📭 В этом сервере нет предстоящих игр."));
-            return;
-        }
-
-        var (embeds, actionRows) = Rendering.DiscordSessionBatchRenderer.Render(view);
-
-        await Context.Interaction.SendResponseAsync(
-            InteractionCallback.Message(new InteractionMessageProperties()
-                .WithEmbeds(embeds)
-                .WithComponents(actionRows)));
-    }
-}
-```
-
-### Step 2.4: Run test — verify GREEN
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordListSessionsHandlerTests" --verbosity normal`
-Expected: PASS.
-
-### Step 2.5: Commit
-
-```bash
-git add src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsHandler.cs src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsCommand.cs tests/GmRelay.Bot.Tests/Discord/DiscordListSessionsHandlerTests.cs
-git commit -m "feat(discord): add /listsessions slash command and handler
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: DiscordNewSessionHandler + Command
-
-**Files:**
-- Create: `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionHandler.cs`
-- Create: `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionCommand.cs`
-- Test: `tests/GmRelay.Bot.Tests/Discord/DiscordNewSessionHandlerTests.cs`
-
-**Context:** Handler должен:
-1. Проверить права пользователя (owner/admin/manager).
-2. Upsert игрока (GM) в `players` с `platform = 'Discord'`.
-3. Upsert `game_groups` с `platform = 'Discord'`, `external_group_id = guild_id`.
-4. Создать batch + sessions.
-5. Отправить rendered schedule в Discord channel.
-6. Сохранить `platform_messages` reference.
-
-### Step 3.1: Write the failing test
-
-Create `tests/GmRelay.Bot.Tests/Discord/DiscordNewSessionHandlerTests.cs`:
-
-```csharp
-using GmRelay.DiscordBot.Features.Sessions;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordNewSessionHandlerTests
-{
-    [Fact]
-    public void ParseTimeInput_ShouldParseDiscordDateFormat()
-    {
-        var result = DiscordNewSessionHandler.ParseTimeInput("2026-05-20 19:30");
-        Assert.True(result.IsSuccess);
-        Assert.Equal(2026, result.Value.Year);
-        Assert.Equal(5, result.Value.Month);
-        Assert.Equal(20, result.Value.Day);
-        Assert.Equal(19, result.Value.Hour);
-        Assert.Equal(30, result.Value.Minute);
-    }
-
-    [Fact]
-    public void ParseTimeInput_ShouldRejectPastDate()
-    {
-        var result = DiscordNewSessionHandler.ParseTimeInput("2020-01-01 00:00");
-        Assert.False(result.IsSuccess);
-    }
-
-    [Fact]
-    public void ParseTimeInput_ShouldParseRussianDateFormat()
-    {
-        var result = DiscordNewSessionHandler.ParseTimeInput("20.05.2026 19:30");
-        Assert.True(result.IsSuccess);
-        Assert.Equal(2026, result.Value.Year);
-        Assert.Equal(5, result.Value.Month);
-        Assert.Equal(20, result.Value.Day);
-    }
-
-    [Fact]
-    public void ParseTimeInput_ShouldRejectInvalidFormat()
-    {
-        var result = DiscordNewSessionHandler.ParseTimeInput("not-a-date");
-        Assert.False(result.IsSuccess);
-        Assert.NotNull(result.Error);
-    }
-}
-```
-
-### Step 3.2: Run test — verify RED
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordNewSessionHandlerTests" --verbosity normal`
-Expected: FAIL — `DiscordNewSessionHandler` not found.
-
-### Step 3.3: Write minimal implementation
-
-Create `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionHandler.cs`:
-
-```csharp
-using Dapper;
-using GmRelay.DiscordBot.Infrastructure.Discord;
-using GmRelay.Shared.Domain;
-using GmRelay.Shared.Platform;
-using GmRelay.Shared.Rendering;
-using Npgsql;
-
-namespace GmRelay.DiscordBot.Features.Sessions;
-
-public sealed record TimeParseResult(bool IsSuccess, DateTimeOffset Value, string? Error);
-
-public sealed class DiscordNewSessionHandler(
-    NpgsqlDataSource dataSource,
-    DiscordPermissionChecker permissionChecker,
-    IPlatformMessenger messenger,
-    ILogger<DiscordNewSessionHandler> logger)
-{
-    public static TimeParseResult ParseTimeInput(string input)
-    {
-        if (DateTimeOffset.TryParseExact(
-            input.Trim(),
-            "yyyy-MM-dd HH:mm",
-            System.Globalization.CultureInfo.InvariantCulture,
-            System.Globalization.DateTimeStyles.AssumeUniversal,
-            out var result))
-        {
-            if (result < DateTimeOffset.UtcNow)
-                return new TimeParseResult(false, default, "Дата находится в прошлом.");
-
-            return new TimeParseResult(true, result.ToUniversalTime(), null);
-        }
-
-        if (DateTimeOffset.TryParseExact(
-            input.Trim(),
-            "dd.MM.yyyy HH:mm",
-            System.Globalization.CultureInfo.InvariantCulture,
-            System.Globalization.DateTimeStyles.AssumeUniversal,
-            out var altResult))
-        {
-            if (altResult < DateTimeOffset.UtcNow)
-                return new TimeParseResult(false, default, "Дата находится в прошлом.");
-
-            return new TimeParseResult(true, altResult.ToUniversalTime(), null);
-        }
-
-        return new TimeParseResult(false, default, "Некорректный формат даты. Используйте YYYY-MM-DD HH:mm или DD.MM.YYYY HH:mm");
-    }
-
-    public async Task<SessionBatchViewModel> HandleAsync(
-        string guildId,
-        string channelId,
-        ulong userId,
-        string userDisplayName,
-        IEnumerable<ulong> userRoles,
-        ulong guildOwnerId,
-        string title,
-        DateTimeOffset scheduledAt,
-        int? maxPlayers,
-        string? joinLink,
-        CancellationToken cancellationToken)
-    {
-        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
-
-        // Resolve db managers
-        var dbManagerUserIds = await connection.QueryAsync<ulong>(
-            @"SELECT CAST(p.external_user_id AS BIGINT)
-              FROM group_managers gm
-              JOIN players p ON p.id = gm.player_id
-              JOIN game_groups g ON g.id = gm.group_id
-              WHERE g.platform = 'Discord' AND g.external_group_id = @GuildId",
-            new { GuildId = guildId });
-
-        if (!permissionChecker.CanManageSchedule(guildOwnerId, userId, userRoles, dbManagerUserIds))
-        {
-            throw new UnauthorizedAccessException("⛔ Только owner, администратор или manager могут создавать сессии.");
-        }
-
-        await using var transaction = await connection.BeginTransactionAsync(cancellationToken);
-        try
-        {
-            // Upsert player
-            await connection.ExecuteAsync(
-                @"INSERT INTO players (display_name, platform, external_user_id, external_username)
-                  VALUES (@Name, 'Discord', @UserId, @Name)
-                  ON CONFLICT (platform, external_user_id)
-                  WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
-                  DO UPDATE SET display_name = EXCLUDED.display_name,
-                                external_username = EXCLUDED.external_username",
-                new { Name = userDisplayName, UserId = userId.ToString() },
-                transaction);
-
-            // Upsert group
-            var groupId = await connection.ExecuteScalarAsync<Guid>(
-                @"INSERT INTO game_groups (name, platform, external_group_id, external_channel_id)
-                  VALUES (@GuildId, 'Discord', @GuildId, @ChannelId)
-                  ON CONFLICT (platform, external_group_id)
-                  WHERE platform IS NOT NULL AND external_group_id IS NOT NULL
-                  DO UPDATE SET name = EXCLUDED.name,
-                                external_channel_id = COALESCE(EXCLUDED.external_channel_id, game_groups.external_channel_id)
-                  RETURNING id",
-                new { GuildId = guildId, ChannelId = channelId },
-                transaction);
-
-            // Ensure manager record
-            await connection.ExecuteAsync(
-                @"INSERT INTO group_managers (group_id, player_id, role)
-                  SELECT @GroupId, p.id, @OwnerRole
-                  FROM players p
-                  WHERE p.platform = 'Discord' AND p.external_user_id = @UserId
-                  ON CONFLICT (group_id, player_id) DO NOTHING",
-                new { GroupId = groupId, UserId = userId.ToString(), OwnerRole = GroupManagerRoleExtensions.OwnerValue },
-                transaction);
-
-            // Create batch + session
-            var batchId = Guid.NewGuid();
-            var sessionId = await connection.ExecuteScalarAsync<Guid>(
-                @"INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, max_players)
-                  VALUES (@BatchId, @GroupId, @Title, @Link, @ScheduledAt, @Status, @MaxPlayers)
-                  RETURNING id",
-                new
-                {
-                    BatchId = batchId,
-                    GroupId = groupId,
-                    Title = title,
-                    Link = joinLink ?? string.Empty,
-                    ScheduledAt = scheduledAt.UtcDateTime,
-                    Status = SessionStatus.Planned,
-                    MaxPlayers = maxPlayers
-                },
-                transaction);
-
-            await transaction.CommitAsync(cancellationToken);
-
-            var sessions = new[] { new SessionBatchDto(sessionId, scheduledAt.UtcDateTime, SessionStatus.Planned, maxPlayers, joinLink ?? string.Empty) };
-            var view = SessionBatchViewBuilder.Build(title, sessions, Array.Empty<ParticipantBatchDto>());
-
-            await messenger.SendScheduleAsync(
-                new PlatformScheduleMessage(
-                    new PlatformGroup(PlatformKind.Discord, guildId, guildId, channelId),
-                    view,
-                    null),
-                cancellationToken);
-
-            return view;
-        }
-        catch
-        {
-            await transaction.RollbackAsync(cancellationToken);
-            throw;
-        }
-    }
-}
-```
-
-Create `src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionCommand.cs`:
-
-```csharp
-using NetCord.Rest;
-using NetCord.Services.ApplicationCommands;
-
-namespace GmRelay.DiscordBot.Features.Sessions;
-
-[SlashCommand("newsession", "Create a new game session")]
-public class DiscordNewSessionCommand : SlashCommandModule<SlashCommandContext>
-{
-    private readonly DiscordNewSessionHandler _handler;
-
-    public DiscordNewSessionCommand(DiscordNewSessionHandler handler)
-    {
-        _handler = handler;
-    }
-
-    [SlashCommandOption("title", "Game title", Required = true)]
-    public string Title { get; set; } = string.Empty;
-
-    [SlashCommandOption("time", "Session time (YYYY-MM-DD HH:mm or DD.MM.YYYY HH:mm)", Required = true)]
-    public string Time { get; set; } = string.Empty;
-
-    [SlashCommandOption("seats", "Maximum number of players", Required = false)]
-    public long? Seats { get; set; }
-
-    [SlashCommandOption("link", "Join link", Required = false)]
-    public string? Link { get; set; }
-
-    public override async Task ExecuteAsync()
-    {
-        var guild = Context.Guild
-            ?? throw new InvalidOperationException("This command can only be used in a guild.");
-
-        var timeResult = DiscordNewSessionHandler.ParseTimeInput(Time);
-        if (!timeResult.IsSuccess)
-        {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message($"❌ {timeResult.Error}"));
-            return;
-        }
-
-        try
-        {
-            var view = await _handler.HandleAsync(
-                guildId: guild.Id.ToString(),
-                channelId: Context.Channel.Id.ToString(),
-                userId: Context.User.Id,
-                userDisplayName: Context.User.GlobalName ?? Context.User.Username,
-                userRoles: Context.GuildUser!.RoleIds,
-                guildOwnerId: guild.OwnerId,
-                title: Title,
-                scheduledAt: timeResult.Value,
-                maxPlayers: Seats is null ? null : (int)Seats.Value,
-                joinLink: Link,
-                Context.CancellationToken);
-
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message("✅ Сессия создана!"));
-        }
-        catch (UnauthorizedAccessException ex)
-        {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message($"⛅ {ex.Message}"));
-        }
-        catch (Exception ex)
-        {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message("💥 Произошла ошибка при создании сессии."));
-        }
-    }
-}
-```
-
-### Step 3.4: Run test — verify GREEN
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordNewSessionHandlerTests" --verbosity normal`
-Expected: PASS.
-
-### Step 3.5: Commit
-
-```bash
-git add src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionHandler.cs src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionCommand.cs tests/GmRelay.Bot.Tests/Discord/DiscordNewSessionHandlerTests.cs
-git commit -m "feat(discord): add /newsession slash command and handler
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: DiscordPlatformMessenger
-
-**Files:**
-- Create: `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs`
-- Test: `tests/GmRelay.Bot.Tests/Discord/DiscordPlatformMessengerTests.cs`
-
-**Context:** Необходима реализация `IPlatformMessenger` для отправки schedule embeds и обновления существующих сообщений в Discord. Для MVP достаточно `SendScheduleAsync` и `UpdateScheduleAsync` (stub для остальных).
-
-### Step 4.1: Write the failing test
-
-Create `tests/GmRelay.Bot.Tests/Discord/DiscordPlatformMessengerTests.cs`:
-
-```csharp
-using GmRelay.DiscordBot.Infrastructure.Discord;
-using GmRelay.Shared.Platform;
-using GmRelay.Shared.Rendering;
-
-namespace GmRelay.Bot.Tests.Discord;
-
-public sealed class DiscordPlatformMessengerTests
-{
-    [Fact]
-    public void Constructor_ShouldAcceptRestClient()
-    {
-        // DiscordPlatformMessenger requires a NetCord.Rest.RestClient.
-        // We verify the type can be instantiated (RestClient itself is not easily unit-testable without a real token).
-        // This test proves the contract exists and compiles.
-        var constructor = typeof(DiscordPlatformMessenger).GetConstructor(new[] { typeof(NetCord.Rest.RestClient) });
-        Assert.NotNull(constructor);
-    }
-
-    [Fact]
-    public void DiscordPlatformMessenger_ShouldImplementIPlatformMessenger()
-    {
-        Assert.True(typeof(IPlatformMessenger).IsAssignableFrom(typeof(DiscordPlatformMessenger)));
-    }
-}
-```
-
-### Step 4.2: Run test — verify RED
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordPlatformMessengerTests" --verbosity normal`
-Expected: FAIL — `DiscordPlatformMessenger` not found.
-
-### Step 4.3: Write minimal implementation
-
-Create `src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs`:
-
-```csharp
-using GmRelay.DiscordBot.Rendering;
-using GmRelay.Shared.Platform;
-using GmRelay.Shared.Rendering;
-using NetCord;
-using NetCord.Rest;
-
-namespace GmRelay.DiscordBot.Infrastructure.Discord;
-
-public sealed class DiscordPlatformMessenger(RestClient restClient) : IPlatformMessenger
-{
-    public async Task<PlatformMessageRef> SendScheduleAsync(PlatformScheduleMessage message, CancellationToken ct)
-    {
-        var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(message.View);
-
-        var channelId = ulong.Parse(message.Group.ExternalChannelId
-            ?? message.Group.ExternalGroupId);
-
-        var msg = await restClient.SendMessageAsync(
-            channelId,
-            new MessageProperties()
-                .WithEmbeds(embeds)
-                .WithComponents(actionRows),
-            ct);
-
-        return new PlatformMessageRef(
-            PlatformKind.Discord,
-            message.Group.ExternalGroupId,
-            null,
-            msg.Id.ToString());
-    }
-
-    public async Task UpdateScheduleAsync(PlatformScheduleMessage message, CancellationToken ct)
-    {
-        if (message.ExistingMessage is null)
-            return;
-
-        var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(message.View);
-
-        var channelId = ulong.Parse(message.Group.ExternalChannelId
-            ?? message.Group.ExternalGroupId);
-        var messageId = ulong.Parse(message.ExistingMessage.ExternalMessageId);
-
-        await restClient.ModifyMessageAsync(
-            channelId,
-            messageId,
-            new MessageProperties()
-                .WithEmbeds(embeds)
-                .WithComponents(actionRows),
-            ct);
-    }
-
-    public Task SendGroupMessageAsync(PlatformGroup group, string htmlText, CancellationToken ct)
-    {
-        // MVP: not needed for /newsession and /listsessions
-        return Task.CompletedTask;
-    }
-
-    public Task SendPrivateMessageAsync(PlatformPrivateMessage message, CancellationToken ct)
-    {
-        // MVP: not needed
-        return Task.CompletedTask;
-    }
-
-    public Task AnswerInteractionAsync(PlatformInteractionReply reply, CancellationToken ct)
-    {
-        // MVP: not needed (commands answer inline via SlashCommandContext)
-        return Task.CompletedTask;
-    }
-
-    public Task SendCalendarFileAsync(PlatformCalendarFile file, CancellationToken ct)
-    {
-        // MVP: not needed
-        return Task.CompletedTask;
-    }
-}
-```
-
-### Step 4.4: Run test — verify GREEN
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordPlatformMessengerTests" --verbosity normal`
-Expected: PASS.
-
-### Step 4.5: Commit
-
-```bash
-git add src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs tests/GmRelay.Bot.Tests/Discord/DiscordPlatformMessengerTests.cs
-git commit -m "feat(discord): add DiscordPlatformMessenger IPlatformMessenger implementation
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Wire up DI and Register Commands
-
-**Files:**
-- Modify: `src/GmRelay.DiscordBot/Program.cs`
-
-### Step 5.1: Write the failing test (structure test)
-
-Modify `tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs` — add test that asserts new handlers are registered:
-
-```csharp
-[Fact]
-public void Program_ShouldRegisterDiscordSessionHandlers()
-{
-    var program = ReadProgram();
-    Assert.Contains("DiscordListSessionsHandler", program);
-    Assert.Contains("DiscordNewSessionHandler", program);
-    Assert.Contains("DiscordPermissionChecker", program);
-    Assert.Contains("DiscordPlatformMessenger", program);
-    Assert.Contains("IPlatformMessenger", program);
-}
-```
-
-### Step 5.2: Run test — verify RED
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordStartupTests" --verbosity normal`
-Expected: FAIL — asserts not found in Program.cs.
-
-### Step 5.3: Write minimal implementation
-
-Modify `src/GmRelay.DiscordBot/Program.cs`:
-
-```csharp
-using GmRelay.DiscordBot.Features.Sessions;
-using GmRelay.DiscordBot.Infrastructure.Discord;
-using GmRelay.Shared.Platform;
-
-// ... existing usings ...
-
-builder.Services.AddSingleton<DiscordPermissionChecker>();
-builder.Services.AddSingleton<DiscordListSessionsHandler>();
-builder.Services.AddSingleton<DiscordNewSessionHandler>();
-builder.Services.AddSingleton<IPlatformMessenger, DiscordPlatformMessenger>();
-
-// After host.Build():
-host.AddSlashCommand("listsessions", "Show upcoming game sessions", async (DiscordListSessionsHandler handler, SlashCommandContext context) =>
-{
-    // NetCord module-based approach preferred; if AddSlashCommand lambda doesn't support DI injection of custom services,
-    // rely on module classes registered via AddApplicationCommands
-});
-```
-
-**Important:** NetCord module classes (`DiscordListSessionsCommand`, `DiscordNewSessionCommand`) автоматически регистрируются через `AddApplicationCommands()` + `AddGatewayHandlers(typeof(Program).Assembly)`. Constructor injection в модулях работает через DI контейнер. Никаких дополнительных `AddSlashCommand` для модулей не требуется.
-
-Убедиться, что в Program.cs есть:
-```csharp
-builder.Services.AddSingleton<DiscordPermissionChecker>();
-builder.Services.AddSingleton<DiscordListSessionsHandler>();
-builder.Services.AddSingleton<DiscordNewSessionHandler>();
-builder.Services.AddSingleton<IPlatformMessenger, DiscordPlatformMessenger>();
-```
-
-### Step 5.4: Run test — verify GREEN
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~DiscordStartupTests" --verbosity normal`
-Expected: PASS.
-
-### Step 5.5: Commit
-
-```bash
-git add src/GmRelay.DiscordBot/Program.cs tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs
-git commit -m "feat(discord): wire up DI registrations for session handlers and messenger
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: Build Verification
-
-### Step 6.1: Build DiscordBot project
-
-Run: `dotnet build src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj --no-restore`
-Expected: Build succeeds (0 errors, 0 warnings).
-
-### Step 6.2: Run all tests
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --verbosity normal`
-Expected: All tests pass.
-
-### Step 6.3: Commit if any fixes needed
-
-If build or tests required fixes, commit them.
-
----
-
-## Task 7: Version Bump
-
-**Files to modify:**
-- `Directory.Build.props`: `<Version>2.4.0</Version>`
-- `compose.yaml`: обновить теги `gmrelay-bot`, `gmrelay-web`, `gmrelay-discord-bot` → `2.4.0`
-- `.gitea/workflows/deploy.yml`: `VERSION: 2.4.0`
-- `src/GmRelay.Web/Components/Layout/NavMenu.razor`: `<div class="nav-version">v2.4.0</div>`
-
-### Step 7.1: Bump version
-
-Apply изменения ко всем 4 файлам.
-
-### Step 7.2: Update version test
-
-Modify `tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs` — обновить `Version_ShouldBeSynchronizedForDiscordFeatureRelease` ожидаемое значение на `2.4.0`.
-
-### Step 7.3: Run version test
-
-Run: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj --filter "FullyQualifiedName~Version_ShouldBeSynchronizedForDiscordFeatureRelease" --verbosity normal`
-Expected: PASS.
-
-### Step 7.4: Commit
-
-```bash
-git add Directory.Build.props compose.yaml .gitea/workflows/deploy.yml src/GmRelay.Web/Components/Layout/NavMenu.razor tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs
-git commit -m "chore: bump version to 2.4.0
-
-Synchronized across Directory.Build.props, compose.yaml, deploy.yml, NavMenu.razor
-
-Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>"
-```
-
----
-
-## Spec Coverage Self-Review
-
-| Issue Requirement | Task |
-|---|---|
-| Slash command `/newsession` | Task 3 |
-| Slash command `/listsessions` | Task 2 |
-| Сохранение platform group identity (guild/channel) | Task 3 (game_groups.platform, external_group_id, external_channel_id) |
-| Минимальная проверка прав | Task 1 + Task 3 |
-| Данные пишутся в общую PostgreSQL без Telegram-only assumptions | Task 2, 3 SQL используют platform-agnostic колонки |
-| `/listsessions` публикует/обновляет расписание | Task 2 + Task 4 |
-
-**Placeholder scan:** Нет TBD, TODO, "implement later". Каждый шаг содержит конкретный код.
-
-**Type consistency:** `DiscordPermissionChecker.CanManageSchedule` перегружен для resolved permissions (ulong bitflag). Handler передает `Context.GuildUser.RoleIds` и `guild.OwnerId`.
-
----
-
-## Execution Handoff
-
-**Plan complete and saved to `docs/superpowers/plans/2026-05-19-discord-newsession-listsessions.md`.**
-
-**Two execution options:**
-
-1. **Subagent-Driven (recommended)** — I dispatch a fresh subagent per task, review between tasks, fast iteration
-2. **Inline Execution** — Execute tasks in this session using executing-plans, batch execution with checkpoints for review
-
-**Which approach?**

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

@@ -1,44 +0,0 @@
-# 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.

docs/superpowers/specs/2026-05-20-platform-messenger-scheduler-notifications-design.md

@@ -1,140 +0,0 @@
-# Platform Messenger Scheduler Notifications Design
-
-## Goal
-
-Issue #31 moves scheduler-driven notifications and reschedule deadline message updates behind `IPlatformMessenger`, preserving Telegram behavior and adding full Discord support instead of no-op placeholders.
-
-## Scope
-
-- `SessionSchedulerService` remains the trigger orchestrator, but scheduler handlers stop depending on Telegram API types for outbound notification work.
-- Confirmation requests, one-hour reminders, join-link notifications, RSVP follow-up messages, and reschedule deadline updates use platform-neutral contracts.
-- Telegram keeps the current user-visible behavior: same message content, RSVP buttons, direct messages, topic/thread targeting, and stored legacy message ids.
-- Discord receives full channel and direct notifications:
-  - confirmation requests are sent to the Discord channel with RSVP buttons;
-  - Discord RSVP button clicks update participant RSVP state, refresh the confirmation message, and send the same group/GM outcome notifications where applicable;
-  - one-hour reminders and join-link notifications are sent as Discord DMs when direct notifications are enabled;
-  - join-link notifications also post the channel message with participant mentions;
-  - reschedule deadline processing updates Discord vote and schedule messages through the same messenger boundary.
-- Discord DM failures are non-fatal: log a warning and continue without posting a public fallback message.
-
-## Architecture
-
-The platform boundary should be semantic, not Telegram-shaped. `GmRelay.Shared.Platform` already owns `PlatformKind`, `PlatformUser`, `PlatformGroup`, `PlatformMessageRef`, and `IPlatformMessenger`; issue #31 extends that layer with notification-specific DTOs and messenger methods.
-
-The scheduler handlers own database queries and notification eligibility. They load platform-neutral groups, users, message refs, and session data, then ask the platform messenger to send or update the platform message. Platform implementations own rendering details: Telegram renders HTML and inline keyboards; Discord renders embeds, components, channel messages, mentions, and DMs.
-
-RSVP handling should become platform-neutral enough for both Telegram and Discord. The current `HandleRsvpHandler` logic is not duplicated. Its command changes from Telegram ids to `PlatformUser`, `PlatformGroup`, `PlatformMessageRef`, and `InteractionId`. Telegram update routing maps callback queries into that command; Discord component routing maps RSVP button interactions into the same command.
-
-Reschedule finalization already has shared database logic in `RescheduleVotingFinalizer`. The remaining platform-specific deadline services should stop editing messages through `ITelegramBotClient` or Discord `RestClient` directly. They should load message refs and call `IPlatformMessenger` to update vote messages, schedule messages, and direct result notifications.
-
-## Platform Contracts
-
-Add semantic notification records in `GmRelay.Shared.Platform`, with names finalized during implementation planning:
-
-- `PlatformSessionParticipant`: a `PlatformUser` plus RSVP, registration, and display metadata needed by notification renderers.
-- `PlatformSessionNotification`: common session title, time, join link, notification mode, group, optional existing message, and participants.
-- `PlatformConfirmationRequest`: confirmation-specific session notification with RSVP actions.
-- `PlatformJoinLinkNotification`: join-link group/direct notification data.
-- `PlatformOneHourReminder`: one-hour direct reminder data.
-- `PlatformRsvpMessageUpdate`: refreshed confirmation message state after a participant responds.
-- `PlatformRescheduleVoteUpdate`: finalized reschedule vote message state, including selected option or rejection reason.
-
-Extend `IPlatformMessenger` with methods for these semantic operations while keeping existing schedule, group, private, interaction, and calendar methods intact for current flows:
-
-- send and update confirmation request messages;
-- send one-hour reminder direct notifications;
-- send join-link channel and direct notifications;
-- update finalized reschedule vote messages;
-- send RSVP outcome messages to the group and GM recipients.
-
-The exact method names should be chosen in the implementation plan after tests define the desired API, but each method should accept platform-neutral DTOs and return `PlatformMessageRef` when the caller must persist a sent message id.
-
-## Telegram Behavior
-
-Telegram implementation lives in `GmRelay.Bot.Infrastructure.Telegram.TelegramPlatformMessenger`.
-
-It must preserve:
-
-- `messageThreadId` handling for forum topics;
-- HTML parse mode where the existing flow uses HTML;
-- current confirmation and RSVP button callback payloads;
-- `confirmation_message_id` and `link_message_id` storage in `sessions`;
-- direct notification behavior controlled by `SessionNotificationMode`;
-- warning-and-continue behavior for failed direct messages;
-- existing schedule rendering through `TelegramSessionBatchRenderer` and `BatchMessageEditor`.
-
-Telegram-specific inbound parsing remains at the Telegram boundary. `UpdateRouter` can still use `Telegram.Bot.Types`, but the command it passes into the RSVP handler should be platform-neutral.
-
-## Discord Behavior
-
-Discord implementation lives in `GmRelay.DiscordBot.Infrastructure.Discord.DiscordPlatformMessenger`.
-
-It must support:
-
-- channel messages through the configured channel id in `PlatformGroup.ExternalChannelId`;
-- interactive RSVP buttons routed by `DiscordSessionInteractionModule`;
-- ephemeral interaction replies via the existing `DiscordInteractionReplyCache` pattern;
-- DMs through Discord user ids in `PlatformUser.ExternalUserId`;
-- non-fatal DM failures with warning logs;
-- Discord-friendly rendering, not raw Telegram HTML;
-- persistence of Discord schedule and notification message refs in `platform_messages` where later updates need them.
-
-The current Discord reschedule deadline service directly uses `RestClient` for vote and schedule message edits. This should be folded into `DiscordPlatformMessenger` so deadline services and future platform handlers do not need to know Discord API details.
-
-## Data Flow
-
-1. `SessionSchedulerService.TickAsync` asks `ISessionTriggerStore` for due confirmation, one-hour reminder, and join-link session ids.
-2. Each handler loads the session, group platform identity, message refs, participants, RSVP state, and notification mode.
-3. The handler builds a semantic platform notification DTO and calls `IPlatformMessenger`.
-4. The messenger renders and sends/updates platform messages.
-5. The handler persists sent message ids where required, using legacy `sessions.confirmation_message_id` and `sessions.link_message_id` for Telegram and `platform_messages` for Discord refs that need later updates.
-6. Telegram callback queries and Discord component interactions both call the same platform-neutral RSVP handler.
-7. Reschedule deadline services use `RescheduleVotingFinalizer`, then call `IPlatformMessenger` for vote message updates, schedule updates, and direct result notifications.
-
-## Error Handling
-
-- A failed trigger query still logs and lets the scheduler continue to the next trigger category.
-- A failed send/update for one session logs and does not stop other sessions in the same tick.
-- DM failures are warning-level and non-fatal for Telegram and Discord.
-- A missing platform message ref logs a warning and skips only the update that needs the ref.
-- Unsupported platform values throw at the messenger boundary, not inside scheduler orchestration.
-- If Discord cannot parse a stored channel, message, or user id, it logs the bad external id and skips that platform send/update.
-
-## Testing
-
-Use TDD for implementation.
-
-Focused tests should cover:
-
-- `IPlatformMessenger` exposes semantic notification methods without referencing Telegram or Discord assemblies from `GmRelay.Shared`.
-- `SendConfirmationHandler`, `SendOneHourReminderHandler`, `SendJoinLinkHandler`, `HandleRsvpHandler`, and reschedule deadline services do not call `ITelegramBotClient`, `BatchMessageEditor`, or Discord `RestClient` directly for notification output.
-- Telegram source/regression tests preserve thread ids, callback payloads, message id persistence, and direct notification mode behavior.
-- Discord source tests verify registration of scheduler handlers, RSVP component routes, and messenger methods.
-- RSVP flow tests run through platform-neutral `PlatformUser` identity, including Discord users without Telegram ids.
-- Discord messenger tests verify DMs are attempted, DM failures are swallowed after logging, channel notifications include buttons or mentions as appropriate, and message refs are returned.
-- Full regression: `dotnet test tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj`, `dotnet build`, and `dotnet format --verify-no-changes --verbosity diagnostic`.
-
-## Versioning
-
-Current repository version is `2.6.0`. Although the Gitea issue is labeled `type:refactor`, the approved scope adds full Discord notification behavior. Proposed bump: `2.6.0` to `2.7.0`.
-
-Synchronize:
-
-- `Directory.Build.props`
-- `compose.yaml` image tags for bot, discord, and web
-- `.gitea/workflows/deploy.yml` `VERSION`
-- `src/GmRelay.Web/Components/Layout/NavMenu.razor`
-
-## Out Of Scope
-
-- Moving the entire scheduler hosted service into `GmRelay.Shared`.
-- Removing legacy Telegram columns such as `telegram_chat_id`, `confirmation_message_id`, or `link_message_id`.
-- Reworking Web dashboard Telegram behavior.
-- Public fallback messages when a Discord DM is blocked.
-
-## Self-Review
-
-- Spec coverage: every issue acceptance criterion is represented by scheduler handler boundaries, messenger contracts, Telegram behavior preservation, and Discord implementation requirements.
-- Placeholder scan: no TBD/TODO/fill-in-later sections remain.
-- Internal consistency: the design uses semantic platform DTOs consistently and keeps SDK-specific rendering in platform implementations.
-- Scope check: the work is large but still one coherent platform-notification refactor; moving the whole scheduler to shared remains explicitly out of scope.

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

@@ -42,12 +42,13 @@ public sealed class CancelSessionHandler(
                        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
+                         AND p.platform = 'Telegram'
+                         AND p.external_user_id = @ExternalUserId
                    ) AS CanManage
             FROM sessions s
             WHERE s.id = @SessionId
             """,
-            new { command.SessionId, command.TelegramUserId }, transaction);
+            new { command.SessionId, ExternalUserId = command.TelegramUserId.ToString() }, transaction);
 
         if (session == null)
         {
@@ -89,7 +90,7 @@ public sealed class CancelSessionHandler(
 
         var directRecipients = (await connection.QueryAsync<DirectNotificationRecipient>(
             """
-            SELECT p.telegram_id AS TelegramId,
+            SELECT p.external_user_id::BIGINT AS TelegramId,
                    p.display_name AS DisplayName
             FROM session_participants sp
             JOIN players p ON sp.player_id = p.id

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

@@ -77,16 +77,15 @@ public sealed class CreateSessionHandler(
         {
             await connection.ExecuteAsync(
                 """
-                INSERT INTO players (telegram_id, display_name, telegram_username, platform, external_user_id, external_username)
-                VALUES (@TgId, @Name, @Username, 'Telegram', @TgId::TEXT, @Username)
-                ON CONFLICT (telegram_id) DO UPDATE
+                INSERT INTO players (display_name, platform, external_user_id, external_username)
+                VALUES (@Name, 'Telegram', @ExternalId, @Username)
+                ON CONFLICT (platform, external_user_id)
+                WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
+                DO UPDATE
                 SET display_name = EXCLUDED.display_name,
-                    telegram_username = EXCLUDED.telegram_username,
-                    platform = COALESCE(players.platform, 'Telegram'),
-                    external_user_id = COALESCE(players.external_user_id, EXCLUDED.telegram_id::TEXT),
-                    external_username = COALESCE(players.external_username, EXCLUDED.telegram_username);
+                    external_username = EXCLUDED.external_username;
                 """,
-                new { TgId = gmId, Name = gmName, Username = gmUsername },
+                new { ExternalId = gmId.ToString(), Name = gmName, Username = gmUsername },
                 transaction);
 
             var existingGroup = await connection.QuerySingleOrDefaultAsync<SessionCreationGroupAccessDto>(
@@ -97,12 +96,14 @@ public sealed class CreateSessionHandler(
                            FROM group_managers gm
                            JOIN players p ON p.id = gm.player_id
                            WHERE gm.group_id = g.id
-                             AND COALESCE(p.external_user_id, p.telegram_id::TEXT) = @GmId::TEXT
+                             AND p.platform = 'Telegram'
+                             AND p.external_user_id = @ExternalGmId
                        ) AS CanManage
                 FROM game_groups g
-                WHERE COALESCE(g.external_group_id, g.telegram_chat_id::TEXT) = @ChatId::TEXT
+                WHERE g.platform = 'Telegram'
+                  AND g.external_group_id = @ExternalChatId
                 """,
-                new { ChatId = chatId, GmId = gmId },
+                new { ExternalChatId = chatId.ToString(), ExternalGmId = gmId.ToString() },
                 transaction);
 
             Guid groupId;
@@ -110,11 +111,11 @@ public sealed class CreateSessionHandler(
             {
                 groupId = await connection.ExecuteScalarAsync<Guid>(
                     """
-                    INSERT INTO game_groups (telegram_chat_id, name, gm_telegram_id, platform, external_group_id)
-                    VALUES (@ChatId, @ChatName, @GmId, 'Telegram', @ChatId::TEXT)
+                    INSERT INTO game_groups (name, platform, external_group_id)
+                    VALUES (@ChatName, 'Telegram', @ExternalChatId)
                     RETURNING id;
                     """,
-                    new { ChatId = chatId, ChatName = chatTitle, GmId = gmId },
+                    new { ExternalChatId = chatId.ToString(), ChatName = chatTitle },
                     transaction);
 
                 await connection.ExecuteAsync(
@@ -122,10 +123,11 @@ public sealed class CreateSessionHandler(
                     INSERT INTO group_managers (group_id, player_id, role)
                     SELECT @GroupId, p.id, @OwnerRole
                     FROM players p
-                    WHERE COALESCE(p.external_user_id, p.telegram_id::TEXT) = @GmId::TEXT
+                    WHERE p.platform = 'Telegram'
+                      AND p.external_user_id = @ExternalGmId
                     ON CONFLICT (group_id, player_id) DO NOTHING
                     """,
-                    new { GroupId = groupId, GmId = gmId, OwnerRole = GroupManagerRoleExtensions.OwnerValue },
+                    new { GroupId = groupId, ExternalGmId = gmId.ToString(), OwnerRole = GroupManagerRoleExtensions.OwnerValue },
                     transaction);
             }
             else

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

@@ -41,13 +41,14 @@ public sealed class PromoteWaitlistedPlayerHandler(
                            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
+                             AND p.platform = 'Telegram'
+                             AND p.external_user_id = @ExternalUserId
                        ) AS CanManage
                 FROM sessions s
                 WHERE s.id = @SessionId
                 FOR UPDATE
                 """,
-                new { command.SessionId, command.TelegramUserId },
+                new { command.SessionId, ExternalUserId = command.TelegramUserId.ToString() },
                 transaction);
 
             if (session is null)
@@ -150,7 +151,7 @@ public sealed class PromoteWaitlistedPlayerHandler(
                 """
                 SELECT sp.session_id AS SessionId,
                        p.display_name AS DisplayName,
-                       p.telegram_username AS TelegramUsername,
+                       p.external_username AS TelegramUsername,
                        sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON sp.player_id = p.id

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

@@ -24,11 +24,12 @@ public sealed class ExportCalendarHandler(
             @"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"
+            + " WHERE g.platform = 'Telegram'"
+            + " AND g.external_group_id = @ExternalChatId"
             + " AND s.status = @Planned"
             + " AND s.scheduled_at > NOW()"
             + " ORDER BY s.scheduled_at ASC",
-            new { ChatId = message.Chat.Id, Planned = SessionStatus.Planned });
+            new { ExternalChatId = message.Chat.Id.ToString(), Planned = SessionStatus.Planned });
 
         var sessionsList = sessions.ToList();
 
@@ -75,13 +76,13 @@ public sealed class ExportCalendarHandler(
             {
                 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 });
+                    @"SELECT id FROM game_groups WHERE platform = 'Telegram' AND external_group_id = @ExternalChatId",
+                    new { ExternalChatId = message.Chat.Id.ToString() });
 
                 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 });
+                    @"INSERT INTO calendar_subscriptions (id, token, user_platform, user_external_id, group_id, filter_type, created_at, expires_at)
+                      VALUES (gen_random_uuid(), @token, 'Telegram', @userExternalId, @groupId, @filterType, now(), NULL)",
+                    new { token, userExternalId = senderId.Value.ToString(), groupId, filterType = (int)CalendarSubscriptionFilter.SpecificGroup });
 
                 subscriptionUrl = $"{baseUrl.TrimEnd('/')}/calendar/{token}.ics";
             }

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

@@ -44,12 +44,13 @@ public sealed class DeleteSessionHandler(
                        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
+                         AND p.platform = 'Telegram'
+                       AND p.external_user_id = @ExternalUserId
                    ) AS CanManage
             FROM sessions s
             WHERE s.id = @SessionId
             """,
-            new { command.SessionId, command.TelegramUserId }, transaction);
+            new { command.SessionId, ExternalUserId = command.TelegramUserId.ToString() }, transaction);
 
         if (session == null)
         {
@@ -109,18 +110,22 @@ public sealed class DeleteSessionHandler(
                          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
+                           AND manager_player.platform = 'Telegram'
+                           AND manager_player.external_user_id = @ExternalUserId
                      ) 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()
+              WHERE g.platform = 'Telegram'
+                AND g.external_group_id = @ExternalChatId
+                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,
-                command.TelegramUserId,
+                ExternalChatId = command.ChatId.ToString(),
+                ExternalUserId = command.TelegramUserId.ToString(),
                 Cancelled = SessionStatus.Cancelled,
                 Active = ParticipantRegistrationStatus.Active,
                 Waitlisted = ParticipantRegistrationStatus.Waitlisted

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

@@ -74,18 +74,22 @@ public sealed class ListSessionsHandler(
                          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
+                           AND manager_player.platform = 'Telegram'
+                           AND manager_player.external_user_id = @ExternalUserId
                      ) 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()
+              WHERE g.platform = 'Telegram'
+                AND g.external_group_id = @ExternalChatId
+                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,
-                TelegramUserId = message.From?.Id,
+                ExternalChatId = message.Chat.Id.ToString(),
+                ExternalUserId = message.From?.Id.ToString(),
                 Cancelled = SessionStatus.Cancelled,
                 Active = ParticipantRegistrationStatus.Active,
                 Waitlisted = ParticipantRegistrationStatus.Waitlisted

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

@@ -53,26 +53,28 @@ 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.external_group_id::BIGINT AS TelegramChatId,
                    s.thread_id AS ThreadId,
                    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
+            WHERE rp.proposed_by_external_user_id = @ExternalGmId
               AND rp.status = 'AwaitingTime'
-              AND g.telegram_chat_id = @ChatId
+              AND g.platform = 'Telegram'
+              AND g.external_group_id = @ExternalChatId
               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
+                    AND manager_player.platform = 'Telegram'
+                    AND manager_player.external_user_id = @ExternalGmId
               )
             ORDER BY rp.created_at DESC
             LIMIT 1
             """,
-            new { GmId = gmTelegramId, ChatId = chatId });
+            new { ExternalGmId = gmTelegramId.ToString(), ExternalChatId = chatId.ToString() });
 
         if (proposal is null)
             return false;
@@ -92,8 +94,8 @@ public sealed class HandleRescheduleTimeInputHandler(
             """
             SELECT p.id AS PlayerId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
-                   p.telegram_id AS TelegramId
+                   p.external_username AS TelegramUsername,
+                   p.external_user_id::BIGINT AS TelegramId
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId
@@ -363,7 +365,7 @@ public sealed class HandleRescheduleTimeInputHandler(
                 """
                 SELECT sp.session_id AS SessionId,
                        p.display_name AS DisplayName,
-                       p.telegram_username AS TelegramUsername,
+                       p.external_username AS TelegramUsername,
                        sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON sp.player_id = p.id

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

@@ -58,11 +58,12 @@ public sealed class HandleRescheduleVoteHandler(
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId
-              AND p.telegram_id = @TelegramUserId
+              AND p.platform = 'Telegram'
+              AND p.external_user_id = @ExternalUserId
               AND sp.is_gm = false
               AND sp.registration_status = @Active
             """,
-            new { proposal.SessionId, command.TelegramUserId, Active = ParticipantRegistrationStatus.Active },
+            new { proposal.SessionId, ExternalUserId = command.TelegramUserId.ToString(), Active = ParticipantRegistrationStatus.Active },
             transaction);
 
         if (playerId is null)
@@ -91,8 +92,8 @@ public sealed class HandleRescheduleVoteHandler(
             """
             SELECT p.id AS PlayerId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
-                   p.telegram_id AS TelegramId
+                   p.external_username AS TelegramUsername,
+                   p.external_user_id::BIGINT AS TelegramId
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId
@@ -120,7 +121,7 @@ public sealed class HandleRescheduleVoteHandler(
             SELECT rov.option_id AS OptionId,
                    p.id AS PlayerId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername
+                   p.external_username AS TelegramUsername
             FROM reschedule_option_votes rov
             JOIN players p ON p.id = rov.player_id
             WHERE rov.proposal_id = @ProposalId

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

@@ -45,12 +45,13 @@ public sealed class InitiateRescheduleHandler(
                        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
+                         AND p.platform = 'Telegram'
+                         AND p.external_user_id = @ExternalUserId
                    ) AS CanManage
             FROM sessions s
             WHERE s.id = @SessionId AND s.status != @Cancelled
             """,
-            new { command.SessionId, command.TelegramUserId, Cancelled = SessionStatus.Cancelled });
+            new { command.SessionId, ExternalUserId = command.TelegramUserId.ToString(), Cancelled = SessionStatus.Cancelled });
 
         if (session is null)
         {
@@ -83,10 +84,10 @@ public sealed class InitiateRescheduleHandler(
         // 3. Create proposal in AwaitingTime status
         await connection.ExecuteAsync(
             """
-            INSERT INTO reschedule_proposals (session_id, proposed_by, source_platform, status)
-            VALUES (@SessionId, @GmId, 'Telegram', 'AwaitingTime')
+            INSERT INTO reschedule_proposals (session_id, proposed_by_external_user_id, source_platform, status)
+            VALUES (@SessionId, @ProposedBy, 'Telegram', 'AwaitingTime')
             """,
-            new { command.SessionId, GmId = command.TelegramUserId });
+            new { command.SessionId, ProposedBy = command.TelegramUserId.ToString() });
 
         logger.LogInformation("Reschedule initiated for session {SessionId} by GM {GmId}", command.SessionId, command.TelegramUserId);
 

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

@@ -79,7 +79,7 @@ public sealed class RescheduleVotingDeadlineService(
             """
             SELECT rp.vote_message_id AS VoteMessageId,
                    s.batch_message_id AS BatchMessageId,
-                   g.telegram_chat_id AS TelegramChatId,
+                   g.external_group_id::BIGINT AS TelegramChatId,
                    s.thread_id AS ThreadId
             FROM reschedule_proposals rp
             JOIN sessions s ON s.id = rp.session_id
@@ -169,7 +169,7 @@ public sealed class RescheduleVotingDeadlineService(
                 """
                 SELECT sp.session_id AS SessionId,
                        p.display_name AS DisplayName,
-                       p.telegram_username AS TelegramUsername,
+                       p.external_username AS TelegramUsername,
                        sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON sp.player_id = p.id

src/GmRelay.Bot/Migrations/V019__audit_log_platform_identity.sql

@@ -0,0 +1,18 @@
+-- =============================================================
+-- V019: Rename session_audit_log.actor_telegram_id to actor_external_user_id
+-- =============================================================
+-- Scope: Support platform-agnostic audit log identity.
+-- =============================================================
+
+ALTER TABLE session_audit_log
+    ADD COLUMN actor_external_user_id VARCHAR(255);
+
+UPDATE session_audit_log
+   SET actor_external_user_id = actor_telegram_id::TEXT
+ WHERE actor_external_user_id IS NULL;
+
+ALTER TABLE session_audit_log
+    ALTER COLUMN actor_external_user_id SET NOT NULL;
+
+ALTER TABLE session_audit_log
+    DROP COLUMN actor_telegram_id;

src/GmRelay.Bot/Migrations/V020__player_identity_links.sql

@@ -0,0 +1,37 @@
+-- =============================================================
+-- V020: Player identity linking for unified multi-platform accounts
+-- =============================================================
+-- Scope: Allow linking multiple platform identities (Telegram, Discord)
+-- to a single "primary" player account. All group/session permissions
+-- resolve through the effective (primary) player id.
+-- =============================================================
+
+-- player_links: secondary player → primary player (1:1 on secondary)
+CREATE TABLE player_links (
+    id                    UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    primary_player_id     UUID NOT NULL REFERENCES players(id) ON DELETE CASCADE,
+    secondary_player_id   UUID NOT NULL UNIQUE REFERENCES players(id) ON DELETE CASCADE,
+    linked_at             TIMESTAMPTZ NOT NULL DEFAULT now(),
+    linked_by_player_id   UUID REFERENCES players(id) ON DELETE SET NULL,
+    -- Prevent self-linking at the DB level
+    CONSTRAINT no_self_link CHECK (primary_player_id <> secondary_player_id)
+);
+
+CREATE INDEX ix_player_links_primary_player_id
+    ON player_links(primary_player_id);
+
+-- identity_audit_log: security-sensitive link/unlink actions
+CREATE TABLE identity_audit_log (
+    id                      UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    player_id               UUID NOT NULL REFERENCES players(id) ON DELETE CASCADE,
+    action                  VARCHAR(50) NOT NULL,   -- 'link', 'unlink', 'link_attempt_conflict'
+    target_platform         VARCHAR(50),
+    target_external_user_id VARCHAR(255),
+    performed_at            TIMESTAMPTZ NOT NULL DEFAULT now(),
+    performed_by_player_id  UUID REFERENCES players(id) ON DELETE SET NULL
+);
+
+CREATE INDEX ix_identity_audit_log_player_id
+    ON identity_audit_log(player_id);
+CREATE INDEX ix_identity_audit_log_performed_at
+    ON identity_audit_log(performed_at DESC);

src/GmRelay.Bot/Migrations/V021__add_avatar_url.sql

@@ -0,0 +1,8 @@
+-- =============================================================
+-- V021: Add avatar_url column to players table
+-- =============================================================
+-- Scope: Support storing avatar URLs for Discord and other platforms.
+-- =============================================================
+
+ALTER TABLE players
+    ADD COLUMN avatar_url VARCHAR(500);

src/GmRelay.Bot/Migrations/V022__fix_discord_telegram_links.sql

@@ -0,0 +1,16 @@
+-- =============================================================
+-- V022: Fix incorrectly oriented player_links for Discord↔Telegram
+-- =============================================================
+-- Scope: Reverse player_links where Discord was incorrectly made primary
+-- and Telegram secondary. Telegram (with historical group/session data)
+-- must always be the primary account.
+-- =============================================================
+
+UPDATE player_links pl
+SET primary_player_id   = pl.secondary_player_id,
+    secondary_player_id = pl.primary_player_id
+FROM players p1, players p2
+WHERE pl.primary_player_id = p1.id
+  AND pl.secondary_player_id = p2.id
+  AND p1.platform = 'Discord'
+  AND p2.platform = 'Telegram';

src/GmRelay.Bot/Migrations/V023__game_groups_telegram_chat_id_nullable.sql

@@ -0,0 +1,14 @@
+-- =============================================================
+-- V023: Make legacy Telegram columns nullable for multi-platform
+-- =============================================================
+-- Scope: Allow Discord (and future platforms) to create players
+-- and game_groups without legacy telegram_* values.
+-- Existing Telegram data was backfilled in V016.
+-- =============================================================
+
+ALTER TABLE game_groups
+    ALTER COLUMN telegram_chat_id DROP NOT NULL,
+    ALTER COLUMN gm_telegram_id DROP NOT NULL;
+
+ALTER TABLE players
+    ALTER COLUMN telegram_id DROP NOT NULL;

src/GmRelay.Bot/Migrations/V024__deprecate_telegram_columns.sql

@@ -0,0 +1,41 @@
+-- =============================================================
+-- V024: Deprecate legacy Telegram-specific columns
+-- =============================================================
+-- Scope: Complete platform migration by backfilling any remaining
+-- external_* gaps and officially deprecating telegram_* columns.
+-- No columns are dropped — rollback-safe.
+-- =============================================================
+
+-- 1. Backfill players platform identity (safeguard for any rows missed in V016)
+UPDATE players
+   SET platform          = 'Telegram',
+       external_user_id  = telegram_id::TEXT,
+       external_username = telegram_username
+ WHERE platform IS NULL;
+
+-- 2. Backfill game_groups platform identity (safeguard for any rows missed in V016)
+UPDATE game_groups
+   SET platform          = 'Telegram',
+       external_group_id = telegram_chat_id::TEXT
+ WHERE platform IS NULL;
+
+-- 3. Add platform identity to calendar_subscriptions
+ALTER TABLE calendar_subscriptions
+    ADD COLUMN user_platform   VARCHAR(50),
+    ADD COLUMN user_external_id VARCHAR(255);
+
+UPDATE calendar_subscriptions
+   SET user_external_id = user_telegram_id::TEXT,
+       user_platform    = 'Telegram'
+ WHERE user_platform IS NULL;
+
+-- 4. Migrate calendar subscription index
+DROP INDEX IF EXISTS ix_calendar_subscriptions_user_telegram_id;
+CREATE INDEX ix_calendar_subscriptions_user_external_id ON calendar_subscriptions (user_external_id);
+
+-- 5. Deprecation comments on legacy columns
+COMMENT ON COLUMN players.telegram_id         IS 'DEPRECATED: use platform + external_user_id';
+COMMENT ON COLUMN players.telegram_username   IS 'DEPRECATED: use external_username';
+COMMENT ON COLUMN game_groups.telegram_chat_id IS 'DEPRECATED: use platform + external_group_id';
+COMMENT ON COLUMN game_groups.gm_telegram_id   IS 'DEPRECATED: group ownership is tracked in group_managers';
+COMMENT ON COLUMN calendar_subscriptions.user_telegram_id IS 'DEPRECATED: use user_platform + user_external_id';

src/GmRelay.Bot/Migrations/V025__reschedule_proposals_telegram_external.sql

@@ -0,0 +1,11 @@
+-- =============================================================
+-- V025: Backfill proposed_by_external_user_id for Telegram proposals
+-- =============================================================
+-- Scope: Ensure all reschedule_proposals have proposed_by_external_user_id
+-- populated so that InitiateRescheduleHandler can stop writing proposed_by.
+-- =============================================================
+
+UPDATE reschedule_proposals
+   SET proposed_by_external_user_id = proposed_by::TEXT
+ WHERE proposed_by_external_user_id IS NULL
+   AND proposed_by IS NOT NULL;

src/GmRelay.Bot/Program.cs

@@ -1,3 +1,4 @@
+using GmRelay.Bot.Features.Notifications;
 using GmRelay.Bot.Features.Sessions.CreateSession;
 using GmRelay.Bot.Features.Sessions.RescheduleSession;
 using GmRelay.Bot.Infrastructure.Database;
@@ -79,6 +80,8 @@ builder.Services.AddSingleton<HandleRescheduleTimeInputHandler>();
 builder.Services.AddSingleton<HandleRescheduleVoteHandler>();
 builder.Services.AddSingleton<RescheduleVotingFinalizer>();
 
+builder.Services.AddSingleton<DirectSessionNotificationSender>();
+
 // ── Telegram infrastructure ──────────────────────────────────────────
 builder.Services.AddSingleton<UpdateRouter>();
 builder.Services.AddSingleton<ITelegramUpdateHandler>(sp => sp.GetRequiredService<UpdateRouter>());

src/GmRelay.DiscordBot/Dockerfile

@@ -13,8 +13,13 @@ WORKDIR /src/src/GmRelay.DiscordBot
 RUN dotnet publish "GmRelay.DiscordBot.csproj" -c Release -o /app/publish /p:UseAppHost=false
 
 # Stage 2: Runtime
-FROM mcr.microsoft.com/dotnet/runtime:10.0-noble AS final
+FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble AS final
 WORKDIR /app
+
+# Install wget for healthcheck
+RUN apt-get update && apt-get install -y --no-install-recommends wget \
+    && rm -rf /var/lib/apt/lists/*
+
 COPY --from=build /app/publish .
 USER $APP_UID
 ENTRYPOINT ["dotnet", "GmRelay.DiscordBot.dll"]

src/GmRelay.DiscordBot/Features/Sessions/DiscordDeleteSessionHandler.cs

@@ -0,0 +1,84 @@
+using Dapper;
+using GmRelay.DiscordBot.Infrastructure.Discord;
+using GmRelay.Shared.Rendering;
+using Npgsql;
+
+namespace GmRelay.DiscordBot.Features.Sessions;
+
+public sealed record DiscordDeleteSessionResult(
+    string ReplyText,
+    SessionBatchViewModel? UpdatedView,
+    string? EmptyMessage = null);
+
+public sealed class DiscordDeleteSessionHandler(
+    NpgsqlDataSource dataSource,
+    DiscordPermissionChecker permissionChecker,
+    DiscordListSessionsHandler listSessionsHandler,
+    ILogger<DiscordDeleteSessionHandler> logger)
+{
+    public async Task<DiscordDeleteSessionResult> HandleAsync(
+        string guildId,
+        string channelId,
+        ulong userId,
+        ulong resolvedPermissions,
+        ulong guildOwnerId,
+        Guid sessionId,
+        CancellationToken cancellationToken)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+
+        var dbManagerUserIds = await connection.QueryAsync<ulong>(
+            @"SELECT CAST(p.external_user_id AS BIGINT)
+              FROM group_managers gm
+              JOIN players p ON p.id = gm.player_id
+              JOIN game_groups g ON g.id = gm.group_id
+              WHERE g.platform = 'Discord' AND g.external_group_id = @GuildId",
+            new { GuildId = guildId });
+
+        if (!permissionChecker.CanManageSchedule(guildOwnerId, userId, dbManagerUserIds, resolvedPermissions))
+        {
+            return new DiscordDeleteSessionResult(
+                "Только owner, администратор или manager могут удалять сессии.",
+                UpdatedView: null);
+        }
+
+        await using var transaction = await connection.BeginTransactionAsync(cancellationToken);
+        var deletedRows = await connection.ExecuteAsync(
+            """
+            DELETE FROM sessions s
+            USING game_groups g
+            WHERE s.group_id = g.id
+              AND s.id = @SessionId
+              AND g.platform = 'Discord'
+              AND g.external_group_id = @GuildId
+            """,
+            new { SessionId = sessionId, GuildId = guildId },
+            transaction);
+
+        await transaction.CommitAsync(cancellationToken);
+
+        if (deletedRows == 0)
+        {
+            return new DiscordDeleteSessionResult(
+                "Сессия не найдена или уже удалена.",
+                UpdatedView: null);
+        }
+
+        logger.LogInformation("Deleted Discord session {SessionId} in guild {GuildId}", sessionId, guildId);
+
+        var updatedView = await listSessionsHandler.BuildScheduleAsync(
+            guildId,
+            channelId,
+            userId,
+            resolvedPermissions,
+            guildOwnerId,
+            cancellationToken);
+
+        return updatedView is null
+            ? new DiscordDeleteSessionResult(
+                "Сессия удалена.",
+                UpdatedView: null,
+                EmptyMessage: "В этом сервере нет предстоящих игр.")
+            : new DiscordDeleteSessionResult("Сессия удалена.", updatedView);
+    }
+}

src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsCommand.cs

@@ -1,9 +1,9 @@
+using NetCord;
 using NetCord.Rest;
 using NetCord.Services.ApplicationCommands;
 
 namespace GmRelay.DiscordBot.Features.Sessions;
 
-[SlashCommand("listsessions", "Show upcoming game sessions in this server")]
 public class DiscordListSessionsCommand : ApplicationCommandModule<SlashCommandContext>
 {
     private readonly DiscordListSessionsHandler _handler;
@@ -13,13 +13,23 @@ public class DiscordListSessionsCommand : ApplicationCommandModule<SlashCommandC
         _handler = handler;
     }
 
+    [SlashCommand("listsessions", "Show upcoming game sessions in this server")]
     public async Task ExecuteAsync()
     {
-        var guildId = Context.Guild?.Id.ToString()
+        var guildId = Context.Interaction.GuildId?.ToString()
             ?? throw new InvalidOperationException("This command can only be used in a guild.");
         var channelId = Context.Channel.Id.ToString();
+        var member = Context.User as GuildInteractionUser;
+        var resolvedPermissions = member is null ? 0UL : (ulong)member.Permissions;
+        var guildOwnerId = 0UL;
 
-        var view = await _handler.BuildScheduleAsync(guildId, channelId, CancellationToken.None);
+        var view = await _handler.BuildScheduleAsync(
+            guildId,
+            channelId,
+            Context.User.Id,
+            resolvedPermissions,
+            guildOwnerId,
+            CancellationToken.None);
 
         if (view is null)
         {

src/GmRelay.DiscordBot/Features/Sessions/DiscordListSessionsHandler.cs

@@ -1,4 +1,5 @@
 using Dapper;
+using GmRelay.DiscordBot.Infrastructure.Discord;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
 using Npgsql;
@@ -9,11 +10,22 @@ internal sealed record DiscordSessionListItemDto(
     Guid Id, string Title, DateTime ScheduledAt, string Status, int? MaxPlayers,
     int PlayerCount, int WaitlistCount);
 
-public sealed class DiscordListSessionsHandler(NpgsqlDataSource dataSource)
+public sealed class DiscordListSessionsHandler(
+    NpgsqlDataSource dataSource,
+    DiscordPermissionChecker permissionChecker)
 {
+    public Task<SessionBatchViewModel?> BuildScheduleAsync(
+        string guildId,
+        string channelId,
+        CancellationToken cancellationToken) =>
+        BuildScheduleAsync(guildId, channelId, 0, 0, 0, cancellationToken);
+
     public async Task<SessionBatchViewModel?> BuildScheduleAsync(
         string guildId,
         string channelId,
+        ulong userId,
+        ulong resolvedPermissions,
+        ulong guildOwnerId,
         CancellationToken cancellationToken)
     {
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
@@ -21,15 +33,15 @@ public sealed class DiscordListSessionsHandler(NpgsqlDataSource dataSource)
         var sessions = await connection.QueryAsync<DiscordSessionListItemDto>(
             @"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
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Active)::int as PlayerCount,
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false AND sp.registration_status = @Waitlisted)::int as WaitlistCount
               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.platform = 'Discord'
                 AND g.external_group_id = @GuildId
                 AND s.status != @Cancelled
-                AND s.scheduled_at > NOW()
+                AND s.scheduled_at > now() - interval '4 hours'
               GROUP BY s.id, s.title, s.scheduled_at, s.status, s.max_players
               ORDER BY s.scheduled_at ASC",
             new
@@ -44,11 +56,25 @@ public sealed class DiscordListSessionsHandler(NpgsqlDataSource dataSource)
         if (sessionList.Count == 0)
             return null;
 
+        var dbManagerUserIds = await connection.QueryAsync<ulong>(
+            @"SELECT CAST(p.external_user_id AS BIGINT)
+              FROM group_managers gm
+              JOIN players p ON p.id = gm.player_id
+              JOIN game_groups g ON g.id = gm.group_id
+              WHERE g.platform = 'Discord' AND g.external_group_id = @GuildId",
+            new { GuildId = guildId });
+
+        var canManage = permissionChecker.CanManageSchedule(
+            guildOwnerId,
+            userId,
+            dbManagerUserIds,
+            resolvedPermissions);
+
         var sessionIds = sessionList.Select(s => s.Id).ToList();
         var participants = await connection.QueryAsync<ParticipantBatchDto>(
             @"SELECT sp.session_id as SessionId,
                      p.display_name as DisplayName,
-                     COALESCE(p.external_username, p.telegram_username) as TelegramUsername,
+                     p.external_username as TelegramUsername,
                      sp.registration_status as RegistrationStatus
               FROM session_participants sp
               JOIN players p ON p.id = sp.player_id
@@ -60,6 +86,25 @@ public sealed class DiscordListSessionsHandler(NpgsqlDataSource dataSource)
         var batchDtos = sessionList.Select(s => new SessionBatchDto(
             s.Id, s.ScheduledAt, s.Status, s.MaxPlayers, "")).ToList();
 
-        return SessionBatchViewBuilder.Build(firstTitle, batchDtos, participants.ToList());
+        var view = SessionBatchViewBuilder.Build(firstTitle, batchDtos, participants.ToList());
+        return canManage ? AddManagerActions(view) : view;
     }
+
+    internal static SessionBatchViewModel AddManagerActions(SessionBatchViewModel view) =>
+        view with
+        {
+            Sessions = view.Sessions
+                .Select(session =>
+                {
+                    if (SessionStatus.IsCancelled(session.Status))
+                        return session;
+
+                    var actions = session.AvailableActions
+                        .Concat([new AvailableAction("delete_session", $"Удалить {session.ScheduledAt.FormatMoscowShort()}", session.SessionId)])
+                        .ToList();
+
+                    return session with { AvailableActions = actions };
+                })
+                .ToList()
+        };
 }

src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionCommand.cs

@@ -1,10 +1,10 @@
-using GmRelay.DiscordBot.Rendering;
+using GmRelay.DiscordBot.Rendering;
+using NetCord;
 using NetCord.Rest;
 using NetCord.Services.ApplicationCommands;
 
 namespace GmRelay.DiscordBot.Features.Sessions;
 
-[SlashCommand("newsession", "Create a new game session")]
 public class DiscordNewSessionCommand : ApplicationCommandModule<SlashCommandContext>
 {
     private readonly DiscordNewSessionHandler _handler;
@@ -16,15 +16,54 @@ public class DiscordNewSessionCommand : ApplicationCommandModule<SlashCommandCon
         _logger = logger;
     }
 
+    [SlashCommand("newsession", "Create a new game session")]
     public async Task ExecuteAsync(
         [SlashCommandParameter(Name = "title", Description = "Game title")] string title,
         [SlashCommandParameter(Name = "time", Description = "Session time (YYYY-MM-DD HH:mm or DD.MM.YYYY HH:mm)")] string time,
         [SlashCommandParameter(Name = "seats", Description = "Maximum number of players")] long? seats = null,
         [SlashCommandParameter(Name = "link", Description = "Join link")] string? link = null)
     {
-        var guild = Context.Guild
+        _logger.LogInformation(
+            "newsession called by user {UserId} ({UserType}) in guild {GuildId}, channel {ChannelId}",
+            Context.User.Id,
+            Context.User.GetType().Name,
+            Context.Interaction.GuildId,
+            Context.Channel?.Id);
+
+        var guildId = Context.Interaction.GuildId
             ?? throw new InvalidOperationException("This command can only be used in a guild.");
 
+        var member = Context.User as GuildInteractionUser;
+        if (member is null)
+        {
+            _logger.LogError("Context.User is not GuildInteractionUser. Actual type: {ActualType}", Context.User.GetType().Name);
+            throw new InvalidOperationException("Guild member data not available in interaction.");
+        }
+
+        var resolvedPermissions = (ulong)member.Permissions;
+        _logger.LogInformation("Resolved permissions for user {UserId}: {Permissions}", Context.User.Id, resolvedPermissions);
+
+        ulong guildOwnerId = 0;
+        var guildName = guildId.ToString();
+        try
+        {
+            var guild = await Context.Client.Rest.GetGuildAsync(guildId);
+            guildOwnerId = guild.OwnerId;
+            guildName = guild.Name;
+            _logger.LogInformation("Guild owner id: {OwnerId}", guildOwnerId);
+        }
+        catch (RestException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+        {
+            _logger.LogWarning(
+                ex,
+                "Bot is not a REST member of guild {GuildId}; using resolved permissions from interaction payload",
+                guildId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unexpected error fetching guild {GuildId}", guildId);
+        }
+
         var timeResult = DiscordNewSessionHandler.ParseTimeInput(time);
         if (!timeResult.IsSuccess)
         {
@@ -33,55 +72,57 @@ public class DiscordNewSessionCommand : ApplicationCommandModule<SlashCommandCon
             return;
         }
 
-        var resolvedPermissions = GetResolvedPermissions(guild, Context.User.Id);
+        // Defer the response to avoid Discord 3-second interaction timeout
+        await Context.Interaction.SendResponseAsync(InteractionCallback.DeferredMessage());
 
         try
         {
+            _logger.LogInformation("Creating session for guild {GuildId}, user {UserId}", guildId, Context.User.Id);
+
             var view = await _handler.HandleAsync(
-                guildId: guild.Id.ToString(),
-                channelId: Context.Channel.Id.ToString(),
+                guildId: guildId.ToString(),
+                channelId: Context.Channel!.Id.ToString(),
+                groupName: guildName,
                 userId: Context.User.Id,
                 userDisplayName: Context.User.GlobalName ?? Context.User.Username,
                 resolvedPermissions: resolvedPermissions,
-                guildOwnerId: guild.OwnerId,
+                guildOwnerId: guildOwnerId,
                 title: title,
                 scheduledAt: timeResult.Value,
                 maxPlayers: seats is null ? null : (int)seats.Value,
                 joinLink: link,
                 CancellationToken.None);
 
+            _logger.LogInformation("Session created successfully. Building render.");
+
             var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(view);
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message(new InteractionMessageProperties()
-                    .WithContent(":white_check_mark: **Session created successfully!**")
-                    .WithEmbeds(embeds)
-                    .WithComponents(actionRows)));
+
+            _logger.LogInformation("Sending success response.");
+
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = ":white_check_mark: **Session created successfully!**";
+                message.Embeds = embeds;
+                message.Components = actionRows;
+            });
+
+            _logger.LogInformation("Success response sent.");
         }
         catch (UnauthorizedAccessException ex)
         {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message($":no_entry: {ex.Message}"));
+            _logger.LogWarning(ex, "Unauthorized session creation attempt by user {UserId}", Context.User.Id);
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = $":no_entry: {ex.Message}";
+            });
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to create session for user {UserId} in guild {GuildId}", Context.User.Id, guild.Id);
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message(":boom: An error occurred while creating the session."));
+            _logger.LogError(ex, "Failed to create session for user {UserId} in guild {GuildId}", Context.User.Id, guildId);
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = ":boom: An error occurred while creating the session.";
+            });
         }
     }
-
-    private static ulong GetResolvedPermissions(NetCord.Gateway.Guild guild, ulong userId)
-    {
-        if (!guild.Users.TryGetValue(userId, out var guildUser))
-            return 0;
-
-        ulong resolved = 0;
-        foreach (var roleId in guildUser.RoleIds)
-        {
-            if (guild.Roles.TryGetValue(roleId, out var role))
-                resolved |= (ulong)role.Permissions;
-        }
-
-        return resolved;
-    }
 }

src/GmRelay.DiscordBot/Features/Sessions/DiscordNewSessionHandler.cs

@@ -1,9 +1,9 @@
 using Dapper;
 using GmRelay.DiscordBot.Infrastructure.Discord;
 using GmRelay.Shared.Domain;
-using GmRelay.Shared.Platform;
 using GmRelay.Shared.Rendering;
 using Npgsql;
+using System.Globalization;
 
 namespace GmRelay.DiscordBot.Features.Sessions;
 
@@ -12,35 +12,40 @@ public sealed record TimeParseResult(bool IsSuccess, DateTimeOffset Value, strin
 public sealed class DiscordNewSessionHandler(
     NpgsqlDataSource dataSource,
     DiscordPermissionChecker permissionChecker,
-    IPlatformMessenger messenger,
     ILogger<DiscordNewSessionHandler> logger)
 {
+    private static readonly TimeSpan MoscowOffset = TimeSpan.FromHours(3);
+
     public static TimeParseResult ParseTimeInput(string input)
     {
-        if (DateTimeOffset.TryParseExact(
-            input.Trim(),
+        var trimmed = input.Trim();
+
+        if (DateTime.TryParseExact(
+            trimmed,
             "yyyy-MM-dd HH:mm",
-            System.Globalization.CultureInfo.InvariantCulture,
-            System.Globalization.DateTimeStyles.AssumeUniversal,
-            out var result))
+            CultureInfo.InvariantCulture,
+            DateTimeStyles.None,
+            out var dt1))
         {
-            if (result < DateTimeOffset.UtcNow)
+            var offset = new DateTimeOffset(dt1, MoscowOffset).ToUniversalTime();
+            if (offset < DateTimeOffset.UtcNow)
                 return new TimeParseResult(false, default, "Дата находится в прошлом.");
 
-            return new TimeParseResult(true, result.ToUniversalTime(), null);
+            return new TimeParseResult(true, offset, null);
         }
 
-        if (DateTimeOffset.TryParseExact(
-            input.Trim(),
+        if (DateTime.TryParseExact(
+            trimmed,
             "dd.MM.yyyy HH:mm",
-            System.Globalization.CultureInfo.InvariantCulture,
-            System.Globalization.DateTimeStyles.AssumeUniversal,
-            out var altResult))
+            CultureInfo.InvariantCulture,
+            DateTimeStyles.None,
+            out var dt2))
         {
-            if (altResult < DateTimeOffset.UtcNow)
+            var offset = new DateTimeOffset(dt2, MoscowOffset).ToUniversalTime();
+            if (offset < DateTimeOffset.UtcNow)
                 return new TimeParseResult(false, default, "Дата находится в прошлом.");
 
-            return new TimeParseResult(true, altResult.ToUniversalTime(), null);
+            return new TimeParseResult(true, offset, null);
         }
 
         return new TimeParseResult(false, default, "Некорректный формат даты. Используйте YYYY-MM-DD HH:mm или DD.MM.YYYY HH:mm");
@@ -49,6 +54,7 @@ public sealed class DiscordNewSessionHandler(
     public async Task<SessionBatchViewModel> HandleAsync(
         string guildId,
         string channelId,
+        string groupName,
         ulong userId,
         string userDisplayName,
         ulong resolvedPermissions,
@@ -60,6 +66,9 @@ public sealed class DiscordNewSessionHandler(
         CancellationToken cancellationToken)
     {
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+        var displayGroupName = string.IsNullOrWhiteSpace(groupName) || string.Equals(groupName, guildId, StringComparison.Ordinal)
+            ? title
+            : groupName.Trim();
 
         var dbManagerUserIds = await connection.QueryAsync<ulong>(
             @"SELECT CAST(p.external_user_id AS BIGINT)
@@ -75,6 +84,7 @@ public sealed class DiscordNewSessionHandler(
         }
 
         await using var transaction = await connection.BeginTransactionAsync(cancellationToken);
+        var transactionCommitted = false;
         try
         {
             await connection.ExecuteAsync(
@@ -89,13 +99,13 @@ public sealed class DiscordNewSessionHandler(
 
             var groupId = await connection.ExecuteScalarAsync<Guid>(
                 @"INSERT INTO game_groups (name, platform, external_group_id, external_channel_id)
-                  VALUES (@GuildId, 'Discord', @GuildId, @ChannelId)
+                  VALUES (@GroupName, 'Discord', @GuildId, @ChannelId)
                   ON CONFLICT (platform, external_group_id)
                   WHERE platform IS NOT NULL AND external_group_id IS NOT NULL
                   DO UPDATE SET name = EXCLUDED.name,
                                 external_channel_id = COALESCE(EXCLUDED.external_channel_id, game_groups.external_channel_id)
                   RETURNING id",
-                new { GuildId = guildId, ChannelId = channelId },
+                new { GroupName = displayGroupName, GuildId = guildId, ChannelId = channelId },
                 transaction);
 
             await connection.ExecuteAsync(
@@ -125,23 +135,19 @@ public sealed class DiscordNewSessionHandler(
                 transaction);
 
             await transaction.CommitAsync(cancellationToken);
+            transactionCommitted = true;
             logger.LogInformation("Created session {SessionId} in guild {GuildId}", sessionId, guildId);
 
             var sessions = new[] { new SessionBatchDto(sessionId, scheduledAt.UtcDateTime, SessionStatus.Planned, maxPlayers, joinLink ?? string.Empty) };
-            var view = SessionBatchViewBuilder.Build(title, sessions, Array.Empty<ParticipantBatchDto>());
-
-            await messenger.SendScheduleAsync(
-                new PlatformScheduleMessage(
-                    new PlatformGroup(PlatformKind.Discord, guildId, guildId, channelId),
-                    view,
-                    null),
-                cancellationToken);
-
-            return view;
+            return SessionBatchViewBuilder.Build(title, sessions, Array.Empty<ParticipantBatchDto>());
         }
         catch
         {
-            await transaction.RollbackAsync(cancellationToken);
+            if (!transactionCommitted)
+            {
+                await transaction.RollbackAsync(cancellationToken);
+            }
+
             throw;
         }
     }

src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleCommand.cs

@@ -1,9 +1,9 @@
 namespace GmRelay.DiscordBot.Features.Sessions;
 
+using NetCord;
 using NetCord.Rest;
 using NetCord.Services.ApplicationCommands;
 
-[SlashCommand("reschedule", "Initiate reschedule voting for a session")]
 public class DiscordRescheduleCommand : ApplicationCommandModule<SlashCommandContext>
 {
     private readonly DiscordRescheduleHandler _handler;
@@ -15,6 +15,7 @@ public class DiscordRescheduleCommand : ApplicationCommandModule<SlashCommandCon
         _logger = logger;
     }
 
+    [SlashCommand("reschedule", "Initiate reschedule voting for a session")]
     public async Task ExecuteAsync(
         [SlashCommandParameter(Name = "session", Description = "Session ID to reschedule")] string sessionIdText,
         [SlashCommandParameter(Name = "option1", Description = "First time option (YYYY-MM-DD HH:mm)")] string option1,
@@ -22,9 +23,44 @@ public class DiscordRescheduleCommand : ApplicationCommandModule<SlashCommandCon
         [SlashCommandParameter(Name = "option3", Description = "Third time option (optional)")] string? option3 = null,
         [SlashCommandParameter(Name = "deadline", Description = "Voting deadline (YYYY-MM-DD HH:mm)")] string deadline = "")
     {
-        var guild = Context.Guild
+        _logger.LogInformation(
+            "reschedule called by user {UserId} ({UserType}) in guild {GuildId}",
+            Context.User.Id,
+            Context.User.GetType().Name,
+            Context.Interaction.GuildId);
+
+        var guildId = Context.Interaction.GuildId
             ?? throw new InvalidOperationException("This command can only be used in a guild.");
 
+        var member = Context.User as GuildInteractionUser;
+        if (member is null)
+        {
+            _logger.LogError("Context.User is not GuildInteractionUser. Actual type: {ActualType}", Context.User.GetType().Name);
+            throw new InvalidOperationException("Guild member data not available in interaction.");
+        }
+
+        var resolvedPermissions = (ulong)member.Permissions;
+        _logger.LogInformation("Resolved permissions for user {UserId}: {Permissions}", Context.User.Id, resolvedPermissions);
+
+        ulong guildOwnerId = 0;
+        try
+        {
+            var guild = await Context.Client.Rest.GetGuildAsync(guildId);
+            guildOwnerId = guild.OwnerId;
+            _logger.LogInformation("Guild owner id: {OwnerId}", guildOwnerId);
+        }
+        catch (RestException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+        {
+            _logger.LogWarning(
+                ex,
+                "Bot is not a REST member of guild {GuildId}; using resolved permissions from interaction payload",
+                guildId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unexpected error fetching guild {GuildId}", guildId);
+        }
+
         if (!Guid.TryParse(sessionIdText, out var sessionId))
         {
             await Context.Interaction.SendResponseAsync(
@@ -64,54 +100,55 @@ public class DiscordRescheduleCommand : ApplicationCommandModule<SlashCommandCon
             return;
         }
 
-        var resolvedPermissions = GetResolvedPermissions(guild, Context.User.Id);
+        // Defer the response to avoid Discord 3-second interaction timeout
+        await Context.Interaction.SendResponseAsync(InteractionCallback.DeferredMessage());
 
         try
         {
+            _logger.LogInformation("Initiating reschedule for session {SessionId} in guild {GuildId}", sessionId, guildId);
+
             var result = await _handler.HandleAsync(
-                guildId: guild.Id.ToString(),
-                channelId: Context.Channel.Id.ToString(),
+                guildId: guildId.ToString(),
+                channelId: Context.Channel!.Id.ToString(),
                 userId: Context.User.Id,
                 userDisplayName: Context.User.GlobalName ?? Context.User.Username,
                 resolvedPermissions: resolvedPermissions,
-                guildOwnerId: guild.OwnerId,
+                guildOwnerId: guildOwnerId,
                 sessionId: sessionId,
                 options: parsedOptions,
                 deadline: deadlineResult.Value,
                 CancellationToken.None);
 
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message(
-                    $"🗳 Голосование за перенос запущено! Дедлайн: {deadlineResult.Value:yyyy-MM-dd HH:mm} UTC."));
+            _logger.LogInformation("Reschedule voting started for session {SessionId}, proposal {ProposalId}", sessionId, result.ProposalId);
+
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = $"🗳 Голосование за перенос запущено! Дедлайн: {deadlineResult.Value:yyyy-MM-dd HH:mm} UTC.";
+            });
         }
         catch (UnauthorizedAccessException ex)
         {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message($":no_entry: {ex.Message}"));
+            _logger.LogWarning(ex, "Unauthorized reschedule attempt by user {UserId}", Context.User.Id);
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = $":no_entry: {ex.Message}";
+            });
         }
         catch (InvalidOperationException ex)
         {
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message($":warning: {ex.Message}"));
+            _logger.LogWarning(ex, "Invalid reschedule request by user {UserId}", Context.User.Id);
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = $":warning: {ex.Message}";
+            });
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Failed to initiate reschedule for session {SessionId}", sessionId);
-            await Context.Interaction.SendResponseAsync(
-                InteractionCallback.Message(":boom: Ошибка при запуске голосования."));
+            await Context.Interaction.ModifyResponseAsync(message =>
+            {
+                message.Content = ":boom: Ошибка при запуске голосования.";
+            });
         }
     }
-
-    private static ulong GetResolvedPermissions(NetCord.Gateway.Guild guild, ulong userId)
-    {
-        if (!guild.Users.TryGetValue(userId, out var guildUser))
-            return 0;
-        ulong resolved = 0;
-        foreach (var roleId in guildUser.RoleIds)
-        {
-            if (guild.Roles.TryGetValue(roleId, out var role))
-                resolved |= (ulong)role.Permissions;
-        }
-        return resolved;
-    }
 }

src/GmRelay.DiscordBot/Features/Sessions/DiscordRescheduleVotingDeadlineService.cs

@@ -152,7 +152,7 @@ public sealed class DiscordRescheduleVotingDeadlineService(
                 """
                 SELECT sp.session_id AS SessionId,
                        p.display_name AS DisplayName,
-                       COALESCE(p.external_username, p.telegram_username) AS TelegramUsername,
+                       p.external_username AS TelegramUsername,
                        sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON p.id = sp.player_id

src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs

@@ -1,8 +1,10 @@
 using GmRelay.DiscordBot.Infrastructure.Discord;
+using GmRelay.DiscordBot.Rendering;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Features.Confirmation.HandleRsvp;
 using GmRelay.Shared.Features.Sessions.CreateSession;
 using GmRelay.Shared.Platform;
+using System.Collections;
 using System.Globalization;
 using NetCord;
 using NetCord.Rest;
@@ -14,6 +16,7 @@ public sealed class DiscordSessionInteractionModule(
     JoinSessionHandler joinSessionHandler,
     LeaveSessionHandler leaveSessionHandler,
     HandleRsvpHandler rsvpHandler,
+    DiscordDeleteSessionHandler deleteSessionHandler,
     DiscordRescheduleVoteHandler voteHandler,
     DiscordInteractionReplyCache interactionReplies,
     ILogger<DiscordSessionInteractionModule> logger) : ComponentInteractionModule<ButtonInteractionContext>
@@ -28,21 +31,22 @@ public sealed class DiscordSessionInteractionModule(
         }
 
         var input = CreateInput(parsedSessionId);
-        await RespondAsync(InteractionCallback.DeferredMessage(MessageFlags.Ephemeral));
+        await RespondAsync(InteractionCallback.DeferredModifyMessage);
+        SessionInteractionResult result;
         try
         {
-            await joinSessionHandler.HandleAsync(
-                DiscordSessionInteractionMapper.CreateJoinCommand(input),
+            result = await joinSessionHandler.HandleAsync(
+                DiscordSessionInteractionMapper.CreateJoinCommand(input) with { DeferScheduleUpdate = true },
                 CancellationToken.None);
         }
         catch (Exception ex)
         {
             logger.LogError(ex, "Failed to handle Discord join interaction for session {SessionId}", parsedSessionId);
-            await CompleteResponseAsync("Не удалось обработать кнопку.");
+            await FollowupEphemeralAsync("Не удалось обработать кнопку.");
             return;
         }
 
-        await CompleteWithStoredReplyAsync(input.InteractionId);
+        await CompleteScheduleUpdateResponseAsync(input.InteractionId, result);
     }
 
     [ComponentInteraction("leave_session")]
@@ -55,21 +59,56 @@ public sealed class DiscordSessionInteractionModule(
         }
 
         var input = CreateInput(parsedSessionId);
-        await RespondAsync(InteractionCallback.DeferredMessage(MessageFlags.Ephemeral));
+        await RespondAsync(InteractionCallback.DeferredModifyMessage);
+        SessionInteractionResult result;
         try
         {
-            await leaveSessionHandler.HandleAsync(
-                DiscordSessionInteractionMapper.CreateLeaveCommand(input),
+            result = await leaveSessionHandler.HandleAsync(
+                DiscordSessionInteractionMapper.CreateLeaveCommand(input) with { DeferScheduleUpdate = true },
                 CancellationToken.None);
         }
         catch (Exception ex)
         {
             logger.LogError(ex, "Failed to handle Discord leave interaction for session {SessionId}", parsedSessionId);
-            await CompleteResponseAsync("Не удалось обработать кнопку.");
+            await FollowupEphemeralAsync("Не удалось обработать кнопку.");
             return;
         }
 
-        await CompleteWithStoredReplyAsync(input.InteractionId);
+        await CompleteScheduleUpdateResponseAsync(input.InteractionId, result);
+    }
+
+    [ComponentInteraction("delete_session")]
+    public async Task DeleteAsync(string sessionId)
+    {
+        if (!Guid.TryParse(sessionId, out var parsedSessionId))
+        {
+            await RespondAsync(CreateEphemeralReply("Session button is outdated."));
+            return;
+        }
+
+        var input = CreateInput(parsedSessionId);
+        var member = Context.User as GuildInteractionUser;
+        var resolvedPermissions = member is null ? 0UL : (ulong)member.Permissions;
+
+        await RespondAsync(InteractionCallback.DeferredModifyMessage);
+        try
+        {
+            var result = await deleteSessionHandler.HandleAsync(
+                guildId: input.GuildId,
+                channelId: input.ChannelId,
+                userId: input.UserId,
+                resolvedPermissions: resolvedPermissions,
+                guildOwnerId: 0,
+                sessionId: parsedSessionId,
+                CancellationToken.None);
+
+            await CompleteDeleteResponseAsync(result);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to handle Discord delete interaction for session {SessionId}", parsedSessionId);
+            await FollowupEphemeralAsync("Не удалось удалить сессию.");
+        }
     }
 
     [ComponentInteraction("rsvp")]
@@ -124,7 +163,7 @@ public sealed class DiscordSessionInteractionModule(
         catch (Exception ex)
         {
             logger.LogError(ex, "Failed to handle Discord RSVP interaction for session {SessionId}", parsedSessionId);
-            await CompleteResponseAsync("Не удалось обработать кнопку.");
+            await CompleteResponseAsync("Не удалось обработать кнопку.");
             return;
         }
 
@@ -168,7 +207,7 @@ public sealed class DiscordSessionInteractionModule(
 
     private DiscordSessionInteractionInput CreateInput(Guid sessionId)
     {
-        var guild = Context.Guild
+        var guildId = Context.Interaction.GuildId?.ToString(CultureInfo.InvariantCulture)
             ?? throw new InvalidOperationException("Session buttons can only be used in a guild.");
         var message = Context.Interaction.Message
             ?? throw new InvalidOperationException("Session button interaction must include a message.");
@@ -176,7 +215,7 @@ public sealed class DiscordSessionInteractionModule(
         return new DiscordSessionInteractionInput(
             SessionId: sessionId,
             InteractionId: Context.Interaction.Id.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            GuildId: guild.Id.ToString(CultureInfo.InvariantCulture),
+            GuildId: guildId,
             ChannelId: Context.Channel.Id.ToString(CultureInfo.InvariantCulture),
             MessageId: message.Id.ToString(CultureInfo.InvariantCulture),
             UserId: Context.User.Id,
@@ -190,9 +229,85 @@ public sealed class DiscordSessionInteractionModule(
         await CompleteResponseAsync(reply?.Text ?? "Session updated.");
     }
 
+    private async Task CompleteScheduleUpdateResponseAsync(string interactionId, SessionInteractionResult result)
+    {
+        var updatedView = result.UpdatedView;
+        if (updatedView is not null && SourceMessageHasDeleteAction())
+        {
+            updatedView = DiscordListSessionsHandler.AddManagerActions(updatedView);
+        }
+
+        if (updatedView is not null)
+        {
+            var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(updatedView);
+            await ModifyResponseAsync(options =>
+            {
+                options.Embeds = embeds;
+                options.Components = actionRows;
+            });
+        }
+
+        var reply = interactionReplies.Take(interactionId);
+        await FollowupEphemeralAsync(reply?.Text ?? result.ReplyText);
+    }
+
+    private async Task CompleteDeleteResponseAsync(DiscordDeleteSessionResult result)
+    {
+        if (result.UpdatedView is not null)
+        {
+            var (embeds, actionRows) = DiscordSessionBatchRenderer.Render(result.UpdatedView);
+            await ModifyResponseAsync(options =>
+            {
+                options.Embeds = embeds;
+                options.Components = actionRows;
+            });
+        }
+        else if (result.EmptyMessage is not null)
+        {
+            await ModifyResponseAsync(options =>
+            {
+                options.Content = result.EmptyMessage;
+                options.Embeds = [];
+                options.Components = [];
+            });
+        }
+
+        await FollowupEphemeralAsync(result.ReplyText);
+    }
+
     private Task CompleteResponseAsync(string text) =>
         ModifyResponseAsync(options => options.Content = text);
 
+    private Task FollowupEphemeralAsync(string text) =>
+        FollowupAsync(new InteractionMessageProperties()
+            .WithContent(text)
+            .WithFlags(MessageFlags.Ephemeral));
+
+    private bool SourceMessageHasDeleteAction() =>
+        Context.Interaction.Message?.Components.Any(ComponentContainsDeleteAction) == true;
+
+    private static bool ComponentContainsDeleteAction(object? component)
+    {
+        if (component is null)
+            return false;
+
+        if (component is IInteractiveComponent interactive
+            && interactive.CustomId.StartsWith("delete_session:", StringComparison.Ordinal))
+            return true;
+
+        var nestedComponents = component.GetType().GetProperty("Components")?.GetValue(component) as IEnumerable;
+        if (nestedComponents is null)
+            return false;
+
+        foreach (var nestedComponent in nestedComponents)
+        {
+            if (ComponentContainsDeleteAction(nestedComponent))
+                return true;
+        }
+
+        return false;
+    }
+
     private static InteractionCallbackProperties CreateEphemeralReply(string text) =>
         InteractionCallback.Message(
             new InteractionMessageProperties()

src/GmRelay.DiscordBot/GmRelay.DiscordBot.csproj

@@ -6,11 +6,14 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <UserSecretsId>dotnet-GmRelay.DiscordBot-issue-26</UserSecretsId>
+    <!-- DiscordBot uses vanilla Dapper in its own handlers; DAP005 requires AOT-enabled Dapper -->
+    <NoWarn>$(NoWarn);DAP005</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
     <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="Microsoft.Extensions.Hosting" Version="10.0.5" />
     <PackageReference Include="NetCord.Hosting" Version="1.0.0-alpha.489" />
     <PackageReference Include="NetCord.Hosting.Services" Version="1.0.0-alpha.489" />

src/GmRelay.DiscordBot/Infrastructure/Discord/DiscordPlatformMessenger.cs

@@ -98,17 +98,34 @@ public sealed class DiscordPlatformMessenger : IPlatformMessenger
         CancellationToken ct)
     {
         var channelId = GetChannelId(request.Group);
-        var message = await restClient.SendMessageAsync(
-            channelId,
-            new MessageProperties()
-                .WithEmbeds([BuildConfirmationEmbed(request)])
-                .WithComponents(BuildRsvpRows(request.SessionId, disabled: false)));
+        try
+        {
+            var message = await restClient.SendMessageAsync(
+                channelId,
+                new MessageProperties()
+                    .WithEmbeds([BuildConfirmationEmbed(request)])
+                    .WithComponents(BuildRsvpRows(request.SessionId, disabled: false)));
 
-        return new PlatformMessageRef(
-            PlatformKind.Discord,
-            request.Group.ExternalGroupId,
-            null,
-            message.Id.ToString(CultureInfo.InvariantCulture));
+            logger?.LogInformation(
+                "Confirmation request sent to Discord channel {ChannelId}, message id {MessageId}",
+                channelId,
+                message.Id);
+
+            return new PlatformMessageRef(
+                PlatformKind.Discord,
+                request.Group.ExternalGroupId,
+                null,
+                message.Id.ToString(CultureInfo.InvariantCulture));
+        }
+        catch (Exception ex)
+        {
+            logger?.LogError(
+                ex,
+                "Failed to send confirmation request to Discord channel {ChannelId} for session {SessionId}",
+                channelId,
+                request.SessionId);
+            throw;
+        }
     }
 
     public async Task UpdateConfirmationRequestAsync(PlatformRsvpMessageUpdate update, CancellationToken ct)
@@ -135,15 +152,32 @@ public sealed class DiscordPlatformMessenger : IPlatformMessenger
         CancellationToken ct)
     {
         var channelId = GetChannelId(notification.Group);
-        var message = await restClient.SendMessageAsync(
-            channelId,
-            new MessageProperties().WithEmbeds([BuildJoinLinkEmbed(notification)]));
+        try
+        {
+            var message = await restClient.SendMessageAsync(
+                channelId,
+                new MessageProperties().WithEmbeds([BuildJoinLinkEmbed(notification)]));
 
-        return new PlatformMessageRef(
-            PlatformKind.Discord,
-            notification.Group.ExternalGroupId,
-            null,
-            message.Id.ToString(CultureInfo.InvariantCulture));
+            logger?.LogInformation(
+                "Join link sent to Discord channel {ChannelId}, message id {MessageId}",
+                channelId,
+                message.Id);
+
+            return new PlatformMessageRef(
+                PlatformKind.Discord,
+                notification.Group.ExternalGroupId,
+                null,
+                message.Id.ToString(CultureInfo.InvariantCulture));
+        }
+        catch (Exception ex)
+        {
+            logger?.LogError(
+                ex,
+                "Failed to send join link to Discord channel {ChannelId} for session {SessionId}",
+                channelId,
+                notification.SessionId);
+            throw;
+        }
     }
 
     public async Task SendDirectSessionNotificationAsync(
@@ -272,14 +306,16 @@ public sealed class DiscordPlatformMessenger : IPlatformMessenger
             ? "—"
             : string.Join(", ", notification.ConfirmedPlayers.Select(p => Mention(p.User)));
 
-        return new EmbedProperties()
+        var embed = new EmbedProperties()
             .WithTitle($"Ссылка на игру: {notification.Title}")
             .WithDescription(
                 $"Время: **{notification.ScheduledAt.FormatMoscow()}** (МСК)\n" +
                 $"Ссылка: {notification.JoinLink}\n\n" +
                 $"Участники: {mentions}")
-            .WithUrl(notification.JoinLink)
             .WithColor(new Color(0x57F287));
+
+        var embedUrl = DiscordEmbedUrls.NormalizeHttpUrl(notification.JoinLink);
+        return embedUrl is null ? embed : embed.WithUrl(embedUrl);
     }
 
     private static IReadOnlyList<ActionRowProperties> BuildRsvpRows(Guid sessionId, bool disabled)

src/GmRelay.DiscordBot/Infrastructure/Health/DiscordHealthCheckHostedService.cs

@@ -0,0 +1,101 @@
+using System.Net;
+
+namespace GmRelay.DiscordBot.Infrastructure.Health;
+
+public sealed class DiscordHealthCheckHostedService : IHostedService
+{
+    private readonly ILogger<DiscordHealthCheckHostedService> _logger;
+    private readonly string _prefix;
+    private HttpListener? _listener;
+    private CancellationTokenSource? _cts;
+    private Task? _listenerTask;
+
+    public DiscordHealthCheckHostedService(
+        ILogger<DiscordHealthCheckHostedService> logger,
+        IConfiguration configuration)
+    {
+        _logger = logger;
+        _prefix = configuration.GetValue("HealthCheck:Prefix", "http://+:8082/")!;
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _cts = new CancellationTokenSource();
+        _listener = new HttpListener();
+        _listener.Prefixes.Add(_prefix);
+        _listener.Start();
+
+        _logger.LogInformation("Discord health check server started on {Prefix}", _prefix);
+
+        _listenerTask = Task.Run(async () => await ListenAsync(_cts.Token), cancellationToken);
+
+        return Task.CompletedTask;
+    }
+
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        _cts?.Cancel();
+        _listener?.Stop();
+
+        if (_listenerTask != null)
+        {
+            await Task.WhenAny(_listenerTask, Task.Delay(TimeSpan.FromSeconds(5), cancellationToken));
+        }
+
+        _listener?.Close();
+        _logger.LogInformation("Discord health check server stopped");
+    }
+
+    private async Task ListenAsync(CancellationToken cancellationToken)
+    {
+        while (_listener?.IsListening == true && !cancellationToken.IsCancellationRequested)
+        {
+            try
+            {
+                var context = await _listener.GetContextAsync();
+                _ = Task.Run(() => HandleRequestAsync(context), cancellationToken);
+            }
+            catch (HttpListenerException) when (cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (ObjectDisposedException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error in Discord health check listener");
+            }
+        }
+    }
+
+    private async Task HandleRequestAsync(HttpListenerContext context)
+    {
+        var response = context.Response;
+        try
+        {
+            var request = context.Request;
+
+            if (request.Url?.AbsolutePath == "/health")
+            {
+                response.StatusCode = (int)HttpStatusCode.OK;
+                response.ContentType = "application/json";
+                var body = "{\"status\":\"healthy\"}"u8.ToArray();
+                await response.OutputStream.WriteAsync(body);
+            }
+            else
+            {
+                response.StatusCode = (int)HttpStatusCode.NotFound;
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error handling Discord health check request");
+        }
+        finally
+        {
+            response.Close();
+        }
+    }
+}

src/GmRelay.DiscordBot/Program.cs

@@ -2,6 +2,7 @@ using GmRelay.DiscordBot;
 using GmRelay.DiscordBot.Features.Sessions;
 using GmRelay.DiscordBot.Infrastructure;
 using GmRelay.DiscordBot.Infrastructure.Discord;
+using GmRelay.DiscordBot.Infrastructure.Health;
 using GmRelay.DiscordBot.Infrastructure.Logging;
 using GmRelay.Shared.Features.Confirmation.HandleRsvp;
 using GmRelay.Shared.Features.Confirmation.SendConfirmation;
@@ -17,8 +18,10 @@ using Microsoft.Extensions.DependencyInjection;
 using NetCord;
 using NetCord.Gateway;
 using NetCord.Hosting.Gateway;
+using NetCord.Hosting.Services;
 using NetCord.Hosting.Services.ApplicationCommands;
 using NetCord.Hosting.Services.ComponentInteractions;
+using NetCord.Services.ApplicationCommands;
 using NetCord.Services.ComponentInteractions;
 using Npgsql;
 
@@ -33,6 +36,8 @@ discordOptions.Validate();
 
 builder.Services.AddSingleton(discordOptions);
 
+builder.Logging.AddConsole();
+
 builder.Services.AddSingleton<NpgsqlDataSource>(sp =>
 {
     var config = sp.GetRequiredService<IConfiguration>();
@@ -51,6 +56,7 @@ builder.Services.AddSingleton<NpgsqlDataSource>(sp =>
 
 builder.Services.AddSingleton<DiscordPermissionChecker>();
 builder.Services.AddSingleton<DiscordListSessionsHandler>();
+builder.Services.AddSingleton<DiscordDeleteSessionHandler>();
 builder.Services.AddSingleton<DiscordNewSessionHandler>();
 builder.Services.AddSingleton<DiscordRescheduleHandler>();
 builder.Services.AddSingleton<DiscordRescheduleVoteHandler>();
@@ -73,6 +79,7 @@ builder.Services.AddSingleton<HandleRsvpHandler>();
 builder.Services.AddSingleton<RescheduleVotingFinalizer>();
 builder.Services.AddHostedService<SessionSchedulerService>();
 builder.Services.AddHostedService<DiscordRescheduleVotingDeadlineService>();
+builder.Services.AddHostedService<DiscordHealthCheckHostedService>();
 
 builder.Services
     .AddDiscordGateway(options =>
@@ -80,12 +87,13 @@ builder.Services
         options.Token = discordOptions.Token;
         options.Intents = GatewayIntents.Guilds;
     })
-    .AddApplicationCommands()
+    .AddApplicationCommands<SlashCommandInteraction, SlashCommandContext>()
     .AddComponentInteractions<ButtonInteraction, ButtonInteractionContext>()
     .AddGatewayHandlers(typeof(Program).Assembly);
 
 var host = builder.Build();
 
 host.AddSlashCommand("ping", "Checks whether GM-Relay Discord is online.", () => "Pong!");
+host.AddModules(typeof(Program).Assembly);
 
 await host.RunAsync();

src/GmRelay.DiscordBot/Rendering/DiscordEmbedUrls.cs

@@ -0,0 +1,43 @@
+namespace GmRelay.DiscordBot.Rendering;
+
+public static class DiscordEmbedUrls
+{
+    public static string? NormalizeHttpUrl(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            return null;
+
+        var candidate = value.Trim();
+        if (IsSupportedHttpUrl(candidate, out var normalized))
+            return normalized;
+
+        if (candidate.Contains("://", StringComparison.Ordinal))
+            return null;
+
+        return IsSupportedHttpUrl($"https://{candidate}", out normalized)
+            && HasPublicHost(normalized)
+                ? normalized
+                : null;
+    }
+
+    private static bool IsSupportedHttpUrl(string value, out string normalized)
+    {
+        normalized = string.Empty;
+
+        if (!Uri.TryCreate(value, UriKind.Absolute, out var uri))
+            return false;
+
+        if (!string.Equals(uri.Scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase)
+            && !string.Equals(uri.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        normalized = uri.ToString();
+        return true;
+    }
+
+    private static bool HasPublicHost(string value) =>
+        Uri.TryCreate(value, UriKind.Absolute, out var uri)
+        && uri.Host.Contains('.', StringComparison.Ordinal);
+}

src/GmRelay.DiscordBot/Rendering/DiscordSessionBatchRenderer.cs

@@ -70,9 +70,10 @@ public static class DiscordSessionBatchRenderer
                 .WithInline()
         };
 
-        if (!string.IsNullOrEmpty(session.JoinLink))
+        var embedUrl = DiscordEmbedUrls.NormalizeHttpUrl(session.JoinLink);
+        if (embedUrl is not null)
         {
-            embed = embed.WithUrl(session.JoinLink);
+            embed = embed.WithUrl(embedUrl);
         }
 
         embed = embed.WithColor(GetColor(session));

src/GmRelay.DiscordBot/packages.lock.json

@@ -28,6 +28,12 @@
         "resolved": "2.1.72",
         "contentHash": "ns4mGqQd9a/MhP8m6w556vVlZIa0/MfUu03zrxjZC/jlr1uVCsUac8bkdB+Fs98Llbd56rRSo1eZH5VVmeGZyw=="
       },
+      "Dapper.AOT": {
+        "type": "Direct",
+        "requested": "[1.0.48, )",
+        "resolved": "1.0.48",
+        "contentHash": "rsLM3yKr4g+YKKox9lhc8D+kz67P7Q9+xdyn1LmCsoYr1kYpJSm+Nt6slo5UrfUrcTiGJ57zUlyO8XUdV7G7iA=="
+      },
       "Microsoft.Extensions.Hosting": {
         "type": "Direct",
         "requested": "[10.0.5, )",

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

@@ -56,8 +56,8 @@ public sealed class HandleRsvpHandler(
                 FROM session_participants sp
                 JOIN players p ON p.id = sp.player_id
                 WHERE sp.session_id = @SessionId
-                  AND COALESCE(p.platform, 'Telegram') = @Platform
-                  AND COALESCE(p.external_user_id, p.telegram_id::TEXT) = @ExternalUserId
+                  AND p.platform = @Platform
+                  AND p.external_user_id = @ExternalUserId
                   AND sp.is_gm = false
                   AND sp.registration_status = @Active
             )
@@ -90,8 +90,8 @@ public sealed class HandleRsvpHandler(
               AND  player_id = (
                     SELECT id
                     FROM players
-                    WHERE COALESCE(platform, 'Telegram') = @Platform
-                      AND COALESCE(external_user_id, telegram_id::TEXT) = @ExternalUserId
+                    WHERE platform = @Platform
+                      AND external_user_id = @ExternalUserId
                     LIMIT 1
               )
               AND  registration_status = @Active
@@ -265,10 +265,10 @@ public sealed class HandleRsvpHandler(
 
             var participants = (await connection.QueryAsync<ParticipantRsvpRow>(
                 """
-                SELECT COALESCE(p.platform, 'Telegram') AS Platform,
-                       COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
+                SELECT p.platform AS Platform,
+                       p.external_user_id AS ExternalUserId,
                        p.display_name AS DisplayName,
-                       COALESCE(p.external_username, p.telegram_username) AS ExternalUsername,
+                       p.external_username AS ExternalUsername,
                        sp.rsvp_status AS RsvpStatus,
                        sp.registration_status AS RegistrationStatus,
                        sp.is_gm AS IsGm
@@ -312,23 +312,13 @@ public sealed class HandleRsvpHandler(
         var rows = await connection.QueryAsync<RsvpRecipientRow>(
             """
             SELECT DISTINCT
-                   COALESCE(p.platform, 'Telegram') AS Platform,
-                   COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
+                   p.platform AS Platform,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   COALESCE(p.external_username, p.telegram_username) AS ExternalUsername
+                   p.external_username AS ExternalUsername
             FROM group_managers gm
             JOIN players p ON p.id = gm.player_id
             WHERE gm.group_id = @GroupId
-            UNION
-            SELECT DISTINCT
-                   COALESCE(p.platform, 'Telegram') AS Platform,
-                   COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
-                   p.display_name AS DisplayName,
-                   COALESCE(p.external_username, p.telegram_username) AS ExternalUsername
-            FROM game_groups g
-            JOIN players p ON p.telegram_id = g.gm_telegram_id
-            WHERE g.id = @GroupId
-              AND g.gm_telegram_id IS NOT NULL
             """,
             new { GroupId = groupId },
             transaction);

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

@@ -45,10 +45,10 @@ public sealed class SendConfirmationHandler(
                    s.title,
                    s.scheduled_at AS ScheduledAt,
                    s.group_id AS GroupId,
-                   COALESCE(g.platform, 'Telegram') AS Platform,
-                   COALESCE(g.external_group_id, g.telegram_chat_id::TEXT) AS ExternalGroupId,
+                   g.platform AS Platform,
+                   g.external_group_id AS ExternalGroupId,
                    g.name AS DisplayName,
-                   COALESCE(g.external_channel_id, g.telegram_chat_id::TEXT) AS ExternalChannelId,
+                   g.external_channel_id AS ExternalChannelId,
                    s.thread_id AS ThreadId,
                    s.notification_mode AS NotificationMode
             FROM sessions s
@@ -65,10 +65,10 @@ public sealed class SendConfirmationHandler(
 
         var participants = (await connection.QueryAsync<ConfirmationParticipantRow>(
             """
-            SELECT COALESCE(p.platform, 'Telegram') AS Platform,
-                   COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
+            SELECT p.platform AS Platform,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   COALESCE(p.external_username, p.telegram_username) AS ExternalUsername,
+                   p.external_username AS ExternalUsername,
                    sp.rsvp_status AS RsvpStatus,
                    sp.registration_status AS RegistrationStatus,
                    sp.is_gm AS IsGm

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

@@ -47,10 +47,10 @@ public sealed class SendJoinLinkHandler(
                    s.title,
                    s.join_link AS JoinLink,
                    s.scheduled_at AS ScheduledAt,
-                   COALESCE(g.platform, 'Telegram') AS Platform,
-                   COALESCE(g.external_group_id, g.telegram_chat_id::TEXT) AS ExternalGroupId,
+                   g.platform AS Platform,
+                   g.external_group_id AS ExternalGroupId,
                    g.name AS DisplayName,
-                   COALESCE(g.external_channel_id, g.telegram_chat_id::TEXT) AS ExternalChannelId,
+                   g.external_channel_id AS ExternalChannelId,
                    s.thread_id AS ThreadId,
                    s.notification_mode AS NotificationMode
             FROM sessions s
@@ -58,14 +58,14 @@ public sealed class SendJoinLinkHandler(
             WHERE s.id = @SessionId
               AND s.status = @Confirmed
               AND (
-                    (COALESCE(g.platform, 'Telegram') = 'Telegram' AND s.link_message_id IS NULL)
+                    (g.platform = 'Telegram' AND s.link_message_id IS NULL)
                     OR (
-                        COALESCE(g.platform, 'Telegram') <> 'Telegram'
+                        g.platform <> 'Telegram'
                         AND NOT EXISTS (
                             SELECT 1
                             FROM platform_messages pm
                             WHERE pm.session_id = s.id
-                              AND pm.platform = COALESCE(g.platform, 'Telegram')
+                              AND pm.platform = g.platform
                               AND pm.purpose = 'join_link'
                         )
                     )
@@ -81,10 +81,10 @@ public sealed class SendJoinLinkHandler(
 
         var players = (await connection.QueryAsync<JoinLinkPlayerRow>(
             """
-            SELECT COALESCE(p.platform, 'Telegram') AS Platform,
-                   COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
+            SELECT p.platform AS Platform,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   COALESCE(p.external_username, p.telegram_username) AS ExternalUsername,
+                   p.external_username AS ExternalUsername,
                    sp.rsvp_status AS RsvpStatus,
                    sp.registration_status AS RegistrationStatus,
                    sp.is_gm AS IsGm

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

@@ -56,10 +56,10 @@ public sealed class SendOneHourReminderHandler(
 
         var recipients = (await connection.QueryAsync<OneHourReminderRecipientRow>(
             """
-            SELECT COALESCE(p.platform, 'Telegram') AS Platform,
-                   COALESCE(p.external_user_id, p.telegram_id::TEXT) AS ExternalUserId,
+            SELECT p.platform AS Platform,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   COALESCE(p.external_username, p.telegram_username) AS ExternalUsername
+                   p.external_username AS ExternalUsername
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId

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

@@ -13,7 +13,12 @@ public sealed record JoinSessionCommand(
     PlatformUser User,
     string InteractionId,
     PlatformGroup Group,
-    PlatformMessageRef ScheduleMessage);
+    PlatformMessageRef ScheduleMessage,
+    bool DeferScheduleUpdate = false);
+
+public sealed record SessionInteractionResult(
+    string ReplyText,
+    SessionBatchViewModel? UpdatedView = null);
 
 // DTOs for AOT compilation
 internal sealed record JoinSessionBatchDto(Guid BatchId, string Title, string Status, int? MaxPlayers);
@@ -24,7 +29,7 @@ public sealed class JoinSessionHandler(
     IScheduleMessageUpdateLock scheduleUpdateLock,
     ILogger<JoinSessionHandler> logger)
 {
-    public async Task HandleAsync(JoinSessionCommand command, CancellationToken ct)
+    public async Task<SessionInteractionResult> HandleAsync(JoinSessionCommand command, CancellationToken ct)
     {
         await using var updateLock = await scheduleUpdateLock.AcquireAsync(command.ScheduleMessage, ct);
         await using var connection = await dataSource.OpenConnectionAsync(ct);
@@ -35,30 +40,19 @@ public sealed class JoinSessionHandler(
         {
             // 1. Убеждаемся, что игрок есть в базе
             var platform = command.User.Platform.ToString();
-            var legacyTelegramId = command.User.Platform == PlatformKind.Telegram
-                ? long.Parse(command.User.ExternalUserId, CultureInfo.InvariantCulture)
-                : (long?)null;
-            var legacyTelegramUsername = command.User.Platform == PlatformKind.Telegram
-                ? command.User.ExternalUsername
-                : null;
 
             var playerId = await connection.ExecuteScalarAsync<Guid>(
-                @"INSERT INTO players (telegram_id, display_name, telegram_username, platform, external_user_id, external_username)
-                  VALUES (@LegacyTelegramId, @Name, @LegacyTelegramUsername, @Platform, @ExternalUserId, @ExternalUsername)
+                @"INSERT INTO players (display_name, platform, external_user_id, external_username)
+                  VALUES (@Name, @Platform, @ExternalUserId, @ExternalUsername)
                   ON CONFLICT (platform, external_user_id)
                   WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
                   DO UPDATE
                   SET display_name = EXCLUDED.display_name,
-                      telegram_username = COALESCE(EXCLUDED.telegram_username, players.telegram_username),
-                      platform = EXCLUDED.platform,
-                      external_user_id = EXCLUDED.external_user_id,
                       external_username = EXCLUDED.external_username
                   RETURNING id;",
                 new
                 {
-                    LegacyTelegramId = legacyTelegramId,
                     Name = command.User.DisplayName,
-                    LegacyTelegramUsername = legacyTelegramUsername,
                     Platform = platform,
                     command.User.ExternalUserId,
                     command.User.ExternalUsername
@@ -77,15 +71,13 @@ public sealed class JoinSessionHandler(
             if (batchInfo is null)
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Сессия не найдена.", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Сессия не найдена.", ct);
             }
 
             if (SessionStatus.IsCancelled(batchInfo.Status))
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Сессия уже отменена.", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Сессия уже отменена.", ct);
             }
 
             var existingRegistrationStatus = await connection.ExecuteScalarAsync<string?>(
@@ -105,8 +97,7 @@ public sealed class JoinSessionHandler(
                 var alreadyText = existingRegistrationStatus == ParticipantRegistrationStatus.Waitlisted
                     ? "Вы уже в листе ожидания!"
                     : "Вы уже записаны!";
-                await AnswerAsync(command.InteractionId, alreadyText, ct);
-                return;
+                return await AnswerAsync(command.InteractionId, alreadyText, ct);
             }
 
             var activeParticipants = await connection.ExecuteScalarAsync<int>(
@@ -139,8 +130,7 @@ public sealed class JoinSessionHandler(
             if (inserted == 0)
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Вы уже записаны!", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Вы уже записаны!", ct);
             }
 
             // Загружаем весь батч для перерисовки
@@ -154,7 +144,7 @@ public sealed class JoinSessionHandler(
             var batchParticipants = await connection.QueryAsync<ParticipantBatchDto>(
                 @"SELECT sp.session_id as SessionId,
                          p.display_name as DisplayName,
-                         COALESCE(p.external_username, p.telegram_username) as TelegramUsername,
+                         p.external_username as TelegramUsername,
                          sp.registration_status as RegistrationStatus
                   FROM session_participants sp
                   JOIN players p ON sp.player_id = p.id
@@ -168,17 +158,20 @@ public sealed class JoinSessionHandler(
 
             // 4. Перерисовываем сообщение
             var view = SessionBatchViewBuilder.Build(batchInfo.Title, batchSessions.ToList(), batchParticipants.ToList());
-            await messenger.UpdateScheduleAsync(
-                new PlatformScheduleMessage(
-                    command.Group,
-                    view,
-                    command.ScheduleMessage),
-                ct);
+            if (!command.DeferScheduleUpdate)
+            {
+                await messenger.UpdateScheduleAsync(
+                    new PlatformScheduleMessage(
+                        command.Group,
+                        view,
+                        command.ScheduleMessage),
+                    ct);
+            }
 
             var callbackText = registrationStatus == ParticipantRegistrationStatus.Waitlisted
                 ? "Основной состав заполнен. Вы добавлены в лист ожидания."
                 : "Вы успешно записаны!";
-            await AnswerAsync(command.InteractionId, callbackText, ct);
+            return await AnswerAsync(command.InteractionId, callbackText, ct, view);
         }
         catch (Exception ex)
         {
@@ -191,10 +184,17 @@ public sealed class JoinSessionHandler(
             var errorText = transactionCommitted
                 ? "Регистрация сохранена, но не удалось обновить сообщение расписания."
                 : "Произошла ошибка при регистрации.";
-            await AnswerAsync(command.InteractionId, errorText, ct);
+            return await AnswerAsync(command.InteractionId, errorText, ct);
         }
     }
 
-    private Task AnswerAsync(string interactionId, string text, CancellationToken ct) =>
-        messenger.AnswerInteractionAsync(new PlatformInteractionReply(interactionId, text), ct);
+    private async Task<SessionInteractionResult> AnswerAsync(
+        string interactionId,
+        string text,
+        CancellationToken ct,
+        SessionBatchViewModel? updatedView = null)
+    {
+        await messenger.AnswerInteractionAsync(new PlatformInteractionReply(interactionId, text), ct);
+        return new SessionInteractionResult(text, updatedView);
+    }
 }

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

@@ -12,7 +12,8 @@ public sealed record LeaveSessionCommand(
     PlatformUser User,
     string InteractionId,
     PlatformGroup Group,
-    PlatformMessageRef ScheduleMessage);
+    PlatformMessageRef ScheduleMessage,
+    bool DeferScheduleUpdate = false);
 
 internal sealed record LeaveSessionInfoDto(string Title, Guid BatchId, string Status, int? MaxPlayers);
 internal sealed record LeaveSessionParticipantDto(Guid ParticipantRowId, string DisplayName, string RegistrationStatus);
@@ -24,7 +25,7 @@ public sealed class LeaveSessionHandler(
     IScheduleMessageUpdateLock scheduleUpdateLock,
     ILogger<LeaveSessionHandler> logger)
 {
-    public async Task HandleAsync(LeaveSessionCommand command, CancellationToken ct)
+    public async Task<SessionInteractionResult> HandleAsync(LeaveSessionCommand command, CancellationToken ct)
     {
         await using var updateLock = await scheduleUpdateLock.AcquireAsync(command.ScheduleMessage, ct);
         await using var connection = await dataSource.OpenConnectionAsync(ct);
@@ -49,15 +50,13 @@ public sealed class LeaveSessionHandler(
             if (session is null)
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Сессия не найдена.", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Сессия не найдена.", ct);
             }
 
             if (SessionStatus.IsCancelled(session.Status))
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Сессия уже отменена.", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Сессия уже отменена.", ct);
             }
 
             var platform = command.User.Platform.ToString();
@@ -81,8 +80,7 @@ public sealed class LeaveSessionHandler(
             if (participant is null)
             {
                 await transaction.RollbackAsync(ct);
-                await AnswerAsync(command.InteractionId, "Вы не записаны на эту сессию.", ct);
-                return;
+                return await AnswerAsync(command.InteractionId, "Вы не записаны на эту сессию.", ct);
             }
 
             await connection.ExecuteAsync(
@@ -175,7 +173,7 @@ public sealed class LeaveSessionHandler(
                 """
                 SELECT sp.session_id AS SessionId,
                        p.display_name AS DisplayName,
-                       COALESCE(p.external_username, p.telegram_username) AS TelegramUsername,
+                       p.external_username AS TelegramUsername,
                        sp.registration_status AS RegistrationStatus
                 FROM session_participants sp
                 JOIN players p ON sp.player_id = p.id
@@ -190,12 +188,15 @@ public sealed class LeaveSessionHandler(
             transactionCommitted = true;
 
             var view = SessionBatchViewBuilder.Build(session.Title, batchSessions, batchParticipants);
-            await messenger.UpdateScheduleAsync(
-                new PlatformScheduleMessage(
-                    command.Group,
-                    view,
-                    command.ScheduleMessage),
-                ct);
+            if (!command.DeferScheduleUpdate)
+            {
+                await messenger.UpdateScheduleAsync(
+                    new PlatformScheduleMessage(
+                        command.Group,
+                        view,
+                        command.ScheduleMessage),
+                    ct);
+            }
 
             var callbackText = participant.RegistrationStatus == ParticipantRegistrationStatus.Waitlisted
                 ? "Вы удалены из листа ожидания."
@@ -203,7 +204,7 @@ public sealed class LeaveSessionHandler(
                     ? "Вы отписались от сессии."
                     : $"Вы отписались от сессии. Место получил(а) {promotedDisplayName}.";
 
-            await AnswerAsync(command.InteractionId, callbackText, ct);
+            return await AnswerAsync(command.InteractionId, callbackText, ct, view);
         }
         catch (Exception ex)
         {
@@ -216,10 +217,17 @@ public sealed class LeaveSessionHandler(
             var errorText = transactionCommitted
                 ? "Запись снята, но не удалось обновить сообщение расписания."
                 : "Произошла ошибка при отмене записи.";
-            await AnswerAsync(command.InteractionId, errorText, ct);
+            return await AnswerAsync(command.InteractionId, errorText, ct);
         }
     }
 
-    private Task AnswerAsync(string interactionId, string text, CancellationToken ct) =>
-        messenger.AnswerInteractionAsync(new PlatformInteractionReply(interactionId, text), ct);
+    private async Task<SessionInteractionResult> AnswerAsync(
+        string interactionId,
+        string text,
+        CancellationToken ct,
+        SessionBatchViewModel? updatedView = null)
+    {
+        await messenger.AnswerInteractionAsync(new PlatformInteractionReply(interactionId, text), ct);
+        return new SessionInteractionResult(text, updatedView);
+    }
 }

src/GmRelay.Shared/Features/Sessions/RescheduleSession/RescheduleVotingFinalizer.cs

@@ -78,8 +78,8 @@ public sealed class RescheduleVotingFinalizer(
             """
             SELECT p.id AS PlayerId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
-                   p.telegram_id AS TelegramId
+                   p.external_username AS TelegramUsername,
+                   p.external_user_id::BIGINT AS TelegramId
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
             WHERE sp.session_id = @SessionId
@@ -107,7 +107,7 @@ public sealed class RescheduleVotingFinalizer(
             SELECT rov.option_id AS OptionId,
                    p.id AS PlayerId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername
+                   p.external_username AS TelegramUsername
             FROM reschedule_option_votes rov
             JOIN players p ON p.id = rov.player_id
             WHERE rov.proposal_id = @ProposalId

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

@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using GmRelay.Shared.Features.Confirmation.SendConfirmation;
 using GmRelay.Shared.Features.Reminders.SendJoinLink;
 using GmRelay.Shared.Features.Reminders.SendOneHourReminder;
@@ -20,6 +21,11 @@ public sealed class SessionSchedulerService(
     ILogger<SessionSchedulerService> logger) : BackgroundService
 {
     private static readonly TimeSpan TickInterval = TimeSpan.FromMinutes(1);
+    private static readonly TimeSpan BackoffDuration = TimeSpan.FromMinutes(15);
+
+    private readonly ConcurrentDictionary<Guid, DateTimeOffset> _confirmationBackoff = new();
+    private readonly ConcurrentDictionary<Guid, DateTimeOffset> _oneHourBackoff = new();
+    private readonly ConcurrentDictionary<Guid, DateTimeOffset> _joinLinkBackoff = new();
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
@@ -71,14 +77,30 @@ public sealed class SessionSchedulerService(
 
         foreach (var sessionId in sessionIds)
         {
+            if (_confirmationBackoff.TryGetValue(sessionId, out var backoffUntil) && backoffUntil > now)
+            {
+                logger.LogDebug(
+                    "Skipping confirmation for session {SessionId} until {Backoff}",
+                    sessionId,
+                    backoffUntil);
+                continue;
+            }
+
             try
             {
                 await confirmationHandler.HandleAsync(sessionId, ct);
+                _confirmationBackoff.TryRemove(sessionId, out _);
                 logger.LogInformation("Confirmation sent for session {SessionId}", sessionId);
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Failed to send confirmation for session {SessionId}", sessionId);
+                var nextAttempt = now.Add(BackoffDuration);
+                _confirmationBackoff[sessionId] = nextAttempt;
+                logger.LogError(
+                    ex,
+                    "Failed to send confirmation for session {SessionId}, backing off until {Backoff}",
+                    sessionId,
+                    nextAttempt);
             }
         }
     }
@@ -98,14 +120,30 @@ public sealed class SessionSchedulerService(
 
         foreach (var sessionId in sessionIds)
         {
+            if (_oneHourBackoff.TryGetValue(sessionId, out var backoffUntil) && backoffUntil > now)
+            {
+                logger.LogDebug(
+                    "Skipping one-hour reminder for session {SessionId} until {Backoff}",
+                    sessionId,
+                    backoffUntil);
+                continue;
+            }
+
             try
             {
                 await oneHourReminderHandler.HandleAsync(sessionId, ct);
+                _oneHourBackoff.TryRemove(sessionId, out _);
                 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);
+                var nextAttempt = now.Add(BackoffDuration);
+                _oneHourBackoff[sessionId] = nextAttempt;
+                logger.LogError(
+                    ex,
+                    "Failed to process one-hour reminder for session {SessionId}, backing off until {Backoff}",
+                    sessionId,
+                    nextAttempt);
             }
         }
     }
@@ -125,14 +163,30 @@ public sealed class SessionSchedulerService(
 
         foreach (var sessionId in sessionIds)
         {
+            if (_joinLinkBackoff.TryGetValue(sessionId, out var backoffUntil) && backoffUntil > now)
+            {
+                logger.LogDebug(
+                    "Skipping join link for session {SessionId} until {Backoff}",
+                    sessionId,
+                    backoffUntil);
+                continue;
+            }
+
             try
             {
                 await joinLinkHandler.HandleAsync(sessionId, ct);
+                _joinLinkBackoff.TryRemove(sessionId, out _);
                 logger.LogInformation("Join link sent for session {SessionId}", sessionId);
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Failed to send join link for session {SessionId}", sessionId);
+                var nextAttempt = now.Add(BackoffDuration);
+                _joinLinkBackoff[sessionId] = nextAttempt;
+                logger.LogError(
+                    ex,
+                    "Failed to send join link for session {SessionId}, backing off until {Backoff}",
+                    sessionId,
+                    nextAttempt);
             }
         }
     }

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

@@ -34,14 +34,31 @@
                     </svg>
                     Шаблоны
                 </NavLink>
+                <NavLink class="nav-item" href="profile" @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="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/>
+                        <circle cx="12" cy="7" r="4"/>
+                    </svg>
+                    Профиль
+                </NavLink>
             </div>
 
             <div class="nav-footer">
                 <div class="nav-user">
                     <div class="nav-user-avatar">
-                        @(context.User.Identity?.Name?.Substring(0, 1).ToUpper() ?? "?")
+                        @if (!string.IsNullOrWhiteSpace(context.User.GetAvatarUrl()))
+                        {
+                            <img src="@context.User.GetAvatarUrl()" alt="" />
+                        }
+                        else
+                        {
+                            @(context.User.Identity?.Name?.Substring(0, 1).ToUpper() ?? "?")
+                        }
+                    </div>
+                    <div class="nav-user-info">
+                        <span class="nav-user-name">@context.User.Identity?.Name</span>
+                        <span class="nav-user-platform">@GetPlatformLabel(context.User)</span>
                     </div>
-                    <span class="nav-user-name">@context.User.Identity?.Name</span>
                 </div>
 
                 <form action="/auth/logout" method="post">
@@ -56,7 +73,7 @@
                     </button>
                 </form>
 
-                <div class="nav-version">v2.7.0</div>
+                <div class="nav-version">v3.1.1</div>
             </div>
         </Authorized>
         <NotAuthorized>
@@ -79,4 +96,7 @@
 
     private void ToggleMenu() => isOpen = !isOpen;
     private void CloseMenu() => isOpen = false;
+
+    private static string GetPlatformLabel(System.Security.Claims.ClaimsPrincipal user) =>
+        user.TryGetDiscordId(out _) ? "Discord" : "Telegram";
 }

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

@@ -185,7 +185,7 @@
     private Guid selectedGroupId;
     private Guid? deletingTemplateId;
     private bool isCreatingTemplate;
-    private long telegramId;
+    private string? externalUserId;
     private string? errorMessage;
     private string? successMessage;
     private CampaignTemplateEditModel templateModel = new();
@@ -195,13 +195,13 @@
     protected override async Task OnInitializedAsync()
     {
         var authState = await AuthStateProvider.GetAuthenticationStateAsync();
-        if (!authState.User.TryGetTelegramId(out telegramId))
+        if (!authState.User.TryGetPlatformIdentity(out var platform, out externalUserId))
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        groups = await SessionService.GetGroupsForGmAsync(telegramId);
+        groups = await SessionService.GetGroupsForCurrentUserAsync();
         selectedGroupId = groups.FirstOrDefault()?.Id ?? Guid.Empty;
 
         if (selectedGroupId != Guid.Empty)
@@ -228,7 +228,7 @@
         campaignTemplates = null;
         campaignTemplateModels = [];
 
-        var templates = await SessionService.GetCampaignTemplatesForGmAsync(selectedGroupId, telegramId);
+        var templates = await SessionService.GetCampaignTemplatesForCurrentUserAsync(selectedGroupId);
         if (templates is null)
         {
             Navigation.NavigateTo("/access-denied");
@@ -260,9 +260,8 @@
 
         try
         {
-            await SessionService.CreateCampaignTemplateForGmAsync(
+            await SessionService.CreateCampaignTemplateForCurrentUserAsync(
                 selectedGroupId,
-                telegramId,
                 new CreateCampaignTemplateRequest(
                     templateModel.Name,
                     templateModel.Title,
@@ -298,7 +297,7 @@
 
         try
         {
-            await SessionService.DeleteCampaignTemplateForGmAsync(template.Id, telegramId);
+            await SessionService.DeleteCampaignTemplateForCurrentUserAsync(template.Id);
             successMessage = "Шаблон кампании удалён.";
             await LoadTemplates();
         }

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

@@ -87,13 +87,13 @@
     protected override async Task OnInitializedAsync()
     {
         var authState = await AuthStateProvider.GetAuthenticationStateAsync();
-        if (!authState.User.TryGetTelegramId(out var telegramId))
+        if (!authState.User.TryGetPlatformIdentity(out var platform, out var externalUserId))
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        session = await SessionService.GetSessionForGmAsync(SessionId, telegramId);
+        session = await SessionService.GetSessionForCurrentUserAsync(SessionId);
         if (session is null)
         {
             Navigation.NavigateTo("/access-denied");
@@ -114,7 +114,7 @@
         try
         {
             var authState = await AuthStateProvider.GetAuthenticationStateAsync();
-            if (!authState.User.TryGetTelegramId(out var telegramId))
+            if (!authState.User.TryGetPlatformIdentity(out var platform, out var externalUserId))
             {
                 Navigation.NavigateTo("/access-denied");
                 return;
@@ -122,7 +122,7 @@
 
             var utcTime = new DateTimeOffset(model.ScheduledAtLocal, TimeSpan.FromHours(3)).ToUniversalTime().UtcDateTime;
 
-            await SessionService.UpdateSessionForGmAsync(SessionId, telegramId, model.Title, utcTime, model.JoinLink, model.MaxPlayers);
+            await SessionService.UpdateSessionForCurrentUserAsync(SessionId, model.Title, utcTime, model.JoinLink, model.MaxPlayers);
             Navigation.NavigateTo($"/group/{session!.GroupId}");
         }
         catch (SessionAccessDeniedException)

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

@@ -40,8 +40,8 @@
                     </span>
                     @if (groupManagement.CurrentUserIsOwner && manager.Role == GroupManagerRoleExtensions.CoGmValue)
                     {
-                        <button type="button" class="btn-gm btn-gm-outline" style="font-size: 0.75rem; padding: 0.25rem 0.5rem;" disabled="@(removingCoGmId == manager.TelegramId)" @onclick="() => RemoveCoGm(manager.TelegramId)">
-                            @(removingCoGmId == manager.TelegramId ? "⏳ Удаляем..." : "Убрать")
+                        <button type="button" class="btn-gm btn-gm-outline" style="font-size: 0.75rem; padding: 0.25rem 0.5rem;" disabled="@(removingCoGmId == manager.ExternalUserId)" @onclick="() => RemoveCoGm(manager.ExternalUserId ?? manager.TelegramId.ToString())">
+                            @(removingCoGmId == manager.ExternalUserId ? "⏳ Удаляем..." : "Убрать")
                         </button>
                     }
                 }
@@ -403,9 +403,9 @@
     private Guid? promotingSessionId;
     private Guid? processingBatchId;
     private Guid? processingTemplateId;
-    private long? removingCoGmId;
+    private string? removingCoGmId;
     private bool isAddingCoGm;
-    private long telegramId;
+    private string? externalUserId;
     private string? errorMessage;
     private string? successMessage;
     private CoGmEditModel coGmModel = new();
@@ -417,7 +417,7 @@
     protected override async Task OnInitializedAsync()
     {
         var authState = await AuthStateProvider.GetAuthenticationStateAsync();
-        if (!authState.User.TryGetTelegramId(out telegramId))
+        if (!authState.User.TryGetPlatformIdentity(out var platform, out externalUserId))
         {
             Navigation.NavigateTo("/access-denied");
             return;
@@ -428,21 +428,21 @@
 
     private async Task LoadSessions()
     {
-        groupManagement = await SessionService.GetGroupManagementForGmAsync(GroupId, telegramId);
+        groupManagement = await SessionService.GetGroupManagementForCurrentUserAsync(GroupId);
         if (groupManagement is null)
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        sessions = await SessionService.GetUpcomingSessionsForGmAsync(GroupId, telegramId);
+        sessions = await SessionService.GetUpcomingSessionsForCurrentUserAsync(GroupId);
         if (sessions is null)
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        campaignTemplates = await SessionService.GetCampaignTemplatesForGmAsync(GroupId, telegramId);
+        campaignTemplates = await SessionService.GetCampaignTemplatesForCurrentUserAsync(GroupId);
         if (campaignTemplates is null)
         {
             Navigation.NavigateTo("/access-denied");
@@ -470,8 +470,8 @@
         {
             await SessionService.AddCoGmForOwnerAsync(
                 GroupId,
-                telegramId,
-                coGmModel.TelegramId.Value,
+                "Telegram",
+                coGmModel.TelegramId.Value.ToString(),
                 coGmModel.DisplayName,
                 coGmModel.TelegramUsername);
 
@@ -493,15 +493,15 @@
         }
     }
 
-    private async Task RemoveCoGm(long coGmTelegramId)
+    private async Task RemoveCoGm(string coGmExternalUserId)
     {
         errorMessage = null;
         successMessage = null;
-        removingCoGmId = coGmTelegramId;
+        removingCoGmId = coGmExternalUserId;
 
         try
         {
-            await SessionService.RemoveCoGmForOwnerAsync(GroupId, telegramId, coGmTelegramId);
+            await SessionService.RemoveCoGmForOwnerAsync(GroupId, "Telegram", coGmExternalUserId);
             successMessage = "Co-GM удалён.";
             await LoadSessions();
         }
@@ -527,7 +527,7 @@
 
         try
         {
-            await SessionService.PromoteWaitlistedPlayerForGmAsync(sessionId, telegramId);
+            await SessionService.PromoteWaitlistedPlayerForCurrentUserAsync(sessionId);
             await LoadSessions();
         }
         catch (SessionAccessDeniedException)
@@ -559,7 +559,7 @@
             loadingParticipantsSessionId = sessionId;
             try
             {
-                var participants = await SessionService.GetSessionParticipantsForGmAsync(sessionId, telegramId);
+                var participants = await SessionService.GetSessionParticipantsForCurrentUserAsync(sessionId);
                 participantsCache[sessionId] = participants ?? [];
             }
             catch (Exception ex)
@@ -582,7 +582,7 @@
 
         try
         {
-            await SessionService.RemovePlayerFromSessionForGmAsync(sessionId, telegramId, participantId);
+            await SessionService.RemovePlayerFromSessionForCurrentUserAsync(sessionId, participantId);
             participantsCache.Remove(sessionId);
             successMessage = "Игрок исключён.";
             await LoadSessions();
@@ -658,10 +658,9 @@
 
         try
         {
-            await SessionService.UpdateBatchDetailsForGmAsync(batch.BatchId, telegramId, batch.Title, batch.JoinLink);
-            await SessionService.UpdateBatchNotificationModeForGmAsync(
+            await SessionService.UpdateBatchDetailsForCurrentUserAsync(batch.BatchId, batch.Title, batch.JoinLink);
+            await SessionService.UpdateBatchNotificationModeForCurrentUserAsync(
                 batch.BatchId,
-                telegramId,
                 SessionNotificationModeExtensions.FromDatabaseValue(batch.NotificationMode));
             successMessage = "Настройки batch обновлены.";
             await LoadSessions();
@@ -696,7 +695,7 @@
         try
         {
             var utcTime = new DateTimeOffset(batch.FirstScheduledAtLocal, TimeSpan.FromHours(3)).ToUniversalTime().UtcDateTime;
-            await SessionService.RescheduleBatchForGmAsync(batch.BatchId, telegramId, utcTime, batch.IntervalDays);
+            await SessionService.RescheduleBatchForCurrentUserAsync(batch.BatchId, utcTime, batch.IntervalDays);
             successMessage = "Расписание пачки обновлено.";
             await LoadSessions();
         }
@@ -726,7 +725,7 @@
                 ? BatchCloneInterval.NextMonth
                 : BatchCloneInterval.NextWeek;
 
-            var clonedBatch = await SessionService.CloneBatchForGmAsync(batch.BatchId, telegramId, interval);
+            var clonedBatch = await SessionService.CloneBatchForCurrentUserAsync(batch.BatchId, interval);
             successMessage = $"Пачка склонирована: {clonedBatch.SessionCount} игр.";
             await LoadSessions();
         }
@@ -759,7 +758,7 @@
                 return;
             }
 
-            var createdBatch = await SessionService.CreateBatchFromCampaignTemplateForGmAsync(template.Id, telegramId, utcTime);
+            var createdBatch = await SessionService.CreateBatchFromCampaignTemplateForCurrentUserAsync(template.Id, utcTime);
             successMessage = $"Batch создан из шаблона: {createdBatch.SessionCount} игр.";
             await LoadSessions();
         }
@@ -836,7 +835,7 @@
     private bool IsTemplateBusy(CampaignTemplateUsageModel template) => processingTemplateId == template.Id;
 
     private string CurrentUserRole =>
-        groupManagement?.Managers.FirstOrDefault(manager => manager.TelegramId == telegramId)?.Role
+        groupManagement?.Managers.FirstOrDefault(manager => manager.ExternalUserId == externalUserId)?.Role
         ?? GroupManagerRoleExtensions.CoGmValue;
 
     private static string FormatRole(string role) =>

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

@@ -5,7 +5,7 @@
 @using Microsoft.AspNetCore.Components.Authorization
 @using System.Security.Claims
 @attribute [Authorize]
-@inject ISessionStore SessionStore
+@inject AuthorizedSessionService SessionService
 @inject AuthenticationStateProvider AuthStateProvider
 @inject NavigationManager Navigation
 
@@ -85,9 +85,9 @@
                                 <td>
                                     <div class="player-info">
                                         <span class="player-name">@s.DisplayName</span>
-                                        @if (!string.IsNullOrEmpty(s.TelegramUsername))
+                                        @if (!string.IsNullOrEmpty(s.ExternalUsername))
                                         {
-                                            <span class="player-username">@@@s.TelegramUsername</span>
+                                            <span class="player-username">@@@s.ExternalUsername</span>
                                         }
                                     </div>
                                 </td>
@@ -171,21 +171,20 @@
             Navigation.NavigateTo("/login");
             return;
         }
-        var telegramIdClaim = user.FindFirst("telegram_id")?.Value
-            ?? user.FindFirst(ClaimTypes.NameIdentifier)?.Value;
-        if (!long.TryParse(telegramIdClaim, out var telegramId))
+        if (!user.TryGetPlatformIdentity(out var platform, out var externalUserId))
         {
             Navigation.NavigateTo("/login");
             return;
         }
         try
         {
-            if (!await SessionStore.IsGroupManagerAsync(GroupId, telegramId))
+            var groupManagement = await SessionService.GetGroupManagementForCurrentUserAsync(GroupId);
+            if (groupManagement is null)
             {
                 Navigation.NavigateTo("/access-denied");
                 return;
             }
-            stats = await SessionStore.GetGroupAttendanceStatsAsync(GroupId) ?? new();
+            stats = await SessionService.GetGroupAttendanceStatsForCurrentUserAsync(GroupId) ?? new();
             UpdateSortedStats();
         }
         catch (Exception ex)

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

@@ -43,10 +43,15 @@
                 <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>
+                    <p class="group-card-id">ID: @(group.Platform == "Discord" ? group.ExternalGroupId : group.TelegramChatId.ToString())</p>
+                    <div class="group-card-meta">
+                        <span class="status-badge platform-badge">
+                            @FormatPlatform(group.Platform)
+                        </span>
+                        <span class="status-badge @(group.ManagerRole == GroupManagerRoleExtensions.OwnerValue ? "status-success" : "status-info")">
+                            @FormatRole(group.ManagerRole)
+                        </span>
+                    </div>
                     <a href="/group/@group.Id" class="btn-gm btn-gm-primary" style="width: 100%; justify-content: center; margin-top: auto;">
                         Посмотреть игры →
                     </a>
@@ -81,6 +86,20 @@
         font-family: 'Courier New', monospace;
         margin-bottom: 1rem;
     }
+
+    .group-card-meta {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.5rem;
+        align-items: center;
+        margin-bottom: 1rem;
+    }
+
+    .platform-badge {
+        background: rgba(88, 101, 242, 0.15);
+        color: #9ea8ff;
+        border-color: rgba(88, 101, 242, 0.35);
+    }
 </style>
 
 @code {
@@ -93,15 +112,18 @@
         var user = authState.User;
         userName = user.Identity?.Name ?? "Мастер Игры";
 
-        if (!user.TryGetTelegramId(out var telegramId))
+        if (!user.TryGetPlatformIdentity(out _, out _))
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        groups = await SessionService.GetGroupsForGmAsync(telegramId);
+        groups = await SessionService.GetGroupsForCurrentUserAsync();
     }
 
     private static string FormatRole(string role) =>
         GroupManagerRoleExtensions.FromDatabaseValue(role).ToDisplayName();
+
+    private static string FormatPlatform(string? platform) =>
+        string.Equals(platform, "Discord", StringComparison.OrdinalIgnoreCase) ? "Discord" : "Telegram";
 }

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

@@ -10,7 +10,7 @@
     <div class="login-card">
         <img src="logo.png" alt="GM-Relay" class="login-logo" />
         <h1 class="login-title">GM-Relay</h1>
-        <p class="login-subtitle">Войдите через Telegram для управления игровыми сессиями</p>
+        <p class="login-subtitle">Войдите для управления игровыми сессиями</p>
 
         @if (Navigation.Uri.Contains("error=auth_failed"))
         {
@@ -20,6 +20,17 @@
         }
 
         <div id="telegram-login-container"></div>
+
+        <div class="login-divider">
+            <span>или</span>
+        </div>
+
+        <a href="/auth/discord" class="login-btn login-btn-discord">
+            <svg class="login-btn-icon" viewBox="0 0 24 24" fill="currentColor">
+                <path d="M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0 12.64 12.64 0 0 0-.617-1.25.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057 19.9 19.9 0 0 0 5.993 3.03.078.078 0 0 0 .084-.028 14.09 14.09 0 0 0 1.226-1.994.076.076 0 0 0-.041-.106 13.107 13.107 0 0 1-1.872-.892.077.077 0 0 1-.008-.128 10.2 10.2 0 0 0 .372-.292.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127 12.299 12.299 0 0 1-1.873.892.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028 19.839 19.839 0 0 0 6.002-3.03.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.956-2.419 2.157-2.419 1.21 0 2.176 1.086 2.157 2.42 0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.955-2.419 2.157-2.419 1.21 0 2.176 1.086 2.157 2.42 0 1.333-.946 2.418-2.157 2.418z"/>
+            </svg>
+            Войти через Discord
+        </a>
     </div>
 </div>
 

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

@@ -0,0 +1,191 @@
+@page "/profile"
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
+@using Microsoft.Extensions.Configuration
+@attribute [Authorize]
+@inject ISessionStore SessionStore
+@inject IConfiguration Configuration
+@inject NavigationManager Navigation
+
+<PageTitle>Профиль — GM-Relay</PageTitle>
+
+<div class="profile-container">
+    <h1 class="page-title">Профиль</h1>
+
+    @if (identities is null)
+    {
+        <p class="loading-text">Загрузка...</p>
+    }
+    else if (identities.Count == 0)
+    {
+        <div class="profile-card">
+            <p>Связанные аккаунты не найдены.</p>
+        </div>
+    }
+    else
+    {
+        <div class="profile-card">
+            <h2 class="section-title">Связанные аккаунты</h2>
+            <ul class="identity-list">
+                @foreach (var id in identities)
+                {
+                    <li class="identity-item">
+                        <div class="identity-info">
+                            <span class="identity-platform">@id.Platform</span>
+                            <span class="identity-name">@id.DisplayName</span>
+                        </div>
+                        @if (id.Platform != currentPlatform || id.ExternalUserId != currentExternalUserId)
+                        {
+                            <button class="btn btn-secondary btn-small"
+                                    @onclick="() => Unlink(id.Platform, id.ExternalUserId)"
+                                    disabled="@isUnlinking">
+                                Отвязать
+                            </button>
+                        }
+                        else
+                        {
+                            <span class="identity-badge">Текущий</span>
+                        }
+                    </li>
+                }
+            </ul>
+        </div>
+    }
+
+    <div class="profile-card">
+        <h2 class="section-title">Добавить аккаунт</h2>
+        @if (!HasLinkedPlatform("Discord"))
+        {
+            <a href="/auth/discord" class="btn btn-primary">
+                Привязать Discord
+            </a>
+        }
+        else
+        {
+            <p class="muted-text">Discord уже привязан.</p>
+        }
+
+        @if (currentPlatform == "Discord" && !HasLinkedPlatform("Telegram"))
+        {
+            var botUsername = Configuration["Telegram__BotUsername"] ?? Configuration["Telegram:BotUsername"];
+            if (!string.IsNullOrWhiteSpace(botUsername))
+            {
+                var authUrl = new Uri(new Uri(Navigation.BaseUri), "auth/telegram").ToString();
+                var widgetHtml = $"<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 class="telegram-widget-wrapper">
+                    @((MarkupString)widgetHtml)
+                </div>
+            }
+        }
+    </div>
+
+    @if (!string.IsNullOrWhiteSpace(errorMessage))
+    {
+        <div class="alert alert-error">@errorMessage</div>
+    }
+
+    @if (!string.IsNullOrWhiteSpace(successMessage))
+    {
+        <div class="alert alert-success">@successMessage</div>
+    }
+</div>
+
+@code {
+    private List<LinkedIdentity>? identities;
+    private string? currentPlatform;
+    private string? currentExternalUserId;
+    private bool isUnlinking;
+    private string? errorMessage;
+    private string? successMessage;
+
+    [CascadingParameter]
+    private Task<AuthenticationState>? AuthenticationStateTask { get; set; }
+
+    [SupplyParameterFromQuery]
+    public string? Linked { get; set; }
+
+    [SupplyParameterFromQuery(Name = "link_error")]
+    public string? LinkError { get; set; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (AuthenticationStateTask is not null)
+        {
+            var authState = await AuthenticationStateTask;
+            var user = authState.User;
+            if (user.TryGetPlatformIdentity(out var plat, out var extId))
+            {
+                currentPlatform = plat;
+                currentExternalUserId = extId;
+            }
+        }
+
+        if (!string.IsNullOrWhiteSpace(Linked))
+        {
+            successMessage = $"{Linked} аккаунт успешно привязан!";
+        }
+
+        if (!string.IsNullOrWhiteSpace(LinkError))
+        {
+            errorMessage = $"Ошибка привязки: {Uri.UnescapeDataString(LinkError)}";
+        }
+
+        await LoadIdentities();
+    }
+
+    private async Task LoadIdentities()
+    {
+        try
+        {
+            if (currentPlatform is not null && currentExternalUserId is not null)
+            {
+                identities = await SessionStore.GetLinkedIdentitiesAsync(currentPlatform, currentExternalUserId);
+            }
+            else
+            {
+                identities = [];
+            }
+        }
+        catch (Exception ex)
+        {
+            errorMessage = $"Не удалось загрузить аккаунты: {ex.Message}";
+        }
+    }
+
+    private bool HasLinkedPlatform(string platform)
+    {
+        return identities?.Any(i => i.Platform == platform) ?? false;
+    }
+
+    private async Task Unlink(string platform, string externalUserId)
+    {
+        isUnlinking = true;
+        errorMessage = null;
+        successMessage = null;
+
+        try
+        {
+            if (currentPlatform is null || currentExternalUserId is null)
+            {
+                errorMessage = "Не удалось определить текущего пользователя.";
+                return;
+            }
+
+            await SessionStore.UnlinkIdentityAsync(currentPlatform, currentExternalUserId, platform, externalUserId);
+            successMessage = $"{platform} аккаунт отвязан.";
+            await LoadIdentities();
+        }
+        catch (InvalidOperationException ex)
+        {
+            errorMessage = $"Ошибка отвязки: {ex.Message}";
+        }
+        catch (Exception ex)
+        {
+            errorMessage = $"Ошибка отвязки: {ex.Message}";
+        }
+        finally
+        {
+            isUnlinking = false;
+        }
+    }
+}

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

@@ -56,7 +56,7 @@
                         {
                             <tr>
                                 <td>@entry.ChangedAt.ToString("dd.MM.yyyy HH:mm") UTC</td>
-                                <td>@entry.ActorName (@entry.ActorTelegramId)</td>
+                                <td>@entry.ActorName (@entry.ActorExternalUserId)</td>
                                 <td>
                                     <span class="status-badge @(GetBadgeClass(entry.ChangeType))">
                                         @GetChangeTypeLabel(entry.ChangeType)
@@ -82,13 +82,13 @@
     protected override async Task OnInitializedAsync()
     {
         var authState = await AuthStateProvider.GetAuthenticationStateAsync();
-        if (!authState.User.TryGetTelegramId(out var telegramId))
+        if (!authState.User.TryGetPlatformIdentity(out var platform, out var externalUserId))
         {
             Navigation.NavigateTo("/access-denied");
             return;
         }
 
-        var session = await SessionService.GetSessionForGmAsync(SessionId, telegramId);
+        var session = await SessionService.GetSessionForCurrentUserAsync(SessionId);
         if (session is null)
         {
             Navigation.NavigateTo("/access-denied");
@@ -97,7 +97,7 @@
 
         sessionTitle = session.Title;
         groupId = session.GroupId;
-        entries = await SessionService.GetSessionHistoryForGmAsync(SessionId, telegramId);
+        entries = await SessionService.GetSessionHistoryForCurrentUserAsync(SessionId);
     }
 
     private string GetChangeTypeLabel(string changeType) => changeType switch

src/GmRelay.Web/DiscordOAuthOptions.cs

@@ -0,0 +1,19 @@
+namespace GmRelay.Web;
+
+public sealed class DiscordOAuthOptions
+{
+    public string ClientId { get; set; } = string.Empty;
+    public string ClientSecret { get; set; } = string.Empty;
+    public string RedirectUri { get; set; } = string.Empty;
+    public string[] Scopes { get; set; } = ["identify", "guilds"];
+
+    public void Validate()
+    {
+        if (string.IsNullOrWhiteSpace(ClientId))
+            throw new InvalidOperationException("Discord:ClientId is required.");
+        if (string.IsNullOrWhiteSpace(ClientSecret))
+            throw new InvalidOperationException("Discord:ClientSecret is required.");
+        if (string.IsNullOrWhiteSpace(RedirectUri))
+            throw new InvalidOperationException("Discord:RedirectUri is required.");
+    }
+}

src/GmRelay.Web/Program.cs

@@ -1,3 +1,4 @@
+using GmRelay.Web;
 using GmRelay.Web.Components;
 using GmRelay.Web.Health;
 using GmRelay.Web.Services;
@@ -7,6 +8,7 @@ using Microsoft.AspNetCore.DataProtection;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 using System.Security.Claims;
+using System.Security.Cryptography;
 using System.Text.Json;
 using Telegram.Bot;
 using Npgsql;
@@ -16,6 +18,12 @@ var builder = WebApplication.CreateBuilder(args);
 // Add Aspire service defaults
 builder.AddServiceDefaults();
 
+// Add HttpClient
+builder.Services.AddHttpClient();
+
+// Add HttpContextAccessor for platform-agnostic identity resolution
+builder.Services.AddHttpContextAccessor();
+
 // Add health checks
 builder.Services.AddHealthChecks()
     .AddCheck<NpgsqlHealthCheck>("npgsql");
@@ -29,6 +37,9 @@ builder.AddNpgsqlDataSource("gmrelaydb");
 
 // Add Services
 builder.Services.AddSingleton<TelegramAuthService>();
+builder.Services.Configure<DiscordOAuthOptions>(builder.Configuration.GetSection("Discord"));
+builder.Services.AddSingleton<DiscordAuthService>();
+builder.Services.AddSingleton<DiscordOAuthStateStore>();
 builder.Services.AddSingleton<ISessionStore, SessionService>();
 builder.Services.AddScoped<AuthorizedSessionService>();
 builder.Services.AddScoped<CalendarSubscriptionService>();
@@ -50,7 +61,7 @@ builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationSc
         options.AccessDeniedPath = "/access-denied";
         options.Cookie.HttpOnly = true;
         options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
-        options.Cookie.SameSite = SameSiteMode.Strict;
+        options.Cookie.SameSite = SameSiteMode.Lax;
         options.ExpireTimeSpan = TimeSpan.FromDays(7);
         options.SlidingExpiration = true;
     });
@@ -112,19 +123,39 @@ app.MapHealthChecks("/alive", new HealthCheckOptions
 });
 
 // Endpoint to handle Telegram Login callback
-app.MapGet("/auth/telegram", async (HttpContext context, TelegramAuthService authService) =>
+app.MapGet("/auth/telegram", async (HttpContext context, TelegramAuthService authService, ISessionStore sessionStore) =>
 {
-    if (authService.Verify(context.Request.Query, out var telegramId, out var name))
+    if (!authService.Verify(context.Request.Query, out var telegramId, out var name))
+        return Results.Redirect("/login?error=auth_failed");
+
+    await sessionStore.UpsertPlayerAsync("Telegram", telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture), name, null);
+
+    // If already authenticated via another platform, link instead of replacing session
+    if (context.User.Identity?.IsAuthenticated == true
+        && context.User.TryGetPlatformIdentity(out var currentPlatform, out var currentExternalUserId)
+        && currentPlatform != "Telegram")
     {
-        var authProperties = new AuthenticationProperties { IsPersistent = true };
-        await context.SignInAsync(
-            CookieAuthenticationDefaults.AuthenticationScheme,
-            CreateTelegramPrincipal(telegramId, name),
-            authProperties);
-        return Results.Redirect("/");
+        try
+        {
+            // Always make Telegram the primary (it has the historical data/groups)
+            await sessionStore.LinkIdentityAsync(
+                "Telegram", telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                currentPlatform, currentExternalUserId,
+                name);
+            return Results.Redirect("/profile?linked=telegram");
+        }
+        catch (InvalidOperationException ex)
+        {
+            return Results.Redirect($"/profile?link_error={Uri.EscapeDataString(ex.Message)}");
+        }
     }
 
-    return Results.Redirect("/login?error=auth_failed");
+    var authProperties = new AuthenticationProperties { IsPersistent = true };
+    await context.SignInAsync(
+        CookieAuthenticationDefaults.AuthenticationScheme,
+        CreateTelegramPrincipal(telegramId, name),
+        authProperties);
+    return Results.Redirect("/");
 });
 
 app.MapPost("/auth/telegram-webapp", async (
@@ -174,6 +205,96 @@ app.MapPost("/auth/logout", async (HttpContext context) =>
     return Results.Redirect("/");
 });
 
+// Discord OAuth endpoints
+app.MapGet("/auth/discord", (DiscordAuthService discordAuth, DiscordOAuthStateStore stateStore) =>
+{
+    var state = stateStore.CreateState();
+    var url = discordAuth.BuildAuthorizeUrl(state);
+    return Results.Redirect(url);
+});
+
+app.MapGet("/auth/discord/callback", async (
+    HttpContext context,
+    DiscordAuthService discordAuth,
+    DiscordOAuthStateStore stateStore,
+    ISessionStore sessionStore) =>
+{
+    var code = context.Request.Query["code"].ToString();
+    var state = context.Request.Query["state"].ToString();
+
+    if (string.IsNullOrWhiteSpace(code) ||
+        string.IsNullOrWhiteSpace(state) ||
+        !stateStore.ValidateAndRemove(state))
+    {
+        return Results.Redirect("/login?error=auth_failed");
+    }
+
+    var user = await discordAuth.ExchangeCodeAsync(code);
+    if (user is null)
+        return Results.Redirect("/login?error=auth_failed");
+
+    await sessionStore.UpsertDiscordUserAsync(user.Id, user.DisplayName, user.AvatarUrl);
+
+    // If already authenticated via another platform, link instead of replacing session
+    if (context.User.Identity?.IsAuthenticated == true
+        && context.User.TryGetPlatformIdentity(out var currentPlatform, out var currentExternalUserId)
+        && currentPlatform != "Discord")
+    {
+        try
+        {
+            await sessionStore.LinkIdentityAsync(
+                currentPlatform, currentExternalUserId,
+                "Discord", user.Id,
+                user.DisplayName);
+            return Results.Redirect("/profile?linked=discord");
+        }
+        catch (InvalidOperationException ex)
+        {
+            return Results.Redirect($"/profile?link_error={Uri.EscapeDataString(ex.Message)}");
+        }
+    }
+
+    var authProperties = new AuthenticationProperties { IsPersistent = true };
+    await context.SignInAsync(
+        CookieAuthenticationDefaults.AuthenticationScheme,
+        CreateDiscordPrincipal(user.Id, user.DisplayName, user.AvatarUrl),
+        authProperties);
+
+    return Results.Redirect("/");
+});
+
+// Identity linking API endpoints
+app.MapGet("/api/me/identities", async (
+    HttpContext context,
+    ISessionStore sessionStore) =>
+{
+    if (!context.User.TryGetPlatformIdentity(out var platform, out var externalUserId))
+        return Results.Unauthorized();
+
+    var identities = await sessionStore.GetLinkedIdentitiesAsync(platform, externalUserId);
+    return Results.Ok(identities);
+}).RequireAuthorization();
+
+app.MapDelete("/api/me/identities/{targetPlatform}/{targetExternalUserId}", async (
+    HttpContext context,
+    ISessionStore sessionStore,
+    string targetPlatform,
+    string targetExternalUserId) =>
+{
+    if (!context.User.TryGetPlatformIdentity(out var platform, out var externalUserId))
+        return Results.Unauthorized();
+
+    try
+    {
+        await sessionStore.UnlinkIdentityAsync(platform, externalUserId, targetPlatform, targetExternalUserId);
+        return Results.NoContent();
+    }
+    catch (InvalidOperationException ex)
+    {
+        return Results.BadRequest(new { error = ex.Message });
+    }
+}).RequireAuthorization();
+
 // Public calendar subscription endpoint (no auth required)
 app.MapGet("/calendar/{token}.ics", async (
     string token,
@@ -200,11 +321,29 @@ static ClaimsPrincipal CreateTelegramPrincipal(long telegramId, string name)
     {
         new(ClaimTypes.NameIdentifier, telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)),
         new(ClaimTypes.Name, name),
-        new("TelegramId", telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture))
+        new("TelegramId", telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)),
+        new("Platform", "Telegram")
     };
 
     var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
     return new ClaimsPrincipal(claimsIdentity);
 }
 
+static ClaimsPrincipal CreateDiscordPrincipal(string discordId, string name, string? avatarUrl)
+{
+    var claims = new List<Claim>
+    {
+        new(ClaimTypes.NameIdentifier, discordId),
+        new(ClaimTypes.Name, name),
+        new("DiscordId", discordId),
+        new("Platform", "Discord")
+    };
+
+    if (!string.IsNullOrWhiteSpace(avatarUrl))
+        claims.Add(new Claim("AvatarUrl", avatarUrl));
+
+    var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
+    return new ClaimsPrincipal(claimsIdentity);
+}
+
 public sealed record TelegramWebAppAuthRequest(string InitData);

src/GmRelay.Web/Services/AuthorizedSessionService.cs

@@ -1,182 +1,237 @@
+using System.Security.Claims;
 using GmRelay.Shared.Domain;
 
 namespace GmRelay.Web.Services;
 
-public sealed class AuthorizedSessionService(ISessionStore sessionStore)
+public sealed class AuthorizedSessionService(ISessionStore sessionStore, IHttpContextAccessor httpContextAccessor)
 {
-    public Task<List<WebGameGroup>> GetGroupsForGmAsync(long gmId) =>
-        sessionStore.GetGroupsForGmAsync(gmId);
-
-    public async Task<WebGroupManagement?> GetGroupManagementForGmAsync(Guid groupId, long gmId)
+    private (string Platform, string ExternalUserId, string Name)? GetCurrentIdentity()
     {
-        if (!await GroupBelongsToGmAsync(groupId, gmId))
-        {
+        var user = httpContextAccessor.HttpContext?.User;
+        if (user is null || !user.TryGetPlatformIdentity(out var platform, out var externalUserId))
+            return null;
+
+        var name = user.FindFirst(ClaimTypes.Name)?.Value ?? externalUserId;
+        return (platform, externalUserId, name);
+    }
+
+    public Task<List<WebGameGroup>> GetGroupsForCurrentUserAsync()
+    {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return Task.FromResult(new List<WebGameGroup>());
+
+        return sessionStore.GetGroupsForUserAsync(identity.Value.Platform, identity.Value.ExternalUserId);
+    }
+
+    public async Task<WebGroupManagement?> GetGroupManagementForCurrentUserAsync(Guid groupId)
+    {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
+        if (!await sessionStore.IsGroupManagerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
             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);
+        var isOwner = await sessionStore.IsGroupOwnerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId);
         return new WebGroupManagement(group, managers, isOwner);
     }
 
-    public async Task<List<WebSession>?> GetUpcomingSessionsForGmAsync(Guid groupId, long gmId)
+    public async Task<List<WebSession>?> GetUpcomingSessionsForCurrentUserAsync(Guid groupId)
     {
-        if (!await GroupBelongsToGmAsync(groupId, gmId))
-        {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
+        if (!await sessionStore.IsGroupManagerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
             return null;
-        }
 
         return await sessionStore.GetUpcomingSessionsAsync(groupId);
     }
 
-    public async Task<WebSession?> GetSessionForGmAsync(Guid sessionId, long gmId)
+    public async Task<WebSession?> GetSessionForCurrentUserAsync(Guid sessionId)
     {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
         var session = await sessionStore.GetSessionAsync(sessionId);
         if (session is null)
-        {
             return null;
-        }
 
-        return await GroupBelongsToGmAsync(session.GroupId, gmId) ? session : null;
+        return await sessionStore.IsGroupManagerAsync(session.GroupId, identity.Value.Platform, identity.Value.ExternalUserId) ? session : null;
     }
 
-    public async Task<WebSessionBatch?> GetBatchForGmAsync(Guid batchId, long gmId)
+    public async Task<WebSessionBatch?> GetBatchForCurrentUserAsync(Guid batchId)
     {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
         var batch = await sessionStore.GetBatchAsync(batchId);
         if (batch is null)
-        {
             return null;
-        }
 
-        return await GroupBelongsToGmAsync(batch.GroupId, gmId) ? batch : null;
+        return await sessionStore.IsGroupManagerAsync(batch.GroupId, identity.Value.Platform, identity.Value.ExternalUserId) ? batch : null;
     }
 
-    public async Task UpdateSessionForGmAsync(Guid sessionId, long gmId, string title, DateTime scheduledAt, string joinLink, int? maxPlayers)
+    public async Task UpdateSessionForCurrentUserAsync(Guid sessionId, string title, DateTime scheduledAt, string joinLink, int? maxPlayers)
     {
-        var session = await GetSessionForGmAsync(sessionId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var session = await GetSessionForCurrentUserAsync(sessionId);
         if (session is null)
         {
-            throw new SessionAccessDeniedException(sessionId, gmId);
+            throw new SessionAccessDeniedException(sessionId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.UpdateSessionAsync(sessionId, session.GroupId, title, scheduledAt, joinLink, maxPlayers);
 
         if (session.Title != title)
-            await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "Title", session.Title, title);
+            await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "Title", session.Title, title);
         if (session.ScheduledAt != scheduledAt)
-            await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "Time", session.ScheduledAt.ToString("O"), scheduledAt.ToString("O"));
+            await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "Time", session.ScheduledAt.ToString("O"), scheduledAt.ToString("O"));
         if (session.JoinLink != joinLink)
-            await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "Link", session.JoinLink, joinLink);
+            await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "Link", session.JoinLink, joinLink);
         if (session.MaxPlayers != maxPlayers)
-            await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "MaxPlayers", session.MaxPlayers?.ToString(), maxPlayers?.ToString());
+            await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "MaxPlayers", session.MaxPlayers?.ToString(), maxPlayers?.ToString());
     }
 
-    public async Task PromoteWaitlistedPlayerForGmAsync(Guid sessionId, long gmId)
+    public async Task PromoteWaitlistedPlayerForCurrentUserAsync(Guid sessionId)
     {
-        var session = await GetSessionForGmAsync(sessionId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var session = await GetSessionForCurrentUserAsync(sessionId);
         if (session is null)
         {
-            throw new SessionAccessDeniedException(sessionId, gmId);
+            throw new SessionAccessDeniedException(sessionId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.PromoteWaitlistedPlayerAsync(sessionId, session.GroupId);
-        await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "WaitlistPromote", null, null);
+        await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "WaitlistPromote", null, null);
     }
 
-    public async Task UpdateBatchDetailsForGmAsync(Guid batchId, long gmId, string title, string joinLink)
+    public async Task UpdateBatchDetailsForCurrentUserAsync(Guid batchId, string title, string joinLink)
     {
-        var batch = await GetBatchForGmAsync(batchId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var batch = await GetBatchForCurrentUserAsync(batchId);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, gmId);
+            throw new SessionAccessDeniedException(batchId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.UpdateBatchDetailsAsync(batchId, batch.GroupId, title.Trim(), joinLink.Trim());
     }
 
-    public async Task UpdateBatchNotificationModeForGmAsync(Guid batchId, long gmId, SessionNotificationMode notificationMode)
+    public async Task UpdateBatchNotificationModeForCurrentUserAsync(Guid batchId, SessionNotificationMode notificationMode)
     {
-        var batch = await GetBatchForGmAsync(batchId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var batch = await GetBatchForCurrentUserAsync(batchId);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, gmId);
+            throw new SessionAccessDeniedException(batchId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.UpdateBatchNotificationModeAsync(batchId, batch.GroupId, notificationMode);
     }
 
-    public async Task RescheduleBatchForGmAsync(Guid batchId, long gmId, DateTime firstScheduledAt, int intervalDays)
+    public async Task RescheduleBatchForCurrentUserAsync(Guid batchId, 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);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var batch = await GetBatchForCurrentUserAsync(batchId);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, gmId);
+            throw new SessionAccessDeniedException(batchId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.RescheduleBatchAsync(batchId, batch.GroupId, firstScheduledAt, intervalDays);
-        await sessionStore.LogSessionChangeAsync(batchId, gmId, "ГМ", "BatchRescheduled", batch.FirstScheduledAt.ToString("O"), firstScheduledAt.ToString("O"));
+        await sessionStore.LogSessionChangeAsync(batchId, identity.Value.ExternalUserId, identity.Value.Name, "BatchRescheduled", batch.FirstScheduledAt.ToString("O"), firstScheduledAt.ToString("O"));
     }
 
-    public async Task<WebSessionBatch> CloneBatchForGmAsync(Guid batchId, long gmId, BatchCloneInterval interval)
+    public async Task<WebSessionBatch> CloneBatchForCurrentUserAsync(Guid batchId, BatchCloneInterval interval)
     {
-        var batch = await GetBatchForGmAsync(batchId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var batch = await GetBatchForCurrentUserAsync(batchId);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, gmId);
+            throw new SessionAccessDeniedException(batchId, identity.Value.ExternalUserId);
         }
 
         return await sessionStore.CloneBatchAsync(batchId, batch.GroupId, interval);
     }
 
-    public async Task<List<WebCampaignTemplate>?> GetCampaignTemplatesForGmAsync(Guid groupId, long gmId)
+    public async Task<List<WebCampaignTemplate>?> GetCampaignTemplatesForCurrentUserAsync(Guid groupId)
     {
-        if (!await GroupBelongsToGmAsync(groupId, gmId))
-        {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
+        if (!await sessionStore.IsGroupManagerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
             return null;
-        }
 
         return await sessionStore.GetCampaignTemplatesAsync(groupId);
     }
 
-    public async Task<WebCampaignTemplate> CreateCampaignTemplateForGmAsync(
+    public async Task<WebCampaignTemplate> CreateCampaignTemplateForCurrentUserAsync(
         Guid groupId,
-        long gmId,
         CreateCampaignTemplateRequest request)
     {
-        if (!await GroupBelongsToGmAsync(groupId, gmId))
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        if (!await sessionStore.IsGroupManagerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
         {
-            throw new SessionAccessDeniedException(groupId, gmId);
+            throw new SessionAccessDeniedException(groupId, identity.Value.ExternalUserId);
         }
 
         var normalizedRequest = NormalizeCampaignTemplateRequest(request);
         return await sessionStore.CreateCampaignTemplateAsync(groupId, normalizedRequest);
     }
 
-    public async Task DeleteCampaignTemplateForGmAsync(Guid templateId, long gmId)
+    public async Task DeleteCampaignTemplateForCurrentUserAsync(Guid templateId)
     {
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
         var template = await sessionStore.GetCampaignTemplateAsync(templateId);
-        if (template is null || !await GroupBelongsToGmAsync(template.GroupId, gmId))
+        if (template is null || !await sessionStore.IsGroupManagerAsync(template.GroupId, identity.Value.Platform, identity.Value.ExternalUserId))
         {
-            throw new SessionAccessDeniedException(templateId, gmId);
+            throw new SessionAccessDeniedException(templateId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.DeleteCampaignTemplateAsync(templateId, template.GroupId);
     }
 
-    public async Task<WebSessionBatch> CreateBatchFromCampaignTemplateForGmAsync(
+    public async Task<WebSessionBatch> CreateBatchFromCampaignTemplateForCurrentUserAsync(
         Guid templateId,
-        long gmId,
         DateTime firstScheduledAt)
     {
         if (firstScheduledAt <= DateTime.UtcNow)
@@ -184,89 +239,112 @@ public sealed class AuthorizedSessionService(ISessionStore sessionStore)
             throw new ArgumentOutOfRangeException(nameof(firstScheduledAt), firstScheduledAt, "First scheduled time must be in the future.");
         }
 
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
         var template = await sessionStore.GetCampaignTemplateAsync(templateId);
-        if (template is null || !await GroupBelongsToGmAsync(template.GroupId, gmId))
+        if (template is null || !await sessionStore.IsGroupManagerAsync(template.GroupId, identity.Value.Platform, identity.Value.ExternalUserId))
         {
-            throw new SessionAccessDeniedException(templateId, gmId);
+            throw new SessionAccessDeniedException(templateId, identity.Value.ExternalUserId);
         }
 
         return await sessionStore.CreateBatchFromTemplateAsync(templateId, template.GroupId, firstScheduledAt);
     }
 
-    public async Task AddCoGmForOwnerAsync(Guid groupId, long ownerTelegramId, long coGmTelegramId, string displayName, string? telegramUsername)
+    public async Task AddCoGmForOwnerAsync(Guid groupId, string coGmPlatform, string coGmExternalUserId, string displayName, string? externalUsername)
     {
-        if (coGmTelegramId <= 0)
+        if (string.IsNullOrWhiteSpace(coGmExternalUserId))
         {
-            throw new ArgumentOutOfRangeException(nameof(coGmTelegramId), coGmTelegramId, "Telegram id must be greater than zero.");
+            throw new ArgumentException("External user id must not be empty.", nameof(coGmExternalUserId));
         }
 
-        if (ownerTelegramId == coGmTelegramId)
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        if (identity.Value.ExternalUserId == coGmExternalUserId && identity.Value.Platform == coGmPlatform)
         {
             throw new InvalidOperationException("Owner is already a group manager.");
         }
 
-        if (!await sessionStore.IsGroupOwnerAsync(groupId, ownerTelegramId))
+        if (!await sessionStore.IsGroupOwnerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
         {
-            throw new SessionAccessDeniedException(groupId, ownerTelegramId);
+            throw new SessionAccessDeniedException(groupId, identity.Value.ExternalUserId);
         }
 
         var normalizedName = string.IsNullOrWhiteSpace(displayName)
-            ? $"Telegram {coGmTelegramId.ToString(System.Globalization.CultureInfo.InvariantCulture)}"
+            ? $"{coGmPlatform} {coGmExternalUserId}"
             : displayName.Trim();
-        var normalizedUsername = string.IsNullOrWhiteSpace(telegramUsername)
+        var normalizedUsername = string.IsNullOrWhiteSpace(externalUsername)
             ? null
-            : telegramUsername.Trim().TrimStart('@');
+            : externalUsername.Trim().TrimStart('@');
 
-        await sessionStore.AddGroupCoGmAsync(groupId, ownerTelegramId, coGmTelegramId, normalizedName, normalizedUsername);
+        await sessionStore.AddGroupCoGmAsync(
+            groupId,
+            identity.Value.Platform, identity.Value.ExternalUserId,
+            coGmPlatform, coGmExternalUserId,
+            normalizedName, normalizedUsername);
     }
 
-    public async Task RemoveCoGmForOwnerAsync(Guid groupId, long ownerTelegramId, long coGmTelegramId)
+    public async Task RemoveCoGmForOwnerAsync(Guid groupId, string coGmPlatform, string coGmExternalUserId)
     {
-        if (!await sessionStore.IsGroupOwnerAsync(groupId, ownerTelegramId))
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        if (!await sessionStore.IsGroupOwnerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
         {
-            throw new SessionAccessDeniedException(groupId, ownerTelegramId);
+            throw new SessionAccessDeniedException(groupId, identity.Value.ExternalUserId);
         }
 
-        await sessionStore.RemoveGroupCoGmAsync(groupId, coGmTelegramId);
+        await sessionStore.RemoveGroupCoGmAsync(groupId, coGmPlatform, coGmExternalUserId);
     }
 
-    public async Task<List<WebParticipant>?> GetSessionParticipantsForGmAsync(Guid sessionId, long gmId)
+    public async Task<List<WebParticipant>?> GetSessionParticipantsForCurrentUserAsync(Guid sessionId)
     {
-        var session = await GetSessionForGmAsync(sessionId, gmId);
+        var session = await GetSessionForCurrentUserAsync(sessionId);
         if (session is null)
-        {
             return null;
-        }
 
         return await sessionStore.GetSessionParticipantsAsync(sessionId);
     }
 
-    public async Task<List<SessionAuditLogEntry>?> GetSessionHistoryForGmAsync(Guid sessionId, long gmId)
+    public async Task<List<SessionAuditLogEntry>?> GetSessionHistoryForCurrentUserAsync(Guid sessionId)
     {
-        var session = await GetSessionForGmAsync(sessionId, gmId);
+        var session = await GetSessionForCurrentUserAsync(sessionId);
         if (session is null)
-        {
             return null;
-        }
 
         return await sessionStore.GetSessionHistoryAsync(sessionId);
     }
 
-    public async Task RemovePlayerFromSessionForGmAsync(Guid sessionId, long gmId, Guid participantId)
+    public async Task RemovePlayerFromSessionForCurrentUserAsync(Guid sessionId, Guid participantId)
     {
-        var session = await GetSessionForGmAsync(sessionId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            throw new InvalidOperationException("User is not authenticated.");
+
+        var session = await GetSessionForCurrentUserAsync(sessionId);
         if (session is null)
         {
-            throw new SessionAccessDeniedException(sessionId, gmId);
+            throw new SessionAccessDeniedException(sessionId, identity.Value.ExternalUserId);
         }
 
         await sessionStore.RemovePlayerFromSessionAsync(sessionId, session.GroupId, participantId);
-        await sessionStore.LogSessionChangeAsync(sessionId, gmId, "ГМ", "PlayerRemoved", participantId.ToString(), null);
+        await sessionStore.LogSessionChangeAsync(sessionId, identity.Value.ExternalUserId, identity.Value.Name, "PlayerRemoved", participantId.ToString(), null);
     }
 
-    private async Task<bool> GroupBelongsToGmAsync(Guid groupId, long gmId)
+    public async Task<List<PlayerAttendanceStats>?> GetGroupAttendanceStatsForCurrentUserAsync(Guid groupId)
     {
-        return await sessionStore.IsGroupManagerAsync(groupId, gmId);
+        var identity = GetCurrentIdentity();
+        if (identity is null)
+            return null;
+
+        if (!await sessionStore.IsGroupManagerAsync(groupId, identity.Value.Platform, identity.Value.ExternalUserId))
+            return null;
+
+        return await sessionStore.GetGroupAttendanceStatsAsync(groupId);
     }
 
     private static CreateCampaignTemplateRequest NormalizeCampaignTemplateRequest(CreateCampaignTemplateRequest request)

src/GmRelay.Web/Services/CalendarSubscriptionService.cs

@@ -12,7 +12,8 @@ public sealed class CalendarSubscriptionService(NpgsqlDataSource dataSource)
     public string GenerateToken() => Guid.NewGuid().ToString("N");
 
     public async Task<string> CreateSubscriptionAsync(
-        long userTelegramId,
+        string userPlatform,
+        string userExternalId,
         Guid? groupId,
         CalendarSubscriptionFilter filter,
         CancellationToken ct = default)
@@ -20,9 +21,9 @@ public sealed class CalendarSubscriptionService(NpgsqlDataSource dataSource)
         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 });
+            @"INSERT INTO calendar_subscriptions (id, token, user_platform, user_external_id, group_id, filter_type, created_at, expires_at)
+              VALUES (gen_random_uuid(), @token, @userPlatform, @userExternalId, @groupId, @filterType, now(), NULL)",
+            new { token, userPlatform, userExternalId, groupId, filterType = (int)filter });
         return token;
     }
 
@@ -31,7 +32,7 @@ public sealed class CalendarSubscriptionService(NpgsqlDataSource dataSource)
         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
+            @"SELECT id, group_id as GroupId, filter_type as FilterType
               FROM calendar_subscriptions
               WHERE token = @token
                 AND (expires_at IS NULL OR expires_at > now())",
@@ -88,6 +89,6 @@ public sealed class CalendarSubscriptionService(NpgsqlDataSource dataSource)
         .Replace("\n", "\\n")
         .Replace("\r", "");
 
-    private sealed record SubscriptionRecord(Guid Id, long UserTelegramId, Guid? GroupId, int FilterType);
+    private sealed record SubscriptionRecord(Guid Id, Guid? GroupId, int FilterType);
     private sealed record CalendarSessionDto(Guid Id, string Title, DateTime ScheduledAt);
 }

src/GmRelay.Web/Services/ClaimsPrincipalExtensions.cs

@@ -6,4 +6,37 @@ public static class ClaimsPrincipalExtensions
 {
     public static bool TryGetTelegramId(this ClaimsPrincipal user, out long telegramId) =>
         long.TryParse(user.FindFirst("TelegramId")?.Value, out telegramId);
+
+    public static bool TryGetDiscordId(this ClaimsPrincipal user, out string? discordId)
+    {
+        discordId = user.FindFirst("DiscordId")?.Value;
+        return !string.IsNullOrWhiteSpace(discordId);
+    }
+
+    public static bool TryGetPlatformIdentity(this ClaimsPrincipal user, out string platform, out string externalUserId)
+    {
+        platform = string.Empty;
+        externalUserId = string.Empty;
+
+        var platformClaim = user.FindFirst("Platform")?.Value;
+        if (!string.IsNullOrWhiteSpace(platformClaim))
+        {
+            platform = platformClaim;
+            externalUserId = user.FindFirst(ClaimTypes.NameIdentifier)?.Value ?? string.Empty;
+            return !string.IsNullOrWhiteSpace(externalUserId);
+        }
+
+        // Fallback for legacy Telegram users before Platform claim was added
+        if (TryGetTelegramId(user, out var telegramId))
+        {
+            platform = "Telegram";
+            externalUserId = telegramId.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            return true;
+        }
+
+        return false;
+    }
+
+    public static string? GetAvatarUrl(this ClaimsPrincipal user) =>
+        user.FindFirst("AvatarUrl")?.Value;
 }

src/GmRelay.Web/Services/DiscordAuthService.cs

@@ -0,0 +1,86 @@
+using System.Net.Http.Headers;
+using System.Security.Claims;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace GmRelay.Web.Services;
+
+public sealed class DiscordAuthService(IHttpClientFactory httpClientFactory, IConfiguration configuration, ILogger<DiscordAuthService> logger)
+{
+    private readonly DiscordOAuthOptions _options = configuration.GetSection("Discord").Get<DiscordOAuthOptions>() ?? new DiscordOAuthOptions();
+
+    public string BuildAuthorizeUrl(string state)
+    {
+        _options.Validate();
+        var scopes = string.Join(" ", _options.Scopes);
+        return $"https://discord.com/oauth2/authorize?client_id={_options.ClientId}&redirect_uri={Uri.EscapeDataString(_options.RedirectUri)}&response_type=code&scope={Uri.EscapeDataString(scopes)}&state={Uri.EscapeDataString(state)}";
+    }
+
+    public async Task<DiscordUser?> ExchangeCodeAsync(string code)
+    {
+        _options.Validate();
+        var client = httpClientFactory.CreateClient();
+
+        var tokenResponse = await ExchangeCodeForTokenAsync(client, code);
+        if (tokenResponse is null)
+            return null;
+
+        return await FetchUserProfileAsync(client, tokenResponse.AccessToken);
+    }
+
+    private async Task<DiscordTokenResponse?> ExchangeCodeForTokenAsync(HttpClient client, string code)
+    {
+        var content = new FormUrlEncodedContent(new Dictionary<string, string>
+        {
+            ["grant_type"] = "authorization_code",
+            ["code"] = code,
+            ["redirect_uri"] = _options.RedirectUri,
+            ["client_id"] = _options.ClientId,
+            ["client_secret"] = _options.ClientSecret
+        });
+
+        var response = await client.PostAsync("https://discord.com/api/oauth2/token", content);
+        var json = await response.Content.ReadAsStringAsync();
+        if (!response.IsSuccessStatusCode)
+        {
+            logger.LogError("Discord token exchange failed: {StatusCode} {Body}. client_id={ClientId}, redirect_uri={RedirectUri}",
+                (int)response.StatusCode, json, _options.ClientId, _options.RedirectUri);
+            return null;
+        }
+
+        return JsonSerializer.Deserialize<DiscordTokenResponse>(json);
+    }
+
+    private static async Task<DiscordUser?> FetchUserProfileAsync(HttpClient client, string accessToken)
+    {
+        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
+        var response = await client.GetAsync("https://discord.com/api/users/@me");
+        if (!response.IsSuccessStatusCode)
+            return null;
+
+        var json = await response.Content.ReadAsStringAsync();
+        return JsonSerializer.Deserialize<DiscordUser>(json);
+    }
+}
+
+public sealed record DiscordTokenResponse(
+    [property: JsonPropertyName("access_token")] string AccessToken,
+    [property: JsonPropertyName("token_type")] string TokenType,
+    [property: JsonPropertyName("expires_in")] int ExpiresIn,
+    [property: JsonPropertyName("scope")] string Scope);
+
+public sealed record DiscordUser(
+    [property: JsonPropertyName("id")] string Id,
+    [property: JsonPropertyName("username")] string Username,
+    [property: JsonPropertyName("discriminator")] string Discriminator,
+    [property: JsonPropertyName("avatar")] string? Avatar,
+    [property: JsonPropertyName("email")] string? Email)
+{
+    public string DisplayName =>
+        Discriminator == "0" ? Username : $"{Username}#{Discriminator}";
+
+    public string? AvatarUrl =>
+        !string.IsNullOrWhiteSpace(Avatar)
+            ? $"https://cdn.discordapp.com/avatars/{Id}/{Avatar}.png"
+            : null;
+}

src/GmRelay.Web/Services/DiscordOAuthStateStore.cs

@@ -0,0 +1,32 @@
+namespace GmRelay.Web.Services;
+
+public sealed class DiscordOAuthStateStore(ILogger<DiscordOAuthStateStore> logger)
+{
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, DateTime> _states = new();
+
+    public string CreateState()
+    {
+        var state = Guid.NewGuid().ToString("N");
+        _states[state] = DateTime.UtcNow.AddMinutes(5);
+        logger.LogDebug("Discord OAuth state created: {State}", state);
+        return state;
+    }
+
+    public bool ValidateAndRemove(string state)
+    {
+        if (!_states.TryRemove(state, out var expiresAt))
+        {
+            logger.LogWarning("Discord OAuth state not found or already used: {State}", state);
+            return false;
+        }
+
+        if (DateTime.UtcNow > expiresAt)
+        {
+            logger.LogWarning("Discord OAuth state expired: {State}", state);
+            return false;
+        }
+
+        logger.LogDebug("Discord OAuth state validated: {State}", state);
+        return true;
+    }
+}

src/GmRelay.Web/Services/ISessionStore.cs

@@ -5,33 +5,31 @@ namespace GmRelay.Web.Services;
 public sealed record PlayerAttendanceStats(
     Guid PlayerId,
     string DisplayName,
-    string? TelegramUsername,
+    string? ExternalUsername,
     long TotalSessions,
     long ConfirmedCount,
     long DeclinedCount,
     long NoResponseCount,
     long WaitlistedCount,
     long CancellationAffectedCount,
-    decimal AttendanceRate
-);
+    decimal AttendanceRate);
 
 public sealed record SessionAuditLogEntry(
     Guid Id,
     Guid SessionId,
-    long ActorTelegramId,
+    string ActorExternalUserId,
     string ActorName,
     string ChangeType,
     string? OldValue,
     string? NewValue,
-    DateTime ChangedAt
-);
+    DateTime ChangedAt);
 
 public interface ISessionStore
 {
-    Task<List<WebGameGroup>> GetGroupsForGmAsync(long gmId);
+    Task<List<WebGameGroup>> GetGroupsForUserAsync(string platform, string externalUserId);
     Task<WebGameGroup?> GetGroupAsync(Guid groupId);
-    Task<bool> IsGroupManagerAsync(Guid groupId, long telegramId);
-    Task<bool> IsGroupOwnerAsync(Guid groupId, long telegramId);
+    Task<bool> IsGroupManagerAsync(Guid groupId, string platform, string externalUserId);
+    Task<bool> IsGroupOwnerAsync(Guid groupId, string platform, string externalUserId);
     Task<List<WebGroupManager>> GetGroupManagersAsync(Guid groupId);
     Task<List<WebSession>> GetUpcomingSessionsAsync(Guid groupId);
     Task<WebSession?> GetSessionAsync(Guid sessionId);
@@ -47,11 +45,27 @@ public interface ISessionStore
     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 AddGroupCoGmAsync(Guid groupId, string ownerPlatform, string ownerExternalUserId, string coGmPlatform, string coGmExternalUserId, string displayName, string? externalUsername);
+    Task RemoveGroupCoGmAsync(Guid groupId, string coGmPlatform, string coGmExternalUserId);
     Task<List<WebParticipant>> GetSessionParticipantsAsync(Guid sessionId);
     Task RemovePlayerFromSessionAsync(Guid sessionId, Guid groupId, Guid participantId);
     Task<List<PlayerAttendanceStats>> GetGroupAttendanceStatsAsync(Guid groupId);
-    Task LogSessionChangeAsync(Guid sessionId, long actorTelegramId, string actorName, string changeType, string? oldValue, string? newValue);
+    Task LogSessionChangeAsync(Guid sessionId, string actorExternalUserId, string actorName, string changeType, string? oldValue, string? newValue);
     Task<List<SessionAuditLogEntry>> GetSessionHistoryAsync(Guid sessionId);
+    Task UpsertDiscordUserAsync(string discordId, string displayName, string? avatarUrl);
+
+    // --- Identity linking (issue #35) ---
+    Task<Guid?> ResolveEffectivePlayerIdAsync(string platform, string externalUserId);
+    Task<List<LinkedIdentity>> GetLinkedIdentitiesAsync(string platform, string externalUserId);
+    Task LinkIdentityAsync(string currentPlatform, string currentExternalUserId, string targetPlatform, string targetExternalUserId, string? currentName);
+    Task UnlinkIdentityAsync(string currentPlatform, string currentExternalUserId, string targetPlatform, string targetExternalUserId);
+    Task UpsertPlayerAsync(string platform, string externalUserId, string displayName, string? avatarUrl);
 }
+
+public sealed record LinkedIdentity(
+    string Platform,
+    string ExternalUserId,
+    string DisplayName,
+    string? ExternalUsername,
+    string? AvatarUrl,
+    DateTime LinkedAt);

src/GmRelay.Web/Services/SessionAccessDeniedException.cs

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

src/GmRelay.Web/Services/SessionService.cs

@@ -3,6 +3,7 @@ using GmRelay.Shared.Domain;
 using GmRelay.Shared.Rendering;
 using Npgsql;
 using Telegram.Bot;
+using Telegram.Bot.Exceptions;
 using GmRelay.Web.Services;
 
 namespace GmRelay.Web.Services;
@@ -10,16 +11,32 @@ namespace GmRelay.Web.Services;
 public sealed record WebGameGroup(
     Guid Id,
     long TelegramChatId,
+    string? ExternalGroupId,
     string Name,
-    long GmTelegramId,
-    string ManagerRole = GroupManagerRoleExtensions.OwnerValue);
+    string? Platform,
+    string ManagerRole = GroupManagerRoleExtensions.OwnerValue)
+{
+    public long GmTelegramId { get; init; }
+
+    public WebGameGroup(Guid id, long telegramChatId, string name, long gmTelegramId)
+        : this(id, telegramChatId, null, name, null)
+    {
+        GmTelegramId = gmTelegramId;
+    }
+}
 
 public sealed record WebGroupManager(
     long TelegramId,
+    string? ExternalUserId,
     string DisplayName,
     string? TelegramUsername,
+    string? ExternalUsername,
     string Role,
-    DateTime AddedAt);
+    DateTime AddedAt)
+{
+    public WebGroupManager(long telegramId, string displayName, string? telegramUsername, string role, DateTime addedAt)
+        : this(telegramId, null, displayName, telegramUsername, null, role, addedAt) { }
+}
 
 public sealed record WebGroupManagement(
     WebGameGroup Group,
@@ -44,8 +61,10 @@ public sealed record WebSession(
 public sealed record WebParticipant(
     Guid Id,
     long TelegramId,
+    string? ExternalUserId,
     string DisplayName,
     string? TelegramUsername,
+    string? ExternalUsername,
     string RsvpStatus,
     string RegistrationStatus,
     bool IsGm,
@@ -77,29 +96,55 @@ internal sealed record WebBatchSessionRow(
     string NotificationMode,
     bool TopicCreatedByBot = false);
 internal sealed record WebTemplateGroupDto(long TelegramChatId);
+internal sealed record WebTemplateTopicDestination(int? MessageThreadId, bool TopicCreatedByBot);
 
 public sealed class SessionService(
     NpgsqlDataSource dataSource,
     ITelegramBotClient bot,
     ILogger<SessionService> logger) : ISessionStore
 {
-    public async Task<List<WebGameGroup>> GetGroupsForGmAsync(long gmId)
+    public async Task<List<WebGameGroup>> GetGroupsForUserAsync(string platform, string externalUserId)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
+        var playerIds = await _ResolveLinkedPlayerIdsAsync(conn, platform, externalUserId);
+        if (playerIds.Length == 0)
+            return [];
+
         return (await conn.QueryAsync<WebGameGroup>(
             """
+            WITH visible_groups AS (
+                SELECT gm.group_id,
+                       CASE
+                           WHEN bool_or(gm.role = @OwnerRole) THEN @OwnerRole
+                           ELSE @CoGmRole
+                       END AS ManagerRole
+                FROM group_managers gm
+                WHERE gm.player_id = ANY(@PlayerIds)
+                GROUP BY gm.group_id
+            )
             SELECT g.id,
-                   g.telegram_chat_id AS TelegramChatId,
-                   g.name,
-                   g.gm_telegram_id AS GmTelegramId,
-                   gm.role AS ManagerRole
-            FROM group_managers gm
-            JOIN players p ON p.id = gm.player_id
-            JOIN game_groups g ON g.id = gm.group_id
-            WHERE p.telegram_id = @GmId
+                   g.external_group_id::BIGINT AS TelegramChatId,
+                   g.external_group_id AS ExternalGroupId,
+                   COALESCE(NULLIF(g.name, g.external_group_id), latest_session.title, g.name) AS Name,
+                   g.platform AS Platform,
+                   vg.ManagerRole
+            FROM visible_groups vg
+            JOIN game_groups g ON g.id = vg.group_id
+            LEFT JOIN LATERAL (
+                SELECT s.title
+                FROM sessions s
+                WHERE s.group_id = g.id
+                ORDER BY s.scheduled_at DESC
+                LIMIT 1
+            ) latest_session ON true
             ORDER BY g.name
             """,
-            new { GmId = gmId })).ToList();
+            new
+            {
+                PlayerIds = playerIds,
+                OwnerRole = GroupManagerRoleExtensions.OwnerValue,
+                CoGmRole = GroupManagerRoleExtensions.CoGmValue
+            })).ToList();
     }
 
     public async Task<WebGameGroup?> GetGroupAsync(Guid groupId)
@@ -108,47 +153,61 @@ public sealed class SessionService(
         return await conn.QuerySingleOrDefaultAsync<WebGameGroup>(
             """
             SELECT g.id,
-                   g.telegram_chat_id AS TelegramChatId,
-                   g.name,
-                   g.gm_telegram_id AS GmTelegramId,
+                   g.external_group_id::BIGINT AS TelegramChatId,
+                   g.external_group_id AS ExternalGroupId,
+                   COALESCE(NULLIF(g.name, g.external_group_id), latest_session.title, g.name) AS Name,
+                   g.platform AS Platform,
                    @OwnerRole AS ManagerRole
             FROM game_groups g
+            LEFT JOIN LATERAL (
+                SELECT s.title
+                FROM sessions s
+                WHERE s.group_id = g.id
+                ORDER BY s.scheduled_at DESC
+                LIMIT 1
+            ) latest_session ON true
             WHERE g.id = @GroupId
             """,
             new { GroupId = groupId, OwnerRole = GroupManagerRoleExtensions.OwnerValue });
     }
 
-    public async Task<bool> IsGroupManagerAsync(Guid groupId, long telegramId)
+    public async Task<bool> IsGroupManagerAsync(Guid groupId, string platform, string externalUserId)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
+        var playerIds = await _ResolveLinkedPlayerIdsAsync(conn, platform, externalUserId);
+        if (playerIds.Length == 0)
+            return false;
+
         return await conn.ExecuteScalarAsync<bool>(
             """
             SELECT EXISTS (
                 SELECT 1
-                FROM group_managers gm
-                JOIN players p ON p.id = gm.player_id
-                WHERE gm.group_id = @GroupId
-                  AND p.telegram_id = @TelegramId
+                FROM group_managers
+                WHERE group_id = @GroupId
+                  AND player_id = ANY(@PlayerIds)
             )
             """,
-            new { GroupId = groupId, TelegramId = telegramId });
+            new { GroupId = groupId, PlayerIds = playerIds });
     }
 
-    public async Task<bool> IsGroupOwnerAsync(Guid groupId, long telegramId)
+    public async Task<bool> IsGroupOwnerAsync(Guid groupId, string platform, string externalUserId)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
+        var playerIds = await _ResolveLinkedPlayerIdsAsync(conn, platform, externalUserId);
+        if (playerIds.Length == 0)
+            return false;
+
         return await conn.ExecuteScalarAsync<bool>(
             """
             SELECT EXISTS (
                 SELECT 1
-                FROM group_managers gm
-                JOIN players p ON p.id = gm.player_id
-                WHERE gm.group_id = @GroupId
-                  AND p.telegram_id = @TelegramId
-                  AND gm.role = @OwnerRole
+                FROM group_managers
+                WHERE group_id = @GroupId
+                  AND player_id = ANY(@PlayerIds)
+                  AND role = @OwnerRole
             )
             """,
-            new { GroupId = groupId, TelegramId = telegramId, OwnerRole = GroupManagerRoleExtensions.OwnerValue });
+            new { GroupId = groupId, PlayerIds = playerIds, OwnerRole = GroupManagerRoleExtensions.OwnerValue });
     }
 
     public async Task<List<WebGroupManager>> GetGroupManagersAsync(Guid groupId)
@@ -156,9 +215,11 @@ public sealed class SessionService(
         await using var conn = await dataSource.OpenConnectionAsync();
         return (await conn.QueryAsync<WebGroupManager>(
             """
-            SELECT p.telegram_id AS TelegramId,
+            SELECT COALESCE(p.external_user_id::BIGINT, 0) AS TelegramId,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
+                   p.external_username AS TelegramUsername,
+                   p.external_username AS ExternalUsername,
                    gm.role AS Role,
                    gm.created_at AS AddedAt
             FROM group_managers gm
@@ -179,7 +240,7 @@ public sealed class SessionService(
             SELECT
                 p.id AS PlayerId,
                 p.display_name AS DisplayName,
-                p.telegram_username AS TelegramUsername,
+                p.external_username AS ExternalUsername,
                 COUNT(DISTINCT s.id) AS TotalSessions,
                 COUNT(DISTINCT CASE WHEN sp.rsvp_status = 'Confirmed' THEN s.id END) AS ConfirmedCount,
                 COUNT(DISTINCT CASE WHEN sp.rsvp_status = 'Declined' THEN s.id END) AS DeclinedCount,
@@ -198,21 +259,21 @@ public sealed class SessionService(
             WHERE s.group_id = @GroupId
               AND s.scheduled_at <= now()
               AND sp.is_gm = false
-            GROUP BY p.id, p.display_name, p.telegram_username
+            GROUP BY p.id, p.display_name, p.external_username
             ORDER BY AttendanceRate DESC, ConfirmedCount DESC
             """,
             new { GroupId = groupId })).ToList();
     }
 
-    public async Task LogSessionChangeAsync(Guid sessionId, long actorTelegramId, string actorName, string changeType, string? oldValue, string? newValue)
+    public async Task LogSessionChangeAsync(Guid sessionId, string actorExternalUserId, string actorName, string changeType, string? oldValue, string? newValue)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
         await conn.ExecuteAsync(
             """
-            INSERT INTO session_audit_log (session_id, actor_telegram_id, actor_name, change_type, old_value, new_value)
-            VALUES (@SessionId, @ActorTelegramId, @ActorName, @ChangeType, @OldValue, @NewValue)
+            INSERT INTO session_audit_log (session_id, actor_external_user_id, actor_name, change_type, old_value, new_value)
+            VALUES (@SessionId, @ActorExternalUserId, @ActorName, @ChangeType, @OldValue, @NewValue)
             """,
-            new { SessionId = sessionId, ActorTelegramId = actorTelegramId, ActorName = actorName, ChangeType = changeType, OldValue = oldValue, NewValue = newValue });
+            new { SessionId = sessionId, ActorExternalUserId = actorExternalUserId, ActorName = actorName, ChangeType = changeType, OldValue = oldValue, NewValue = newValue });
     }
 
     public async Task<List<SessionAuditLogEntry>> GetSessionHistoryAsync(Guid sessionId)
@@ -220,7 +281,7 @@ public sealed class SessionService(
         await using var conn = await dataSource.OpenConnectionAsync();
         var entries = await conn.QueryAsync<SessionAuditLogEntry>(
             """
-            SELECT id, session_id AS SessionId, actor_telegram_id AS ActorTelegramId, actor_name AS ActorName,
+            SELECT id, session_id AS SessionId, actor_external_user_id AS ActorExternalUserId, actor_name AS ActorName,
                    change_type AS ChangeType, old_value AS OldValue, new_value AS NewValue, changed_at AS ChangedAt
             FROM session_audit_log
             WHERE session_id = @SessionId
@@ -232,43 +293,23 @@ public sealed class SessionService(
 
     public async Task AddGroupCoGmAsync(
         Guid groupId,
-        long ownerTelegramId,
-        long coGmTelegramId,
-        string displayName,
-        string? telegramUsername)
+        string ownerPlatform, string ownerExternalUserId,
+        string coGmPlatform, string coGmExternalUserId,
+        string displayName, string? externalUsername)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
         await using var transaction = await conn.BeginTransactionAsync();
 
-        await conn.ExecuteAsync(
-            """
-            INSERT INTO players (telegram_id, display_name, telegram_username, platform, external_user_id, external_username)
-            VALUES (@TelegramId, @DisplayName, @TelegramUsername, 'Telegram', @TelegramId::TEXT, @TelegramUsername)
-            ON CONFLICT (telegram_id) DO UPDATE
-            SET display_name = EXCLUDED.display_name,
-                telegram_username = EXCLUDED.telegram_username,
-                platform = COALESCE(players.platform, 'Telegram'),
-                external_user_id = COALESCE(players.external_user_id, EXCLUDED.telegram_id::TEXT),
-                external_username = COALESCE(players.external_username, EXCLUDED.telegram_username)
-            """,
-            new
-            {
-                TelegramId = coGmTelegramId,
-                DisplayName = displayName,
-                TelegramUsername = telegramUsername
-            },
-            transaction);
+        var ownerPlayerId = await _ResolveEffectivePlayerIdAsync(conn, ownerPlatform, ownerExternalUserId);
+        if (ownerPlayerId is null)
+            throw new InvalidOperationException("Owner player not found.");
+
+        var coGmPlayerId = await _UpsertPlayerAndGetIdAsync(conn, coGmPlatform, coGmExternalUserId, displayName, externalUsername, transaction);
 
         await conn.ExecuteAsync(
             """
             INSERT INTO group_managers (group_id, player_id, role, added_by_player_id)
-            SELECT @GroupId,
-                   co_gm.id,
-                   @CoGmRole,
-                   owner_player.id
-            FROM players co_gm
-            LEFT JOIN players owner_player ON owner_player.telegram_id = @OwnerTelegramId
-            WHERE co_gm.telegram_id = @CoGmTelegramId
+            VALUES (@GroupId, @CoGmPlayerId, @CoGmRole, @OwnerPlayerId)
             ON CONFLICT (group_id, player_id) DO UPDATE
             SET role = CASE
                     WHEN group_managers.role = @OwnerRole THEN group_managers.role
@@ -279,8 +320,8 @@ public sealed class SessionService(
             new
             {
                 GroupId = groupId,
-                OwnerTelegramId = ownerTelegramId,
-                CoGmTelegramId = coGmTelegramId,
+                OwnerPlayerId = ownerPlayerId.Value,
+                CoGmPlayerId = coGmPlayerId,
                 OwnerRole = GroupManagerRoleExtensions.OwnerValue,
                 CoGmRole = GroupManagerRoleExtensions.CoGmValue
             },
@@ -289,22 +330,24 @@ public sealed class SessionService(
         await transaction.CommitAsync();
     }
 
-    public async Task RemoveGroupCoGmAsync(Guid groupId, long coGmTelegramId)
+    public async Task RemoveGroupCoGmAsync(Guid groupId, string coGmPlatform, string coGmExternalUserId)
     {
         await using var conn = await dataSource.OpenConnectionAsync();
+        var coGmPlayerId = await _ResolveEffectivePlayerIdAsync(conn, coGmPlatform, coGmExternalUserId);
+        if (coGmPlayerId is null)
+            return;
+
         await conn.ExecuteAsync(
             """
-            DELETE FROM group_managers gm
-            USING players p
-            WHERE gm.player_id = p.id
-              AND gm.group_id = @GroupId
-              AND p.telegram_id = @CoGmTelegramId
-              AND gm.role = @CoGmRole
+            DELETE FROM group_managers
+            WHERE group_id = @GroupId
+              AND player_id = @PlayerId
+              AND role = @CoGmRole
             """,
             new
             {
                 GroupId = groupId,
-                CoGmTelegramId = coGmTelegramId,
+                PlayerId = coGmPlayerId.Value,
                 CoGmRole = GroupManagerRoleExtensions.CoGmValue
             });
     }
@@ -315,7 +358,7 @@ public sealed class SessionService(
         return (await conn.QueryAsync<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,
+                     g.external_group_id::BIGINT AS TelegramChatId,
                      s.max_players AS MaxPlayers,
                      COALESCE(active_counts.count, 0)::int AS ActivePlayerCount,
                      COALESCE(waitlist_counts.count, 0)::int AS WaitlistedPlayerCount,
@@ -353,7 +396,7 @@ public sealed class SessionService(
         return 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,
+                     g.external_group_id::BIGINT AS TelegramChatId,
                      s.max_players AS MaxPlayers,
                      COALESCE(active_counts.count, 0)::int AS ActivePlayerCount,
                      COALESCE(waitlist_counts.count, 0)::int AS WaitlistedPlayerCount,
@@ -412,7 +455,7 @@ public sealed class SessionService(
         var oldSession = 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,
+                     g.external_group_id::BIGINT AS TelegramChatId,
                      s.max_players AS MaxPlayers,
                      0 AS ActivePlayerCount,
                      0 AS WaitlistedPlayerCount,
@@ -426,7 +469,7 @@ public sealed class SessionService(
 
         if (oldSession is null)
         {
-            throw new SessionAccessDeniedException(sessionId, 0);
+            throw new SessionAccessDeniedException(sessionId, "0");
         }
 
         var updatedRows = await conn.ExecuteAsync(
@@ -454,7 +497,7 @@ public sealed class SessionService(
 
         if (updatedRows == 0)
         {
-            throw new SessionAccessDeniedException(sessionId, 0);
+            throw new SessionAccessDeniedException(sessionId, "0");
         }
 
         await conn.ExecuteAsync(
@@ -498,7 +541,7 @@ public sealed class SessionService(
         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,
+                     g.external_group_id::BIGINT AS TelegramChatId,
                      s.max_players AS MaxPlayers,
                      0 AS ActivePlayerCount,
                      0 AS WaitlistedPlayerCount,
@@ -513,7 +556,7 @@ public sealed class SessionService(
 
         if (session is null)
         {
-            throw new SessionAccessDeniedException(sessionId, 0);
+            throw new SessionAccessDeniedException(sessionId, "0");
         }
 
         var activeParticipants = await conn.ExecuteScalarAsync<int>(
@@ -597,9 +640,11 @@ public sealed class SessionService(
         return (await conn.QueryAsync<WebParticipant>(
             """
             SELECT sp.id AS Id,
-                   p.telegram_id AS TelegramId,
+                   COALESCE(p.external_user_id::BIGINT, 0) AS TelegramId,
+                   p.external_user_id AS ExternalUserId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
+                   p.external_username AS TelegramUsername,
+                   p.external_username AS ExternalUsername,
                    sp.rsvp_status AS RsvpStatus,
                    sp.registration_status AS RegistrationStatus,
                    sp.is_gm AS IsGm,
@@ -622,7 +667,7 @@ public sealed class SessionService(
         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,
+                     g.external_group_id::BIGINT AS TelegramChatId,
                      s.max_players AS MaxPlayers,
                      0 AS ActivePlayerCount,
                      0 AS WaitlistedPlayerCount,
@@ -637,15 +682,15 @@ public sealed class SessionService(
 
         if (session is null)
         {
-            throw new SessionAccessDeniedException(sessionId, 0);
+            throw new SessionAccessDeniedException(sessionId, "0");
         }
 
         var participant = await conn.QuerySingleOrDefaultAsync<WebParticipant>(
             """
             SELECT sp.id AS Id,
-                   p.telegram_id AS TelegramId,
+                   p.external_user_id::BIGINT AS TelegramId,
                    p.display_name AS DisplayName,
-                   p.telegram_username AS TelegramUsername,
+                   p.external_username AS TelegramUsername,
                    sp.rsvp_status AS RsvpStatus,
                    sp.registration_status AS RegistrationStatus,
                    sp.is_gm AS IsGm,
@@ -744,7 +789,7 @@ public sealed class SessionService(
         var batch = await GetBatchInfoAsync(conn, batchId, groupId, transaction);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         var updatedRows = await conn.ExecuteAsync(
@@ -767,7 +812,7 @@ public sealed class SessionService(
 
         if (updatedRows == 0)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         await transaction.CommitAsync();
@@ -786,7 +831,7 @@ public sealed class SessionService(
         var batch = await GetBatchInfoAsync(conn, batchId, groupId, transaction);
         if (batch is null)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         var updatedRows = await conn.ExecuteAsync(
@@ -807,7 +852,7 @@ public sealed class SessionService(
 
         if (updatedRows == 0)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         await transaction.CommitAsync();
@@ -828,7 +873,7 @@ public sealed class SessionService(
                    s.status AS Status,
                    s.max_players AS MaxPlayers,
                    s.batch_message_id AS BatchMessageId,
-                   g.telegram_chat_id AS TelegramChatId,
+                   g.external_group_id::BIGINT AS TelegramChatId,
                    s.thread_id AS ThreadId,
                    s.topic_created_by_bot AS TopicCreatedByBot,
                    s.notification_mode AS NotificationMode
@@ -844,7 +889,7 @@ public sealed class SessionService(
 
         if (batchSessions.Count == 0)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         var newSchedule = BatchSchedulePlanner.BuildFixedIntervalSchedule(
@@ -912,7 +957,7 @@ public sealed class SessionService(
                    s.status AS Status,
                    s.max_players AS MaxPlayers,
                    s.batch_message_id AS BatchMessageId,
-                   g.telegram_chat_id AS TelegramChatId,
+                   g.external_group_id::BIGINT AS TelegramChatId,
                    s.thread_id AS ThreadId,
                    s.topic_created_by_bot AS TopicCreatedByBot,
                    s.notification_mode AS NotificationMode
@@ -928,7 +973,7 @@ public sealed class SessionService(
 
         if (sourceSessions.Count == 0)
         {
-            throw new SessionAccessDeniedException(batchId, 0);
+            throw new SessionAccessDeniedException(batchId, "0");
         }
 
         var newBatchId = Guid.NewGuid();
@@ -1130,19 +1175,23 @@ public sealed class SessionService(
 
         if (template is null)
         {
-            throw new SessionAccessDeniedException(templateId, 0);
+            throw new SessionAccessDeniedException(templateId, "0");
         }
 
         var group = await conn.QuerySingleOrDefaultAsync<WebTemplateGroupDto>(
-            "SELECT telegram_chat_id AS TelegramChatId FROM game_groups WHERE id = @GroupId",
+            "SELECT external_group_id::BIGINT AS TelegramChatId FROM game_groups WHERE id = @GroupId",
             new { GroupId = groupId },
             transaction);
 
         if (group is null)
         {
-            throw new SessionAccessDeniedException(groupId, 0);
+            throw new SessionAccessDeniedException(groupId, "0");
         }
 
+        var topicDestination = await ResolveTemplateBatchTopicAsync(group.TelegramChatId, template.Title);
+        var messageThreadId = topicDestination.MessageThreadId;
+        var topicCreatedByBot = topicDestination.TopicCreatedByBot;
+
         var schedule = BatchSchedulePlanner.BuildRecurringSchedule(
             firstScheduledAt,
             template.SessionCount,
@@ -1154,8 +1203,8 @@ public sealed class SessionService(
         {
             var sessionId = await conn.ExecuteScalarAsync<Guid>(
                 """
-                INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, max_players, notification_mode)
-                VALUES (@BatchId, @GroupId, @Title, @JoinLink, @ScheduledAt, @Status, @MaxPlayers, @NotificationMode)
+                INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, thread_id, topic_created_by_bot, max_players, notification_mode)
+                VALUES (@BatchId, @GroupId, @Title, @JoinLink, @ScheduledAt, @Status, @ThreadId, @TopicCreatedByBot, @MaxPlayers, @NotificationMode)
                 RETURNING id
                 """,
                 new
@@ -1166,6 +1215,8 @@ public sealed class SessionService(
                     template.JoinLink,
                     ScheduledAt = scheduledAt,
                     Status = SessionStatus.Planned,
+                    ThreadId = messageThreadId,
+                    TopicCreatedByBot = topicCreatedByBot,
                     template.MaxPlayers,
                     template.NotificationMode
                 },
@@ -1180,6 +1231,7 @@ public sealed class SessionService(
         var renderResult = TelegramSessionBatchRenderer.Render(view);
         var batchMessage = await bot.SendMessage(
             chatId: group.TelegramChatId,
+            messageThreadId: messageThreadId,
             text: renderResult.Text,
             parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
             replyMarkup: renderResult.Markup);
@@ -1199,13 +1251,41 @@ public sealed class SessionService(
             template.NotificationMode);
     }
 
+    private async Task<WebTemplateTopicDestination> ResolveTemplateBatchTopicAsync(long telegramChatId, string title)
+    {
+        var chat = await bot.GetChat(chatId: telegramChatId);
+        if (!chat.IsForum)
+        {
+            return new WebTemplateTopicDestination(null, TopicCreatedByBot: false);
+        }
+
+        try
+        {
+            var topic = await bot.CreateForumTopic(
+                chatId: telegramChatId,
+                name: $"🎲 Игры: {title}");
+            return new WebTemplateTopicDestination(topic.MessageThreadId, TopicCreatedByBot: true);
+        }
+        catch (ApiRequestException ex) when (IsMissingForumTopicRightsError(ex.Message))
+        {
+            throw new InvalidOperationException(
+                "Не удалось создать Telegram topic. Сделайте бота admin и включите право Manage Topics, затем повторите действие.",
+                ex);
+        }
+    }
+
+    private static bool IsMissingForumTopicRightsError(string apiError) =>
+        apiError.Contains("not enough rights", StringComparison.OrdinalIgnoreCase) ||
+        apiError.Contains("CHAT_ADMIN_REQUIRED", StringComparison.OrdinalIgnoreCase) ||
+        apiError.Contains("not an administrator", StringComparison.OrdinalIgnoreCase);
+
     private async Task<List<WebDirectNotificationRecipient>> LoadSessionDirectRecipientsAsync(
         Npgsql.NpgsqlConnection conn,
         Guid sessionId)
     {
         return (await conn.QueryAsync<WebDirectNotificationRecipient>(
             """
-            SELECT p.telegram_id AS TelegramId,
+            SELECT p.external_user_id::BIGINT AS TelegramId,
                    p.display_name AS DisplayName
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
@@ -1222,7 +1302,7 @@ public sealed class SessionService(
     {
         return (await conn.QueryAsync<WebDirectNotificationRecipient>(
             """
-            SELECT DISTINCT p.telegram_id AS TelegramId,
+            SELECT DISTINCT p.external_user_id::BIGINT AS TelegramId,
                             p.display_name AS DisplayName
             FROM session_participants sp
             JOIN players p ON p.id = sp.player_id
@@ -1275,7 +1355,7 @@ public sealed class SessionService(
             var participants = (await conn.QueryAsync<ParticipantBatchDto>(
                 @"SELECT sp.session_id AS SessionId,
                          p.display_name AS DisplayName,
-                         p.telegram_username AS TelegramUsername,
+                         p.external_username AS TelegramUsername,
                          sp.registration_status AS RegistrationStatus
                   FROM session_participants sp
                   JOIN players p ON sp.player_id = p.id
@@ -1312,7 +1392,7 @@ public sealed class SessionService(
                    s.group_id AS GroupId,
                    (array_agg(s.title ORDER BY s.scheduled_at))[1] AS Title,
                    (array_agg(s.join_link ORDER BY s.scheduled_at))[1] AS JoinLink,
-                   g.telegram_chat_id AS TelegramChatId,
+                   g.external_group_id::BIGINT AS TelegramChatId,
                    (array_agg(s.batch_message_id ORDER BY s.scheduled_at))[1] AS BatchMessageId,
                    (array_agg(s.thread_id ORDER BY s.scheduled_at))[1] AS ThreadId,
                    (array_agg(s.notification_mode ORDER BY s.scheduled_at))[1] AS NotificationMode
@@ -1320,9 +1400,280 @@ public sealed class SessionService(
             JOIN game_groups g ON g.id = s.group_id
             WHERE s.batch_id = @BatchId
               AND s.group_id = @GroupId
-            GROUP BY s.batch_id, s.group_id, g.telegram_chat_id
+            GROUP BY s.batch_id, s.group_id, g.external_group_id
             """,
             new { BatchId = batchId, GroupId = groupId },
             transaction);
     }
+
+    // --- Identity linking (issue #35) ---
+
+    public async Task<Guid?> ResolveEffectivePlayerIdAsync(string platform, string externalUserId)
+    {
+        await using var conn = await dataSource.OpenConnectionAsync();
+        return await _ResolveEffectivePlayerIdAsync(conn, platform, externalUserId);
+    }
+
+    public async Task<List<LinkedIdentity>> GetLinkedIdentitiesAsync(string platform, string externalUserId)
+    {
+        await using var conn = await dataSource.OpenConnectionAsync();
+
+        var effectiveId = await _ResolveEffectivePlayerIdAsync(conn, platform, externalUserId);
+        if (effectiveId is null)
+            return [];
+
+        return (await conn.QueryAsync<LinkedIdentity>(
+            """
+            SELECT p.platform AS Platform,
+                   p.external_user_id AS ExternalUserId,
+                   p.display_name AS DisplayName,
+                   p.external_username AS ExternalUsername,
+                   p.avatar_url AS AvatarUrl,
+                   COALESCE(pl.linked_at, p.created_at) AS LinkedAt
+            FROM players p
+            LEFT JOIN player_links pl ON pl.secondary_player_id = p.id
+            WHERE pl.primary_player_id = @EffectiveId
+               OR p.id = @EffectiveId
+            ORDER BY CASE WHEN p.id = @EffectiveId THEN 0 ELSE 1 END,
+                     p.platform
+            """,
+            new { EffectiveId = effectiveId.Value })).ToList();
+    }
+
+    public async Task LinkIdentityAsync(
+        string currentPlatform, string currentExternalUserId,
+        string targetPlatform, string targetExternalUserId,
+        string? currentName)
+    {
+        if (currentPlatform == targetPlatform && currentExternalUserId == targetExternalUserId)
+            throw new InvalidOperationException("Cannot link an identity to itself.");
+
+        await using var conn = await dataSource.OpenConnectionAsync();
+        await using var transaction = await conn.BeginTransactionAsync();
+
+        // Resolve current player (must exist — they are logged in)
+        var currentPlayerId = await _ResolvePlayerIdAsync(conn, currentPlatform, currentExternalUserId);
+        if (currentPlayerId is null)
+            throw new InvalidOperationException("Current player not found.");
+
+        // Upsert target player so it exists
+        var targetDisplayName = currentName ?? $"{targetPlatform} {targetExternalUserId}";
+        var targetPlayerId = await _UpsertPlayerAndGetIdAsync(conn, targetPlatform, targetExternalUserId, targetDisplayName, null, transaction);
+
+        // Check if target is already a primary of another link chain (conflict)
+        var targetIsPrimary = await conn.ExecuteScalarAsync<bool>(
+            """
+            SELECT EXISTS (
+                SELECT 1 FROM player_links WHERE primary_player_id = @TargetPlayerId
+            )
+            """,
+            new { TargetPlayerId = targetPlayerId }, transaction);
+
+        if (targetIsPrimary)
+        {
+            await _LogIdentityAuditAsync(conn, currentPlayerId.Value, "link_attempt_conflict",
+                targetPlatform, targetExternalUserId, currentPlayerId.Value, transaction);
+            await transaction.CommitAsync();
+            throw new InvalidOperationException("Target identity is already the primary account of another linked set.");
+        }
+
+        // Check if current is already a secondary (then their primary becomes the effective primary)
+        var currentPrimaryId = await conn.QuerySingleOrDefaultAsync<Guid?>(
+            """
+            SELECT primary_player_id
+            FROM player_links
+            WHERE secondary_player_id = @CurrentPlayerId
+            """,
+            new { CurrentPlayerId = currentPlayerId.Value }, transaction);
+
+        var effectiveCurrentPrimary = currentPrimaryId ?? currentPlayerId.Value;
+
+        // Check if target is already linked to someone else as secondary
+        var existingLink = await conn.QuerySingleOrDefaultAsync<Guid?>(
+            """
+            SELECT primary_player_id
+            FROM player_links
+            WHERE secondary_player_id = @TargetPlayerId
+            """,
+            new { TargetPlayerId = targetPlayerId }, transaction);
+
+        if (existingLink is not null && existingLink.Value != effectiveCurrentPrimary)
+        {
+            await _LogIdentityAuditAsync(conn, effectiveCurrentPrimary, "link_attempt_conflict",
+                targetPlatform, targetExternalUserId, currentPlayerId.Value, transaction);
+            await transaction.CommitAsync();
+            throw new InvalidOperationException("Target identity is already linked to another account.");
+        }
+
+        var effectivePrimary = currentPrimaryId ?? currentPlayerId.Value;
+
+        // Check if already linked
+        var alreadyLinked = await conn.ExecuteScalarAsync<bool>(
+            """
+            SELECT EXISTS (
+                SELECT 1 FROM player_links
+                WHERE primary_player_id = @EffectivePrimary AND secondary_player_id = @TargetPlayerId
+            )
+            """,
+            new { EffectivePrimary = effectivePrimary, TargetPlayerId = targetPlayerId }, transaction);
+
+        if (alreadyLinked)
+        {
+            await transaction.CommitAsync();
+            return; // Already linked, idempotent
+        }
+
+        await conn.ExecuteAsync(
+            """
+            INSERT INTO player_links (primary_player_id, secondary_player_id, linked_by_player_id)
+            VALUES (@PrimaryPlayerId, @SecondaryPlayerId, @LinkedByPlayerId)
+            """,
+            new
+            {
+                PrimaryPlayerId = effectivePrimary,
+                SecondaryPlayerId = targetPlayerId,
+                LinkedByPlayerId = currentPlayerId.Value
+            },
+            transaction);
+
+        await _LogIdentityAuditAsync(conn, effectivePrimary, "link",
+            targetPlatform, targetExternalUserId, currentPlayerId.Value, transaction);
+
+        await transaction.CommitAsync();
+    }
+
+    public async Task UnlinkIdentityAsync(
+        string currentPlatform, string currentExternalUserId,
+        string targetPlatform, string targetExternalUserId)
+    {
+        if (currentPlatform == targetPlatform && currentExternalUserId == targetExternalUserId)
+            throw new InvalidOperationException("Cannot unlink your own primary identity from itself.");
+
+        await using var conn = await dataSource.OpenConnectionAsync();
+        await using var transaction = await conn.BeginTransactionAsync();
+
+        var currentPlayerId = await _ResolvePlayerIdAsync(conn, currentPlatform, currentExternalUserId);
+        if (currentPlayerId is null)
+            throw new InvalidOperationException("Current player not found.");
+
+        var targetPlayerId = await _ResolvePlayerIdAsync(conn, targetPlatform, targetExternalUserId);
+        if (targetPlayerId is null)
+            throw new InvalidOperationException("Target identity not found.");
+
+        var effectivePrimary = await _ResolveEffectivePlayerIdAsync(conn, currentPlatform, currentExternalUserId);
+        if (effectivePrimary is null)
+            throw new InvalidOperationException("Effective primary not found.");
+
+        // Only the primary account owner (or the linked identity itself) can unlink
+        var rows = await conn.ExecuteAsync(
+            """
+            DELETE FROM player_links
+            WHERE primary_player_id = @EffectivePrimary
+              AND secondary_player_id = @TargetPlayerId
+            """,
+            new { EffectivePrimary = effectivePrimary.Value, TargetPlayerId = targetPlayerId.Value },
+            transaction);
+
+        if (rows == 0)
+        {
+            await transaction.RollbackAsync();
+            throw new InvalidOperationException("Identity is not linked to your account.");
+        }
+
+        await _LogIdentityAuditAsync(conn, effectivePrimary.Value, "unlink",
+            targetPlatform, targetExternalUserId, currentPlayerId.Value, transaction);
+
+        await transaction.CommitAsync();
+    }
+
+    public async Task UpsertPlayerAsync(string platform, string externalUserId, string displayName, string? avatarUrl)
+    {
+        await using var conn = await dataSource.OpenConnectionAsync();
+        await _UpsertPlayerAndGetIdAsync(conn, platform, externalUserId, displayName, avatarUrl, null);
+    }
+
+    public async Task UpsertDiscordUserAsync(string discordId, string displayName, string? avatarUrl)
+    {
+        await using var conn = await dataSource.OpenConnectionAsync();
+        await _UpsertPlayerAndGetIdAsync(conn, "Discord", discordId, displayName, avatarUrl, null);
+    }
+
+    // --- Private helpers ---
+
+    private static async Task<Guid?> _ResolvePlayerIdAsync(NpgsqlConnection conn, string platform, string externalUserId)
+    {
+        return await conn.QuerySingleOrDefaultAsync<Guid?>(
+            """
+            SELECT id FROM players
+            WHERE platform = @Platform AND external_user_id = @ExternalUserId
+            """,
+            new { Platform = platform, ExternalUserId = externalUserId });
+    }
+
+    private static async Task<Guid?> _ResolveEffectivePlayerIdAsync(NpgsqlConnection conn, string platform, string externalUserId)
+    {
+        var playerId = await _ResolvePlayerIdAsync(conn, platform, externalUserId);
+        if (playerId is null)
+            return null;
+
+        var primaryId = await conn.QuerySingleOrDefaultAsync<Guid?>(
+            """
+            SELECT primary_player_id FROM player_links
+            WHERE secondary_player_id = @PlayerId
+            """,
+            new { PlayerId = playerId.Value });
+
+        return primaryId ?? playerId;
+    }
+
+    private static async Task<Guid[]> _ResolveLinkedPlayerIdsAsync(NpgsqlConnection conn, string platform, string externalUserId)
+    {
+        var effectiveId = await _ResolveEffectivePlayerIdAsync(conn, platform, externalUserId);
+        if (effectiveId is null)
+            return [];
+
+        return (await conn.QueryAsync<Guid>(
+            """
+            SELECT @EffectiveId
+            UNION
+            SELECT secondary_player_id
+            FROM player_links
+            WHERE primary_player_id = @EffectiveId
+            """,
+            new { EffectiveId = effectiveId.Value })).ToArray();
+    }
+
+    private static async Task<Guid> _UpsertPlayerAndGetIdAsync(
+        NpgsqlConnection conn, string platform, string externalUserId,
+        string displayName, string? avatarUrl, NpgsqlTransaction? transaction)
+    {
+        return await conn.QuerySingleAsync<Guid>(
+            """
+            INSERT INTO players (display_name, platform, external_user_id, external_username, avatar_url)
+            VALUES (@DisplayName, @Platform, @ExternalUserId, @DisplayName, @AvatarUrl)
+            ON CONFLICT (platform, external_user_id)
+            WHERE platform IS NOT NULL AND external_user_id IS NOT NULL
+            DO UPDATE
+            SET display_name = EXCLUDED.display_name,
+                external_username = EXCLUDED.external_username,
+                avatar_url = COALESCE(EXCLUDED.avatar_url, players.avatar_url)
+            RETURNING id
+            """,
+            new { DisplayName = displayName, Platform = platform, ExternalUserId = externalUserId, AvatarUrl = avatarUrl },
+            transaction);
+    }
+
+    private static async Task _LogIdentityAuditAsync(
+        NpgsqlConnection conn, Guid playerId, string action,
+        string? targetPlatform, string? targetExternalUserId,
+        Guid? performedByPlayerId, NpgsqlTransaction? transaction)
+    {
+        await conn.ExecuteAsync(
+            """
+            INSERT INTO identity_audit_log (player_id, action, target_platform, target_external_user_id, performed_by_player_id)
+            VALUES (@PlayerId, @Action, @TargetPlatform, @TargetExternalUserId, @PerformedByPlayerId)
+            """,
+            new { PlayerId = playerId, Action = action, TargetPlatform = targetPlatform, TargetExternalUserId = targetExternalUserId, PerformedByPlayerId = performedByPlayerId },
+            transaction);
+    }
 }

src/GmRelay.Web/wwwroot/app.css

@@ -1619,3 +1619,78 @@ body.telegram-mini-app .session-card-mobile {
         display: flex;
     }
 }
+
+/* === Discord Login Button === */
+.login-btn-discord {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.75rem 1.25rem;
+    border-radius: var(--radius-md);
+    font-weight: 500;
+    font-size: 0.9375rem;
+    text-decoration: none;
+    transition: all 0.2s ease;
+    background-color: #5865F2;
+    color: white;
+    border: none;
+    cursor: pointer;
+}
+
+.login-btn-discord:hover {
+    background-color: #4752C4;
+    transform: translateY(-1px);
+}
+
+.login-btn-discord:active {
+    transform: translateY(0);
+}
+
+.login-btn-discord .login-btn-icon {
+    width: 20px;
+    height: 20px;
+    flex-shrink: 0;
+}
+
+.login-divider {
+    display: flex;
+    align-items: center;
+    margin: 1.25rem 0;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+
+.login-divider::before,
+.login-divider::after {
+    content: "";
+    flex: 1;
+    height: 1px;
+    background: var(--border-color);
+}
+
+.login-divider span {
+    padding: 0 1rem;
+}
+
+/* === Platform Indicator in Nav === */
+.nav-user-info {
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+}
+
+.nav-user-platform {
+    font-size: 0.6875rem;
+    color: var(--text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.025em;
+}
+
+.nav-user-avatar img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+    border-radius: 50%;
+}

tests/GmRelay.Bot.Tests/Discord/DiscordListSessionsHandlerTests.cs

@@ -33,7 +33,17 @@ public sealed class DiscordListSessionsHandlerTests
 
         Assert.Contains("platform = 'Discord'", handler, StringComparison.Ordinal);
         Assert.Contains("external_group_id = @GuildId", handler, StringComparison.Ordinal);
-        Assert.Contains("scheduled_at > NOW()", handler, StringComparison.Ordinal);
+        Assert.Contains("scheduled_at > now() - interval '4 hours'", handler, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Handler_ShouldIncludeRecentlyStartedSessionsForCleanup()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordListSessionsHandler.cs");
+        var handler = File.ReadAllText(handlerPath);
+
+        Assert.Contains("now() - interval '4 hours'", handler, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]
@@ -47,6 +57,17 @@ public sealed class DiscordListSessionsHandlerTests
         Assert.DoesNotContain("telegram_id", handler, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void Handler_ShouldExposeDeleteActionForManagers()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordListSessionsHandler.cs");
+        var handler = File.ReadAllText(handlerPath);
+
+        Assert.Contains("delete_session", handler, StringComparison.Ordinal);
+        Assert.Contains("CanManageSchedule", handler, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void Command_ShouldExist()
     {
@@ -66,4 +87,18 @@ public sealed class DiscordListSessionsHandlerTests
         Assert.Contains("SlashCommand", command, StringComparison.Ordinal);
         Assert.Contains("listsessions", command, StringComparison.Ordinal);
     }
+
+    [Fact]
+    public void DeleteHandler_ShouldDeleteOnlySessionsFromTheInteractionGuild()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordDeleteSessionHandler.cs");
+
+        Assert.True(File.Exists(handlerPath), "DiscordDeleteSessionHandler should exist.");
+
+        var handler = File.ReadAllText(handlerPath);
+        Assert.Contains("DELETE FROM sessions", handler, StringComparison.Ordinal);
+        Assert.Contains("external_group_id = @GuildId", handler, StringComparison.Ordinal);
+        Assert.Contains("CanManageSchedule", handler, StringComparison.Ordinal);
+    }
 }

tests/GmRelay.Bot.Tests/Discord/DiscordNewSessionHandlerTests.cs

@@ -17,6 +17,17 @@ public sealed class DiscordNewSessionHandlerTests
 
     // --- Runtime tests for ParseTimeInput (static, no DB) ---
 
+    [Fact]
+    public void ParseTimeInput_ShouldTreatInputAsMoscowTime()
+    {
+        var result = DiscordNewSessionHandler.ParseTimeInput("2026-06-01 15:00");
+        Assert.True(result.IsSuccess);
+        // 15:00 MSK = 12:00 UTC
+        Assert.Equal(12, result.Value.Hour);
+        Assert.Equal(0, result.Value.Minute);
+        Assert.Equal(TimeSpan.Zero, result.Value.Offset);
+    }
+
     [Fact]
     public void ParseTimeInput_ShouldParseDiscordDateFormat()
     {
@@ -28,7 +39,8 @@ public sealed class DiscordNewSessionHandlerTests
         Assert.Equal(expected.Year, result.Value.Year);
         Assert.Equal(expected.Month, result.Value.Month);
         Assert.Equal(expected.Day, result.Value.Day);
-        Assert.Equal(19, result.Value.Hour);
+        // Input is treated as Moscow time; 19:30 MSK = 16:30 UTC
+        Assert.Equal(16, result.Value.Hour);
         Assert.Equal(30, result.Value.Minute);
     }
 
@@ -127,6 +139,18 @@ public sealed class DiscordNewSessionHandlerTests
         Assert.Contains("RollbackAsync", source, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void Handler_ShouldNotRollbackCommittedTransactionAfterPostCommitFailure()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordNewSessionHandler.cs");
+        var source = File.ReadAllText(handlerPath);
+
+        Assert.Contains("transactionCommitted = false", source, StringComparison.Ordinal);
+        Assert.Contains("transactionCommitted = true", source, StringComparison.Ordinal);
+        Assert.Contains("if (!transactionCommitted)", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void Handler_ShouldRespectCancellationToken()
     {
@@ -145,7 +169,30 @@ public sealed class DiscordNewSessionHandlerTests
         var source = File.ReadAllText(commandPath);
 
         Assert.Contains("DiscordSessionBatchRenderer.Render", source, StringComparison.Ordinal);
-        Assert.Contains("WithEmbeds", source, StringComparison.Ordinal);
+        Assert.Contains("message.Embeds = embeds", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Handler_ShouldLeaveScheduleMessageCreationToInteractionResponse()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordNewSessionHandler.cs");
+        var source = File.ReadAllText(handlerPath);
+
+        Assert.DoesNotContain("SendScheduleAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("PlatformScheduleMessage", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Handler_ShouldStoreReadableDiscordGroupNameForWebCards()
+    {
+        var repoRoot = GetRepoRoot();
+        var handlerPath = Path.Combine(repoRoot, "src", "GmRelay.DiscordBot", "Features", "Sessions", "DiscordNewSessionHandler.cs");
+        var source = File.ReadAllText(handlerPath);
+
+        Assert.Contains("groupName", source, StringComparison.Ordinal);
+        Assert.Contains("displayGroupName", source, StringComparison.Ordinal);
+        Assert.Contains("VALUES (@GroupName, 'Discord'", source, StringComparison.Ordinal);
     }
 
     private static DateTimeOffset FutureDateAt1930()

tests/GmRelay.Bot.Tests/Discord/DiscordProjectStructureTests.cs

@@ -40,6 +40,7 @@ public sealed class DiscordProjectStructureTests
         Assert.Contains("GmRelay.Shared.csproj", project);
         Assert.DoesNotContain("Telegram.Bot", project);
         Assert.DoesNotContain("GmRelay.Bot.csproj", project);
+        Assert.Contains("Dapper.AOT", project);
     }
 
     [Fact]
@@ -61,7 +62,7 @@ public sealed class DiscordProjectStructureTests
         var prChecks = File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "pr-checks.yml"));
         var deploy = File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "deploy.yml"));
 
-        Assert.Contains("gmrelay-discord-bot:2.7.0", compose);
+        Assert.Contains("gmrelay-discord-bot:3.1.1", compose);
         Assert.Contains("Discord__Token=${DISCORD_BOT_TOKEN:?Set DISCORD_BOT_TOKEN in .env}", compose);
         Assert.Contains("src/GmRelay.DiscordBot/Dockerfile", deploy);
         Assert.Contains("DISCORD_BOT_TOKEN", deploy);
@@ -75,13 +76,49 @@ public sealed class DiscordProjectStructureTests
     {
         var repoRoot = GetRepoRoot();
 
-        Assert.Contains("<Version>2.7.0</Version>", File.ReadAllText(Path.Combine(repoRoot, "Directory.Build.props")));
-        Assert.Contains("VERSION: 2.7.0", File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "deploy.yml")));
-        Assert.Contains("gmrelay-bot:2.7.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
-        Assert.Contains("gmrelay-web:2.7.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
-        Assert.Contains("gmrelay-discord-bot:2.7.0", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
+        Assert.Contains("<Version>3.1.1</Version>", File.ReadAllText(Path.Combine(repoRoot, "Directory.Build.props")));
+        Assert.Contains("VERSION: 3.1.1", File.ReadAllText(Path.Combine(repoRoot, ".gitea", "workflows", "deploy.yml")));
+        Assert.Contains("gmrelay-bot:3.1.1", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
+        Assert.Contains("gmrelay-web:3.1.1", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
+        Assert.Contains("gmrelay-discord-bot:3.1.1", File.ReadAllText(Path.Combine(repoRoot, "compose.yaml")));
         Assert.Contains(
-            "v2.7.0",
+            "v3.1.1",
             File.ReadAllText(Path.Combine(repoRoot, "src", "GmRelay.Web", "Components", "Layout", "NavMenu.razor")));
     }
+
+    [Fact]
+    public void EnvExample_ShouldContainDiscordBotToken()
+    {
+        var repoRoot = GetRepoRoot();
+        var envExample = File.ReadAllText(Path.Combine(repoRoot, ".env.example"));
+
+        Assert.Contains("DISCORD_BOT_TOKEN", envExample);
+    }
+
+    [Fact]
+    public void Readme_ShouldNotAskForUnusedDiscordBotClientId()
+    {
+        var repoRoot = GetRepoRoot();
+        var readme = File.ReadAllText(Path.Combine(repoRoot, "README.md"));
+
+        Assert.DoesNotContain("DISCORD_BOT_CLIENT_ID", readme);
+        Assert.Contains("DISCORD_CLIENT_ID", readme);
+    }
+
+    [Fact]
+    public void Compose_ShouldIncludeDiscordHealthcheck()
+    {
+        var repoRoot = GetRepoRoot();
+        var compose = File.ReadAllText(Path.Combine(repoRoot, "compose.yaml"));
+
+        var discordIndex = compose.IndexOf("discord:", StringComparison.Ordinal);
+        Assert.True(discordIndex >= 0, "compose.yaml should contain discord service");
+
+        var nextServiceIndex = compose.IndexOf("  web:", StringComparison.Ordinal);
+        var discordBlock = compose[discordIndex..nextServiceIndex];
+
+        Assert.Contains("healthcheck:", discordBlock);
+        Assert.Contains("test:", discordBlock);
+        Assert.Contains("localhost:8082/health", discordBlock);
+    }
 }

tests/GmRelay.Bot.Tests/Discord/DiscordSessionInteractionModuleSourceTests.cs

@@ -21,6 +21,26 @@ public sealed class DiscordSessionInteractionModuleSourceTests
         Assert.Contains("MessageFlags.Ephemeral", source, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task Module_ShouldUpdateSourceScheduleMessageThroughComponentInteraction()
+    {
+        var source = await ReadRepositoryFileAsync("src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs");
+
+        Assert.Contains("InteractionCallback.DeferredModifyMessage", source, StringComparison.Ordinal);
+        Assert.Contains("DiscordSessionBatchRenderer.Render", source, StringComparison.Ordinal);
+        Assert.Contains("FollowupAsync", source, StringComparison.Ordinal);
+        Assert.Contains("CompleteScheduleUpdateResponseAsync", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Module_ShouldRouteDeleteSessionButtons()
+    {
+        var source = await ReadRepositoryFileAsync("src/GmRelay.DiscordBot/Features/Sessions/DiscordSessionInteractionModule.cs");
+
+        Assert.Contains("[ComponentInteraction(\"delete_session\")]", source, StringComparison.Ordinal);
+        Assert.Contains("DiscordDeleteSessionHandler", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task Module_ShouldRouteRsvpButtonsToNeutralHandler()
     {

tests/GmRelay.Bot.Tests/Discord/DiscordStartupTests.cs

@@ -1,5 +1,8 @@
 using System;
 using System.IO;
+using System.Reflection;
+using GmRelay.DiscordBot.Features.Sessions;
+using NetCord.Services.ApplicationCommands;
 
 namespace GmRelay.Bot.Tests.Discord;
 
@@ -47,6 +50,41 @@ public sealed class DiscordStartupTests
         Assert.Contains(".AddComponentInteractions", program);
         Assert.Contains(".AddGatewayHandlers", program);
         Assert.Contains("AddSlashCommand", program);
+        Assert.Contains("AddModules(typeof(Program).Assembly)", program);
+    }
+
+    [Theory]
+    [InlineData(typeof(DiscordNewSessionCommand), "newsession")]
+    [InlineData(typeof(DiscordListSessionsCommand), "listsessions")]
+    [InlineData(typeof(DiscordRescheduleCommand), "reschedule")]
+    public void DiscordSessionSlashCommands_ShouldBeDeclaredOnModuleMethods(Type moduleType, string commandName)
+    {
+        var executeMethod = moduleType.GetMethod("ExecuteAsync", BindingFlags.Instance | BindingFlags.Public);
+
+        Assert.NotNull(executeMethod);
+
+        var methodAttribute = Assert.Single(executeMethod.GetCustomAttributes<SlashCommandAttribute>(inherit: false));
+        var nameProperty = typeof(SlashCommandAttribute).GetProperty("Name")
+            ?? throw new InvalidOperationException("SlashCommandAttribute should expose command name.");
+
+        Assert.Equal(commandName, nameProperty.GetValue(methodAttribute));
+        Assert.Empty(moduleType.GetCustomAttributes<SlashCommandAttribute>(inherit: false));
+    }
+
+    [Fact]
+    public void DiscordSessionSlashCommands_ShouldBeDiscoverableByNetCordService()
+    {
+        var service = new ApplicationCommandService<SlashCommandContext>();
+
+        service.AddModules(typeof(DiscordNewSessionCommand).Assembly);
+
+        var commandNames = service.GetCommands()
+            .Select(command => command.Name)
+            .ToArray();
+
+        Assert.Contains("newsession", commandNames);
+        Assert.Contains("listsessions", commandNames);
+        Assert.Contains("reschedule", commandNames);
     }
 
     [Fact]
@@ -87,6 +125,14 @@ public sealed class DiscordStartupTests
         Assert.Contains("HandleRsvpHandler", program);
     }
 
+    [Fact]
+    public void Program_ShouldRegisterDiscordHealthCheckHostedService()
+    {
+        var program = ReadProgram();
+        Assert.Contains("DiscordHealthCheckHostedService", program);
+        Assert.Contains("AddHostedService<DiscordHealthCheckHostedService>", program);
+    }
+
     private static string ReadProgram()
     {
         var repoRoot = GetRepoRoot();

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

@@ -0,0 +1,410 @@
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.RescheduleSession;
+using GmRelay.DiscordBot.Rendering;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Sessions.RescheduleSession;
+using GmRelay.Shared.Rendering;
+using NetCord.Rest;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Tests.Features.Landing;
+
+public sealed class DiscordLandingPromisesSmokeTests
+{
+    [Fact]
+    public void Smoke_ShouldCoverDiscordLandingPromisesWithoutExternalDiscordApi()
+    {
+        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 = DiscordLandingSmokeScenario.Publish(parseResult, SessionNotificationMode.GroupAndDirect);
+        var publishedCallbacks = CallbackData(scenario.LastMessage.ActionRows);
+
+        Assert.Contains(scenario.LastMessage.Embeds, e => e.Title!.Contains("Landing Promise Smoke"));
+        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(scenario.LastMessage.Embeds, embed => embed.Title!.Contains(session.ScheduledAt.FormatMoscow()));
+        });
+
+        var firstSessionId = scenario.Sessions[0].Id;
+        var alice = scenario.Join(firstSessionId, 1001UL, "Alice");
+        var bob = scenario.Join(firstSessionId, 1002UL, "Bob");
+        var carol = scenario.Join(firstSessionId, 1003UL, "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));
+
+        var firstSessionEmbed = scenario.LastMessage.Embeds.First(e => e.Title!.Contains(scenario.Sessions[0].ScheduledAt.FormatMoscow()));
+        Assert.Equal("2/2", firstSessionEmbed.Fields!.First().Value);
+        Assert.Contains("Alice", firstSessionEmbed.Description);
+        Assert.Contains("Bob", firstSessionEmbed.Description);
+        Assert.Contains("Carol", firstSessionEmbed.Description);
+
+        scenario.Leave(firstSessionId, alice);
+
+        Assert.False(scenario.HasParticipant(firstSessionId, alice));
+        Assert.Equal(ParticipantRegistrationStatus.Active, scenario.RegistrationStatus(firstSessionId, carol));
+        firstSessionEmbed = scenario.LastMessage.Embeds.First(e => e.Title!.Contains(scenario.Sessions[0].ScheduledAt.FormatMoscow()));
+        Assert.DoesNotContain("Alice", firstSessionEmbed.Description);
+        Assert.Contains("Carol", firstSessionEmbed.Description);
+
+        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(GmRelay.Shared.Domain.RsvpStatus.Pending, scenario.RsvpStatus(firstSessionId, bob));
+        Assert.Equal(GmRelay.Shared.Domain.RsvpStatus.Pending, scenario.RsvpStatus(firstSessionId, carol));
+        Assert.Contains(scenario.LastMessage.Embeds, e => e.Title!.Contains(options[1].ProposedAt.UtcDateTime.FormatMoscow()));
+
+        Assert.Collection(
+            scenario.Messenger.DirectMessages.Select(message => message.DiscordId).Order(),
+            discordId => Assert.Equal(1002UL, discordId),
+            discordId => Assert.Equal(1003UL, discordId));
+        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(scenario.LastMessage.Embeds, e => e.Title!.Contains("Landing Promise Smoke - Dashboard Sync"));
+        firstSessionEmbed = scenario.LastMessage.Embeds.First(e => e.Title!.Contains(scenario.Sessions[0].ScheduledAt.FormatMoscow()));
+        Assert.Contains("Bob", firstSessionEmbed.Description);
+        Assert.Contains("Carol", firstSessionEmbed.Description);
+    }
+
+    private static string BuildRecurringSessionCommand() =>
+        string.Join(
+            '\n',
+            "/newsession",
+            "Название: Landing Promise Smoke",
+            "Время: 15.05.2026 19:30",
+            "Игр: 3",
+            "Интервал: 7",
+            "Мест: 2",
+            "Ссылка: https://example.test/table");
+
+    private static IReadOnlyList<string> CallbackData(IReadOnlyList<ActionRowProperties> actionRows) =>
+        actionRows
+            .SelectMany(row => row)
+            .OfType<ButtonProperties>()
+            .Select(button => button.CustomId)
+            .OfType<string>()
+            .ToList();
+
+    private static IReadOnlyList<string> CallbackData(InlineKeyboardMarkup markup) =>
+        markup.InlineKeyboard
+            .SelectMany(row => row)
+            .Select(button => button.CallbackData)
+            .OfType<string>()
+            .ToList();
+
+    private sealed class DiscordLandingSmokeScenario
+    {
+        private readonly List<SmokeSession> sessions;
+        private readonly List<SmokeParticipant> participants = [];
+        private readonly SessionNotificationMode notificationMode;
+
+        private DiscordLandingSmokeScenario(
+            string title,
+            IReadOnlyList<DateTimeOffset> scheduledTimes,
+            int? maxPlayers,
+            string joinLink,
+            SessionNotificationMode notificationMode)
+        {
+            Title = title;
+            this.notificationMode = notificationMode;
+            sessions = scheduledTimes
+                .Select(scheduledAt => new SmokeSession(
+                    Guid.NewGuid(),
+                    scheduledAt.UtcDateTime,
+                    SessionStatus.Planned,
+                    maxPlayers,
+                    joinLink))
+                .ToList();
+        }
+
+        public string Title { get; private set; }
+        public FakeDiscordMessenger Messenger { get; } = new();
+        public IReadOnlyList<SmokeSession> Sessions => sessions;
+        public FakeDiscordMessage LastMessage => Messenger.LastMessage;
+
+        public static DiscordLandingSmokeScenario Publish(
+            NewSessionParseResult parseResult,
+            SessionNotificationMode notificationMode)
+        {
+            var scenario = new DiscordLandingSmokeScenario(
+                parseResult.Title!,
+                parseResult.ScheduledTimes,
+                parseResult.MaxPlayers,
+                parseResult.Link!,
+                notificationMode);
+
+            scenario.RenderBatch();
+            return scenario;
+        }
+
+        public Guid Join(Guid sessionId, ulong discordId, string displayName)
+        {
+            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,
+                discordId,
+                displayName,
+                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,
+                    null,
+                    0))
+                .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.DiscordId, 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,
+                        session.JoinLink))
+                    .ToList(),
+                participants
+                    .Select(participant => new ParticipantBatchDto(
+                        participant.SessionId,
+                        participant.DisplayName,
+                        null,
+                        participant.RegistrationStatus))
+                    .ToList());
+            var renderResult = DiscordSessionBatchRenderer.Render(view);
+
+            if (Messenger.HasPublishedMessage)
+            {
+                Messenger.EditBatchMessage(renderResult.Embeds, renderResult.ActionRows);
+            }
+            else
+            {
+                Messenger.PublishBatchMessage(renderResult.Embeds, renderResult.ActionRows);
+            }
+        }
+    }
+
+    private sealed class FakeDiscordMessenger
+    {
+        private const int BatchMessageId = 7001;
+
+        public List<FakeDiscordMessage> Sends { get; } = [];
+        public List<FakeDiscordMessage> Edits { get; } = [];
+        public List<FakeDirectMessage> DirectMessages { get; } = [];
+        public bool HasPublishedMessage => Sends.Count > 0;
+        public FakeDiscordMessage LastMessage => Edits.Count > 0 ? Edits[^1] : Sends[^1];
+
+        public void PublishBatchMessage(IReadOnlyList<EmbedProperties> embeds, IReadOnlyList<ActionRowProperties> actionRows) =>
+            Sends.Add(new FakeDiscordMessage(BatchMessageId, embeds, actionRows));
+
+        public void EditBatchMessage(IReadOnlyList<EmbedProperties> embeds, IReadOnlyList<ActionRowProperties> actionRows) =>
+            Edits.Add(new FakeDiscordMessage(BatchMessageId, embeds, actionRows));
+
+        public void SendDirectMessage(ulong discordId, string text) =>
+            DirectMessages.Add(new FakeDirectMessage(discordId, text));
+    }
+
+    private sealed record FakeDiscordMessage(
+        int MessageId,
+        IReadOnlyList<EmbedProperties> Embeds,
+        IReadOnlyList<ActionRowProperties> ActionRows);
+
+    private sealed record FakeDirectMessage(ulong DiscordId, string Text);
+
+    private sealed record SmokeSession(
+        Guid Id,
+        DateTime ScheduledAt,
+        string Status,
+        int? MaxPlayers,
+        string JoinLink)
+    {
+        public DateTime ScheduledAt { get; set; } = ScheduledAt;
+    }
+
+    private sealed record SmokeParticipant(
+        Guid SessionId,
+        Guid PlayerId,
+        ulong DiscordId,
+        string DisplayName,
+        string RegistrationStatus,
+        string RsvpStatus,
+        int JoinOrder)
+    {
+        public string RegistrationStatus { get; set; } = RegistrationStatus;
+        public string RsvpStatus { get; set; } = RsvpStatus;
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/PlatformNeutralSessionInteractionCommandTests.cs

@@ -13,6 +13,7 @@ public sealed class PlatformNeutralSessionInteractionCommandTests
         AssertProperty<JoinSessionCommand>("InteractionId", typeof(string));
         AssertProperty<JoinSessionCommand>("Group", typeof(PlatformGroup));
         AssertProperty<JoinSessionCommand>("ScheduleMessage", typeof(PlatformMessageRef));
+        AssertProperty<JoinSessionCommand>("DeferScheduleUpdate", typeof(bool));
         AssertNoTelegramSpecificProperties<JoinSessionCommand>();
     }
 
@@ -24,12 +25,29 @@ public sealed class PlatformNeutralSessionInteractionCommandTests
         AssertProperty<LeaveSessionCommand>("InteractionId", typeof(string));
         AssertProperty<LeaveSessionCommand>("Group", typeof(PlatformGroup));
         AssertProperty<LeaveSessionCommand>("ScheduleMessage", typeof(PlatformMessageRef));
+        AssertProperty<LeaveSessionCommand>("DeferScheduleUpdate", typeof(bool));
         AssertNoTelegramSpecificProperties<LeaveSessionCommand>();
     }
 
+    [Fact]
+    public void SessionInteractionResult_ShouldExposeReplyTextAndUpdatedView()
+    {
+        var resultType = typeof(JoinSessionCommand).Assembly.GetType(
+            "GmRelay.Shared.Features.Sessions.CreateSession.SessionInteractionResult");
+
+        Assert.NotNull(resultType);
+        AssertProperty(resultType, "ReplyText", typeof(string));
+        AssertProperty(resultType, "UpdatedView", typeof(GmRelay.Shared.Rendering.SessionBatchViewModel));
+    }
+
     private static void AssertProperty<T>(string name, Type expectedType)
     {
-        var property = Assert.Single(typeof(T).GetProperties(), property => property.Name == name);
+        AssertProperty(typeof(T), name, expectedType);
+    }
+
+    private static void AssertProperty(Type type, string name, Type expectedType)
+    {
+        var property = Assert.Single(type.GetProperties(), property => property.Name == name);
 
         Assert.Equal(expectedType, property.PropertyType);
     }

tests/GmRelay.Bot.Tests/Infrastructure/Database/PlatformIdentityMigrationTests.cs

@@ -91,6 +91,15 @@ public sealed class PlatformIdentityMigrationTests
         Assert.Contains("platform", service, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task WebSessionService_ShouldAuthorizeGroupsAcrossLinkedIdentities()
+    {
+        var service = await ReadRepositoryFileAsync("src/GmRelay.Web/Services/SessionService.cs");
+
+        Assert.Contains("_ResolveLinkedPlayerIdsAsync", service, StringComparison.Ordinal);
+        Assert.Contains("player_id = ANY(@PlayerIds)", service, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task AttendanceStatsFunction_ShouldReferenceExternalUsername()
     {
@@ -108,6 +117,28 @@ public sealed class PlatformIdentityMigrationTests
         Assert.Contains("telegram_id DROP NOT NULL", migration, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task MigrationV024_ShouldDeprecateTelegramColumns()
+    {
+        var migration = await ReadRepositoryFileAsync("src/GmRelay.Bot/Migrations/V024__deprecate_telegram_columns.sql");
+
+        Assert.Contains("UPDATE players", migration, StringComparison.Ordinal);
+        Assert.Contains("UPDATE game_groups", migration, StringComparison.Ordinal);
+        Assert.Contains("DEPRECATED", migration, StringComparison.Ordinal);
+        Assert.Contains("calendar_subscriptions", migration, StringComparison.Ordinal);
+        Assert.Contains("user_platform", migration, StringComparison.Ordinal);
+        Assert.Contains("user_external_id", migration, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task MigrationV025_ShouldBackfillRescheduleProposals()
+    {
+        var migration = await ReadRepositoryFileAsync("src/GmRelay.Bot/Migrations/V025__reschedule_proposals_telegram_external.sql");
+
+        Assert.Contains("reschedule_proposals", migration, StringComparison.Ordinal);
+        Assert.Contains("proposed_by_external_user_id", migration, StringComparison.Ordinal);
+    }
+
     private static async Task<string> ReadRepositoryFileAsync(string relativePath)
     {
         var directory = new DirectoryInfo(AppContext.BaseDirectory);

tests/GmRelay.Bot.Tests/Infrastructure/Health/DiscordHealthCheckHostedServiceTests.cs

@@ -0,0 +1,53 @@
+using System.Net;
+using System.Net.Sockets;
+using GmRelay.DiscordBot.Infrastructure.Health;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace GmRelay.Bot.Tests.Infrastructure.Health;
+
+public sealed class DiscordHealthCheckHostedServiceTests : IDisposable
+{
+    private readonly DiscordHealthCheckHostedService _service;
+    private readonly int _port;
+
+    public DiscordHealthCheckHostedServiceTests()
+    {
+        _port = GetAvailablePort();
+        var config = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["HealthCheck:Prefix"] = $"http://localhost:{_port}/"
+            })
+            .Build();
+
+        _service = new DiscordHealthCheckHostedService(
+            NullLogger<DiscordHealthCheckHostedService>.Instance,
+            config);
+    }
+
+    public void Dispose()
+    {
+        _service.StopAsync(CancellationToken.None).Wait(TimeSpan.FromSeconds(5));
+    }
+
+    [Fact]
+    public async Task HealthEndpoint_ShouldReturn200_WhenServiceIsRunning()
+    {
+        await _service.StartAsync(CancellationToken.None);
+
+        using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(5) };
+        var response = await client.GetAsync($"http://localhost:{_port}/health");
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    private static int GetAvailablePort()
+    {
+        var listener = new TcpListener(IPAddress.Loopback, 0);
+        listener.Start();
+        var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+        listener.Stop();
+        return port;
+    }
+}

tests/GmRelay.Bot.Tests/Infrastructure/Scheduling/SessionSchedulerServiceTests.cs

@@ -149,6 +149,68 @@ public sealed class SessionSchedulerServiceTests
         Assert.Null(ex);
     }
 
+    [Fact]
+    public async Task TickAsync_WhenHandlerThrows_BackoffsForDuration()
+    {
+        var sessionId = Guid.NewGuid();
+        var now = new DateTimeOffset(2026, 5, 15, 10, 0, 0, TimeSpan.Zero);
+        _clock.UtcNow = now;
+        _store.SessionsNeedingConfirmation = [sessionId];
+        _confirmationHandler.ThrowFor.Add(sessionId);
+
+        var sut = CreateSut();
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Single(_confirmationHandler.Calls);
+
+        // Second tick immediately — should be backed off
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Single(_confirmationHandler.Calls);
+    }
+
+    [Fact]
+    public async Task TickAsync_WhenHandlerThrows_AfterBackoffRetriesAgain()
+    {
+        var sessionId = Guid.NewGuid();
+        var now = new DateTimeOffset(2026, 5, 15, 10, 0, 0, TimeSpan.Zero);
+        _clock.UtcNow = now;
+        _store.SessionsNeedingConfirmation = [sessionId];
+        _confirmationHandler.ThrowFor.Add(sessionId);
+
+        var sut = CreateSut();
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Single(_confirmationHandler.Calls);
+
+        // Advance clock past backoff duration (15 min)
+        _clock.UtcNow = now.AddMinutes(16);
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Equal(2, _confirmationHandler.Calls.Count);
+    }
+
+    [Fact]
+    public async Task TickAsync_WhenHandlerSucceedsAfterBackoff_ClearsBackoff()
+    {
+        var sessionId = Guid.NewGuid();
+        var now = new DateTimeOffset(2026, 5, 15, 10, 0, 0, TimeSpan.Zero);
+        _clock.UtcNow = now;
+        _store.SessionsNeedingConfirmation = [sessionId];
+        _confirmationHandler.ThrowFor.Add(sessionId);
+
+        var sut = CreateSut();
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Single(_confirmationHandler.Calls);
+
+        // Remove throw condition, advance past backoff
+        _confirmationHandler.ThrowFor.Remove(sessionId);
+        _clock.UtcNow = now.AddMinutes(16);
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Equal(2, _confirmationHandler.Calls.Count);
+
+        // Next tick should still call because backoff was cleared on success
+        _clock.UtcNow = now.AddMinutes(17);
+        await sut.TickAsync(CancellationToken.None);
+        Assert.Equal(3, _confirmationHandler.Calls.Count);
+    }
+
     private sealed class FakeSendConfirmationHandler : ISendConfirmationHandler
     {
         public List<Guid> Calls { get; } = [];

tests/GmRelay.Bot.Tests/Infrastructure/Telegram/TelegramTopicIntegrationSmokeTests.cs

@@ -60,6 +60,19 @@ public sealed class TelegramTopicIntegrationSmokeTests
         Assert.Contains("ExternalThreadId", telegramMessenger, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task WebTemplateBatches_ShouldCreateAndPersistForumTopic()
+    {
+        var sessionService = await ReadRepositoryFileAsync("src/GmRelay.Web/Services/SessionService.cs");
+
+        Assert.Contains("GetChat", sessionService, StringComparison.Ordinal);
+        Assert.Contains("CreateForumTopic", sessionService, StringComparison.Ordinal);
+        Assert.Contains("thread_id, topic_created_by_bot", sessionService, StringComparison.Ordinal);
+        Assert.Contains("ThreadId = messageThreadId", sessionService, StringComparison.Ordinal);
+        Assert.Contains("TopicCreatedByBot = topicCreatedByBot", sessionService, StringComparison.Ordinal);
+        Assert.Contains("messageThreadId: messageThreadId", sessionService, StringComparison.Ordinal);
+    }
+
     private static async Task<string> ReadRepositoryFileAsync(string relativePath)
     {
         var directory = new DirectoryInfo(AppContext.BaseDirectory);

tests/GmRelay.Bot.Tests/Rendering/DiscordSessionBatchRendererTests.cs

@@ -136,4 +136,94 @@ public sealed class DiscordSessionBatchRendererTests
         Assert.Single(embeds);
         Assert.Single(actionRows); // not cancelled → actions present
     }
+
+    [Fact]
+    public void Render_ShouldUseBlueColorForConfirmedSessions()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Confirmed, 4, "https://example.com/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+
+        Assert.Equal(0x5865F2, embeds[0].Color.RawValue);
+    }
+
+    [Fact]
+    public void Render_ShouldShowEmptyPlayerDescription()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "https://example.com/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+
+        Assert.Contains("Пока никто не записался", embeds[0].Description);
+    }
+
+    [Fact]
+    public void Render_ShouldSetEmbedUrlWhenJoinLinkPresent()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "https://example.com/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+
+        Assert.Equal("https://example.com/game", embeds[0].Url);
+    }
+
+    [Fact]
+    public void Render_ShouldNormalizeBareDomainJoinLinkForEmbedUrl()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "mobaxterm.mobatek.net/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+
+        Assert.Equal("https://mobaxterm.mobatek.net/game", embeds[0].Url);
+    }
+
+    [Fact]
+    public void Render_ShouldNotSetEmbedUrlWhenJoinLinkIsNotHttpUrl()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "test") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+
+        Assert.Null(embeds[0].Url);
+    }
+
+    [Fact]
+    public void Render_ShouldEmbedCorrectFieldValues()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "https://example.com/game") };
+        var participants = new[]
+        {
+            new ParticipantBatchDto(sessionId, "Alice", "alice", ParticipantRegistrationStatus.Active),
+            new ParticipantBatchDto(sessionId, "Bob", null, ParticipantRegistrationStatus.Waitlisted)
+        };
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (embeds, _) = DiscordSessionBatchRenderer.Render(view);
+        var embed = embeds[0];
+        var fields = embed.Fields!.ToList();
+
+        Assert.Equal(3, fields.Count);
+        Assert.Equal("👥 Заполненность", fields[0].Name);
+        Assert.Equal("1/4", fields[0].Value);
+        Assert.Equal("⏳ Лист ожидания", fields[1].Name);
+        Assert.Equal("1", fields[1].Value);
+        Assert.Equal("📊 Статус", fields[2].Name);
+        Assert.Equal("Запланирована", fields[2].Value);
+    }
 }

tests/GmRelay.Bot.Tests/Rendering/SessionBatchViewBuilderTests.cs

@@ -110,4 +110,43 @@ public sealed class SessionBatchViewBuilderTests
         Assert.Equal("Alice", player.DisplayName);
         Assert.Equal("alice", player.TelegramUsername);
     }
+
+    [Fact]
+    public void Build_ShouldHandleEmptySessions()
+    {
+        var result = SessionBatchViewBuilder.Build("Empty", Array.Empty<SessionBatchDto>(), Array.Empty<ParticipantBatchDto>());
+        Assert.Equal("Empty", result.Title);
+        Assert.Empty(result.Sessions);
+    }
+
+    [Fact]
+    public void Build_ShouldHandleConfirmedStatus()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Confirmed, 4, "https://example.com/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var result = SessionBatchViewBuilder.Build("Test", sessions, participants);
+
+        Assert.Equal(SessionStatus.Confirmed, result.Sessions[0].Status);
+        Assert.Equal(2, result.Sessions[0].AvailableActions.Count);
+        Assert.Equal("join_session", result.Sessions[0].AvailableActions[0].ActionKey);
+        Assert.Equal("leave_session", result.Sessions[0].AvailableActions[1].ActionKey);
+        Assert.Equal(sessionId, result.Sessions[0].AvailableActions[0].SessionId);
+        Assert.Equal(sessionId, result.Sessions[0].AvailableActions[1].SessionId);
+    }
+
+    [Fact]
+    public void Build_ShouldHandleNullMaxPlayers()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, null, "https://example.com/game") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var result = SessionBatchViewBuilder.Build("Test", sessions, participants);
+
+        Assert.Null(result.Sessions[0].MaxPlayers);
+        var joinAction = result.Sessions[0].AvailableActions.First(a => a.ActionKey == "join_session");
+        Assert.DoesNotContain("ожидания", joinAction.Label);
+    }
 }

tests/GmRelay.Bot.Tests/Rendering/TelegramSessionBatchRendererTests.cs

@@ -77,4 +77,75 @@ public sealed class TelegramSessionBatchRendererTests
 
         Assert.Contains("ожидания", joinButton.Text);
     }
+
+    [Fact]
+    public void Render_ShouldHandleEmptySessions()
+    {
+        var view = SessionBatchViewBuilder.Build("Empty", Array.Empty<SessionBatchDto>(), Array.Empty<ParticipantBatchDto>());
+        var (text, markup) = TelegramSessionBatchRenderer.Render(view);
+
+        Assert.Contains("Empty", text);
+        Assert.DoesNotContain("📅", text);
+        Assert.Empty(markup.InlineKeyboard);
+    }
+
+    [Fact]
+    public void Render_ShouldEncodeHtmlInTitle()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("<script>alert(1)</script>", sessions, participants);
+        var (text, _) = TelegramSessionBatchRenderer.Render(view);
+
+        Assert.Contains("&lt;script&gt;alert(1)&lt;/script&gt;", text);
+        Assert.DoesNotContain("<script>", text);
+    }
+
+    [Fact]
+    public void Render_ShouldShowConfirmedStatusButtons()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Confirmed, 4, "") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (_, markup) = TelegramSessionBatchRenderer.Render(view);
+
+        var buttons = markup.InlineKeyboard.SelectMany(row => row).ToList();
+        Assert.Equal(2, buttons.Count);
+        Assert.Contains(buttons, b => b.CallbackData == $"join_session:{sessionId}");
+        Assert.Contains(buttons, b => b.CallbackData == $"leave_session:{sessionId}");
+    }
+
+    [Fact]
+    public void Render_ShouldHandleNoJoinLink()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (text, markup) = TelegramSessionBatchRenderer.Render(view);
+        var buttons = markup.InlineKeyboard.SelectMany(row => row).ToList();
+
+        Assert.DoesNotContain("Ссылка на игру", text);
+        Assert.Contains("📅", text);
+        Assert.Equal(2, buttons.Count);
+    }
+
+    [Fact]
+    public void Render_ShouldEncodeHtmlInJoinLink()
+    {
+        var sessionId = Guid.NewGuid();
+        var sessions = new[] { new SessionBatchDto(sessionId, DateTime.UtcNow, SessionStatus.Planned, 4, "https://example.com/test?a=1&b=2") };
+        var participants = Array.Empty<ParticipantBatchDto>();
+
+        var view = SessionBatchViewBuilder.Build("Test", sessions, participants);
+        var (text, _) = TelegramSessionBatchRenderer.Render(view);
+
+        Assert.Contains("a=1&amp;b=2", text);
+        Assert.DoesNotContain("a=1&b=2" + "\"", text); // make sure & is encoded
+    }
 }

tests/GmRelay.Bot.Tests/Web/AuthorizedSessionServiceTests.cs

@@ -1,10 +1,29 @@
 using GmRelay.Web.Services;
+using System.Security.Claims;
+using Microsoft.AspNetCore.Http;
 using GmRelay.Shared.Domain;
 
 namespace GmRelay.Bot.Tests.Web;
 
 public sealed class AuthorizedSessionServiceTests
 {
+    private static IHttpContextAccessor CreateAccessor(string externalUserId, string? name = null)
+    {
+        var claims = new List<Claim>
+        {
+            new Claim(ClaimTypes.NameIdentifier, externalUserId),
+            new Claim("TelegramId", externalUserId),
+            new Claim("Platform", "Telegram")
+        };
+        if (name is not null)
+            claims.Add(new Claim(ClaimTypes.Name, name));
+
+        var identity = new ClaimsIdentity(claims, "Test");
+        var principal = new ClaimsPrincipal(identity);
+        var httpContext = new DefaultHttpContext { User = principal };
+        return new HttpContextAccessor { HttpContext = httpContext };
+    }
+
     [Fact]
     public async Task GetUpcomingSessionsForGmAsync_ReturnsSessions_WhenGroupBelongsToGm()
     {
@@ -19,9 +38,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var sessions = await service.GetUpcomingSessionsForGmAsync(groupId, gmId);
+        var sessions = await service.GetUpcomingSessionsForCurrentUserAsync(groupId);
 
         Assert.NotNull(sessions);
         Assert.Single(sessions);
@@ -47,9 +67,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, coGmId, GroupManagerRole.CoGm)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(coGmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var sessions = await service.GetUpcomingSessionsForGmAsync(groupId, coGmId);
+        var sessions = await service.GetUpcomingSessionsForCurrentUserAsync(groupId);
 
         Assert.NotNull(sessions);
         Assert.Single(sessions);
@@ -65,9 +86,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, 42, "Alpha", 2002L)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var sessions = await service.GetUpcomingSessionsForGmAsync(groupId, 1001L);
+        var sessions = await service.GetUpcomingSessionsForCurrentUserAsync(groupId);
 
         Assert.Null(sessions);
     }
@@ -87,9 +109,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var session = await service.GetSessionForGmAsync(sessionId, gmId);
+        var session = await service.GetSessionForCurrentUserAsync(sessionId);
 
         Assert.NotNull(session);
         Assert.Equal(sessionId, session.Id);
@@ -109,9 +132,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var session = await service.GetSessionForGmAsync(sessionId, 1001L);
+        var session = await service.GetSessionForCurrentUserAsync(sessionId);
 
         Assert.Null(session);
     }
@@ -130,9 +154,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.UpdateSessionForGmAsync(sessionId, 1001L, "Updated", DateTime.UtcNow.AddDays(1), "https://example.test/b", 5);
+        var action = () => service.UpdateSessionForCurrentUserAsync(sessionId, "Updated", DateTime.UtcNow.AddDays(1), "https://example.test/b", 5);
 
         await Assert.ThrowsAsync<SessionAccessDeniedException>(action);
         Assert.False(store.UpdateCalled);
@@ -154,9 +179,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateSessionForGmAsync(sessionId, gmId, "Updated", scheduledAt, "https://example.test/b", 5);
+        await service.UpdateSessionForCurrentUserAsync(sessionId, "Updated", scheduledAt, "https://example.test/b", 5);
 
         Assert.True(store.UpdateCalled);
         Assert.Equal(groupId, store.LastUpdatedGroupId);
@@ -183,9 +209,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", originalTime, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateSessionForGmAsync(sessionId, gmId, "Updated Title", originalTime, "https://example.test/a", 4);
+        await service.UpdateSessionForCurrentUserAsync(sessionId, "Updated Title", originalTime, "https://example.test/a", 4);
 
         Assert.Single(store.LogEntries);
         Assert.Equal("Title", store.LogEntries[0].ChangeType);
@@ -209,10 +236,11 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", originalTime, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
         var newTime = originalTime.AddDays(1);
-        await service.UpdateSessionForGmAsync(sessionId, gmId, "Updated Title", newTime, "https://example.test/b", 5);
+        await service.UpdateSessionForCurrentUserAsync(sessionId, "Updated Title", newTime, "https://example.test/b", 5);
 
         Assert.Equal(4, store.LogEntries.Count);
         Assert.Contains(store.LogEntries, e => e.ChangeType == "Title");
@@ -237,9 +265,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", originalTime, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateSessionForGmAsync(sessionId, gmId, "Session A", originalTime, "https://example.test/a", 4);
+        await service.UpdateSessionForCurrentUserAsync(sessionId, "Session A", originalTime, "https://example.test/a", 4);
 
         Assert.Empty(store.LogEntries);
     }
@@ -259,9 +288,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var history = await service.GetSessionHistoryForGmAsync(sessionId, gmId);
+        var history = await service.GetSessionHistoryForCurrentUserAsync(sessionId);
 
         Assert.NotNull(history);
         Assert.Empty(history);
@@ -281,9 +311,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var history = await service.GetSessionHistoryForGmAsync(sessionId, 1001L);
+        var history = await service.GetSessionHistoryForCurrentUserAsync(sessionId);
 
         Assert.Null(history);
     }
@@ -303,9 +334,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42, 4, 3, 1)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.PromoteWaitlistedPlayerForGmAsync(sessionId, gmId);
+        await service.PromoteWaitlistedPlayerForCurrentUserAsync(sessionId);
 
         Assert.True(store.PromoteCalled);
         Assert.Equal(groupId, store.LastPromotedGroupId);
@@ -326,9 +358,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.UpdateBatchDetailsForGmAsync(batchId, 1001L, "Updated", "https://example.test/b");
+        var action = () => service.UpdateBatchDetailsForCurrentUserAsync(batchId, "Updated", "https://example.test/b");
 
         await Assert.ThrowsAsync<SessionAccessDeniedException>(action);
         Assert.False(store.UpdateBatchDetailsCalled);
@@ -349,9 +382,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateBatchDetailsForGmAsync(batchId, gmId, "Updated", "https://example.test/b");
+        await service.UpdateBatchDetailsForCurrentUserAsync(batchId, "Updated", "https://example.test/b");
 
         Assert.True(store.UpdateBatchDetailsCalled);
         Assert.Equal(batchId, store.LastUpdatedBatchId);
@@ -380,9 +414,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, coGmId, GroupManagerRole.CoGm)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(coGmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateBatchDetailsForGmAsync(batchId, coGmId, "Updated", "https://example.test/b");
+        await service.UpdateBatchDetailsForCurrentUserAsync(batchId, "Updated", "https://example.test/b");
 
         Assert.True(store.UpdateBatchDetailsCalled);
         Assert.Equal(batchId, store.LastUpdatedBatchId);
@@ -400,9 +435,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, 42, "Alpha", ownerId)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(ownerId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.AddCoGmForOwnerAsync(groupId, ownerId, coGmId, "Assistant GM", "assistant");
+        await service.AddCoGmForOwnerAsync(groupId, "Telegram", coGmId.ToString(), "Assistant GM", "assistant");
 
         Assert.True(store.AddCoGmCalled);
         Assert.Equal(groupId, store.LastAddedCoGmGroupId);
@@ -427,9 +463,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, coGmId, GroupManagerRole.CoGm)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(coGmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.AddCoGmForOwnerAsync(groupId, coGmId, newCoGmId, "Second Assistant", null);
+        var action = () => service.AddCoGmForOwnerAsync(groupId, "Telegram", newCoGmId.ToString(), "Second Assistant", null);
 
         await Assert.ThrowsAsync<SessionAccessDeniedException>(action);
         Assert.False(store.AddCoGmCalled);
@@ -450,9 +487,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, coGmId, GroupManagerRole.CoGm)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(ownerId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.RemoveCoGmForOwnerAsync(groupId, ownerId, coGmId);
+        await service.RemoveCoGmForOwnerAsync(groupId, "Telegram", coGmId.ToString());
 
         Assert.True(store.RemoveCoGmCalled);
         Assert.Equal(groupId, store.LastRemovedCoGmGroupId);
@@ -473,9 +511,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.UpdateBatchNotificationModeForGmAsync(batchId, 1001L, SessionNotificationMode.GroupOnly);
+        var action = () => service.UpdateBatchNotificationModeForCurrentUserAsync(batchId, SessionNotificationMode.GroupOnly);
 
         await Assert.ThrowsAsync<SessionAccessDeniedException>(action);
         Assert.False(store.UpdateBatchNotificationModeCalled);
@@ -496,9 +535,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.UpdateBatchNotificationModeForGmAsync(batchId, gmId, SessionNotificationMode.GroupOnly);
+        await service.UpdateBatchNotificationModeForCurrentUserAsync(batchId, SessionNotificationMode.GroupOnly);
 
         Assert.True(store.UpdateBatchNotificationModeCalled);
         Assert.Equal(batchId, store.LastUpdatedNotificationBatchId);
@@ -521,9 +561,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.RescheduleBatchForGmAsync(batchId, gmId, DateTime.UtcNow.AddDays(7), intervalDays: 0);
+        var action = () => service.RescheduleBatchForCurrentUserAsync(batchId, DateTime.UtcNow.AddDays(7), intervalDays: 0);
 
         await Assert.ThrowsAsync<ArgumentOutOfRangeException>(action);
         Assert.False(store.RescheduleBatchCalled);
@@ -545,9 +586,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.RescheduleBatchForGmAsync(batchId, gmId, firstScheduledAt, intervalDays: 14);
+        await service.RescheduleBatchForCurrentUserAsync(batchId, firstScheduledAt, intervalDays: 14);
 
         Assert.True(store.RescheduleBatchCalled);
         Assert.Equal(batchId, store.LastRescheduledBatchId);
@@ -571,9 +613,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(Guid.NewGuid(), groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", batchId, 10, 42, 4, 1, 0)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.CloneBatchForGmAsync(batchId, gmId, BatchCloneInterval.NextWeek);
+        await service.CloneBatchForCurrentUserAsync(batchId, BatchCloneInterval.NextWeek);
 
         Assert.True(store.CloneBatchCalled);
         Assert.Equal(batchId, store.LastClonedBatchId);
@@ -591,11 +634,11 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, 42, "Alpha", gmId)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.CreateCampaignTemplateForGmAsync(
+        await service.CreateCampaignTemplateForCurrentUserAsync(
             groupId,
-            gmId,
             new CreateCampaignTemplateRequest(
                 "  Weekly arc  ",
                 "  Kingmaker  ",
@@ -626,11 +669,11 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, 42, "Alpha", gmId)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.CreateCampaignTemplateForGmAsync(
+        await service.CreateCampaignTemplateForCurrentUserAsync(
             groupId,
-            gmId,
             new CreateCampaignTemplateRequest(
                 "Open table",
                 "West Marches",
@@ -653,11 +696,11 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(groupId, 42, "Alpha", 2002L)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.CreateCampaignTemplateForGmAsync(
+        var action = () => service.CreateCampaignTemplateForCurrentUserAsync(
             groupId,
-            1001L,
             new CreateCampaignTemplateRequest(
                 "Weekly arc",
                 "Kingmaker",
@@ -687,9 +730,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(templateId, groupId, "Weekly arc", "Kingmaker", "https://example.test/kingmaker", 6, 7, 5, SessionNotificationModeExtensions.GroupOnlyValue, DateTime.UtcNow, DateTime.UtcNow)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor(gmId.ToString());
+        var service = new AuthorizedSessionService(store, accessor);
 
-        await service.CreateBatchFromCampaignTemplateForGmAsync(templateId, gmId, firstScheduledAt);
+        await service.CreateBatchFromCampaignTemplateForCurrentUserAsync(templateId, firstScheduledAt);
 
         Assert.True(store.CreateBatchFromTemplateCalled);
         Assert.Equal(templateId, store.LastCreatedBatchTemplateId);
@@ -711,9 +755,10 @@ public sealed class AuthorizedSessionServiceTests
             [
                 new(templateId, groupId, "Weekly arc", "Kingmaker", "https://example.test/kingmaker", 6, 7, 5, SessionNotificationModeExtensions.GroupOnlyValue, DateTime.UtcNow, DateTime.UtcNow)
             ]);
-        var service = new AuthorizedSessionService(store);
+        var accessor = CreateAccessor("1001");
+        var service = new AuthorizedSessionService(store, accessor);
 
-        var action = () => service.CreateBatchFromCampaignTemplateForGmAsync(templateId, 1001L, DateTime.UtcNow.AddDays(3));
+        var action = () => service.CreateBatchFromCampaignTemplateForCurrentUserAsync(templateId, DateTime.UtcNow.AddDays(3));
 
         await Assert.ThrowsAsync<SessionAccessDeniedException>(action);
         Assert.False(store.CreateBatchFromTemplateCalled);
@@ -1019,7 +1064,7 @@ public sealed class AuthorizedSessionServiceTests
 
         public Task LogSessionChangeAsync(Guid sessionId, long actorTelegramId, string actorName, string changeType, string? oldValue, string? newValue)
         {
-            var entry = new SessionAuditLogEntry(Guid.NewGuid(), sessionId, actorTelegramId, actorName, changeType, oldValue, newValue, DateTime.UtcNow);
+            var entry = new SessionAuditLogEntry(Guid.NewGuid(), sessionId, actorTelegramId.ToString(), actorName, changeType, oldValue, newValue, DateTime.UtcNow);
             LogEntries.Add(entry);
             LastLogSessionId = sessionId;
             LastLogActorTelegramId = actorTelegramId;
@@ -1033,12 +1078,77 @@ public sealed class AuthorizedSessionServiceTests
         public Task<List<SessionAuditLogEntry>> GetSessionHistoryAsync(Guid sessionId) =>
             Task.FromResult(LogEntries.Where(e => e.SessionId == sessionId).OrderByDescending(e => e.ChangedAt).ToList());
 
+        public Task<List<WebGameGroup>> GetGroupsForUserAsync(string platform, string externalUserId) =>
+            Task.FromResult(groupsById.Values.Where(group => IsManager(group.Id, externalUserId)).ToList());
+
+        public Task<bool> IsGroupManagerAsync(Guid groupId, string platform, string externalUserId) =>
+            Task.FromResult(IsManager(groupId, externalUserId));
+
+        public Task<bool> IsGroupOwnerAsync(Guid groupId, string platform, string externalUserId) =>
+            Task.FromResult(IsOwner(groupId, externalUserId));
+
+        public Task AddGroupCoGmAsync(Guid groupId, string ownerPlatform, string ownerExternalUserId, string coGmPlatform, string coGmExternalUserId, string displayName, string? externalUsername)
+        {
+            AddCoGmCalled = true;
+            LastAddedCoGmGroupId = groupId;
+            LastAddedCoGmTelegramId = long.TryParse(coGmExternalUserId, out var id) ? id : null;
+            LastAddedCoGmDisplayName = displayName;
+            LastAddedCoGmUsername = externalUsername;
+            return Task.CompletedTask;
+        }
+
+        public Task RemoveGroupCoGmAsync(Guid groupId, string coGmPlatform, string coGmExternalUserId)
+        {
+            RemoveCoGmCalled = true;
+            LastRemovedCoGmGroupId = groupId;
+            LastRemovedCoGmTelegramId = long.TryParse(coGmExternalUserId, out var id) ? id : null;
+            return Task.CompletedTask;
+        }
+
+        public Task LogSessionChangeAsync(Guid sessionId, string actorExternalUserId, string actorName, string changeType, string? oldValue, string? newValue)
+        {
+            var entry = new SessionAuditLogEntry(Guid.NewGuid(), sessionId, actorExternalUserId, actorName, changeType, oldValue, newValue, DateTime.UtcNow);
+            LogEntries.Add(entry);
+            LastLogSessionId = sessionId;
+            LastLogActorTelegramId = long.TryParse(actorExternalUserId, out var id) ? (long?)id : null;
+            LastLogActorName = actorName;
+            LastLogChangeType = changeType;
+            LastLogOldValue = oldValue;
+            LastLogNewValue = newValue;
+            return Task.CompletedTask;
+        }
+
+        public Task UpsertDiscordUserAsync(string discordId, string displayName, string? avatarUrl) =>
+            Task.CompletedTask;
+
+        public Task<Guid?> ResolveEffectivePlayerIdAsync(string platform, string externalUserId) =>
+            Task.FromResult<Guid?>(Guid.NewGuid());
+
+        public Task<List<LinkedIdentity>> GetLinkedIdentitiesAsync(string platform, string externalUserId) =>
+            Task.FromResult(new List<LinkedIdentity>());
+
+        public Task LinkIdentityAsync(string currentPlatform, string currentExternalUserId, string targetPlatform, string targetExternalUserId, string? currentName) =>
+            Task.CompletedTask;
+
+        public Task UnlinkIdentityAsync(string currentPlatform, string currentExternalUserId, string targetPlatform, string targetExternalUserId) =>
+            Task.CompletedTask;
+
+        public Task UpsertPlayerAsync(string platform, string externalUserId, string displayName, string? avatarUrl) =>
+            Task.CompletedTask;
+
         private bool IsManager(Guid groupId, long telegramId) =>
             IsOwner(groupId, telegramId) ||
             managers.Any(manager => manager.GroupId == groupId && manager.TelegramId == telegramId);
 
         private bool IsOwner(Guid groupId, long telegramId) =>
             groupsById.TryGetValue(groupId, out var group) && group.GmTelegramId == telegramId;
+
+        private bool IsManager(Guid groupId, string externalUserId) =>
+            IsOwner(groupId, externalUserId) ||
+            managers.Any(manager => manager.GroupId == groupId && manager.TelegramId.ToString() == externalUserId);
+
+        private bool IsOwner(Guid groupId, string externalUserId) =>
+            groupsById.TryGetValue(groupId, out var group) && group.GmTelegramId.ToString() == externalUserId;
     }
 
     private sealed record FakeGroupManager(Guid GroupId, long TelegramId, GroupManagerRole Role);

tests/GmRelay.Bot.Tests/Web/CookieAuthOptionsTests.cs

@@ -0,0 +1,34 @@
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace GmRelay.Bot.Tests.Web;
+
+public sealed class CookieAuthOptionsTests
+{
+    [Fact]
+    public void CookieAuthOptions_ShouldUseLaxSameSite_ToAllowOAuthCallback()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
+            .AddCookie(options =>
+            {
+                options.Cookie.HttpOnly = true;
+                options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
+                options.Cookie.SameSite = SameSiteMode.Lax;
+                options.ExpireTimeSpan = TimeSpan.FromDays(7);
+                options.SlidingExpiration = true;
+            });
+
+        var provider = services.BuildServiceProvider();
+        var optionsMonitor = provider.GetRequiredService<IOptionsMonitor<CookieAuthenticationOptions>>();
+        var options = optionsMonitor.Get(CookieAuthenticationDefaults.AuthenticationScheme);
+
+        // Assert
+        Assert.Equal(SameSiteMode.Lax, options.Cookie.SameSite);
+        Assert.True(options.Cookie.HttpOnly);
+        Assert.Equal(CookieSecurePolicy.Always, options.Cookie.SecurePolicy);
+    }
+}

tests/GmRelay.Bot.Tests/Web/DiscordAuthServiceTests.cs

@@ -0,0 +1,140 @@
+using System.Net;
+using System.Text.Json;
+using GmRelay.Web;
+using GmRelay.Web.Services;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace GmRelay.Bot.Tests.Web;
+
+public class DiscordAuthServiceTests
+{
+    [Fact]
+    public void BuildAuthorizeUrl_GeneratesCorrectUrl()
+    {
+        var config = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["Discord:ClientId"] = "12345",
+                ["Discord:ClientSecret"] = "secret",
+                ["Discord:RedirectUri"] = "https://example.com/callback"
+            })
+            .Build();
+
+        var service = new DiscordAuthService(new TestHttpClientFactory(), config, NullLogger<DiscordAuthService>.Instance);
+        var url = service.BuildAuthorizeUrl("state123");
+
+        Assert.Contains("client_id=12345", url);
+        Assert.Contains("response_type=code", url);
+        Assert.Contains("state=state123", url);
+        Assert.Contains("https%3A%2F%2Fexample.com%2Fcallback", url);
+    }
+
+    [Fact]
+    public void BuildAuthorizeUrl_WithMissingConfig_ThrowsInvalidOperationException()
+    {
+        var config = new ConfigurationBuilder().Build();
+        var service = new DiscordAuthService(new TestHttpClientFactory(), config, NullLogger<DiscordAuthService>.Instance);
+
+        Assert.Throws<InvalidOperationException>(() => service.BuildAuthorizeUrl("state"));
+    }
+
+    [Fact]
+    public async Task ExchangeCodeAsync_WithValidCode_ReturnsUser()
+    {
+        var handler = new TestHttpMessageHandler((request) =>
+        {
+            if (request.RequestUri?.AbsolutePath == "/api/oauth2/token")
+            {
+                var response = new DiscordTokenResponse("access_123", "Bearer", 604800, "identify");
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(JsonSerializer.Serialize(response))
+                };
+            }
+
+            if (request.RequestUri?.AbsolutePath == "/api/users/@me")
+            {
+                var user = new DiscordUser("98765", "TestUser", "0", "avatar123", null);
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(JsonSerializer.Serialize(user))
+                };
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.NotFound);
+        });
+
+        var config = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["Discord:ClientId"] = "client",
+                ["Discord:ClientSecret"] = "secret",
+                ["Discord:RedirectUri"] = "https://example.com/callback"
+            })
+            .Build();
+
+        var factory = new TestHttpClientFactory(handler);
+        var service = new DiscordAuthService(factory, config, NullLogger<DiscordAuthService>.Instance);
+
+        var result = await service.ExchangeCodeAsync("valid_code");
+
+        Assert.NotNull(result);
+        Assert.Equal("98765", result.Id);
+        Assert.Equal("TestUser", result.Username);
+        Assert.Equal("https://cdn.discordapp.com/avatars/98765/avatar123.png", result.AvatarUrl);
+    }
+
+    [Fact]
+    public async Task ExchangeCodeAsync_WithInvalidCode_ReturnsNull()
+    {
+        var handler = new TestHttpMessageHandler((request) =>
+        {
+            return new HttpResponseMessage(HttpStatusCode.BadRequest);
+        });
+
+        var config = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["Discord:ClientId"] = "client",
+                ["Discord:ClientSecret"] = "secret",
+                ["Discord:RedirectUri"] = "https://example.com/callback"
+            })
+            .Build();
+
+        var factory = new TestHttpClientFactory(handler);
+        var service = new DiscordAuthService(factory, config, NullLogger<DiscordAuthService>.Instance);
+
+        var result = await service.ExchangeCodeAsync("invalid_code");
+
+        Assert.Null(result);
+    }
+
+    private class TestHttpClientFactory : IHttpClientFactory
+    {
+        private readonly HttpMessageHandler? _handler;
+
+        public TestHttpClientFactory(HttpMessageHandler? handler = null)
+        {
+            _handler = handler;
+        }
+
+        public HttpClient CreateClient(string name) =>
+            _handler is not null ? new HttpClient(_handler) : new HttpClient();
+    }
+
+    private class TestHttpMessageHandler : HttpMessageHandler
+    {
+        private readonly Func<HttpRequestMessage, HttpResponseMessage> _handler;
+
+        public TestHttpMessageHandler(Func<HttpRequestMessage, HttpResponseMessage> handler)
+        {
+            _handler = handler;
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(_handler(request));
+        }
+    }
+}

tests/GmRelay.Bot.Tests/Web/HomePageSourceTests.cs

@@ -0,0 +1,35 @@
+namespace GmRelay.Bot.Tests.Web;
+
+public sealed class HomePageSourceTests
+{
+    [Fact]
+    public async Task HomePage_ShouldShowPlatformBadgeForGroups()
+    {
+        var source = await ReadRepositoryFileAsync("src/GmRelay.Web/Components/Pages/Home.razor");
+
+        Assert.Contains("platform-badge", source, StringComparison.Ordinal);
+        Assert.Contains("FormatPlatform", source, StringComparison.Ordinal);
+        Assert.Contains("group.Platform", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task SessionService_ShouldUseSessionTitleWhenDiscordGroupNameIsOnlyId()
+    {
+        var source = await ReadRepositoryFileAsync("src/GmRelay.Web/Services/SessionService.cs");
+
+        Assert.Contains("latest_session.title", source, StringComparison.Ordinal);
+        Assert.Contains("NULLIF(g.name, g.external_group_id)", source, StringComparison.Ordinal);
+    }
+
+    private static async Task<string> ReadRepositoryFileAsync(string relativePath)
+    {
+        var dir = AppContext.BaseDirectory;
+        while (!string.IsNullOrEmpty(dir) && !File.Exists(Path.Combine(dir, "Directory.Build.props")))
+        {
+            dir = Directory.GetParent(dir)?.FullName;
+        }
+
+        var repoRoot = dir ?? throw new InvalidOperationException("Could not find repo root");
+        return await File.ReadAllTextAsync(Path.Combine(repoRoot, relativePath));
+    }
+}