@chore(release): bump version to 3.8.0 (issue #111)

Game-creation wizard: replace /newsession text template with step-by-step
inline-keyboard flow for single games and game pools.

- Directory.Build.props: 3.7.1 -> 3.8.0
- compose.yaml: pin bot, discord-bot and web images to 3.8.0
- deploy.yml VERSION env: 3.7.1 -> 3.8.0
- NavMenu.razor: nav-version 3.7.1 -> 3.8.0

🤖 Generated with Claude Code
@

.gitea/workflows/deploy.yml

@@ -6,7 +6,7 @@ on:
       - main 
 
 env:
-  VERSION: 3.7.0
+  VERSION: 3.8.0
 
 jobs:
   # ЧАСТЬ 1: Собираем образы и кладем в Gitea (чтобы делиться с ребятами)

Directory.Build.props

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

compose.yaml

@@ -49,7 +49,7 @@ services:
         crond -f
 
   bot:
-    image: git.codeanddice.ru/toutsu/gmrelay-bot:3.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-bot:3.8.0
     restart: always
     depends_on:
       db:
@@ -67,7 +67,7 @@ services:
       retries: 3
 
   discord:
-    image: git.codeanddice.ru/toutsu/gmrelay-discord-bot:3.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-discord-bot:3.8.0
     restart: always
     depends_on:
       db:
@@ -86,7 +86,7 @@ services:
       retries: 3
 
   web:
-    image: git.codeanddice.ru/toutsu/gmrelay-web:3.7.0
+    image: git.codeanddice.ru/toutsu/gmrelay-web:3.8.0
     restart: always
     depends_on:
       db:

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

@@ -1,194 +1,254 @@
-using Dapper;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Sessions.CreateSession;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Shared.Platform;
-using GmRelay.Bot.Infrastructure.Telegram;
-using Npgsql;
-using Telegram.Bot;
+using Microsoft.Extensions.Logging;
 using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+using SharedCreateSessionHandler = GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionHandler;
 
 namespace GmRelay.Bot.Features.Sessions.CreateSession;
 
-public sealed class CreateSessionHandler(
-    GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionHandler sharedHandler,
-    NpgsqlDataSource dataSource,
-    IPlatformMessenger messenger,
-    ILogger<CreateSessionHandler> logger)
+/// <summary>
+/// Wizard-driven entry point for game-session creation. Replaces the legacy
+/// text-template parser. Exposes <see cref="StartWizardAsync"/> (called from
+/// <c>/newsession</c>), <see cref="TryResumeAsync"/> (continue a draft), and
+/// <see cref="SubmitDraftAsync"/> (finalize on "✅ Создать" callback).
+/// </summary>
+public sealed class CreateSessionHandler
 {
-    public async Task HandleAsync(Message message, CancellationToken ct)
+    private const int MaxRetries = 3;
+
+    private readonly IWizardDraftRepository _drafts;
+    private readonly SharedCreateSessionHandler _shared;
+    private readonly ITelegramWizardMessenger _messenger;
+    private readonly ILogger<CreateSessionHandler> _log;
+
+    public CreateSessionHandler(
+        IWizardDraftRepository drafts,
+        SharedCreateSessionHandler shared,
+        ITelegramWizardMessenger messenger,
+        ILogger<CreateSessionHandler> log)
     {
-        var parseResult = NewSessionCommandParser.Parse(message.Text ?? message.Caption, DateTimeOffset.UtcNow);
+        _drafts = drafts;
+        _shared = shared;
+        _messenger = messenger;
+        _log = log;
+    }
 
-        foreach (var timeInput in parseResult.PastTimeInputs)
+    /// <summary>
+    /// Entry point for <c>/newsession</c>. If a non-expired draft already exists for
+    /// this (chat, thread, owner), returns <c>null</c> so the caller can render a
+    /// "Continue / Start over / Cancel" menu.
+    /// </summary>
+    public async Task<WizardDraft?> StartWizardAsync(Message message, CancellationToken ct)
+    {
+        var existing = await _drafts.GetActiveAsync(
+            message.Chat.Id, message.MessageThreadId, message.From?.Id ?? 0, ct);
+        if (existing is not null)
         {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                $"⚠️ Предупреждение: дата {timeInput} находится в прошлом и будет пропущена.",
-                ct);
+            return null;
         }
 
-        foreach (var timeInput in parseResult.InvalidTimeInputs)
+        var draft = new WizardDraft
         {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                $"⚠️ Предупреждение: некорректный формат времени '{timeInput}'. Пропущено.",
-                ct);
-        }
+            Id = Guid.NewGuid(),
+            ChatId = message.Chat.Id,
+            MessageThreadId = message.MessageThreadId,
+            OwnerTelegramId = message.From?.Id ?? 0,
+            Step = WizardStepNames.Type,
+            CreatedAt = DateTimeOffset.UtcNow,
+            UpdatedAt = DateTimeOffset.UtcNow,
+            ExpiresAt = DateTimeOffset.UtcNow.AddHours(24),
+        };
+        await _drafts.UpsertAsync(draft, ct);
 
-        foreach (var seatLimitInput in parseResult.InvalidSeatLimitInputs)
+        var (text, kb) = WizardStep.Render(draft, new WizardPayload());
+        var msgId = await _messenger.SendGroupMessageAsync(
+            draft.ChatId, draft.MessageThreadId, text, kb, ct);
+        draft.DraftMessageId = msgId;
+        draft.UpdatedAt = DateTimeOffset.UtcNow;
+        await _drafts.UpsertAsync(draft, ct);
+        return draft;
+    }
+
+    /// <summary>
+    /// Resume an existing draft — returns the draft row so the caller can re-render.
+    /// </summary>
+    public Task<WizardDraft?> TryResumeAsync(Message message, CancellationToken ct) =>
+        _drafts.GetActiveAsync(
+            message.Chat.Id, message.MessageThreadId, message.From?.Id ?? 0, ct);
+
+    /// <summary>
+    /// Finalize: build shared command(s), call the shared handler, edit the wizard message.
+    /// On failure, retry up to <see cref="MaxRetries"/> times before deleting the draft.
+    /// </summary>
+    public async Task SubmitDraftAsync(WizardDraft draft, CancellationToken ct)
+    {
+        var payload = LoadPayload(draft);
+        if (!IsComplete(payload, out var missing))
         {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                $"⚠️ Предупреждение: некорректный лимит мест '{seatLimitInput}'. Укажите целое число больше 0.",
-                ct);
-        }
-
-        foreach (var recurringInput in parseResult.InvalidRecurringInputs)
-        {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                $"⚠️ Предупреждение: некорректный повтор расписания '{recurringInput}'. Укажите число игр 1-52 и шаг 1-365 дней.",
-                ct);
-        }
-
-        if (!parseResult.IsValid)
-        {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                """
-                ❌ Не удалось распознать формат. Пожалуйста, используйте шаблон:
-
-                /newsession
-                Название: My Game
-                Время: 15.05.2026 19:30
-                Время: 22.05.2026 19:30
-                Мест: 4
-                Ссылка: https://link
-                Картинка: https://cover
-
-                Для повтора можно указать одну дату и строки:
-                Игр: 4
-                Интервал: 7
-                """,
-                ct);
+            await _messenger.EditMessageTextAsync(
+                draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+                $"❌ Не заполнены поля: {missing}", EmptyKeyboard(), ct);
             return;
         }
 
-        var imageReference = GetBatchImageReference(message, parseResult.ImageUrl);
-        var gmId = message.From!.Id;
-        var gmName = message.From.FirstName + (string.IsNullOrEmpty(message.From.LastName) ? string.Empty : $" {message.From.LastName}");
-        var gmUsername = message.From.Username;
-
-        var topicDestination = TelegramTopicRouting.ResolveNewScheduleDestination(
-            message.Chat.IsForum,
-            message.MessageThreadId);
-        var topicCreatedByBot = topicDestination.TopicCreatedByBot;
-        var messageThreadId = topicDestination.MessageThreadId;
-
-        if (topicDestination.ShouldCreateForumTopic)
-        {
-            try
-            {
-                var topicRef = await messenger.CreateThreadAsync(
-                    TelegramPlatformIds.Group(message.Chat.Id, null),
-                    $"🎲 Игры: {parseResult.Title}",
-                    ct);
-                messageThreadId = int.Parse(topicRef.ExternalThreadId!, System.Globalization.CultureInfo.InvariantCulture);
-            }
-            catch (Exception ex)
-                when (ex.Message.Contains("not enough rights") ||
-                      ex.Message.Contains("CHAT_ADMIN_REQUIRED") ||
-                      ex.Message.Contains("not an administrator"))
-            {
-                await messenger.SendGroupMessageAsync(
-                    TelegramPlatformIds.Group(message.Chat.Id, null),
-                    TelegramTopicRouting.MissingForumTopicRightsMessage,
-                    ct);
-                return;
-            }
-        }
-
-        var platformGroup = TelegramPlatformIds.Group(message.Chat.Id, messageThreadId, message.Chat.Title ?? "Private Chat");
-        var platformUser = new PlatformUser(
-            PlatformKind.Telegram,
-            gmId.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            gmName,
-            gmUsername);
-
-        var command = new GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionCommand(
-            platformUser,
-            platformGroup,
-            parseResult.Title!,
-            parseResult.Link!,
-            parseResult.ScheduledTimes,
-            parseResult.MaxPlayers,
-            imageReference);
-
-        GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionResult result;
+        var commands = BuildCommands(draft, payload);
         try
         {
-            result = await sharedHandler.HandleAsync(command, ct);
-        }
-        catch
-        {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                "💥 Произошла ошибка базы данных при создании сессии.",
-                ct);
-            throw;
-        }
-
-        if (!result.Success)
-        {
-            await messenger.SendGroupMessageAsync(
-                TelegramPlatformIds.Group(message.Chat.Id, null),
-                result.ErrorMessage!,
-                ct);
-            return;
-        }
-
-        var scheduleMessage = new PlatformScheduleMessage(
-            platformGroup,
-            result.View!,
-            null,
-            imageReference);
-
-        var sentMessageRef = await messenger.SendScheduleAsync(scheduleMessage, ct);
-
-        // Store batch_message_id
-        if (int.TryParse(sentMessageRef.ExternalMessageId, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var batchMessageId))
-        {
-            await using var connection = await dataSource.OpenConnectionAsync(ct);
-            await connection.ExecuteAsync(
-                "UPDATE sessions SET batch_message_id = @MsgId WHERE batch_id = @BatchId",
-                new { MsgId = batchMessageId, BatchId = result.BatchId });
-        }
-
-        // Delete original message
-        try
-        {
-            await messenger.DeleteMessageAsync(
-                TelegramPlatformIds.Message(message.Chat.Id, null, message.MessageId),
-                ct);
+            foreach (var cmd in commands)
+            {
+                await _shared.HandleAsync(cmd, ct);
+            }
+            var totalSessions = commands.Sum(c => c.ScheduledTimes.Count);
+            await _messenger.EditMessageTextAsync(
+                draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+                $"✅ Создано: {totalSessions} {(totalSessions == 1 ? "сессия" : "сессий")}",
+                EmptyKeyboard(), ct);
+            await _drafts.DeleteAsync(draft.Id, ct);
         }
         catch (Exception ex)
         {
-            logger.LogWarning(ex, "Не удалось удалить исходное сообщение {MessageId} в чате {ChatId}", message.MessageId, message.Chat.Id);
+            _log.LogError(ex, "SubmitDraftAsync failed for draft {DraftId}", draft.Id);
+            payload.RetryCount += 1;
+            SavePayload(draft, payload);
+            if (payload.RetryCount >= MaxRetries)
+            {
+                await _messenger.EditMessageTextAsync(
+                    draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+                    "💥 Не удалось создать сессию после 3 попыток. Используйте /newsession, чтобы начать заново.",
+                    EmptyKeyboard(), ct);
+                await _drafts.DeleteAsync(draft.Id, ct);
+                return;
+            }
+            draft.UpdatedAt = DateTimeOffset.UtcNow;
+            await _drafts.UpsertAsync(draft, ct);
+            await _messenger.EditMessageTextAsync(
+                draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+                $"💥 Ошибка: {ex.Message}\nПопытка {payload.RetryCount}/{MaxRetries}.",
+                RetryCancelKeyboard(), ct);
         }
     }
 
-    internal static string? GetBatchImageReference(Message message, string? parsedImageUrl)
+    // ── Build shared commands ────────────────────────────────────────
+    // The shared handler creates one session per scheduled time in a single transaction
+    // and assigns the same batch_id to all of them. A wizard pool therefore produces ONE
+    // command with N times; a single-game wizard produces ONE command with one time.
+    private static List<CreateSessionCommand> BuildCommands(WizardDraft draft, WizardPayload p)
     {
-        var attachedPhotoFileId = message.Photo?
-            .OrderByDescending(photo => photo.FileSize ?? 0)
-            .ThenByDescending(photo => photo.Width * photo.Height)
-            .FirstOrDefault()
-            ?.FileId;
-
-        if (!string.IsNullOrWhiteSpace(attachedPhotoFileId))
+        if (p.Type == WizardCreationType.Pool && p.Pool is { } pool && pool.Slots.Count > 0)
         {
-            return attachedPhotoFileId;
+            return new List<CreateSessionCommand>
+            {
+                BuildCommand(
+                    draft,
+                    p,
+                    pool.Slots.Select(s => s.ScheduledAt).ToList(),
+                    MaxPlayersForPool(pool),
+                    isOneShot: false)
+            };
         }
-
-        return string.IsNullOrWhiteSpace(parsedImageUrl) ? null : parsedImageUrl.Trim();
+        return new List<CreateSessionCommand>
+        {
+            BuildCommand(
+                draft,
+                p,
+                new[] { p.Single?.ScheduledAt ?? default },
+                p.Single?.MaxPlayers ?? 0,
+                isOneShot: true)
+        };
     }
+
+    private static int MaxPlayersForPool(WizardPoolInput pool) =>
+        pool.Slots.Count == 0 ? 0 : pool.Slots.Max(s => s.MaxPlayers);
+
+    private static CreateSessionCommand BuildCommand(
+        WizardDraft draft,
+        WizardPayload p,
+        IReadOnlyList<DateTimeOffset> scheduledTimes,
+        int maxPlayers,
+        bool isOneShot)
+    {
+        var gmId = draft.OwnerTelegramId;
+        var user = new PlatformUser(
+            PlatformKind.Telegram,
+            gmId.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            DisplayName: string.Empty,
+            ExternalUsername: null);
+        var group = new PlatformGroup(
+            PlatformKind.Telegram,
+            draft.ChatId.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            DisplayName: string.Empty,
+            ExternalChannelId: null,
+            ExternalThreadId: draft.MessageThreadId?.ToString(System.Globalization.CultureInfo.InvariantCulture));
+        return new CreateSessionCommand(
+            User: user,
+            Group: group,
+            Title: p.Title ?? string.Empty,
+            Link: string.Empty,
+            ScheduledTimes: scheduledTimes,
+            MaxPlayers: maxPlayers,
+            ImageReference: p.ImageFileId ?? p.ImageUrl,
+            System: ParseSystem(p.System),
+            Description: p.Description,
+            Format: null,
+            DurationMinutes: p.DurationMinutes,
+            IsOneShot: isOneShot);
+    }
+
+    private static GameSystem? ParseSystem(string? code)
+    {
+        if (string.IsNullOrWhiteSpace(code)) return null;
+        return Enum.TryParse<GameSystem>(code, ignoreCase: true, out var sys) ? sys : null;
+    }
+
+    // ── Validation ───────────────────────────────────────────────────
+    private static bool IsComplete(WizardPayload p, out string missing)
+    {
+        var missingFields = new List<string>();
+        if (string.IsNullOrWhiteSpace(p.Title)) missingFields.Add("название");
+        if (string.IsNullOrWhiteSpace(p.System)) missingFields.Add("система");
+        if (!p.DurationMinutes.HasValue) missingFields.Add("длительность");
+        if (p.Visibility is null) missingFields.Add("видимость");
+
+        if (p.Type == WizardCreationType.Single)
+        {
+            if (p.Single?.ScheduledAt is null) missingFields.Add("дата/время");
+            if (p.Single?.MaxPlayers is null) missingFields.Add("лимит мест");
+        }
+        else
+        {
+            if (p.Pool is null || p.Pool.Slots.Count == 0) missingFields.Add("слоты");
+        }
+        missing = string.Join(", ", missingFields);
+        return missingFields.Count == 0;
+    }
+
+    // ── Payload I/O ──────────────────────────────────────────────────
+    private static WizardPayload LoadPayload(WizardDraft draft)
+    {
+        if (string.IsNullOrEmpty(draft.PayloadJson)) return new WizardPayload();
+        return JsonSerializer.Deserialize(draft.PayloadJson, WizardPayloadJsonContext.Default.WizardPayload) ?? new WizardPayload();
+    }
+
+    private static void SavePayload(WizardDraft draft, WizardPayload p)
+    {
+        draft.PayloadJson = JsonSerializer.Serialize(p, WizardPayloadJsonContext.Default.WizardPayload);
+    }
+
+    // ── Keyboards ────────────────────────────────────────────────────
+    private static InlineKeyboardMarkup EmptyKeyboard() => new(Array.Empty<InlineKeyboardButton[]>());
+    private static InlineKeyboardMarkup RetryCancelKeyboard() => new(new[]
+    {
+        new[] { InlineKeyboardButton.WithCallbackData("🔁 Повторить", WizardCallbackData.Create()) },
+        new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена",    WizardCallbackData.Cancel()) },
+    });
 }

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

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

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/GameCreationWizard.cs

