feat(connections): carry IsConnected/WasConnected on ConnectionStatusChangedEvent

WasConnected is computed from in-process published history, not the
persisted store (which would still say Connected right after boot).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Abstractions/Events/ConnectionStatusChangedEvent.cs

@@ -3,4 +3,14 @@ namespace RustPlusBot.Abstractions.Events;
 /// <summary>Published when a server's live-connection state changes, so #info can re-render.</summary>
 /// <param name="GuildId">The owning guild snowflake.</param>
 /// <param name="ServerId">The server whose connection state changed.</param>
-public sealed record ConnectionStatusChangedEvent(ulong GuildId, Guid ServerId);
+/// <param name="IsConnected">True when the new status is Connected.</param>
+/// <param name="WasConnected">
+///     True when the previous status published in this process was Connected. Deliberately
+///     in-process (not store-derived): the persisted status survives restarts and would still
+///     read Connected right after boot, re-triggering unreachable sweeps on every startup.
+/// </param>
+public sealed record ConnectionStatusChangedEvent(
+    ulong GuildId,
+    Guid ServerId,
+    bool IsConnected,
+    bool WasConnected);

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -46,6 +46,10 @@ internal sealed partial class ConnectionSupervisor(
     private readonly SemaphoreSlim _gate = new(1, 1);
     private readonly ConcurrentDictionary<(ulong Guild, Guid Server), LiveSocket> _liveSockets = new();
     private readonly ConnectionOptions _options = options.Value;
+
+    /// <summary>Last status published per key IN THIS PROCESS — the store's persisted status survives restarts and would falsely report Connected at boot.</summary>
+    private readonly ConcurrentDictionary<(ulong Guild, Guid Server), ConnectionStatus> _publishedStatuses = new();
+
     private readonly CancellationTokenSource _shutdown = new();
     private bool _disposed;
 
@@ -953,7 +957,12 @@ private async Task PublishStatusAsync(
 
         if (changed)
         {
-            await eventBus.PublishAsync(new ConnectionStatusChangedEvent(key.Guild, key.Server), ct)
+            var wasConnected = _publishedStatuses.TryGetValue(key, out var previous)
+                               && previous == ConnectionStatus.Connected;
+            _publishedStatuses[key] = status;
+            await eventBus.PublishAsync(
+                    new ConnectionStatusChangedEvent(key.Guild, key.Server,
+                        status == ConnectionStatus.Connected, wasConnected), ct)
                 .ConfigureAwait(false);
         }
     }

tests/RustPlusBot.Features.Alarms.Tests/AlarmStateRelayTests.cs

@@ -380,7 +380,8 @@ public async Task ConnectionStatus_not_connected_refreshes_all_alarms_unreachabl
             ]);
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+            new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: false, WasConnected: true),
+            CancellationToken.None);
 
         await h.Refresher.Received(1).RefreshAsync(
             Arg.Is<SmartAlarm>(a => a.EntityId == 42UL), unreachable: true, Arg.Any<CancellationToken>());
@@ -402,7 +403,8 @@ public async Task ConnectionStatus_connected_does_nothing()
             });
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+            new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: true, WasConnected: true),
+            CancellationToken.None);
 
         await h.Refresher.DidNotReceive().RefreshAsync(
             Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());

tests/RustPlusBot.Features.Alarms.Tests/Hosting/AlarmsHostedServiceTests.cs

@@ -197,7 +197,8 @@ public async Task ConnectionStatusChangedEvent_non_connected_routes_to_relay_and
                && !h.Refresher.ReceivedCalls().Any(c =>
                    c.GetMethodInfo().Name == nameof(IAlarmRefresher.RefreshAsync)))
         {
-            await h.Bus.PublishAsync(new ConnectionStatusChangedEvent(10UL, serverId));
+            await h.Bus.PublishAsync(
+                new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: false, WasConnected: true));
             await Task.Delay(20);
         }
 

tests/RustPlusBot.Features.Connections.Tests/ConnectionSupervisorTests.cs

@@ -231,6 +231,72 @@ public async Task Heartbeat_Unreachable_ReconnectsAndRecovers()
         Assert.True(source.CreateCount >= 2);
     }
 
