diff --git a/.gitignore b/.gitignore
index cb3b121..a6441b2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -418,6 +418,8 @@ docs/obj/
 docs/superpowers/
 docs/product/
 
+.superpowers/
+
 # Stryker mutation testing output
 StrykerOutput/
 
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 5da787e..d0f54e0 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.1" />
-    <PackageVersion Include="RustPlusApi.Fcm" Version="2.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="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/RustPlusBot.slnx b/RustPlusBot.slnx
index d3157bc..3ccce97 100644
--- a/RustPlusBot.slnx
+++ b/RustPlusBot.slnx
@@ -11,6 +11,7 @@
     <Project Path="src/RustPlusBot.Features.Chat/RustPlusBot.Features.Chat.csproj" />
     <Project Path="src/RustPlusBot.Features.Events/RustPlusBot.Features.Events.csproj" />
     <Project Path="src/RustPlusBot.Features.Players/RustPlusBot.Features.Players.csproj" />
+    <Project Path="src/RustPlusBot.Features.Switches/RustPlusBot.Features.Switches.csproj" />
     <Project Path="src/RustPlusBot.Features.Workspace/RustPlusBot.Features.Workspace.csproj" />
     <Project Path="src/RustPlusBot.Persistence/RustPlusBot.Persistence.csproj" />
   </Folder>
@@ -21,6 +22,7 @@
     <Project Path="tests/RustPlusBot.Features.Map.Tests/RustPlusBot.Features.Map.Tests.csproj" />
     <Project Path="tests/RustPlusBot.Features.Pairing.Tests/RustPlusBot.Features.Pairing.Tests.csproj" />
     <Project Path="tests/RustPlusBot.Features.Players.Tests/RustPlusBot.Features.Players.Tests.csproj" />
+    <Project Path="tests/RustPlusBot.Features.Switches.Tests/RustPlusBot.Features.Switches.Tests.csproj" />
     <Project Path="tests/RustPlusBot.Features.Workspace.Tests/RustPlusBot.Features.Workspace.Tests.csproj" />
     <Project Path="tests/RustPlusBot.Features.Chat.Tests/RustPlusBot.Features.Chat.Tests.csproj" />
     <Project Path="tests/RustPlusBot.Features.Events.Tests/RustPlusBot.Features.Events.Tests.csproj" />
diff --git a/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs b/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
index c1a7586..3c7576b 100644
--- a/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
+++ b/src/RustPlusBot.Abstractions/Connections/IRustServerQuery.cs
@@ -55,4 +55,43 @@ Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
         ulong guildId,
         Guid serverId,
         CancellationToken cancellationToken);
+
+    /// <summary>Reads a smart switch's on/off state, or null when there is no live socket or the call fails.</summary>
+    /// <param name="guildId">The owning guild snowflake.</param>
+    /// <param name="serverId">The target server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True/false for on/off, or null when unavailable.</returns>
+    Task<bool?> GetSmartSwitchStateAsync(ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken);
+
+    /// <summary>Sets a smart switch on/off; returns false when there is no live socket or the call fails.</summary>
+    /// <param name="guildId">The owning guild snowflake.</param>
+    /// <param name="serverId">The target server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="value">True to turn on, false to turn off.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True on success; false when unavailable or the call fails.</returns>
+    Task<bool> SetSmartSwitchAsync(ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        bool value,
+        CancellationToken cancellationToken);
+
+    /// <summary>Strobes a smart switch; returns false when there is no live socket or the call fails.</summary>
+    /// <param name="guildId">The owning guild snowflake.</param>
+    /// <param name="serverId">The target server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="timeoutMs">The in-game strobe duration in milliseconds.</param>
+    /// <param name="value">The terminal value after strobing.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True on success; false when unavailable or the call fails.</returns>
+    Task<bool> StrobeSmartSwitchAsync(ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        int timeoutMs,
+        bool value,
+        CancellationToken cancellationToken);
 }
diff --git a/src/RustPlusBot.Abstractions/Events/SwitchPairedEvent.cs b/src/RustPlusBot.Abstractions/Events/SwitchPairedEvent.cs
new file mode 100644
index 0000000..61df741
--- /dev/null
+++ b/src/RustPlusBot.Abstractions/Events/SwitchPairedEvent.cs
@@ -0,0 +1,7 @@
+namespace RustPlusBot.Abstractions.Events;
+
+/// <summary>Raised when a Smart Switch is paired in-game and resolved to a known server (awaiting user validation).</summary>
+/// <param name="GuildId">The owning Discord guild snowflake.</param>
+/// <param name="ServerId">The local RustServer id the entity belongs to.</param>
+/// <param name="EntityId">The in-game smart-switch entity id.</param>
+public sealed record SwitchPairedEvent(ulong GuildId, Guid ServerId, ulong EntityId);
diff --git a/src/RustPlusBot.Abstractions/Events/SwitchStateChangedEvent.cs b/src/RustPlusBot.Abstractions/Events/SwitchStateChangedEvent.cs
new file mode 100644
index 0000000..5a040e5
--- /dev/null
+++ b/src/RustPlusBot.Abstractions/Events/SwitchStateChangedEvent.cs
@@ -0,0 +1,8 @@
+namespace RustPlusBot.Abstractions.Events;
+
+/// <summary>Raised when a Smart Switch's live on/off state is observed (prime or trigger).</summary>
+/// <param name="GuildId">The owning Discord guild snowflake.</param>
+/// <param name="ServerId">The local RustServer id the entity belongs to.</param>
+/// <param name="EntityId">The in-game smart-switch entity id.</param>
+/// <param name="IsActive">True when the switch is on.</param>
+public sealed record SwitchStateChangedEvent(ulong GuildId, Guid ServerId, ulong EntityId, bool IsActive);
diff --git a/src/RustPlusBot.Domain/Servers/RustServer.cs b/src/RustPlusBot.Domain/Servers/RustServer.cs
index b879d37..084f23d 100644
--- a/src/RustPlusBot.Domain/Servers/RustServer.cs
+++ b/src/RustPlusBot.Domain/Servers/RustServer.cs
@@ -20,4 +20,7 @@ public sealed class RustServer
 
     /// <summary>The Discord user who added this server.</summary>
     public ulong AddedByUserId { get; set; }
+
+    /// <summary>The Facepunch server GUID from FCM pairings, backfilled on server pairing; null until first seen. Used to attribute entity pairings.</summary>
+    public Guid? FacepunchServerId { get; set; }
 }
diff --git a/src/RustPlusBot.Domain/Switches/SmartSwitch.cs b/src/RustPlusBot.Domain/Switches/SmartSwitch.cs
new file mode 100644
index 0000000..43c0732
--- /dev/null
+++ b/src/RustPlusBot.Domain/Switches/SmartSwitch.cs
@@ -0,0 +1,32 @@
+namespace RustPlusBot.Domain.Switches;
+
+/// <summary>A paired Smart Switch the bot manages, surviving restarts. Guild- and server-scoped.</summary>
+public sealed class SmartSwitch
+{
+    /// <summary>Surrogate primary key.</summary>
+    public Guid Id { get; set; } = Guid.NewGuid();
+
+    /// <summary>The owning Discord guild snowflake.</summary>
+    public ulong GuildId { get; set; }
+
+    /// <summary>The server this switch belongs to (FK to RustServer, cascade delete).</summary>
+    public Guid ServerId { get; set; }
+
+    /// <summary>The in-game smart-switch entity id.</summary>
+    public ulong EntityId { get; set; }
+
+    /// <summary>User-facing label; defaults to a generated "Switch &lt;EntityId&gt;" (the FCM event carries no name).</summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>The Discord message id of this switch's embed, or null until first posted.</summary>
+    public ulong? MessageId { get; set; }
+
+    /// <summary>The Discord user who accepted (validated) the pairing.</summary>
+    public ulong PairedByUserId { get; set; }
+
+    /// <summary>The last observed on/off state.</summary>
+    public bool LastIsActive { get; set; }
+
+    /// <summary>When the switch was accepted (UTC).</summary>
+    public DateTimeOffset CreatedUtc { get; set; }
+}
diff --git a/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs b/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
index 8588a1d..7853faf 100644
--- a/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
+++ b/src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs
@@ -47,6 +47,37 @@ 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>
+    /// <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);
+
+    /// <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>
+    /// <param name="value">True to turn on, false to turn off.</param>
+    /// <param name="timeout">How long to wait for the response.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True on success; false on failure/timeout.</returns>
+    Task<bool> SetSmartSwitchValueAsync(ulong entityId,
+        bool value,
+        TimeSpan timeout,
+        CancellationToken cancellationToken);
+
+    /// <summary>Strobes a smart switch; returns true on success, false on failure/timeout.</summary>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="timeoutMs">The in-game strobe duration in milliseconds.</param>
+    /// <param name="value">The terminal value after strobing.</param>
+    /// <param name="timeout">How long to wait for the response.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True on success; false on failure/timeout.</returns>
+    Task<bool> StrobeSmartSwitchAsync(ulong entityId,
+        int timeoutMs,
+        bool value,
+        TimeSpan timeout,
+        CancellationToken cancellationToken);
+
     /// <summary>Polls the current map markers the bot tracks (cargo ship, patrol helicopter, chinook), for diffing by id. Throws on failure.</summary>
     /// <param name="timeout">How long to wait for the response.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
@@ -75,4 +106,7 @@ 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;
 }
diff --git a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
index 4d4bed8..02558ee 100644
--- a/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
+++ b/src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs
@@ -48,6 +48,24 @@ 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,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) =>
+            Task.FromResult<bool?>(null);
+
+        public Task<bool> SetSmartSwitchValueAsync(ulong entityId,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) =>
+            Task.FromResult(false);
+
+        public Task<bool> StrobeSmartSwitchAsync(ulong entityId,
+            int timeoutMs,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) =>
+            Task.FromResult(false);
+
         public Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(TimeSpan timeout,
             CancellationToken cancellationToken = default) =>
             Task.FromResult<IReadOnlyList<MapMarkerSnapshot>>([]);
@@ -69,6 +87,12 @@ public event EventHandler<TeamChatLine>? TeamMessageReceived
             remove { _ = value; }
         }
 
+        public event EventHandler<ulong>? SmartSwitchTriggered
+        {
+            add { _ = value; }
+            remove { _ = value; }
+        }
+
         public ValueTask DisposeAsync() => ValueTask.CompletedTask;
     }
 
@@ -92,6 +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;
         }
 
         public async Task<SocketConnectOutcome> ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
@@ -320,6 +345,94 @@ public async Task<bool> PromoteToLeaderAsync(ulong steamId,
             }
         }
 
+        public event EventHandler<ulong>? SmartSwitchTriggered;
+
+        public async Task<bool?> GetSmartSwitchInfoAsync(ulong entityId,
+            TimeSpan timeout,
+            CancellationToken cancellationToken)
+        {
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            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.
+                var response = await _rustPlus.GetSmartSwitchInfoAsync(entityId, timeoutCts.Token)
+                    .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
+                return response.IsSuccess && response.Data is { } info ? info.IsActive : null;
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return null;
+            }
+#pragma warning disable CA1031 // Broad catch: any switch-info failure maps to null; never surface a token/secret.
+            catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
+#pragma warning restore CA1031
+            {
+                LogQueryFailed(_logger, ex);
+                return null;
+            }
+        }
+
+        public async Task<bool> SetSmartSwitchValueAsync(ulong entityId,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken)
+        {
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            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.
+                var response = await _rustPlus.SetSmartSwitchValueAsync(entityId, value, timeoutCts.Token)
+                    .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
+                return response.IsSuccess;
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return false;
+            }
+#pragma warning disable CA1031 // Broad catch: any set failure maps to false; never surface a token/secret.
+            catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
+#pragma warning restore CA1031
+            {
+                LogQueryFailed(_logger, ex);
+                return false;
+            }
+        }
+
+        public async Task<bool> StrobeSmartSwitchAsync(ulong entityId,
+            int timeoutMs,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken)
+        {
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            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.
+                var response = await _rustPlus.StrobeSmartSwitchAsync(entityId, timeoutMs, value, timeoutCts.Token)
+                    .WaitAsync(timeoutCts.Token).ConfigureAwait(false);
+                return response.IsSuccess;
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return false;
+            }
+#pragma warning disable CA1031 // Broad catch: any strobe failure maps to false; never surface a token/secret.
+            catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
+#pragma warning restore CA1031
+            {
+                LogQueryFailed(_logger, ex);
+                return false;
+            }
+        }
+
         public async Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(
             TimeSpan timeout,
             CancellationToken cancellationToken = default)
@@ -443,6 +556,7 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
         public async ValueTask DisposeAsync()
         {
             _rustPlus.OnTeamChatReceived -= OnTeamChatReceived;
+            _rustPlus.OnSmartSwitchTriggered -= OnSmartSwitchTriggered;
             try
             {
                 // CONFIRMED: RustPlusSocket implements IAsyncDisposable in 2.0.0-beta.1.
@@ -457,6 +571,9 @@ public async ValueTask DisposeAsync()
             }
         }
 
+        private void OnSmartSwitchTriggered(object? sender, RustPlusApi.Data.Events.SmartSwitchEventArg e) =>
+            SmartSwitchTriggered?.Invoke(this, e.Id);
+
         private static void AddMarkers<TMarker>(
             List<MapMarkerSnapshot> into,
             IReadOnlyDictionary<ulong, TMarker> source,
diff --git a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
index 7e854cd..7d53942 100644
--- a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
+++ b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
@@ -12,6 +12,7 @@
 using RustPlusBot.Features.Connections.Listening;
 using RustPlusBot.Persistence.Connections;
 using RustPlusBot.Persistence.Servers;
+using RustPlusBot.Persistence.Switches;
 
 namespace RustPlusBot.Features.Connections.Supervisor;
 
@@ -244,6 +245,59 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
             .ConfigureAwait(false);
     }
 
+    /// <inheritdoc />
+    public async Task<bool?> GetSmartSwitchStateAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken)
+    {
+        if (!_liveSockets.TryGetValue((guildId, serverId), out var live))
+        {
+            return null;
+        }
+
+        return await live.Connection.GetSmartSwitchInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> SetSmartSwitchAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        bool value,
+        CancellationToken cancellationToken)
+    {
+        if (!_liveSockets.TryGetValue((guildId, serverId), out var live))
+        {
+            return false;
+        }
+
+        return await live.Connection
+            .SetSmartSwitchValueAsync(entityId, value, _options.HeartbeatTimeout, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> StrobeSmartSwitchAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        int timeoutMs,
+        bool value,
+        CancellationToken cancellationToken)
+    {
+        if (!_liveSockets.TryGetValue((guildId, serverId), out var live))
+        {
+            return false;
+        }
+
+        return await live.Connection
+            .StrobeSmartSwitchAsync(entityId, timeoutMs, value, _options.HeartbeatTimeout, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     /// <inheritdoc />
     public async Task<TeamChatSendResult> SendAsync(
         ulong guildId,
@@ -413,9 +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)
+        {
+            // 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);
+        }
+#pragma warning restore RCS1163
+
         var tracker = new TeamStateTracker();
         connection.TeamMessageReceived += OnTeamMessage;
+        connection.SmartSwitchTriggered += OnSmartSwitch;
         _liveSockets[key] = new LiveSocket(connection, activeSteamId, tracker);
+        await PrimeSwitchesAsync(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);
@@ -456,6 +521,7 @@ await PublishStatusAsync(key, ConnectionStatus.Connected, beat.PlayerCount, cred
 
             _liveSockets.TryRemove(key, out _);
             connection.TeamMessageReceived -= OnTeamMessage;
+            connection.SmartSwitchTriggered -= OnSmartSwitch;
         }
     }
 
@@ -733,6 +799,88 @@ private async Task PublishTeamMessageAsync((ulong Guild, Guid Server) key, ulong
         }
     }
 
+    private async Task PrimeSwitchesAsync(
+        (ulong Guild, Guid Server) key,
+        IRustServerConnection connection,
+        CancellationToken ct)
+    {
+        IReadOnlyList<Domain.Switches.SmartSwitch> switches;
+        try
+        {
+            var scope = scopeFactory.CreateAsyncScope();
+            await using (scope.ConfigureAwait(false))
+            {
+                var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+                switches = await store.ListByServerAsync(key.Guild, key.Server, ct).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+#pragma warning disable CA1031 // Broad catch: a failed switch-list read just skips priming for this connection.
+        catch (Exception ex)
+#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);
+            return;
+        }
+
+#pragma warning disable S3267 // Not a projection: each iteration awaits with per-switch best-effort error handling.
+        foreach (var sw in switches)
+#pragma warning restore S3267
+        {
+            // 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);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+#pragma warning disable CA1031 // Broad catch: a single switch's prime failure is logged and skipped.
+            catch (Exception ex)
+#pragma warning restore CA1031
+            {
+                LogSwitchPrimeFailed(logger, ex, sw.EntityId, key.Server);
+            }
+        }
+    }
+
+    private async Task PublishSwitchStateAsync(
+        (ulong Guild, Guid Server) key,
+        IRustServerConnection connection,
+        ulong entityId)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        try
+        {
+            var isActive = await connection
+                .GetSmartSwitchInfoAsync(entityId, _options.HeartbeatTimeout, _shutdown.Token)
+                .ConfigureAwait(false);
+            await eventBus.PublishAsync(
+                    new SwitchStateChangedEvent(key.Guild, key.Server, entityId, isActive ?? false),
+                    _shutdown.Token)
+                .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a switch publish failure must not crash the socket callback.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogSwitchPublishFailed(logger, ex, entityId, key.Server);
+        }
+    }
+
     [LoggerMessage(Level = LogLevel.Warning, Message = "Marker poll for server {ServerId} failed.")]
     private static partial void LogMarkerPollFailed(ILogger logger, Exception exception, Guid serverId);
 
@@ -748,6 +896,21 @@ private async Task PublishTeamMessageAsync((ulong Guild, Guid Server) key, ulong
         Message = "Publishing a received team message for server {ServerId} failed.")]
     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);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Priming smart switch {EntityId} on server {ServerId} failed.")]
