feat(alarms): add AlarmsHostedService, AddAlarms DI, and Host wiring

Wire the smart-alarms slice live: AlarmsHostedService drives three
consume loops (AlarmPairedEvent → coordinator, SmartDeviceTriggeredEvent
→ relay, ConnectionStatusChangedEvent → relay); AddAlarms registers all
slice singletons and the hosted service; Host references the Alarms
project and calls AddAlarms() after AddSwitches(). AlarmRegistrationTests
covers both descriptor presence and captive-dependency-free resolution.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Alarms/AlarmServiceCollectionExtensions.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Discord;
+using RustPlusBot.Features.Alarms.Hosting;
+using RustPlusBot.Features.Alarms.Pairing;
+using RustPlusBot.Features.Alarms.Posting;
+using RustPlusBot.Features.Alarms.Relaying;
+using RustPlusBot.Features.Alarms.Rendering;
+
+namespace RustPlusBot.Features.Alarms;
+
+/// <summary>DI registration for the Smart Alarms feature.</summary>
+public static class AlarmServiceCollectionExtensions
+{
+    /// <summary>Registers the localizer, renderer, poster, refresher, coordinator, relay, modules, and hosted service.</summary>
+    /// <param name="services">The service collection to add to.</param>
+    /// <returns>The same service collection, for chaining.</returns>
+    public static IServiceCollection AddAlarms(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddSingleton<IAlarmLocalizer>(new AlarmLocalizer(AlarmLocalizationCatalog.Default));
+        services.AddSingleton<AlarmEmbedRenderer>();
+        services.AddSingleton<IAlarmChannelPoster, DiscordAlarmChannelPoster>();
+        services.AddSingleton<IAlarmRefresher, AlarmRefresher>();
+        services.AddSingleton<AlarmPairingCoordinator>();
+        services.AddSingleton<AlarmStateRelay>();
+        services.AddHostedService<AlarmsHostedService>();
+
+        // Contribute this assembly's interaction modules to the Discord layer.
+        services.AddSingleton(new InteractionModuleAssembly(typeof(AlarmServiceCollectionExtensions).Assembly));
+
+        return services;
+    }
+}

src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs

@@ -0,0 +1,133 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Alarms.Pairing;
+using RustPlusBot.Features.Alarms.Relaying;
+
+namespace RustPlusBot.Features.Alarms.Hosting;
+
+/// <summary>Runs the alarm-pairing loop, the alarm-triggered relay loop, and the connection-status relay loop.</summary>
+/// <param name="eventBus">The in-process event bus.</param>
+/// <param name="coordinator">Handles paired alarms.</param>
+/// <param name="relay">Re-renders alarms on trigger/connection changes.</param>
+/// <param name="logger">The logger.</param>
+internal sealed partial class AlarmsHostedService(
+    IEventBus eventBus,
+    AlarmPairingCoordinator coordinator,
+    AlarmStateRelay relay,
+    ILogger<AlarmsHostedService> logger) : IHostedService, IDisposable
+{
+    private readonly CancellationTokenSource _cts = new();
+    private Task? _pairedLoop;
+    private Task? _statusLoop;
+    private Task? _triggeredLoop;
+
+    /// <inheritdoc />
+    public void Dispose() => _cts.Dispose();
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _pairedLoop = Task.Run(() => ConsumePairedAsync(_cts.Token), CancellationToken.None);
+        _triggeredLoop = Task.Run(() => ConsumeTriggeredAsync(_cts.Token), CancellationToken.None);
+        _statusLoop = Task.Run(() => ConsumeStatusAsync(_cts.Token), CancellationToken.None);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        await _cts.CancelAsync().ConfigureAwait(false);
+        foreach (var loop in new[]
+                 {
+                     _pairedLoop, _triggeredLoop, _statusLoop
+                 }.Where(t => t is not null))
+        {
+            try
+            {
+#pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
+                await loop!.ConfigureAwait(false);
+#pragma warning restore VSTHRD003
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected on shutdown.
+            }
+        }
+    }
+
+    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);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a faulting consumer must not crash the host.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogPairedLoopFaulted(logger, ex);
+        }
+    }
+
+    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);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a faulting consumer must not crash the host.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogTriggeredLoopFaulted(logger, ex);
+        }
+    }
+
+    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);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a faulting consumer must not crash the host.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogStatusLoopFaulted(logger, ex);
+        }
+    }
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Alarm pairing loop faulted.")]
+    private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Alarm device-triggered relay loop faulted.")]
+    private static partial void LogTriggeredLoopFaulted(ILogger logger, Exception exception);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Alarm connection-status relay loop faulted.")]
+    private static partial void LogStatusLoopFaulted(ILogger logger, Exception exception);
+}

