diff --git a/Directory.Packages.props b/Directory.Packages.props
index d0f54e0..03d14d0 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -11,8 +11,8 @@
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.9" />
     <PackageVersion Include="Persistord.Core" Version="1.0.0-beta.1" />
-    <PackageVersion Include="RustPlusApi" Version="2.0.0-beta.2" />
-    <PackageVersion Include="RustPlusApi.Fcm" Version="2.0.0-beta.2" />
+    <PackageVersion Include="RustPlusApi" Version="2.0.0-beta.3" />
+    <PackageVersion Include="RustPlusApi.Fcm" Version="2.0.0-beta.3" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.12" />
     <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="2.1.7" />
     <!-- Pinned to override the transitive 2.1.11 pulled by Microsoft.EntityFrameworkCore.Sqlite,
diff --git a/src/RustPlusBot.Abstractions/Events/SmartDeviceTriggeredEvent.cs b/src/RustPlusBot.Abstractions/Events/SmartDeviceTriggeredEvent.cs
new file mode 100644
index 0000000..a1020a9
--- /dev/null
+++ b/src/RustPlusBot.Abstractions/Events/SmartDeviceTriggeredEvent.cs
@@ -0,0 +1,8 @@
+namespace RustPlusBot.Abstractions.Events;
+
+/// <summary>A managed smart device (switch/alarm/…) changed state in-game, as reported by the socket broadcast.</summary>
+/// <param name="GuildId">The owning Discord guild snowflake.</param>
+/// <param name="ServerId">The local Rust server id.</param>
+/// <param name="EntityId">The in-game entity id (the discriminant — features filter to the ids they manage).</param>
+/// <param name="IsActive">The new on/off state, carried directly on the broadcast (no re-read).</param>
+public sealed record SmartDeviceTriggeredEvent(ulong GuildId, Guid ServerId, ulong EntityId, bool IsActive);
diff --git a/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs b/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
index 7853faf..dd7b65f 100644
--- a/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
+++ b/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
@@ -47,12 +47,12 @@ internal interface IRustServerConnection : IAsyncDisposable
     /// <returns>True if the promotion succeeded; false on failure/timeout.</returns>
     Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, CancellationToken cancellationToken);
 
-    /// <summary>Reads a smart switch's on/off state, or null on failure/timeout. Also primes the socket's interest in the entity.</summary>
-    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <summary>Reads a smart device's on/off state, or null on failure/timeout. Also primes the socket's interest in the entity (so triggers fire for it thereafter).</summary>
+    /// <param name="entityId">The in-game entity id (switch or alarm).</param>
     /// <param name="timeout">How long to wait for the response.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
     /// <returns>True/false for on/off, or null on failure/timeout.</returns>
-    Task<bool?> GetSmartSwitchInfoAsync(ulong entityId, TimeSpan timeout, CancellationToken cancellationToken);
+    Task<bool?> GetSmartDeviceInfoAsync(ulong entityId, TimeSpan timeout, CancellationToken cancellationToken);
 
     /// <summary>Sets a smart switch on/off; returns true on success, false on failure/timeout.</summary>
     /// <param name="entityId">The in-game smart-switch entity id.</param>
@@ -107,6 +107,6 @@ Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(TimeSpan timeout,
     /// <summary>Raised for every in-game team chat line received on this socket.</summary>
     event EventHandler<TeamChatLine>? TeamMessageReceived;
 
-    /// <summary>Raised when a smart switch's state changes in-game; carries the entity id.</summary>
-    event EventHandler<ulong>? SmartSwitchTriggered;
+    /// <summary>Raised when a managed smart device's state changes in-game; carries the entity id and new state.</summary>
+    event EventHandler<SmartDeviceTrigger>? SmartDeviceTriggered;
 }
diff --git a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
index 02558ee..fea185f 100644
--- a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
+++ b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
@@ -48,7 +48,7 @@ public Task SendTeamMessageAsync(string message, CancellationToken cancellationT
         public Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, CancellationToken cancellationToken) =>
             Task.FromResult(false);
 
-        public Task<bool?> GetSmartSwitchInfoAsync(ulong entityId,
+        public Task<bool?> GetSmartDeviceInfoAsync(ulong entityId,
             TimeSpan timeout,
             CancellationToken cancellationToken) =>
             Task.FromResult<bool?>(null);
@@ -87,7 +87,7 @@ public event EventHandler<TeamChatLine>? TeamMessageReceived
             remove { _ = value; }
         }
 
