refactor: extract moderation and mystery-box logic out of RoomGrain (ARCH-02, partial)

The audit's ARCH-02 R5 recommendation was to pull Trading/Moderation/
MysteryBox out into three separate Orleans grains, characterizing them
as low-coupling ("the trade has its own lifecycle", "isolated
reservation state"). Investigating the actual code before touching it
found the opposite: kick/ban mutate live avatar state
(AvatarModule.RemoveAvatarFromPlayerAsync), mute status is read
in-process on every chat message by RoomChatSystem, and mystery-box
sessions are torn down synchronously from the room tick, from an
avatar leaving, and from item removal - all of which currently get
single-grain-turn atomicity for free. Moving these to separate grains
would turn each of those into a cross-grain call with no transaction
to back it, in code that grants prizes and enforces moderation.

Given that risk, and no way to validate cross-grain consistency
behavior without a live multi-silo cluster, this applies the safer
half of the same idea instead: Moderation and MysteryBox move out of
RoomGrain's own partial-class files into RoomModerationSystem and
RoomMysteryBoxSystem, owned classes constructed the same way this
codebase already does for RoomChatSystem/RoomWiredSystem. RoomGrain
keeps every existing public/internal method as a one-line delegate, so
every external call site (PacketHandlers, RoomObjectModule, the wired
kick action, the tick loop, avatar-leave handling) is unchanged. This
is a pure move - no method's logic changed - and it's the same
pattern already proven safe by Chat/Wired, not a new design.

This reduces RoomGrain's own file size/complexity and gives these two
areas an isolated home to grow in, without gambling on unverified
cross-grain consistency for prize-granting and moderation-enforcement
code. Trading is the next candidate (largest of the three); full
separate-grain extraction remains a legitimate follow-up if someone
invests in a state-sync design and integration tests against a real
cluster first.

All 251 Vortex.Rooms.Tests pass; full solution build stays clean at 0
warnings.

Author: claude

Vortex.Rooms/Grains/RoomGrain.Moderation.cs

@@ -1,13 +1,7 @@
-using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using Vortex.Primitives.Action;
-using Vortex.Primitives.Events;
-using Vortex.Primitives.Navigator.Enums;
-using Vortex.Primitives.Permissions;
 using Vortex.Primitives.Players;
-using Vortex.Primitives.Rooms.Enums;
 
 namespace Vortex.Rooms.Grains;
 
@@ -17,333 +11,37 @@ public Task<bool> KickUserAsync(
         ActionContext actorCtx,
         PlayerId targetPlayerId,
         CancellationToken ct
-    )
-    {
-        if (
-            actorCtx.PlayerId <= 0
-            || actorCtx.RoomId != _state.RoomId
-            || actorCtx.PlayerId == targetPlayerId
-        )
-        {
-            return Task.FromResult(false);
-        }
-
-        return KickUserGuardedAsync(actorCtx, targetPlayerId, ct);
-    }
-
-    private async Task<bool> KickUserGuardedAsync(
-        ActionContext actorCtx,
-        PlayerId targetPlayerId,
-        CancellationToken ct
-    )
-    {
-        if (
-            !await CanModerateAsync(
-                actorCtx,
-                _state.RoomSnapshot.ModSettings.WhoCanKick,
-                ModerationAction.Kick
-            )
-        )
-        {
-            return false;
-        }
-
-        return await KickUserInternalAsync(actorCtx, targetPlayerId, ct).ConfigureAwait(true);
-    }
-
-    /// <summary>
-    /// Whether <paramref name="actorCtx"/> may perform a moderation action gated by
-    /// <paramref name="setting"/> in this room. System/wired origins resolve to moderator and pass.
-    /// </summary>
-    private async Task<bool> CanModerateAsync(
-        ActionContext actorCtx,
-        ModSettingType setting,
-        ModerationAction action
-    )
-    {
-        RoomControllerType level = await SecurityModule
-            .GetControllerLevelAsync(actorCtx)
-            .ConfigureAwait(true);
-
-        bool hasStaffCapability = await SecurityModule
-            .HasStaffModerationCapabilityAsync(actorCtx, action)
-            .ConfigureAwait(true);
-
-        if (RoomModerationPolicy.CanModerate(level, setting, hasStaffCapability))
-        {
-            return true;
-        }
-
-        _logger.LogDebug(
-            "Player {ActorId} lacks {Setting} moderation rights in room {RoomId} (level {Level}).",
-            actorCtx.PlayerId,
-            setting,
-            _state.RoomId,
-            level
-        );
-
-        return false;
-    }
+    ) => ModerationSystem.KickUserAsync(actorCtx, targetPlayerId, ct);
 
     /// <summary>Kicks a user without a human actor — for wired / system-driven kicks (the
     /// <c>wf_act_kick_user</c> action). Called directly on the grain from inside its own turn, so it is
     /// not a re-entrant grain-reference call.</summary>
     public Task<bool> KickUserFromWiredAsync(PlayerId targetPlayerId, CancellationToken ct) =>