+    private static partial void
+        LogSwitchPrimeFailed(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,
+        Exception exception,
+        ulong entityId,
+        Guid serverId);
+
     private TimeSpan NextDelay(TimeSpan delay) =>
         delay < _options.MaxRetryDelay
             ? TimeSpan.FromTicks(Math.Min(delay.Ticks * 2, _options.MaxRetryDelay.Ticks))
diff --git a/src/RustPlusBot.Features.Pairing/Listening/PairingNotification.cs b/src/RustPlusBot.Features.Pairing/Listening/PairingNotification.cs
index 73482a1..fca4029 100644
--- a/src/RustPlusBot.Features.Pairing/Listening/PairingNotification.cs
+++ b/src/RustPlusBot.Features.Pairing/Listening/PairingNotification.cs
@@ -30,10 +30,14 @@ internal enum PairingConnectOutcome
 /// <param name="Port">The Rust+ app port.</param>
 /// <param name="PlayerId">The paired player's Steam64 id.</param>
 /// <param name="PlayerToken">The Rust+ player token for this (server, player).</param>
+/// <param name="FacepunchServerId">The Facepunch server GUID this pairing is associated with.</param>
+/// <param name="EntityId">The in-game entity id for entity pairings; 0 for server pairings.</param>
 internal sealed record PairingNotification(
     PairingKind Kind,
     string ServerName,
     string Ip,
     int Port,
     ulong PlayerId,
-    string PlayerToken);
+    string PlayerToken,
+    Guid FacepunchServerId = default,
+    ulong EntityId = 0UL);
diff --git a/src/RustPlusBot.Features.Pairing/Listening/RustPlusFcmPairingSource.cs b/src/RustPlusBot.Features.Pairing/Listening/RustPlusFcmPairingSource.cs
index 3053958..39ad04c 100644
--- a/src/RustPlusBot.Features.Pairing/Listening/RustPlusFcmPairingSource.cs
+++ b/src/RustPlusBot.Features.Pairing/Listening/RustPlusFcmPairingSource.cs
@@ -68,6 +68,7 @@ public RustPlusFcmListener(
             _logger = logger;
             _fcm = new RustPlusFcm(credentials, persistentIds: null, options: null, loggerFactory: null);
             _fcm.OnServerPairing += OnServerPairing;
+            _fcm.OnSmartSwitchPairing += OnSmartSwitchPairing;
         }
 
         /// <inheritdoc />
@@ -99,6 +100,7 @@ public async Task<PairingConnectOutcome> ConnectAsync(TimeSpan timeout, Cancella
         public async ValueTask DisposeAsync()
         {
             _fcm.OnServerPairing -= OnServerPairing;
+            _fcm.OnSmartSwitchPairing -= OnSmartSwitchPairing;
             await _fcm.DisposeAsync().ConfigureAwait(false);
         }
 
@@ -122,8 +124,34 @@ private void OnServerPairing(object? sender, Notification<ServerEvent?> e)
                 Ip: e.Data.Ip ?? string.Empty,
                 Port: e.Data.Port,
                 PlayerId: e.PlayerId,
-                PlayerToken: e.PlayerToken.ToString(System.Globalization.CultureInfo.InvariantCulture));
+                PlayerToken: e.PlayerToken.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                FacepunchServerId: e.ServerId);
 
