feat(#20): довести RSVP и напоминания до полного набора событий

- Добавлена абстракция ISystemClock + SystemClock / FakeSystemClock
  для тестируемого scheduling.
- Добавлена миграция V014: confirmation_sent_at в sessions.
- Обновлен SendConfirmationHandler: записывает confirmation_sent_at.
- Обновлен SessionSchedulerService:
  - выделен ISessionTriggerStore / DbSessionTriggerStore
  - SQL-запросы используют параметр @Now вместо now()
  - добавлен публичный TickAsync для тестов
  - защита от дублей через confirmation_sent_at IS NULL
- Обновлен RescheduleVotingDeadlineService: использует ISystemClock.
- Добавлены интерфейсы ISendConfirmationHandler, ISendOneHourReminderHandler,
  ISendJoinLinkHandler для unit-тестируемости.
- Добавлены 8 unit-тестов SessionSchedulerService:
  - все 3 триггера (T-24h, T-1h, T-5min)
  - идемпотентность при повторном запуске
  - ошибки handler не падают и не блокируют другие сессии
  - ошибки store логируются без падения worker-а

Bump version -> 1.13.0

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

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

@@ -0,0 +1,86 @@
+using Dapper;
+using GmRelay.Shared.Domain;
+using Npgsql;
+
+namespace GmRelay.Bot.Infrastructure.Scheduling;
+
+public interface ISessionTriggerStore
+{
+    Task<IReadOnlyList<Guid>> GetSessionsNeedingConfirmationAsync(DateTimeOffset now, CancellationToken ct);
+    Task<IReadOnlyList<Guid>> GetSessionsNeedingOneHourReminderAsync(DateTimeOffset now, CancellationToken ct);
+    Task<IReadOnlyList<Guid>> GetSessionsNeedingJoinLinkAsync(DateTimeOffset now, CancellationToken ct);
+}
+
+public sealed class DbSessionTriggerStore(NpgsqlDataSource dataSource) : ISessionTriggerStore
+{
+    private static readonly TimeSpan ConfirmationLeadTime = TimeSpan.FromHours(24);
+    private static readonly TimeSpan OneHourReminderLeadTime = TimeSpan.FromHours(1);
+    private static readonly TimeSpan JoinLinkLeadTime = TimeSpan.FromMinutes(5);
+
+    public async Task<IReadOnlyList<Guid>> GetSessionsNeedingConfirmationAsync(DateTimeOffset now, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var results = await connection.QueryAsync<Guid>(
+            """
+            SELECT id
+            FROM sessions
+            WHERE status = @Planned
+              AND scheduled_at - @LeadTime <= @Now
+              AND confirmation_sent_at IS NULL
+            """,
+            new
+            {
+                Planned = SessionStatus.Planned,
+                LeadTime = ConfirmationLeadTime,
+                Now = now.UtcDateTime
+            });
+
+        return results.ToList();
+    }
+
+    public async Task<IReadOnlyList<Guid>> GetSessionsNeedingOneHourReminderAsync(DateTimeOffset now, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var results = await connection.QueryAsync<Guid>(
+            """
+            SELECT id
+            FROM sessions
+            WHERE status IN (@Confirmed, @ConfirmationSent)
+              AND scheduled_at - @LeadTime <= @Now
+              AND one_hour_reminder_processed_at IS NULL
+            """,
+            new
+            {
+                Confirmed = SessionStatus.Confirmed,
+                ConfirmationSent = SessionStatus.ConfirmationSent,
+                LeadTime = OneHourReminderLeadTime,
+                Now = now.UtcDateTime
+            });
+
+        return results.ToList();
+    }
+
+    public async Task<IReadOnlyList<Guid>> GetSessionsNeedingJoinLinkAsync(DateTimeOffset now, CancellationToken ct)
+    {
+        await using var connection = await dataSource.OpenConnectionAsync(ct);
+
+        var results = await connection.QueryAsync<Guid>(
+            """
+            SELECT id
+            FROM sessions
+            WHERE status = @Confirmed
+              AND scheduled_at - @LeadTime <= @Now
+              AND link_message_id IS NULL
+            """,
+            new
+            {
+                Confirmed = SessionStatus.Confirmed,
+                LeadTime = JoinLinkLeadTime,
+                Now = now.UtcDateTime
+            });
+
+        return results.ToList();
+    }
+}

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

@@ -0,0 +1,16 @@
+namespace GmRelay.Bot.Infrastructure.Scheduling;
+
+public interface ISystemClock
+{
+    DateTimeOffset UtcNow { get; }
+}
+
+public sealed class SystemClock : ISystemClock
+{
+    public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;
+}
+
+public sealed class FakeSystemClock : ISystemClock
+{
+    public DateTimeOffset UtcNow { get; set; } = DateTimeOffset.UtcNow;
+}

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

@@ -1,31 +1,27 @@
-using Dapper;
-using GmRelay.Shared.Domain;
 using GmRelay.Bot.Features.Confirmation.SendConfirmation;
 using GmRelay.Bot.Features.Reminders.SendJoinLink;
 using GmRelay.Bot.Features.Reminders.SendOneHourReminder;
-using Npgsql;
 
 namespace GmRelay.Bot.Infrastructure.Scheduling;
 
 /// <summary>
 /// Stateless scheduler: wakes every 60 seconds, queries PostgreSQL for actionable sessions.
-/// Two triggers:
+/// Three triggers:
 ///   T-24h: send confirmation request with inline keyboard
+///   T-1h:  send one-hour direct reminder
 ///   T-5min: send join link to all confirmed players
 ///
 /// If the Raspberry Pi reboots, nothing is lost — all state is in the DB.
 /// </summary>
 public sealed class SessionSchedulerService(
-    NpgsqlDataSource dataSource,
-    SendConfirmationHandler confirmationHandler,
-    SendOneHourReminderHandler oneHourReminderHandler,
-    SendJoinLinkHandler joinLinkHandler,
+    ISessionTriggerStore triggerStore,
+    ISendConfirmationHandler confirmationHandler,
+    ISendOneHourReminderHandler oneHourReminderHandler,
+    ISendJoinLinkHandler joinLinkHandler,
+    ISystemClock clock,
     ILogger<SessionSchedulerService> logger) : BackgroundService
 {
     private static readonly TimeSpan TickInterval = TimeSpan.FromMinutes(1);
-    private static readonly TimeSpan ConfirmationLeadTime = TimeSpan.FromHours(24);
-    private static readonly TimeSpan OneHourReminderLeadTime = TimeSpan.FromHours(1);
-    private static readonly TimeSpan JoinLinkLeadTime = TimeSpan.FromMinutes(5);
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
@@ -33,14 +29,11 @@ public sealed class SessionSchedulerService(
 
         using var timer = new PeriodicTimer(TickInterval);
 
-        // Run immediately on startup, then on each tick
         do
         {
             try
             {
-                await ProcessConfirmationTriggers(stoppingToken);
-                await ProcessOneHourReminderTriggers(stoppingToken);
-                await ProcessJoinLinkTriggers(stoppingToken);
+                await TickAsync(stoppingToken);
             }
             catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
             {
@@ -57,57 +50,30 @@ public sealed class SessionSchedulerService(
     }
 
     /// <summary>
-    /// T-1h trigger: process direct reminders according to the session notification mode.
+    /// Runs a single scheduler tick using the current clock time.
+    /// Public so it can be called from integration tests with a fake clock.
     /// </summary>
-    private async Task ProcessOneHourReminderTriggers(CancellationToken ct)
+    public async Task TickAsync(CancellationToken ct)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        var now = clock.UtcNow;
 
-        var sessionIds = await connection.QueryAsync<Guid>(
-            """
-            SELECT id
-            FROM sessions
-            WHERE status IN (@Confirmed, @ConfirmationSent)
-              AND scheduled_at - @LeadTime <= now()
-              AND one_hour_reminder_processed_at IS NULL
-            """,
-            new
-            {
-                Confirmed = SessionStatus.Confirmed,
-                ConfirmationSent = SessionStatus.ConfirmationSent,
-                LeadTime = OneHourReminderLeadTime
-            });
-
-        foreach (var sessionId in sessionIds)
-        {
-            try
-            {
-                await oneHourReminderHandler.HandleAsync(sessionId, ct);
-                logger.LogInformation("One-hour reminder processed for session {SessionId}", sessionId);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "Failed to process one-hour reminder for session {SessionId}", sessionId);
-            }
-        }
+        await ProcessConfirmationTriggers(now, ct);
+        await ProcessOneHourReminderTriggers(now, ct);
+        await ProcessJoinLinkTriggers(now, ct);
     }
 
-    /// <summary>
-    /// T-24h trigger: find sessions that need confirmation requests sent.
-    /// Condition: status='Planned' AND scheduled_at minus 24h is in the past.
-    /// </summary>
-    private async Task ProcessConfirmationTriggers(CancellationToken ct)
+    private async Task ProcessConfirmationTriggers(DateTimeOffset now, CancellationToken ct)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
-
-        var sessionIds = await connection.QueryAsync<Guid>(
-            """
-            SELECT id
-            FROM sessions
-            WHERE status = @Planned
-              AND scheduled_at - @LeadTime <= now()
-            """,
-            new { Planned = SessionStatus.Planned, LeadTime = ConfirmationLeadTime });
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingConfirmationAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query confirmation triggers");
+            return;
+        }
 
         foreach (var sessionId in sessionIds)
         {
@@ -123,23 +89,45 @@ public sealed class SessionSchedulerService(
         }
     }
 
-    /// <summary>
-    /// T-5min trigger: find confirmed sessions that need join links sent.
-    /// Condition: status='Confirmed' AND scheduled_at minus 5min is in the past AND link not yet sent.
-    /// </summary>
-    private async Task ProcessJoinLinkTriggers(CancellationToken ct)
+    private async Task ProcessOneHourReminderTriggers(DateTimeOffset now, CancellationToken ct)
     {
-        await using var connection = await dataSource.OpenConnectionAsync(ct);
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingOneHourReminderAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query one-hour reminder triggers");
+            return;
+        }
 
-        var sessionIds = await connection.QueryAsync<Guid>(
-            """
-            SELECT id
-            FROM sessions
-            WHERE status = @Confirmed
-              AND scheduled_at - @LeadTime <= now()
-              AND link_message_id IS NULL
-            """,
-            new { Confirmed = SessionStatus.Confirmed, LeadTime = JoinLinkLeadTime });
+        foreach (var sessionId in sessionIds)
+        {
+            try
+            {
+                await oneHourReminderHandler.HandleAsync(sessionId, ct);
+                logger.LogInformation("One-hour reminder processed for session {SessionId}", sessionId);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to process one-hour reminder for session {SessionId}", sessionId);
+            }
+        }
+    }
+
+    private async Task ProcessJoinLinkTriggers(DateTimeOffset now, CancellationToken ct)
+    {
+        IReadOnlyList<Guid> sessionIds;
+        try
+        {
+            sessionIds = await triggerStore.GetSessionsNeedingJoinLinkAsync(now, ct);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to query join-link triggers");
+            return;
+        }
 
         foreach (var sessionId in sessionIds)
         {