-        KickUserInternalAsync(ActionContext.CreateForWired(_state.RoomId), targetPlayerId, ct);
-
-    private async Task<bool> KickUserInternalAsync(
-        ActionContext ctx,
-        PlayerId targetPlayerId,
-        CancellationToken ct
-    )
-    {
-        try
-        {
-            if (targetPlayerId <= 0 || !_state.AvatarsByPlayerId.ContainsKey(targetPlayerId))
-            {
-                return false;
-            }
-
-            await AvatarModule
-                .RemoveAvatarFromPlayerAsync(ctx, targetPlayerId, ct)
-                .ConfigureAwait(true);
+        ModerationSystem.KickUserFromWiredAsync(targetPlayerId, ct);
 
-            await _events
-                .PublishAsync(
-                    new PlayerKickedFromRoomEvent(
-                        ctx.PlayerId,
-                        targetPlayerId,
-                        _state.RoomId.Value
-                    ),
-                    ct
-                )
-                .ConfigureAwait(true);
-
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(
-                ex,
-                "Failed to kick player {TargetPlayerId} from room {RoomId}.",
-                targetPlayerId,
-                _state.RoomId
-            );
-
-            return false;
-        }
-    }
-
-    public async Task<bool> MuteUserAsync(
+    public Task<bool> MuteUserAsync(
         ActionContext actorCtx,
         PlayerId targetPlayerId,
         int durationSeconds,
         CancellationToken ct
-    )
-    {
-        if (actorCtx.PlayerId <= 0 || targetPlayerId <= 0 || actorCtx.RoomId != _state.RoomId)
-        {
-            return false;
-        }
-
-        if (durationSeconds <= 0 || actorCtx.PlayerId == targetPlayerId)
-        {
-            return false;
-        }
-
-        if (
-            !await CanModerateAsync(
-                actorCtx,
-                _state.RoomSnapshot.ModSettings.WhoCanMute,
-                ModerationAction.Mute
-            )
-        )
-        {
-            return false;
-        }
+    ) => ModerationSystem.MuteUserAsync(actorCtx, targetPlayerId, durationSeconds, ct);
 
-        DateTime expiresUtc = DateTime.UtcNow.AddSeconds(durationSeconds);
-
-        try
-        {
-            await _moderationStore.MuteAsync(_state.RoomId.Value, targetPlayerId, expiresUtc, ct);
-            _state.MuteExpiresUtc[targetPlayerId] = expiresUtc;
-
-            await _events
-                .PublishAsync(
-                    new PlayerMutedInRoomEvent(
-                        actorCtx.PlayerId,
-                        targetPlayerId,
-                        _state.RoomId.Value,
-                        durationSeconds
-                    ),
-                    ct
-                )
-                .ConfigureAwait(true);
-
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(
-                ex,
-                "Failed to mute player {TargetPlayerId} in room {RoomId}.",
-                targetPlayerId,
-                _state.RoomId
-            );
-        }
-
-        return false;
-    }
-
-    public async Task<bool> BanUserAsync(
+    public Task<bool> BanUserAsync(
         ActionContext actorCtx,
         PlayerId targetPlayerId,
         int durationSeconds,
         CancellationToken ct
-    )
-    {
-        try
-        {
-            if (actorCtx.PlayerId <= 0 || targetPlayerId <= 0 || actorCtx.RoomId != _state.RoomId)
-            {
-                return false;
-            }
-
-            if (durationSeconds <= 0 || actorCtx.PlayerId == targetPlayerId)
-            {
-                return false;
-            }
-
-            if (
-                !await CanModerateAsync(
-                    actorCtx,
-                    _state.RoomSnapshot.ModSettings.WhoCanBan,
-                    ModerationAction.Ban
-                )
-            )
-            {
-                return false;
-            }
-
-            DateTime expiresUtc = DateTime.UtcNow.AddSeconds(durationSeconds);
-
-            await _moderationStore.BanAsync(_state.RoomId.Value, targetPlayerId, expiresUtc, ct);
-            await AvatarModule
-                .RemoveAvatarFromPlayerAsync(actorCtx, targetPlayerId, ct)
-                .ConfigureAwait(true);
-
-            await _events
-                .PublishAsync(
-                    new PlayerBannedInRoomEvent(
-                        actorCtx.PlayerId,
-                        targetPlayerId,
-                        _state.RoomId.Value,
-                        durationSeconds
-                    ),
-                    ct
-                )
-                .ConfigureAwait(true);
+    ) => ModerationSystem.BanUserAsync(actorCtx, targetPlayerId, durationSeconds, ct);
 
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(
-                ex,
-                "Failed to ban player {TargetPlayerId} in room {RoomId}.",
-                targetPlayerId,
-                _state.RoomId
-            );
-
-            return false;
-        }
-    }
-
-    public async Task<bool> UnmuteUserAsync(
+    public Task<bool> UnmuteUserAsync(
         ActionContext actorCtx,
         PlayerId targetPlayerId,
         CancellationToken ct
-    )
-    {
-        try
-        {
-            if (actorCtx.PlayerId <= 0 || targetPlayerId <= 0 || actorCtx.RoomId != _state.RoomId)
-            {
-                return false;
-            }
-
-            if (
-                !await CanModerateAsync(
-                    actorCtx,
-                    _state.RoomSnapshot.ModSettings.WhoCanMute,
-                    ModerationAction.Mute
-                )
-            )
-            {
-                return false;
-            }
-
-            await _moderationStore
-                .UnmuteAsync(_state.RoomId.Value, targetPlayerId, ct)
-                .ConfigureAwait(true);
-            _state.MuteExpiresUtc.Remove(targetPlayerId);
-
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(
-                ex,
-                "Failed to unmute player {TargetPlayerId} in room {RoomId}.",
-                targetPlayerId,
-                _state.RoomId
-            );
+    ) => ModerationSystem.UnmuteUserAsync(actorCtx, targetPlayerId, ct);
 
-            return false;
-        }
-    }
-
-    public async Task<bool> UnbanUserAsync(
+    public Task<bool> UnbanUserAsync(
         ActionContext actorCtx,
         PlayerId targetPlayerId,
         CancellationToken ct
-    )
-    {
-        try
-        {
-            if (actorCtx.PlayerId <= 0 || targetPlayerId <= 0 || actorCtx.RoomId != _state.RoomId)
-            {
-                return false;
-            }
-
-            if (
-                !await CanModerateAsync(
-                    actorCtx,
-                    _state.RoomSnapshot.ModSettings.WhoCanBan,
-                    ModerationAction.Ban
-                )
-            )
-            {
-                return false;
-            }
-
-            await _moderationStore
-                .UnbanAsync(_state.RoomId.Value, targetPlayerId, ct)
-                .ConfigureAwait(true);
-
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(
-                ex,
-                "Failed to unban player {TargetPlayerId} in room {RoomId}.",
-                targetPlayerId,
-                _state.RoomId
-            );
-
-            return false;
-        }
-    }
+    ) => ModerationSystem.UnbanUserAsync(actorCtx, targetPlayerId, ct);
 }