+            Dispatch(notification);
+        }
+
+        private void OnSmartSwitchPairing(object? sender, Notification<ulong?> e)
+        {
+            if (e?.Data is not { } entityId)
+            {
+                return; // null entity id → drop
+            }
+
+            var notification = new PairingNotification(
+                Kind: PairingKind.Entity,
+                ServerName: string.Empty,
+                Ip: string.Empty,
+                Port: 0,
+                PlayerId: e.PlayerId,
+                PlayerToken: e.PlayerToken.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                FacepunchServerId: e.ServerId,
+                EntityId: entityId);
+
+            Dispatch(notification);
+        }
+
+        private void Dispatch(PairingNotification notification)
+        {
             // Fire-and-forget bridge from synchronous event to async callback.
             // Exception must never propagate back into the package's event dispatcher.
 #pragma warning disable CA2008 // Task.Run without TaskScheduler: acceptable here; default is ThreadPool.
diff --git a/src/RustPlusBot.Features.Pairing/Pairing/PairingHandler.cs b/src/RustPlusBot.Features.Pairing/Pairing/PairingHandler.cs
index fe23448..346a145 100644
--- a/src/RustPlusBot.Features.Pairing/Pairing/PairingHandler.cs
+++ b/src/RustPlusBot.Features.Pairing/Pairing/PairingHandler.cs
@@ -25,9 +25,9 @@ public async Task HandleAsync(
         CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(notification);
-        if (notification.Kind != PairingKind.Server)
+        if (notification.Kind == PairingKind.Entity)
         {
-            LogIgnoringKind(logger, notification.Kind);
+            await HandleEntityAsync(guildId, notification, cancellationToken).ConfigureAwait(false);
             return;
         }
 
@@ -35,6 +35,14 @@ public async Task HandleAsync(
                 guildId, ownerUserId, notification.ServerName, notification.Ip, notification.Port, cancellationToken)
             .ConfigureAwait(false);
 
+        // Only backfill a real Facepunch GUID. Persisting Guid.Empty would make every server that paired
+        // without one share the same id, breaking GUID-based entity-pairing attribution.
+        if (notification.FacepunchServerId != Guid.Empty)
+        {
+            await servers.SetFacepunchServerIdAsync(server.Id, notification.FacepunchServerId, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
         await credentials.UpsertFromPairingAsync(
             new StoreCredentialRequest(guildId, server.Id, ownerUserId, notification.PlayerId,
                 notification.PlayerToken),
@@ -48,7 +56,27 @@ await eventBus.PublishAsync(new ServerRegisteredEvent(guildId, server.Id), cance
         }
     }
 
+    private async Task HandleEntityAsync(
+        ulong guildId,
+        PairingNotification notification,
+        CancellationToken cancellationToken)
+    {
+        var server = await servers
+            .GetByFacepunchServerIdAsync(guildId, notification.FacepunchServerId, cancellationToken)
+            .ConfigureAwait(false);
+        if (server is null)
+        {
+            // Never create a server from an entity pairing; an unknown Facepunch server is logged and dropped.
+            LogUnknownEntityServer(logger, notification.FacepunchServerId);
+            return;
+        }
+
+        await eventBus.PublishAsync(
+                new SwitchPairedEvent(guildId, server.Id, notification.EntityId), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     [LoggerMessage(Level = LogLevel.Debug,
-        Message = "Ignoring {Kind} pairing notification (deferred to a later subsystem).")]
-    private static partial void LogIgnoringKind(ILogger logger, PairingKind kind);
+        Message = "Dropping entity pairing for unknown Facepunch server {FacepunchServerId} (no matching server).")]
+    private static partial void LogUnknownEntityServer(ILogger logger, Guid facepunchServerId);
 }
diff --git a/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
new file mode 100644
index 0000000..1345944
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs
@@ -0,0 +1,133 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Switches.Pairing;
+using RustPlusBot.Features.Switches.Relaying;
+
+namespace RustPlusBot.Features.Switches.Hosting;
+
+/// <summary>Runs the switch-pairing loop and the switch-state/connection-status relay loop.</summary>
+/// <param name="eventBus">The in-process event bus.</param>
+/// <param name="coordinator">Handles paired switches.</param>
+/// <param name="relay">Re-renders switches on state/connection changes.</param>
+/// <param name="logger">The logger.</param>
+internal sealed partial class SwitchesHostedService(
+    IEventBus eventBus,
+    SwitchPairingCoordinator coordinator,
+    SwitchStateRelay relay,
+    ILogger<SwitchesHostedService> logger) : IHostedService, IDisposable
+{
+    private readonly CancellationTokenSource _cts = new();
+    private Task? _pairedLoop;
+    private Task? _stateLoop;
+    private Task? _statusLoop;
+
+    /// <inheritdoc />
+    public void Dispose() => _cts.Dispose();
+
+    /// <inheritdoc />
+    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);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        await _cts.CancelAsync().ConfigureAwait(false);
+        foreach (var loop in new[]
+                 {
+                     _pairedLoop, _stateLoop, _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<SwitchPairedEvent>(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 ConsumeStateAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await foreach (var evt in eventBus.SubscribeAsync<SwitchStateChangedEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                await relay.HandleStateChangedAsync(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
+        {
+            LogStateLoopFaulted(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 = "Switch pairing loop faulted.")]
+    private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Switch state relay loop faulted.")]
+    private static partial void LogStateLoopFaulted(ILogger logger, Exception exception);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Switch connection-status relay loop faulted.")]
+    private static partial void LogStatusLoopFaulted(ILogger logger, Exception exception);
+}
diff --git a/src/RustPlusBot.Features.Switches/Modules/SwitchComponentModule.cs b/src/RustPlusBot.Features.Switches/Modules/SwitchComponentModule.cs
new file mode 100644
index 0000000..ccc6f51
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Modules/SwitchComponentModule.cs
@@ -0,0 +1,217 @@
+using System.Globalization;
+using Discord;
+using Discord.Interactions;
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Switches.Pairing;
+using RustPlusBot.Features.Switches.Rendering;
+using RustPlusBot.Persistence.Switches;
+
+namespace RustPlusBot.Features.Switches.Modules;
+
+/// <summary>Thin handler for the #switches pairing prompt + control buttons + rename modal. Any guild member.</summary>
+/// <param name="scopeFactory">Creates a short-lived DI scope per interaction.</param>
+/// <param name="query">Live socket read/control.</param>
+/// <param name="eventBus">Publishes a state-changed event to drive an embed refresh.</param>
+public sealed class SwitchComponentModule(
+    IServiceScopeFactory scopeFactory,
+    IRustServerQuery query,
+    IEventBus eventBus) : InteractionModuleBase<SocketInteractionContext>
+{
+    /// <summary>Accepts a pending pairing prompt and starts managing the switch.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.AcceptPrefix + "*")]
+    public async Task AcceptAsync(string tail)
+    {
+        if (!TryParse(tail, out var serverId, out var entityId) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        await DeferAsync(ephemeral: true).ConfigureAwait(false);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var coordinator = scope.ServiceProvider.GetRequiredService<SwitchPairingCoordinator>();
+            var accepted = await coordinator
+                .TryAcceptAsync(Context.Guild.Id, serverId, entityId, Context.User.Id, CancellationToken.None)
+                .ConfigureAwait(false);
+            await FollowupAsync(accepted ? "Switch added." : "That switch is already managed.", ephemeral: true)
+                .ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>Dismisses a pending pairing prompt and removes the transient prompt message.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.DismissPrefix + "*")]
+    public async Task DismissAsync(string tail)
+    {
+        if (!TryParse(tail, out var serverId, out var entityId) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var coordinator = scope.ServiceProvider.GetRequiredService<SwitchPairingCoordinator>();
+            coordinator.TryDismiss(Context.Guild.Id, serverId, entityId);
+        }
+
+        // Delete the actual prompt message that hosts this button (the component interaction's source
+        // message) — not the ephemeral interaction response. Best-effort: a delete failure is non-fatal.
+        await DeletePromptMessageSafeAsync().ConfigureAwait(false);
+        await RespondAsync("Dismissed.", ephemeral: true).ConfigureAwait(false);
+    }
+
+    /// <summary>Turns the switch on.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.OnPrefix + "*")]
+    public Task OnAsync(string tail) => SetAsync(tail, value: true);
+
+    /// <summary>Turns the switch off.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.OffPrefix + "*")]
+    public Task OffAsync(string tail) => SetAsync(tail, value: false);
+
+    /// <summary>Strobes the switch on, then re-reads and publishes the settled state.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.StrobePrefix + "*")]
+    public async Task StrobeAsync(string tail)
+    {
+        if (!TryParse(tail, out var serverId, out var entityId) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        await DeferAsync(ephemeral: true).ConfigureAwait(false);
+        var ok = await query
+            .StrobeSmartSwitchAsync(Context.Guild.Id, serverId, entityId, timeoutMs: 1000, value: true,
+                CancellationToken.None)
+            .ConfigureAwait(false);
+        if (!ok)
+        {
+            await FollowupAsync("Switch is unreachable right now.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var state = await query.GetSmartSwitchStateAsync(Context.Guild.Id, serverId, entityId, CancellationToken.None)
+            .ConfigureAwait(false);
+        await eventBus
+            .PublishAsync(new SwitchStateChangedEvent(Context.Guild.Id, serverId, entityId, state ?? true))
+            .ConfigureAwait(false);
+        await FollowupAsync("Strobed.", ephemeral: true).ConfigureAwait(false);
+    }
+
+    /// <summary>Opens the rename modal, carrying the target tail in the modal custom id.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    [ComponentInteraction(SwitchComponentIds.RenamePrefix + "*")]
+    public async Task RenamePromptAsync(string tail)
+    {
+        if (!TryParse(tail, out _, out _) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        // The modal id carries the same tail so the submit handler can route.
+        await RespondWithModalAsync<SwitchRenameModal>(SwitchComponentIds.RenameModalPrefix + tail)
+            .ConfigureAwait(false);
+    }
+
+    /// <summary>Persists the new name, then publishes the current state so the embed refreshes.</summary>
+    /// <param name="tail">The "{serverId}:{entityId}" custom-id tail.</param>
+    /// <param name="modal">The submitted rename modal.</param>
+    [ModalInteraction(SwitchComponentIds.RenameModalPrefix + "*")]
+    public async Task RenameSubmitAsync(string tail, SwitchRenameModal modal)
+    {
+        ArgumentNullException.ThrowIfNull(modal);
+        if (!TryParse(tail, out var serverId, out var entityId) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var name = string.IsNullOrWhiteSpace(modal.Name)
+            ? "Switch " + entityId.ToString(CultureInfo.InvariantCulture)
+            : modal.Name.Trim();
+        await DeferAsync(ephemeral: true).ConfigureAwait(false);
+
+        bool isActive;
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            await store.RenameAsync(Context.Guild.Id, serverId, entityId, name, CancellationToken.None)
+                .ConfigureAwait(false);
+            var sw = await store.GetAsync(Context.Guild.Id, serverId, entityId, CancellationToken.None)
+                .ConfigureAwait(false);
+            isActive = sw?.LastIsActive ?? false;
+        }
+
+        await eventBus
+            .PublishAsync(new SwitchStateChangedEvent(Context.Guild.Id, serverId, entityId, isActive))
+            .ConfigureAwait(false);
+        await FollowupAsync("Renamed.", ephemeral: true).ConfigureAwait(false);
+    }
+
+    private async Task SetAsync(string tail, bool value)
+    {
+        if (!TryParse(tail, out var serverId, out var entityId) || Context.Guild is null)
+        {
+            await RespondAsync("That control wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        await DeferAsync(ephemeral: true).ConfigureAwait(false);
+        var ok = await query.SetSmartSwitchAsync(Context.Guild.Id, serverId, entityId, value, CancellationToken.None)
+            .ConfigureAwait(false);
+        if (!ok)
+        {
+            await FollowupAsync("Switch is unreachable right now.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        await eventBus.PublishAsync(new SwitchStateChangedEvent(Context.Guild.Id, serverId, entityId, value))
+            .ConfigureAwait(false);
+        await FollowupAsync(value ? "Turned on." : "Turned off.", ephemeral: true).ConfigureAwait(false);
+    }
+
+    private static bool TryParse(string tail, out Guid serverId, out ulong entityId)
+    {
+        serverId = Guid.Empty;
+        entityId = 0UL;
+        if (tail is null)
+        {
+            return false;
+        }
+
+        var parts = tail.Split(':');
+        return parts.Length == 2
+               && Guid.TryParse(parts[0], out serverId)
+               && ulong.TryParse(parts[1], NumberStyles.None, CultureInfo.InvariantCulture, out entityId);
+    }
+
+    private async Task DeletePromptMessageSafeAsync()
+    {
+        try
+        {
+            // The source message of a component interaction is the prompt that carries the button.
+            if (Context.Interaction is IComponentInteraction component)
+            {
+                await component.Message.DeleteAsync().ConfigureAwait(false);
+            }
+        }
+#pragma warning disable CA1031 // Best-effort prompt cleanup; a delete failure is non-fatal.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            // Ignore: the prompt is transient and harmless if it lingers.
+            _ = ex;
+        }
+    }
+}
diff --git a/src/RustPlusBot.Features.Switches/Modules/SwitchRenameModal.cs b/src/RustPlusBot.Features.Switches/Modules/SwitchRenameModal.cs
new file mode 100644
index 0000000..6d1e8bb
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Modules/SwitchRenameModal.cs
@@ -0,0 +1,17 @@
+using Discord;
+using Discord.Interactions;
+using RustPlusBot.Features.Switches.Rendering;
+
+namespace RustPlusBot.Features.Switches.Modules;
+
+/// <summary>The modal that collects a new switch name. Handled by <see cref="SwitchComponentModule"/>.</summary>
+public sealed class SwitchRenameModal : IModal
+{
+    /// <summary>The new name.</summary>
+    [InputLabel("Switch name")]
+    [ModalTextInput(SwitchComponentIds.RenameInputId, TextInputStyle.Short, maxLength: 128)]
+    public string Name { get; set; } = string.Empty;
+
+    /// <inheritdoc />
+    public string Title => "Rename switch";
+}
diff --git a/src/RustPlusBot.Features.Switches/Pairing/SwitchPairingCoordinator.cs b/src/RustPlusBot.Features.Switches/Pairing/SwitchPairingCoordinator.cs
new file mode 100644
index 0000000..694faf9
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Pairing/SwitchPairingCoordinator.cs
@@ -0,0 +1,142 @@
+using System.Collections.Concurrent;
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Switches.Posting;
+using RustPlusBot.Features.Switches.Rendering;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Switches;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Switches.Pairing;
+
+/// <summary>Turns a <see cref="SwitchPairedEvent"/> into an "Add it?" prompt and, on Accept, a managed switch.</summary>
+/// <param name="scopeFactory">Opens scopes for the scoped switch/workspace stores.</param>
+/// <param name="locator">Resolves the #switches channel id.</param>
+/// <param name="poster">Posts/edits switch + prompt messages.</param>
+/// <param name="renderer">Renders the prompt and switch embeds.</param>
+internal sealed class SwitchPairingCoordinator(
+    IServiceScopeFactory scopeFactory,
+    ISwitchChannelLocator locator,
+    ISwitchChannelPoster poster,
+    SwitchEmbedRenderer renderer)
+{
+    private readonly ConcurrentDictionary<(ulong Guild, Guid Server, ulong Entity), Pending> _pending = new();
+
+    /// <summary>Gets the held default name for a pending pairing, or null.</summary>
+    /// <param name="guildId">The guild id.</param>
+    /// <param name="serverId">The server id.</param>
+    /// <param name="entityId">The switch entity id.</param>
+    /// <returns>The held default name, or null when no pending pairing exists.</returns>
+    public string? PendingName(ulong guildId, Guid serverId, ulong entityId) =>
+        _pending.TryGetValue((guildId, serverId, entityId), out var p) ? p.DefaultName : null;
+
+    /// <summary>Handles a paired switch: ignore if already managed, else post the prompt and hold pending state.</summary>
+    /// <param name="evt">The paired-switch event.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>A task that completes when the prompt has been posted (or the switch was ignored).</returns>
+    public async Task HandlePairedAsync(SwitchPairedEvent evt, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        if (await ExistsAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken).ConfigureAwait(false))
+        {
+            return;
+        }
+
+        var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
+            .ConfigureAwait(false);
+        if (channelId is not { } channel)
+        {
+            return;
+        }
+
+        var culture = await GetCultureAsync(evt.GuildId, cancellationToken).ConfigureAwait(false);
+        var defaultName = $"Switch {evt.EntityId}";
+        var (embed, components) = renderer.RenderPrompt(evt.ServerId, evt.EntityId, defaultName, culture);
+        var messageId = await poster.EnsureAsync(channel, null, embed, components, cancellationToken)
+            .ConfigureAwait(false);
+        _pending[(evt.GuildId, evt.ServerId, evt.EntityId)] = new Pending(defaultName, messageId);
+    }
+
+    /// <summary>Accepts a pending pairing: persist + replace prompt with the switch embed. Race-guarded.</summary>
+    /// <param name="guildId">The guild id.</param>
+    /// <param name="serverId">The server id.</param>
+    /// <param name="entityId">The switch entity id.</param>
+    /// <param name="acceptingUserId">The id of the user who accepted the pairing.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>True when the switch was persisted; false when it was already managed (race).</returns>
+    public async Task<bool> TryAcceptAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        ulong acceptingUserId,
+        CancellationToken cancellationToken)
+    {
+        if (await ExistsAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false))
+        {
+            _pending.TryRemove((guildId, serverId, entityId), out _);
+            return false;
+        }
+
+        _pending.TryGetValue((guildId, serverId, entityId), out var pending);
+        var name = pending?.DefaultName ?? $"Switch {entityId}";
+
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            var added = await store.AddAsync(guildId, serverId, entityId, name, acceptingUserId, cancellationToken)
+                .ConfigureAwait(false);
+
+            var channelId = await locator.GetChannelIdAsync(guildId, serverId, cancellationToken).ConfigureAwait(false);
+            if (channelId is { } channel)
+            {
+                var culture = await GetCultureAsync(guildId, cancellationToken).ConfigureAwait(false);
+
+                // The switch is freshly accepted; state is unknown until the next prime/trigger, so render the
+                // persisted LastIsActive (defaults false). The supervisor's prime path republishes real state shortly.
+                var (embed, components) = renderer.RenderSwitch(added, isActive: added.LastIsActive, culture);
+                var newMessageId = await poster
+                    .EnsureAsync(channel, pending?.MessageId, embed, components, cancellationToken)
+                    .ConfigureAwait(false);
+                if (newMessageId is { } mid)
+                {
+                    await store.SetMessageIdAsync(guildId, serverId, entityId, mid, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+        }
+
+        _pending.TryRemove((guildId, serverId, entityId), out _);
+        return true;
+    }
+
+    /// <summary>Drops a pending pairing; returns whether one was present.</summary>
+    /// <param name="guildId">The guild id.</param>
+    /// <param name="serverId">The server id.</param>
+    /// <param name="entityId">The switch entity id.</param>
+    /// <returns>True when a pending pairing was removed; false when none was held.</returns>
+    public bool TryDismiss(ulong guildId, Guid serverId, ulong entityId) =>
+        _pending.TryRemove((guildId, serverId, entityId), out _);
+
+    private async Task<bool> ExistsAsync(ulong guildId, Guid serverId, ulong entityId, CancellationToken ct)
+    {
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            return await store.ExistsAsync(guildId, serverId, entityId, ct).ConfigureAwait(false);
+        }
+    }
+
+    private async Task<string> GetCultureAsync(ulong guildId, CancellationToken ct)
+    {
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
+            return await store.GetCultureAsync(guildId, ct).ConfigureAwait(false);
+        }
+    }
+
+    private sealed record Pending(string DefaultName, ulong? MessageId);
+}
diff --git a/src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs b/src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs
new file mode 100644
index 0000000..539b32e
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs
@@ -0,0 +1,86 @@
+using Discord.Net;
+using Discord.WebSocket;
+using Microsoft.Extensions.Logging;
+
+namespace RustPlusBot.Features.Switches.Posting;
+
+/// <summary>Posts/edits switch embeds in #switches by message id. Untested integration shim.</summary>
+/// <param name="client">The Discord socket client.</param>
+/// <param name="logger">The logger.</param>
+internal sealed partial class DiscordSwitchChannelPoster(
+    DiscordSocketClient client,
+    ILogger<DiscordSwitchChannelPoster> logger) : ISwitchChannelPoster
+{
+    /// <inheritdoc />
+    public async Task<ulong?> EnsureAsync(
+        ulong channelId,
+        ulong? messageId,
+        global::Discord.Embed embed,
+        global::Discord.MessageComponent components,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var options = new global::Discord.RequestOptions
+            {
+                CancelToken = cancellationToken
+            };
+            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false)
+                is not global::Discord.ITextChannel channel)
+            {
+                return null;
+            }
+
+            if (messageId is { } id)
+            {
+                // Inner try: some Discord.Net versions THROW (HttpException 404/Unknown Message)
+                // rather than return null for a deleted message. Catch it and fall through to repost
+                // so the self-heal path always runs.
+                try
+                {
+                    var existing = await channel.GetMessageAsync(id, options: options).ConfigureAwait(false);
+                    if (existing is global::Discord.IUserMessage userMessage)
+                    {
+                        await userMessage.ModifyAsync(m =>
+                        {
+                            m.Embed = embed;
+                            m.Components = components;
+                        }, options).ConfigureAwait(false);
+                        return userMessage.Id;
+                    }
+
+                    // Message was deleted (returned null / not a user message); fall through to repost.
+                }
+                catch (HttpException ex) when (ex.HttpCode == System.Net.HttpStatusCode.NotFound)
+                {
+                    // Deleted/unknown message; fall through to repost and return the new id.
+                    LogMessageMissing(logger, ex, channelId, id);
+                }
+            }
+
+            var posted = await channel
+                .SendMessageAsync(embed: embed, options: options, components: components)
+                .ConfigureAwait(false);
+            return posted.Id;
+        }
+        catch (OperationCanceledException)
+        {
+            throw; // Shutdown — let the loop unwind.
+        }
+#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay; report failure as null.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogEnsureFailed(logger, ex, channelId);
+            return null;
+        }
+    }
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Posting/editing a switch embed in channel {ChannelId} failed.")]
+    private static partial void LogEnsureFailed(ILogger logger, Exception exception, ulong channelId);
+
+    [LoggerMessage(Level = LogLevel.Debug,
+        Message = "Switch embed {MessageId} in channel {ChannelId} was deleted; reposting.")]
+    private static partial void
+        LogMessageMissing(ILogger logger, Exception exception, ulong channelId, ulong messageId);
+}
diff --git a/src/RustPlusBot.Features.Switches/Posting/ISwitchChannelPoster.cs b/src/RustPlusBot.Features.Switches/Posting/ISwitchChannelPoster.cs
new file mode 100644
index 0000000..e0f34f4
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Posting/ISwitchChannelPoster.cs
@@ -0,0 +1,19 @@
+namespace RustPlusBot.Features.Switches.Posting;
+
+/// <summary>Posts/edits a switch embed in #switches by message id, self-healing a deleted message.</summary>
+internal interface ISwitchChannelPoster
+{
+    /// <summary>Edits the message at <paramref name="messageId"/> if present and found; otherwise posts a new one.</summary>
+    /// <param name="channelId">The #switches channel id.</param>
+    /// <param name="messageId">The known embed message id, or null to post fresh.</param>
+    /// <param name="embed">The embed to show.</param>
+    /// <param name="components">The control row.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The (possibly new) message id, or null on failure.</returns>
+    Task<ulong?> EnsureAsync(
+        ulong channelId,
+        ulong? messageId,
+        global::Discord.Embed embed,
+        global::Discord.MessageComponent components,
+        CancellationToken cancellationToken);
+}
diff --git a/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs b/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs
new file mode 100644
index 0000000..d9b3e02
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Relaying/SwitchStateRelay.cs
@@ -0,0 +1,124 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Domain.Connections;
+using RustPlusBot.Domain.Switches;
+using RustPlusBot.Features.Switches.Posting;
+using RustPlusBot.Features.Switches.Rendering;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Persistence.Switches;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Switches.Relaying;
+
+/// <summary>Keeps switch embeds in sync: live state changes re-render; a non-Connected server marks them unreachable.</summary>
+/// <param name="scopeFactory">Opens scopes for the scoped stores.</param>
+/// <param name="locator">Resolves the #switches channel id.</param>
+/// <param name="poster">Posts/edits switch embeds.</param>
+/// <param name="renderer">Renders switch embeds.</param>
+internal sealed class SwitchStateRelay(
+    IServiceScopeFactory scopeFactory,
+    ISwitchChannelLocator locator,
+    ISwitchChannelPoster poster,
+    SwitchEmbedRenderer renderer)
+{
+    /// <summary>Handles a live state change: persist + re-render the switch's embed.</summary>
+    /// <param name="evt">The switch state change.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the embed has been re-rendered.</returns>
+    public async Task HandleStateChangedAsync(SwitchStateChangedEvent evt, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            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>
+    /// <returns>A task that completes when every affected embed has been re-rendered.</returns>
+    public async Task HandleConnectionStatusAsync(
+        ConnectionStatusChangedEvent evt,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var connections = scope.ServiceProvider.GetRequiredService<IConnectionStore>();
+            var state = await connections.GetStateAsync(evt.GuildId, evt.ServerId, cancellationToken)
+                .ConfigureAwait(false);
+            if (state is { Status: ConnectionStatus.Connected })
+            {
+                // The supervisor's prime path republishes real state on connect; nothing to do here.
+                return;
+            }
+
+            var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+            var switches = await store.ListByServerAsync(evt.GuildId, evt.ServerId, cancellationToken)
+                .ConfigureAwait(false);
+            if (switches.Count == 0)
+            {
+                return;
+            }
+
+            var culture = await GetCultureAsync(scope.ServiceProvider, evt.GuildId, cancellationToken)
+                .ConfigureAwait(false);
+            foreach (var sw in switches)
+            {
+                await RenderAsync(store, sw, isActive: null, evt.GuildId, evt.ServerId, culture, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    private async Task RenderAsync(
+        ISwitchStore store,
+        SmartSwitch sw,
+        bool? isActive,
+        ulong guildId,
+        Guid serverId,
+        string culture,
+        CancellationToken cancellationToken)
+    {
+        var channelId = await locator.GetChannelIdAsync(guildId, serverId, cancellationToken).ConfigureAwait(false);
+        if (channelId is not { } channel)
+        {
+            return;
+        }
+
+        var (embed, components) = renderer.RenderSwitch(sw, isActive, culture);
+        var newMessageId = await poster.EnsureAsync(channel, sw.MessageId, embed, components, cancellationToken)
+            .ConfigureAwait(false);
+        if (newMessageId is { } mid && mid != sw.MessageId)
+        {
+            await store.SetMessageIdAsync(guildId, serverId, sw.EntityId, mid, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    private static async Task<string> GetCultureAsync(
+        IServiceProvider provider,
+        ulong guildId,
+        CancellationToken cancellationToken)
+    {
+        var store = provider.GetRequiredService<IWorkspaceStore>();
+        return await store.GetCultureAsync(guildId, cancellationToken).ConfigureAwait(false);
+    }
+}
diff --git a/src/RustPlusBot.Features.Switches/Rendering/ISwitchLocalizer.cs b/src/RustPlusBot.Features.Switches/Rendering/ISwitchLocalizer.cs
new file mode 100644
index 0000000..c274dab
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Rendering/ISwitchLocalizer.cs
@@ -0,0 +1,16 @@
+namespace RustPlusBot.Features.Switches.Rendering;
+
+/// <summary>Resolves localized smart-switch strings by key and culture, falling back to English.</summary>
+internal interface ISwitchLocalizer
+{
+    /// <summary>Gets the localized string for a key, or the key itself if not found.</summary>
+    /// <param name="key">The string key.</param>
+    /// <param name="culture">The BCP-47 culture tag (e.g. "en", "fr").</param>
+    string Get(string key, string culture);
+
+    /// <summary>Gets the localized, format-applied string.</summary>
+    /// <param name="key">The string key.</param>
+    /// <param name="culture">The BCP-47 culture tag.</param>
+    /// <param name="args">Format arguments.</param>
+    string Get(string key, string culture, params object[] args);
+}
diff --git a/src/RustPlusBot.Features.Switches/Rendering/SwitchComponentIds.cs b/src/RustPlusBot.Features.Switches/Rendering/SwitchComponentIds.cs
new file mode 100644
index 0000000..8e17d55
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Rendering/SwitchComponentIds.cs
@@ -0,0 +1,29 @@
+namespace RustPlusBot.Features.Switches.Rendering;
+
+/// <summary>Custom ids for switch components. Tails encode "{serverId}:{entityId}".</summary>
+internal static class SwitchComponentIds
+{
+    /// <summary>Pairing-prompt Accept button; tail "{serverId}:{entityId}".</summary>
+    public const string AcceptPrefix = "switch:accept:";
+
+    /// <summary>Pairing-prompt Dismiss button; tail "{serverId}:{entityId}".</summary>
+    public const string DismissPrefix = "switch:dismiss:";
+
+    /// <summary>Turn-on button; tail "{serverId}:{entityId}".</summary>
+    public const string OnPrefix = "switch:on:";
+
+    /// <summary>Turn-off button; tail "{serverId}:{entityId}".</summary>
+    public const string OffPrefix = "switch:off:";
+
+    /// <summary>Strobe button; tail "{serverId}:{entityId}".</summary>
+    public const string StrobePrefix = "switch:strobe:";
+
+    /// <summary>Rename button (opens the modal); tail "{serverId}:{entityId}".</summary>
+    public const string RenamePrefix = "switch:rename:";
+
+    /// <summary>Rename modal id; tail "{serverId}:{entityId}".</summary>
+    public const string RenameModalPrefix = "switch:rename:modal:";
+
+    /// <summary>The rename modal's text input id.</summary>
+    public const string RenameInputId = "switch:rename:input";
+}
diff --git a/src/RustPlusBot.Features.Switches/Rendering/SwitchEmbedRenderer.cs b/src/RustPlusBot.Features.Switches/Rendering/SwitchEmbedRenderer.cs
new file mode 100644
index 0000000..efdcc70
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Rendering/SwitchEmbedRenderer.cs
@@ -0,0 +1,74 @@
+using Discord;
+using RustPlusBot.Domain.Switches;
+
+namespace RustPlusBot.Features.Switches.Rendering;
+
+/// <summary>Renders a Smart Switch as a Discord embed + control row, and the pairing-prompt embed + row. Pure.</summary>
+/// <param name="localizer">The switch localizer.</param>
+internal sealed class SwitchEmbedRenderer(ISwitchLocalizer localizer)
+{
+    /// <summary>Renders the switch embed and its control buttons. <paramref name="isActive"/> null ⇒ unreachable.</summary>
+    /// <param name="sw">The switch.</param>
+    /// <param name="isActive">On (true), off (false), or unreachable (null).</param>
+    /// <param name="culture">The guild culture.</param>
+    /// <returns>The embed and the component rows.</returns>
+    public (Embed Embed, MessageComponent Components) RenderSwitch(SmartSwitch sw, bool? isActive, string culture)
+    {
+        ArgumentNullException.ThrowIfNull(sw);
+        var unreachable = isActive is null;
+        var statusKey = isActive switch
+        {
+            true => "switch.status.on",
+            false => "switch.status.off",
+            null => "switch.status.unreachable",
+        };
+
+        var embed = new EmbedBuilder()
+            .WithTitle(sw.Name)
+            .WithDescription(localizer.Get(statusKey, culture))
+            .WithFooter(localizer.Get("switch.embed.footer", culture, sw.EntityId))
+            .Build();
+
+        var tail = $"{sw.ServerId}:{sw.EntityId}";
+        var components = new ComponentBuilder()
+            .WithButton(localizer.Get("switch.button.on", culture), SwitchComponentIds.OnPrefix + tail,
+                ButtonStyle.Success, disabled: unreachable || isActive == true)
+            .WithButton(localizer.Get("switch.button.off", culture), SwitchComponentIds.OffPrefix + tail,
+                ButtonStyle.Secondary, disabled: unreachable || isActive == false)
+            .WithButton(localizer.Get("switch.button.strobe", culture), SwitchComponentIds.StrobePrefix + tail,
+                ButtonStyle.Primary, disabled: unreachable)
+            .WithButton(localizer.Get("switch.button.rename", culture), SwitchComponentIds.RenamePrefix + tail,
+                ButtonStyle.Secondary, disabled: unreachable)
+            .Build();
+
+        return (embed, components);
+    }
+
+    /// <summary>Renders the transient "New switch detected — Add it?" prompt.</summary>
+    /// <param name="serverId">The server id.</param>
+    /// <param name="entityId">The entity id.</param>
+    /// <param name="defaultName">The generated default name.</param>
+    /// <param name="culture">The guild culture.</param>
+    /// <returns>The prompt embed and Accept/Dismiss row.</returns>
+    public (Embed Embed, MessageComponent Components) RenderPrompt(
+        Guid serverId,
+        ulong entityId,
+        string defaultName,
+        string culture)
+    {
+        var embed = new EmbedBuilder()
+            .WithTitle(localizer.Get("switch.prompt.title", culture))
+            .WithDescription(localizer.Get("switch.prompt.body", culture, defaultName))
+            .Build();
+
+        var tail = $"{serverId}:{entityId}";
+        var components = new ComponentBuilder()
+            .WithButton(localizer.Get("switch.prompt.accept", culture), SwitchComponentIds.AcceptPrefix + tail,
+                ButtonStyle.Success)
+            .WithButton(localizer.Get("switch.prompt.dismiss", culture), SwitchComponentIds.DismissPrefix + tail,
+                ButtonStyle.Secondary)
+            .Build();
+
+        return (embed, components);
+    }
+}
diff --git a/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizationCatalog.cs b/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizationCatalog.cs
new file mode 100644
index 0000000..fe050a0
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizationCatalog.cs
@@ -0,0 +1,54 @@
+namespace RustPlusBot.Features.Switches.Rendering;
+
+/// <summary>The in-memory string catalog for Smart Switches: culture -> (key -> value). English is the fallback.</summary>
+internal sealed class SwitchLocalizationCatalog
+{
+    /// <summary>culture -> key -> value.</summary>
+    public required IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> Strings { get; init; }
+
+    /// <summary>The built-in EN/FR catalog.</summary>
+    public static SwitchLocalizationCatalog Default { get; } = new()
+    {
+        Strings = new Dictionary<string, IReadOnlyDictionary<string, string>>(StringComparer.Ordinal)
+        {
+            ["en"] = new Dictionary<string, string>(StringComparer.Ordinal)
+            {
+                ["switch.status.on"] = "⚡ ON",
+                ["switch.status.off"] = "⭘ OFF",
+                ["switch.status.unreachable"] = "⚠️ Unreachable",
+                ["switch.button.on"] = "Turn on",
+                ["switch.button.off"] = "Turn off",
+                ["switch.button.strobe"] = "Strobe",
+                ["switch.button.rename"] = "Rename",
+                ["switch.embed.footer"] = "Entity {0}",
+                ["switch.prompt.title"] = "New switch detected",
+                ["switch.prompt.body"] = "Detected a new Smart Switch ({0}). Add it?",
+                ["switch.prompt.accept"] = "Accept",
+                ["switch.prompt.dismiss"] = "Dismiss",
+                ["switch.prompt.dismissed"] = "Dismissed.",
+                ["switch.rename.modal.title"] = "Rename switch",
+                ["switch.rename.input.label"] = "Switch name",
+                ["switch.unreachable.ephemeral"] = "Switch is unreachable right now.",
+            },
+            ["fr"] = new Dictionary<string, string>(StringComparer.Ordinal)
+            {
+                ["switch.status.on"] = "⚡ ALLUMÉ",
+                ["switch.status.off"] = "⭘ ÉTEINT",
+                ["switch.status.unreachable"] = "⚠️ Injoignable",
+                ["switch.button.on"] = "Allumer",
+                ["switch.button.off"] = "Éteindre",
+                ["switch.button.strobe"] = "Stroboscope",
+                ["switch.button.rename"] = "Renommer",
+                ["switch.embed.footer"] = "Entité {0}",
+                ["switch.prompt.title"] = "Nouvel interrupteur détecté",
+                ["switch.prompt.body"] = "Nouvel interrupteur connecté détecté ({0}). L'ajouter ?",
+                ["switch.prompt.accept"] = "Accepter",
+                ["switch.prompt.dismiss"] = "Ignorer",
+                ["switch.prompt.dismissed"] = "Ignoré.",
+                ["switch.rename.modal.title"] = "Renommer l'interrupteur",
+                ["switch.rename.input.label"] = "Nom de l'interrupteur",
+                ["switch.unreachable.ephemeral"] = "L'interrupteur est injoignable pour le moment.",
+            },
+        },
+    };
+}
diff --git a/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizer.cs b/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizer.cs
new file mode 100644
index 0000000..95bd080
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/Rendering/SwitchLocalizer.cs
@@ -0,0 +1,61 @@
+using System.Globalization;
+
+namespace RustPlusBot.Features.Switches.Rendering;
+
+/// <summary>Dictionary-backed <see cref="ISwitchLocalizer"/> with English fallback and region normalization.</summary>
+/// <remarks>Duplicated from the command/workspace localizers; consolidate into a shared project in a future refactor.</remarks>
+/// <param name="catalog">The string catalog.</param>
+internal sealed class SwitchLocalizer(SwitchLocalizationCatalog catalog) : ISwitchLocalizer
+{
+    private const string FallbackCulture = "en";
+
+    /// <inheritdoc />
+    public string Get(string key, string culture)
+    {
+        var normalized = Normalize(culture);
+        if (catalog.Strings.TryGetValue(normalized, out var map) && map.TryGetValue(key, out var value))
+        {
+            return value;
+        }
+
+        if (catalog.Strings.TryGetValue(FallbackCulture, out var fallback) &&
+            fallback.TryGetValue(key, out var fallbackValue))
+        {
+            return fallbackValue;
+        }
+
+        return key;
+    }
+
+    /// <inheritdoc />
+    public string Get(string key, string culture, params object[] args)
+    {
+        var format = Get(key, culture);
+        var provider = ResolveFormatProvider(Normalize(culture));
+        return string.Format(provider, format, args);
+    }
+
+    private static string Normalize(string culture)
+    {
+        if (string.IsNullOrWhiteSpace(culture))
+        {
+            return FallbackCulture;
+        }
+
+        var dash = culture.IndexOf('-', StringComparison.Ordinal);
+        var primary = dash >= 0 ? culture[..dash] : culture;
+        return primary.ToLowerInvariant();
+    }
+
+    private static CultureInfo ResolveFormatProvider(string culture)
+    {
+        try
+        {
+            return CultureInfo.GetCultureInfo(culture);
+        }
+        catch (CultureNotFoundException)
+        {
+            return CultureInfo.InvariantCulture;
+        }
+    }
+}
diff --git a/src/RustPlusBot.Features.Switches/RustPlusBot.Features.Switches.csproj b/src/RustPlusBot.Features.Switches/RustPlusBot.Features.Switches.csproj
new file mode 100644
index 0000000..7ac83d0
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/RustPlusBot.Features.Switches.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="RustPlusBot.Features.Switches.Tests" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\RustPlusBot.Abstractions\RustPlusBot.Abstractions.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Persistence\RustPlusBot.Persistence.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Discord\RustPlusBot.Discord.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Domain\RustPlusBot.Domain.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Features.Workspace\RustPlusBot.Features.Workspace.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Features.Connections\RustPlusBot.Features.Connections.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Discord.Net" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/RustPlusBot.Features.Switches/SwitchServiceCollectionExtensions.cs b/src/RustPlusBot.Features.Switches/SwitchServiceCollectionExtensions.cs
new file mode 100644
index 0000000..fa17e8f
--- /dev/null
+++ b/src/RustPlusBot.Features.Switches/SwitchServiceCollectionExtensions.cs
@@ -0,0 +1,34 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Discord;
+using RustPlusBot.Features.Switches.Hosting;
+using RustPlusBot.Features.Switches.Pairing;
+using RustPlusBot.Features.Switches.Posting;
+using RustPlusBot.Features.Switches.Relaying;
+using RustPlusBot.Features.Switches.Rendering;
+
+namespace RustPlusBot.Features.Switches;
+
+/// <summary>DI registration for the Smart Switches feature.</summary>
+public static class SwitchServiceCollectionExtensions
+{
+    /// <summary>Registers the localizer, renderer, poster, 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 AddSwitches(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddSingleton(SwitchLocalizationCatalog.Default);
+        services.AddSingleton<ISwitchLocalizer, SwitchLocalizer>();
+        services.AddSingleton<SwitchEmbedRenderer>();
+        services.AddSingleton<ISwitchChannelPoster, DiscordSwitchChannelPoster>();
+        services.AddSingleton<SwitchPairingCoordinator>();
+        services.AddSingleton<SwitchStateRelay>();
+        services.AddHostedService<SwitchesHostedService>();
+
+        // Contribute this assembly's interaction modules to the Discord layer.
+        services.AddSingleton(new InteractionModuleAssembly(typeof(SwitchServiceCollectionExtensions).Assembly));
+
+        return services;
+    }
+}
diff --git a/src/RustPlusBot.Features.Workspace/Localization/LocalizationCatalog.cs b/src/RustPlusBot.Features.Workspace/Localization/LocalizationCatalog.cs
index 699ffe6..631e0f6 100644
--- a/src/RustPlusBot.Features.Workspace/Localization/LocalizationCatalog.cs
+++ b/src/RustPlusBot.Features.Workspace/Localization/LocalizationCatalog.cs
@@ -21,6 +21,7 @@ internal sealed class LocalizationCatalog
                 ["channel.teamchat.name"] = "teamchat",
                 ["channel.events.name"] = "events",
                 ["channel.map.name"] = "map",
+                ["channel.switches.name"] = "switches",
                 ["information.title"] = "RustPlusBot",
                 ["information.body"] = "Connect your Rust+ account in #setup, then pair a server in-game to begin.",
                 ["information.servers"] = "Servers registered: {0}",
@@ -63,6 +64,7 @@ internal sealed class LocalizationCatalog
                 ["channel.teamchat.name"] = "tchat-equipe",
                 ["channel.events.name"] = "evenements",
                 ["channel.map.name"] = "carte",
+                ["channel.switches.name"] = "interrupteurs",
                 ["information.title"] = "RustPlusBot",
                 ["information.body"] =
                     "Connectez votre compte Rust+ dans #configuration, puis appairez un serveur en jeu.",
diff --git a/src/RustPlusBot.Features.Workspace/Locating/ISwitchChannelLocator.cs b/src/RustPlusBot.Features.Workspace/Locating/ISwitchChannelLocator.cs
new file mode 100644
index 0000000..88fc24e
--- /dev/null
+++ b/src/RustPlusBot.Features.Workspace/Locating/ISwitchChannelLocator.cs
@@ -0,0 +1,12 @@
+namespace RustPlusBot.Features.Workspace.Locating;
+
+/// <summary>Resolves the per-server #switches channel (used to post/edit switch embeds).</summary>
+public interface ISwitchChannelLocator
+{
+    /// <summary>Gets the Discord channel id of #switches for (<paramref name="guildId"/>, <paramref name="serverId"/>), or null.</summary>
+    /// <param name="guildId">The guild snowflake.</param>
+    /// <param name="serverId">The server id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The Discord channel id, or null if not provisioned.</returns>
+    Task<ulong?> GetChannelIdAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken);
+}
diff --git a/src/RustPlusBot.Features.Workspace/Locating/SwitchChannelLocator.cs b/src/RustPlusBot.Features.Workspace/Locating/SwitchChannelLocator.cs
new file mode 100644
index 0000000..3bcb8c1
--- /dev/null
+++ b/src/RustPlusBot.Features.Workspace/Locating/SwitchChannelLocator.cs
@@ -0,0 +1,75 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Workspace.Locating;
+
+/// <summary>
+/// Caches the small set of provisioned #switches channels (rebuilt when the cache goes stale) and resolves
+/// (guild, server) → channel id for posting/editing switch embeds.
+/// </summary>
+/// <param name="scopeFactory">Opens scopes for the scoped workspace store.</param>
+/// <param name="clock">Drives the cache TTL.</param>
+internal sealed class SwitchChannelLocator(IServiceScopeFactory scopeFactory, IClock clock)
+    : ISwitchChannelLocator, IDisposable
+{
+    private static readonly TimeSpan CacheTtl = TimeSpan.FromSeconds(30);
+    private readonly SemaphoreSlim _refreshGate = new(1, 1);
+
+    private DateTimeOffset _builtAt = DateTimeOffset.MinValue;
+
+    private Dictionary<(ulong GuildId, Guid ServerId), ulong> _byServer = new();
+
+    /// <inheritdoc />
+    public void Dispose() => _refreshGate.Dispose();
+
+    /// <inheritdoc />
+    public async Task<ulong?> GetChannelIdAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken)
+    {
+        await EnsureFreshAsync(cancellationToken).ConfigureAwait(false);
+        return _byServer.TryGetValue((guildId, serverId), out var id) ? id : null;
+    }
+
+    private async Task EnsureFreshAsync(CancellationToken cancellationToken)
+    {
+        if (clock.UtcNow - _builtAt < CacheTtl)
+        {
+            return;
+        }
+
+        await _refreshGate.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            if (clock.UtcNow - _builtAt < CacheTtl)
+            {
+                return;
+            }
+
+            var scope = scopeFactory.CreateAsyncScope();
+            await using (scope.ConfigureAwait(false))
+            {
+                var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
+                var rows = await store.GetChannelsByKeyAsync(WorkspaceChannelKeys.ServerSwitches, cancellationToken)
+                    .ConfigureAwait(false);
+
+                var byServer = new Dictionary<(ulong GuildId, Guid ServerId), ulong>();
+                foreach (var row in rows)
+                {
+                    if (row.RustServerId is not { } serverId)
+                    {
+                        continue;
+                    }
+
+                    byServer[(row.GuildId, serverId)] = row.DiscordChannelId;
+                }
+
+                _byServer = byServer;
+                _builtAt = clock.UtcNow;
+            }
+        }
+        finally
+        {
+            _refreshGate.Release();
+        }
+    }
+}
diff --git a/src/RustPlusBot.Features.Workspace/Specs/ServerWorkspaceSpecProvider.cs b/src/RustPlusBot.Features.Workspace/Specs/ServerWorkspaceSpecProvider.cs
index 479321f..723b04f 100644
--- a/src/RustPlusBot.Features.Workspace/Specs/ServerWorkspaceSpecProvider.cs
+++ b/src/RustPlusBot.Features.Workspace/Specs/ServerWorkspaceSpecProvider.cs
@@ -16,6 +16,8 @@ public IEnumerable<ChannelSpec> GetChannelSpecs() =>
             ChannelPermissionProfile.ReadOnly, 2),
         new(WorkspaceScope.PerServer, WorkspaceChannelKeys.ServerMap, "channel.map.name",
             ChannelPermissionProfile.ReadOnly, 3),
+        new(WorkspaceScope.PerServer, WorkspaceChannelKeys.ServerSwitches, "channel.switches.name",
+            ChannelPermissionProfile.Interactive, 4),
     ];
 
     /// <inheritdoc />
diff --git a/src/RustPlusBot.Features.Workspace/WorkspaceKeys.cs b/src/RustPlusBot.Features.Workspace/WorkspaceKeys.cs
index 0c05d8b..bd78212 100644
--- a/src/RustPlusBot.Features.Workspace/WorkspaceKeys.cs
+++ b/src/RustPlusBot.Features.Workspace/WorkspaceKeys.cs
@@ -23,6 +23,9 @@ internal static class WorkspaceChannelKeys
 
     /// <summary>The per-server rendered-map channel.</summary>
     public const string ServerMap = "map";
+
+    /// <summary>Key for the per-server #switches channel.</summary>
+    public const string ServerSwitches = "switches";
 }
 
 /// <summary>Stable message keys persisted as <c>ProvisionedMessage.MessageKey</c>.</summary>
diff --git a/src/RustPlusBot.Features.Workspace/WorkspaceServiceCollectionExtensions.cs b/src/RustPlusBot.Features.Workspace/WorkspaceServiceCollectionExtensions.cs
index 42deaf1..f444261 100644
--- a/src/RustPlusBot.Features.Workspace/WorkspaceServiceCollectionExtensions.cs
+++ b/src/RustPlusBot.Features.Workspace/WorkspaceServiceCollectionExtensions.cs
@@ -62,6 +62,7 @@ public static IServiceCollection AddWorkspace(this IServiceCollection services)
         services.AddSingleton<ITeamChatChannelLocator, TeamChatChannelLocator>();
         services.AddSingleton<IEventChannelLocator, EventChannelLocator>();
         services.AddSingleton<IMapChannelLocator, MapChannelLocator>();
+        services.AddSingleton<ISwitchChannelLocator, SwitchChannelLocator>();
 
         services.AddHostedService<Hosting.WorkspaceHostedService>();
 
diff --git a/src/RustPlusBot.Host/Program.cs b/src/RustPlusBot.Host/Program.cs
index e2ce689..63bddd9 100644
--- a/src/RustPlusBot.Host/Program.cs
+++ b/src/RustPlusBot.Host/Program.cs
@@ -11,6 +11,7 @@
 using RustPlusBot.Features.Connections;
 using RustPlusBot.Features.Events;
 using RustPlusBot.Features.Map;
+using RustPlusBot.Features.Switches;
 using RustPlusBot.Features.Players;
 using RustPlusBot.Features.Pairing;
 using RustPlusBot.Features.Workspace;
@@ -75,6 +76,7 @@
     .Validate(static o => o.MapRefreshInterval > TimeSpan.Zero, "Map:MapRefreshInterval must be positive.")
     .ValidateOnStart();
 builder.Services.AddMap();
+builder.Services.AddSwitches();
 
 var host = builder.Build();
 
diff --git a/src/RustPlusBot.Host/RustPlusBot.Host.csproj b/src/RustPlusBot.Host/RustPlusBot.Host.csproj
index 313203a..14df6e2 100644
--- a/src/RustPlusBot.Host/RustPlusBot.Host.csproj
+++ b/src/RustPlusBot.Host/RustPlusBot.Host.csproj
@@ -24,6 +24,7 @@
     <ProjectReference Include="..\RustPlusBot.Features.Chat\RustPlusBot.Features.Chat.csproj" />
     <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.Map\RustPlusBot.Features.Map.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Players\RustPlusBot.Features.Players.csproj" />
   </ItemGroup>
diff --git a/src/RustPlusBot.Persistence/BotDbContext.cs b/src/RustPlusBot.Persistence/BotDbContext.cs
index 6090e30..7bb1aa7 100644
--- a/src/RustPlusBot.Persistence/BotDbContext.cs
+++ b/src/RustPlusBot.Persistence/BotDbContext.cs
@@ -8,6 +8,7 @@
 using RustPlusBot.Domain.Guilds;
 using RustPlusBot.Domain.Map;
 using RustPlusBot.Domain.Servers;
+using RustPlusBot.Domain.Switches;
 using RustPlusBot.Domain.Workspace;
 using RustPlusBot.Persistence.Configurations;
 
@@ -44,6 +45,9 @@ public sealed class BotDbContext(DbContextOptions<BotDbContext> options) : Disco
     /// <summary>Paired smart devices.</summary>
     public DbSet<PairedEntity> PairedEntities => Set<PairedEntity>();
 
+    /// <summary>Paired and managed Smart Switches.</summary>
+    public DbSet<SmartSwitch> SmartSwitches => Set<SmartSwitch>();
+
     /// <summary>Per-guild event subscriptions.</summary>
     public DbSet<EventSubscription> EventSubscriptions => Set<EventSubscription>();
 
@@ -71,6 +75,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             .ApplyConfiguration(new ServerMapSettingsConfiguration())
             .ApplyConfiguration(new GuildSettingsConfiguration())
             .ApplyConfiguration(new PairedEntityConfiguration())
+            .ApplyConfiguration(new SmartSwitchConfiguration())
             .ApplyConfiguration(new EventSubscriptionConfiguration())
             .ApplyConfiguration(new ProvisionedCategoryConfiguration())
             .ApplyConfiguration(new ProvisionedChannelConfiguration())
diff --git a/src/RustPlusBot.Persistence/Configurations/RustServerConfiguration.cs b/src/RustPlusBot.Persistence/Configurations/RustServerConfiguration.cs
index 6925d71..cce8d51 100644
--- a/src/RustPlusBot.Persistence/Configurations/RustServerConfiguration.cs
+++ b/src/RustPlusBot.Persistence/Configurations/RustServerConfiguration.cs
@@ -17,5 +17,6 @@ public void Configure(EntityTypeBuilder<RustServer> builder)
         {
             s.GuildId, s.Ip, s.Port
         }).IsUnique();
+        builder.HasIndex(s => s.FacepunchServerId);
     }
 }
diff --git a/src/RustPlusBot.Persistence/Configurations/SmartSwitchConfiguration.cs b/src/RustPlusBot.Persistence/Configurations/SmartSwitchConfiguration.cs
new file mode 100644
index 0000000..079b0f9
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Configurations/SmartSwitchConfiguration.cs
@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Domain.Switches;
+
+namespace RustPlusBot.Persistence.Configurations;
+
+internal sealed class SmartSwitchConfiguration : IEntityTypeConfiguration<SmartSwitch>
+{
+    public void Configure(EntityTypeBuilder<SmartSwitch> builder)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        builder.HasKey(s => s.Id);
+        builder.Property(s => s.Name).IsRequired().HasMaxLength(128);
+        builder.HasIndex(s => new
+        {
+            s.GuildId, s.ServerId, s.EntityId
+        }).IsUnique();
+
+        // Removing a RustServer cascades to its switches so no orphaned rows linger.
+        builder.HasOne<RustServer>()
+            .WithMany()
+            .HasForeignKey(s => s.ServerId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
diff --git a/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.Designer.cs b/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.Designer.cs
new file mode 100644
index 0000000..23149bc
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.Designer.cs
@@ -0,0 +1,595 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RustPlusBot.Persistence;
+
+#nullable disable
+
+namespace RustPlusBot.Persistence.Migrations
+{
+    [DbContext(typeof(BotDbContext))]
+    [Migration("20260619111443_SmartSwitches")]
+    partial class SmartSwitches
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.9");
+
+            modelBuilder.Entity("Persistord.Core.Entities.ChannelEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Channels");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.GuildEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("OwnerId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Guilds");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.MemberEntity", b =>
+                {
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("JoinedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Nickname")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GuildId", "UserId");
+
+                    b.ToTable("Members");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.RoleEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Color")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Permissions")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.UserEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GlobalName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Commands.ServerCommandSettings", b =>
+                {
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Muted")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ServerId");
+
+                    b.ToTable("ServerCommandSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Connections.ConnectionState", b =>
+                {
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ActiveCredentialId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PlayerCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("RustServerId");
+
+                    b.ToTable("ConnectionStates");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.FcmRegistration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("OwnerUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProtectedFcmCredentials")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "OwnerUserId")
+                        .IsUnique();
+
+                    b.ToTable("FcmRegistrations");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.PlayerCredential", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("OwnerUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProtectedPlayerToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("SteamId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "OwnerUserId")
+                        .IsUnique();
+
+                    b.ToTable("PlayerCredentials");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Entities.PairedEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EntityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "RustServerId");
+
+                    b.ToTable("PairedEntities");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Events.EventSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EventKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "RustServerId");
+
+                    b.ToTable("EventSubscriptions");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Guilds.GuildSettings", b =>
+                {
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Culture")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GuildId");
+
+                    b.ToTable("GuildSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Map.ServerMapSettings", b =>
+                {
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowGrid")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowMarkers")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowMonuments")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowPlayers")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowRigs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowVendor")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ServerId");
+
+                    b.ToTable("ServerMapSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Servers.RustServer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("AddedByUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Port")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.HasIndex("GuildId", "Ip", "Port")
+                        .IsUnique();
+
+                    b.ToTable("RustServers");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EntityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LastIsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("MessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("PairedByUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("GuildId", "ServerId", "EntityId")
+                        .IsUnique();
+
+                    b.ToTable("SmartSwitches");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedCategories");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedChannel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChannelKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "ChannelKey")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedChannels");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("DiscordMessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MessageKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "MessageKey")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedMessages");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.ChannelEntity", b =>
+                {
+                    b.HasOne("Persistord.Core.Entities.ChannelEntity", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Commands.ServerCommandSettings", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Commands.ServerCommandSettings", "ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Connections.ConnectionState", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Connections.ConnectionState", "RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.PlayerCredential", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Map.ServerMapSettings", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Map.ServerMapSettings", "ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedChannel", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedMessage", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.cs b/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.cs
new file mode 100644
index 0000000..9824e75
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Migrations/20260619111443_SmartSwitches.cs
@@ -0,0 +1,58 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RustPlusBot.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class SmartSwitches : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "SmartSwitches",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    GuildId = table.Column<long>(type: "INTEGER", nullable: false),
+                    ServerId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    EntityId = table.Column<long>(type: "INTEGER", nullable: false),
+                    Name = table.Column<string>(type: "TEXT", maxLength: 128, nullable: false),
+                    MessageId = table.Column<long>(type: "INTEGER", nullable: true),
+                    PairedByUserId = table.Column<long>(type: "INTEGER", nullable: false),
+                    LastIsActive = table.Column<bool>(type: "INTEGER", nullable: false),
+                    CreatedUtc = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SmartSwitches", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_SmartSwitches_RustServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "RustServers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SmartSwitches_GuildId_ServerId_EntityId",
+                table: "SmartSwitches",
+                columns: new[] { "GuildId", "ServerId", "EntityId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SmartSwitches_ServerId",
+                table: "SmartSwitches",
+                column: "ServerId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "SmartSwitches");
+        }
+    }
+}
diff --git a/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.Designer.cs b/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.Designer.cs
new file mode 100644
index 0000000..6c1fbe9
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.Designer.cs
@@ -0,0 +1,600 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RustPlusBot.Persistence;
+
+#nullable disable
+
+namespace RustPlusBot.Persistence.Migrations
+{
+    [DbContext(typeof(BotDbContext))]
+    [Migration("20260619122323_FacepunchServerId")]
+    partial class FacepunchServerId
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.9");
+
+            modelBuilder.Entity("Persistord.Core.Entities.ChannelEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Channels");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.GuildEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("OwnerId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Guilds");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.MemberEntity", b =>
+                {
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("JoinedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Nickname")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GuildId", "UserId");
+
+                    b.ToTable("Members");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.RoleEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Color")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Permissions")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId");
+
+                    b.ToTable("Roles");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.UserEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GlobalName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Commands.ServerCommandSettings", b =>
+                {
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Muted")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ServerId");
+
+                    b.ToTable("ServerCommandSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Connections.ConnectionState", b =>
+                {
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ActiveCredentialId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PlayerCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("RustServerId");
+
+                    b.ToTable("ConnectionStates");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.FcmRegistration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("OwnerUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProtectedFcmCredentials")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "OwnerUserId")
+                        .IsUnique();
+
+                    b.ToTable("FcmRegistrations");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.PlayerCredential", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("OwnerUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProtectedPlayerToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("SteamId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "OwnerUserId")
+                        .IsUnique();
+
+                    b.ToTable("PlayerCredentials");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Entities.PairedEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EntityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "RustServerId");
+
+                    b.ToTable("PairedEntities");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Events.EventSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EventKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "RustServerId");
+
+                    b.ToTable("EventSubscriptions");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Guilds.GuildSettings", b =>
+                {
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Culture")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("GuildId");
+
+                    b.ToTable("GuildSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Map.ServerMapSettings", b =>
+                {
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowGrid")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowMarkers")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowMonuments")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowPlayers")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowRigs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowVendor")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ServerId");
+
+                    b.ToTable("ServerMapSettings");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Servers.RustServer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("AddedByUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("FacepunchServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Port")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FacepunchServerId");
+
+                    b.HasIndex("GuildId");
+
+                    b.HasIndex("GuildId", "Ip", "Port")
+                        .IsUnique();
+
+                    b.ToTable("RustServers");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EntityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LastIsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("MessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("PairedByUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("GuildId", "ServerId", "EntityId")
+                        .IsUnique();
+
+                    b.ToTable("SmartSwitches");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedCategories");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedChannel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChannelKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "ChannelKey")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedChannels");
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("DiscordChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("DiscordMessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MessageKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("RustServerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RustServerId");
+
+                    b.HasIndex("GuildId", "RustServerId", "MessageKey")
+                        .IsUnique();
+
+                    b.ToTable("ProvisionedMessages");
+                });
+
+            modelBuilder.Entity("Persistord.Core.Entities.ChannelEntity", b =>
+                {
+                    b.HasOne("Persistord.Core.Entities.ChannelEntity", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Commands.ServerCommandSettings", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Commands.ServerCommandSettings", "ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Connections.ConnectionState", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Connections.ConnectionState", "RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Credentials.PlayerCredential", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Map.ServerMapSettings", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithOne()
+                        .HasForeignKey("RustPlusBot.Domain.Map.ServerMapSettings", "ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedChannel", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedMessage", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("RustServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.cs b/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.cs
new file mode 100644
index 0000000..de45236
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Migrations/20260619122323_FacepunchServerId.cs
@@ -0,0 +1,38 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RustPlusBot.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class FacepunchServerId : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "FacepunchServerId",
+                table: "RustServers",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RustServers_FacepunchServerId",
+                table: "RustServers",
+                column: "FacepunchServerId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_RustServers_FacepunchServerId",
+                table: "RustServers");
+
+            migrationBuilder.DropColumn(
+                name: "FacepunchServerId",
+                table: "RustServers");
+        }
+    }
+}
diff --git a/src/RustPlusBot.Persistence/Migrations/BotDbContextModelSnapshot.cs b/src/RustPlusBot.Persistence/Migrations/BotDbContextModelSnapshot.cs
index 73fe478..510beff 100644
--- a/src/RustPlusBot.Persistence/Migrations/BotDbContextModelSnapshot.cs
+++ b/src/RustPlusBot.Persistence/Migrations/BotDbContextModelSnapshot.cs
@@ -342,6 +342,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<long>("AddedByUserId")
                         .HasColumnType("INTEGER");
 
+                    b.Property<Guid?>("FacepunchServerId")
+                        .HasColumnType("TEXT");
+
                     b.Property<long>("GuildId")
                         .HasColumnType("INTEGER");
 
@@ -360,6 +363,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("FacepunchServerId");
+
                     b.HasIndex("GuildId");
 
                     b.HasIndex("GuildId", "Ip", "Port")
@@ -368,6 +373,48 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("RustServers");
                 });
 
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EntityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LastIsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("MessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("PairedByUserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ServerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("GuildId", "ServerId", "EntityId")
+                        .IsUnique();
+
+                    b.ToTable("SmartSwitches");
+                });
+
             modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
                 {
                     b.Property<Guid>("Id")
@@ -512,6 +559,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("RustPlusBot.Domain.Switches.SmartSwitch", b =>
+                {
+                    b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("RustPlusBot.Domain.Workspace.ProvisionedCategory", b =>
                 {
                     b.HasOne("RustPlusBot.Domain.Servers.RustServer", null)
diff --git a/src/RustPlusBot.Persistence/PersistenceServiceCollectionExtensions.cs b/src/RustPlusBot.Persistence/PersistenceServiceCollectionExtensions.cs
index 6750620..98ff335 100644
--- a/src/RustPlusBot.Persistence/PersistenceServiceCollectionExtensions.cs
+++ b/src/RustPlusBot.Persistence/PersistenceServiceCollectionExtensions.cs
@@ -6,6 +6,7 @@
 using RustPlusBot.Persistence.Credentials;
 using RustPlusBot.Persistence.Map;
 using RustPlusBot.Persistence.Servers;
+using RustPlusBot.Persistence.Switches;
 using RustPlusBot.Persistence.Workspace;
 
 namespace RustPlusBot.Persistence;
@@ -35,6 +36,7 @@ public static IServiceCollection AddBotPersistence(this IServiceCollection servi
         services.AddScoped<IFcmRegistrationStore, FcmRegistrationStore>();
         services.AddScoped<IWorkspaceStore, WorkspaceStore>();
         services.AddScoped<IConnectionStore, ConnectionStore>();
+        services.AddScoped<ISwitchStore, SwitchStore>();
         services.AddScoped<IMuteStore, MuteStore>();
         services.AddScoped<IMapSettingsStore, MapSettingsStore>();
 
diff --git a/src/RustPlusBot.Persistence/Servers/IServerService.cs b/src/RustPlusBot.Persistence/Servers/IServerService.cs
index 81490e5..548f0bf 100644
--- a/src/RustPlusBot.Persistence/Servers/IServerService.cs
+++ b/src/RustPlusBot.Persistence/Servers/IServerService.cs
@@ -40,6 +40,35 @@ Task<RustServer> AddAsync(ulong guildId,
     /// <returns>The server, or null if not found in this guild.</returns>
     Task<RustServer?> GetAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken = default);
 
+    /// <summary>Looks up a server by endpoint without creating one; returns null if absent.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="ip">Server host or ip.</param>
+    /// <param name="port">Rust+ app port.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The matching server, or null.</returns>
+    Task<RustServer?> GetByEndpointAsync(ulong guildId,
+        string ip,
+        int port,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Looks up a server by its Facepunch server GUID within a guild without creating one; returns null if absent.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="facepunchServerId">The Facepunch server GUID delivered by FCM pairings.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The matching server, or null.</returns>
+    Task<RustServer?> GetByFacepunchServerIdAsync(ulong guildId,
+        Guid facepunchServerId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Backfills a server's Facepunch server GUID by id; idempotent no-op when the server is absent or already equal.</summary>
+    /// <param name="serverId">The local server id to update.</param>
+    /// <param name="facepunchServerId">The Facepunch server GUID to store.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the backfill is persisted or skipped.</returns>
+    Task SetFacepunchServerIdAsync(Guid serverId,
+        Guid facepunchServerId,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Returns the server matching (guild, ip, port), creating it if none exists. Handles the
     /// concurrent-create race (two pairings for the same new server) by re-reading the winner.
diff --git a/src/RustPlusBot.Persistence/Servers/ServerService.cs b/src/RustPlusBot.Persistence/Servers/ServerService.cs
index 6c23ae4..9076b32 100644
--- a/src/RustPlusBot.Persistence/Servers/ServerService.cs
+++ b/src/RustPlusBot.Persistence/Servers/ServerService.cs
@@ -44,6 +44,52 @@ await context.RustServers
     public Task<RustServer?> GetAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken = default) =>
         context.RustServers.SingleOrDefaultAsync(s => s.GuildId == guildId && s.Id == serverId, cancellationToken);
 
+    /// <inheritdoc />
+    public Task<RustServer?> GetByEndpointAsync(
+        ulong guildId,
+        string ip,
+        int port,
+        CancellationToken cancellationToken = default) =>
+        context.RustServers
+            .SingleOrDefaultAsync(s => s.GuildId == guildId && s.Ip == ip && s.Port == port, cancellationToken);
+
+    /// <inheritdoc />
+    public Task<RustServer?> GetByFacepunchServerIdAsync(
+        ulong guildId,
+        Guid facepunchServerId,
+        CancellationToken cancellationToken = default)
+    {
+        // An empty GUID is "unknown" — never resolve to a server. Use FirstOrDefault (not Single) so the
+        // lookup can never throw if legacy rows ever share a Facepunch id (the column is not uniquely indexed).
+        if (facepunchServerId == Guid.Empty)
+        {
+            return Task.FromResult<RustServer?>(null);
+        }
+
+        return context.RustServers
+            .FirstOrDefaultAsync(
+                s => s.GuildId == guildId && s.FacepunchServerId == facepunchServerId, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task SetFacepunchServerIdAsync(
+        Guid serverId,
+        Guid facepunchServerId,
+        CancellationToken cancellationToken = default)
+    {
+        var server = await context.RustServers
+            .SingleOrDefaultAsync(s => s.Id == serverId, cancellationToken)
+            .ConfigureAwait(false);
+
+        if (server is null || server.FacepunchServerId == facepunchServerId)
+        {
+            return;
+        }
+
+        server.FacepunchServerId = facepunchServerId;
+        await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+    }
+
     /// <inheritdoc />
     public async Task<bool> RemoveAsync(
         ulong guildId,
diff --git a/src/RustPlusBot.Persistence/Switches/ISwitchStore.cs b/src/RustPlusBot.Persistence/Switches/ISwitchStore.cs
new file mode 100644
index 0000000..54f7d77
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Switches/ISwitchStore.cs
@@ -0,0 +1,111 @@
+using RustPlusBot.Domain.Switches;
+
+namespace RustPlusBot.Persistence.Switches;
+
+/// <summary>Persists managed Smart Switches (accepted pairings only; pending pairings stay in-memory).</summary>
+public interface ISwitchStore
+{
+    /// <summary>Adds a managed switch and returns the persisted row.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="name">The display name.</param>
+    /// <param name="pairedByUserId">The user who accepted the pairing.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The persisted switch.</returns>
+    Task<SmartSwitch> AddAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        string name,
+        ulong pairedByUserId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Gets a switch by identity, or null.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The switch, or null.</returns>
+    Task<SmartSwitch?> GetAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Lists every managed switch for a server.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The managed switches for the server.</returns>
+    Task<IReadOnlyList<SmartSwitch>> ListByServerAsync(
+        ulong guildId,
+        Guid serverId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>True when a managed switch with this identity exists.</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>True if a matching switch exists.</returns>
+    Task<bool> ExistsAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Renames a switch (no-op if absent).</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="name">The new display name.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the rename has been persisted.</returns>
+    Task RenameAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        string name,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Sets the embed message id (no-op if absent).</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="messageId">The Discord embed message id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the message id has been persisted.</returns>
+    Task SetMessageIdAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        ulong messageId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Updates the last-known on/off state (no-op if absent).</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="isActive">The last observed on/off state.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the state has been persisted.</returns>
+    Task UpdateStateAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        bool isActive,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>Removes a switch (no-op if absent).</summary>
+    /// <param name="guildId">Owning Discord guild snowflake.</param>
+    /// <param name="serverId">The Rust server id.</param>
+    /// <param name="entityId">The in-game smart-switch entity id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the switch has been removed.</returns>
+    Task RemoveAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default);
+}
diff --git a/src/RustPlusBot.Persistence/Switches/SwitchStore.cs b/src/RustPlusBot.Persistence/Switches/SwitchStore.cs
new file mode 100644
index 0000000..a63183d
--- /dev/null
+++ b/src/RustPlusBot.Persistence/Switches/SwitchStore.cs
@@ -0,0 +1,147 @@
+using Microsoft.EntityFrameworkCore;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Domain.Switches;
+
+namespace RustPlusBot.Persistence.Switches;
+
+/// <summary>EF-backed <see cref="ISwitchStore"/>.</summary>
+/// <param name="context">The bot database context.</param>
+/// <param name="clock">Supplies the creation timestamp.</param>
+public sealed class SwitchStore(BotDbContext context, IClock clock) : ISwitchStore
+{
+    /// <inheritdoc />
+    public async Task<SmartSwitch> AddAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        string name,
+        ulong pairedByUserId,
+        CancellationToken cancellationToken = default)
+    {
+        var entity = new SmartSwitch
+        {
+            GuildId = guildId,
+            ServerId = serverId,
+            EntityId = entityId,
+            Name = name,
+            PairedByUserId = pairedByUserId,
+            LastIsActive = false,
+            CreatedUtc = clock.UtcNow,
+        };
+        context.SmartSwitches.Add(entity);
+        try
+        {
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+            return entity;
+        }
+        catch (DbUpdateException)
+        {
+            // Two users accepted the same pending pairing concurrently (both saw ExistsAsync == false); the
+            // unique (GuildId, ServerId, EntityId) index rejects the second insert. Recover idempotently by
+            // detaching the failed insert and returning the row the winner persisted. If no such row exists,
+            // the failure was not the uniqueness race — let it propagate.
+            context.Entry(entity).State = EntityState.Detached;
+            var existing = await GetAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false);
+            if (existing is null)
+            {
+                throw;
+            }
+
+            return existing;
+        }
+    }
+
+    /// <inheritdoc />
+    public Task<SmartSwitch?> GetAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default) =>
+        context.SmartSwitches.SingleOrDefaultAsync(
+            s => s.GuildId == guildId && s.ServerId == serverId && s.EntityId == entityId, cancellationToken);
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<SmartSwitch>> ListByServerAsync(
+        ulong guildId,
+        Guid serverId,
+        CancellationToken cancellationToken = default)
+    {
+        // SQLite cannot ORDER BY a DateTimeOffset column, so order oldest-first on the client side.
+        var switches = await context.SmartSwitches
+            .Where(s => s.GuildId == guildId && s.ServerId == serverId)
+            .ToListAsync(cancellationToken)
+            .ConfigureAwait(false);
+
+        return switches.OrderBy(s => s.CreatedUtc).ToList();
+    }
+
+    /// <inheritdoc />
+    public Task<bool> ExistsAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default) =>
+        context.SmartSwitches.AnyAsync(
+            s => s.GuildId == guildId && s.ServerId == serverId && s.EntityId == entityId, cancellationToken);
+
+    /// <inheritdoc />
+    public Task RenameAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        string name,
+        CancellationToken cancellationToken = default) =>
+        MutateAsync(guildId, serverId, entityId, s => s.Name = name, cancellationToken);
+
+    /// <inheritdoc />
+    public Task SetMessageIdAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        ulong messageId,
+        CancellationToken cancellationToken = default) =>
+        MutateAsync(guildId, serverId, entityId, s => s.MessageId = messageId, cancellationToken);
+
+    /// <inheritdoc />
+    public Task UpdateStateAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        bool isActive,
+        CancellationToken cancellationToken = default) =>
+        MutateAsync(guildId, serverId, entityId, s => s.LastIsActive = isActive, cancellationToken);
+
+    /// <inheritdoc />
+    public async Task RemoveAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        CancellationToken cancellationToken = default)
+    {
+        var entity = await GetAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false);
+        if (entity is null)
+        {
+            return;
+        }
+
+        context.SmartSwitches.Remove(entity);
+        await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task MutateAsync(
+        ulong guildId,
+        Guid serverId,
+        ulong entityId,
+        Action<SmartSwitch> mutate,
+        CancellationToken cancellationToken)
+    {
+        var entity = await GetAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false);
+        if (entity is null)
+        {
+            return;
+        }
+
+        mutate(entity);
+        await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+    }
+}
diff --git a/tests/RustPlusBot.Abstractions.Tests/SwitchEventsTests.cs b/tests/RustPlusBot.Abstractions.Tests/SwitchEventsTests.cs
new file mode 100644
index 0000000..7f7bc06
--- /dev/null
+++ b/tests/RustPlusBot.Abstractions.Tests/SwitchEventsTests.cs
@@ -0,0 +1,29 @@
+using RustPlusBot.Abstractions.Events;
+
+namespace RustPlusBot.Abstractions.Tests;
+
+public sealed class SwitchEventsTests
+{
+    [Fact]
+    public void SwitchPairedEvent_carries_guild_server_entity()
+    {
+        var serverId = Guid.NewGuid();
+        var evt = new SwitchPairedEvent(10UL, serverId, 42UL);
+
+        Assert.Equal(10UL, evt.GuildId);
+        Assert.Equal(serverId, evt.ServerId);
+        Assert.Equal(42UL, evt.EntityId);
+    }
+
+    [Fact]
+    public void SwitchStateChangedEvent_carries_state()
+    {
+        var serverId = Guid.NewGuid();
+        var evt = new SwitchStateChangedEvent(10UL, serverId, 42UL, IsActive: true);
+
+        Assert.Equal(10UL, evt.GuildId);
+        Assert.Equal(serverId, evt.ServerId);
+        Assert.Equal(42UL, evt.EntityId);
+        Assert.True(evt.IsActive);
+    }
+}
diff --git a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
index 8e3b4fa..78b7c2c 100644
--- a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
+++ b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
@@ -117,6 +117,18 @@ 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>
+        public Dictionary<ulong, bool?> SwitchStates { get; } = new();
+
+        /// <summary>The result returned by <see cref="SetSmartSwitchValueAsync"/>. Defaults to true.</summary>
+        public bool SetSwitchResult { get; set; } = true;
+
+        /// <summary>The result returned by <see cref="StrobeSmartSwitchAsync"/>. Defaults to true.</summary>
+        public bool StrobeSwitchResult { get; set; } = true;
+
+        /// <summary>Records (entityId, value) passed to <see cref="SetSmartSwitchValueAsync"/>.</summary>
+        public List<(ulong EntityId, bool Value)> SetSwitchCalls { get; } = [];
+
         /// <summary>
         /// The fallback markers returned by <see cref="GetMapMarkersAsync"/> when no scripted results remain.
         /// Defaults to empty (nothing on the map). Callers that do not use <see cref="EnqueueMarkers"/> see
@@ -139,6 +151,9 @@ 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;
+
         public Task<SocketConnectOutcome> ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken) =>
             Task.FromResult(outcome);
 
@@ -168,6 +183,33 @@ public Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, Cancella
             return Task.FromResult(PromoteResult);
         }
 
+#pragma warning disable RCS1163 // Unused parameters for fake implementation
+        public Task<bool?> GetSmartSwitchInfoAsync(ulong entityId,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) =>
+            Task.FromResult(SwitchStates.TryGetValue(entityId, out var s) ? s : null);
+#pragma warning restore RCS1163
+
+#pragma warning disable RCS1163 // Unused parameters for fake implementation
+        public Task<bool> SetSmartSwitchValueAsync(ulong entityId,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken)
+#pragma warning restore RCS1163
+        {
+            SetSwitchCalls.Add((entityId, value));
+            return Task.FromResult(SetSwitchResult);
+        }
+
+#pragma warning disable RCS1163 // Unused parameters for fake implementation
+        public Task<bool> StrobeSmartSwitchAsync(ulong entityId,
+            int timeoutMs,
+            bool value,
+            TimeSpan timeout,
+            CancellationToken cancellationToken) =>
+            Task.FromResult(StrobeSwitchResult);
+#pragma warning restore RCS1163
+
         public Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(TimeSpan timeout,
             CancellationToken cancellationToken = default)
         {
@@ -214,5 +256,9 @@ public Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(TimeSpan timeout,
         /// <summary>Raises <see cref="TeamMessageReceived"/> to simulate an inbound team chat line.</summary>
         /// <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);
     }
 }
diff --git a/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs b/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs
new file mode 100644
index 0000000..5cbade2
--- /dev/null
+++ b/tests/RustPlusBot.Features.Connections.Tests/SwitchQueryTests.cs
@@ -0,0 +1,208 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using RustPlusBot.Abstractions.Credentials;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Discord.Notifications;
+using RustPlusBot.Domain.Credentials;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Connections.Supervisor;
+using RustPlusBot.Features.Connections.Tests.Fakes;
+using RustPlusBot.Persistence;
+using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Persistence.Servers;
+using RustPlusBot.Persistence.Switches;
+
+namespace RustPlusBot.Features.Connections.Tests;
+
+public sealed class SwitchQueryTests
+{
+    private static (ServiceProvider Provider, ConnectionSupervisor Supervisor, InMemoryEventBus Bus) CreateHarness(
+        FakeRustSocketSource source)
+    {
+        var protector = Substitute.For<ICredentialProtector>();
+        protector.Unprotect(Arg.Any<string>()).Returns(c => c.Arg<string>());
+        var dm = Substitute.For<IUserDmSender>();
+        var clock = Substitute.For<IClock>();
+        clock.UtcNow.Returns(DateTimeOffset.UnixEpoch);
+        var bus = new InMemoryEventBus();
+
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddSingleton(clock);
+        services.AddSingleton(protector);
+        services.AddSingleton(dm);
+        services.AddSingleton<IEventBus>(bus);
+
+        var cs = $"DataSource=switchquery-{Guid.NewGuid():N};Mode=Memory;Cache=Shared";
+        var keepAlive = new SqliteConnection(cs);
+        keepAlive.Open();
+        using (var seed = new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(cs).Options))
+        {
+            seed.Database.Migrate();
+        }
+
+        services.AddSingleton(keepAlive);
+        services.AddScoped(_ => new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(cs).Options));
+        services.AddScoped<IConnectionStore, ConnectionStore>();
+        services.AddScoped<IServerService, ServerService>();
+        services.AddScoped<ISwitchStore, SwitchStore>();
+        services.AddSingleton<IRustSocketSource>(source);
+        services.AddSingleton(Options.Create(new ConnectionOptions
+        {
+            ConnectTimeout = TimeSpan.FromSeconds(1),
+            InitialRetryDelay = TimeSpan.FromMilliseconds(5),
+            MaxRetryDelay = TimeSpan.FromMilliseconds(20),
+            HeartbeatInterval = TimeSpan.FromMilliseconds(20),
+            HeartbeatTimeout = TimeSpan.FromMilliseconds(200),
+        }));
+        services.AddSingleton<ConnectionSupervisor>();
+
+        var provider = services.BuildServiceProvider();
+        return (provider, provider.GetRequiredService<ConnectionSupervisor>(), bus);
+    }
+
+    private static async Task<Guid> SeedServerWithActiveAndSwitchAsync(ServiceProvider provider, ulong entityId)
+    {
+        using var scope = provider.CreateScope();
+        var ctx = scope.ServiceProvider.GetRequiredService<BotDbContext>();
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        ctx.RustServers.Add(server);
+        ctx.PlayerCredentials.Add(new PlayerCredential
+        {
+            GuildId = 10UL,
+            RustServerId = server.Id,
+            OwnerUserId = 1UL,
+            SteamId = 555UL,
+            ProtectedPlayerToken = "123",
+            Status = CredentialStatus.Active,
+        });
+        await ctx.SaveChangesAsync();
+        var store = scope.ServiceProvider.GetRequiredService<ISwitchStore>();
+        await store.AddAsync(10UL, server.Id, entityId, $"Switch {entityId}", 1UL);
+        return server.Id;
+    }
+
+    private static async Task WaitUntilAsync(Func<bool> condition, CancellationToken ct)
+    {
+        while (!condition())
+        {
+            ct.ThrowIfCancellationRequested();
+            await Task.Delay(10, ct);
+        }
+    }
+
+    [Fact]
+    public async Task SetSmartSwitch_forwards_value_when_connected()
+    {
+        var source = new FakeRustSocketSource();
+        var (provider, supervisor, _) = CreateHarness(source);
+        await using var disposeProvider = provider;
+        var serverId = await SeedServerWithActiveAndSwitchAsync(provider, entityId: 42UL);
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        await supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
+        await WaitUntilAsync(() => supervisor.HasLiveSocket(10UL, serverId), cts.Token);
+
+        var ok = await supervisor.SetSmartSwitchAsync(10UL, serverId, 42UL, value: true, cts.Token);
+
+        Assert.True(ok);
+        Assert.Contains((42UL, true), source.LastConnection!.SetSwitchCalls);
+        await supervisor.StopAllAsync();
+    }
+
+    [Fact]
+    public async Task SetSmartSwitch_returns_false_when_no_live_socket()
+    {
+        var source = new FakeRustSocketSource();
+        var (provider, supervisor, _) = CreateHarness(source);
+        await using var disposeProvider = provider;
+
+        Assert.False(await supervisor.SetSmartSwitchAsync(10UL, Guid.NewGuid(), 42UL, true, CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task Priming_publishes_state_for_persisted_switch_on_connect()
+    {
+        var source = new FakeRustSocketSource();
+        var (provider, supervisor, bus) = CreateHarness(source);
+        await using var disposeProvider = provider;
+        var serverId = await SeedServerWithActiveAndSwitchAsync(provider, entityId: 42UL);
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+
+        // 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 received =
+            new TaskCompletionSource<SwitchStateChangedEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _ = Task.Run(
+            async () =>
+            {
+                await foreach (var evt in stream)
+                {
+                    if (evt.EntityId == 42UL)
+                    {
+                        received.TrySetResult(evt);
+                        break;
+                    }
+                }
+            },
+            cts.Token);
+
+        // The fake defaults entity 42 absent → GetSmartSwitchInfoAsync returns null → priming publishes off.
+        await supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
+
+        var evt = await received.Task.WaitAsync(cts.Token);
+        Assert.Equal(42UL, evt.EntityId);
+        Assert.False(evt.IsActive); // absent in SwitchStates → null → defaulted off
+        await supervisor.StopAllAsync();
+    }
+
+    [Fact]
+    public async Task Trigger_publishes_state_change()
+    {
+        var source = new FakeRustSocketSource();
+        var (provider, supervisor, bus) = CreateHarness(source);
+        await using var disposeProvider = provider;
+        var serverId = await SeedServerWithActiveAndSwitchAsync(provider, entityId: 42UL);
+
+        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 received =
+            new TaskCompletionSource<SwitchStateChangedEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _ = Task.Run(
+            async () =>
+            {
+                await foreach (var e in stream)
+                {
+                    // Skip the prime (off) and match the trigger (on) for entity 42.
+                    if (e is { EntityId: 42UL, IsActive: true })
+                    {
+                        received.TrySetResult(e);
+                        break;
+                    }
+                }
+            },
+            cts.Token);
+
+        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);
+
+        var evt = await received.Task.WaitAsync(cts.Token);
+        Assert.True(evt.IsActive);
+        await supervisor.StopAllAsync();
+    }
+}
diff --git a/tests/RustPlusBot.Features.Pairing.Tests/PairingHandlerTests.cs b/tests/RustPlusBot.Features.Pairing.Tests/PairingHandlerTests.cs
index 85fbda8..e8d3aa3 100644
--- a/tests/RustPlusBot.Features.Pairing.Tests/PairingHandlerTests.cs
+++ b/tests/RustPlusBot.Features.Pairing.Tests/PairingHandlerTests.cs
@@ -13,6 +13,8 @@ namespace RustPlusBot.Features.Pairing.Tests;
 
 public sealed class PairingHandlerTests
 {
+    private static readonly Guid FpServer = Guid.Parse("11111111-1111-1111-1111-111111111111");
+
     private static ICredentialProtector PassThrough()
     {
         var p = Substitute.For<ICredentialProtector>();
@@ -25,7 +27,11 @@ private static PairingHandler CreateHandler(BotDbContext context, IEventBus bus)
             Microsoft.Extensions.Logging.Abstractions.NullLogger<PairingHandler>.Instance);
 
     private static PairingNotification ServerPairing(string ip = "1.2.3.4", int port = 28015, ulong steam = 7UL) =>
-        new(PairingKind.Server, "Rustopia", ip, port, steam, "ptoken");
+        new(PairingKind.Server, "Rustopia", ip, port, steam, "ptoken", FacepunchServerId: FpServer, EntityId: 0UL);
+
+    private static PairingNotification EntityPairing(Guid fpServer, ulong entityId = 42UL) =>
+        new(PairingKind.Entity, string.Empty, string.Empty, 0, 1UL, "t", FacepunchServerId: fpServer,
+            EntityId: entityId);
 
     [Fact]
     public async Task ServerPairing_CreatesServerCredentialAndFiresEventOnce()
@@ -69,7 +75,7 @@ public async Task SecondOwnerSameServer_AddsStandbyCredentialNoEvent()
     }
 
     [Fact]
-    public async Task EntityPairing_IsIgnored()
+    public async Task ServerPairing_BackfillsFacepunchServerId()
     {
         var (context, connection) = TestDb.Create();
         await using var _ = context;
@@ -77,11 +83,44 @@ public async Task EntityPairing_IsIgnored()
         var bus = Substitute.For<IEventBus>();
         var handler = CreateHandler(context, bus);
 
-        await handler.HandleAsync(10UL, 1UL,
-            new PairingNotification(PairingKind.Entity, "x", "1.2.3.4", 28015, 1UL, "t"), CancellationToken.None);
+        await handler.HandleAsync(10UL, 99UL, ServerPairing(), CancellationToken.None);
+
+        var server = await context.RustServers.SingleAsync();
+        Assert.Equal(FpServer, server.FacepunchServerId);
+    }
+
+    [Fact]
+    public async Task EntityPairing_KnownServer_PublishesSwitchPairedEvent()
+    {
+        var (context, connection) = TestDb.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var bus = Substitute.For<IEventBus>();
+        var handler = CreateHandler(context, bus);
+
+        await handler.HandleAsync(10UL, 99UL, ServerPairing(), CancellationToken.None);
+        var server = await context.RustServers.SingleAsync();
+        bus.ClearReceivedCalls();
+
+        await handler.HandleAsync(10UL, 1UL, EntityPairing(FpServer, entityId: 42UL), CancellationToken.None);
+
+        await bus.Received(1).PublishAsync(
+            Arg.Is<SwitchPairedEvent>(e => e.GuildId == 10UL && e.ServerId == server.Id && e.EntityId == 42UL),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task EntityPairing_UnknownServer_DropsAndCreatesNothing()
+    {
+        var (context, connection) = TestDb.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var bus = Substitute.For<IEventBus>();
+        var handler = CreateHandler(context, bus);
+
+        await handler.HandleAsync(10UL, 1UL, EntityPairing(Guid.NewGuid(), 42UL), CancellationToken.None);
 
         Assert.Empty(await context.RustServers.ToListAsync());
-        Assert.Empty(await context.PlayerCredentials.ToListAsync());
-        await bus.DidNotReceive().PublishAsync(Arg.Any<ServerRegisteredEvent>(), Arg.Any<CancellationToken>());
+        await bus.DidNotReceive().PublishAsync(Arg.Any<SwitchPairedEvent>(), Arg.Any<CancellationToken>());
     }
 }
diff --git a/tests/RustPlusBot.Features.Switches.Tests/RustPlusBot.Features.Switches.Tests.csproj b/tests/RustPlusBot.Features.Switches.Tests/RustPlusBot.Features.Switches.Tests.csproj
new file mode 100644
index 0000000..82f2e38
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/RustPlusBot.Features.Switches.Tests.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" />
+    <PackageReference Include="Discord.Net" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NSubstitute" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\RustPlusBot.Features.Switches\RustPlusBot.Features.Switches.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchEmbedRendererTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchEmbedRendererTests.cs
new file mode 100644
index 0000000..9e23bfd
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchEmbedRendererTests.cs
@@ -0,0 +1,83 @@
+using Discord;
+using RustPlusBot.Domain.Switches;
+using RustPlusBot.Features.Switches.Rendering;
+
+namespace RustPlusBot.Features.Switches.Tests;
+
+public sealed class SwitchEmbedRendererTests
+{
+    private static SwitchEmbedRenderer Create() =>
+        new(new SwitchLocalizer(SwitchLocalizationCatalog.Default));
+
+    private static SmartSwitch Sample(string name = "Front gate", bool lastActive = false) => new()
+    {
+        GuildId = 10UL,
+        ServerId = Guid.NewGuid(),
+        EntityId = 42UL,
+        Name = name,
+        LastIsActive = lastActive,
+    };
+
+    [Fact]
+    public void RenderSwitch_on_shows_on_status_and_off_button_enabled()
+    {
+        var (embed, components) = Create().RenderSwitch(Sample(), isActive: true, "en");
+
+        Assert.Contains("ON", embed.Description ?? embed.Title ?? string.Empty, StringComparison.Ordinal);
+        // Find the on/off buttons by custom id and assert disabled-state reflects current value.
+        var buttons = components.Components.OfType<ActionRowComponent>().SelectMany(r => r.Components)
+            .OfType<ButtonComponent>().ToList();
+        var onBtn = buttons.Single(b => b.CustomId!.StartsWith(SwitchComponentIds.OnPrefix, StringComparison.Ordinal));
+        var offBtn =
+            buttons.Single(b => b.CustomId!.StartsWith(SwitchComponentIds.OffPrefix, StringComparison.Ordinal));
+        Assert.True(onBtn.IsDisabled); // already on
+        Assert.False(offBtn.IsDisabled);
+    }
+
+    [Fact]
+    public void RenderSwitch_off_shows_off_status_and_on_button_enabled()
+    {
+        var (embed, components) = Create().RenderSwitch(Sample(), isActive: false, "en");
+
+        Assert.Contains("OFF", embed.Description ?? embed.Title ?? string.Empty, StringComparison.Ordinal);
+        var buttons = components.Components.OfType<ActionRowComponent>().SelectMany(r => r.Components)
+            .OfType<ButtonComponent>().ToList();
+        var onBtn = buttons.Single(b => b.CustomId!.StartsWith(SwitchComponentIds.OnPrefix, StringComparison.Ordinal));
+        var offBtn =
+            buttons.Single(b => b.CustomId!.StartsWith(SwitchComponentIds.OffPrefix, StringComparison.Ordinal));
+        Assert.False(onBtn.IsDisabled);
+        Assert.True(offBtn.IsDisabled); // already off
+    }
+
+    [Fact]
+    public void RenderSwitch_unreachable_disables_all_control_buttons()
+    {
+        var (embed, components) = Create().RenderSwitch(Sample(), isActive: null, "en");
+
+        Assert.Contains("Unreachable", embed.Description ?? string.Empty, StringComparison.Ordinal);
+        var buttons = components.Components.OfType<ActionRowComponent>().SelectMany(r => r.Components)
+            .OfType<ButtonComponent>().ToList();
+        Assert.All(buttons, b => Assert.True(b.IsDisabled));
+    }
+
+    [Fact]
+    public void RenderSwitch_french_uses_french_status()
+    {
+        var (embed, _) = Create().RenderSwitch(Sample(), isActive: true, "fr");
+        Assert.Contains("ALLUMÉ", embed.Description ?? string.Empty, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RenderPrompt_carries_accept_and_dismiss_with_identity_tail()
+    {
+        var serverId = Guid.NewGuid();
+        var (_, components) = Create().RenderPrompt(serverId, 42UL, "Switch 42", "en");
+
+        var buttons = components.Components.OfType<ActionRowComponent>().SelectMany(r => r.Components)
+            .OfType<ButtonComponent>().ToList();
+        Assert.Contains(buttons, b =>
+            b.CustomId == $"{SwitchComponentIds.AcceptPrefix}{serverId}:42");
+        Assert.Contains(buttons, b =>
+            b.CustomId == $"{SwitchComponentIds.DismissPrefix}{serverId}:42");
+    }
+}
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchLocalizationCatalogTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchLocalizationCatalogTests.cs
new file mode 100644
index 0000000..65976b6
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchLocalizationCatalogTests.cs
@@ -0,0 +1,33 @@
+using RustPlusBot.Features.Switches.Rendering;
+
+namespace RustPlusBot.Features.Switches.Tests;
+
+public sealed class SwitchLocalizationCatalogTests
+{
+    [Theory]
+    [InlineData("en")]
+    [InlineData("fr")]
+    public void Catalog_contains_all_required_keys(string culture)
+    {
+        var map = SwitchLocalizationCatalog.Default.Strings[culture];
+        foreach (var key in new[]
+                 {
+                     "switch.status.on", "switch.status.off", "switch.status.unreachable", "switch.button.on",
+                     "switch.button.off", "switch.button.strobe", "switch.button.rename", "switch.prompt.title",
+                     "switch.prompt.body", "switch.prompt.accept", "switch.prompt.dismiss", "switch.rename.modal.title",
+                     "switch.rename.input.label", "switch.unreachable.ephemeral",
+                 })
+        {
+            Assert.True(map.ContainsKey(key), $"Missing key '{key}' for culture '{culture}'.");
+        }
+    }
+
+    [Fact]
+    public void Localizer_falls_back_to_english()
+    {
+        var localizer = new SwitchLocalizer(SwitchLocalizationCatalog.Default);
+        Assert.Equal(
+            SwitchLocalizationCatalog.Default.Strings["en"]["switch.status.on"],
+            localizer.Get("switch.status.on", "de"));
+    }
+}
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchPairingCoordinatorTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchPairingCoordinatorTests.cs
new file mode 100644
index 0000000..584e10c
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchPairingCoordinatorTests.cs
@@ -0,0 +1,109 @@
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Switches.Pairing;
+using RustPlusBot.Features.Switches.Posting;
+using RustPlusBot.Features.Switches.Rendering;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Switches;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Switches.Tests;
+
+public sealed class SwitchPairingCoordinatorTests
+{
+    private static Harness Create()
+    {
+        var store = Substitute.For<ISwitchStore>();
+        var workspace = Substitute.For<IWorkspaceStore>();
+        workspace.GetCultureAsync(Arg.Any<ulong>(), Arg.Any<CancellationToken>()).Returns("en");
+
+        var services = new ServiceCollection();
+        services.AddScoped(_ => store);
+        services.AddScoped(_ => workspace);
+        var provider = services.BuildServiceProvider();
+        var scopeFactory = provider.GetRequiredService<IServiceScopeFactory>();
+
+        var locator = Substitute.For<ISwitchChannelLocator>();
+        locator.GetChannelIdAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>())
+            .Returns(777UL);
+
+        var poster = Substitute.For<ISwitchChannelPoster>();
+        poster.EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(), Arg.Any<global::Discord.Embed>(),
+                Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>())
+            .Returns(900UL);
+
+        var renderer = new SwitchEmbedRenderer(new SwitchLocalizer(SwitchLocalizationCatalog.Default));
+        var coordinator = new SwitchPairingCoordinator(scopeFactory, locator, poster, renderer);
+        return new Harness(coordinator, store, poster, locator);
+    }
+
+    [Fact]
+    public async Task Paired_new_switch_posts_prompt_with_default_name()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(false);
+
+        await h.Coordinator.HandlePairedAsync(new SwitchPairedEvent(10UL, serverId, 42UL), CancellationToken.None);
+
+        await h.Poster.Received(1).EnsureAsync(777UL, null, Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
+        Assert.Equal("Switch 42", h.Coordinator.PendingName(10UL, serverId, 42UL));
+    }
+
+    [Fact]
+    public async Task Paired_already_managed_switch_is_ignored()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(true);
+
+        await h.Coordinator.HandlePairedAsync(new SwitchPairedEvent(10UL, serverId, 42UL), CancellationToken.None);
+
+        await h.Poster.DidNotReceive().EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(),
+            Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
+        Assert.Null(h.Coordinator.PendingName(10UL, serverId, 42UL));
+    }
+
+    [Fact]
+    public async Task Accept_persists_switch_and_replaces_prompt()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(false);
+        await h.Coordinator.HandlePairedAsync(new SwitchPairedEvent(10UL, serverId, 42UL), CancellationToken.None);
+        h.Store.AddAsync(10UL, serverId, 42UL, "Switch 42", 5UL, Arg.Any<CancellationToken>())
+            .Returns(new RustPlusBot.Domain.Switches.SmartSwitch
+            {
+                GuildId = 10UL, ServerId = serverId, EntityId = 42UL, Name = "Switch 42",
+            });
+
+        var ok = await h.Coordinator.TryAcceptAsync(10UL, serverId, 42UL, acceptingUserId: 5UL, CancellationToken.None);
+
+        Assert.True(ok);
+        await h.Store.Received(1).AddAsync(10UL, serverId, 42UL, "Switch 42", 5UL, Arg.Any<CancellationToken>());
+        Assert.Null(h.Coordinator.PendingName(10UL, serverId, 42UL)); // pending cleared
+    }
+
+    [Fact]
+    public async Task Accept_is_noop_when_already_persisted_by_race()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(true);
+
+        var ok = await h.Coordinator.TryAcceptAsync(10UL, serverId, 42UL, 5UL, CancellationToken.None);
+
+        Assert.False(ok);
+        await h.Store.DidNotReceive().AddAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
+            Arg.Any<string>(), Arg.Any<ulong>(), Arg.Any<CancellationToken>());
+    }
+
+    private sealed record Harness(
+        SwitchPairingCoordinator Coordinator,
+        ISwitchStore Store,
+        ISwitchChannelPoster Poster,
+        ISwitchChannelLocator Locator);
+}
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchRegistrationTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchRegistrationTests.cs
new file mode 100644
index 0000000..464f42b
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchRegistrationTests.cs
@@ -0,0 +1,22 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Features.Switches;
+using RustPlusBot.Features.Switches.Pairing;
+using RustPlusBot.Features.Switches.Relaying;
+using RustPlusBot.Features.Switches.Rendering;
+
+namespace RustPlusBot.Features.Switches.Tests;
+
+public sealed class SwitchRegistrationTests
+{
+    [Fact]
+    public void AddSwitches_registers_core_services()
+    {
+        var services = new ServiceCollection();
+        services.AddSwitches();
+
+        Assert.Contains(services, d => d.ServiceType == typeof(SwitchPairingCoordinator));
+        Assert.Contains(services, d => d.ServiceType == typeof(SwitchStateRelay));
+        Assert.Contains(services, d => d.ServiceType == typeof(SwitchEmbedRenderer));
+        Assert.Contains(services, d => d.ServiceType == typeof(ISwitchLocalizer));
+    }
+}
diff --git a/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs b/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs
new file mode 100644
index 0000000..8ed1603
--- /dev/null
+++ b/tests/RustPlusBot.Features.Switches.Tests/SwitchStateRelayTests.cs
@@ -0,0 +1,120 @@
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Domain.Connections;
+using RustPlusBot.Domain.Switches;
+using RustPlusBot.Features.Switches.Posting;
+using RustPlusBot.Features.Switches.Relaying;
+using RustPlusBot.Features.Switches.Rendering;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Persistence.Switches;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Switches.Tests;
+
+public sealed class SwitchStateRelayTests
+{
+    private static Harness Create()
+    {
+        var store = Substitute.For<ISwitchStore>();
+        var connections = Substitute.For<IConnectionStore>();
+        var workspace = Substitute.For<IWorkspaceStore>();
+        workspace.GetCultureAsync(Arg.Any<ulong>(), Arg.Any<CancellationToken>()).Returns("en");
+
+        var services = new ServiceCollection();
+        services.AddScoped(_ => store);
+        services.AddScoped(_ => connections);
+        services.AddScoped(_ => workspace);
+        var provider = services.BuildServiceProvider();
+
+        var locator = Substitute.For<ISwitchChannelLocator>();
+        locator.GetChannelIdAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>()).Returns(777UL);
+        var poster = Substitute.For<ISwitchChannelPoster>();
+        poster.EnsureAsync(Arg.Any<ulong>(), Arg.Any<ulong?>(), Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>()).Returns((ulong?)900UL);
+        var renderer = new SwitchEmbedRenderer(new SwitchLocalizer(SwitchLocalizationCatalog.Default));
+
+        var relay = new SwitchStateRelay(provider.GetRequiredService<IServiceScopeFactory>(), locator, poster,
+            renderer);
+        return new Harness(relay, store, poster, connections);
+    }
+
+    [Fact]
+    public async Task StateChanged_updates_store_and_rerenders()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        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.HandleStateChangedAsync(
+            new SwitchStateChangedEvent(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 ConnectionStatus_not_connected_marks_switches_unreachable()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Connections.GetStateAsync(10UL, serverId, Arg.Any<CancellationToken>())
+            .Returns(new ConnectionState
+            {
+                GuildId = 10UL, RustServerId = serverId, Status = ConnectionStatus.Unreachable
+            });
+        h.Store.ListByServerAsync(10UL, serverId, Arg.Any<CancellationToken>())
+            .Returns(new[]
+            {
+                new SmartSwitch
+                {
+                    GuildId = 10UL,
+                    ServerId = serverId,
+                    EntityId = 42UL,
+                    Name = "G",
+                    MessageId = 900UL
+                }
+            });
+
+        await h.Relay.HandleConnectionStatusAsync(
+            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+
+        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 ConnectionStatus_connected_does_nothing()
+    {
+        var h = Create();
+        var serverId = Guid.NewGuid();
+        h.Connections.GetStateAsync(10UL, serverId, Arg.Any<CancellationToken>())
+            .Returns(new ConnectionState
+            {
+                GuildId = 10UL, RustServerId = serverId, Status = ConnectionStatus.Connected
+            });
+
+        await h.Relay.HandleConnectionStatusAsync(
+            new ConnectionStatusChangedEvent(10UL, serverId), CancellationToken.None);
+
+        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,
+        ISwitchChannelPoster Poster,
+        IConnectionStore Connections);
+}
diff --git a/tests/RustPlusBot.Features.Workspace.Tests/Locating/SwitchChannelLocatorTests.cs b/tests/RustPlusBot.Features.Workspace.Tests/Locating/SwitchChannelLocatorTests.cs
new file mode 100644
index 0000000..0ad446c
--- /dev/null
+++ b/tests/RustPlusBot.Features.Workspace.Tests/Locating/SwitchChannelLocatorTests.cs
@@ -0,0 +1,136 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Domain.Workspace;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Workspace.Tests.Locating;
+
+public sealed class SwitchChannelLocatorTests
+{
+    private static (SwitchChannelLocator Locator, ServiceProvider Provider, string ConnectionString, IClock Clock)
+        CreateLocator()
+    {
+        var clock = Substitute.For<IClock>();
+        clock.UtcNow.Returns(DateTimeOffset.UnixEpoch);
+
+        var cs = $"DataSource=switch-locator-{Guid.NewGuid():N};Mode=Memory;Cache=Shared";
+        var keepAlive = new SqliteConnection(cs);
+        keepAlive.Open();
+        using (var seed = new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(cs).Options))
+        {
+            seed.Database.Migrate();
+        }
+
+        var services = new ServiceCollection();
+        services.AddSingleton(keepAlive);
+        services.AddSingleton(clock);
+        services.AddScoped(_ => new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(cs).Options));
+        services.AddScoped<IWorkspaceStore, WorkspaceStore>();
+        var provider = services.BuildServiceProvider();
+
+        var locator = new SwitchChannelLocator(provider.GetRequiredService<IServiceScopeFactory>(), clock);
+        return (locator, provider, cs, clock);
+    }
+
+    private static async Task<Guid> SeedAsync(string connectionString)
+    {
+        await using var context =
+            new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(connectionString).Options);
+
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+
+        context.ProvisionedChannels.Add(new ProvisionedChannel
+        {
+            GuildId = 10UL,
+            RustServerId = server.Id,
+            ChannelKey = WorkspaceChannelKeys.ServerSwitches,
+            DiscordChannelId = 888UL,
+            CreatedAt = DateTimeOffset.UnixEpoch,
+        });
+
+        // A row with a null RustServerId (global scope) must be skipped by the locator.
+        context.ProvisionedChannels.Add(new ProvisionedChannel
+        {
+            GuildId = 10UL,
+            RustServerId = null,
+            ChannelKey = WorkspaceChannelKeys.ServerSwitches,
+            DiscordChannelId = 777UL,
+            CreatedAt = DateTimeOffset.UnixEpoch,
+        });
+        await context.SaveChangesAsync();
+
+        return server.Id;
+    }
+
+    [Fact]
+    public async Task GetChannelIdAsync_returns_provisioned_switches_channel()
+    {
+        var (locator, provider, cs, _) = CreateLocator();
+        await using var _p = provider;
+        var serverId = await SeedAsync(cs);
+
+        var channelId = await locator.GetChannelIdAsync(10UL, serverId, CancellationToken.None);
+
+        Assert.Equal(888UL, channelId);
+    }
+
+    [Fact]
+    public async Task GetChannelIdAsync_returns_null_when_not_provisioned()
+    {
+        var (locator, provider, _, _) = CreateLocator();
+        await using var _p = provider;
+
+        Assert.Null(await locator.GetChannelIdAsync(10UL, Guid.NewGuid(), CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task Cache_refreshes_after_ttl_expires()
+    {
+        var (locator, provider, cs, clock) = CreateLocator();
+        await using var _p = provider;
+
+        // Cold load with empty DB — cache built at UnixEpoch, no rows.
+        var firstResult = await locator.GetChannelIdAsync(20UL, Guid.NewGuid(), CancellationToken.None);
+        Assert.Null(firstResult);
+
+        // Insert a server + channel into the DB after the first load.
+        await using var insertCtx =
+            new BotDbContext(new DbContextOptionsBuilder<BotDbContext>().UseSqlite(cs).Options);
+        var server = new RustServer
+        {
+            GuildId = 20UL, Name = "T", Ip = "2.2.2.2", Port = 28015
+        };
+        insertCtx.RustServers.Add(server);
+        await insertCtx.SaveChangesAsync();
+        insertCtx.ProvisionedChannels.Add(new ProvisionedChannel
+        {
+            GuildId = 20UL,
+            RustServerId = server.Id,
+            ChannelKey = WorkspaceChannelKeys.ServerSwitches,
+            DiscordChannelId = 999UL,
+            CreatedAt = DateTimeOffset.UnixEpoch,
+        });
+        await insertCtx.SaveChangesAsync();
+
+        // Clock still at UnixEpoch — within the 30 s TTL, cache must NOT be reloaded.
+        var withinTtlResult = await locator.GetChannelIdAsync(20UL, server.Id, CancellationToken.None);
+        Assert.Null(withinTtlResult);
+
+        // Advance the clock past the 30 s TTL — next call must rebuild the cache.
+        clock.UtcNow.Returns(DateTimeOffset.UnixEpoch + TimeSpan.FromSeconds(31));
+
+        var afterTtlResult = await locator.GetChannelIdAsync(20UL, server.Id, CancellationToken.None);
+        Assert.Equal(999UL, afterTtlResult);
+    }
+}
diff --git a/tests/RustPlusBot.Persistence.Tests/PersistenceRegistrationTests.cs b/tests/RustPlusBot.Persistence.Tests/PersistenceRegistrationTests.cs
index c410299..219124e 100644
--- a/tests/RustPlusBot.Persistence.Tests/PersistenceRegistrationTests.cs
+++ b/tests/RustPlusBot.Persistence.Tests/PersistenceRegistrationTests.cs
@@ -5,6 +5,7 @@
 using RustPlusBot.Persistence.Connections;
 using RustPlusBot.Persistence.Credentials;
 using RustPlusBot.Persistence.Servers;
+using RustPlusBot.Persistence.Switches;
 
 namespace RustPlusBot.Persistence.Tests;
 
@@ -33,5 +34,6 @@ public void AddBotPersistence_RegistersDbContextFactoryAndScopedServices()
         Assert.Contains(services, d => d.ServiceType == typeof(ICredentialStore));
         Assert.Contains(services, d => d.ServiceType == typeof(IFcmRegistrationStore));
         Assert.Contains(services, d => d.ServiceType == typeof(IConnectionStore));
+        Assert.Contains(services, d => d.ServiceType == typeof(ISwitchStore));
     }
 }
diff --git a/tests/RustPlusBot.Persistence.Tests/Servers/ServerServiceTests.cs b/tests/RustPlusBot.Persistence.Tests/Servers/ServerServiceTests.cs
index 8e8baaf..b688df4 100644
--- a/tests/RustPlusBot.Persistence.Tests/Servers/ServerServiceTests.cs
+++ b/tests/RustPlusBot.Persistence.Tests/Servers/ServerServiceTests.cs
@@ -1,3 +1,4 @@
+using RustPlusBot.Domain.Servers;
 using RustPlusBot.Persistence.Servers;
 
 namespace RustPlusBot.Persistence.Tests.Servers;
@@ -96,4 +97,91 @@ public async Task ResolveOrCreateByEndpoint_DifferentPortIsDistinct()
 
         Assert.Equal(2, (await service.ListAsync(10UL)).Count);
     }