src/RustPlusBot.Host/Program.cs

@@ -11,6 +11,7 @@
 using RustPlusBot.Features.Connections;
 using RustPlusBot.Features.Events;
 using RustPlusBot.Features.Map;
+using RustPlusBot.Features.Alarms;
 using RustPlusBot.Features.Switches;
 using RustPlusBot.Features.Players;
 using RustPlusBot.Features.Pairing;
@@ -77,6 +78,7 @@
     .ValidateOnStart();
 builder.Services.AddMap();
 builder.Services.AddSwitches();
+builder.Services.AddAlarms();
 
 var host = builder.Build();
 

src/RustPlusBot.Host/RustPlusBot.Host.csproj

@@ -25,6 +25,7 @@
     <ProjectReference Include="..\RustPlusBot.Features.Commands\RustPlusBot.Features.Commands.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Events\RustPlusBot.Features.Events.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Switches\RustPlusBot.Features.Switches.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Features.Alarms\RustPlusBot.Features.Alarms.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Map\RustPlusBot.Features.Map.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Players\RustPlusBot.Features.Players.csproj" />
   </ItemGroup>

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

@@ -0,0 +1,83 @@
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Features.Alarms.Pairing;
+using RustPlusBot.Features.Alarms.Posting;
+using RustPlusBot.Features.Alarms.Relaying;
+using RustPlusBot.Features.Alarms.Rendering;
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Alarms;
+using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Alarms.Tests;
+
+/// <summary>Validates that <see cref="AlarmServiceCollectionExtensions.AddAlarms"/> registers all required services.</summary>
+public sealed class AlarmRegistrationTests
+{
+    /// <summary>Verifies core service descriptors are present after calling <see cref="AlarmServiceCollectionExtensions.AddAlarms"/>.</summary>
+    [Fact]
+    public void AddAlarms_registers_core_services()
+    {
+        var services = new ServiceCollection();
+        services.AddAlarms();
+
+        Assert.Contains(services, d => d.ServiceType == typeof(IAlarmLocalizer));
+        Assert.Contains(services, d => d.ServiceType == typeof(AlarmEmbedRenderer));
+        Assert.Contains(services, d => d.ServiceType == typeof(IAlarmChannelPoster));
+        Assert.Contains(services, d => d.ServiceType == typeof(IAlarmRefresher));
+        Assert.Contains(services, d => d.ServiceType == typeof(AlarmPairingCoordinator));
+        Assert.Contains(services, d => d.ServiceType == typeof(AlarmStateRelay));
+        Assert.Contains(services, d => d.ServiceType == typeof(IHostedService));
+    }
+
+    /// <summary>Verifies the container resolves key types without captive-dependency errors when all cross-layer deps are provided.</summary>
+    [Fact]
+    public void AddAlarms_resolves_without_captive_dependency_errors()
+    {
+        var services = new ServiceCollection();
+
+        // Logging (required by concrete types such as DiscordAlarmChannelPoster and AlarmsHostedService)
+        services.AddLogging();
+
+        // Cross-layer singletons from other slices
+        services.AddSingleton(Substitute.For<IClock>());
+        services.AddSingleton(Substitute.For<IEventBus>());
+        services.AddSingleton(Substitute.For<IAlarmChannelLocator>());
+        services.AddSingleton(Substitute.For<ITeamChatSender>());
+
+        // Discord
+        var discordConfig = new DiscordSocketConfig();
+        services.AddSingleton(new DiscordSocketClient(discordConfig));
+
+        // Scoped stores from Persistence
+        services.AddScoped(_ => Substitute.For<IAlarmStore>());
+        services.AddScoped(_ => Substitute.For<IWorkspaceStore>());
+        services.AddScoped(_ => Substitute.For<IConnectionStore>());
+
+        services.AddAlarms();
+
+        using var provider = services.BuildServiceProvider(validateScopes: true);
+
+        var localizer = provider.GetRequiredService<IAlarmLocalizer>();
+        var renderer = provider.GetRequiredService<AlarmEmbedRenderer>();
+        var poster = provider.GetRequiredService<IAlarmChannelPoster>();
+        var refresher = provider.GetRequiredService<IAlarmRefresher>();
+        var coordinator = provider.GetRequiredService<AlarmPairingCoordinator>();
+        var relay = provider.GetRequiredService<AlarmStateRelay>();
+        var hostedService = provider.GetRequiredService<IHostedService>();
+
+        Assert.NotNull(localizer);
+        Assert.NotNull(renderer);
+        Assert.NotNull(poster);
+        Assert.NotNull(refresher);
+        Assert.NotNull(coordinator);
+        Assert.NotNull(relay);
+        Assert.NotNull(hostedService);
+    }
+}