+    /// <summary>
+    /// WasConnected must be computed from in-process state (the DB status survives restarts and
+    /// would claim Connected at boot): statuses before the first Connected carry false; the drop
+    /// after a Connected carries true.
+    /// </summary>
+    [Fact]
+    public async Task StatusEvents_CarryWasConnected_OnlyAfterAConnectedDrop()
+    {
+        var source = new FakeRustSocketSource();
+        source.EnqueueConnect(SocketConnectOutcome.Connected);
+        source.EnqueueHeartbeat(HeartbeatResult.Ok(2)); // first heartbeat -> Connected
+        source.EnqueueHeartbeat(HeartbeatResult.Unreachable); // next heartbeat -> drop
+        source.EnqueueConnect(SocketConnectOutcome.Connected); // reconnect
+        source.EnqueueHeartbeat(HeartbeatResult.Ok(4));
+        await using var h = CreateHarness(source);
+        var (serverId, _, _) = await SeedAsync(h.Provider);
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        var events = new List<ConnectionStatusChangedEvent>();
+        _ = Task.Run(async () =>
+        {
+            await foreach (var e in h.Bus.SubscribeAsync<ConnectionStatusChangedEvent>(cts.Token))
+            {
+                lock (events)
+                {
+                    events.Add(e);
+                }
+            }
+        }, cts.Token);
+
+        await h.Supervisor.EnsureConnectionAsync(10UL, serverId);
+        var recovered = await WaitForStateAsync(
+            h.Provider, serverId, s => s.Status == ConnectionStatus.Connected && s.PlayerCount == 4);
+        Assert.NotNull(recovered);
+
+        // The bus delivers asynchronously; wait until the collector has seen the drop.
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(10);
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            lock (events)
+            {
+                if (events.Any(e => !e.IsConnected && e.WasConnected))
+                {
+                    break;
+                }
+            }
+
+            await Task.Delay(15);
+        }
+
+        await cts.CancelAsync();
+        ConnectionStatusChangedEvent[] snapshot;
+        lock (events)
+        {
+            snapshot = [.. events];
+        }
+
+        var firstConnected = Array.FindIndex(snapshot, e => e.IsConnected);
+        Assert.True(firstConnected >= 0, "expected a Connected status event");
+        Assert.All(snapshot.Take(firstConnected), e => Assert.False(e.WasConnected));
+        var drop = Array.FindIndex(
+            snapshot, firstConnected, snapshot.Length - firstConnected, e => !e.IsConnected);
+        Assert.True(drop > firstConnected, "expected a drop event after Connected");
+        Assert.True(snapshot[drop].WasConnected);
+    }
+
     [Fact]
     public async Task StartAll_StartsAConnectionPerConnectableServer()
     {

tests/RustPlusBot.Features.StorageMonitors.Tests/Hosting/StorageMonitorsHostedServiceTests.cs

@@ -160,7 +160,8 @@ public async Task ConnectionStatusChangedEvent_non_connected_routes_to_relay_and
                && !h.Poster.ReceivedCalls().Any(c =>
                    c.GetMethodInfo().Name == nameof(IStorageMonitorChannelPoster.EnsureAsync)))
         {
-            await h.Bus.PublishAsync(new ConnectionStatusChangedEvent(Guild, serverId));
+            await h.Bus.PublishAsync(
+                new ConnectionStatusChangedEvent(Guild, serverId, IsConnected: false, WasConnected: true));
             await Task.Delay(20);
         }
 

tests/RustPlusBot.Features.StorageMonitors.Tests/StorageMonitorStateRelayTests.cs

@@ -114,7 +114,8 @@ public async Task HandleConnectionStatusAsync_NotConnected_PostsUnreachable()
             ]);
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(Guild, Server), CancellationToken.None);
+            new ConnectionStatusChangedEvent(Guild, Server, IsConnected: false, WasConnected: true),
+            CancellationToken.None);
 
         await h.Poster.Received(1).EnsureAsync(555UL, Arg.Any<ulong?>(),
             Arg.Any<global::Discord.Embed>(), Arg.Any<global::Discord.MessageComponent>(),
@@ -132,7 +133,8 @@ public async Task HandleConnectionStatusAsync_Connected_DoesNothing()
             });
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(Guild, Server), CancellationToken.None);
+            new ConnectionStatusChangedEvent(Guild, Server, IsConnected: true, WasConnected: true),
+            CancellationToken.None);
 
         await h.Poster.DidNotReceive().EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(),
             Arg.Any<global::Discord.Embed>(), Arg.Any<global::Discord.MessageComponent>(),

tests/RustPlusBot.Features.Switches.Tests/Hosting/SwitchesHostedServiceTests.cs

@@ -152,7 +152,8 @@ public async Task ConnectionStatusChangedEvent_non_connected_routes_to_relay_and
                && !h.Poster.ReceivedCalls().Any(c =>
                    c.GetMethodInfo().Name == nameof(ISwitchChannelPoster.EnsureAsync)))
         {
-            await h.Bus.PublishAsync(new ConnectionStatusChangedEvent(10UL, serverId));
+            await h.Bus.PublishAsync(
+                new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: false, WasConnected: true));
             await Task.Delay(20);
         }
 

tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs

@@ -89,7 +89,8 @@ public async Task ConnectionStatus_not_connected_marks_switches_unreachable()
             ]);
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+            new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: false, WasConnected: true),
+            CancellationToken.None);
 
         await h.Poster.Received(1).EnsureAsync(777UL, 900UL, Arg.Any<global::Discord.Embed>(),
             Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
@@ -107,7 +108,8 @@ public async Task ConnectionStatus_connected_does_nothing()
             });
 
         await h.Relay.HandleConnectionStatusAsync(
-            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+            new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: true, WasConnected: true),
+            CancellationToken.None);
 
         await h.Poster.DidNotReceive().EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(),
             Arg.Any<global::Discord.Embed>(),

tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConnectionStatusTests.cs

@@ -32,7 +32,8 @@ public async Task ConnectionStatusChanged_ReconcilesThatServer()
                && !reconciler.ReceivedCalls().Any(c =>
                    c.GetMethodInfo().Name == nameof(IWorkspaceReconciler.ReconcileServerAsync)))
         {
-            await bus.PublishAsync(new ConnectionStatusChangedEvent(10UL, serverId));
+            await bus.PublishAsync(
+                new ConnectionStatusChangedEvent(10UL, serverId, IsConnected: false, WasConnected: false));
             await Task.Delay(20);
         }