Initial commit: GM-Relay Telegram Bot

2026-04-13 13:52:49 +03:00
commit 9db4bee2f6
51 changed files with 3407 additions and 0 deletions
@@ -0,0 +1,330 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using GmRelay.Bot.Features.Confirmation.SendConfirmation;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Confirmation.HandleRsvp;
+
+// ── Command ──────────────────────────────────────────────────────────
+
+public sealed record HandleRsvpCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string Status,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+// ── DTOs ─────────────────────────────────────────────────────────────
+
+internal sealed record RsvpCounts(int Total, int Confirmed, int Declined);
+
+internal sealed record SessionContext(
+    string Title,
+    DateTime ScheduledAt,
+    long GmTelegramId,
+    long TelegramChatId);
+
+internal sealed record ParticipantRsvp(
+    long TelegramId,
+    string DisplayName,
+    string? TelegramUsername,
+    string RsvpStatus);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Handles the "Буду" / "Не смогу" callback query.
+///
+/// Flow:
+///   1. Validate that the user is a participant in this session
+///   2. Record or update their RSVP (idempotent)
+///   3. If declined → alert GM privately, revert session if was Confirmed
+///   4. If all non-GM players confirmed → mark session Confirmed, notify group + GM
+///   5. Update the inline keyboard to show current RSVP status
+///
+/// Concurrency: two simultaneous clicks on different rows don't conflict (MVCC).
+/// The last EditMessage wins, which is fine — both reflect up-to-date state.
+/// </summary>
+public sealed class HandleRsvpHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<HandleRsvpHandler> logger)
+{
+    public async Task HandleAsync(HandleRsvpCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        // ── 1. Validate participant ──────────────────────────────────
+
+        var participantExists = await connection.ExecuteScalarAsync<bool>(
+            """
+            SELECT EXISTS (
+                SELECT 1 FROM session_participants sp
+                JOIN players p ON p.id = sp.player_id
+                WHERE sp.session_id = @SessionId
+                  AND p.telegram_id = @TelegramUserId
+                  AND sp.is_gm = false
+            )
+            """,
+            new { command.SessionId, command.TelegramUserId },
+            transaction);
+
+        if (!participantExists)
+        {
+            await bot.AnswerCallbackQuery(
+                callbackQueryId: command.CallbackQueryId,
+                text: "Вы не являетесь участником этой сессии.",
+                cancellationToken: ct);
+            return;
+        }
+
+        // ── 2. Record RSVP (idempotent) ─────────────────────────────
+
+        var updated = await connection.ExecuteAsync(
+            """
+            UPDATE session_participants
+            SET    rsvp_status  = @Status,
+                   responded_at = now()
+            WHERE  session_id = @SessionId
+              AND  player_id  = (SELECT id FROM players WHERE telegram_id = @TelegramUserId)
+              AND  rsvp_status != @Status
+            """,
+            new { command.SessionId, command.TelegramUserId, command.Status },
+            transaction);
+
+        if (updated == 0)
+        {
+            // Already in this state — just dismiss the loading spinner
+            var alreadyText = command.Status == RsvpStatus.Confirmed
+                ? "Вы уже подтвердили участие."
+                : "Вы уже отказались от участия.";
+
+            await bot.AnswerCallbackQuery(
+                callbackQueryId: command.CallbackQueryId,
+                text: alreadyText,
+                cancellationToken: ct);
+            return;
+        }
+
+        // ── 3. Load session context ─────────────────────────────────
+
+        var session = await connection.QuerySingleAsync<SessionContext>(
+            """
+            SELECT s.title, s.scheduled_at AS ScheduledAt,
+                   g.gm_telegram_id AS GmTelegramId,
+                   g.telegram_chat_id AS TelegramChatId
+            FROM sessions s
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE s.id = @SessionId
+            """,
+            new { command.SessionId },
+            transaction);
+
+        // ── 4. Handle decline ───────────────────────────────────────
+
+        if (command.Status == RsvpStatus.Declined)
+        {
+            // Revert session to ConfirmationSent if it was Confirmed
+            await connection.ExecuteAsync(
+                """
+                UPDATE sessions
+                SET    status = @ConfirmationSent, updated_at = now()
+                WHERE  id = @SessionId AND status = @Confirmed
+                """,
+                new
+                {
+                    command.SessionId,
+                    ConfirmationSent = SessionStatus.ConfirmationSent,
+                    Confirmed = SessionStatus.Confirmed
+                },
+                transaction);
+
+            // Alert GM immediately via private message
+            var declinedPlayer = await connection.QuerySingleAsync<string>(
+                "SELECT display_name FROM players WHERE telegram_id = @TelegramUserId",
+                new { command.TelegramUserId },
+                transaction);
+
+            await transaction.CommitAsync(ct);
+
+            // Send alert outside transaction (network call)
+            try
+            {
+                await bot.SendMessage(
+                    chatId: session.GmTelegramId,
+                    text: $"🚨 Отмена! {declinedPlayer} не сможет прийти на игру «{session.Title}».",
+                    cancellationToken: ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to send decline alert to GM for session {SessionId}",
+                    command.SessionId);
+            }
+
+            await bot.AnswerCallbackQuery(
+                callbackQueryId: command.CallbackQueryId,
+                text: "Вы отказались от участия.",
+                cancellationToken: ct);
+        }
+        // ── 5. Handle confirm — check if ALL confirmed ──────────────
+        else
+        {
+            var counts = await connection.QuerySingleAsync<RsvpCounts>(
+                """
+                SELECT
+                    count(*)                                              AS Total,
+                    count(*) FILTER (WHERE rsvp_status = @Confirmed)      AS Confirmed,
+                    count(*) FILTER (WHERE rsvp_status = @Declined)       AS Declined
+                FROM session_participants
+                WHERE session_id = @SessionId AND is_gm = false
+                """,
+                new
+                {
+                    command.SessionId,
+                    Confirmed = RsvpStatus.Confirmed,
+                    Declined = RsvpStatus.Declined
+                },
+                transaction);
+
+            var allConfirmed = counts.Confirmed == counts.Total;
+
+            if (allConfirmed)
+            {
+                await connection.ExecuteAsync(
+                    """
+                    UPDATE sessions
+                    SET    status = @Confirmed, updated_at = now()
+                    WHERE  id = @SessionId
+                    """,
+                    new { command.SessionId, Confirmed = SessionStatus.Confirmed },
+                    transaction);
+            }
+
+            await transaction.CommitAsync(ct);
+
+            if (allConfirmed)
+            {
+                // Notify group
+                try
+                {
+                    await bot.SendMessage(
+                        chatId: session.TelegramChatId,
+                        text: $"🎉 Игра «{session.Title}» подтверждена! Все участники на месте.",
+                        cancellationToken: ct);
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "Failed to send group confirmation for session {SessionId}",
+                        command.SessionId);
+                }
+
+                // Notify GM privately
+                try
+                {
+                    await bot.SendMessage(
+                        chatId: session.GmTelegramId,
+                        text: $"✅ Все подтвердили участие в «{session.Title}» ({session.ScheduledAt.FormatMoscow()} МСК).",
+                        cancellationToken: ct);
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "Failed to send GM confirmation for session {SessionId}",
+                        command.SessionId);
+                }
+            }
+
+            await bot.AnswerCallbackQuery(
+                callbackQueryId: command.CallbackQueryId,
+                text: "Вы подтвердили участие!",
+                cancellationToken: ct);
+        }
+
+        // ── 6. Update inline keyboard message ───────────────────────
+
+        await UpdateConfirmationMessage(command, session, ct);
+    }
+
+    /// <summary>
+    /// Re-renders the confirmation message with current RSVP statuses.
+    /// </summary>
+    private async Task UpdateConfirmationMessage(
+        HandleRsvpCommand command, SessionContext session, CancellationToken ct)
+    {
+        try
+        {
+            await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+            var participants = (await connection.QueryAsync<ParticipantRsvp>(
+                """
+                SELECT p.telegram_id    AS TelegramId,
+                       p.display_name    AS DisplayName,
+                       p.telegram_username AS TelegramUsername,
+                       sp.rsvp_status    AS RsvpStatus
+                FROM session_participants sp
+                JOIN players p ON p.id = sp.player_id
+                WHERE sp.session_id = @SessionId AND sp.is_gm = false
+                ORDER BY sp.responded_at NULLS LAST
+                """,
+                new { command.SessionId })).ToList();
+
+            var confirmed = participants.Where(p => p.RsvpStatus == RsvpStatus.Confirmed).ToList();
+            var declined = participants.Where(p => p.RsvpStatus == RsvpStatus.Declined).ToList();
+            var pending = participants.Where(p => p.RsvpStatus == RsvpStatus.Pending).ToList();
+
+            var lines = new List<string>
+            {
+                $"🎲 Подтвердите участие в «{session.Title}»",
+                $"📅 {session.ScheduledAt.FormatMoscow()} (МСК)",
+                ""
+            };
+
+            foreach (var p in confirmed)
+                lines.Add($"   ✅ {FormatName(p)}");
+            foreach (var p in declined)
+                lines.Add($"   ❌ ~~{FormatName(p)}~~");
+            foreach (var p in pending)
+                lines.Add($"   ⏳ {FormatName(p)}");
+
+            lines.Add("");
+
+            if (confirmed.Count == participants.Count)
+                lines.Add($"Статус: ✅ все подтвердили ({confirmed.Count}/{participants.Count})");
+            else if (declined.Count > 0)
+                lines.Add($"Статус: ⚠️ есть отказы ({confirmed.Count}/{participants.Count} подтвердили)");
+            else
+                lines.Add($"Статус: ожидаем подтверждения ({confirmed.Count}/{participants.Count})");
+
+            var text = string.Join("\n", lines);
+
+            // Keep buttons unless everyone confirmed
+            var replyMarkup = confirmed.Count == participants.Count
+                ? null
+                : new InlineKeyboardMarkup([
+                    [
+                        InlineKeyboardButton.WithCallbackData("\u2705 Буду", $"rsvp:confirm:{command.SessionId}"),
+                        InlineKeyboardButton.WithCallbackData("\u274c Не смогу", $"rsvp:decline:{command.SessionId}")
+                    ]
+                ]);
+
+            await bot.EditMessageText(
+                chatId: command.ChatId,
+                messageId: command.MessageId,
+                text: text,
+                replyMarkup: replyMarkup,
+                cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            // EditMessage can fail if message is too old or unchanged — non-critical
+            logger.LogWarning(ex, "Failed to update confirmation message for session {SessionId}",
+                command.SessionId);
+        }
+    }
+
+    private static string FormatName(ParticipantRsvp p) =>
+        p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
+}
@@ -0,0 +1,123 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Confirmation.SendConfirmation;
+
+// ── DTOs for Dapper mapping ──────────────────────────────────────────
+
+internal sealed record SessionInfo(
+    Guid Id,
+    string Title,
+    DateTime ScheduledAt,
+    Guid GroupId,
+    long TelegramChatId);
+
+internal sealed record ParticipantInfo(
+    long TelegramId,
+    string DisplayName,
+    string? TelegramUsername);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Sends the interactive confirmation message (inline keyboard) to the group chat.
+/// Called by SessionSchedulerService at T-24h.
+/// </summary>
+public sealed class SendConfirmationHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<SendConfirmationHandler> logger)
+{
+    public async Task HandleAsync(Guid sessionId, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        // 1. Load session + group info
+        var session = await connection.QuerySingleOrDefaultAsync<SessionInfo>(
+            """
+            SELECT s.id, s.title, s.scheduled_at AS ScheduledAt, s.group_id AS GroupId,
+                   g.telegram_chat_id AS TelegramChatId
+            FROM sessions s
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE s.id = @SessionId AND s.status = @Planned
+            """,
+            new { SessionId = sessionId, Planned = SessionStatus.Planned });
+
+        if (session is null)
+        {
+            logger.LogWarning("Session {SessionId} not found or not in Planned status", sessionId);
+            return;
+        }
+
+        // 2. Load non-GM participants
+        var participants = (await connection.QueryAsync<ParticipantInfo>(
+            """
+            SELECT p.telegram_id AS TelegramId,
+                   p.display_name AS DisplayName,
+                   p.telegram_username AS TelegramUsername
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            """,
+            new { SessionId = sessionId })).ToList();
+
+        if (participants.Count == 0)
+        {
+            logger.LogWarning("Session {SessionId} has no non-GM participants", sessionId);
+            return;
+        }
+
+        // 3. Build confirmation message
+        var playerList = string.Join("\n", participants.Select(p =>
+            $"   ⏳ {FormatPlayerName(p)}"));
+
+        var text = $"""
+            🎲 Подтвердите участие в «{session.Title}»
+            📅 {session.ScheduledAt.FormatMoscow()} (МСК)
+
+            {playerList}
+            
+            Статус: ожидаем подтверждения (0/{participants.Count})
+            """;
+
+        var keyboard = new InlineKeyboardMarkup([
+            [
+                InlineKeyboardButton.WithCallbackData("✅ Буду", $"rsvp:confirm:{sessionId}"),
+                InlineKeyboardButton.WithCallbackData("❌ Не смогу", $"rsvp:decline:{sessionId}")
+            ]
+        ]);
+
+        // 4. Send to group
+        var message = await bot.SendMessage(
+            chatId: session.TelegramChatId,
+            text: text,
+            replyMarkup: keyboard,
+            cancellationToken: ct);
+
+        // 5. Update session status and store message ID
+        await connection.ExecuteAsync(
+            """
+            UPDATE sessions
+            SET status = @Status,
+                confirmation_message_id = @MessageId,
+                updated_at = now()
+            WHERE id = @SessionId
+            """,
+            new
+            {
+                SessionId = sessionId,
+                Status = SessionStatus.ConfirmationSent,
+                MessageId = message.MessageId
+            });
+
+        logger.LogInformation(
+            "Confirmation sent for session {SessionId} ({Title}), message_id={MessageId}",
+            sessionId, session.Title, message.MessageId);
+    }
+
+    internal static string FormatPlayerName(ParticipantInfo p) =>
+        p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
+}
@@ -0,0 +1,103 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+
+namespace GmRelay.Bot.Features.Reminders.SendJoinLink;
+
+// ── DTOs ─────────────────────────────────────────────────────────────
+
+internal sealed record JoinLinkSession(
+    Guid Id,
+    string Title,
+    string JoinLink,
+    DateTime ScheduledAt,
+    long TelegramChatId);
+
+internal sealed record ConfirmedPlayer(
+    long TelegramId,
+    string DisplayName,
+    string? TelegramUsername);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Sends the join link to the group chat at T-5min, tagging all confirmed players.
+/// Called by SessionSchedulerService.
+/// </summary>
+public sealed class SendJoinLinkHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<SendJoinLinkHandler> logger)
+{
+    public async Task HandleAsync(Guid sessionId, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        // 1. Load session
+        var session = await connection.QuerySingleOrDefaultAsync<JoinLinkSession>(
+            """
+            SELECT s.id, s.title, s.join_link AS JoinLink, s.scheduled_at AS ScheduledAt,
+                   g.telegram_chat_id AS TelegramChatId
+            FROM sessions s
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE s.id = @SessionId
+              AND s.status = @Confirmed
+              AND s.link_message_id IS NULL
+            """,
+            new { SessionId = sessionId, Confirmed = SessionStatus.Confirmed });
+
+        if (session is null)
+        {
+            logger.LogWarning("Session {SessionId} not eligible for join link", sessionId);
+            return;
+        }
+
+        // 2. Load confirmed players
+        var players = (await connection.QueryAsync<ConfirmedPlayer>(
+            """
+            SELECT p.telegram_id    AS TelegramId,
+                   p.display_name    AS DisplayName,
+                   p.telegram_username AS TelegramUsername
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId
+              AND sp.rsvp_status = @Confirmed
+            """,
+            new { SessionId = sessionId, Confirmed = RsvpStatus.Confirmed })).ToList();
+
+        // 3. Build message with player mentions
+        var mentions = string.Join(", ", players.Select(p =>
+            p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName));
+
+        var text = $"""
+            🎮 Игра «{session.Title}» начинается через 5 минут!
+
+            🔗 Ссылка на подключение:
+            {session.JoinLink}
+
+            Участники: {mentions}
+
+            Хорошей игры! 🎲
+            """;
+
+        // 4. Send
+        var message = await bot.SendMessage(
+            chatId: session.TelegramChatId,
+            text: text,
+            cancellationToken: ct);
+
+        // 5. Mark as sent (idempotent — link_message_id IS NULL guard in query)
+        await connection.ExecuteAsync(
+            """
+            UPDATE sessions
+            SET    link_message_id = @MessageId, updated_at = now()
+            WHERE  id = @SessionId AND link_message_id IS NULL
+            """,
+            new { SessionId = sessionId, MessageId = message.MessageId });
+
+        logger.LogInformation(
+            "Join link sent for session {SessionId} ({Title}), message_id={MessageId}",
+            sessionId, session.Title, message.MessageId);
+    }
+}
@@ -0,0 +1,92 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+public sealed record CancelSessionCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+// DTOs for AOT compilation
+internal sealed record CancelSessionInfoDto(string Title, Guid BatchId, long GmId);
+
+public sealed class CancelSessionHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<CancelSessionHandler> logger)
+{
+    public async Task HandleAsync(CancelSessionCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+        
+        // 1. Проверяем, что запрос делает ГМ данной сессии
+        var session = await connection.QuerySingleOrDefaultAsync<CancelSessionInfoDto>(
+            @"SELECT s.title as Title, s.batch_id as BatchId, g.gm_telegram_id as GmId
+              FROM sessions s
+              JOIN game_groups g ON s.group_id = g.id
+              WHERE s.id = @SessionId",
+            new { command.SessionId }, transaction);
+
+        if (session == null)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+            return;
+        }
+
+        if (session.GmId != command.TelegramUserId)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только Мастер Игры (GM) может отменять сессию.", showAlert: true, cancellationToken: ct);
+            return;
+        }
+
+        // 2. Отменяем сессию
+        await connection.ExecuteAsync("UPDATE sessions SET status = 'Cancelled' WHERE id = @Id", new { Id = command.SessionId }, transaction);
+
+        // 3. Загружаем весь батч для перерисовки
+        var batchSessions = await connection.QueryAsync<SessionBatchDto>(
+            @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+            new { BatchId = session.BatchId }, transaction);
+
+        var batchParticipants = await connection.QueryAsync<ParticipantBatchDto>(
+            @"SELECT sp.session_id as SessionId, p.display_name as DisplayName, p.telegram_username as TelegramUsername 
+              FROM session_participants sp
+              JOIN players p ON sp.player_id = p.id
+              JOIN sessions s ON sp.session_id = s.id
+              WHERE s.batch_id = @BatchId AND sp.is_gm = false
+              ORDER BY sp.responded_at ASC, p.created_at ASC",
+            new { BatchId = session.BatchId }, transaction);
+
+        await transaction.CommitAsync(ct);
+
+        // 4. Перерисовываем сообщение
+        var renderResult = SessionBatchRenderer.Render(session.Title, batchSessions.ToList(), batchParticipants.ToList());
+
+        try
+        {
+            await bot.EditMessageText(
+                chatId: command.ChatId,
+                messageId: command.MessageId,
+                text: renderResult.Text,
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                replyMarkup: renderResult.Markup, 
+                cancellationToken: ct);
+
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия отменена!", cancellationToken: ct);
+            
+            // Опционально: написать отдельное сообщение в чат
+            await bot.SendMessage(command.ChatId, $"❌ <b>Внимание!</b> Сессия \"{System.Net.WebUtility.HtmlEncode(session.Title)}\" отменена.", parseMode: Telegram.Bot.Types.Enums.ParseMode.Html, cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to update batch message after cancelling session {SessionId}", command.SessionId);
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Ошибка при обновлении сообщения.", cancellationToken: ct);
+        }
+    }
+}
@@ -0,0 +1,152 @@
+using System.Text.RegularExpressions;
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+public sealed class CreateSessionHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient botClient,
+    ILogger<CreateSessionHandler> logger)
+{
+    public async Task HandleAsync(Message message, CancellationToken cancellationToken)
+    {
+        var text = message.Text ?? "";
+        
+        string? title = null;
+        string? link = null;
+        var scheduledTimes = new List<DateTimeOffset>();
+
+        foreach (var line in text.Split('\n'))
+        {
+            var trimmed = line.Trim();
+            if (trimmed.StartsWith("Название:", StringComparison.OrdinalIgnoreCase))
+                title = trimmed["Название:".Length..].Trim();
+            else if (trimmed.StartsWith("Ссылка:", StringComparison.OrdinalIgnoreCase))
+                link = trimmed["Ссылка:".Length..].Trim();
+            else if (trimmed.StartsWith("Время:", StringComparison.OrdinalIgnoreCase))
+            {
+                var timeStr = trimmed["Время:".Length..].Trim();
+                if (MoscowTime.TryParseMoscow(timeStr, out var scheduledAt))
+                {
+                    if (scheduledAt > DateTimeOffset.UtcNow)
+                        scheduledTimes.Add(scheduledAt);
+                    else
+                        await botClient.SendMessage(message.Chat.Id, $"⚠️ Предупреждение: Дата {timeStr} находится в прошлом и будет пропущена.", cancellationToken: cancellationToken);
+                }
+                else
+                {
+                    await botClient.SendMessage(message.Chat.Id, $"⚠️ Предупреждение: Некорректный формат времени '{timeStr}'. Пропущено.", cancellationToken: cancellationToken);
+                }
+            }
+        }
+
+        if (string.IsNullOrEmpty(title) || string.IsNullOrEmpty(link) || scheduledTimes.Count == 0)
+        {
+            await botClient.SendMessage(
+                chatId: message.Chat.Id,
+                text: "❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:\n\n/newsession\nНазвание: My Game\nВремя: 15.05.2026 19:30\nВремя: 22.05.2026 19:30\nСсылка: https://link",
+                cancellationToken: cancellationToken);
+            return;
+        }
+
+        var gmId = message.From!.Id;
+        var gmName = message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? "" : $" {message.From.LastName}");
+        var gmUsername = message.From.Username;
+        
+        var chatId = message.Chat.Id;
+        var chatTitle = message.Chat.Title ?? "Private Chat";
+
+        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+        await using var transaction = await connection.BeginTransactionAsync(cancellationToken);
+
+        try
+        {
+            // 1. Убеждаемся, что GM зарегистрирован
+            await connection.ExecuteAsync(
+                @"INSERT INTO players (telegram_id, display_name, telegram_username) 
+                  VALUES (@TgId, @Name, @Username)
+                  ON CONFLICT (telegram_id) DO UPDATE SET display_name = EXCLUDED.display_name, telegram_username = EXCLUDED.telegram_username;",
+                new { TgId = gmId, Name = gmName, Username = gmUsername },
+                transaction);
+
+            // 2. Убеждаемся, что Группа зарегистрирована
+            var groupId = await connection.ExecuteScalarAsync<Guid>(
+                @"INSERT INTO game_groups (telegram_chat_id, name, gm_telegram_id)
+                  VALUES (@ChatId, @ChatName, @GmId)
+                  ON CONFLICT (telegram_chat_id) DO UPDATE SET name = EXCLUDED.name
+                  RETURNING id;",
+                new { ChatId = chatId, ChatName = chatTitle, GmId = gmId },
+                transaction);
+
+            int? messageThreadId = null;
+            if (message.Chat.IsForum)
+            {
+                var topic = await botClient.CreateForumTopic(
+                    chatId: chatId,
+                    name: $"🎲 Игры: {title}",
+                    cancellationToken: cancellationToken);
+                messageThreadId = topic.MessageThreadId;
+            }
+
+            // 3. Создаем сессии в цикле с общим batch_id
+            var batchId = Guid.NewGuid();
+            var sessions = new List<SessionBatchDto>();
+
+            foreach (var dt in scheduledTimes.OrderBy(d => d))
+            {
+                var sessionId = await connection.ExecuteScalarAsync<Guid>(
+                    @"INSERT INTO sessions (batch_id, group_id, title, join_link, scheduled_at, status, thread_id)
+                      VALUES (@BatchId, @GroupId, @Title, @Link, @ScheduledAt, 'Planned', @ThreadId)
+                      RETURNING id;",
+                    new { BatchId = batchId, GroupId = groupId, Title = title, Link = link, ScheduledAt = dt, ThreadId = messageThreadId },
+                    transaction);
+
+                sessions.Add(new SessionBatchDto(sessionId, dt.UtcDateTime, "Planned"));
+            }
+
+            await transaction.CommitAsync(cancellationToken);
+            logger.LogInformation("Создан батч {BatchId} с {Count} сессиями в группе {GroupId}", batchId, sessions.Count, groupId);
+
+            // 4. Отправляем сообщение в чат
+            var renderResult = SessionBatchRenderer.Render(title, sessions, Array.Empty<ParticipantBatchDto>());
+
+
+            var batchMessage = await botClient.SendMessage(
+                chatId: chatId,
+                messageThreadId: messageThreadId,
+                text: renderResult.Text,
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                replyMarkup: renderResult.Markup,
+                cancellationToken: cancellationToken);
+
+            // 4b. Сохраняем message_id батч-сообщения для дальнейшего редактирования
+            await connection.ExecuteAsync(
+                "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
+                new { MsgId = batchMessage.MessageId, BatchId = batchId });
+
+            // 5. Удаляем исходное сообщение с командой /newsession, чтобы не спамить
+            try
+            {
+                await botClient.DeleteMessage(
+                    chatId: chatId,
+                    messageId: message.MessageId,
+                    cancellationToken: cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Не удалось удалить исходное сообщение {MessageId} в чате {ChatId}", message.MessageId, chatId);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при создании сессии");
+            await transaction.RollbackAsync(cancellationToken);
+            await botClient.SendMessage(chatId, "💥 Произошла ошибка базы данных при создании сессии.", cancellationToken: cancellationToken);
+        }
+    }
+}
@@ -0,0 +1,99 @@
+using Dapper;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+using GmRelay.Bot.Domain;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+public sealed record JoinSessionCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string DisplayName,
+    string? TelegramUsername,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+// DTOs for AOT compilation
+internal sealed record JoinSessionBatchDto(Guid BatchId, string Title);
+
+public sealed class JoinSessionHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<JoinSessionHandler> logger)
+{
+    public async Task HandleAsync(JoinSessionCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        try
+        {
+            // 1. Убеждаемся, что игрок есть в базе
+            var playerId = await connection.ExecuteScalarAsync<Guid>(
+                @"INSERT INTO players (telegram_id, display_name, telegram_username) 
+                  VALUES (@TgId, @Name, @Username)
+                  ON CONFLICT (telegram_id) DO UPDATE SET display_name = EXCLUDED.display_name, telegram_username = EXCLUDED.telegram_username
+                  RETURNING id;",
+                new { TgId = command.TelegramUserId, Name = command.DisplayName, Username = command.TelegramUsername },
+                transaction);
+
+            // 2. Добавляем в участники сессии (статус Pending, так как за 24 часа нужно будет финальное подтверждение)
+            var inserted = await connection.ExecuteAsync(
+                @"INSERT INTO session_participants (session_id, player_id, is_gm, rsvp_status)
+                  VALUES (@SessionId, @PlayerId, false, 'Pending')
+                  ON CONFLICT (session_id, player_id) DO NOTHING;",
+                new { SessionId = command.SessionId, PlayerId = playerId },
+                transaction);
+
+            if (inserted == 0)
+            {
+                await transaction.RollbackAsync(ct);
+                await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы уже записаны!", cancellationToken: ct);
+                return;
+            }
+
+            // 3. Получаем batch_id по session_id
+            var batchInfo = await connection.QuerySingleAsync<JoinSessionBatchDto>(
+                @"SELECT batch_id as BatchId, title as Title FROM sessions WHERE id = @SessionId",
+                new { command.SessionId }, transaction);
+
+            // Загружаем весь батч для перерисовки
+            var batchSessions = await connection.QueryAsync<SessionBatchDto>(
+                @"SELECT id as SessionId, scheduled_at as ScheduledAt, status as Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                new { BatchId = batchInfo.BatchId }, transaction);
+
+            var batchParticipants = await connection.QueryAsync<ParticipantBatchDto>(
+                @"SELECT sp.session_id as SessionId, p.display_name as DisplayName, p.telegram_username as TelegramUsername 
+                  FROM session_participants sp
+                  JOIN players p ON sp.player_id = p.id
+                  JOIN sessions s ON sp.session_id = s.id
+                  WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                  ORDER BY sp.responded_at ASC, p.created_at ASC",
+                new { BatchId = batchInfo.BatchId }, transaction);
+
+            await transaction.CommitAsync(ct);
+
+            // 4. Перерисовываем сообщение
+            var renderResult = SessionBatchRenderer.Render(batchInfo.Title, batchSessions.ToList(), batchParticipants.ToList());
+
+            await bot.EditMessageText(
+                chatId: command.ChatId,
+                messageId: command.MessageId,
+                text: renderResult.Text,
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                replyMarkup: renderResult.Markup,
+                cancellationToken: ct);
+
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы успешно записаны!", cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при добавлении игрока к сессии");
+            await transaction.RollbackAsync(ct);
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Произошла ошибка при регистрации.", cancellationToken: ct);
+        }
+    }
+}
@@ -0,0 +1,63 @@
+using GmRelay.Bot.Domain;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession;
+
+internal sealed record SessionBatchDto(Guid SessionId, DateTime ScheduledAt, string Status);
+internal sealed record ParticipantBatchDto(Guid SessionId, string DisplayName, string? TelegramUsername);
+
+internal static class SessionBatchRenderer
+{
+    public static (string Text, InlineKeyboardMarkup Markup) Render(
+        string title,
+        IReadOnlyList<SessionBatchDto> sessions,
+        IReadOnlyList<ParticipantBatchDto> participants)
+    {
+        var activeSessions = sessions.OrderBy(s => s.ScheduledAt).ToList();
+        
+        var messageText = $"🎲 <b>Новые игры:</b> {System.Net.WebUtility.HtmlEncode(title)}\n\n" +
+                          $"<b>Расписание:</b>\n\n";
+
+        var buttons = new List<InlineKeyboardButton[]>();
+
+        foreach (var session in activeSessions)
+        {
+            var sessionPlayers = participants.Where(p => p.SessionId == session.SessionId).ToList();
+            
+            messageText += $"📅 <b>{session.ScheduledAt.FormatMoscow()}</b>\n";
+            messageText += $"👥 Игроки ({sessionPlayers.Count}):\n";
+            
+            if (sessionPlayers.Count > 0)
+            {
+                messageText += string.Join("\n", sessionPlayers.Select(p => $"  👤 {(p.TelegramUsername != null ? "@" + p.TelegramUsername : p.DisplayName)}")) + "\n";
+            }
+            else
+            {
+                messageText += "  <i>Пока никто не записался</i>\n";
+            }
+
+            if (session.Status == "Cancelled")
+            {
+                messageText += "❌ <i>Сессия отменена</i>\n\n";
+            }
+            else if (session.Status == "RecruitmentClosed") // custom state we can derive or use
+            {
+                messageText += "🔒 <i>Набор завершен</i>\n\n";
+            }
+            else
+            {
+                messageText += "\n";
+                // Add buttons for this specific session
+                var dateTitle = session.ScheduledAt.FormatMoscowShort();
+                buttons.Add(new[]
+                {
+                    InlineKeyboardButton.WithCallbackData($"✋ На {dateTitle}", $"join_session:{session.SessionId}"),
+                    InlineKeyboardButton.WithCallbackData($"❌ Отменить {dateTitle} (ГМ)", $"cancel_session:{session.SessionId}"),
+                    InlineKeyboardButton.WithCallbackData($"⏰ (ГМ)", $"reschedule_session:{session.SessionId}")
+                });
+            }
+        }
+
+        return (messageText, new InlineKeyboardMarkup(buttons));
+    }
+}
@@ -0,0 +1,76 @@
+using System.Text;
+using Dapper;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace GmRelay.Bot.Features.Sessions.ExportCalendar;
+
+internal sealed record CalendarSessionDto(Guid Id, string Title, DateTime ScheduledAt);
+
+public sealed class ExportCalendarHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient botClient)
+{
+    public async Task HandleAsync(Message message, CancellationToken cancellationToken)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+
+        var sessions = await connection.QueryAsync<CalendarSessionDto>(
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt
+              FROM sessions s
+              JOIN game_groups g ON s.group_id = g.id
+              WHERE g.telegram_chat_id = @ChatId 
+                AND s.status = 'Planned' 
+                AND s.scheduled_at > NOW()
+              ORDER BY s.scheduled_at ASC",
+            new { ChatId = message.Chat.Id });
+
+        var sessionsList = sessions.ToList();
+
+        if (sessionsList.Count == 0)
+        {
+            await botClient.SendMessage(
+                chatId: message.Chat.Id,
+                text: "📭 У этой группы нет запланированных сессий для экспорта.",
+                cancellationToken: cancellationToken);
+            return;
+        }
+
+        var sb = new StringBuilder();
+        sb.AppendLine("BEGIN:VCALENDAR");
+        sb.AppendLine("VERSION:2.0");
+        sb.AppendLine("PRODID:-//GM-Relay//TTRPG Schedule//EN");
+
+        foreach (var s in sessionsList)
+        {
+            var dtStart = s.ScheduledAt.ToString("yyyyMMddTHHmmssZ");
+            var dtEnd = s.ScheduledAt.AddHours(4).ToString("yyyyMMddTHHmmssZ");
+
+            sb.AppendLine("BEGIN:VEVENT");
+            sb.AppendLine($"UID:{s.Id}@gmrelay");
+            sb.AppendLine($"DTSTAMP:{DateTime.UtcNow:yyyyMMddTHHmmssZ}");
+            sb.AppendLine($"DTSTART:{dtStart}");
+            sb.AppendLine($"DTEND:{dtEnd}");
+            sb.AppendLine($"SUMMARY:{s.Title}");
+            // Escape special chars according to iCal standards (RFC 5545) -- simple escaping for summary
+            // In a fuller implementation we'd escape \r\n, commas, etc. But titles are mostly plain text.
+            sb.AppendLine("END:VEVENT");
+        }
+
+        sb.AppendLine("END:VCALENDAR");
+
+        var bytes = Encoding.UTF8.GetBytes(sb.ToString());
+        using var stream = new MemoryStream(bytes);
+
+        var inputFile = InputFile.FromStream(stream, "schedule.ics");
+
+        await botClient.SendDocument(
+             chatId: message.Chat.Id,
+             document: inputFile,
+             caption: "📅 <b>Ваш календарь игр!</b>\nОткройте файл на устройстве, чтобы добавить события в свой календарь.",
+             parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+             messageThreadId: message.MessageThreadId,
+             cancellationToken: cancellationToken);
+    }
+}
@@ -0,0 +1,123 @@
+using Dapper;
+using Npgsql;
+using Telegram.Bot;
+using GmRelay.Bot.Domain;
+
+namespace GmRelay.Bot.Features.Sessions.ListSessions;
+
+public sealed record DeleteSessionCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+internal sealed record DeleteSessionInfoDto(string Title, Guid BatchId, long GmId, int? ThreadId);
+
+public sealed class DeleteSessionHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<DeleteSessionHandler> logger)
+{
+    public async Task HandleAsync(DeleteSessionCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        // 1. Fetch session and verify GM
+        var session = await connection.QuerySingleOrDefaultAsync<DeleteSessionInfoDto>(
+            @"SELECT s.title as Title, s.batch_id as BatchId, s.thread_id as ThreadId, g.gm_telegram_id as GmId
+              FROM sessions s
+              JOIN game_groups g ON s.group_id = g.id
+              WHERE s.id = @SessionId",
+            new { command.SessionId }, transaction);
+
+        if (session == null)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+            return;
+        }
+
+        if (session.GmId != command.TelegramUserId)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Только Мастер Игры (GM) может удалять сессию.", showAlert: true, cancellationToken: ct);
+            return;
+        }
+
+        // 2. Delete session
+        await connection.ExecuteAsync("DELETE FROM sessions WHERE id = @Id", new { Id = command.SessionId }, transaction);
+
+        // 3. Check if any sessions are left in the batch
+        var remainingInBatch = await connection.ExecuteScalarAsync<int>(
+            "SELECT COUNT(*) FROM sessions WHERE batch_id = @BatchId",
+            new { BatchId = session.BatchId }, transaction);
+
+        await transaction.CommitAsync(ct);
+
+        // 4. If no sessions left and we have a forum topic, delete the topic
+        if (remainingInBatch == 0 && session.ThreadId.HasValue)
+        {
+            try
+            {
+                await bot.DeleteForumTopic(command.ChatId, session.ThreadId.Value, cancellationToken: ct);
+                logger.LogInformation("Deleted forum topic {ThreadId} for batch {BatchId} as no sessions remained.", session.ThreadId.Value, session.BatchId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to delete forum topic {ThreadId}", session.ThreadId.Value);
+            }
+        }
+
+        await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия удалена!", cancellationToken: ct);
+
+        // 5. Update the /listsessions message (we delete the message or edit it to remove the button)
+        // A simple way is to re-render the list:
+        await using var readConnection = await dataSource.OpenConnectionAsync(ct);
+        var sessions = await readConnection.QueryAsync<SessionListItemDto>(
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, 
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false) as PlayerCount,
+                     g.gm_telegram_id as GmId
+              FROM sessions s
+              JOIN game_groups g ON s.group_id = g.id
+              LEFT JOIN session_participants sp ON s.id = sp.session_id
+              WHERE g.telegram_chat_id = @ChatId AND s.status != 'Cancelled' AND s.scheduled_at > NOW()
+              GROUP BY s.id, s.title, s.scheduled_at, s.status, g.gm_telegram_id
+              ORDER BY s.scheduled_at ASC",
+            new { ChatId = command.ChatId });
+
+        var sessionsList = sessions.ToList();
+
+        if (sessionsList.Count == 0)
+        {
+            try { await bot.EditMessageText(command.ChatId, command.MessageId, "📭 В этой группе нет предстоящих игр.", cancellationToken: ct); } catch {}
+            return;
+        }
+
+        var text = "📅 <b>Ближайшие игры:</b>\n\n";
+        foreach (var s in sessionsList)
+        {
+            text += $"🔹 <b>{s.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(s.Title)} (Участников: {s.PlayerCount})\n";
+        }
+
+        var isGm = command.TelegramUserId == sessionsList.First().GmId;
+        var keyboard = isGm 
+            ? new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
+                sessionsList.Select(s => new[] { Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton.WithCallbackData($"🗑 Удалить {s.ScheduledAt.FormatMoscowShort()}", $"delete_session:{s.Id}") }))
+            : null;
+
+        try
+        {
+            await bot.EditMessageText(
+                command.ChatId,
+                command.MessageId,
+                text,
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                replyMarkup: keyboard,
+                cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to edit list sessions message");
+        }
+    }
+}
@@ -0,0 +1,61 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace GmRelay.Bot.Features.Sessions.ListSessions;
+
+internal sealed record SessionListItemDto(Guid Id, string Title, DateTime ScheduledAt, string Status, int PlayerCount, long GmId);
+
+public sealed class ListSessionsHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient botClient)
+{
+    public async Task HandleAsync(Message message, CancellationToken cancellationToken)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken);
+
+        var sessions = await connection.QueryAsync<SessionListItemDto>(
+            @"SELECT s.id as Id, s.title as Title, s.scheduled_at as ScheduledAt, s.status as Status, 
+                     COUNT(sp.id) FILTER (WHERE sp.is_gm = false) as PlayerCount,
+                     g.gm_telegram_id as GmId
+              FROM sessions s
+              JOIN game_groups g ON s.group_id = g.id
+              LEFT JOIN session_participants sp ON s.id = sp.session_id
+              WHERE g.telegram_chat_id = @ChatId AND s.status != 'Cancelled' AND s.scheduled_at > NOW()
+              GROUP BY s.id, s.title, s.scheduled_at, s.status, g.gm_telegram_id
+              ORDER BY s.scheduled_at ASC",
+            new { ChatId = message.Chat.Id });
+
+        var sessionsList = sessions.ToList();
+
+        if (sessionsList.Count == 0)
+        {
+            await botClient.SendMessage(
+                chatId: message.Chat.Id,
+                text: "📭 В этой группе нет предстоящих игр.",
+                cancellationToken: cancellationToken);
+            return;
+        }
+
+        var text = "📅 <b>Ближайшие игры:</b>\n\n";
+        foreach (var s in sessionsList)
+        {
+            text += $"🔹 <b>{s.ScheduledAt.FormatMoscow()}</b> — {System.Net.WebUtility.HtmlEncode(s.Title)} (Участников: {s.PlayerCount})\n";
+        }
+
+        var isGm = message.From?.Id == sessionsList.First().GmId;
+        var keyboard = isGm 
+            ? new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
+                sessionsList.Select(s => new[] { Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton.WithCallbackData($"🗑 Удалить {s.ScheduledAt.FormatMoscowShort()}", $"delete_session:{s.Id}") }))
+            : null;
+
+        await botClient.SendMessage(
+            chatId: message.Chat.Id,
+            text: text,
+            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+            replyMarkup: keyboard,
+            cancellationToken: cancellationToken);
+    }
+}
@@ -0,0 +1,265 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+// ── DTOs ─────────────────────────────────────────────────────────────
+
+internal sealed record AwaitingProposalDto(
+    Guid Id, Guid SessionId, string Title, DateTime CurrentScheduledAt,
+    Guid BatchId, int? BatchMessageId, long TelegramChatId);
+
+internal sealed record VoteParticipantDto(Guid PlayerId, string DisplayName, string? TelegramUsername);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Handles text input from the GM who has an AwaitingTime proposal.
+/// Parses the new time, creates a voting message, and tags all participants.
+/// If no participants are registered, reschedules immediately.
+/// </summary>
+public sealed class HandleRescheduleTimeInputHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<HandleRescheduleTimeInputHandler> logger)
+{
+    /// <summary>
+    /// Attempts to handle a text message as reschedule time input.
+    /// Returns true if it was handled (i.e. user had an AwaitingTime proposal).
+    /// </summary>
+    public async Task<bool> TryHandleAsync(Message message, CancellationToken ct)
+    {
+        if (message.From is null || string.IsNullOrWhiteSpace(message.Text))
+            return false;
+
+        var gmTelegramId = message.From.Id;
+        var chatId = message.Chat.Id;
+        var text = message.Text.Trim();
+
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        // 1. Check if this GM has an AwaitingTime proposal in this chat
+        var proposal = await connection.QuerySingleOrDefaultAsync<AwaitingProposalDto>(
+            """
+            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
+            FROM reschedule_proposals rp
+            JOIN sessions s ON s.id = rp.session_id
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE rp.proposed_by = @GmId
+              AND rp.status = 'AwaitingTime'
+              AND g.telegram_chat_id = @ChatId
+            ORDER BY rp.created_at DESC
+            LIMIT 1
+            """,
+            new { GmId = gmTelegramId, ChatId = chatId });
+
+        if (proposal is null)
+            return false;
+
+        // 2. Parse the new time
+        if (!MoscowTime.TryParseMoscow(text, out var newTime))
+        {
+            await bot.SendMessage(
+                chatId: chatId,
+                text: "⚠️ Не удалось распознать время. Используйте формат: <code>ДД.ММ.ГГГГ ЧЧ:ММ</code>\nНапример: <code>25.04.2026 19:30</code>",
+                parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                cancellationToken: ct);
+            return true;
+        }
+
+        if (newTime <= DateTimeOffset.UtcNow)
+        {
+            await bot.SendMessage(
+                chatId: chatId,
+                text: "⚠️ Новое время должно быть в будущем. Попробуйте снова.",
+                cancellationToken: ct);
+            return true;
+        }
+
+        // 3. Load participants (non-GM) signed up for this session
+        var participants = (await connection.QueryAsync<VoteParticipantDto>(
+            """
+            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            """,
+            new { proposal.SessionId })).ToList();
+
+        // 4. If no participants — reschedule immediately
+        if (participants.Count == 0)
+        {
+            await RescheduleImmediately(connection, proposal, newTime, chatId, ct);
+            await TryDeleteMessage(chatId, message.MessageId, ct);
+            return true;
+        }
+
+        // 5. Create voting message
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        // Update proposal with proposed time and Voting status
+        await connection.ExecuteAsync(
+            """
+            UPDATE reschedule_proposals
+            SET proposed_at = @ProposedAt, status = 'Voting', vote_chat_id = @ChatId
+            WHERE id = @Id
+            """,
+            new { ProposedAt = newTime, ChatId = chatId, Id = proposal.Id },
+            transaction);
+
+        await transaction.CommitAsync(ct);
+
+        // Build voting message text
+        var voteText = BuildVotingMessage(proposal.Title, proposal.CurrentScheduledAt, newTime, participants, []);
+        
+        var keyboard = new InlineKeyboardMarkup([
+            [
+                InlineKeyboardButton.WithCallbackData("✅ Согласен", $"reschedule_vote:yes:{proposal.Id}"),
+                InlineKeyboardButton.WithCallbackData("❌ Против", $"reschedule_vote:no:{proposal.Id}")
+            ]
+        ]);
+
+        var voteMsg = await bot.SendMessage(
+            chatId: chatId,
+            text: voteText,
+            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+            replyMarkup: keyboard,
+            cancellationToken: ct);
+
+        // Store vote message ID
+        await connection.ExecuteAsync(
+            "UPDATE reschedule_proposals SET vote_message_id = @MsgId WHERE id = @Id",
+            new { MsgId = voteMsg.MessageId, Id = proposal.Id });
+
+        logger.LogInformation("Reschedule voting started for session {SessionId}, proposal {ProposalId}", proposal.SessionId, proposal.Id);
+
+        // Delete GM's time input message
+        await TryDeleteMessage(chatId, message.MessageId, ct);
+
+        return true;
+    }
+
+    private async Task RescheduleImmediately(
+        NpgsqlConnection connection, AwaitingProposalDto proposal,
+        DateTimeOffset newTime, long chatId, CancellationToken ct)
+    {
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        await connection.ExecuteAsync(
+            """
+            UPDATE sessions SET scheduled_at = @NewTime, status = 'Planned', updated_at = now()
+            WHERE id = @SessionId
+            """,
+            new { NewTime = newTime, proposal.SessionId },
+            transaction);
+
+        await connection.ExecuteAsync(
+            "UPDATE reschedule_proposals SET proposed_at = @NewTime, status = 'Approved' WHERE id = @Id",
+            new { NewTime = newTime, Id = proposal.Id },
+            transaction);
+
+        await transaction.CommitAsync(ct);
+
+        await bot.SendMessage(
+            chatId: chatId,
+            text: $"✅ Сессия «{proposal.Title}» перенесена!\n\n📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)\n\n<i>Участников нет — голосование не требуется.</i>",
+            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+            cancellationToken: ct);
+
+        // Re-render batch message with updated time
+        await TryUpdateBatchMessage(proposal, ct);
+
+        logger.LogInformation("Session {SessionId} rescheduled immediately (no participants)", proposal.SessionId);
+    }
+
+    internal static string BuildVotingMessage(
+        string title, DateTime currentTime, DateTimeOffset newTime,
+        IReadOnlyList<VoteParticipantDto> participants,
+        IReadOnlyCollection<Guid> approvedPlayerIds)
+    {
+        var lines = new List<string>
+        {
+            $"🔄 <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(title)}»</b>",
+            "",
+            $"📅 Текущее время: <b>{currentTime.FormatMoscow()}</b> (МСК)",
+            $"📅 Новое время: <b>{newTime.ToOffset(TimeSpan.FromHours(3)).ToString("d MMMM yyyy, HH:mm", System.Globalization.CultureInfo.GetCultureInfo("ru-RU"))}</b> (МСК)",
+            "",
+            "Для переноса нужно согласие всех участников:"
+        };
+
+        foreach (var p in participants)
+        {
+            var name = p.TelegramUsername is not null ? $"@{p.TelegramUsername}" : p.DisplayName;
+            var icon = approvedPlayerIds.Contains(p.PlayerId) ? "✅" : "⏳";
+            lines.Add($"   {icon} {name}");
+        }
+
+        lines.Add("");
+        lines.Add($"Голоса: {approvedPlayerIds.Count}/{participants.Count} ✅");
+
+        return string.Join("\n", lines);
+    }
+
+    private async Task TryUpdateBatchMessage(AwaitingProposalDto proposal, CancellationToken ct)
+    {
+        try
+        {
+            await using var conn = await dataSource.OpenConnectionAsync(ct);
+
+            var batchSessions = (await conn.QueryAsync<GmRelay.Bot.Features.Sessions.CreateSession.SessionBatchDto>(
+                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                new { proposal.BatchId })).ToList();
+
+            var batchParticipants = (await conn.QueryAsync<GmRelay.Bot.Features.Sessions.CreateSession.ParticipantBatchDto>(
+                """
+                SELECT sp.session_id AS SessionId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+                FROM session_participants sp
+                JOIN players p ON sp.player_id = p.id
+                JOIN sessions s ON sp.session_id = s.id
+                WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                ORDER BY sp.responded_at ASC, p.created_at ASC
+                """,
+                new { proposal.BatchId })).ToList();
+
+            if (proposal.BatchMessageId.HasValue)
+            {
+                var renderResult = GmRelay.Bot.Features.Sessions.CreateSession.SessionBatchRenderer.Render(
+                    proposal.Title, batchSessions, batchParticipants);
+
+                await bot.EditMessageText(
+                    chatId: proposal.TelegramChatId,
+                    messageId: proposal.BatchMessageId.Value,
+                    text: renderResult.Text,
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    replyMarkup: renderResult.Markup,
+                    cancellationToken: ct);
+            }
+            else
+            {
+                logger.LogWarning("No batch_message_id stored for session {SessionId}, cannot edit batch message in-place", proposal.SessionId);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to update batch message after immediate reschedule for session {SessionId}", proposal.SessionId);
+        }
+    }
+
+    private async Task TryDeleteMessage(long chatId, int messageId, CancellationToken ct)
+    {
+        try
+        {
+            await bot.DeleteMessage(chatId, messageId, cancellationToken: ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to delete message {MessageId} in chat {ChatId}", messageId, chatId);
+        }
+    }
+}
@@ -0,0 +1,313 @@
+using Dapper;
+using GmRelay.Bot.Domain;
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+// ── Command ──────────────────────────────────────────────────────────
+
+public sealed record HandleRescheduleVoteCommand(
+    Guid ProposalId,
+    string Vote,           // "yes" or "no"
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+// ── DTOs ─────────────────────────────────────────────────────────────
+
+internal sealed record VoteProposalDto(
+    Guid Id,
+    Guid SessionId,
+    DateTime ProposedAt,
+    string Title,
+    DateTime CurrentScheduledAt,
+    Guid BatchId,
+    string SessionStatus,
+    long TelegramChatId,
+    int? ConfirmationMessageId,
+    int? BatchMessageId);
+
+internal sealed record VoteCountDto(int Total, int Approved);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Handles "✅ Согласен" / "❌ Против" votes on a reschedule proposal.
+/// 
+/// If anyone votes no → proposal rejected, old time stays.
+/// If all vote yes → session time updated, batch message re-rendered,
+/// session status reset to Planned so confirmation triggers work correctly.
+/// </summary>
+public sealed class HandleRescheduleVoteHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<HandleRescheduleVoteHandler> logger)
+{
+    public async Task HandleAsync(HandleRescheduleVoteCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await using var transaction = await connection.BeginTransactionAsync(ct);
+
+        // 1. Load proposal + session info
+        var proposal = await connection.QuerySingleOrDefaultAsync<VoteProposalDto>(
+            """
+            SELECT rp.id AS Id, rp.session_id AS SessionId, rp.proposed_at AS ProposedAt,
+                   s.title AS Title, s.scheduled_at AS CurrentScheduledAt,
+                   s.batch_id AS BatchId, s.status AS SessionStatus,
+                   s.confirmation_message_id AS ConfirmationMessageId,
+                   s.batch_message_id AS BatchMessageId,
+                   g.telegram_chat_id AS TelegramChatId
+            FROM reschedule_proposals rp
+            JOIN sessions s ON s.id = rp.session_id
+            JOIN game_groups g ON g.id = s.group_id
+            WHERE rp.id = @ProposalId AND rp.status = 'Voting'
+            """,
+            new { command.ProposalId },
+            transaction);
+
+        if (proposal is null)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId,
+                "Голосование уже завершено или не найдено.", cancellationToken: ct);
+            return;
+        }
+
+        // 2. Verify voter is a participant of this session
+        var playerId = await connection.ExecuteScalarAsync<Guid?>(
+            """
+            SELECT p.id
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId
+              AND p.telegram_id = @TelegramUserId
+              AND sp.is_gm = false
+            """,
+            new { proposal.SessionId, command.TelegramUserId },
+            transaction);
+
+        if (playerId is null)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId,
+                "Вы не являетесь участником этой сессии.", cancellationToken: ct);
+            return;
+        }
+
+        // 3. Record vote (upsert)
+        var inserted = await connection.ExecuteAsync(
+            """
+            INSERT INTO reschedule_votes (proposal_id, player_id, vote)
+            VALUES (@ProposalId, @PlayerId, @Vote)
+            ON CONFLICT (proposal_id, player_id) DO UPDATE SET vote = EXCLUDED.vote, voted_at = now()
+            """,
+            new { command.ProposalId, PlayerId = playerId.Value, command.Vote },
+            transaction);
+
+        // 4. Handle "no" vote — immediately reject
+        if (command.Vote == "no")
+        {
+            await connection.ExecuteAsync(
+                "UPDATE reschedule_proposals SET status = 'Rejected' WHERE id = @Id",
+                new { Id = command.ProposalId },
+                transaction);
+
+            await transaction.CommitAsync(ct);
+
+            // Get voter's name
+            var voterName = await connection.QuerySingleOrDefaultAsync<string>(
+                "SELECT display_name FROM players WHERE telegram_id = @TgId",
+                new { TgId = command.TelegramUserId });
+
+            // Update voting message — show rejection
+            try
+            {
+                await bot.EditMessageText(
+                    chatId: command.ChatId,
+                    messageId: command.MessageId,
+                    text: $"❌ <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(proposal.Title)}» отклонён!</b>\n\n{voterName ?? "Участник"} проголосовал(а) против. Время сессии остаётся прежним:\n📅 <b>{proposal.CurrentScheduledAt.FormatMoscow()}</b> (МСК)",
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    cancellationToken: ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to update vote message after rejection");
+            }
+
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Вы проголосовали против переноса.", cancellationToken: ct);
+            logger.LogInformation("Reschedule proposal {ProposalId} rejected by player {PlayerId}", command.ProposalId, playerId);
+            return;
+        }
+
+        // 5. Handle "yes" vote — check if all approved
+        var participants = (await connection.QueryAsync<VoteParticipantDto>(
+            """
+            SELECT p.id AS PlayerId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+            FROM session_participants sp
+            JOIN players p ON p.id = sp.player_id
+            WHERE sp.session_id = @SessionId AND sp.is_gm = false
+            """,
+            new { proposal.SessionId },
+            transaction)).ToList();
+
+        var approvedPlayerIds = (await connection.QueryAsync<Guid>(
+            """
+            SELECT player_id FROM reschedule_votes
+            WHERE proposal_id = @ProposalId AND vote = 'yes'
+            """,
+            new { command.ProposalId },
+            transaction)).ToHashSet();
+
+        var allApproved = approvedPlayerIds.Count == participants.Count;
+
+        if (allApproved)
+        {
+            // 6. All approved — reschedule!
+            var newTime = new DateTimeOffset(proposal.ProposedAt, TimeSpan.Zero); // ProposedAt is stored in UTC
+
+            // Update session time and reset status to Planned for fresh notification cycle
+            await connection.ExecuteAsync(
+                """
+                UPDATE sessions
+                SET scheduled_at = @NewTime,
+                    status = 'Planned',
+                    confirmation_message_id = NULL,
+                    link_message_id = NULL,
+                    updated_at = now()
+                WHERE id = @SessionId
+                """,
+                new { NewTime = newTime, proposal.SessionId },
+                transaction);
+
+            await connection.ExecuteAsync(
+                "UPDATE reschedule_proposals SET status = 'Approved' WHERE id = @Id",
+                new { Id = command.ProposalId },
+                transaction);
+
+            // Reset all participant RSVP to Pending for the new confirmation cycle
+            await connection.ExecuteAsync(
+                """
+                UPDATE session_participants
+                SET rsvp_status = 'Pending', responded_at = NULL
+                WHERE session_id = @SessionId AND is_gm = false
+                """,
+                new { proposal.SessionId },
+                transaction);
+
+            await transaction.CommitAsync(ct);
+
+            // Update voting message — show approval
+            try
+            {
+                await bot.EditMessageText(
+                    chatId: command.ChatId,
+                    messageId: command.MessageId,
+                    text: $"✅ <b>Перенос сессии «{System.Net.WebUtility.HtmlEncode(proposal.Title)}» одобрен!</b>\n\nВсе участники согласились.\n📅 Новое время: <b>{proposal.ProposedAt.FormatMoscow()}</b> (МСК)\n\n<i>Уведомления будут приходить согласно новому расписанию.</i>",
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    cancellationToken: ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to update vote message after approval");
+            }
+
+            // Re-render batch message
+            await TryUpdateBatchMessage(proposal, ct);
+
+            logger.LogInformation("Session {SessionId} rescheduled to {NewTime} (proposal {ProposalId})",
+                proposal.SessionId, newTime, command.ProposalId);
+        }
+        else
+        {
+            // Not all voted yet — update the voting message to show progress
+            await transaction.CommitAsync(ct);
+
+            var voteText = HandleRescheduleTimeInputHandler.BuildVotingMessage(
+                proposal.Title, proposal.CurrentScheduledAt,
+                new DateTimeOffset(proposal.ProposedAt, TimeSpan.Zero),
+                participants, approvedPlayerIds);
+
+            var keyboard = new InlineKeyboardMarkup([
+                [
+                    InlineKeyboardButton.WithCallbackData("✅ Согласен", $"reschedule_vote:yes:{command.ProposalId}"),
+                    InlineKeyboardButton.WithCallbackData("❌ Против", $"reschedule_vote:no:{command.ProposalId}")
+                ]
+            ]);
+
+            try
+            {
+                await bot.EditMessageText(
+                    chatId: command.ChatId,
+                    messageId: command.MessageId,
+                    text: voteText,
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    replyMarkup: keyboard,
+                    cancellationToken: ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to update vote message with progress");
+            }
+        }
+
+        await bot.AnswerCallbackQuery(command.CallbackQueryId,
+            allApproved ? "Вы подтвердили перенос! Все согласны — время обновлено." : "Вы подтвердили перенос!",
+            cancellationToken: ct);
+    }
+
+    /// <summary>
+    /// Re-renders the batch schedule message to reflect the updated session time.
+    /// If batch_message_id is stored, edits the original message. Otherwise sends a notification.
+    /// </summary>
+    private async Task TryUpdateBatchMessage(VoteProposalDto proposal, CancellationToken ct)
+    {
+        try
+        {
+            await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+            var batchSessions = (await connection.QueryAsync<SessionBatchDto>(
+                "SELECT id AS SessionId, scheduled_at AS ScheduledAt, status AS Status FROM sessions WHERE batch_id = @BatchId ORDER BY scheduled_at",
+                new { proposal.BatchId })).ToList();
+
+            var batchParticipants = (await connection.QueryAsync<ParticipantBatchDto>(
+                """
+                SELECT sp.session_id AS SessionId, p.display_name AS DisplayName, p.telegram_username AS TelegramUsername
+                FROM session_participants sp
+                JOIN players p ON sp.player_id = p.id
+                JOIN sessions s ON sp.session_id = s.id
+                WHERE s.batch_id = @BatchId AND sp.is_gm = false
+                ORDER BY sp.responded_at ASC, p.created_at ASC
+                """,
+                new { proposal.BatchId })).ToList();
+
+            if (proposal.BatchMessageId.HasValue)
+            {
+                // Edit the original batch schedule message in-place
+                var renderResult = SessionBatchRenderer.Render(proposal.Title, batchSessions, batchParticipants);
+
+                await bot.EditMessageText(
+                    chatId: proposal.TelegramChatId,
+                    messageId: proposal.BatchMessageId.Value,
+                    text: renderResult.Text,
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    replyMarkup: renderResult.Markup,
+                    cancellationToken: ct);
+            }
+            else
+            {
+                // Fallback for sessions created before V005 migration (no batch_message_id)
+                await bot.SendMessage(
+                    chatId: proposal.TelegramChatId,
+                    text: $"📢 Расписание обновлено! Сессия «{proposal.Title}» перенесена на <b>{proposal.ProposedAt.FormatMoscow()}</b> (МСК).",
+                    parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+                    cancellationToken: ct);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to update batch message for proposal {ProposalId}", proposal.Id);
+        }
+    }
+}
@@ -0,0 +1,96 @@
+using Dapper;
+using Npgsql;
+using Telegram.Bot;
+
+namespace GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+// ── Command ──────────────────────────────────────────────────────────
+
+public sealed record InitiateRescheduleCommand(
+    Guid SessionId,
+    long TelegramUserId,
+    string CallbackQueryId,
+    long ChatId,
+    int MessageId);
+
+// ── DTOs ─────────────────────────────────────────────────────────────
+
+internal sealed record RescheduleSessionInfoDto(string Title, long GmId);
+
+// ── Handler ──────────────────────────────────────────────────────────
+
+/// <summary>
+/// Handles the "⏰ Перенести" button press from the batch message.
+/// Creates a reschedule proposal in AwaitingTime status and prompts
+/// the GM to enter the new time via a regular text message.
+/// </summary>
+public sealed class InitiateRescheduleHandler(
+    NpgsqlDataSource dataSource,
+    ITelegramBotClient bot,
+    ILogger<InitiateRescheduleHandler> logger)
+{
+    public async Task HandleAsync(InitiateRescheduleCommand command, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        // 1. Verify GM ownership
+        var session = await connection.QuerySingleOrDefaultAsync<RescheduleSessionInfoDto>(
+            """
+            SELECT s.title AS Title, g.gm_telegram_id AS GmId
+            FROM sessions s
+            JOIN game_groups g ON s.group_id = g.id
+            WHERE s.id = @SessionId AND s.status != 'Cancelled'
+            """,
+            new { command.SessionId });
+
+        if (session is null)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId, "Сессия не найдена.", cancellationToken: ct);
+            return;
+        }
+
+        if (session.GmId != command.TelegramUserId)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId,
+                "Только Мастер Игры (GM) может переносить сессию.", showAlert: true, cancellationToken: ct);
+            return;
+        }
+
+        // 2. Check no active proposal exists
+        var hasActive = await connection.ExecuteScalarAsync<bool>(
+            """
+            SELECT EXISTS (
+                SELECT 1 FROM reschedule_proposals
+                WHERE session_id = @SessionId AND status IN ('AwaitingTime', 'Voting')
+            )
+            """,
+            new { command.SessionId });
+
+        if (hasActive)
+        {
+            await bot.AnswerCallbackQuery(command.CallbackQueryId,
+                "Уже есть активный запрос на перенос этой сессии.", showAlert: true, cancellationToken: ct);
+            return;
+        }
+
+        // 3. Create proposal in AwaitingTime status
+        await connection.ExecuteAsync(
+            """
+            INSERT INTO reschedule_proposals (session_id, proposed_by, status)
+            VALUES (@SessionId, @GmId, 'AwaitingTime')
+            """,
+            new { command.SessionId, GmId = command.TelegramUserId });
+
+        logger.LogInformation("Reschedule initiated for session {SessionId} by GM {GmId}", command.SessionId, command.TelegramUserId);
+
+        // 4. Prompt GM in chat
+        await bot.AnswerCallbackQuery(command.CallbackQueryId,
+            "Введите новое время в чат (формат: ДД.ММ.ГГГГ ЧЧ:ММ)", cancellationToken: ct);
+
+        await bot.SendMessage(
+            chatId: command.ChatId,
+            text: $"⏰ Укажите новое время для сессии «{session.Title}» в формате:\n<code>ДД.ММ.ГГГГ ЧЧ:ММ</code>\n\nНапример: <code>25.04.2026 19:30</code>",
+            parseMode: Telegram.Bot.Types.Enums.ParseMode.Html,
+            cancellationToken: ct);
+    }
+}