diff --git a/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs b/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
index 27fa751e..3c574816 100644
--- a/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
+++ b/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
@@ -53,11 +53,12 @@ public interface IRustServerQuery
     /// <returns>The world snapshot, or null.</returns>
     Task<WorldSnapshot?> GetWorldAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken);
 
-    /// <summary>Gets the server's monuments, or an empty list when there is no live socket.</summary>
+    /// <summary>Gets the server's monuments, or an empty list when there is no live socket or the fetch
+    /// fails; never throws for a failed fetch.</summary>
     /// <param name="guildId">The owning guild snowflake.</param>
     /// <param name="serverId">The target server id.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
-    /// <returns>The monuments, or an empty list when there is no live socket.</returns>
+    /// <returns>The monuments, or an empty list when there is no live socket or the fetch fails/times out.</returns>
     Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
         ulong guildId,
         Guid serverId,
diff --git a/src/RustPlusBot.Abstractions/Events/EventBusConsumption.cs b/src/RustPlusBot.Abstractions/Events/EventBusConsumption.cs
new file mode 100644
index 00000000..5be073d5
--- /dev/null
+++ b/src/RustPlusBot.Abstractions/Events/EventBusConsumption.cs
@@ -0,0 +1,55 @@
+namespace RustPlusBot.Abstractions.Events;
+
+/// <summary>
+/// Consumption helpers for <see cref="IEventBus"/> subscribers.
+/// </summary>
+/// <remarks>
+/// Every long-running consumer in this solution wraps its <c>await foreach</c> in a broad catch that logs
+/// and then <em>exits</em>: an exception escaping a handler ends the subscription for the rest of the
+/// process, and the feature it drives goes silently dead until the host restarts. Handlers here talk to
+/// Discord and to the Rust+ server, where a timeout or a 5xx is routine rather than exceptional, so that
+/// trade is never the one we want. Consuming through <see cref="ConsumeAsync{TEvent}"/> keeps the
+/// subscription alive: a failed handler costs its own event and nothing more.
+/// </remarks>
+public static class EventBusConsumption
+{
+    /// <summary>
+    /// Consumes every published <typeparamref name="TEvent"/>, reporting and skipping the ones whose
+    /// handler throws. Only cancellation of <paramref name="cancellationToken"/> ends the subscription.
+    /// </summary>
+    /// <typeparam name="TEvent">The event type to consume.</typeparam>
+    /// <param name="eventBus">The bus to subscribe to.</param>
+    /// <param name="handle">Handles one event; its failures are reported, not propagated.</param>
+    /// <param name="onHandlerFailure">Reports a handler failure (typically a log call).</param>
+    /// <param name="cancellationToken">Ends the subscription when cancelled.</param>
+    /// <returns>A task that completes when the subscription ends.</returns>
+    public static async Task ConsumeAsync<TEvent>(
+        this IEventBus eventBus,
+        Func<TEvent, CancellationToken, Task> handle,
+        Action<Exception> onHandlerFailure,
+        CancellationToken cancellationToken)
+        where TEvent : notnull
+    {
+        ArgumentNullException.ThrowIfNull(eventBus);
+        ArgumentNullException.ThrowIfNull(handle);
+        ArgumentNullException.ThrowIfNull(onHandlerFailure);
+
+        await foreach (var evt in eventBus.SubscribeAsync<TEvent>(cancellationToken).ConfigureAwait(false))
+        {
+            try
+            {
+                await handle(evt, cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw; // A real shutdown: let the caller's loop handler end it.
+            }
+#pragma warning disable CA1031 // Broad catch: a handler failure must cost one event, never the subscription.
+            catch (Exception ex)
+#pragma warning restore CA1031
+            {
+                onHandlerFailure(ex);
+            }
+        }
+    }
+}
diff --git a/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs b/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs
index 15fc6629..54d822d1 100644
--- a/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs
+++ b/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs
@@ -68,11 +68,9 @@ private async Task ConsumePairedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<AlarmPairedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await coordinator.HandlePairedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<AlarmPairedEvent>(coordinator.HandlePairedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(AlarmPairedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -90,11 +88,9 @@ private async Task ConsumeTriggeredAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<SmartDeviceTriggeredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleTriggeredAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<SmartDeviceTriggeredEvent>(relay.HandleTriggeredAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(SmartDeviceTriggeredEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -112,11 +108,9 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleConnectionStatusAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(relay.HandleConnectionStatusAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -134,11 +128,9 @@ private async Task ConsumeReachabilityChangedAsync(CancellationToken cancellatio
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<DeviceReachabilityChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleReachabilityChangedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<DeviceReachabilityChangedEvent>(relay.HandleReachabilityChangedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(DeviceReachabilityChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -156,11 +148,9 @@ private async Task ConsumeStateObservedAsync(CancellationToken cancellationToken
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<SmartDeviceStateObservedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleStateObservedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<SmartDeviceStateObservedEvent>(relay.HandleStateObservedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(SmartDeviceStateObservedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -178,11 +168,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ServerWipedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await purger.HandleServerWipedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerWipedEvent>(purger.HandleServerWipedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerWipedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -196,6 +184,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Alarm pairing loop faulted.")]
     private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Chat/Hosting/ChatHostedService.cs b/src/RustPlusBot.Features.Chat/Hosting/ChatHostedService.cs
index 04ad9969..b2c150f0 100644
--- a/src/RustPlusBot.Features.Chat/Hosting/ChatHostedService.cs
+++ b/src/RustPlusBot.Features.Chat/Hosting/ChatHostedService.cs
@@ -76,13 +76,12 @@ private async Task ConsumeTeamMessagesAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<TeamMessageReceivedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.RelayAsync(
-                    new RelayedChatLine(ChatChannelKind.Team, evt.GuildId, evt.ServerId, evt.SenderName,
-                        evt.Message, evt.FromActivePlayer), cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<TeamMessageReceivedEvent>(
+                    (evt, ct) => relay.RelayAsync(
+                        new RelayedChatLine(ChatChannelKind.Team, evt.GuildId, evt.ServerId, evt.SenderName,
+                            evt.Message, evt.FromActivePlayer), ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(TeamMessageReceivedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -100,33 +99,9 @@ private async Task ConsumeClanMessagesAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ClanMessageReceivedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                // Clan members arrive as Steam ids only; chat is where we learn their names. A failure here
-                // is isolated so it cannot take down the relay loop below: a missed name is cosmetic, a
-                // dead relay loop silences clan chat until the process restarts.
-                try
-                {
-                    var scope = scopeFactory.CreateAsyncScope();
-                    await using (scope.ConfigureAwait(false))
-                    {
-                        var store = scope.ServiceProvider.GetRequiredService<IClanStore>();
-                        await store.RecordNameAsync(evt.GuildId, evt.ServerId, evt.SenderSteamId, evt.SenderName,
-                            cancellationToken).ConfigureAwait(false);
-                    }
-                }
-#pragma warning disable CA1031 // Broad catch: a name-recording failure must not kill the clan relay loop.
-                catch (Exception ex)
-#pragma warning restore CA1031
-                {
-                    LogClanNameRecordFailed(logger, ex);
-                }
-
-                await relay.RelayAsync(
-                    new RelayedChatLine(ChatChannelKind.Clan, evt.GuildId, evt.ServerId, evt.SenderName,
-                        evt.Message, evt.FromActivePlayer), cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ClanMessageReceivedEvent>(HandleClanMessageAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ClanMessageReceivedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -140,6 +115,32 @@ await relay.RelayAsync(
         }
     }
 
+    private async Task HandleClanMessageAsync(ClanMessageReceivedEvent evt, CancellationToken cancellationToken)
+    {
+        // Clan members arrive as Steam ids only; chat is where we learn their names. A failure here is
+        // isolated so it cannot cost the relay below: a missed name is cosmetic, a dropped clan line is not.
+        try
+        {
+            var scope = scopeFactory.CreateAsyncScope();
+            await using (scope.ConfigureAwait(false))
+            {
+                var store = scope.ServiceProvider.GetRequiredService<IClanStore>();
+                await store.RecordNameAsync(evt.GuildId, evt.ServerId, evt.SenderSteamId, evt.SenderName,
+                    cancellationToken).ConfigureAwait(false);
+            }
+        }
+#pragma warning disable CA1031 // Broad catch: a name-recording failure must not cost the relay.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogClanNameRecordFailed(logger, ex);
+        }
+
+        await relay.RelayAsync(
+            new RelayedChatLine(ChatChannelKind.Clan, evt.GuildId, evt.ServerId, evt.SenderName,
+                evt.Message, evt.FromActivePlayer), cancellationToken).ConfigureAwait(false);
+    }
+
     private async Task OnMessageReceivedAsync(SocketMessage message)
     {
         try
@@ -169,6 +170,9 @@ private async Task OnMessageReceivedAsync(SocketMessage message)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Team message relay loop faulted.")]
     private static partial void LogTeamRelayLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Connections/Hosting/ConnectionHostedService.cs b/src/RustPlusBot.Features.Connections/Hosting/ConnectionHostedService.cs
index e4f2c3b9..a80bc667 100644
--- a/src/RustPlusBot.Features.Connections/Hosting/ConnectionHostedService.cs
+++ b/src/RustPlusBot.Features.Connections/Hosting/ConnectionHostedService.cs
@@ -78,12 +78,10 @@ private async Task ConsumeRegisteredAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var registered in eventBus.SubscribeAsync<ServerRegisteredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await supervisor.EnsureConnectionAsync(registered.GuildId, registered.ServerId, cancellationToken)
-                    .ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerRegisteredEvent>(
+                    (registered, ct) => supervisor.EnsureConnectionAsync(registered.GuildId, registered.ServerId, ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerRegisteredEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -101,12 +99,10 @@ private async Task ConsumeCredentialsChangedAsync(CancellationToken cancellation
     {
         try
         {
-            await foreach (var changed in eventBus.SubscribeAsync<ServerCredentialsChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await supervisor.EnsureConnectionAsync(changed.GuildId, changed.ServerId, cancellationToken)
-                    .ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerCredentialsChangedEvent>(
+                    (changed, ct) => supervisor.EnsureConnectionAsync(changed.GuildId, changed.ServerId, ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerCredentialsChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -120,6 +116,9 @@ await supervisor.EnsureConnectionAsync(changed.GuildId, changed.ServerId, cancel
 #pragma warning restore CA1031
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Connection hosted-service loop faulted.")]
     private static partial void LogLoopFaulted(ILogger logger, Exception exception);
 }
diff --git a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
index 0dc59c44..47f2b35b 100644
--- a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
+++ b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
@@ -714,7 +714,11 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
                 .ConfigureAwait(false);
             if (!response.IsSuccess || response.Data is null)
             {
-                throw new InvalidOperationException("GetMap returned no data.");
+                // Name the reason: the caller only ever sees this message, and "rate_limit" (three heavy
+                // GetMap calls land back-to-back on connect) reads very differently from "no_map".
+                throw new InvalidOperationException(
+                    "GetMap returned no data; error: " + (response.Error?.Code.ToString() ?? "none") +
+                    " (" + (response.Error?.Message ?? "no message") + ").");
             }
 
             var monuments = new List<MonumentSnapshot>();
diff --git a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
index 80f78185..aa2fb10a 100644
--- a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
+++ b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
@@ -311,8 +311,25 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
             return [];
         }
 
-        return await live.Connection.GetMonumentsAsync(_options.HeartbeatTimeout, cancellationToken)
-            .ConfigureAwait(false);
+        try
+        {
+            return await live.Connection.GetMonumentsAsync(_options.HeartbeatTimeout, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+#pragma warning disable CA1031 // Broad catch: this seam promises degradation, so a failed fetch is "no monuments".
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            // The connection-level call throws on a failed/timed-out GetMap (rate limit, no map, slow
+            // endpoint). Callers here are render paths that must degrade to an icon-less map, never fault:
+            // an escaping exception tears down the consuming loop for the rest of the process.
+            LogMonumentsQueryFailed(logger, ex, serverId);
+            return [];
+        }
     }
 
     /// <inheritdoc />
@@ -1498,6 +1515,10 @@ await eventBus.PublishAsync(
             "Fetching monuments for oil-rig detection on server {ServerId} failed; rig detection disabled for this connection.")]
     private static partial void LogMonumentsFetchFailed(ILogger logger, Exception exception, Guid serverId);
 
+    [LoggerMessage(Level = LogLevel.Warning,
+        Message = "Querying monuments for server {ServerId} failed; returning no monuments for this call.")]
+    private static partial void LogMonumentsQueryFailed(ILogger logger, Exception exception, Guid serverId);
+
     [LoggerMessage(Level = LogLevel.Warning, Message = "Relaying a message to team chat for server {ServerId} failed.")]
     private static partial void LogSendFailed(ILogger logger, Exception exception, Guid serverId);
 
diff --git a/src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs b/src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs
index 06c919a8..22aa08b8 100644
--- a/src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs
+++ b/src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs
@@ -115,11 +115,9 @@ private async Task ConsumeMarkerEventsAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<MapMarkersChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.RelayAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<MapMarkersChangedEvent>(relay.RelayAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(MapMarkersChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -137,11 +135,9 @@ private async Task ConsumeRigEventsAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<RigStateChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.RelayRigAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<RigStateChangedEvent>(relay.RelayRigAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(RigStateChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -159,11 +155,9 @@ private async Task ConsumeConnectionStatusEventsAsync(CancellationToken cancella
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await ClearIfDisconnectedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(ClearIfDisconnectedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -193,6 +187,9 @@ private async Task ClearIfDisconnectedAsync(ConnectionStatusChangedEvent evt, Ca
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Event relay loop faulted.")]
     private static partial void LogRelayLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Map/Assets/MonumentTokenMap.cs b/src/RustPlusBot.Features.Map/Assets/MonumentTokenMap.cs
index 3985e9d0..2116e652 100644
--- a/src/RustPlusBot.Features.Map/Assets/MonumentTokenMap.cs
+++ b/src/RustPlusBot.Features.Map/Assets/MonumentTokenMap.cs
@@ -19,6 +19,7 @@ public static class MonumentTokenMap
     {
         ["AbandonedMilitaryBase"] = MonumentType.MilitaryBaseA,
         ["airfield_display_name"] = MonumentType.Airfield,
+        ["apartmentcomplex"] = MonumentType.ApartmentsComplex,
         ["arctic_base_a"] = MonumentType.ArcticResearchBaseA,
         ["arctic_base_b"] = MonumentType.ArcticResearchBaseA,
         ["bandit_camp"] = MonumentType.BanditTown,
diff --git a/src/RustPlusBot.Features.Map/Hosting/InfoMapHostedService.cs b/src/RustPlusBot.Features.Map/Hosting/InfoMapHostedService.cs
index 51e5990d..ac3fb976 100644
--- a/src/RustPlusBot.Features.Map/Hosting/InfoMapHostedService.cs
+++ b/src/RustPlusBot.Features.Map/Hosting/InfoMapHostedService.cs
@@ -163,11 +163,9 @@ private async Task ConsumeConnectionStatusAsync(CancellationToken cancellationTo
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await OnConnectionStatusAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(OnConnectionStatusAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -209,6 +207,9 @@ private async Task OnConnectionStatusAsync(ConnectionStatusChangedEvent evt, Can
         coordinator.Register(new RustMapsMapKey((int)world.WorldSize, (int)world.Seed), evt.GuildId, evt.ServerId);
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Info-map tick loop faulted.")]
     private static partial void LogTickFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Map/Hosting/MapHostedService.cs b/src/RustPlusBot.Features.Map/Hosting/MapHostedService.cs
index 949a0a01..9a113c71 100644
--- a/src/RustPlusBot.Features.Map/Hosting/MapHostedService.cs
+++ b/src/RustPlusBot.Features.Map/Hosting/MapHostedService.cs
@@ -98,11 +98,10 @@ private async Task ConsumeMarkerEventsAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<MapMarkersChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await RefreshAsync(evt.GuildId, evt.ServerId, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<MapMarkersChangedEvent>(
+                    (evt, ct) => RefreshAsync(evt.GuildId, evt.ServerId, ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(MapMarkersChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -128,11 +127,10 @@ private async Task ConsumeSettingsEventsAsync(CancellationToken cancellationToke
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<MapSettingsChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await RefreshAsync(evt.GuildId, evt.ServerId, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<MapSettingsChangedEvent>(
+                    (evt, ct) => RefreshAsync(evt.GuildId, evt.ServerId, ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(MapSettingsChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -162,7 +160,8 @@ private async Task RunPeriodicRefreshAsync(CancellationToken cancellationToken)
                 await Task.Delay(options.Value.MapRefreshInterval, cancellationToken).ConfigureAwait(false);
                 foreach (var (guild, server) in _connected.Keys)
                 {
-                    await RefreshAsync(guild, server, cancellationToken).ConfigureAwait(false);
+                    await RunGuardedAsync(() => RefreshAsync(guild, server, cancellationToken),
+                        guild, server, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
@@ -178,6 +177,38 @@ private async Task RunPeriodicRefreshAsync(CancellationToken cancellationToken)
         }
     }
 
+    /// <summary>
+    /// Runs one unit of loop work, absorbing any failure so a single bad refresh degrades that refresh
+    /// only. Without this, an exception escaping into a consumer's <c>await foreach</c> ends the
+    /// subscription for the rest of the process — the #map then stays frozen until the bot restarts.
+    /// </summary>
+    /// <param name="work">The refresh (or status handling) to run.</param>
+    /// <param name="guildId">The owning guild snowflake, for the failure log.</param>
+    /// <param name="serverId">The target server id, for the failure log.</param>
+    /// <param name="cancellationToken">A cancellation token; a real shutdown still propagates.</param>
+    /// <returns>A task that completes when the work has run or failed.</returns>
+    private async Task RunGuardedAsync(
+        Func<Task> work,
+        ulong guildId,
+        Guid serverId,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await work().ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw; // Shutdown: let the loop's own handler end it.
+        }
+#pragma warning disable CA1031 // Broad catch: any refresh failure must cost one repaint, never the loop.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogRefreshFailed(logger, ex, guildId, serverId);
+        }
+    }
+
     private async Task RefreshAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken)
     {
         if (!_throttle.ShouldRefresh(guildId, serverId, options.Value.MapRefreshInterval))
@@ -204,11 +235,9 @@ private async Task ConsumeConnectionStatusEventsAsync(CancellationToken cancella
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await OnConnectionStatusAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(OnConnectionStatusAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -245,6 +274,13 @@ private async Task OnConnectionStatusAsync(ConnectionStatusChangedEvent evt, Can
         await RefreshAsync(evt.GuildId, evt.ServerId, cancellationToken).ConfigureAwait(false);
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that repaint.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
+    [LoggerMessage(Level = LogLevel.Warning,
+        Message = "Refreshing the map for guild {GuildId}, server {ServerId} failed; skipping this repaint.")]
+    private static partial void LogRefreshFailed(ILogger logger, Exception exception, ulong guildId, Guid serverId);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Map marker loop faulted.")]
     private static partial void LogMarkerLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Players/Hosting/PlayersHostedService.cs b/src/RustPlusBot.Features.Players/Hosting/PlayersHostedService.cs
index 9de6ec17..d5054b63 100644
--- a/src/RustPlusBot.Features.Players/Hosting/PlayersHostedService.cs
+++ b/src/RustPlusBot.Features.Players/Hosting/PlayersHostedService.cs
@@ -50,11 +50,9 @@ private async Task ConsumeAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<PlayerStateChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.RelayAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<PlayerStateChangedEvent>(relay.RelayAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(PlayerStateChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -68,6 +66,9 @@ private async Task ConsumeAsync(CancellationToken cancellationToken)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Player relay loop faulted.")]
     private static partial void LogRelayLoopFaulted(ILogger logger, Exception exception);
 }
diff --git a/src/RustPlusBot.Features.StorageMonitors/Hosting/StorageMonitorsHostedService.cs b/src/RustPlusBot.Features.StorageMonitors/Hosting/StorageMonitorsHostedService.cs
index ea8d21ca..546349e8 100644
--- a/src/RustPlusBot.Features.StorageMonitors/Hosting/StorageMonitorsHostedService.cs
+++ b/src/RustPlusBot.Features.StorageMonitors/Hosting/StorageMonitorsHostedService.cs
@@ -66,11 +66,9 @@ private async Task ConsumePairedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<StorageMonitorPairedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await coordinator.HandlePairedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<StorageMonitorPairedEvent>(coordinator.HandlePairedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(StorageMonitorPairedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -88,11 +86,9 @@ private async Task ConsumeTriggeredAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<StorageMonitorTriggeredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleTriggeredAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<StorageMonitorTriggeredEvent>(relay.HandleTriggeredAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(StorageMonitorTriggeredEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -110,11 +106,9 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleConnectionStatusAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(relay.HandleConnectionStatusAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -132,11 +126,9 @@ private async Task ConsumeReachabilityChangedAsync(CancellationToken cancellatio
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<DeviceReachabilityChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleReachabilityChangedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<DeviceReachabilityChangedEvent>(relay.HandleReachabilityChangedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(DeviceReachabilityChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -154,11 +146,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ServerWipedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await purger.HandleServerWipedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerWipedEvent>(purger.HandleServerWipedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerWipedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -172,6 +162,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Storage monitor pairing loop faulted.")]
     private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
index 0ec822bb..fd0537c4 100644
--- a/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
+++ b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
@@ -68,11 +68,9 @@ private async Task ConsumePairedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<SwitchPairedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await coordinator.HandlePairedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<SwitchPairedEvent>(coordinator.HandlePairedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(SwitchPairedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -90,11 +88,9 @@ private async Task ConsumeStateAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<SwitchStateChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleStateChangedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<SwitchStateChangedEvent>(relay.HandleStateChangedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(SwitchStateChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -112,11 +108,9 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleConnectionStatusAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(relay.HandleConnectionStatusAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -134,11 +128,9 @@ private async Task ConsumeDeviceTriggeredAsync(CancellationToken cancellationTok
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<SmartDeviceTriggeredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleDeviceTriggeredAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<SmartDeviceTriggeredEvent>(relay.HandleDeviceTriggeredAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(SmartDeviceTriggeredEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -156,11 +148,9 @@ private async Task ConsumeReachabilityChangedAsync(CancellationToken cancellatio
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<DeviceReachabilityChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await relay.HandleReachabilityChangedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<DeviceReachabilityChangedEvent>(relay.HandleReachabilityChangedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(DeviceReachabilityChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -178,11 +168,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ServerWipedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await purger.HandleServerWipedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerWipedEvent>(purger.HandleServerWipedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerWipedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -196,6 +184,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Switch device-triggered relay loop faulted.")]
     private static partial void LogDeviceLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Wipes/Hosting/WipesHostedService.cs b/src/RustPlusBot.Features.Wipes/Hosting/WipesHostedService.cs
index 04d27e8e..c5d217b9 100644
--- a/src/RustPlusBot.Features.Wipes/Hosting/WipesHostedService.cs
+++ b/src/RustPlusBot.Features.Wipes/Hosting/WipesHostedService.cs
@@ -58,16 +58,12 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                if (!evt.IsConnected || evt.WasConnected)
-                {
-                    continue;
-                }
-
-                await detector.CheckAsync(evt.GuildId, evt.ServerId, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(
+                    (evt, ct) => !evt.IsConnected || evt.WasConnected
+                        ? Task.CompletedTask
+                        : detector.CheckAsync(evt.GuildId, evt.ServerId, ct),
+                    ex => LogHandlerFailed(logger, ex, nameof(ConnectionStatusChangedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -85,11 +81,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (var evt in eventBus.SubscribeAsync<ServerWipedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await announcer.HandleServerWipedAsync(evt, cancellationToken).ConfigureAwait(false);
-            }
+            await eventBus.ConsumeAsync<ServerWipedEvent>(announcer.HandleServerWipedAsync,
+                    ex => LogHandlerFailed(logger, ex, nameof(ServerWipedEvent)), cancellationToken)
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -103,6 +97,9 @@ private async Task ConsumeWipedAsync(CancellationToken cancellationToken)
         }
     }
 
+    [LoggerMessage(Level = LogLevel.Error, Message = "Handling {EventType} failed; skipping that event.")]
+    private static partial void LogHandlerFailed(ILogger logger, Exception exception, string eventType);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Wipe connection-status loop faulted.")]
     private static partial void LogStatusLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs b/src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs
index e458b1ee..03ae039d 100644
--- a/src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs
+++ b/src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs
@@ -144,23 +144,35 @@ private async Task OnChannelDestroyedAsync(SocketChannel channel)
         }
     }
 
+    /// <summary>
+    /// Reconciles one server in its own scope. Every consumer below runs this through
+    /// <see cref="EventBusConsumption.ConsumeAsync{TEvent}"/>, which absorbs its failures: the reconcile
+    /// talks to Discord over REST, where a timeout or a 5xx is routine, and one of those must never end
+    /// the subscription that drives the channels.
+    /// </summary>
+    /// <param name="guildId">The owning guild snowflake.</param>
+    /// <param name="serverId">The server to reconcile.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the reconcile has run.</returns>
+    private async Task ReconcileServerAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken)
+    {
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
+            await reconciler.ReconcileServerAsync(guildId, serverId, cancellationToken).ConfigureAwait(false);
+        }
+    }
+
     private async Task ConsumeConnectionStatusAsync(CancellationToken cancellationToken)
     {
-        // If this loop faults (broad catch), the consumer exits permanently and info channels stop
-        // updating until the host restarts. Acceptable: the reconciler is idempotent and a restart heals.
         try
         {
-            await foreach (var changed in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                var scope = scopeFactory.CreateAsyncScope();
-                await using (scope.ConfigureAwait(false))
-                {
-                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                    await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-            }
+            await eventBus.ConsumeAsync<ConnectionStatusChangedEvent>(
+                (evt, ct) => ReconcileServerAsync(evt.GuildId, evt.ServerId, ct),
+                ex => logger.LogError(ex, "Handling {EventType} failed; skipping that reconcile.",
+                    nameof(ConnectionStatusChangedEvent)),
+                cancellationToken).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -176,17 +188,11 @@ private async Task ConsumeServerCredentialsAsync(CancellationToken cancellationT
     {
         try
         {
-            await foreach (var changed in eventBus.SubscribeAsync<ServerCredentialsChangedEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                var scope = scopeFactory.CreateAsyncScope();
-                await using (scope.ConfigureAwait(false))
-                {
-                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                    await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-            }
+            await eventBus.ConsumeAsync<ServerCredentialsChangedEvent>(
+                (evt, ct) => ReconcileServerAsync(evt.GuildId, evt.ServerId, ct),
+                ex => logger.LogError(ex, "Handling {EventType} failed; skipping that reconcile.",
+                    nameof(ServerCredentialsChangedEvent)),
+                cancellationToken).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -200,21 +206,13 @@ await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancell
 
     private async Task ConsumeInfoMapReadyAsync(CancellationToken cancellationToken)
     {
-        // If this loop faults (broad catch), the consumer exits permanently and the #info map message stops
-        // updating until the host restarts. Acceptable: the reconciler is idempotent and a restart heals.
         try
         {
-            await foreach (var ready in eventBus.SubscribeAsync<InfoMapReadyEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                var scope = scopeFactory.CreateAsyncScope();
-                await using (scope.ConfigureAwait(false))
-                {
-                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                    await reconciler.ReconcileServerAsync(ready.GuildId, ready.ServerId, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-            }
+            await eventBus.ConsumeAsync<InfoMapReadyEvent>(
+                (evt, ct) => ReconcileServerAsync(evt.GuildId, evt.ServerId, ct),
+                ex => logger.LogError(ex, "Handling {EventType} failed; skipping that reconcile.",
+                    nameof(InfoMapReadyEvent)),
+                cancellationToken).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -234,17 +232,11 @@ private async Task ConsumeServerRegisteredAsync(CancellationToken cancellationTo
         // long after startup.
         try
         {
-            await foreach (var registered in eventBus.SubscribeAsync<ServerRegisteredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                var scope = scopeFactory.CreateAsyncScope();
-                await using (scope.ConfigureAwait(false))
-                {
-                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                    await reconciler.ReconcileServerAsync(registered.GuildId, registered.ServerId, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-            }
+            await eventBus.ConsumeAsync<ServerRegisteredEvent>(
+                (evt, ct) => ReconcileServerAsync(evt.GuildId, evt.ServerId, ct),
+                ex => logger.LogError(ex, "Handling {EventType} failed; skipping that reconcile.",
+                    nameof(ServerRegisteredEvent)),
+                cancellationToken).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
diff --git a/tests/RustPlusBot.Abstractions.Tests/Events/EventBusConsumptionTests.cs b/tests/RustPlusBot.Abstractions.Tests/Events/EventBusConsumptionTests.cs
new file mode 100644
index 00000000..05292261
--- /dev/null
+++ b/tests/RustPlusBot.Abstractions.Tests/Events/EventBusConsumptionTests.cs
@@ -0,0 +1,70 @@
+using RustPlusBot.Abstractions.Events;
+
+namespace RustPlusBot.Abstractions.Tests.Events;
+
+public sealed class EventBusConsumptionTests
+{
+    [Fact]
+    public async Task A_failing_handler_costs_its_own_event_only()
+    {
+        var handled = new List<int>();
+        var failures = new List<Exception>();
+        using var cts = new CancellationTokenSource();
+
+        var consume = new ScriptedBus(new Ping(1), new Ping(2), new Ping(3)).ConsumeAsync<Ping>(
+            (evt, _) =>
+            {
+                handled.Add(evt.Id);
+                return evt.Id == 1 ? throw new TimeoutException("The operation has timed out.") : Task.CompletedTask;
+            },
+            failures.Add,
+            cts.Token);
+
+        while (handled.Count < 3)
+        {
+            await Task.Delay(10);
+        }
+
+        await cts.CancelAsync();
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => consume);
+        Assert.Equal([1, 2, 3], handled);
+        Assert.Single(failures);
+        Assert.IsType<TimeoutException>(failures[0]);
+    }
+
+    [Fact]
+    public async Task Cancellation_ends_the_subscription()
+    {
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        var consume = new ScriptedBus(new Ping(1)).ConsumeAsync<Ping>(
+            (_, _) => Task.CompletedTask, _ => Assert.Fail("no handler failure expected"), cts.Token);
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => consume);
+    }
+
+    private sealed record Ping(int Id);
+
+    /// <summary>A bus whose subscription replays a fixed sequence, then blocks until cancelled.</summary>
+    /// <param name="events">The events to yield, in order.</param>
+    private sealed class ScriptedBus(params Ping[] events) : IEventBus
+    {
+        public ValueTask PublishAsync<TEvent>(TEvent @event, CancellationToken cancellationToken = default)
+            where TEvent : notnull => ValueTask.CompletedTask;
+
+        public async IAsyncEnumerable<TEvent> SubscribeAsync<TEvent>(
+            [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default)
+            where TEvent : notnull
+        {
+            foreach (var evt in events.Cast<TEvent>())
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                yield return evt;
+            }
+
+            await Task.Delay(Timeout.Infinite, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
index 7b2277bd..739ca1cf 100644
--- a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
+++ b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
@@ -262,6 +262,11 @@ internal sealed class FakeConnection(SocketConnectOutcome outcome, FakeRustSocke
         /// (a per-request timeout) instead of returning <see cref="MonumentsResult"/>.</summary>
         public bool MonumentsTimeout { get; set; }
 
+        /// <summary>When set, <see cref="GetMonumentsAsync"/> throws this instead of returning
+        /// <see cref="MonumentsResult"/> — models the real socket's "GetMap returned no data" throw when
+        /// the Rust+ endpoint answers with an error (rate limit, no map, …).</summary>
+        public Exception? MonumentsFault { get; set; }
+
         /// <summary>The bytes returned by <see cref="GetMapImageAsync"/>. Defaults to null.</summary>
         public byte[]? MapImageResult { get; set; }
 
@@ -414,10 +419,13 @@ public Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(TimeSpan timeou
             Task.FromResult(World);
 
         public Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(TimeSpan timeout,
-            CancellationToken cancellationToken = default) =>
-            MonumentsTimeout
-                ? Task.FromException<IReadOnlyList<MonumentSnapshot>>(new OperationCanceledException())
-                : Task.FromResult(MonumentsResult);
+            CancellationToken cancellationToken = default)
+        {
+            var fault = MonumentsFault ?? (MonumentsTimeout ? new OperationCanceledException() : null);
+            return fault is null
+                ? Task.FromResult(MonumentsResult)
+                : Task.FromException<IReadOnlyList<MonumentSnapshot>>(fault);
+        }
 
         public Task<byte[]?> GetMapImageAsync(TimeSpan timeout, CancellationToken cancellationToken = default) =>
             Task.FromResult(MapImageResult);
diff --git a/tests/RustPlusBot.Features.Connections.Tests/ServerQueryTests.cs b/tests/RustPlusBot.Features.Connections.Tests/ServerQueryTests.cs
index c8e03528..4a20e23a 100644
--- a/tests/RustPlusBot.Features.Connections.Tests/ServerQueryTests.cs
+++ b/tests/RustPlusBot.Features.Connections.Tests/ServerQueryTests.cs
@@ -258,6 +258,27 @@ public async Task GetMonumentsAsync_returns_empty_when_no_live_socket()
         Assert.Empty(result);
     }
 
+    [Fact]
+    public async Task GetMonumentsAsync_returns_empty_when_the_endpoint_fails()
+    {
+        // The query seam promises degradation ("or an empty list"), but the socket-level call throws on a
+        // failed GetMap. Left unguarded, that throw escapes into the map pipeline and kills its event loop.
+        var source = new FakeRustSocketSource();
+        var (provider, supervisor) = CreateHarness(source);
+        await using var _ = provider;
+        var serverId = await SeedServerWithActiveAsync(provider, steamId: 555UL);
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        await supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
+        await WaitUntilAsync(() => supervisor.HasLiveSocket(10UL, serverId), cts.Token);
+        source.LastConnection!.MonumentsFault = new InvalidOperationException("GetMap returned no data.");
+
+        var result = await supervisor.GetMonumentsAsync(10UL, serverId, cts.Token);
+
+        Assert.Empty(result);
+        await supervisor.StopAllAsync();
+    }
+
     private static async Task WaitUntilAsync(Func<bool> condition, CancellationToken ct)
     {
         while (!condition())
diff --git a/tests/RustPlusBot.Features.Map.Tests/Hosting/MapHostedServiceTests.cs b/tests/RustPlusBot.Features.Map.Tests/Hosting/MapHostedServiceTests.cs
new file mode 100644
index 00000000..574b9b5a
--- /dev/null
+++ b/tests/RustPlusBot.Features.Map.Tests/Hosting/MapHostedServiceTests.cs
@@ -0,0 +1,104 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using RustMapsApi.V4.Assets;
+using RustPlusBot.Abstractions.Connections;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Domain.Connections;
+using RustPlusBot.Features.Events.State;
+using RustPlusBot.Features.Map.Assets;
+using RustPlusBot.Features.Map.Composing;
+using RustPlusBot.Features.Map.Hosting;
+using RustPlusBot.Features.Map.Posting;
+using RustPlusBot.Features.Map.Rendering;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Persistence.Map;
+
+namespace RustPlusBot.Features.Map.Tests.Hosting;
+
+public sealed class MapHostedServiceTests
+{
+    private const ulong Guild = 1UL;
+    private static readonly Guid Server = Guid.NewGuid();
+
+    /// <summary>A clock that jumps an hour per read — past <see cref="MapOptions.MapRefreshInterval"/> below,
+    /// so the throttle passes every refresh and each consumed event reaches the counter (never gates).</summary>
+    private static IClock AdvancingClock()
+    {
+        var ticks = 0;
+        var clock = Substitute.For<IClock>();
+        clock.UtcNow.Returns(_ => DateTimeOffset.UnixEpoch + TimeSpan.FromHours(ticks++));
+        return clock;
+    }
+
+    private static IServiceScopeFactory ScopeFactory(IConnectionStore store) =>
+        new ServiceCollection()
+            .AddScoped(_ => store)
+            .AddScoped(_ => Substitute.For<IMapSettingsStore>())
+            .BuildServiceProvider()
+            .GetRequiredService<IServiceScopeFactory>();
+
+    private static IConnectionStore ConnectedStore()
+    {
+        var store = Substitute.For<IConnectionStore>();
+        store.GetStateAsync(Guild, Server, Arg.Any<CancellationToken>())
+            .Returns(new ConnectionState
+            {
+                GuildId = Guild, RustServerId = Server, Status = ConnectionStatus.Connected
+            });
+        return store;
+    }
+
+    private static MapComposer Composer(IServiceScopeFactory scopeFactory) =>
+        new(new BaseMapCache([]), Substitute.For<IEventState>(), Substitute.For<IRigState>(),
+            Substitute.For<IRustServerQuery>(),
+            new MapRenderer(new MonumentIconSource(new MonumentAssetSource(), NullLogger<MonumentIconSource>.Instance)),
+            scopeFactory);
+
+    [Fact]
+    public async Task Status_loop_survives_a_faulting_refresh_and_keeps_consuming_events()
+    {
+        // A transient failure anywhere in the refresh path (a Rust+ query, Discord, …) used to escape the
+        // await-foreach and end the subscription for the rest of the process: the #map then went silent
+        // until restart. One bad refresh must degrade that refresh only.
+        var locator = Substitute.For<IMapChannelLocator>();
+        var calls = 0;
+        locator.GetChannelIdAsync(Guild, Server, Arg.Any<CancellationToken>())
+            .Returns<ulong?>(_ => ++calls == 1
+                ? throw new InvalidOperationException("GetMap returned no data.")
+                : null);
+
+        var scopeFactory = ScopeFactory(ConnectedStore());
+        var pipeline = new MapPipeline(Composer(scopeFactory), new BaseMapCache([]), locator,
+            Substitute.For<IMapChannelPoster>());
+        var bus = new InMemoryEventBus();
+        var options = Options.Create(new MapOptions
+        {
+            MapRefreshInterval = TimeSpan.FromMinutes(30)
+        });
+        var service = new MapHostedService(bus, pipeline, AdvancingClock(), options, scopeFactory,
+            NullLogger<MapHostedService>.Instance);
+
+        await service.StartAsync(CancellationToken.None);
+        try
+        {
+            // The bus drops events published before the subscriber is live, so publish until observed.
+            var deadline = DateTimeOffset.UtcNow.AddSeconds(5);
+            while (DateTimeOffset.UtcNow < deadline && Volatile.Read(ref calls) < 2)
+            {
+                await bus.PublishAsync(new ConnectionStatusChangedEvent(Guild, Server, true, false));
+                await Task.Delay(20);
+            }
+        }
+        finally
+        {
+            await service.StopAsync(CancellationToken.None);
+        }
+
+        Assert.True(Volatile.Read(ref calls) >= 2,
+            $"the status loop stopped consuming after the first refresh threw (calls: {calls})");
+    }
+}
diff --git a/tests/RustPlusBot.Features.Map.Tests/MonumentTokenMapTests.cs b/tests/RustPlusBot.Features.Map.Tests/MonumentTokenMapTests.cs
index 859fe27e..1d1be3d4 100644
--- a/tests/RustPlusBot.Features.Map.Tests/MonumentTokenMapTests.cs
+++ b/tests/RustPlusBot.Features.Map.Tests/MonumentTokenMapTests.cs
@@ -13,6 +13,7 @@ public sealed class MonumentTokenMapTests
     [InlineData("bandit_camp", MonumentType.BanditTown)]
     [InlineData("radtown", MonumentType.Radtown)]
     [InlineData("jungle_ziggurat", MonumentType.JungleZigguratA)]
+    [InlineData("apartmentcomplex", MonumentType.ApartmentsComplex)]
     [InlineData("train_tunnel_display_name", MonumentType.TunnelEntrance)]
     [InlineData("train_tunnel_link_display_name", MonumentType.TunnelEntranceTransition)]
     [InlineData("arctic_base_b", MonumentType.ArcticResearchBaseA)]
diff --git a/tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConsumerResilienceTests.cs b/tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConsumerResilienceTests.cs
new file mode 100644
index 00000000..6df6f335
--- /dev/null
+++ b/tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConsumerResilienceTests.cs
@@ -0,0 +1,67 @@
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Workspace.Hosting;
+using RustPlusBot.Features.Workspace.Reconciler;
+using RustPlusBot.Features.Workspace.Registry;
+
+namespace RustPlusBot.Features.Workspace.Tests.Hosting;
+
+public sealed class WorkspaceConsumerResilienceTests
+{
+    private static (WorkspaceHostedService Service, ServiceProvider Provider, InMemoryEventBus Bus) Build(
+        IWorkspaceReconciler reconciler)
+    {
+        var services = new ServiceCollection();
+        services.AddScoped(_ => reconciler);
+        services.AddSingleton(Substitute.For<IWorkspaceRegistry>()); // StartAsync resolves this up front.
+        var provider = services.BuildServiceProvider();
+
+        var bus = new InMemoryEventBus();
+        var service = new WorkspaceHostedService(new DiscordSocketClient(), bus,
+            provider.GetRequiredService<IServiceScopeFactory>(),
+            NullLogger<WorkspaceHostedService>.Instance);
+        return (service, provider, bus);
+    }
+
+    /// <summary>
+    /// A Discord REST timeout inside the reconcile is routine, but it used to escape the consumer's
+    /// await-foreach and end the subscription for the rest of the process — every later connect/disconnect
+    /// then left the info channels stale until the bot restarted.
+    /// </summary>
+    [Fact]
+    public async Task ConnectionStatus_consumer_survives_a_faulting_reconcile()
+    {
+        var calls = 0;
+        var reconciler = Substitute.For<IWorkspaceReconciler>();
+        reconciler.ReconcileServerAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>())
+            .Returns(_ => Interlocked.Increment(ref calls) == 1
+                ? throw new TimeoutException("The operation has timed out.")
+                : Task.CompletedTask);
+
+        var (service, provider, bus) = Build(reconciler);
+        await using var _ = provider;
+
+        await service.StartAsync(CancellationToken.None);
+        try
+        {
+            // The in-process bus does not replay; re-publish until the consumer has handled two events.
+            var deadline = DateTimeOffset.UtcNow.AddSeconds(20);
+            while (DateTimeOffset.UtcNow < deadline && Volatile.Read(ref calls) < 2)
+            {
+                await bus.PublishAsync(
+                    new ConnectionStatusChangedEvent(10UL, Guid.NewGuid(), IsConnected: true, WasConnected: false));
+                await Task.Delay(20);
+            }
+        }
+        finally
+        {
+            await service.StopAsync(CancellationToken.None);
+        }
+
+        Assert.True(Volatile.Read(ref calls) >= 2,
+            $"the consumer stopped after the first reconcile threw (calls: {calls})");
+    }
+}