+
+    [Fact]
+    public async Task GetByEndpoint_returns_existing_server()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var service = new ServerService(context);
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+
+        var found = await service.GetByEndpointAsync(10UL, "1.1.1.1", 28015);
+
+        Assert.NotNull(found);
+        Assert.Equal(server.Id, found.Id);
+    }
+
+    [Fact]
+    public async Task GetByEndpoint_returns_null_for_unknown_endpoint()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var service = new ServerService(context);
+
+        Assert.Null(await service.GetByEndpointAsync(10UL, "9.9.9.9", 28015));
+    }
+
+    [Fact]
+    public async Task GetByFacepunchServerId_returns_matching_server()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var service = new ServerService(context);
+        var fp = Guid.NewGuid();
+        var server = new RustServer
+        {
+            GuildId = 10UL,
+            Name = "S",
+            Ip = "1.1.1.1",
+            Port = 28015,
+            FacepunchServerId = fp,
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+
+        var found = await service.GetByFacepunchServerIdAsync(10UL, fp);
+
+        Assert.NotNull(found);
+        Assert.Equal(server.Id, found.Id);
+        Assert.Null(await service.GetByFacepunchServerIdAsync(10UL, Guid.NewGuid()));
+    }
+
+    [Fact]
+    public async Task SetFacepunchServerId_backfills_then_is_idempotent()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = context;
+        await using var __ = connection;
+        var service = new ServerService(context);
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015,
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+        var g = Guid.NewGuid();
+
+        await service.SetFacepunchServerIdAsync(server.Id, g);
+        var reloaded = await service.GetAsync(10UL, server.Id);
+        Assert.NotNull(reloaded);
+        Assert.Equal(g, reloaded.FacepunchServerId);
+
+        // Calling again with the same GUID is a no-op (no throw, value unchanged).
+        await service.SetFacepunchServerIdAsync(server.Id, g);
+        reloaded = await service.GetAsync(10UL, server.Id);
+        Assert.NotNull(reloaded);
+        Assert.Equal(g, reloaded.FacepunchServerId);
+
+        // An absent server id is a silent no-op (no throw).
+        await service.SetFacepunchServerIdAsync(Guid.NewGuid(), g);
+    }
 }