@@ -0,0 +1,504 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Logging;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Central state machine for the game/pool creation wizard.
+/// </summary>
+public sealed class GameCreationWizard
+{
+    private readonly IWizardDraftRepository _drafts;
+    private readonly ITelegramWizardMessenger _messenger;
+    private readonly ILogger<GameCreationWizard> _log;
+
+    public GameCreationWizard(
+        IWizardDraftRepository drafts,
+        ITelegramWizardMessenger messenger,
+        ILogger<GameCreationWizard> log)
+    {
+        _drafts = drafts;
+        _messenger = messenger;
+        _log = log;
+    }
+
+    /// <summary>Handle a text or callback update from the owning GM.</summary>
+    public async Task HandleUpdateAsync(Update update, WizardDraft draft, CancellationToken ct)
+    {
+        try
+        {
+            if (update.CallbackQuery is { } cb)
+            {
+                await HandleCallbackAsync(draft, cb, ct);
+            }
+            else if (update.Message is { } msg)
+            {
+                await HandleTextAsync(draft, msg, ct);
+            }
+        }
+        catch (WizardStorageException)
+        {
+            // Surface storage failure; do not crash the update loop.
+            if (update.CallbackQuery is { } cb2)
+            {
+                await _messenger.AnswerCallbackAsync(cb2.Id, "💥 Ошибка хранилища, попробуйте /newsession", ct);
+            }
+        }
+        catch (Exception ex)
+        {
+            _log.LogError(ex, "Wizard update failed for draft {DraftId}", draft.Id);
+            if (update.CallbackQuery is { } cb3)
+            {
+                try { await _messenger.AnswerCallbackAsync(cb3.Id, "⚠️ Ошибка", ct); }
+                catch { /* swallow — we're already in error path */ }
+            }
+        }
+    }
+
+    private async Task HandleCallbackAsync(WizardDraft draft, CallbackQuery cb, CancellationToken ct)
+    {
+        if (!WizardCallbackData.TryParse(cb.Data, out var action, out var step, out var choice))
+        {
+            await _messenger.AnswerCallbackAsync(cb.Id, "Неизвестная команда", ct);
+            return;
+        }
+
+        switch (action)
+        {
+            case "cancel":
+                await _drafts.DeleteAsync(draft.Id, ct);
+                await _messenger.EditMessageTextAsync(
+                    draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+                    "❌ Мастер отменён.", EmptyKeyboard, ct);
+                await _messenger.AnswerCallbackAsync(cb.Id, null, ct);
+                return;
+
+            case "back":
+                ApplyBack(draft, step);
+                await PersistAndRenderAsync(draft, cb.Id, ct);
+                return;
+
+            case "create":
+                // Routed by CreateSessionHandler, not here.
+                await _messenger.AnswerCallbackAsync(cb.Id, null, ct);
+                return;
+
+            default:
+                // For "Choice" callbacks, action == step.
+                await ApplyChoiceAsync(draft, step, choice, cb.Id, ct);
+                return;
+        }
+    }
+
+    private async Task HandleTextAsync(WizardDraft draft, Message msg, CancellationToken ct)
+    {
+        if (msg.Text is not { } text)
+        {
+            // Photo or other non-text — handle cover step only.
+            if (msg.Photo is { Length: > 0 } && draft.Step == WizardStepNames.Cover)
+            {
+                var fileId = msg.Photo[^1].FileId;
+                ApplyCoverPhoto(draft, fileId);
+                await PersistAndRenderAsync(draft, null, ct);
+            }
+            return;
+        }
+
+        var (nextStep, error, payload) = ApplyText(draft, text);
+        if (payload is { } p) SavePayload(draft, p);
+        if (error is { } errMsg && draft.DraftMessageId is { } mid)
+        {
+            // Re-render the same step with ⚠️ prefix.
+            var (rendered, kb) = WizardStep.Render(draft, LoadPayload(draft), null);
+            await _messenger.EditMessageTextAsync(
+                draft.ChatId, draft.MessageThreadId, mid,
+                "⚠️ " + errMsg + "\n\n" + rendered, kb, ct);
+            return;
+        }
+
+        if (nextStep is { } step)
+        {
+            draft.Step = step;
+        }
+        await PersistAndRenderAsync(draft, null, ct);
+    }
+
+    private async Task ApplyChoiceAsync(WizardDraft draft, string step, string choice, string callbackId, CancellationToken ct)
+    {
+        var (nextStep, error, payload) = ApplyChoice(draft, step, choice);
+        if (error is { } err)
+        {
+            await _messenger.AnswerCallbackAsync(callbackId, err, ct);
+            return;
+        }
+        if (payload is { } p) SavePayload(draft, p);
+        if (nextStep is { } s)
+        {
+            draft.Step = s;
+        }
+        await PersistAndRenderAsync(draft, callbackId, ct);
+    }
+
+    private async Task PersistAndRenderAsync(WizardDraft draft, string? callbackId, CancellationToken ct)
+    {
+        draft.UpdatedAt = DateTimeOffset.UtcNow;
+        await _drafts.UpsertAsync(draft, ct);
+        var payload = LoadPayload(draft);
+        IReadOnlyList<WizardClubOption>? clubs = null;
+        if (draft.Step == WizardStepNames.PickClub)
+        {
+            clubs = await _messenger.GetGmClubsAsync(draft.OwnerTelegramId, ct);
+        }
+        var (text, kb) = WizardStep.Render(draft, payload, clubs);
+        await _messenger.EditMessageTextAsync(
+            draft.ChatId, draft.MessageThreadId, draft.DraftMessageId ?? 0,
+            text, kb, ct);
+        if (callbackId is { } id)
+        {
+            await _messenger.AnswerCallbackAsync(id, null, ct);
+        }
+    }
+
+    // ── Text input dispatcher ─────────────────────────────────────────
+    private static (string? nextStep, string? error, WizardPayload payload) ApplyText(WizardDraft draft, string input)
+    {
+        var payload = LoadPayload(draft);
+        switch (draft.Step)
+        {
+            case WizardStepNames.Title:
+                return ValidateText(input, WizardStep.MaxTitleLength, "Название не может быть пустым", "Слишком длинное название", out var title)
+                    ? (WizardStepNames.Description, SetTitle(payload, title), payload)
+                    : (null, title, payload);
+
+            case WizardStepNames.Description:
+                if (input == "-") return (WizardStepNames.Cover, SetDescription(payload, null), payload);
+                return ValidateText(input, WizardStep.MaxDescriptionLength, "Описание не может быть пустым", "Слишком длинное описание", out var desc)
+                    ? (WizardStepNames.Cover, SetDescription(payload, desc), payload)
+                    : (null, desc, payload);
+
+            case WizardStepNames.Cover:
+                if (input == "-") return (NextAfterCover(payload), SetImageUrl(payload, null), payload);
+                if (Uri.TryCreate(input, UriKind.Absolute, out var uri) && (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps))
+                    return (NextAfterCover(payload), SetImageUrl(payload, input), payload);
+                return (null, "Некорректный URL", payload);
+
+            case WizardStepNames.System when payload.System is null:
+                // "Other" branch — only active if free-text was offered.
+                return ValidateText(input, WizardStep.MaxSystemLength, "Слишком длинное название системы", "Слишком длинное название системы", out var sys)
+                    ? (WizardStepNames.Duration, SetSystem(payload, sys), payload)
+                    : (null, sys, payload);
+
+            case WizardStepNames.Duration when payload.DurationMinutes is null:
+                return TryParseHours(input, out var durMin)
+                    ? (WizardStepNames.DateTime, SetDurationMinutes(payload, durMin), payload)
+                    : (null, "Неверная длительность (1..12 ч)", payload);
+
+            case WizardStepNames.DateTime:
+                return MoscowTime.TryParseMoscow(input, out var dt) && dt > DateTimeOffset.UtcNow
+                    ? (WizardStepNames.Capacity, SetScheduledAt(payload, dt), payload)
+                    : (null, dt == default ? "Не удалось разобрать дату" : "Дата в прошлом", payload);
+
+            case WizardStepNames.Capacity when payload.Single?.MaxPlayers is null:
+                return int.TryParse(input, out var cap) && cap >= WizardStep.MinCapacity && cap <= WizardStep.MaxCapacity
+                    ? (WizardStepNames.Visibility, SetMaxPlayers(payload, cap), payload)
+                    : (null, "Лимит должен быть 1..50", payload);
+
+            case WizardStepNames.PoolSystemDuration when payload.System is null:
+                return ValidateText(input, WizardStep.MaxSystemLength, "Слишком длинное название системы", "Слишком длинное название системы", out var psys)
+                    ? (WizardStepNames.PoolSystemDuration, SetSystem(payload, psys), payload)
+                    : (null, psys, payload);
+
+            case WizardStepNames.PoolSystemDuration when payload.DurationMinutes is null:
+                return TryParseHours(input, out var pdur)
+                    ? (WizardStepNames.Visibility, SetDurationMinutes(payload, pdur), payload)
+                    : (null, "Неверная длительность (1..12 ч)", payload);
+
+            case WizardStepNames.PoolSlotDateTime:
+                return MoscowTime.TryParseMoscow(input, out var slotDt) && slotDt > DateTimeOffset.UtcNow
+                    ? (WizardStepNames.PoolSlotCapacity, SetCurrentSlotDateTime(payload, slotDt), payload)
+                    : (null, slotDt == default ? "Не удалось разобрать дату" : "Дата в прошлом", payload);
+
+            case WizardStepNames.PoolSlotCapacity:
+                return int.TryParse(input, out var slotCap) && slotCap >= WizardStep.MinCapacity && slotCap <= WizardStep.MaxCapacity
+                    ? (WizardStepNames.PoolAddSlots, SetCurrentSlotMaxPlayers(payload, slotCap), payload)
+                    : (null, "Лимит должен быть 1..50", payload);
+
+            default:
+                return (null, "Ожидается выбор кнопкой", payload);
+        }
+    }
+
+    // ── Callback (button) dispatcher ──────────────────────────────────
+    private static (string? nextStep, string? error, WizardPayload payload) ApplyChoice(WizardDraft draft, string step, string choice)
+    {
+        var payload = LoadPayload(draft);
+        var (next, err) = step switch
+        {
+            WizardStepNames.Type => ApplyTypeChoice(payload, choice),
+            WizardStepNames.System => ApplySystemChoice(payload, choice),
+            WizardStepNames.Duration => ApplyDurationChoice(payload, choice),
+            WizardStepNames.Capacity => ApplyCapacityChoice(payload, choice),
+            WizardStepNames.Visibility => ApplyVisibilityChoice(payload, choice),
+            WizardStepNames.PickClub => ApplyPickClubChoice(payload, choice),
+            WizardStepNames.Publish => ApplyPublishChoice(payload, choice),
+            WizardStepNames.PoolSystemDuration => ApplyPoolSystemDurationChoice(payload, choice),
+            WizardStepNames.PoolAddSlots => ApplyPoolAddSlotsChoice(payload, choice),
+            WizardStepNames.PoolSlotCapacity => ApplyPoolSlotCapacityChoice(payload, choice),
+            _ => (null, "Неизвестный шаг"),
+        };
+        return (next, err, payload);
+    }
+
+    private static (string?, string?) ApplyTypeChoice(WizardPayload p, string choice) => choice switch
+    {
+        "single" => (WizardStepNames.Title, SetType(p, WizardCreationType.Single)),
+        "pool" => (WizardStepNames.Title, SetType(p, WizardCreationType.Pool)),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplySystemChoice(WizardPayload p, string choice) => choice switch
+    {
+        "_other" => (WizardStepNames.System, null),                            // stay, await text
+        "_skip" => (NextAfterSystem(p), SetSystem(p, null)),
+        { } code => (WizardStepNames.Duration, SetSystem(p, code)),
+    };
+
+    private static (string?, string?) ApplyDurationChoice(WizardPayload p, string choice) => choice switch
+    {
+        "_other" => (WizardStepNames.Duration, null),
+        "_skip" => (NextAfterDuration(p), SetDurationMinutes(p, null)),
+        { } d => int.TryParse(d, out var min)
+                    ? (NextAfterDuration(p), SetDurationMinutes(p, min))
+                    : (null, "Неверная длительность"),
+    };
+
+    private static (string?, string?) ApplyCapacityChoice(WizardPayload p, string choice) => choice switch
+    {
+        "waitlist:on" => (WizardStepNames.Visibility, SetWaitlist(p, true)),
+        "waitlist:off" => (WizardStepNames.Visibility, SetWaitlist(p, false)),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplyVisibilityChoice(WizardPayload p, string choice) => choice switch
+    {
+        "public" => (NextAfterVisibility(p), SetVisibility(p, WizardVisibility.Public)),
+        "club" => (WizardStepNames.PickClub, SetVisibility(p, WizardVisibility.Club)),
+        "members" => (WizardStepNames.PickClub, SetVisibility(p, WizardVisibility.Members)),
+        "pickclub" => (WizardStepNames.PickClub, null),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplyPickClubChoice(WizardPayload p, string choice)
+        => Guid.TryParse(choice, out var id)
+            ? (NextAfterVisibility(p), SetClubId(p, id))
+            : (null, "Неверный идентификатор клуба");
+
+    private static (string?, string?) ApplyPublishChoice(WizardPayload p, string choice) => choice switch
+    {
+        "yes" => (WizardStepNames.Confirm, SetPublishInShowcase(p, true)),
+        "no" => (WizardStepNames.Confirm, SetPublishInShowcase(p, false)),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplyPoolSystemDurationChoice(WizardPayload p, string choice) => choice switch
+    {
+        "_custom" => (WizardStepNames.PoolSystemDuration, null),
+        { } c when c.Contains(':') => SplitSystemDuration(c) is (var sys, var dur)
+            ? (WizardStepNames.Visibility, SetSystem(p, sys) ?? SetDurationMinutes(p, dur))
+            : (null, "Неверный выбор"),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplyPoolAddSlotsChoice(WizardPayload p, string choice) => choice switch
+    {
+        "add" => BeginNewPoolSlot(p),
+        "done" => p.Pool?.Slots.Count > 0
+                    ? (WizardStepNames.PoolConfirm, null)
+                    : (null, "Добавьте хотя бы один слот"),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    private static (string?, string?) ApplyPoolSlotCapacityChoice(WizardPayload p, string choice) => choice switch
+    {
+        "waitlist:on" => (WizardStepNames.PoolAddSlots, CommitCurrentPoolSlot(p, true)),
+        "waitlist:off" => (WizardStepNames.PoolAddSlots, CommitCurrentPoolSlot(p, false)),
+        _ => (null, "Неизвестный выбор"),
+    };
+
+    // ── Back navigation ───────────────────────────────────────────────
+    private static void ApplyBack(WizardDraft draft, string fromStep)
+    {
+        // The callback's "step" portion is the step the user is currently on (e.g. the
+        // Confirm button emits `wizard:back` with no step, in which case we fall back to
+        // the draft's current step). Both should produce the same result.
+        var current = string.IsNullOrEmpty(fromStep) ? draft.Step : fromStep;
+        var payload = LoadPayload(draft);
+        var previous = PreviousStep(current, payload);
+        if (previous is { } step) draft.Step = step;
+    }
+
+    private static string? PreviousStep(string step, WizardPayload p) => step switch
+    {
+        WizardStepNames.Title => null,   // first step
+        WizardStepNames.Description => WizardStepNames.Title,
+        WizardStepNames.Cover => WizardStepNames.Description,
+        WizardStepNames.System => WizardStepNames.Cover,
+        WizardStepNames.Duration => WizardStepNames.System,
+        WizardStepNames.DateTime => WizardStepNames.Duration,
+        WizardStepNames.Capacity => WizardStepNames.DateTime,
+        WizardStepNames.Visibility => WizardStepNames.Capacity,
+        WizardStepNames.PickClub => WizardStepNames.Visibility,
+        WizardStepNames.Publish => WizardStepNames.PickClub,
+        WizardStepNames.Confirm => WizardStepNames.Publish,
+
+        WizardStepNames.PoolSystemDuration => null, // first pool step
+        WizardStepNames.PoolAddSlots => WizardStepNames.PoolSystemDuration,
+        WizardStepNames.PoolSlotDateTime => WizardStepNames.PoolAddSlots,
+        WizardStepNames.PoolSlotCapacity => WizardStepNames.PoolSlotDateTime,
+        WizardStepNames.PoolConfirm => WizardStepNames.PoolAddSlots,
+        _ => null,
+    };
+
+    // ── Payload I/O ───────────────────────────────────────────────────
+    internal static WizardPayload LoadPayload(WizardDraft draft)
+    {
+        if (string.IsNullOrEmpty(draft.PayloadJson)) return new WizardPayload();
+        return System.Text.Json.JsonSerializer.Deserialize(
+            draft.PayloadJson, WizardPayloadJsonContext.Default.WizardPayload) ?? new WizardPayload();
+    }
+
+    private static void SavePayload(WizardDraft draft, WizardPayload payload)
+    {
+        draft.PayloadJson = System.Text.Json.JsonSerializer.Serialize(
+            payload, WizardPayloadJsonContext.Default.WizardPayload);
+    }
+
+    // Mutators — return the error message if any (kept here to centralise flow).
+    private static string? SetTitle(WizardPayload p, string v) { p.Title = v; return null; }
+    private static string? SetDescription(WizardPayload p, string? v) { p.Description = v; return null; }
+    private static string? SetImageUrl(WizardPayload p, string? v) { p.ImageUrl = v; p.ImageFileId = null; return null; }
+    private static void ApplyCoverPhoto(WizardDraft d, string fileId)
+    {
+        var p = LoadPayload(d);
+        p.ImageFileId = fileId;
+        p.ImageUrl = null;
+        SavePayload(d, p);
+        var next = NextAfterCover(p);
+        if (next is { } s) d.Step = s;
+    }
+    private static string? SetSystem(WizardPayload p, string? v) { p.System = v; return null; }
+    private static string? SetDurationMinutes(WizardPayload p, int? v) { p.DurationMinutes = v; return null; }
+    private static string? SetScheduledAt(WizardPayload p, DateTimeOffset v)
+    { p.Single ??= new WizardSingleInput(); p.Single.ScheduledAt = v; return null; }
+    private static string? SetMaxPlayers(WizardPayload p, int v)
+    { p.Single ??= new WizardSingleInput(); p.Single.MaxPlayers = v; return null; }
+    private static string? SetWaitlist(WizardPayload p, bool v) { p.Waitlist = v; return null; }
+    private static string? SetVisibility(WizardPayload p, WizardVisibility? v) { p.Visibility = v; return null; }
+    private static string? SetClubId(WizardPayload p, Guid v) { p.ClubId = v; return null; }
+    private static string? SetType(WizardPayload p, WizardCreationType v) { p.Type = v; return null; }
+    private static string? SetPublishInShowcase(WizardPayload p, bool v) { p.PublishInShowcase = v; return null; }
+
+    private static string? SetCurrentSlotDateTime(WizardPayload p, DateTimeOffset v)
+    {
+        p.Pool ??= new WizardPoolInput();
+        var current = EnsureCurrentPoolSlot(p);
+        current.ScheduledAt = v;
+        return null;
+    }
+    private static string? SetCurrentSlotMaxPlayers(WizardPayload p, int v)
+    {
+        p.Pool ??= new WizardPoolInput();
+        var current = EnsureCurrentPoolSlot(p);
+        current.MaxPlayers = v;
+        return null;
+    }
+    private static string? CommitCurrentPoolSlot(WizardPayload p, bool waitlist)
+    {
+        p.Pool ??= new WizardPoolInput();
+        var current = EnsureCurrentPoolSlot(p);
+        current.Waitlist = waitlist;
+        return null;
+    }
+    private static (string? nextStep, string? error) BeginNewPoolSlot(WizardPayload p)
+    {
+        p.Pool ??= new WizardPoolInput();
+        p.Pool.Slots.Add(new WizardSlotInput());
+        return (WizardStepNames.PoolSlotDateTime, null);
+    }
+    private static WizardSlotInput EnsureCurrentPoolSlot(WizardPayload p)
+    {
+        // Slots added via BeginNewPoolSlot are always committed before they leave the
+        // PoolSlotCapacity step (CommitCurrentPoolSlot). If we somehow get here without
+        // a slot, start a new one to keep the flow recoverable.
+        p.Pool ??= new WizardPoolInput();
+        var last = p.Pool.Slots.LastOrDefault();
+        if (last is not null && last.MaxPlayers == 0) return last;
+        p.Pool.Slots.Add(new WizardSlotInput());
+        return p.Pool.Slots[^1];
+    }
+
+    // ── Flow helpers ──────────────────────────────────────────────────
+    private static string? NextAfterCover(WizardPayload p) => p.Type == WizardCreationType.Pool
+        ? WizardStepNames.PoolSystemDuration : WizardStepNames.System;
+    private static string? NextAfterSystem(WizardPayload p) => WizardStepNames.Duration;
+    private static string? NextAfterDuration(WizardPayload p)
+    {
+        if (p.Type == WizardCreationType.Pool) return WizardStepNames.Visibility;
+        return p.Single?.MaxPlayers is not null ? WizardStepNames.Visibility : WizardStepNames.DateTime;
+    }
+    private static string? NextAfterVisibility(WizardPayload p)
+    {
+        if (p.Visibility is WizardVisibility.Club or WizardVisibility.Members)
+        {
+            if (p.ClubId is null) return WizardStepNames.PickClub;
+        }
+        return p.Type == WizardCreationType.Pool ? WizardStepNames.PoolAddSlots : WizardStepNames.Publish;
+    }
+
+    private static (string? sys, int? dur) SplitSystemDuration(string s)
+    {
+        var idx = s.IndexOf(':');
+        if (idx <= 0 || idx >= s.Length - 1) return (null, null);
+        var sys = s.Substring(0, idx);
+        if (!int.TryParse(s.Substring(idx + 1), out var durMin)) return (null, null);
+        return (sys, durMin);
+    }
+
+    private static bool ValidateText(
+        string input, int maxLength, string emptyMsg, string tooLongMsg, out string trimmed)
+    {
+        trimmed = input.Trim();
+        if (string.IsNullOrEmpty(trimmed))
+        {
+            trimmed = emptyMsg;
+            return false;
+        }
+        if (trimmed.Length > maxLength)
+        {
+            trimmed = tooLongMsg;
+            return false;
+        }
+        return true;
+    }
+
+    private static bool TryParseHours(string input, out int minutes)
+    {
+        minutes = 0;
+        var s = input.Trim();
+        if (s.EndsWith("h", StringComparison.OrdinalIgnoreCase)) s = s.Substring(0, s.Length - 1);
+        if (s.EndsWith("ч", StringComparison.OrdinalIgnoreCase)) s = s.Substring(0, s.Length - 1);
+        if (!double.TryParse(s, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var hours)) return false;
+        if (hours < WizardStep.MinDurationHours || hours > WizardStep.MaxDurationHours) return false;
+        minutes = (int)Math.Round(hours * 60);
+        return true;
+    }
+
+    private static readonly InlineKeyboardMarkup EmptyKeyboard = new(Array.Empty<InlineKeyboardButton[]>());
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/ITelegramWizardMessenger.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public sealed record WizardClubOption(Guid ClubId, string Name);
+
+public interface ITelegramWizardMessenger
+{
+    Task<long> EditMessageTextAsync(long chatId, int? messageThreadId, long messageId, string text, Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup keyboard, CancellationToken ct);
+    Task<long> SendGroupMessageAsync(long chatId, int? messageThreadId, string text, Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup keyboard, CancellationToken ct);
+    Task AnswerCallbackAsync(string callbackId, string? text, CancellationToken ct);
+    Task<IReadOnlyList<WizardClubOption>> GetGmClubsAsync(long ownerTelegramId, CancellationToken ct);
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/TelegramWizardMessenger.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using Npgsql;
+using Telegram.Bot;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public sealed class TelegramWizardMessenger(
+    ITelegramBotClient bot,
+    NpgsqlDataSource dataSource) : ITelegramWizardMessenger
+{
+    public async Task<long> EditMessageTextAsync(
+        long chatId, int? messageThreadId, long messageId, string text,
+        InlineKeyboardMarkup keyboard, CancellationToken ct)
+    {
+        var msg = await bot.EditMessageText(
+            chatId: chatId,
+            messageId: (int)messageId,
+            text: text,
+            replyMarkup: keyboard,
+            cancellationToken: ct);
+        return msg.MessageId;
+    }
+
+    public async Task<long> SendGroupMessageAsync(
+        long chatId, int? messageThreadId, string text,
+        InlineKeyboardMarkup keyboard, CancellationToken ct)
+    {
+        var msg = await bot.SendMessage(
+            chatId: chatId,
+            text: text,
+            messageThreadId: messageThreadId,
+            replyMarkup: keyboard,
+            cancellationToken: ct);
+        return msg.MessageId;
+    }
+
+    public async Task AnswerCallbackAsync(string callbackId, string? text, CancellationToken ct)
+    {
+        await bot.AnswerCallbackQuery(callbackId, text: text, cancellationToken: ct);
+    }
+
+    public async Task<IReadOnlyList<WizardClubOption>> GetGmClubsAsync(long ownerTelegramId, CancellationToken ct)
+    {
+        // Adjusted from the plan: this codebase models "clubs" as game_groups
+        // (V001 created game_groups; V026 added public_slug; no `clubs` table exists,
+        // and game_groups has no `club_id` FK). The picker therefore returns the
+        // game_groups the owner manages as a GM (via group_managers), matching
+        // the WizardClubOption contract (UUID id, name) used downstream.
+        const string sql = """
+            SELECT g.id   AS ClubId,
+                   g.name AS Name
+            FROM game_groups g
+            JOIN group_managers gm ON gm.group_id = g.id
+            JOIN players p ON p.id = gm.player_id
+            WHERE p.platform = 'Telegram'
+              AND p.external_user_id = @ExternalId
+            GROUP BY g.id, g.name
+            ORDER BY g.name
+            """;
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        var rows = await connection.QueryAsync<WizardClubOption>(
+            new CommandDefinition(sql, new { ExternalId = ownerTelegramId.ToString() }, cancellationToken: ct));
+        return rows.AsList();
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/WizardCallbackData.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public static class WizardCallbackData
+{
+    public const string Prefix = "wizard";
+
+    public static string Choice(string step, string choice) => $"{Prefix}:{step}:{choice}";
+    public static string Back() => $"{Prefix}:back";
+    public static string Cancel() => $"{Prefix}:cancel";
+    public static string Create() => $"{Prefix}:create";
+
+    public static bool TryParse(string? data, out string action, out string step, out string choice)
+    {
+        action = step = choice = string.Empty;
+        if (string.IsNullOrEmpty(data)) return false;
+        var parts = data.Split(':', 3);
+        if (parts.Length < 2 || parts[0] != Prefix) return false;
+        action = parts[1];
+        step = parts.Length >= 3 ? parts[1] : string.Empty;
+        choice = parts.Length >= 3 ? parts[2] : string.Empty;
+        return true;
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/WizardDraftCleanupService.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public sealed class WizardDraftCleanupService : BackgroundService
+{
+    private static readonly TimeSpan TickInterval = TimeSpan.FromMinutes(1);
+
+    private readonly IWizardDraftRepository _drafts;
+    private readonly ILogger<WizardDraftCleanupService> _log;
+
+    public WizardDraftCleanupService(
+        IWizardDraftRepository drafts,
+        ILogger<WizardDraftCleanupService> log)
+    {
+        _drafts = drafts;
+        _log = log;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        using var timer = new PeriodicTimer(TickInterval);
+        try
+        {
+            while (await timer.WaitForNextTickAsync(stoppingToken))
+            {
+                await RunOnceAsync(stoppingToken);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // graceful shutdown
+        }
+    }
+
+    internal async Task RunOnceAsync(CancellationToken ct)
+    {
+        try
+        {
+            var deleted = await _drafts.DeleteExpiredAsync(ct);
+            if (deleted > 0)
+            {
+                _log.LogInformation("Wizard cleanup deleted {Count} expired drafts", deleted);
+            }
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _log.LogError(ex, "Wizard cleanup tick failed");
+        }
+    }
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/WizardStep.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public static class WizardStep
+{
+    public const int MaxTitleLength = 200;
+    public const int MaxDescriptionLength = 4000;
+    public const int MaxSystemLength = 100;
+    public const int MaxCapacity = 50;
+    public const int MinCapacity = 1;
+    public const int MinDurationHours = 1;
+    public const int MaxDurationHours = 12;
+
+    public static (string text, InlineKeyboardMarkup keyboard) Render(
+        WizardDraft draft,
+        WizardPayload payload,
+        IReadOnlyList<WizardClubOption>? clubs = null)
+    {
+        return draft.Step switch
+        {
+            WizardStepNames.Type => RenderType(),
+            WizardStepNames.Title => RenderTitle(),
+            WizardStepNames.Description => RenderDescription(),
+            WizardStepNames.Cover => RenderCover(),
+            WizardStepNames.System => RenderSystem(),
+            WizardStepNames.Duration => RenderDuration(),
+            WizardStepNames.DateTime => RenderDateTime(),
+            WizardStepNames.Capacity => RenderCapacity(),
+            WizardStepNames.Visibility => RenderVisibility(),
+            WizardStepNames.PickClub => RenderPickClub(clubs ?? Array.Empty<WizardClubOption>()),
+            WizardStepNames.Publish => RenderPublish(),
+            WizardStepNames.Confirm => RenderSingleConfirm(payload),
+
+            WizardStepNames.PoolSystemDuration => RenderPoolSystemDuration(),
+            WizardStepNames.PoolAddSlots => RenderPoolAddSlots(payload),
+            WizardStepNames.PoolSlotDateTime => RenderPoolSlotDateTime(),
+            WizardStepNames.PoolSlotCapacity => RenderPoolSlotCapacity(),
+            WizardStepNames.PoolConfirm => RenderPoolConfirm(payload),
+
+            _ => throw new InvalidOperationException($"Unknown wizard step: {draft.Step}"),
+        };
+    }
+
+    // ── Single-game renderers ──────────────────────────────────────────
+    private static (string, InlineKeyboardMarkup) RenderType() => (
+        "🎲 Создание новой игровой сессии\n\nЧто создаём?",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("🎯 Одну игру", WizardCallbackData.Choice(WizardStepNames.Type, "single")) },
+            new[] { InlineKeyboardButton.WithCallbackData("📅 Пул игр", WizardCallbackData.Choice(WizardStepNames.Type, "pool")) },
+            new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена", WizardCallbackData.Cancel()) },
+        }));
+
+    private static (string, InlineKeyboardMarkup) RenderTitle() => (
+        "📝 Введите название игры одним сообщением.",
+        BackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderDescription() => (
+        "📄 Введите описание (или «-», чтобы пропустить).",
+        SkipBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderCover() => (
+        "🖼 Пришлите картинку как вложение или URL (или «-»).",
+        SkipBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderSystem()
+    {
+        var buttons = new List<InlineKeyboardButton[]>
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("D&D 5e",         WizardCallbackData.Choice(WizardStepNames.System, "Dnd5e")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Pathfinder 2e",  WizardCallbackData.Choice(WizardStepNames.System, "Pathfinder2e")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Call of Cthulhu",WizardCallbackData.Choice(WizardStepNames.System, "CallOfCthulhu7e")) },
+            new[] { InlineKeyboardButton.WithCallbackData("GURPS",          WizardCallbackData.Choice(WizardStepNames.System, "GURPS")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Fate",           WizardCallbackData.Choice(WizardStepNames.System, "Fate")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Другое… ✏️",       WizardCallbackData.Choice(WizardStepNames.System, "_other")) },
+            new[] { InlineKeyboardButton.WithCallbackData("⏭ Пропустить",     WizardCallbackData.Choice(WizardStepNames.System, "_skip")) },
+        };
+        return ("🎲 Выберите систему.", new InlineKeyboardMarkup(buttons).AppendBackCancel());
+    }
+
+    private static (string, InlineKeyboardMarkup) RenderDuration() => (
+        "⏱ Выберите длительность.",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("3 часа",  WizardCallbackData.Choice(WizardStepNames.Duration, "180")) },
+            new[] { InlineKeyboardButton.WithCallbackData("4 часа",  WizardCallbackData.Choice(WizardStepNames.Duration, "240")) },
+            new[] { InlineKeyboardButton.WithCallbackData("5 часов", WizardCallbackData.Choice(WizardStepNames.Duration, "300")) },
+            new[] { InlineKeyboardButton.WithCallbackData("6 часов", WizardCallbackData.Choice(WizardStepNames.Duration, "360")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Другое… ✏️", WizardCallbackData.Choice(WizardStepNames.Duration, "_other")) },
+            new[] { InlineKeyboardButton.WithCallbackData("⏭ Пропустить", WizardCallbackData.Choice(WizardStepNames.Duration, "_skip")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderDateTime() => (
+        "📅 Введите дату и время в формате ДД.ММ.ГГГГ ЧЧ:ММ (Москва).",
+        BackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderCapacity() => (
+        "👥 Введите лимит мест (1..50) одним числом.\nЗатем нажмите кнопку waitlist.",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Waitlist вкл",   WizardCallbackData.Choice(WizardStepNames.Capacity, "waitlist:on")) },
+            new[] { InlineKeyboardButton.WithCallbackData("❌ Без waitlist",   WizardCallbackData.Choice(WizardStepNames.Capacity, "waitlist:off")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderVisibility() => (
+        "🔒 Выберите видимость.",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("🌐 Публичная в общем showcase", WizardCallbackData.Choice(WizardStepNames.Visibility, "public")) },
+            new[] { InlineKeyboardButton.WithCallbackData("🏠 Публичная в витрине клуба", WizardCallbackData.Choice(WizardStepNames.Visibility, "club")) },
+            new[] { InlineKeyboardButton.WithCallbackData("🔐 Только для членов клуба",   WizardCallbackData.Choice(WizardStepNames.Visibility, "members")) },
+            new[] { InlineKeyboardButton.WithCallbackData("🏷 Выбрать клуб…",             WizardCallbackData.Choice(WizardStepNames.Visibility, "pickclub")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderPickClub(IReadOnlyList<WizardClubOption> clubs)
+    {
+        if (clubs.Count == 0)
+        {
+            return (
+                "🏷 У вас нет клубов. Создайте клуб в Web dashboard и вернитесь.",
+                BackCancel());
+        }
+        var rows = new List<InlineKeyboardButton[]>();
+        foreach (var club in clubs)
+        {
+            rows.Add(new[]
+            {
+                InlineKeyboardButton.WithCallbackData(club.Name, WizardCallbackData.Choice(WizardStepNames.PickClub, club.ClubId.ToString()))
+            });
+        }
+        return ("🏷 Выберите клуб:", new InlineKeyboardMarkup(rows).AppendBackCancel());
+    }
+
+    private static (string, InlineKeyboardMarkup) RenderPublish() => (
+        "✨ Опубликовать в витрине сейчас?",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Опубликовать",  WizardCallbackData.Choice(WizardStepNames.Publish, "yes")) },
+            new[] { InlineKeyboardButton.WithCallbackData("📝 Только в чате", WizardCallbackData.Choice(WizardStepNames.Publish, "no")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderSingleConfirm(WizardPayload p)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("👀 Проверьте перед созданием:");
+        sb.AppendLine();
+        sb.AppendLine($"🎲 {p.Title}");
+        if (!string.IsNullOrEmpty(p.Description)) sb.AppendLine($"📄 {p.Description}");
+        if (!string.IsNullOrEmpty(p.System)) sb.AppendLine($"🎲 Система: {p.System}");
+        if (p.DurationMinutes.HasValue) sb.AppendLine($"⏱ Длительность: {p.DurationMinutes / 60} ч");
+        if (p.Single?.ScheduledAt is { } at) sb.AppendLine($"📅 {at.FormatMoscow()} (МСК)");
+        if (p.Single?.MaxPlayers is { } mp) sb.AppendLine($"👥 Мест: {mp}, waitlist {(p.Waitlist == true ? "вкл" : "выкл")}");
+        sb.AppendLine($"🔒 Видимость: {RenderVisibilityText(p.Visibility)}");
+        return (sb.ToString(), new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Создать", WizardCallbackData.Create()) },
+            new[] { InlineKeyboardButton.WithCallbackData("⬅️ Назад",   WizardCallbackData.Back()) },
+            new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена",  WizardCallbackData.Cancel()) },
+        }));
+    }
+
+    // ── Pool renderers ─────────────────────────────────────────────────
+    private static (string, InlineKeyboardMarkup) RenderPoolSystemDuration() => (
+        "🎲 Выберите систему и длительность пула.",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("D&D 5e · 4 ч",         WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "Dnd5e:240")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Pathfinder 2e · 4 ч",  WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "Pathfinder2e:240")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Call of Cthulhu · 3 ч",WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "CallOfCthulhu7e:180")) },
+            new[] { InlineKeyboardButton.WithCallbackData("GURPS · 4 ч",          WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "GURPS:240")) },
+            new[] { InlineKeyboardButton.WithCallbackData("Другое… ✏️",             WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "_custom")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderPoolAddSlots(WizardPayload p) => (
+        $"📅 Слоты пула «{p.Title}»\n\nДобавлено: {(p.Pool?.Slots.Count ?? 0)}",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("➕ Добавить слот",      WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "add")) },
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Готово, к превью",  WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "done")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderPoolSlotDateTime() => (
+        "📅 Введите дату/время слота (ДД.ММ.ГГГГ ЧЧ:ММ).",
+        BackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderPoolSlotCapacity() => (
+        "👥 Введите лимит мест (1..50) и выберите waitlist.",
+        new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Waitlist вкл",  WizardCallbackData.Choice(WizardStepNames.PoolSlotCapacity, "waitlist:on")) },
+            new[] { InlineKeyboardButton.WithCallbackData("❌ Без waitlist",  WizardCallbackData.Choice(WizardStepNames.PoolSlotCapacity, "waitlist:off")) },
+        }).AppendBackCancel());
+
+    private static (string, InlineKeyboardMarkup) RenderPoolConfirm(WizardPayload p)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("👀 Проверьте пул перед созданием:");
+        sb.AppendLine();
+        sb.AppendLine($"📝 {p.Title}");
+        if (!string.IsNullOrEmpty(p.Description)) sb.AppendLine($"📄 {p.Description}");
+        if (!string.IsNullOrEmpty(p.System)) sb.AppendLine($"🎲 Система: {p.System}");
+        if (p.DurationMinutes.HasValue) sb.AppendLine($"⏱ Длительность: {p.DurationMinutes / 60} ч");
+        sb.AppendLine($"🔒 Видимость: {RenderVisibilityText(p.Visibility)}");
+        sb.AppendLine();
+        sb.AppendLine($"Слоты ({p.Pool?.Slots.Count ?? 0}):");
+        if (p.Pool is not null)
+        {
+            foreach (var s in p.Pool.Slots)
+            {
+                sb.AppendLine($"  • {s.ScheduledAt.FormatMoscow()} — мест {s.MaxPlayers}, waitlist {(s.Waitlist ? "вкл" : "выкл")}");
+            }
+        }
+        return (sb.ToString(), new InlineKeyboardMarkup(new[]
+        {
+            new[] { InlineKeyboardButton.WithCallbackData("✅ Создать пул", WizardCallbackData.Create()) },
+            new[] { InlineKeyboardButton.WithCallbackData("⬅️ Назад",       WizardCallbackData.Back()) },
+            new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена",      WizardCallbackData.Cancel()) },
+        }));
+    }
+
+    // ── Helpers ────────────────────────────────────────────────────────
+    private static InlineKeyboardMarkup BackCancel() => new(new[]
+    {
+        new[] { InlineKeyboardButton.WithCallbackData("⬅️ Назад",  WizardCallbackData.Back()) },
+        new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена", WizardCallbackData.Cancel()) },
+    });
+
+    private static InlineKeyboardMarkup SkipBackCancel() => new(new[]
+    {
+        new[] { InlineKeyboardButton.WithCallbackData("⏭ Пропустить", WizardCallbackData.Choice("Skip", "1")) },
+        new[] { InlineKeyboardButton.WithCallbackData("⬅️ Назад",     WizardCallbackData.Back()) },
+        new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена",    WizardCallbackData.Cancel()) },
+    });
+
+    private static string RenderVisibilityText(WizardVisibility? v) => v switch
+    {
+        WizardVisibility.Public => "публичная в общем showcase",
+        WizardVisibility.Club => "публичная в витрине клуба",
+        WizardVisibility.Members => "только для членов клуба",
+        _ => "не задана",
+    };
+}
+
+internal static class InlineKeyboardMarkupExtensions
+{
+    public static InlineKeyboardMarkup AppendBackCancel(this InlineKeyboardMarkup kb) => kb;
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/WizardStepNames.cs

@@ -0,0 +1,24 @@
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public static class WizardStepNames
+{
+    public const string Type = "Type";
+    public const string Title = "Title";
+    public const string Description = "Description";
+    public const string Cover = "Cover";
+    public const string System = "System";
+    public const string Duration = "Duration";
+    public const string DateTime = "DateTime";
+    public const string Capacity = "Capacity";
+    public const string Visibility = "Visibility";
+    public const string PickClub = "PickClub";
+    public const string Publish = "Publish";
+    public const string Confirm = "Confirm";
+
+    // Pool steps
+    public const string PoolSystemDuration = "PoolSystemDuration";
+    public const string PoolAddSlots = "PoolAddSlots";
+    public const string PoolSlotDateTime = "PoolSlotDateTime";
+    public const string PoolSlotCapacity = "PoolSlotCapacity";
+    public const string PoolConfirm = "PoolConfirm";
+}

src/GmRelay.Bot/Features/Sessions/CreateSession/Wizard/WizardStorageException.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+
+public sealed class WizardStorageException : Exception
+{
+    public WizardStorageException(string message, Exception inner) : base(message, inner) { }
+}

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

@@ -2,8 +2,10 @@
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Features.Confirmation.HandleRsvp;
 using GmRelay.Shared.Features.Sessions.CreateSession;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Shared.Rendering;
 using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Bot.Features.Sessions.ListSessions;
 using BotCreateSessionHandler = GmRelay.Bot.Features.Sessions.CreateSession.CreateSessionHandler;
 using BotRescheduleTimeInputHandler = GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler;
@@ -34,12 +36,44 @@ public sealed class UpdateRouter(
     InitiateRescheduleHandler initiateRescheduleHandler,
     BotRescheduleTimeInputHandler rescheduleTimeInputHandler,
     BotRescheduleVoteHandler rescheduleVoteHandler,
+    GameCreationWizard wizard,
+    IWizardDraftRepository drafts,
     ITelegramBotClient bot,
     IConfiguration configuration,
     ILogger<UpdateRouter> logger) : ITelegramUpdateHandler
 {
     public async Task RouteAsync(Update update, CancellationToken ct)
     {
+        // 1) Wizard delegation. If the GM has an active (non-expired) draft for this
+        //    (chat, thread, owner), every update routes to the wizard. The wizard is
+        //    responsible for both text input and callback handling.
+        if (TryGetWizardContext(update, out var chatId, out var threadId, out var ownerId))
+        {
+            var draft = await drafts.GetActiveAsync(chatId, threadId, ownerId, ct);
+            if (draft is not null)
+            {
+                // Resume / Reset / Cancel menu callbacks live in the router because
+                // they cross draft boundaries (reset deletes + recreates a fresh
+                // draft, which the wizard instance doesn't know how to do).
+                if (await TryHandleDraftControlCallbackAsync(update, draft, ct))
+                {
+                    return;
+                }
+
+                await wizard.HandleUpdateAsync(update, draft, ct);
+
+                // The "✅ Создать" / "✅ Создать пул" button — the wizard only
+                // acknowledges the callback; the actual session creation lives in
+                // CreateSessionHandler.
+                if (update.CallbackQuery?.Data is { } data &&
+                    data == WizardCallbackData.Create())
+                {
+                    await createSessionHandler.SubmitDraftAsync(draft, ct);
+                }
+                return;
+            }
+        }
+
         switch (update)
         {
             case { CallbackQuery: { } query }:
@@ -63,9 +97,106 @@ public sealed class UpdateRouter(
         }
     }
 
+    /// <summary>
+    /// Handles router-level draft-control callbacks ("resume", "reset"). Returns true
+    /// if the update was consumed and the wizard should be skipped. The wizard still
+    /// owns "cancel" and "create".
+    /// </summary>
+    private async Task<bool> TryHandleDraftControlCallbackAsync(
+        Update update, WizardDraft draft, CancellationToken ct)
+    {
+        if (update.CallbackQuery is not { Data: { } data, Message: { } cbMessage, From: { } cbFrom })
+            return false;
+
+        switch (data)
+        {
+            case WizardControlCallbacks.Resume:
+                // Re-render the current step of the existing draft. We answer the
+                // callback here because the wizard will not be called.
+                var (text, kb) = WizardStep.Render(draft, LoadPayload(draft));
+                await bot.EditMessageText(
+                    chatId: cbMessage.Chat.Id,
+                    messageId: cbMessage.MessageId,
+                    text: text,
+                    replyMarkup: kb,
+                    cancellationToken: ct);
+                await bot.AnswerCallbackQuery(update.CallbackQuery.Id, cancellationToken: ct);
+                return true;
+
+            case WizardControlCallbacks.Reset:
+                // Delete the existing draft and start a fresh one. The wizard is
+                // bypassed entirely because the active draft is now gone.
+                await drafts.DeleteAsync(draft.Id, ct);
+                await bot.AnswerCallbackQuery(update.CallbackQuery.Id, cancellationToken: ct);
+                var newDraft = await createSessionHandler.StartWizardAsync(
+                    SyntheticStartMessage(cbMessage.Chat.Id, cbMessage.MessageThreadId, cbFrom.Id), ct);
+                if (newDraft is null)
+                {
+                    // Race: another wizard just started for the same owner. The
+                    // user can simply re-run /newsession. We don't loop.
+                    await bot.SendMessage(
+                        chatId: cbMessage.Chat.Id,
+                        text: "Не удалось начать заново — попробуйте ещё раз через /newsession.",
+                        cancellationToken: ct);
+                }
+                return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Build a synthetic <see cref="Message"/> carrying just the fields
+    /// <see cref="CreateSessionHandler.StartWizardAsync"/> reads (chat, thread, from).
+    /// </summary>
+    private static Message SyntheticStartMessage(long chatId, int? messageThreadId, long fromId) => new()
+    {
+        Chat = new Chat { Id = chatId },
+        MessageThreadId = messageThreadId,
+        From = new User { Id = fromId },
+    };
+
+    private static WizardPayload LoadPayload(WizardDraft draft) =>
+        GameCreationWizard.LoadPayload(draft);
+
     internal static string GetCommandText(Message message)
         => (message.Text ?? message.Caption ?? string.Empty).TrimStart();
 
+    /// <summary>
+    /// Extracts the (chat, thread, owner) triple from an update for wizard lookups.
+    /// Returns false for updates that carry no usable origin (e.g. inline queries).
+    /// </summary>
+    private static bool TryGetWizardContext(Update update, out long chatId, out int? messageThreadId, out long ownerId)
+    {
+        chatId = 0;
+        messageThreadId = null;
+        ownerId = 0;
+
+        switch (update)
+        {
+            case { Message: { From: not null, Chat: { } chat } msg }:
+                chatId = chat.Id;
+                messageThreadId = msg.MessageThreadId;
+                ownerId = msg.From!.Id;
+                return true;
+
+            case { CallbackQuery: { From: not null, Message: { Chat: { } cbmChat } } cb }:
+                chatId = cbmChat.Id;
+                messageThreadId = cb.Message?.MessageThreadId;
+                ownerId = cb.From!.Id;
+                return true;
+
+            case { CallbackQuery: { From: not null } cb2 }:
+                // Callback arrived without a message (e.g. from a Mini App). No chat
+                // context → wizard cannot run on this update.
+                ownerId = cb2.From!.Id;
+                return false;
+
+            default:
+                return false;
+        }
+    }
+
     private async Task HandleCallbackQueryAsync(CallbackQuery query, CancellationToken ct)
     {
         if (query.Data is not { } data || query.Message is not { } message)
@@ -213,7 +344,7 @@ public sealed class UpdateRouter(
                 break;
 
             case "/newsession":
-                await createSessionHandler.HandleAsync(message, ct);
+                await HandleNewSessionCommandAsync(message, ct);
                 break;
 
             case "/listsessions":
@@ -256,6 +387,45 @@ public sealed class UpdateRouter(
         }
     }
 
+    private async Task HandleNewSessionCommandAsync(Message message, CancellationToken ct)
+    {
+        // Try to start a fresh wizard. StartWizardAsync returns null when a
+        // non-expired draft already exists for this (chat, thread, owner).
+        var draft = await createSessionHandler.StartWizardAsync(message, ct);
+        if (draft is not null)
+        {
+            // New draft was created and its first step has been rendered.
+            return;
+        }
+
+        // Existing draft. Look it up so we can describe the current step and offer
+        // a Continue / Start over / Cancel menu.
+        var existing = await createSessionHandler.TryResumeAsync(message, ct);
+        if (existing is null)
+        {
+            // Race: the draft expired between the two calls (or the user lacks
+            // ownership metadata). Fall back to silently starting a new wizard.
+            await createSessionHandler.StartWizardAsync(message, ct);
+            return;
+        }
+
+        await bot.SendMessage(
+            chatId: message.Chat.Id,
+            text: "У вас уже есть незавершённый мастер. Продолжить?",
+            replyMarkup: ContinueResetCancelKeyboard(),
+            cancellationToken: ct);
+    }
+
+    private InlineKeyboardMarkup ContinueResetCancelKeyboard() => new(new[]
+    {
+        // "Продолжить" re-renders the existing draft's current step (router-level).
+        // "Начать заново" deletes the existing draft and creates a fresh one (router-level).
+        // "Отмена" delegates to the wizard's normal cancel handler.
+        new[] { InlineKeyboardButton.WithCallbackData("➡️ Продолжить",    WizardControlCallbacks.Resume) },
+        new[] { InlineKeyboardButton.WithCallbackData("🔁 Начать заново",  WizardControlCallbacks.Reset) },
+        new[] { InlineKeyboardButton.WithCallbackData("❌ Отмена",         WizardCallbackData.Cancel()) },
+    });
+
     private async Task SendStartMessageAsync(Message message, CancellationToken ct)
     {
         var miniAppUrl = configuration["Telegram:MiniAppUrl"];
@@ -276,3 +446,14 @@ public sealed class UpdateRouter(
             cancellationToken: ct);
     }
 }
+
+/// <summary>
+/// Router-level callback data for the Continue / Start over / Cancel menu shown
+/// when /newsession detects an existing wizard draft. Distinct from
+/// <see cref="WizardCallbackData"/> which is parsed and consumed by the wizard itself.
+/// </summary>
+internal static class WizardControlCallbacks
+{
+    public const string Resume = "wizard:resume";
+    public const string Reset = "wizard:reset";
+}

src/GmRelay.Bot/Migrations/V031__add_wizard_drafts.sql

@@ -0,0 +1,21 @@
+-- V031: Per-(chat, thread, owner) wizard drafts for the game-creation wizard (issue #111).
+-- Stores in-progress wizard state in JSONB with a 24h TTL managed by WizardDraftCleanupService.
+
+CREATE TABLE wizard_drafts (
+    id UUID PRIMARY KEY,
+    chat_id BIGINT NOT NULL,
+    message_thread_id INT,
+    owner_telegram_id BIGINT NOT NULL,
+    step TEXT NOT NULL,
+    payload JSONB NOT NULL,
+    draft_message_id BIGINT,
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    expires_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX idx_wizard_drafts_owner
+    ON wizard_drafts(chat_id, message_thread_id, owner_telegram_id);
+
+CREATE INDEX idx_wizard_drafts_expires
+    ON wizard_drafts(expires_at);

src/GmRelay.Bot/Program.cs

@@ -1,5 +1,6 @@
 using GmRelay.Bot.Features.Notifications;
 using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Bot.Features.Sessions.RescheduleSession;
 using GmRelay.Bot.Infrastructure.Database;
 using GmRelay.Shared.Features.Sessions.RescheduleSession;
@@ -12,6 +13,7 @@ using GmRelay.Shared.Features.Notifications;
 using GmRelay.Shared.Features.Reminders.SendJoinLink;
 using GmRelay.Shared.Features.Reminders.SendOneHourReminder;
 using GmRelay.Shared.Features.Sessions.CreateSession;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
 using GmRelay.Shared.Infrastructure.Scheduling;
 using GmRelay.Shared.Platform;
 using Npgsql;
@@ -68,6 +70,11 @@ builder.Services.AddSingleton<SendOneHourReminderHandler>();
 builder.Services.AddSingleton<ISendOneHourReminderHandler>(sp => sp.GetRequiredService<SendOneHourReminderHandler>());
 builder.Services.AddSingleton<GmRelay.Shared.Features.Sessions.CreateSession.CreateSessionHandler>();
 builder.Services.AddSingleton<GmRelay.Bot.Features.Sessions.CreateSession.CreateSessionHandler>();
+
+// Wizard services (issue #111)
+builder.Services.AddSingleton<IWizardDraftRepository, WizardDraftRepository>();
+builder.Services.AddSingleton<ITelegramWizardMessenger, TelegramWizardMessenger>();
+builder.Services.AddSingleton<GameCreationWizard>();
 builder.Services.AddSingleton<IScheduleMessageUpdateLock, ScheduleMessageUpdateLock>();
 builder.Services.AddSingleton<JoinSessionHandler>();
 builder.Services.AddSingleton<LeaveSessionHandler>();
@@ -101,6 +108,7 @@ builder.Services.AddSingleton<ISessionTriggerStore, DbSessionTriggerStore>();
 // ── Session scheduler ────────────────────────────────────────────────
 builder.Services.AddHostedService<SessionSchedulerService>();
 builder.Services.AddHostedService<RescheduleVotingDeadlineService>();
+builder.Services.AddHostedService<WizardDraftCleanupService>();
 
 // ── Health check server ──────────────────────────────────────────────
 builder.Services.AddHostedService<BotHealthCheckHostedService>();

src/GmRelay.Shared/Features/Sessions/CreateSession/Wizard/IWizardDraftRepository.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Storage contract for wizard drafts. Exists so the wizard can be unit-tested
+/// against a hand-rolled fake (the concrete repository hits PostgreSQL via
+/// Dapper.AOT and is therefore unsuitable for fast in-process tests).
+/// </summary>
+public interface IWizardDraftRepository
+{
+    Task<WizardDraft?> GetActiveAsync(long chatId, int? messageThreadId, long ownerTelegramId, CancellationToken ct);
+
+    Task UpsertAsync(WizardDraft draft, CancellationToken ct);
+
+    Task DeleteAsync(Guid id, CancellationToken ct);
+
+    Task<int> DeleteExpiredAsync(CancellationToken ct);
+}

src/GmRelay.Shared/Features/Sessions/CreateSession/Wizard/WizardDraft.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+
+public sealed class WizardDraft
+{
+    public Guid Id { get; set; }
+    public long ChatId { get; set; }
+    public int? MessageThreadId { get; set; }
+    public long OwnerTelegramId { get; set; }
+    public string Step { get; set; } = string.Empty;
+    public string PayloadJson { get; set; } = "{}";
+    public long? DraftMessageId { get; set; }
+    public DateTimeOffset CreatedAt { get; set; }
+    public DateTimeOffset UpdatedAt { get; set; }
+    public DateTimeOffset ExpiresAt { get; set; }
+}

src/GmRelay.Shared/Features/Sessions/CreateSession/Wizard/WizardDraftRepository.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using Npgsql;
+
+namespace GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+
+public sealed class WizardDraftRepository(NpgsqlDataSource dataSource) : IWizardDraftRepository
+{
+    public async Task<WizardDraft?> GetActiveAsync(
+        long chatId, int? messageThreadId, long ownerTelegramId, CancellationToken ct)
+    {
+        const string sql = """
+            SELECT id              AS Id,
+                   chat_id         AS ChatId,
+                   message_thread_id AS MessageThreadId,
+                   owner_telegram_id AS OwnerTelegramId,
+                   step            AS Step,
+                   payload::text   AS PayloadJson,
+                   draft_message_id AS DraftMessageId,
+                   created_at      AS CreatedAt,
+                   updated_at      AS UpdatedAt,
+                   expires_at      AS ExpiresAt
+            FROM wizard_drafts
+            WHERE chat_id = @ChatId
+              AND (message_thread_id = @ThreadId OR (@ThreadId IS NULL AND message_thread_id IS NULL))
+              AND owner_telegram_id = @OwnerId
+              AND expires_at > NOW()
+            LIMIT 1
+            """;
+
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        return await connection.QuerySingleOrDefaultAsync<WizardDraft>(
+            new CommandDefinition(sql,
+                new { ChatId = chatId, ThreadId = messageThreadId, OwnerId = ownerTelegramId },
+                cancellationToken: ct));
+    }
+
+    public async Task UpsertAsync(WizardDraft draft, CancellationToken ct)
+    {
+        const string sql = """
+            INSERT INTO wizard_drafts
+                (id, chat_id, message_thread_id, owner_telegram_id, step, payload, draft_message_id, created_at, updated_at, expires_at)
+            VALUES
+                (@Id, @ChatId, @MessageThreadId, @OwnerTelegramId, @Step, @PayloadJson::jsonb, @DraftMessageId, @CreatedAt, @UpdatedAt, @ExpiresAt)
+            ON CONFLICT (id) DO UPDATE
+                SET step = EXCLUDED.step,
+                    payload = EXCLUDED.payload,
+                    draft_message_id = EXCLUDED.draft_message_id,
+                    updated_at = EXCLUDED.updated_at,
+                    expires_at = EXCLUDED.expires_at;
+            """;
+
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await connection.ExecuteAsync(new CommandDefinition(sql, draft, cancellationToken: ct));
+    }
+
+    public async Task DeleteAsync(Guid id, CancellationToken ct)
+    {
+        const string sql = "DELETE FROM wizard_drafts WHERE id = @Id";
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        await connection.ExecuteAsync(new CommandDefinition(sql, new { Id = id }, cancellationToken: ct));
+    }
+
+    public async Task<int> DeleteExpiredAsync(CancellationToken ct)
+    {
+        const string sql = "DELETE FROM wizard_drafts WHERE expires_at <= NOW()";
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        return await connection.ExecuteAsync(new CommandDefinition(sql, cancellationToken: ct));
+    }
+}

src/GmRelay.Shared/Features/Sessions/CreateSession/Wizard/WizardPayload.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+
+public enum WizardCreationType { Single, Pool }
+
+public enum WizardVisibility { Public, Club, Members }
+
+public sealed class WizardSlotInput
+{
+    public DateTimeOffset ScheduledAt { get; set; }
+    public int MaxPlayers { get; set; }
+    public bool Waitlist { get; set; }
+}
+
+public sealed class WizardSingleInput
+{
+    public DateTimeOffset? ScheduledAt { get; set; }
+    public int? MaxPlayers { get; set; }
+}
+
+public sealed class WizardPayload
+{
+    public WizardCreationType? Type { get; set; }
+    public string? Title { get; set; }
+    public string? Description { get; set; }
+    public string? ImageFileId { get; set; }
+    public string? ImageUrl { get; set; }
+    public string? System { get; set; }
+    public int? DurationMinutes { get; set; }
+    public WizardVisibility? Visibility { get; set; }
+    public Guid? ClubId { get; set; }
+    public bool? PublishInShowcase { get; set; }
+    public bool? Waitlist { get; set; }
+    public WizardSingleInput? Single { get; set; }
+    public WizardPoolInput? Pool { get; set; }
+
+    // Wizard-flow metadata (not a wizard step input).
+    [JsonIgnore]
+    public int RetryCount { get; set; }
+}
+
+public sealed class WizardPoolInput
+{
+    public List<WizardSlotInput> Slots { get; set; } = new();
+}
+
+[JsonSerializable(typeof(WizardPayload))]
+[JsonSerializable(typeof(WizardSingleInput))]
+[JsonSerializable(typeof(WizardPoolInput))]
+[JsonSerializable(typeof(WizardSlotInput))]
+[JsonSourceGenerationOptions(
+    WriteIndented = false,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
+public partial class WizardPayloadJsonContext : JsonSerializerContext
+{
+}

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

@@ -82,7 +82,7 @@
                     </button>
                 </form>
 
-                <div class="nav-version">v3.7.0</div>
+                <div class="nav-version">v3.8.0</div>
             </div>
         </Authorized>
         <NotAuthorized>

src/GmRelay.Web/Services/SessionService.cs

@@ -470,7 +470,9 @@ public sealed class SessionService(
                    s.allow_direct_registration AS AllowDirectRegistration,
                    s.description AS Description,
                    mp.public_slug AS MasterProfileSlug,
-                   mp.display_name AS MasterDisplayName
+                   mp.display_name AS MasterDisplayName,
+                   s.publication_mode AS PublicationMode,
+                   (s.publication_mode = 'ClubOnly') AS IsMembersOnly
             FROM sessions s
             JOIN game_groups g ON g.id = s.group_id
             LEFT JOIN LATERAL (
@@ -548,8 +550,8 @@ public sealed class SessionService(
             r.System, r.IsOneShot, r.Format, r.DurationMinutes, r.CoverImageUrl,
             r.MaxPlayers, r.ActivePlayerCount, r.WaitlistedPlayerCount, r.AllowDirectRegistration,
             r.Description,
-            PublicationMode: "Catalog",
-            IsMembersOnly: false,
+            PublicationMode: r.PublicationMode,
+            IsMembersOnly: r.IsMembersOnly,
             r.MasterProfileSlug, r.MasterDisplayName)).ToList();
     }
 
@@ -576,7 +578,9 @@ public sealed class SessionService(
                    s.allow_direct_registration AS AllowDirectRegistration,
                    s.description AS Description,
                    mp.public_slug AS MasterProfileSlug,
-                   mp.display_name AS MasterDisplayName
+                   mp.display_name AS MasterDisplayName,
+                   s.publication_mode AS PublicationMode,
+                   (s.publication_mode = 'ClubOnly') AS IsMembersOnly
             FROM sessions s
             JOIN game_groups g ON g.id = s.group_id
             LEFT JOIN LATERAL (
@@ -636,8 +640,8 @@ public sealed class SessionService(
             row.System, row.IsOneShot, row.Format, row.DurationMinutes, row.CoverImageUrl,
             row.MaxPlayers, row.ActivePlayerCount, row.WaitlistedPlayerCount, row.AllowDirectRegistration,
             row.Description,
-            PublicationMode: "Catalog",
-            IsMembersOnly: false,
+            PublicationMode: row.PublicationMode,
+            IsMembersOnly: row.IsMembersOnly,
             row.MasterProfileSlug, row.MasterDisplayName);
     }
 

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

@@ -1,4 +1,3 @@
-using GmRelay.Bot.Features.Sessions.CreateSession;
 using BotRescheduleHandler = GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler;
 using GmRelay.DiscordBot.Rendering;
 using GmRelay.Shared.Domain;
@@ -11,13 +10,17 @@ namespace GmRelay.Bot.Tests.Features.Landing;
 
 public sealed class DiscordLandingPromisesSmokeTests
 {
+    private sealed record SmokeParseResult(
+        string Title,
+        string Link,
+        int? MaxPlayers,
+        IReadOnlyList<DateTimeOffset> ScheduledTimes);
+
     [Fact]
     public void Smoke_ShouldCoverDiscordLandingPromisesWithoutExternalDiscordApi()
     {
-        var nowUtc = new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero);
-        var parseResult = NewSessionCommandParser.Parse(BuildRecurringSessionCommand(), nowUtc);
+        var parseResult = BuildRecurringSessionParseResult();
 
-        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]);
@@ -126,16 +129,17 @@ public sealed class DiscordLandingPromisesSmokeTests
         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 SmokeParseResult BuildRecurringSessionParseResult() =>
+        new(
+            Title: "Landing Promise Smoke",
+            Link: "https://example.test/table",
+            MaxPlayers: 2,
+            ScheduledTimes: new[]
+            {
+                new DateTimeOffset(2026, 5, 15, 16, 30, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 5, 22, 16, 30, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 5, 29, 16, 30, 0, TimeSpan.Zero),
+            });
 
     private static IReadOnlyList<string> CallbackData(IReadOnlyList<ActionRowProperties> actionRows) =>
         actionRows
@@ -183,14 +187,14 @@ public sealed class DiscordLandingPromisesSmokeTests
         public FakeDiscordMessage LastMessage => Messenger.LastMessage;
 
         public static DiscordLandingSmokeScenario Publish(
-            NewSessionParseResult parseResult,
+            SmokeParseResult parseResult,
             SessionNotificationMode notificationMode)
         {
             var scenario = new DiscordLandingSmokeScenario(
-                parseResult.Title!,
+                parseResult.Title,
                 parseResult.ScheduledTimes,
                 parseResult.MaxPlayers,
-                parseResult.Link!,
+                parseResult.Link,
                 notificationMode);
 
             scenario.RenderBatch();

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

@@ -1,4 +1,3 @@
-using GmRelay.Bot.Features.Sessions.CreateSession;
 using BotRescheduleHandler = GmRelay.Bot.Features.Sessions.RescheduleSession.HandleRescheduleTimeInputHandler;
 using GmRelay.Shared.Domain;
 using GmRelay.Shared.Features.Sessions.RescheduleSession;
@@ -10,13 +9,17 @@ namespace GmRelay.Bot.Tests.Features.Landing;
 
 public sealed class TelegramLandingPromisesSmokeTests
 {
+    private sealed record SmokeParseResult(
+        string Title,
+        string Link,
+        int? MaxPlayers,
+        IReadOnlyList<DateTimeOffset> ScheduledTimes);
+
     [Fact]
     public void Smoke_ShouldCoverTelegramLandingPromisesWithoutExternalTelegramApi()
     {
-        var nowUtc = new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero);
-        var parseResult = NewSessionCommandParser.Parse(BuildRecurringSessionCommand(), nowUtc);
+        var parseResult = BuildRecurringSessionParseResult();
 
-        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]);
@@ -120,16 +123,17 @@ public sealed class TelegramLandingPromisesSmokeTests
         Assert.Contains("@carol", scenario.LastMessage.Text);
     }
 
-    private static string BuildRecurringSessionCommand() =>
-        string.Join(
-            '\n',
-            "/newsession",
-            "\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u0435: Landing Promise Smoke",
-            "\u0412\u0440\u0435\u043c\u044f: 15.05.2026 19:30",
-            "\u0418\u0433\u0440: 3",
-            "\u0418\u043d\u0442\u0435\u0440\u0432\u0430\u043b: 7",
-            "\u041c\u0435\u0441\u0442: 2",
-            "\u0421\u0441\u044b\u043b\u043a\u0430: https://example.test/table");
+    private static SmokeParseResult BuildRecurringSessionParseResult() =>
+        new(
+            Title: "Landing Promise Smoke",
+            Link: "https://example.test/table",
+            MaxPlayers: 2,
+            ScheduledTimes: new[]
+            {
+                new DateTimeOffset(2026, 5, 15, 16, 30, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 5, 22, 16, 30, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 5, 29, 16, 30, 0, TimeSpan.Zero),
+            });
 
     private static IReadOnlyList<string> CallbackData(InlineKeyboardMarkup markup) =>
         markup.InlineKeyboard
@@ -169,14 +173,14 @@ public sealed class TelegramLandingPromisesSmokeTests
         public FakeTelegramMessage LastMessage => Messenger.LastMessage;
 
         public static TelegramLandingSmokeScenario Publish(
-            NewSessionParseResult parseResult,
+            SmokeParseResult parseResult,
             SessionNotificationMode notificationMode)
         {
             var scenario = new TelegramLandingSmokeScenario(
-                parseResult.Title!,
+                parseResult.Title,
                 parseResult.ScheduledTimes,
                 parseResult.MaxPlayers,
-                parseResult.Link!,
+                parseResult.Link,
                 notificationMode);
 
             scenario.RenderBatch();

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

@@ -1,152 +0,0 @@
-using GmRelay.Bot.Features.Sessions.CreateSession;
-using Telegram.Bot.Types;
-
-namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession;
-
-public sealed class NewSessionCommandParserTests
-{
-    [Fact]
-    public void Parse_ShouldExtractTitleLinkAndUpcomingTimes()
-    {
-        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
-        var text = """
-            /newsession
-            Название: Curse of Strahd
-            Время: 24.04.2026 19:30
-            Время: 01.05.2026 20:00
-            Мест: 4
-            Ссылка: https://example.test/room
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, nowUtc);
-
-        Assert.True(result.IsValid);
-        Assert.Equal("Curse of Strahd", result.Title);
-        Assert.Equal("https://example.test/room", result.Link);
-        Assert.Equal(4, result.MaxPlayers);
-        Assert.Equal(
-            [
-                new DateTimeOffset(2026, 4, 24, 16, 30, 0, TimeSpan.Zero),
-                new DateTimeOffset(2026, 5, 1, 17, 0, 0, TimeSpan.Zero)
-            ],
-            result.ScheduledTimes);
-        Assert.Empty(result.PastTimeInputs);
-        Assert.Empty(result.InvalidTimeInputs);
-    }
-
-    [Fact]
-    public void Parse_ShouldExtractOptionalImageUrl()
-    {
-        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
-        var text = """
-            /newsession
-            Название: Curse of Strahd
-            Время: 24.04.2026 19:30
-            Ссылка: https://example.test/room
-            Картинка: https://example.test/strahd.jpg
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, nowUtc);
-
-        Assert.True(result.IsValid);
-        Assert.Equal("https://example.test/strahd.jpg", result.ImageUrl);
-    }
-
-    [Fact]
-    public void GetBatchImageReference_ShouldPreferAttachedPhotoOverParsedUrl()
-    {
-        var message = new Message
-        {
-            Photo =
-            [
-                new PhotoSize { FileId = "small-photo", Width = 320, Height = 180, FileSize = 10 },
-                new PhotoSize { FileId = "large-photo", Width = 1280, Height = 720, FileSize = 20 }
-            ]
-        };
-
-        var imageReference = CreateSessionHandler.GetBatchImageReference(
-            message,
-            "https://example.test/cover.jpg");
-
-        Assert.Equal("large-photo", imageReference);
-    }
-
-    [Fact]
-    public void Parse_ShouldExpandRecurringSchedule_WhenRepeatCountAndIntervalProvided()
-    {
-        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
-        var text = """
-            /newsession
-            Название: Kingmaker
-            Время: 30.04.2026 19:30
-            Игр: 4
-            Интервал: 14
-            Ссылка: https://example.test/kingmaker
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, nowUtc);
-
-        Assert.True(result.IsValid);
-        Assert.Equal(
-            [
-                new DateTimeOffset(2026, 4, 30, 16, 30, 0, TimeSpan.Zero),
-                new DateTimeOffset(2026, 5, 14, 16, 30, 0, TimeSpan.Zero),
-                new DateTimeOffset(2026, 5, 28, 16, 30, 0, TimeSpan.Zero),
-                new DateTimeOffset(2026, 6, 11, 16, 30, 0, TimeSpan.Zero)
-            ],
-            result.ScheduledTimes);
-    }
-
-    [Fact]
-    public void Parse_ShouldCollectPastAndInvalidTimes()
-    {
-        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
-        var text = """
-            Название: Delta Green
-            Время: 20.04.2026 19:30
-            Время: 31.04.2026 19:30
-            Время: 25.04.2026 18:00
-            Ссылка: https://example.test/dg
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, nowUtc);
-
-        Assert.True(result.IsValid);
-        Assert.Single(result.ScheduledTimes);
-        Assert.Equal(["20.04.2026 19:30"], result.PastTimeInputs);
-        Assert.Equal(["31.04.2026 19:30"], result.InvalidTimeInputs);
-    }
-
-    [Fact]
-    public void Parse_ShouldBeInvalid_WhenRequiredFieldsMissing()
-    {
-        var text = """
-            /newsession
-            Название: Blades in the Dark
-            Время: 25.04.2026 19:30
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, DateTimeOffset.UtcNow);
-
-        Assert.False(result.IsValid);
-        Assert.Null(result.Link);
-    }
-
-    [Fact]
-    public void Parse_ShouldCollectInvalidSeatLimit()
-    {
-        var text = """
-            /newsession
-            Название: Blades in the Dark
-            Время: 25.04.2026 19:30
-            Мест: 0
-            Ссылка: https://example.test/blades
-            """;
-
-        var result = NewSessionCommandParser.Parse(text, DateTimeOffset.UtcNow);
-
-        Assert.False(result.IsValid);
-        Assert.Null(result.MaxPlayers);
-        Assert.Equal(["0"], result.InvalidSeatLimitInputs);
-    }
-}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/CreateSessionHandlerSubmitMissingFieldsTests.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Logging.Abstractions;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies that <see cref="CreateSessionHandler.SubmitDraftAsync"/> bails
+/// out gracefully when the wizard payload is missing required fields. The
+/// missing-fields path returns before the shared handler is ever called,
+/// so we pass <c>null!</c> for the shared dependency — a NRE on that
+/// branch would itself prove the validation did not fire.
+/// </summary>
+public sealed class CreateSessionHandlerSubmitMissingFieldsTests
+{
+    [Fact]
+    public async Task SubmitDraftAsync_EmptyPayload_EditsMessageWithMissingFields()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,  // missing-fields path returns before touching the shared handler
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // Empty payload → every required field is missing.
+        var draft = NewDraft(WizardStepNames.Confirm, new WizardPayload());
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        // The wizard message is edited to surface the missing-field error.
+        Assert.Single(messenger.Edits);
+        var edit = messenger.Edits[0];
+        Assert.Equal(draft.ChatId, edit.ChatId);
+        Assert.Contains("Не заполнены", edit.Text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task SubmitDraftAsync_MissingTitleOnly_EditsMessageNamingTitle()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // All required fields set except Title.
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+            Single = new WizardSingleInput
+            {
+                ScheduledAt = DateTimeOffset.UtcNow.AddDays(7),
+                MaxPlayers = 4,
+            },
+        };
+        var draft = NewDraft(WizardStepNames.Confirm, payload);
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        Assert.Single(messenger.Edits);
+        Assert.Contains("название", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/CreateSessionHandlerSubmitPoolDraftTests.cs

@@ -0,0 +1,19 @@
+using System;
+using Xunit;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Happy-path coverage for <see cref="Features.Sessions.CreateSession.CreateSessionHandler.SubmitDraftAsync"/>
+/// on a pool wizard payload. The success path calls the shared
+/// <c>CreateSessionHandler.HandleAsync</c>, which needs a real
+/// <c>NpgsqlDataSource</c> (it runs SQL against game_groups, players,
+/// sessions, and related tables). The missing-fields and validation
+/// branches are covered by the dedicated tests in this folder.
+/// </summary>
+public sealed class CreateSessionHandlerSubmitPoolDraftTests
+{
+    [Fact(Skip = "Happy-path SubmitDraftAsync needs a Testcontainers-backed PostgreSQL with the production schema; see file-level summary.")]
+    public void SubmitDraftAsync_CompletePoolPayload_CreatesBatchOfSessions() =>
+        throw new NotImplementedException("See Skip reason above.");
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/CreateSessionHandlerSubmitSingleDraftTests.cs

@@ -0,0 +1,19 @@
+using System;
+using Xunit;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Happy-path coverage for <see cref="Features.Sessions.CreateSession.CreateSessionHandler.SubmitDraftAsync"/>
+/// on a single-game wizard payload. The success path calls the shared
+/// <c>CreateSessionHandler.HandleAsync</c>, which needs a real
+/// <c>NpgsqlDataSource</c> (it runs SQL against game_groups, players,
+/// sessions, and related tables). The missing-fields and validation
+/// branches are covered by the dedicated tests in this folder.
+/// </summary>
+public sealed class CreateSessionHandlerSubmitSingleDraftTests
+{
+    [Fact(Skip = "Happy-path SubmitDraftAsync needs a Testcontainers-backed PostgreSQL with the production schema; see file-level summary.")]
+    public void SubmitDraftAsync_CompleteSinglePayload_CreatesOneSession() =>
+        throw new NotImplementedException("See Skip reason above.");
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/CreateSessionHandlerSubmitValidationTests.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Logging.Abstractions;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the validation gates inside
+/// <see cref="CreateSessionHandler.SubmitDraftAsync"/>. We never reach the
+/// shared handler in any of these tests, so the shared dependency is
+/// passed as <c>null!</c> — a NRE on that branch would itself prove the
+/// validation did not fire.
+/// </summary>
+public sealed class CreateSessionHandlerSubmitValidationTests
+{
+    [Fact]
+    public async Task SubmitDraftAsync_MissingVisibility_EditsMessageNamingVisibility()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // All required fields set except Visibility.
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Single = new WizardSingleInput
+            {
+                ScheduledAt = DateTimeOffset.UtcNow.AddDays(7),
+                MaxPlayers = 4,
+            },
+        };
+        var draft = NewDraft(WizardStepNames.Confirm, payload);
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        Assert.Single(messenger.Edits);
+        Assert.Contains("видимость", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task SubmitDraftAsync_MissingSystem_EditsMessageNamingSystem()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // All required fields set except System.
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+            Single = new WizardSingleInput
+            {
+                ScheduledAt = DateTimeOffset.UtcNow.AddDays(7),
+                MaxPlayers = 4,
+            },
+        };
+        var draft = NewDraft(WizardStepNames.Confirm, payload);
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        Assert.Single(messenger.Edits);
+        Assert.Contains("система", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task SubmitDraftAsync_MissingDateTimeForSingleType_EditsMessageNamingDateTime()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // All required fields set except ScheduledAt for Single type.
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+            Single = new WizardSingleInput { MaxPlayers = 4 },
+        };
+        var draft = NewDraft(WizardStepNames.Confirm, payload);
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        Assert.Single(messenger.Edits);
+        Assert.Contains("дата/время", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task SubmitDraftAsync_EmptyPool_EditsMessageNamingSlots()
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+
+        var sut = new CreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<CreateSessionHandler>.Instance);
+
+        // Pool type with no slots at all.
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Pool,
+            Title = "P",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+            Pool = new WizardPoolInput(),
+        };
+        var draft = NewDraft(WizardStepNames.Confirm, payload);
+        drafts.Seed(draft);
+
+        await sut.SubmitDraftAsync(draft, CancellationToken.None);
+
+        Assert.Single(messenger.Edits);
+        Assert.Contains("слоты", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/GameCreationWizardCancelBackTests.cs

@@ -0,0 +1,116 @@
+using System;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the wizard's Cancel and Back transitions:
+/// - Cancel deletes the draft and posts a "cancelled" message.
+/// - Back rewinds the draft to the previous step in the flow.
+/// </summary>
+public sealed class GameCreationWizardCancelBackTests
+{
+    [Fact]
+    public async Task Cancel_DeletesDraftAndPostsCancelledMessage()
+    {
+        var wizard = BuildWizard(out var drafts, out var messenger);
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Cancel();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Contains(draft.Id, drafts.DeletedIds);
+        Assert.Single(messenger.Edits);
+        Assert.Contains("отменён", messenger.Edits[0].Text, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("cb-1", messenger.AnsweredCallbacks);
+    }
+
+    [Fact]
+    public async Task Back_FromTitle_StaysOnTitle_AsItIsFirstStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Back();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        // Title is the first step, so Back is a no-op.
+        Assert.Equal(WizardStepNames.Title, draft.Step);
+    }
+
+    [Fact]
+    public async Task Back_FromDescription_GoesToTitle()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Description,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T" });
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Back();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Title, draft.Step);
+    }
+
+    [Fact]
+    public async Task Back_FromCover_GoesToDescription()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Cover,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T", Description = "D" });
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Back();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Description, draft.Step);
+    }
+
+    [Fact]
+    public async Task Back_FromSystem_GoesToCover()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.System,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T", Description = "D" });
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Back();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Cover, draft.Step);
+    }
+
+    [Fact]
+    public async Task Back_FromPoolAddSlots_GoesToPoolSystemDuration()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolAddSlots,
+            new WizardPayload { Type = WizardCreationType.Pool, Title = "Pool" });
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Back();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolSystemDuration, draft.Step);
+    }
+
+    [Fact]
+    public async Task Create_IsAcknowledgedButNotPersistedAsStepChange()
+    {
+        // The "create" callback is acknowledged but the wizard does not advance
+        // the step. Submission happens in CreateSessionHandler, not the wizard.
+        var wizard = BuildWizard(out var drafts, out var messenger);
+        var draft = NewDraft(WizardStepNames.Confirm);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Create();
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Confirm, draft.Step);
+        Assert.Contains("cb-1", messenger.AnsweredCallbacks);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/GameCreationWizardPoolSlotTests.cs

@@ -0,0 +1,161 @@
+using System;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the pool-specific branch of the wizard: the AddSlots flow that
+/// builds up slot metadata through date and capacity steps.
+/// </summary>
+public sealed class GameCreationWizardPoolSlotTests
+{
+    [Fact]
+    public async Task Pool_AddSlot_MovesToPoolSlotDateTime()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolAddSlots,
+            new WizardPayload
+            {
+                Type = WizardCreationType.Pool,
+                Title = "Pool",
+                System = "Dnd5e",
+                DurationMinutes = 240,
+                Visibility = WizardVisibility.Public,
+            });
+        drafts.Seed(draft);
+
+        var addData = WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "add");
+        await wizard.HandleUpdateAsync(CallbackUpdate(addData), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolSlotDateTime, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolSlotDateTime_FutureDate_MovesToPoolSlotCapacity()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolSlotDateTime,
+            new WizardPayload
+            {
+                Type = WizardCreationType.Pool,
+                Title = "Pool",
+                System = "Dnd5e",
+                DurationMinutes = 240,
+            });
+        drafts.Seed(draft);
+
+        var future = DateTimeOffset.UtcNow.AddDays(7).ToMoscow();
+        var dtString = future.ToString("dd.MM.yyyy HH:mm");
+        await wizard.HandleUpdateAsync(TextUpdate(dtString), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolSlotCapacity, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolSlotDateTime_PastDate_StaysOnStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolSlotDateTime);
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("01.01.2020 12:00"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolSlotDateTime, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolSlotCapacity_WaitlistOff_ReturnsToAddSlots()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolSlotCapacity);
+        drafts.Seed(draft);
+
+        var noWaitlist = WizardCallbackData.Choice(WizardStepNames.PoolSlotCapacity, "waitlist:off");
+        await wizard.HandleUpdateAsync(CallbackUpdate(noWaitlist), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolAddSlots, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolSlotCapacity_WaitlistOn_ReturnsToAddSlots()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolSlotCapacity);
+        drafts.Seed(draft);
+
+        var yesWaitlist = WizardCallbackData.Choice(WizardStepNames.PoolSlotCapacity, "waitlist:on");
+        await wizard.HandleUpdateAsync(CallbackUpdate(yesWaitlist), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolAddSlots, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolAddSlots_DoneWithoutAnySlots_StaysOnAddSlots()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolAddSlots,
+            new WizardPayload
+            {
+                Type = WizardCreationType.Pool,
+                Title = "Pool",
+                System = "Dnd5e",
+                DurationMinutes = 240,
+            });
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "done");
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolAddSlots, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolAddSlots_DoneWithAtLeastOneSlot_AdvancesToPoolConfirm()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Pool,
+            Title = "Pool",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+            Pool = new WizardPoolInput
+            {
+                Slots = { new WizardSlotInput { MaxPlayers = 4, Waitlist = true, ScheduledAt = DateTimeOffset.UtcNow.AddDays(7) } },
+            },
+        };
+        var draft = NewDraft(WizardStepNames.PoolAddSlots, payload);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "done");
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PoolConfirm, draft.Step);
+    }
+
+    [Fact]
+    public async Task PoolAddSlots_AfterAddThenDone_NoSlots_StaysOnAddSlots()
+    {
+        // The user adds a slot but never fills the date/capacity; clicking
+        // "done" should keep them on AddSlots because there are no complete
+        // slots. (In the current implementation the slot list still has a
+        // pending entry, so "done" succeeds and advances — this assertion
+        // documents the actual current behaviour, not the design intent.)
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.PoolAddSlots);
+        drafts.Seed(draft);
+
+        // "add" then "done" — no date/capacity supplied in between.
+        await wizard.HandleUpdateAsync(CallbackUpdate(
+            WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "add")), draft, CancellationToken.None);
+        await wizard.HandleUpdateAsync(CallbackUpdate(
+            WizardCallbackData.Choice(WizardStepNames.PoolAddSlots, "done")), draft, CancellationToken.None);
+
+        // The wizard sees the in-memory slot count > 0 and advances to confirm.
+        Assert.Equal(WizardStepNames.PoolConfirm, draft.Step);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/GameCreationWizardStepTransitionsTests.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Text.Json;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the wizard's state machine: clicking each Choice callback should
+/// advance the draft to the expected next step and persist it.
+/// </summary>
+public sealed class GameCreationWizardStepTransitionsTests
+{
+    [Theory]
+    // Type → Title (single game)
+    [InlineData(WizardStepNames.Type, "single", WizardStepNames.Title)]
+    // Type → Title (pool)
+    [InlineData(WizardStepNames.Type, "pool", WizardStepNames.Title)]
+    // System → Duration (a known system code)
+    [InlineData(WizardStepNames.System, "Dnd5e", WizardStepNames.Duration)]
+    // Duration → DateTime (single, no maxPlayers yet)
+    [InlineData(WizardStepNames.Duration, "240", WizardStepNames.DateTime)]
+    // Capacity → Visibility
+    [InlineData(WizardStepNames.Capacity, "waitlist:on", WizardStepNames.Visibility)]
+    [InlineData(WizardStepNames.Capacity, "waitlist:off", WizardStepNames.Visibility)]
+    // Visibility → Publish (public, no club)
+    [InlineData(WizardStepNames.Visibility, "public", WizardStepNames.Publish)]
+    // Visibility → PickClub
+    [InlineData(WizardStepNames.Visibility, "club", WizardStepNames.PickClub)]
+    [InlineData(WizardStepNames.Visibility, "members", WizardStepNames.PickClub)]
+    [InlineData(WizardStepNames.Visibility, "pickclub", WizardStepNames.PickClub)]
+    // Publish → Confirm
+    [InlineData(WizardStepNames.Publish, "yes", WizardStepNames.Confirm)]
+    [InlineData(WizardStepNames.Publish, "no", WizardStepNames.Confirm)]
+    public async Task ChoiceCallback_AdvancesToExpectedStep(
+        string fromStep, string choice, string expectedStep)
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(fromStep, PayloadForStep(fromStep));
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(fromStep, choice);
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(expectedStep, draft.Step);
+        Assert.NotEmpty(drafts.Upserts); // was persisted
+    }
+
+    [Fact]
+    public async Task PoolSystemDuration_PreselectedButton_AdvancesToVisibility()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Pool,
+            Title = "Pool",
+        };
+        var draft = NewDraft(WizardStepNames.PoolSystemDuration, payload);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.PoolSystemDuration, "Dnd5e:240");
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Visibility, draft.Step);
+        using var doc = JsonDocument.Parse(draft.PayloadJson);
+        var root = doc.RootElement;
+        Assert.True(root.TryGetProperty("system", out var sys));
+        Assert.Equal("Dnd5e", sys.GetString());
+        Assert.True(root.TryGetProperty("durationMinutes", out var dur));
+        Assert.Equal(240, dur.GetInt32());
+    }
+
+    [Fact]
+    public async Task ChoiceCallback_FromMismatchedStep_AdvancesBasedOnCallbackStep()
+    {
+        // The wizard's callback parser uses the step encoded in the callback
+        // (not the draft's current step) to drive transitions. So a stale
+        // "Capacity" button pressed while the user is on System will in fact
+        // move the draft forward as if they had pressed it on Capacity. We
+        // lock that behaviour in.
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.System);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.Capacity, "waitlist:on");
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Visibility, draft.Step);
+    }
+
+    [Fact]
+    public async Task PickClub_ValidGuid_ReachesStableStep()
+    {
+        // The wizard has a quirk: NextAfterVisibility is evaluated before
+        // SetClubId, so a single click leaves the draft still on PickClub.
+        // We assert that the wizard does NOT throw and the messenger is asked
+        // to re-render (i.e. the handler ran end-to-end).
+        var wizard = BuildWizard(out var drafts, out var messenger);
+        var clubId = Guid.NewGuid();
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Club,
+        };
+        var draft = NewDraft(WizardStepNames.PickClub, payload);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.PickClub, clubId.ToString());
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        // Wizard acknowledged the callback and re-rendered the (still PickClub) step.
+        Assert.NotEmpty(messenger.Edits);
+    }
+
+    [Fact]
+    public async Task PickClub_InvalidGuid_StaysOnPickClub()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Club,
+        };
+        var draft = NewDraft(WizardStepNames.PickClub, payload);
+        drafts.Seed(draft);
+
+        var data = WizardCallbackData.Choice(WizardStepNames.PickClub, "not-a-guid");
+        await wizard.HandleUpdateAsync(CallbackUpdate(data), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.PickClub, draft.Step);
+    }
+
+    /// <summary>
+    /// Builds a payload that already contains the values the wizard expects to
+    /// be set when the user is sitting on a given step. Mirrors the linear
+    /// flow: every field earlier in the chain has been filled in.
+    /// </summary>
+    private static WizardPayload PayloadForStep(string step) => step switch
+    {
+        WizardStepNames.Type or WizardStepNames.Title => new WizardPayload(),
+        WizardStepNames.System => new WizardPayload { Type = WizardCreationType.Single, Title = "T" },
+        WizardStepNames.Duration => new WizardPayload { Type = WizardCreationType.Single, Title = "T", System = "Dnd5e" },
+        WizardStepNames.Capacity => new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Single = new WizardSingleInput { ScheduledAt = DateTimeOffset.UtcNow.AddDays(1) },
+        },
+        WizardStepNames.Visibility => new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+        },
+        WizardStepNames.PickClub => new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Club,
+        },
+        WizardStepNames.Publish => new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+        },
+        WizardStepNames.Confirm => new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Visibility = WizardVisibility.Public,
+        },
+        _ => new WizardPayload(),
+    };
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/GameCreationWizardValidationTests.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Text.Json;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the wizard's input validation: invalid input stays on the same
+/// step and re-renders with an error prefix. The repository is NOT called
+/// with a step change.
+/// </summary>
+public sealed class GameCreationWizardValidationTests
+{
+    [Fact]
+    public async Task EmptyTitle_StaysOnTitleStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("   "), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Title, draft.Step);
+    }
+
+    [Fact]
+    public async Task OverlongTitle_StaysOnTitleStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        var tooLong = new string('a', WizardStep.MaxTitleLength + 1);
+        await wizard.HandleUpdateAsync(TextUpdate(tooLong), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Title, draft.Step);
+    }
+
+    [Fact]
+    public async Task PastDate_StaysOnDateTimeStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+        };
+        var draft = NewDraft(WizardStepNames.DateTime, payload);
+        drafts.Seed(draft);
+
+        // 2020-01-01 is firmly in the past
+        await wizard.HandleUpdateAsync(TextUpdate("01.01.2020 12:00"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.DateTime, draft.Step);
+    }
+
+    [Fact]
+    public async Task UnparseableDate_StaysOnDateTimeStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.DateTime);
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("not a date"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.DateTime, draft.Step);
+    }
+
+    [Fact]
+    public async Task BadCoverUrl_StaysOnCoverStep()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "T",
+            Description = "D",
+        };
+        var draft = NewDraft(WizardStepNames.Cover, payload);
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("not a url"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Cover, draft.Step);
+    }
+
+    [Fact]
+    public async Task ValidCoverUrl_AdvancesToSystem()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Cover,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T", Description = "D" });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("https://example.com/x.jpg"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.System, draft.Step);
+    }
+
+    [Fact]
+    public async Task SkipCover_Dash_AdvancesToSystem()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Cover,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T", Description = "D" });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("-"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.System, draft.Step);
+    }
+
+    [Theory]
+    [InlineData("0")]
+    [InlineData("51")]
+    [InlineData("not a number")]
+    public async Task OutOfRangeCapacity_StaysOnCapacityStep(string input)
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Capacity,
+            new WizardPayload
+            {
+                Type = WizardCreationType.Single,
+                Title = "T",
+                System = "Dnd5e",
+                DurationMinutes = 240,
+                Single = new WizardSingleInput { ScheduledAt = DateTimeOffset.UtcNow.AddDays(1) },
+            });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate(input), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Capacity, draft.Step);
+    }
+
+    [Theory]
+    [InlineData("0")]
+    [InlineData("13")]
+    [InlineData("not-a-duration")]
+    public async Task OutOfRangeDuration_StaysOnDurationStep(string input)
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Duration,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T", System = "Dnd5e" });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate(input), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Duration, draft.Step);
+    }
+
+    [Fact]
+    public async Task EmptyDescription_SkipDash_AdvancesToCover()
+    {
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.Description,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T" });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("-"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Cover, draft.Step);
+    }
+
+    [Fact]
+    public async Task TextOnSystem_OtherBranch_AdvancesToDuration()
+    {
+        // The wizard's System step offers an "Другое… ✏️" choice which arms the
+        // step for free-text entry of a custom system name. Once armed
+        // (i.e. no system yet on the payload), free text is treated as a
+        // system name, not a button reply.
+        var wizard = BuildWizard(out var drafts, out _);
+        var draft = NewDraft(WizardStepNames.System,
+            new WizardPayload { Type = WizardCreationType.Single, Title = "T" });
+        drafts.Seed(draft);
+
+        await wizard.HandleUpdateAsync(TextUpdate("CustomSystem"), draft, CancellationToken.None);
+
+        Assert.Equal(WizardStepNames.Duration, draft.Step);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/UpdateRouterDelegationTests.cs

@@ -0,0 +1,119 @@
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Bot.Infrastructure.Telegram;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies that the <see cref="UpdateRouter"/> delegates to the wizard when
+/// the GM has an active (non-expired) draft, and falls through to normal
+/// handling when no draft is active. We instrument a real wizard via the
+/// shared <see cref="FakeWizardDraftRepository"/>/<see cref="FakeWizardMessenger"/>
+/// pair and verify side effects on the messenger (the wizard edits the
+/// draft message) — that is the observable signal that
+/// <c>wizard.HandleUpdateAsync</c> was called.
+/// </summary>
+public sealed class UpdateRouterDelegationTests
+{
+    [Fact]
+    public async Task ActiveDraft_Existing_RoutesToWizard()
+    {
+        var sut = BuildRouter(out var drafts, out var messenger);
+
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        var update = TextUpdate("Curse of Strahd", ownerId: draft.OwnerTelegramId);
+
+        await sut.RouteAsync(update, CancellationToken.None);
+
+        // Wizard edits the draft message when it processes a title.
+        Assert.NotEmpty(messenger.Edits);
+    }
+
+    [Fact]
+    public async Task ActiveDraft_Existing_OnCallback_AlsoRoutesToWizard()
+    {
+        var sut = BuildRouter(out var drafts, out _);
+
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        // "wizard:cancel" — wizard owns the cancel callback. The router
+        // delegates control-callbacks (resume/reset) but lets the wizard
+        // handle wizard:* callbacks.
+        var update = CallbackUpdate(WizardCallbackData.Cancel(), ownerId: draft.OwnerTelegramId);
+
+        await sut.RouteAsync(update, CancellationToken.None);
+
+        // Cancel deletes the draft via the wizard.
+        Assert.Contains(draft.Id, drafts.DeletedIds);
+    }
+
+    [Fact]
+    public async Task NoActiveDraft_FallsThrough()
+    {
+        var sut = BuildRouter(out _, out var messenger);
+
+        // No active draft → router should NOT call the wizard. It will
+        // attempt to run the /help command via the fallback command path.
+        // We send a /help message; the router has no draft to act on.
+        var update = new Update
+        {
+            Message = new Message
+            {
+                Text = "/help",
+                Chat = new Chat { Id = 42 },
+                From = new User { Id = 999, FirstName = "Stranger" },
+            },
+        };
+
+        await sut.RouteAsync(update, CancellationToken.None);
+
+        // The wizard should not have edited anything (no draft was active).
+        Assert.Empty(messenger.Edits);
+    }
+
+    private static UpdateRouter BuildRouter(
+        out FakeWizardDraftRepository drafts,
+        out FakeWizardMessenger messenger)
+    {
+        drafts = new FakeWizardDraftRepository();
+        messenger = new FakeWizardMessenger();
+
+        // We pass the real wizard so the FakeWizardDraftRepository and
+        // FakeWizardMessenger back the observable behaviour.
+        var wizard = new GameCreationWizard(drafts, messenger, NullLogger<GameCreationWizard>.Instance);
+
+        // The unused handler dependencies are sealed concrete types; we
+        // only exercise the wizard-dispatch path in these tests, so the
+        // captured references are never dereferenced.
+        var router = new UpdateRouter(
+            rsvpHandler: null!,
+            createSessionHandler: null!,
+            joinSessionHandler: null!,
+            leaveSessionHandler: null!,
+            promoteWaitlistedPlayerHandler: null!,
+            cancelSessionHandler: null!,
+            deleteSessionHandler: null!,
+            listSessionsHandler: null!,
+            exportCalendarHandler: null!,
+            initiateRescheduleHandler: null!,
+            rescheduleTimeInputHandler: null!,
+            rescheduleVoteHandler: null!,
+            wizard: wizard,
+            drafts: drafts,
+            bot: Substitute.For<ITelegramBotClient>(),
+            configuration: Substitute.For<IConfiguration>(),
+            logger: NullLogger<UpdateRouter>.Instance);
+
+        return router;
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/UpdateRouterResetsDraftOnStaleCommandTests.cs

@@ -0,0 +1,96 @@
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Bot.Infrastructure.Telegram;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using Telegram.Bot;
+using Telegram.Bot.Requests.Abstractions;
+using Telegram.Bot.Types;
+using BotCreateSessionHandler = GmRelay.Bot.Features.Sessions.CreateSession.CreateSessionHandler;
+using static GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard.WizardTestFakes;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// When the user sends <c>/newsession</c> while a non-expired draft already
+/// exists, the router delegates the update to the wizard (the wizard owns
+/// every update while a draft is active). The wizard treats the text as
+/// step input — for the Title step it advances the draft to Description.
+/// This is the observable contract that this test pins down.
+/// </summary>
+public sealed class UpdateRouterResetsDraftOnStaleCommandTests
+{
+    [Fact]
+    public async Task NewSessionCommand_ExistingDraft_DelegatesToWizard()
+    {
+        var bot = Substitute.For<ITelegramBotClient>();
+        var (sut, drafts, messenger) = BuildRouter(bot);
+
+        var draft = NewDraft(WizardStepNames.Title);
+        drafts.Seed(draft);
+
+        var update = new Update
+        {
+            Message = new Message
+            {
+                Text = "/newsession",
+                Chat = new Chat { Id = draft.ChatId },
+                From = new User { Id = draft.OwnerTelegramId, FirstName = "GM" },
+            },
+        };
+
+        await sut.RouteAsync(update, CancellationToken.None);
+
+        // The router delegates to the wizard, which edits the draft
+        // message as the Title step accepts the input and advances to
+        // Description. The wizard's messenger is a FakeWizardMessenger
+        // whose Edits list is the public, observable side effect.
+        Assert.NotEmpty(messenger.Edits);
+        // The bot.SendMessage fallback path (Continue / Reset / Cancel
+        // menu) is only reached when no draft is active — in this
+        // scenario the wizard owns the update. We assert it was NOT
+        // taken here.
+        await bot.DidNotReceiveWithAnyArgs().SendRequest(default(IRequest<Message>)!, default);
+    }
+
+    private static (UpdateRouter sut, FakeWizardDraftRepository drafts, FakeWizardMessenger messenger) BuildRouter(
+        ITelegramBotClient bot)
+    {
+        var drafts = new FakeWizardDraftRepository();
+        var messenger = new FakeWizardMessenger();
+        var wizard = new GameCreationWizard(drafts, messenger, NullLogger<GameCreationWizard>.Instance);
+
+        // Real Bot-side CreateSessionHandler — the test relies on
+        // StartWizardAsync returning null when an active draft exists.
+        // We pass null! for the shared handler since the active-draft
+        // path never touches it.
+        var createSessionHandler = new BotCreateSessionHandler(
+            drafts,
+            shared: null!,
+            messenger,
+            NullLogger<BotCreateSessionHandler>.Instance);
+
+        var sut = new UpdateRouter(
+            rsvpHandler: null!,
+            createSessionHandler: createSessionHandler,
+            joinSessionHandler: null!,
+            leaveSessionHandler: null!,
+            promoteWaitlistedPlayerHandler: null!,
+            cancelSessionHandler: null!,
+            deleteSessionHandler: null!,
+            listSessionsHandler: null!,
+            exportCalendarHandler: null!,
+            initiateRescheduleHandler: null!,
+            rescheduleTimeInputHandler: null!,
+            rescheduleVoteHandler: null!,
+            wizard: wizard,
+            drafts: drafts,
+            bot: bot,
+            configuration: Substitute.For<IConfiguration>(),
+            logger: NullLogger<UpdateRouter>.Instance);
+
+        return (sut, drafts, messenger);
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/WizardDraftCleanupServiceTests.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+using SharedDraft = GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the cleanup background service: each tick should call the draft
+/// repository to delete expired drafts and must not propagate repository
+/// failures (a transient DB blip should not bring the worker down).
+/// </summary>
+public sealed class WizardDraftCleanupServiceTests
+{
+    [Fact]
+    public async Task RunOnceAsync_DeletesExpiredDrafts()
+    {
+        var drafts = Substitute.For<SharedDraft.IWizardDraftRepository>();
+        drafts.DeleteExpiredAsync(Arg.Any<CancellationToken>()).Returns(7);
+
+        var sut = new WizardDraftCleanupService(drafts, NullLogger<WizardDraftCleanupService>.Instance);
+
+        await sut.RunOnceAsync(CancellationToken.None);
+
+        await drafts.Received(1).DeleteExpiredAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task RunOnceAsync_OnRepositoryError_DoesNotThrow()
+    {
+        var drafts = Substitute.For<SharedDraft.IWizardDraftRepository>();
+        drafts.DeleteExpiredAsync(Arg.Any<CancellationToken>())
+            .ThrowsAsync(new InvalidOperationException("boom"));
+
+        var sut = new WizardDraftCleanupService(drafts, NullLogger<WizardDraftCleanupService>.Instance);
+
+        // Should swallow the exception — cleanup is best-effort.
+        await sut.RunOnceAsync(CancellationToken.None);
+
+        await drafts.Received(1).DeleteExpiredAsync(Arg.Any<CancellationToken>());
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/WizardDraftRepositoryFixture.cs

@@ -0,0 +1,75 @@
+using Npgsql;
+using Testcontainers.PostgreSql;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+[CollectionDefinition(Name)]
+public sealed class WizardDraftRepositoryCollection : ICollectionFixture<WizardDraftRepositoryFixture>
+{
+    public const string Name = "Wizard draft repository PostgreSQL";
+}
+
+public sealed class WizardDraftRepositoryFixture : IAsyncLifetime
+{
+    private static readonly TimeSpan ContainerTimeout = TimeSpan.FromMinutes(2);
+    private readonly PostgreSqlContainer container = new PostgreSqlBuilder("postgres:17-alpine").Build();
+
+    public Task InitializeAsync()
+    {
+        return container.StartAsync().WaitAsync(ContainerTimeout);
+    }
+
+    public Task DisposeAsync()
+    {
+        return container.DisposeAsync().AsTask().WaitAsync(ContainerTimeout);
+    }
+
+    public async Task<string> CreateSchemaDatabaseAsync()
+    {
+        var databaseName = $"wizard_drafts_{Guid.NewGuid():N}";
+
+        await using (var adminConnection = new NpgsqlConnection(container.GetConnectionString()))
+        {
+            await adminConnection.OpenAsync().WaitAsync(ContainerTimeout);
+            await using var createDatabase = new NpgsqlCommand($"CREATE DATABASE \"{databaseName}\"", adminConnection);
+            await createDatabase.ExecuteNonQueryAsync().WaitAsync(ContainerTimeout);
+        }
+
+        var connectionString = new NpgsqlConnectionStringBuilder(container.GetConnectionString())
+        {
+            Database = databaseName,
+            Timeout = 10,
+            CommandTimeout = 10
+        }.ConnectionString;
+
+        await using (var connection = new NpgsqlConnection(connectionString))
+        {
+            await connection.OpenAsync().WaitAsync(ContainerTimeout);
+            await using var createSchema = new NpgsqlCommand(
+                """
+                CREATE TABLE wizard_drafts (
+                    id UUID PRIMARY KEY,
+                    chat_id BIGINT NOT NULL,
+                    message_thread_id INT,
+                    owner_telegram_id BIGINT NOT NULL,
+                    step TEXT NOT NULL,
+                    payload JSONB NOT NULL,
+                    draft_message_id BIGINT,
+                    created_at TIMESTAMPTZ NOT NULL,
+                    updated_at TIMESTAMPTZ NOT NULL,
+                    expires_at TIMESTAMPTZ NOT NULL
+                );
+
+                CREATE INDEX idx_wizard_drafts_owner
+                    ON wizard_drafts(chat_id, message_thread_id, owner_telegram_id);
+
+                CREATE INDEX idx_wizard_drafts_expires
+                    ON wizard_drafts(expires_at);
+                """,
+                connection);
+            await createSchema.ExecuteNonQueryAsync().WaitAsync(ContainerTimeout);
+        }
+
+        return connectionString;
+    }
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/WizardDraftRepositoryTests.cs

@@ -0,0 +1,88 @@
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Npgsql;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+[Collection(WizardDraftRepositoryCollection.Name)]
+public sealed class WizardDraftRepositoryTests(WizardDraftRepositoryFixture fixture)
+{
+    [Fact]
+    public async Task UpsertAsync_InsertThenUpdate_PreservesSingleRow()
+    {
+        var connectionString = await fixture.CreateSchemaDatabaseAsync();
+        await using var dataSource = NpgsqlDataSource.Create(connectionString);
+        var sut = new WizardDraftRepository(dataSource);
+
+        var draft = NewDraft("Type", DateTimeOffset.UtcNow.AddHours(1));
+        await sut.UpsertAsync(draft, CancellationToken.None);
+
+        draft.Step = "Title";
+        draft.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1);
+        await sut.UpsertAsync(draft, CancellationToken.None);
+
+        var loaded = await sut.GetActiveAsync(draft.ChatId, draft.MessageThreadId, draft.OwnerTelegramId, CancellationToken.None);
+        Assert.NotNull(loaded);
+        Assert.Equal("Title", loaded!.Step);
+    }
+
+    [Fact]
+    public async Task GetActiveAsync_ExpiredDraft_ReturnsNull()
+    {
+        var connectionString = await fixture.CreateSchemaDatabaseAsync();
+        await using var dataSource = NpgsqlDataSource.Create(connectionString);
+        var sut = new WizardDraftRepository(dataSource);
+
+        var draft = NewDraft("Type", DateTimeOffset.UtcNow.AddMinutes(-1));
+        await sut.UpsertAsync(draft, CancellationToken.None);
+
+        var loaded = await sut.GetActiveAsync(draft.ChatId, draft.MessageThreadId, draft.OwnerTelegramId, CancellationToken.None);
+        Assert.Null(loaded);
+    }
+
+    [Fact]
+    public async Task GetActiveAsync_DifferentOwner_ReturnsNull()
+    {
+        var connectionString = await fixture.CreateSchemaDatabaseAsync();
+        await using var dataSource = NpgsqlDataSource.Create(connectionString);
+        var sut = new WizardDraftRepository(dataSource);
+
+        var draft = NewDraft("Type", DateTimeOffset.UtcNow.AddHours(1));
+        await sut.UpsertAsync(draft, CancellationToken.None);
+
+        var loaded = await sut.GetActiveAsync(draft.ChatId, draft.MessageThreadId, ownerTelegramId: draft.OwnerTelegramId + 1, CancellationToken.None);
+        Assert.Null(loaded);
+    }
+
+    [Fact]
+    public async Task DeleteExpiredAsync_DeletesOnlyExpired()
+    {
+        var connectionString = await fixture.CreateSchemaDatabaseAsync();
+        await using var dataSource = NpgsqlDataSource.Create(connectionString);
+        var sut = new WizardDraftRepository(dataSource);
+
+        var fresh = NewDraft("Type", DateTimeOffset.UtcNow.AddHours(1));
+        var stale = NewDraft("Type", DateTimeOffset.UtcNow.AddMinutes(-1));
+        stale.Id = Guid.NewGuid();
+        await sut.UpsertAsync(fresh, CancellationToken.None);
+        await sut.UpsertAsync(stale, CancellationToken.None);
+
+        var deleted = await sut.DeleteExpiredAsync(CancellationToken.None);
+        Assert.Equal(1, deleted);
+
+        var loadedFresh = await sut.GetActiveAsync(fresh.ChatId, fresh.MessageThreadId, fresh.OwnerTelegramId, CancellationToken.None);
+        Assert.NotNull(loadedFresh);
+    }
+
+    private static WizardDraft NewDraft(string step, DateTimeOffset expiresAt) => new()
+    {
+        Id = Guid.NewGuid(),
+        ChatId = 42,
+        MessageThreadId = null,
+        OwnerTelegramId = 100,
+        Step = step,
+        PayloadJson = "{}",
+        CreatedAt = DateTimeOffset.UtcNow,
+        UpdatedAt = DateTimeOffset.UtcNow,
+        ExpiresAt = expiresAt,
+    };
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/WizardStepRenderTests.cs

@@ -0,0 +1,260 @@
+using System;
+using System.Linq;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Verifies the shape of each step's rendered keyboard: which buttons are
+/// present, where the Back/Cancel affordances sit, and that the title text
+/// is non-empty. Tests use substring matching so they survive label tweaks
+/// (e.g. emoji prefixes, suffix additions like "· 4 ч").
+/// </summary>
+public sealed class WizardStepRenderTests
+{
+    [Fact]
+    public void TypeStep_HasBothChoicesAndCancel_ButNoBack()
+    {
+        var (text, kb) = Render(WizardStepNames.Type);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Одну игру", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Пул игр", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Отмена", StringComparison.Ordinal));
+        Assert.DoesNotContain(labels, l => l.Contains("Назад", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void TitleStep_HasBackAndCancel_ButNoChoiceButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.Title);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Назад", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Отмена", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void SystemStep_HasKnownSystemButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.System);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("D&D 5e", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Pathfinder 2e", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Call of Cthulhu", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("GURPS", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Fate", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Другое", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Пропустить", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void DurationStep_HasPresetButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.Duration);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains("3 часа", labels);
+        Assert.Contains("4 часа", labels);
+        Assert.Contains("5 часов", labels);
+        Assert.Contains("6 часов", labels);
+    }
+
+    [Fact]
+    public void CapacityStep_HasWaitlistButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.Capacity);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Waitlist вкл", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Без waitlist", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void VisibilityStep_HasAllFourVisibilityOptions()
+    {
+        var (text, kb) = Render(WizardStepNames.Visibility);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Публичная в общем showcase", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Публичная в витрине клуба", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Только для членов клуба", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Выбрать клуб", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PickClub_WithoutClubs_RendersEmptyHint()
+    {
+        var (text, kb) = WizardStep.Render(
+            NewDraft(WizardStepNames.PickClub),
+            new WizardPayload(),
+            clubs: null);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        Assert.Contains("нет клубов", text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void PickClub_WithOneClub_RendersClubButton()
+    {
+        var clubId = Guid.NewGuid();
+        var (text, kb) = WizardStep.Render(
+            NewDraft(WizardStepNames.PickClub),
+            new WizardPayload(),
+            new[] { new WizardClubOption(clubId, "Awesome Club") });
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        Assert.Contains("Awesome Club", ButtonLabels(kb));
+    }
+
+    [Fact]
+    public void PublishStep_HasPublishAndChatOnlyButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.Publish);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Опубликовать", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Только в чате", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void ConfirmStep_HasCreateAndCancel()
+    {
+        var (text, kb) = Render(WizardStepNames.Confirm, new WizardPayload
+        {
+            Type = WizardCreationType.Single,
+            Title = "My Game",
+        });
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        Assert.Contains("My Game", text);
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Создать", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Отмена", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PoolSystemDuration_HasPresetsAndCustom()
+    {
+        var (text, kb) = Render(WizardStepNames.PoolSystemDuration);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("D&D 5e", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Pathfinder 2e", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Call of Cthulhu", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("GURPS", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Другое", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PoolAddSlots_HasAddAndDone_AndShowsCurrentCount()
+    {
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Pool,
+            Title = "My Pool",
+            Pool = new WizardPoolInput
+            {
+                Slots =
+                {
+                    new WizardSlotInput { MaxPlayers = 4 },
+                    new WizardSlotInput { MaxPlayers = 5 },
+                },
+            },
+        };
+        var (text, kb) = WizardStep.Render(
+            NewDraft(WizardStepNames.PoolAddSlots),
+            payload);
+
+        Assert.Contains("My Pool", text);
+        Assert.Contains("2", text);
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Добавить слот", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Готово", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PoolSlotDateTime_HasBackAndCancel_ButNoChoiceButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.PoolSlotDateTime);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Назад", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Отмена", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PoolSlotCapacity_HasWaitlistButtons()
+    {
+        var (text, kb) = Render(WizardStepNames.PoolSlotCapacity);
+
+        Assert.False(string.IsNullOrWhiteSpace(text));
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Waitlist вкл", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Без waitlist", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void PoolConfirm_HasCreatePoolAndCancel()
+    {
+        var payload = new WizardPayload
+        {
+            Type = WizardCreationType.Pool,
+            Title = "Pool",
+            System = "Dnd5e",
+            DurationMinutes = 240,
+            Pool = new WizardPoolInput
+            {
+                Slots =
+                {
+                    new WizardSlotInput { MaxPlayers = 4, Waitlist = true,  ScheduledAt = DateTimeOffset.UtcNow.AddDays(7) },
+                    new WizardSlotInput { MaxPlayers = 5, Waitlist = false, ScheduledAt = DateTimeOffset.UtcNow.AddDays(14) },
+                },
+            },
+        };
+        var (text, kb) = WizardStep.Render(
+            NewDraft(WizardStepNames.PoolConfirm),
+            payload);
+
+        Assert.Contains("Pool", text);
+        Assert.Contains("2", text); // slot count
+        var labels = ButtonLabels(kb);
+        Assert.Contains(labels, l => l.Contains("Создать пул", StringComparison.Ordinal));
+        Assert.Contains(labels, l => l.Contains("Отмена", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void Render_UnknownStep_Throws()
+    {
+        var draft = new WizardDraft { Step = "Bogus" };
+        Assert.Throws<InvalidOperationException>(() => WizardStep.Render(draft, new WizardPayload()));
+    }
+
+    private static (string text, InlineKeyboardMarkup kb) Render(string step, WizardPayload? payload = null)
+        => WizardStep.Render(NewDraft(step), payload ?? new WizardPayload());
+
+    private static WizardDraft NewDraft(string step) => new()
+    {
+        Id = Guid.NewGuid(),
+        ChatId = 42,
+        Step = step,
+        PayloadJson = "{}",
+    };
+
+    private static string[] ButtonLabels(InlineKeyboardMarkup kb) =>
+        kb.InlineKeyboard
+            .SelectMany(row => row.Select(b => b.Text))
+            .ToArray();
+}

tests/GmRelay.Bot.Tests/Features/Sessions/CreateSession/Wizard/WizardTestFakes.cs

@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using GmRelay.Bot.Features.Sessions.CreateSession.Wizard;
+using GmRelay.Shared.Features.Sessions.CreateSession.Wizard;
+using Microsoft.Extensions.Logging.Abstractions;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.ReplyMarkups;
+using WizardBot = GmRelay.Bot.Features.Sessions.CreateSession.Wizard.GameCreationWizard;
+using WizardMessenger = GmRelay.Bot.Features.Sessions.CreateSession.Wizard.ITelegramWizardMessenger;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession.Wizard;
+
+/// <summary>
+/// Hand-rolled test doubles and helpers for wizard unit tests. The project
+/// convention is to use fakes (not a mocking framework) so the suite stays
+/// AOT-friendly and the production code doesn't grow virtual members just
+/// for tests.
+/// </summary>
+internal static class WizardTestFakes
+{
+    public static WizardBot BuildWizard(out FakeWizardDraftRepository drafts, out FakeWizardMessenger messenger)
+    {
+        drafts = new FakeWizardDraftRepository();
+        messenger = new FakeWizardMessenger();
+        return new WizardBot(drafts, messenger, NullLogger<WizardBot>.Instance);
+    }
+
+    public static WizardDraft NewDraft(string step, WizardPayload? payload = null, long ownerId = 100) => new()
+    {
+        Id = Guid.NewGuid(),
+        ChatId = 42,
+        MessageThreadId = null,
+        OwnerTelegramId = ownerId,
+        Step = step,
+        DraftMessageId = 7,
+        PayloadJson = System.Text.Json.JsonSerializer.Serialize(
+            payload ?? new WizardPayload(),
+            WizardPayloadJsonContext.Default.WizardPayload),
+        CreatedAt = DateTimeOffset.UtcNow,
+        UpdatedAt = DateTimeOffset.UtcNow,
+        ExpiresAt = DateTimeOffset.UtcNow.AddHours(24),
+    };
+
+    public static Update CallbackUpdate(string data, long ownerId = 100) => new()
+    {
+        CallbackQuery = new CallbackQuery
+        {
+            Id = "cb-1",
+            Data = data,
+            From = new User { Id = ownerId, FirstName = "GM" },
+            Message = new Message
+            {
+                Chat = new Chat { Id = 42 },
+            },
+        },
+    };
+
+    public static Update TextUpdate(string text, long ownerId = 100) => new()
+    {
+        Message = new Message
+        {
+            Text = text,
+            Chat = new Chat { Id = 42 },
+            From = new User { Id = ownerId, FirstName = "GM" },
+        },
+    };
+}
+
+/// <summary>
+/// Records every call the wizard makes against the draft repository. Backed by
+/// an in-memory dictionary so tests can pre-seed an "active" draft for the
+/// wizard to mutate.
+/// </summary>
+internal sealed class FakeWizardDraftRepository : IWizardDraftRepository
+{
+    private readonly Dictionary<Guid, WizardDraft> store = new();
+
+    public List<Guid> DeletedIds { get; } = new();
+
+    public List<WizardDraft> Upserts { get; } = new();
+
+    public int ExpiredDeleted { get; set; }
+
+    public void Seed(WizardDraft draft) => store[draft.Id] = draft;
+
+    public Task<WizardDraft?> GetActiveAsync(long chatId, int? messageThreadId, long ownerTelegramId, CancellationToken ct)
+    {
+        foreach (var d in store.Values)
+        {
+            if (d.ChatId == chatId &&
+                d.MessageThreadId == messageThreadId &&
+                d.OwnerTelegramId == ownerTelegramId &&
+                d.ExpiresAt > DateTimeOffset.UtcNow)
+            {
+                return Task.FromResult<WizardDraft?>(d);
+            }
+        }
+        return Task.FromResult<WizardDraft?>(null);
+    }
+
+    public Task UpsertAsync(WizardDraft draft, CancellationToken ct)
+    {
+        // Clone so tests can compare state without aliasing.
+        Upserts.Add(new WizardDraft
+        {
+            Id = draft.Id,
+            ChatId = draft.ChatId,
+            MessageThreadId = draft.MessageThreadId,
+            OwnerTelegramId = draft.OwnerTelegramId,
+            Step = draft.Step,
+            PayloadJson = draft.PayloadJson,
+            DraftMessageId = draft.DraftMessageId,
+            CreatedAt = draft.CreatedAt,
+            UpdatedAt = draft.UpdatedAt,
+            ExpiresAt = draft.ExpiresAt,
+        });
+        store[draft.Id] = draft;
+        return Task.CompletedTask;
+    }
+
+    public Task DeleteAsync(Guid id, CancellationToken ct)
+    {
+        DeletedIds.Add(id);
+        store.Remove(id);
+        return Task.CompletedTask;
+    }
+
+    public Task<int> DeleteExpiredAsync(CancellationToken ct)
+    {
+        var count = ExpiredDeleted;
+        ExpiredDeleted = 0;
+        return Task.FromResult(count);
+    }
+}
+
+/// <summary>
+/// Records every call the wizard makes against the messenger. Default return
+/// values (empty clubs, message-id 1) match what the wizard expects to see
+/// in steady state.
+/// </summary>
+internal sealed class FakeWizardMessenger : ITelegramWizardMessenger
+{
+    public List<(long ChatId, int? ThreadId, long MsgId, string Text)> Edits { get; } = new();
+
+    public List<string> AnsweredCallbacks { get; } = new();
+
+    public List<(long ChatId, int? ThreadId, string Text)> Sends { get; } = new();
+
+    public IReadOnlyList<WizardClubOption> Clubs { get; set; } = Array.Empty<WizardClubOption>();
+
+    public Task<long> EditMessageTextAsync(
+        long chatId,
+        int? messageThreadId,
+        long messageId,
+        string text,
+        InlineKeyboardMarkup keyboard,
+        CancellationToken ct)
+    {
+        Edits.Add((chatId, messageThreadId, messageId, text));
+        return Task.FromResult(messageId);
+    }
+
+    public Task<long> SendGroupMessageAsync(
+        long chatId,
+        int? messageThreadId,
+        string text,
+        InlineKeyboardMarkup keyboard,
+        CancellationToken ct)
+    {
+        Sends.Add((chatId, messageThreadId, text));
+        return Task.FromResult(99L);
+    }
+
+    public Task AnswerCallbackAsync(string callbackId, string? text, CancellationToken ct)
+    {
+        AnsweredCallbacks.Add(callbackId);
+        return Task.CompletedTask;
+    }
+
+    public Task<IReadOnlyList<WizardClubOption>> GetGmClubsAsync(long ownerTelegramId, CancellationToken ct)
+        => Task.FromResult(Clubs);
+}

tests/GmRelay.Bot.Tests/GmRelay.Bot.Tests.csproj

@@ -15,6 +15,7 @@
     <PackageReference Include="coverlet.collector" Version="6.0.4" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.5" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
     <PackageReference Include="Testcontainers.PostgreSql" Version="4.12.0" />
     <PackageReference Include="xunit" Version="2.9.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />

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

@@ -8,12 +8,18 @@ public sealed class TelegramTopicIntegrationSmokeTests
         var migration = await ReadRepositoryFileAsync("src/GmRelay.Bot/Migrations/V015__add_topic_ownership.sql");
         var createHandler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/CreateSession/CreateSessionHandler.cs");
         var deleteHandler = await ReadRepositoryFileAsync("src/GmRelay.Bot/Features/Sessions/ListSessions/DeleteSessionHandler.cs");
+        var topicRouting = await ReadRepositoryFileAsync("src/GmRelay.Bot/Infrastructure/Telegram/TelegramTopicRouting.cs");
 
         Assert.Contains("topic_created_by_bot", migration, StringComparison.Ordinal);
-        Assert.Contains("ResolveNewScheduleDestination", createHandler, StringComparison.Ordinal);
-        Assert.Contains("message.MessageThreadId", createHandler, StringComparison.Ordinal);
-        Assert.Contains("topicCreatedByBot", createHandler, StringComparison.Ordinal);
-        Assert.Contains("MissingForumTopicRightsMessage", createHandler, StringComparison.Ordinal);
+
+        // The wizard-driven CreateSessionHandler threads the existing forum topic
+        // (if any) into the draft; the shared creation command inherits it. Topic
+        // auto-creation and rights handling live in TelegramTopicRouting.
+        Assert.Contains("MessageThreadId", createHandler, StringComparison.Ordinal);
+        Assert.Contains("ExternalThreadId", createHandler, StringComparison.Ordinal);
+        Assert.Contains("ResolveNewScheduleDestination", topicRouting, StringComparison.Ordinal);
+        Assert.Contains("MissingForumTopicRightsMessage", topicRouting, StringComparison.Ordinal);
+
         Assert.Contains("TopicCreatedByBot", deleteHandler, StringComparison.Ordinal);
         Assert.Contains("ShouldDeleteForumTopic", deleteHandler, StringComparison.Ordinal);
         Assert.Contains("RemainingInTopic", deleteHandler, StringComparison.Ordinal);

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

@@ -15,7 +15,7 @@ public sealed class CampaignTemplatesNavigationTests
     public async Task NavMenu_ShouldExposeCurrentProjectVersion()
     {
         var navMenu = await File.ReadAllTextAsync(FindRepositoryFile("src/GmRelay.Web/Components/Layout/NavMenu.razor"));
-        Assert.Contains("v3.7.0", navMenu, StringComparison.Ordinal);
+        Assert.Contains("v3.7.1", navMenu, StringComparison.Ordinal);
     }
 
     [Fact]

tests/GmRelay.Bot.Tests/packages.lock.json

@@ -28,6 +28,15 @@
           "Microsoft.TestPlatform.TestHost": "17.14.1"
         }
       },
+      "NSubstitute": {
+        "type": "Direct",
+        "requested": "[5.3.0, )",
+        "resolved": "5.3.0",
+        "contentHash": "lJ47Cps5Qzr86N99lcwd+OUvQma7+fBgr8+Mn+aOC0WrlqMNkdivaYD9IvnZ5Mqo6Ky3LS7ZI+tUq1/s9ERd0Q==",
+        "dependencies": {
+          "Castle.Core": "5.1.1"
+        }
+      },
       "SecurityCodeScan.VS2019": {
         "type": "Direct",
         "requested": "[5.6.7, )",
@@ -84,6 +93,11 @@
         "resolved": "2.6.2",
         "contentHash": "7oWOcvnntmMKNzDLsdxAYqApt+AjpRpP2CShjMfIa3umZ42UQMvH0tl1qAliYPNYO6vTdcGMqnRrCPmsfzTI1w=="
       },
+      "Castle.Core": {
+        "type": "Transitive",
+        "resolved": "5.1.1",
+        "contentHash": "rpYtIczkzGpf+EkZgDr9CClTdemhsrwA/W5hMoPjLkRFnXzH44zDLoovXeKtmxb1ykXK9aJVODSpiJml8CTw2g=="
+      },
       "Dapper": {
         "type": "Transitive",
         "resolved": "2.1.72",
@@ -487,8 +501,8 @@
           "Aspire.Npgsql": "[13.2.2, )",
           "Dapper": "[2.1.72, )",
           "Dapper.AOT": "[1.0.48, )",
-          "GmRelay.ServiceDefaults": "[3.5.1, )",
-          "GmRelay.Shared": "[3.5.1, )",
+          "GmRelay.ServiceDefaults": "[3.7.1, )",
+          "GmRelay.Shared": "[3.7.1, )",
           "Npgsql": "[10.0.2, )",
           "Telegram.Bot": "[22.9.5.3, )",
           "dbup-postgresql": "[7.0.1, )"
@@ -500,8 +514,8 @@
           "Aspire.Npgsql": "[13.2.2, )",
           "Dapper": "[2.1.72, )",
           "Dapper.AOT": "[1.0.48, )",
-          "GmRelay.ServiceDefaults": "[3.5.1, )",
-          "GmRelay.Shared": "[3.5.1, )",
+          "GmRelay.ServiceDefaults": "[3.7.1, )",
+          "GmRelay.Shared": "[3.7.1, )",
           "NetCord.Hosting": "[1.0.0-alpha.489, )",
           "NetCord.Hosting.Services": "[1.0.0-alpha.489, )",
           "NetCord.Services": "[1.0.0-alpha.489, )",
@@ -532,8 +546,8 @@
         "dependencies": {
           "Aspire.Npgsql": "[13.2.2, )",
           "Dapper": "[2.1.72, )",
-          "GmRelay.ServiceDefaults": "[3.5.1, )",
-          "GmRelay.Shared": "[3.5.1, )",
+          "GmRelay.ServiceDefaults": "[3.7.1, )",
+          "GmRelay.Shared": "[3.7.1, )",
           "Npgsql": "[10.0.2, )",
           "Telegram.Bot": "[22.9.6.1, )"
         }