-        public event EventHandler<ulong>? SmartSwitchTriggered
+        public event EventHandler<SmartDeviceTrigger>? SmartDeviceTriggered
         {
             add { _ = value; }
             remove { _ = value; }
@@ -116,7 +116,7 @@ public RustPlusServerConnection(string ip, int port, ulong steamId, int playerTo
             var connection = new RustPlusConnection(ip, port, steamId, playerToken, UseFacepunchProxy: false);
             _rustPlus = new RustPlus(connection);
             _rustPlus.OnTeamChatReceived += OnTeamChatReceived;
-            _rustPlus.OnSmartSwitchTriggered += OnSmartSwitchTriggered;
+            _rustPlus.OnSmartDeviceTriggered += OnSmartDeviceTriggered;
         }
 
         public async Task<SocketConnectOutcome> ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
@@ -345,9 +345,9 @@ public async Task<bool> PromoteToLeaderAsync(ulong steamId,
             }
         }
 
-        public event EventHandler<ulong>? SmartSwitchTriggered;
+        public event EventHandler<SmartDeviceTrigger>? SmartDeviceTriggered;
 
-        public async Task<bool?> GetSmartSwitchInfoAsync(ulong entityId,
+        public async Task<bool?> GetSmartDeviceInfoAsync(ulong entityId,
             TimeSpan timeout,
             CancellationToken cancellationToken)
         {
@@ -355,10 +355,10 @@ public async Task<bool> PromoteToLeaderAsync(ulong steamId,
             timeoutCts.CancelAfter(timeout);
             try
             {
-                // CONFIRMED (2.0.0-beta.2): GetSmartSwitchInfoAsync(ulong, CancellationToken) returns
-                // Task of Response of SmartSwitchInfo; Response.IsSuccess and Response.Data are the accessors and
-                // SmartSwitchInfo.IsActive is a bool. The call also primes the socket's interest in this
-                // entity, so OnSmartSwitchTriggered fires for it thereafter.
+                // CONFIRMED (2.0.0-beta.3): GetSmartSwitchInfoAsync(ulong, CancellationToken) returns
+                // Task of Response of SmartDeviceInfo; Response.IsSuccess and Response.Data are the accessors and
+                // SmartDeviceInfo.IsActive is a bool. The call also primes the socket's interest in this
+                // entity, so OnSmartDeviceTriggered fires for it thereafter.
                 var response = await _rustPlus.GetSmartSwitchInfoAsync(entityId, timeoutCts.Token)
                     .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
                 return response.IsSuccess && response.Data is { } info ? info.IsActive : null;
@@ -385,8 +385,8 @@ public async Task<bool> SetSmartSwitchValueAsync(ulong entityId,
             timeoutCts.CancelAfter(timeout);
             try
             {
-                // CONFIRMED (2.0.0-beta.2): SetSmartSwitchValueAsync(ulong, bool, CancellationToken) returns
-                // Task of Response of SmartSwitchInfo; Response.IsSuccess indicates the outcome.
+                // CONFIRMED (2.0.0-beta.3): SetSmartSwitchValueAsync(ulong, bool, CancellationToken) returns
+                // Task of Response of SmartDeviceInfo; Response.IsSuccess indicates the outcome.
                 var response = await _rustPlus.SetSmartSwitchValueAsync(entityId, value, timeoutCts.Token)
                     .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
                 return response.IsSuccess;
@@ -414,8 +414,8 @@ public async Task<bool> StrobeSmartSwitchAsync(ulong entityId,
             timeoutCts.CancelAfter(timeout);
             try
             {
-                // CONFIRMED (2.0.0-beta.2): StrobeSmartSwitchAsync(ulong, int timeoutMs, bool value, CancellationToken)
-                // returns Task of Response of SmartSwitchInfo; Response.IsSuccess indicates the outcome.
+                // CONFIRMED (2.0.0-beta.3): StrobeSmartSwitchAsync(ulong, int timeoutMs, bool value, CancellationToken)
+                // returns Task of Response of SmartDeviceInfo; Response.IsSuccess indicates the outcome.
                 var response = await _rustPlus.StrobeSmartSwitchAsync(entityId, timeoutMs, value, timeoutCts.Token)
                     .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
                 return response.IsSuccess;
@@ -556,7 +556,7 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
         public async ValueTask DisposeAsync()
         {
             _rustPlus.OnTeamChatReceived -= OnTeamChatReceived;
-            _rustPlus.OnSmartSwitchTriggered -= OnSmartSwitchTriggered;
+            _rustPlus.OnSmartDeviceTriggered -= OnSmartDeviceTriggered;
             try
             {
                 // CONFIRMED: RustPlusSocket implements IAsyncDisposable in 2.0.0-beta.1.
@@ -571,8 +571,8 @@ public async ValueTask DisposeAsync()
             }
         }
 
-        private void OnSmartSwitchTriggered(object? sender, RustPlusApi.Data.Events.SmartSwitchEventArg e) =>
-            SmartSwitchTriggered?.Invoke(this, e.Id);
+        private void OnSmartDeviceTriggered(object? sender, RustPlusApi.Data.Events.SmartDeviceEventArg e) =>
+            SmartDeviceTriggered?.Invoke(this, new SmartDeviceTrigger(e.Id, e.IsActive));
 
         private static void AddMarkers<TMarker>(
             List<MapMarkerSnapshot> into,
diff --git a/src/RustPlusBot.Features.Connections/Listening/SmartDeviceTrigger.cs b/src/RustPlusBot.Features.Connections/Listening/SmartDeviceTrigger.cs
new file mode 100644
index 0000000..67d0fcc
--- /dev/null
+++ b/src/RustPlusBot.Features.Connections/Listening/SmartDeviceTrigger.cs
@@ -0,0 +1,6 @@
+namespace RustPlusBot.Features.Connections.Listening;
+
+/// <summary>An in-game device-state broadcast: the entity id and its new on/off state.</summary>
+/// <param name="EntityId">The in-game entity id.</param>
+/// <param name="IsActive">The new on/off state carried on the broadcast.</param>
+internal sealed record SmartDeviceTrigger(ulong EntityId, bool IsActive);
diff --git a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
index 7d53942..f85beae 100644
--- a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
+++ b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
@@ -257,7 +257,7 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
             return null;
         }
 
-        return await live.Connection.GetSmartSwitchInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)
+        return await live.Connection.GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)
             .ConfigureAwait(false);
     }
 
@@ -467,20 +467,20 @@ void OnTeamMessage(object? sender, TeamChatLine line)
         var dims = await connection.GetMapDimensionsAsync(_options.HeartbeatTimeout, ct).ConfigureAwait(false);
         var rigs = await GetRigPositionsAsync(key.Server, connection, ct).ConfigureAwait(false);
 
-#pragma warning disable RCS1163 // Unused 'sender': required by the EventHandler<ulong> delegate shape.
-        void OnSmartSwitch(object? sender, ulong entityId)
+#pragma warning disable RCS1163 // Unused 'sender': required by the EventHandler<SmartDeviceTrigger> delegate shape.
+        void OnSmartDevice(object? sender, SmartDeviceTrigger trigger)
         {
-            // Fire-and-forget: PublishSwitchStateAsync catches everything internally, so the discarded task never
-            // surfaces an unobserved exception. Switch triggers are low-volume, so unbounded concurrency is fine.
-            _ = PublishSwitchStateAsync(key, connection, entityId);
+            // Fire-and-forget: PublishDeviceTriggerAsync catches everything internally, so the discarded task never
+            // surfaces an unobserved exception. Device triggers are low-volume, so unbounded concurrency is fine.
+            _ = PublishDeviceTriggerAsync(key, trigger);
         }
 #pragma warning restore RCS1163
 
         var tracker = new TeamStateTracker();
         connection.TeamMessageReceived += OnTeamMessage;
-        connection.SmartSwitchTriggered += OnSmartSwitch;
+        connection.SmartDeviceTriggered += OnSmartDevice;
         _liveSockets[key] = new LiveSocket(connection, activeSteamId, tracker);
-        await PrimeSwitchesAsync(key, connection, ct).ConfigureAwait(false);
+        await PrimeDevicesAsync(key, connection, ct).ConfigureAwait(false);
         using var pollCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
         var markerPoll = Task.Run(() => PollMarkersAsync(key, connection, dims, rigs, tracker, pollCts.Token),
             CancellationToken.None);
@@ -521,7 +521,7 @@ await PublishStatusAsync(key, ConnectionStatus.Connected, beat.PlayerCount, cred
 
             _liveSockets.TryRemove(key, out _);
             connection.TeamMessageReceived -= OnTeamMessage;
-            connection.SmartSwitchTriggered -= OnSmartSwitch;
+            connection.SmartDeviceTriggered -= OnSmartDevice;
         }
     }
 
@@ -799,7 +799,7 @@ private async Task PublishTeamMessageAsync((ulong Guild, Guid Server) key, ulong
         }
     }
 
-    private async Task PrimeSwitchesAsync(
+    private async Task PrimeDevicesAsync(
         (ulong Guild, Guid Server) key,
         IRustServerConnection connection,
         CancellationToken ct)
@@ -823,7 +823,7 @@ private async Task PrimeSwitchesAsync(
 #pragma warning restore CA1031
         {
             // Best-effort: a store/DB failure must not crash the connected loop or block the heartbeat.
-            LogSwitchListFailed(logger, ex, key.Server);
+            LogDeviceListFailed(logger, ex, key.Server);
             return;
         }
 
@@ -834,7 +834,7 @@ private async Task PrimeSwitchesAsync(
             // Best-effort per switch: one failure must not crash the connected loop or block the heartbeat.
             try
             {
-                await PublishSwitchStateAsync(key, connection, sw.EntityId).ConfigureAwait(false);
+                await PublishDevicePrimeAsync(key, connection, sw.EntityId).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -844,12 +844,47 @@ private async Task PrimeSwitchesAsync(
             catch (Exception ex)
 #pragma warning restore CA1031
             {
-                LogSwitchPrimeFailed(logger, ex, sw.EntityId, key.Server);
+                LogDevicePrimeFailed(logger, ex, sw.EntityId, key.Server);
             }
         }
     }
 
-    private async Task PublishSwitchStateAsync(
+    /// <summary>Trigger path: IsActive is carried on the broadcast arg — no re-read.</summary>
+    /// <param name="key">The (guild, server) routing key.</param>
+    /// <param name="trigger">The device trigger carrying the entity id and active state.</param>
+    private async Task PublishDeviceTriggerAsync(
+        (ulong Guild, Guid Server) key,
+        SmartDeviceTrigger trigger)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        try
+        {
+            await eventBus.PublishAsync(
+                    new SmartDeviceTriggeredEvent(key.Guild, key.Server, trigger.EntityId, trigger.IsActive),
+                    _shutdown.Token)
+                .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a device publish failure must not crash the socket callback.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogDevicePublishFailed(logger, ex, trigger.EntityId, key.Server);
+        }
+    }
+
+    /// <summary>Prime path: read state on connect (also primes the socket's interest), then publish.</summary>
+    /// <param name="key">The (guild, server) routing key.</param>
+    /// <param name="connection">The live connection used to read device state.</param>
+    /// <param name="entityId">The entity id of the device to prime.</param>
+    private async Task PublishDevicePrimeAsync(
         (ulong Guild, Guid Server) key,
         IRustServerConnection connection,
         ulong entityId)
@@ -862,10 +897,10 @@ private async Task PublishSwitchStateAsync(
         try
         {
             var isActive = await connection
-                .GetSmartSwitchInfoAsync(entityId, _options.HeartbeatTimeout, _shutdown.Token)
+                .GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, _shutdown.Token)
                 .ConfigureAwait(false);
             await eventBus.PublishAsync(
-                    new SwitchStateChangedEvent(key.Guild, key.Server, entityId, isActive ?? false),
+                    new SmartDeviceTriggeredEvent(key.Guild, key.Server, entityId, isActive ?? false),
                     _shutdown.Token)
                 .ConfigureAwait(false);
         }
@@ -873,11 +908,11 @@ await eventBus.PublishAsync(
         {
             // Shutting down.
         }
-#pragma warning disable CA1031 // Broad catch: a switch publish failure must not crash the socket callback.
+#pragma warning disable CA1031 // Broad catch: a device prime failure must not crash the socket callback.
         catch (Exception ex)
 #pragma warning restore CA1031
         {
-            LogSwitchPublishFailed(logger, ex, entityId, key.Server);
+            LogDevicePublishFailed(logger, ex, entityId, key.Server);
         }
     }
 
@@ -897,16 +932,16 @@ await eventBus.PublishAsync(
     private static partial void LogPublishTeamMessageFailed(ILogger logger, Exception exception, Guid serverId);
 
     [LoggerMessage(Level = LogLevel.Warning,
-        Message = "Listing smart switches to prime on server {ServerId} failed; priming skipped for this connection.")]
-    private static partial void LogSwitchListFailed(ILogger logger, Exception exception, Guid serverId);
+        Message = "Listing smart devices to prime on server {ServerId} failed; priming skipped for this connection.")]
+    private static partial void LogDeviceListFailed(ILogger logger, Exception exception, Guid serverId);
 
-    [LoggerMessage(Level = LogLevel.Warning, Message = "Priming smart switch {EntityId} on server {ServerId} failed.")]
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Priming smart device {EntityId} on server {ServerId} failed.")]
     private static partial void
-        LogSwitchPrimeFailed(ILogger logger, Exception exception, ulong entityId, Guid serverId);
+        LogDevicePrimeFailed(ILogger logger, Exception exception, ulong entityId, Guid serverId);
 
     [LoggerMessage(Level = LogLevel.Warning,
-        Message = "Publishing a smart-switch state for entity {EntityId} on server {ServerId} failed.")]
-    private static partial void LogSwitchPublishFailed(ILogger logger,
+        Message = "Publishing a smart-device state for entity {EntityId} on server {ServerId} failed.")]
+    private static partial void LogDevicePublishFailed(ILogger logger,
         Exception exception,
         ulong entityId,
         Guid serverId);
diff --git a/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
index 1345944..56c1af6 100644
--- a/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
+++ b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
@@ -18,6 +18,7 @@ internal sealed partial class SwitchesHostedService(
     ILogger<SwitchesHostedService> logger) : IHostedService, IDisposable
 {
     private readonly CancellationTokenSource _cts = new();
+    private Task? _deviceLoop;
     private Task? _pairedLoop;
     private Task? _stateLoop;
     private Task? _statusLoop;
@@ -31,6 +32,7 @@ public Task StartAsync(CancellationToken cancellationToken)
         _pairedLoop = Task.Run(() => ConsumePairedAsync(_cts.Token), CancellationToken.None);
         _stateLoop = Task.Run(() => ConsumeStateAsync(_cts.Token), CancellationToken.None);
         _statusLoop = Task.Run(() => ConsumeStatusAsync(_cts.Token), CancellationToken.None);
+        _deviceLoop = Task.Run(() => ConsumeDeviceTriggeredAsync(_cts.Token), CancellationToken.None);
         return Task.CompletedTask;
     }
 
@@ -40,7 +42,7 @@ public async Task StopAsync(CancellationToken cancellationToken)
         await _cts.CancelAsync().ConfigureAwait(false);
         foreach (var loop in new[]
                  {
-                     _pairedLoop, _stateLoop, _statusLoop
+                     _pairedLoop, _stateLoop, _statusLoop, _deviceLoop
                  }.Where(t => t is not null))
         {
             try
@@ -122,6 +124,31 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
         }
     }
 
+    private async Task ConsumeDeviceTriggeredAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await foreach (var evt in eventBus.SubscribeAsync<SmartDeviceTriggeredEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                await relay.HandleDeviceTriggeredAsync(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
+        {
+            LogDeviceLoopFaulted(logger, ex);
+        }
+    }
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Switch device-triggered relay loop faulted.")]
+    private static partial void LogDeviceLoopFaulted(ILogger logger, Exception exception);
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Switch pairing loop faulted.")]
     private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
 
diff --git a/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs b/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs
index d9b3e02..a056bef 100644
--- a/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs
+++ b/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs
@@ -49,6 +49,39 @@ await RenderAsync(store, sw, evt.IsActive, evt.GuildId, evt.ServerId, culture, c
         }
     }
 
+    /// <summary>Handles an in-game device trigger: ignore ids this relay doesn't manage, else persist + re-render.</summary>
+    /// <param name="evt">The device-triggered event.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the embed has been re-rendered (or the id was ignored).</returns>
+    public async Task HandleDeviceTriggeredAsync(SmartDeviceTriggeredEvent evt, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            if (!await store.ExistsAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken)
+                    .ConfigureAwait(false))
+            {
+                return; // not a switch this relay manages (e.g. an alarm) — ignore.
+            }
+
+            await store.UpdateStateAsync(evt.GuildId, evt.ServerId, evt.EntityId, evt.IsActive, cancellationToken)
+                .ConfigureAwait(false);
+            var sw = await store.GetAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken)
+                .ConfigureAwait(false);
+            if (sw is null)
+            {
+                return;
+            }
+
+            var culture = await GetCultureAsync(scope.ServiceProvider, evt.GuildId, cancellationToken)
+                .ConfigureAwait(false);
+            await RenderAsync(store, sw, evt.IsActive, evt.GuildId, evt.ServerId, culture, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
     /// <summary>Handles a connection-status change: a non-Connected server marks its switch embeds unreachable.</summary>
     /// <param name="evt">The connection-status change.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
diff --git a/tests/RustPlusBot.Abstractions.Tests/SmartDeviceTriggeredEventTests.cs b/tests/RustPlusBot.Abstractions.Tests/SmartDeviceTriggeredEventTests.cs
new file mode 100644
index 0000000..17796ee
--- /dev/null
+++ b/tests/RustPlusBot.Abstractions.Tests/SmartDeviceTriggeredEventTests.cs
@@ -0,0 +1,15 @@
+using RustPlusBot.Abstractions.Events;
+
+namespace RustPlusBot.Abstractions.Tests;
+
+public sealed class SmartDeviceTriggeredEventTests
+{
+    [Fact]
+    public void CarriesIdentityAndState()
+    {
+        var e = new SmartDeviceTriggeredEvent(10UL, Guid.Empty, 42UL, IsActive: true);
+        Assert.Equal(10UL, e.GuildId);
+        Assert.Equal(42UL, e.EntityId);
+        Assert.True(e.IsActive);
+    }
+}
diff --git a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
index 78b7c2c..0055341 100644
--- a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
+++ b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
@@ -117,7 +117,7 @@ internal sealed class FakeConnection(SocketConnectOutcome outcome, FakeRustSocke
         /// <summary>The Steam ID passed to the most recent <see cref="PromoteToLeaderAsync"/> call.</summary>
         public ulong LastPromotedSteamId { get; private set; }
 
-        /// <summary>The state returned by <see cref="GetSmartSwitchInfoAsync"/> per entity id; absent → null.</summary>
+        /// <summary>The state returned by <see cref="GetSmartDeviceInfoAsync"/> per entity id; absent → null.</summary>
         public Dictionary<ulong, bool?> SwitchStates { get; } = new();
 
         /// <summary>The result returned by <see cref="SetSmartSwitchValueAsync"/>. Defaults to true.</summary>
@@ -151,8 +151,8 @@ internal sealed class FakeConnection(SocketConnectOutcome outcome, FakeRustSocke
         /// <summary>Raised when a team chat message arrives on this connection.</summary>
         public event EventHandler<TeamChatLine>? TeamMessageReceived;
 
-        /// <summary>Raised by <see cref="RaiseSmartSwitchTriggered"/>.</summary>
-        public event EventHandler<ulong>? SmartSwitchTriggered;
+        /// <summary>Raised by <see cref="RaiseSmartDeviceTriggered"/>.</summary>
+        public event EventHandler<SmartDeviceTrigger>? SmartDeviceTriggered;
 
         public Task<SocketConnectOutcome> ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken) =>
             Task.FromResult(outcome);
@@ -184,7 +184,7 @@ public Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, Cancella
         }
 
 #pragma warning disable RCS1163 // Unused parameters for fake implementation
-        public Task<bool?> GetSmartSwitchInfoAsync(ulong entityId,
+        public Task<bool?> GetSmartDeviceInfoAsync(ulong entityId,
             TimeSpan timeout,
             CancellationToken cancellationToken) =>
             Task.FromResult(SwitchStates.TryGetValue(entityId, out var s) ? s : null);
@@ -257,8 +257,10 @@ public Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(TimeSpan timeout,
         /// <param name="line">The team chat line to raise.</param>
         public void RaiseTeamMessage(TeamChatLine line) => TeamMessageReceived?.Invoke(this, line);
 
-        /// <summary>Simulates an in-game smart-switch state change.</summary>
-        /// <param name="entityId">The smart-switch entity id to raise the event for.</param>
-        public void RaiseSmartSwitchTriggered(ulong entityId) => SmartSwitchTriggered?.Invoke(this, entityId);
+        /// <summary>Simulates an in-game smart-device state change.</summary>
+        /// <param name="entityId">The smart-device entity id to raise the event for.</param>
+        /// <param name="isActive">The current active state carried on the trigger arg.</param>
+        public void RaiseSmartDeviceTriggered(ulong entityId, bool isActive) =>
+            SmartDeviceTriggered?.Invoke(this, new SmartDeviceTrigger(entityId, isActive));
     }
 }
diff --git a/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs b/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs
index 5cbade2..882e26c 100644
--- a/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs
+++ b/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs
@@ -140,9 +140,9 @@ public async Task Priming_publishes_state_for_persisted_switch_on_connect()
 
         // Subscribe BEFORE connecting: SubscribeAsync registers the channel eagerly on THIS thread, so the primed
         // publish (which fires during EnsureConnectionAsync) is observed. Only the enumeration runs in Task.Run.
-        var stream = bus.SubscribeAsync<SwitchStateChangedEvent>(cts.Token);
+        var stream = bus.SubscribeAsync<SmartDeviceTriggeredEvent>(cts.Token);
         var received =
-            new TaskCompletionSource<SwitchStateChangedEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+            new TaskCompletionSource<SmartDeviceTriggeredEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
         _ = Task.Run(
             async () =>
             {
@@ -157,7 +157,7 @@ public async Task Priming_publishes_state_for_persisted_switch_on_connect()
             },
             cts.Token);
 
-        // The fake defaults entity 42 absent → GetSmartSwitchInfoAsync returns null → priming publishes off.
+        // The fake defaults entity 42 absent → GetSmartDeviceInfoAsync returns null → priming publishes off.
         await supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
 
         var evt = await received.Task.WaitAsync(cts.Token);
@@ -177,9 +177,9 @@ public async Task Trigger_publishes_state_change()
         using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
 
         // Subscribe BEFORE raising the trigger so the channel is registered when the publish fires.
-        var stream = bus.SubscribeAsync<SwitchStateChangedEvent>(cts.Token);
+        var stream = bus.SubscribeAsync<SmartDeviceTriggeredEvent>(cts.Token);
         var received =
-            new TaskCompletionSource<SwitchStateChangedEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+            new TaskCompletionSource<SmartDeviceTriggeredEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
         _ = Task.Run(
             async () =>
             {
@@ -198,8 +198,7 @@ public async Task Trigger_publishes_state_change()
         await supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
         await WaitUntilAsync(() => supervisor.HasLiveSocket(10UL, serverId), cts.Token);
 
-        source.LastConnection!.SwitchStates[42UL] = true; // re-read on trigger returns on
-        source.LastConnection.RaiseSmartSwitchTriggered(42UL);
+        source.LastConnection!.RaiseSmartDeviceTriggered(42UL, isActive: true);
 
         var evt = await received.Task.WaitAsync(cts.Token);
         Assert.True(evt.IsActive);
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs
index 8ed1603..242dec6 100644
--- a/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs
@@ -112,6 +112,47 @@ await h.Poster.DidNotReceive().EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(),
             Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
     }
 
+    [Fact]
+    public async Task DeviceTriggered_managed_switch_updates_store_and_rerenders()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(true);
+        h.Store.GetAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>())
+            .Returns(new SmartSwitch
+            {
+                GuildId = 10UL,
+                ServerId = serverId,
+                EntityId = 42UL,
+                Name = "G",
+                MessageId = 900UL
+            });
+
+        await h.Relay.HandleDeviceTriggeredAsync(
+            new SmartDeviceTriggeredEvent(10UL, serverId, 42UL, IsActive: true), CancellationToken.None);
+
+        await h.Store.Received(1).UpdateStateAsync(10UL, serverId, 42UL, true, Arg.Any<CancellationToken>());
+        await h.Poster.Received(1).EnsureAsync(777UL, 900UL, Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task DeviceTriggered_non_switch_id_is_ignored()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 99UL, Arg.Any<CancellationToken>()).Returns(false);
+
+        await h.Relay.HandleDeviceTriggeredAsync(
+            new SmartDeviceTriggeredEvent(10UL, serverId, 99UL, IsActive: true), CancellationToken.None);
+
+        await h.Store.DidNotReceive().UpdateStateAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
+            Arg.Any<bool>(), Arg.Any<CancellationToken>());
+        await h.Poster.DidNotReceive().EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(),
+            Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
+    }
+
     private sealed record Harness(
         SwitchStateRelay Relay,
         ISwitchStore Store,