diff --git a/tests/RustPlusBot.Persistence.Tests/Switches/SmartSwitchSchemaTests.cs b/tests/RustPlusBot.Persistence.Tests/Switches/SmartSwitchSchemaTests.cs
new file mode 100644
index 0000000..e11d0da
--- /dev/null
+++ b/tests/RustPlusBot.Persistence.Tests/Switches/SmartSwitchSchemaTests.cs
@@ -0,0 +1,104 @@
+using Microsoft.EntityFrameworkCore;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Domain.Switches;
+
+namespace RustPlusBot.Persistence.Tests.Switches;
+
+public sealed class SmartSwitchSchemaTests
+{
+    [Fact]
+    public async Task SmartSwitch_round_trips_through_sqlite()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = connection;
+        await using var __ = context;
+
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+
+        var entity = new SmartSwitch
+        {
+            GuildId = 10UL,
+            ServerId = server.Id,
+            EntityId = 42UL,
+            Name = "Switch 42",
+            PairedByUserId = 7UL,
+            LastIsActive = true,
+            CreatedUtc = DateTimeOffset.UnixEpoch,
+        };
+        context.Set<SmartSwitch>().Add(entity);
+        await context.SaveChangesAsync();
+
+        var loaded = await context.Set<SmartSwitch>().SingleAsync();
+        Assert.Equal(42UL, loaded.EntityId);
+        Assert.Equal("Switch 42", loaded.Name);
+        Assert.True(loaded.LastIsActive);
+        Assert.Null(loaded.MessageId);
+    }
+
+    [Fact]
+    public async Task SmartSwitch_cascades_when_server_removed()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = connection;
+        await using var __ = context;
+
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+        context.Set<SmartSwitch>().Add(new SmartSwitch
+        {
+            GuildId = 10UL,
+            ServerId = server.Id,
+            EntityId = 42UL,
+            Name = "Switch 42",
+            CreatedUtc = DateTimeOffset.UnixEpoch,
+        });
+        await context.SaveChangesAsync();
+
+        context.RustServers.Remove(server);
+        await context.SaveChangesAsync();
+
+        Assert.Empty(await context.Set<SmartSwitch>().ToListAsync());
+    }
+
+    [Fact]
+    public async Task SmartSwitch_unique_index_rejects_duplicate_entity()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = connection;
+        await using var __ = context;
+
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = "S", Ip = "1.1.1.1", Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+        context.Set<SmartSwitch>().Add(new SmartSwitch
+        {
+            GuildId = 10UL,
+            ServerId = server.Id,
+            EntityId = 42UL,
+            Name = "A",
+            CreatedUtc = DateTimeOffset.UnixEpoch,
+        });
+        context.Set<SmartSwitch>().Add(new SmartSwitch
+        {
+            GuildId = 10UL,
+            ServerId = server.Id,
+            EntityId = 42UL,
+            Name = "B",
+            CreatedUtc = DateTimeOffset.UnixEpoch,
+        });
+
+        await Assert.ThrowsAsync<DbUpdateException>(() => context.SaveChangesAsync());
+    }
+}
diff --git a/tests/RustPlusBot.Persistence.Tests/Switches/SwitchStoreTests.cs b/tests/RustPlusBot.Persistence.Tests/Switches/SwitchStoreTests.cs
new file mode 100644
index 0000000..a673da2
--- /dev/null
+++ b/tests/RustPlusBot.Persistence.Tests/Switches/SwitchStoreTests.cs
@@ -0,0 +1,149 @@
+using Microsoft.Data.Sqlite;
+using NSubstitute;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Persistence.Switches;
+
+namespace RustPlusBot.Persistence.Tests.Switches;
+
+public sealed class SwitchStoreTests
+{
+    private static (SwitchStore Store, BotDbContext Context, SqliteConnection Conn) Create()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        var clock = Substitute.For<IClock>();
+        clock.UtcNow.Returns(DateTimeOffset.UnixEpoch);
+        return (new SwitchStore(context, clock), context, connection);
+    }
+
+    private static async Task<Guid> SeedServerAsync(BotDbContext context, string ip = "1.1.1.1", string name = "S")
+    {
+        var server = new RustServer
+        {
+            GuildId = 10UL, Name = name, Ip = ip, Port = 28015
+        };
+        context.RustServers.Add(server);
+        await context.SaveChangesAsync();
+        return server.Id;
+    }
+
+    [Fact]
+    public async Task Add_then_Get_round_trips_and_defaults_state_off()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+
+        var added = await store.AddAsync(10UL, serverId, 42UL, "Switch 42", pairedByUserId: 7UL);
+        var loaded = await store.GetAsync(10UL, serverId, 42UL);
+
+        Assert.NotNull(loaded);
+        Assert.Equal(added.Id, loaded.Id);
+        Assert.Equal("Switch 42", loaded.Name);
+        Assert.Equal(7UL, loaded.PairedByUserId);
+        Assert.False(loaded.LastIsActive);
+        Assert.Equal(DateTimeOffset.UnixEpoch, loaded.CreatedUtc);
+    }
+
+    [Fact]
+    public async Task Add_is_idempotent_when_switch_already_exists()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+
+        var first = await store.AddAsync(10UL, serverId, 42UL, "Switch 42", pairedByUserId: 7UL);
+        // Simulates the concurrent double-accept race: a second AddAsync for the same identity must not throw,
+        // and must return the row the first accept persisted (the unique index rejects the duplicate insert).
+        var second = await store.AddAsync(10UL, serverId, 42UL, "Switch 42 (dup)", pairedByUserId: 9UL);
+
+        Assert.Equal(first.Id, second.Id);
+        Assert.Equal("Switch 42", second.Name);
+        Assert.Equal(7UL, second.PairedByUserId);
+        Assert.Single(await store.ListByServerAsync(10UL, serverId));
+    }
+
+    [Fact]
+    public async Task Exists_reflects_presence()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+
+        Assert.False(await store.ExistsAsync(10UL, serverId, 42UL));
+        await store.AddAsync(10UL, serverId, 42UL, "Switch 42", 7UL);
+        Assert.True(await store.ExistsAsync(10UL, serverId, 42UL));
+    }
+
+    [Fact]
+    public async Task ListByServer_returns_only_that_server()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverA = await SeedServerAsync(context);
+        var serverB = await SeedServerAsync(context, ip: "2.2.2.2", name: "T");
+
+        await store.AddAsync(10UL, serverA, 1UL, "A1", 7UL);
+        await store.AddAsync(10UL, serverA, 2UL, "A2", 7UL);
+        await store.AddAsync(10UL, serverB, 3UL, "B1", 7UL);
+
+        var listA = await store.ListByServerAsync(10UL, serverA);
+        Assert.Equal(2, listA.Count);
+        Assert.All(listA, s => Assert.Equal(serverA, s.ServerId));
+    }
+
+    [Fact]
+    public async Task Rename_SetMessageId_UpdateState_mutate_the_row()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+        await store.AddAsync(10UL, serverId, 42UL, "Switch 42", 7UL);
+
+        await store.RenameAsync(10UL, serverId, 42UL, "Front gate");
+        await store.SetMessageIdAsync(10UL, serverId, 42UL, 999UL);
+        await store.UpdateStateAsync(10UL, serverId, 42UL, isActive: true);
+
+        var loaded = await store.GetAsync(10UL, serverId, 42UL);
+        Assert.NotNull(loaded);
+        Assert.Equal("Front gate", loaded.Name);
+        Assert.Equal(999UL, loaded.MessageId);
+        Assert.True(loaded.LastIsActive);
+    }
+
+    [Fact]
+    public async Task Remove_deletes_the_row()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+        await store.AddAsync(10UL, serverId, 42UL, "Switch 42", 7UL);
+
+        await store.RemoveAsync(10UL, serverId, 42UL);
+
+        Assert.Null(await store.GetAsync(10UL, serverId, 42UL));
+    }
+
+    [Fact]
+    public async Task Mutators_are_noops_when_switch_absent()
+    {
+        var (store, context, conn) = Create();
+        await using var _ = conn;
+        await using var __ = context;
+        var serverId = await SeedServerAsync(context);
+
+        // Should not throw.
+        await store.RenameAsync(10UL, serverId, 42UL, "x");
+        await store.SetMessageIdAsync(10UL, serverId, 42UL, 1UL);
+        await store.UpdateStateAsync(10UL, serverId, 42UL, true);
+        await store.RemoveAsync(10UL, serverId, 42UL);
+
+        Assert.Null(await store.GetAsync(10UL, serverId, 42UL));
+    }
+}