fix(discord): offload workspace heal + connection start off the Ready chain

Live verification showed these two handlers, not command registration, were what kept the gateway's Ready-blocking warning firing.

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

Author: HandyS11

src/RustPlusBot.Features.Pairing/Hosting/PairingHostedService.cs

@@ -30,17 +30,28 @@ public async Task StopAsync(CancellationToken cancellationToken)
         await supervisor.StopAllAsync().ConfigureAwait(false);
     }
 
-    private async Task OnReadyAsync()
+    private Task OnReadyAsync()
     {
         // Ready fires on every (re)connect; only start listeners once per process. Ready is dispatched
         // serially on the gateway thread, so the plain bool guard needs no synchronization (same pattern
-        // as DiscordBotService and WorkspaceHostedService).
+        // as DiscordBotService and WorkspaceHostedService) — set the flag before offloading so a
+        // re-fired Ready can't double-start.
         if (_started)
         {
-            return;
+            return Task.CompletedTask;
         }
 
         _started = true;
+
+        // Starting listeners connects to every active Rust server; doing it inline blocks the gateway
+        // task and stalls event dispatch, so offload it. Failures must be caught here — nothing awaits
+        // this.
+        _ = Task.Run(StartListenersAsync);
+        return Task.CompletedTask;
+    }
+
+    private async Task StartListenersAsync()
+    {
         try
         {
             await supervisor.StartAllActiveAsync().ConfigureAwait(false);

src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs

@@ -68,24 +68,44 @@ public async Task StopAsync(CancellationToken cancellationToken)
         }
     }
 
-    private async Task OnReadyAsync()
+    private Task OnReadyAsync()
     {
+        // Ready fires on every gateway (re)connect; only heal once per process. Ready is dispatched
+        // serially on the gateway thread, so no synchronization is needed — set the flag before
+        // offloading so a re-fired Ready can't double-run.
         if (_startupDone)
         {
-            return;
+            return Task.CompletedTask;
         }
 
         _startupDone = true;
-        var scope = scopeFactory.CreateAsyncScope();
-        await using (scope.ConfigureAwait(false))
+
+        // Healing sweeps every provisioned guild's channels over REST; doing it inline blocks the
+        // gateway task and stalls event dispatch, so offload it. Failures must be caught here —
+        // nothing awaits this.
+        _ = Task.Run(HealProvisionedGuildsAsync);
+        return Task.CompletedTask;
+    }
+
+    private async Task HealProvisionedGuildsAsync()
+    {
+        try
         {
-            var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
-            var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-            foreach (var guildId in await store.GetProvisionedGuildIdsAsync().ConfigureAwait(false))
+            var scope = scopeFactory.CreateAsyncScope();
+            await using (scope.ConfigureAwait(false))
             {
-                await reconciler.HealGuildAsync(guildId).ConfigureAwait(false);
+                var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
+                var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
+                foreach (var guildId in await store.GetProvisionedGuildIdsAsync().ConfigureAwait(false))
+                {
+                    await reconciler.HealGuildAsync(guildId).ConfigureAwait(false);
+                }
             }
         }
+        catch (Exception ex) // Broad catch is intentional: a faulting startup heal must not crash the host.
+        {
+            logger.LogError(ex, "Startup self-heal failed.");
+        }
     }
 
     private async Task OnChannelDestroyedAsync(SocketChannel channel)