fix(players): address Copilot review + ReSharper format gate

- AFK: clear the latch SILENTLY when a member goes offline, is dead, or
  died this poll (detected via LastDeathTimeUtc advancing even on a slow
  poll where IsAlive already flipped back), instead of emitting a
  contradictory ReturnedFromAfk alongside the disconnect/death line.
- AFK movement: use a squared-distance check so AfkEpsilon is a true
  movement radius (per-axis treated diagonal moves as still).
- Prune per-member stillness/AFK state for ids absent from the snapshot
  (members who leave the team) so the maps don't grow unbounded.
- Add player.title to the localization-catalog key-coverage test.
- Run jb cleanupcode (ReformatAndReorder) — fixes the Linux CI format gate
  that the original push skipped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Connections/Listening/IAfkState.cs

@@ -14,5 +14,7 @@ public interface IAfkState
     /// <param name="serverId">The target server id.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
     /// <returns>The currently-AFK members, or null when there is no live socket.</returns>
-    Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken);
+    Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(ulong guildId,
+        Guid serverId,
+        CancellationToken cancellationToken);
 }

src/RustPlusBot.Features.Connections/Listening/TeamStateTracker.cs

@@ -5,10 +5,10 @@ namespace RustPlusBot.Features.Connections.Listening;
 /// <summary>Diffs successive team snapshots into presence transitions. One instance per connected window.</summary>
 internal sealed class TeamStateTracker
 {
+    private readonly HashSet<ulong> _afk = new();
     private readonly object _gate = new();
-    private Dictionary<ulong, TeamMemberSnapshot>? _baseline;
     private readonly Dictionary<ulong, DateTimeOffset> _stillSince = new();
-    private readonly HashSet<ulong> _afk = new();
+    private Dictionary<ulong, TeamMemberSnapshot>? _baseline;
 
     /// <summary>Diffs <paramref name="snapshot"/> against the previous one. First non-null call primes silently.</summary>
     /// <param name="snapshot">The latest team snapshot, or null when the poll returned no data.</param>
@@ -17,7 +17,10 @@ internal sealed class TeamStateTracker
     /// <param name="afkEpsilon">Movement tolerance (world units) below which a member is considered still.</param>
     /// <returns>The transitions since the previous snapshot; empty on prime, null input, or no change.</returns>
     public IReadOnlyList<PlayerTransition> Diff(
-        TeamInfoSnapshot? snapshot, DateTimeOffset now, TimeSpan afkThreshold, float afkEpsilon)
+        TeamInfoSnapshot? snapshot,
+        DateTimeOffset now,
+        TimeSpan afkThreshold,
+        float afkEpsilon)
     {
         if (snapshot is null)
         {
@@ -49,17 +52,22 @@ public IReadOnlyList<PlayerTransition> Diff(
                 }
 
                 AddPresenceTransitions(transitions, id, was, nowMember, snapshot);
-                UpdateAfk(transitions, id, was, nowMember, now, afkThreshold, afkEpsilon);
+                var diedThisPoll = nowMember.LastDeathTimeUtc > was.LastDeathTimeUtc;
+                UpdateAfk(transitions, id, was, nowMember, now, afkThreshold, afkEpsilon, diedThisPoll);
             }
 
+            PruneDepartedMembers(current);
             _baseline = current;
             return transitions;
         }
     }
 
     private static void AddPresenceTransitions(
-        List<PlayerTransition> transitions, ulong id,
-        TeamMemberSnapshot was, TeamMemberSnapshot now, TeamInfoSnapshot snapshot)
+        List<PlayerTransition> transitions,
+        ulong id,
+        TeamMemberSnapshot was,
+        TeamMemberSnapshot now,
+        TeamInfoSnapshot snapshot)
     {
         if (now.IsOnline && !was.IsOnline)
         {
@@ -83,22 +91,31 @@ private static void AddPresenceTransitions(
     }
 
     private void UpdateAfk(
-        List<PlayerTransition> transitions, ulong id,
-        TeamMemberSnapshot was, TeamMemberSnapshot now, DateTimeOffset clock, TimeSpan threshold, float epsilon)
+        List<PlayerTransition> transitions,
+        ulong id,
+        TeamMemberSnapshot was,
+        TeamMemberSnapshot now,
+        DateTimeOffset clock,
+        TimeSpan threshold,
+        float epsilon,
+        bool diedThisPoll)
     {
-        var eligible = now.IsOnline && now.IsAlive;
-        if (!eligible)
+        // A member who goes offline, is dead, or died this poll (even if a slow poll already shows them
+        // respawned) can no longer be AFK. Clear the AFK latch SILENTLY — the disconnect/death transition
+        // already speaks for them, and a "back" line alongside "disconnected"/"died" would contradict it —
+        // and reset the stillness clock so AFK must be re-earned after the state change.
+        if (!now.IsOnline || !now.IsAlive || diedThisPoll)
         {
-            if (_afk.Remove(id))
-            {
-                transitions.Add(new PlayerTransition(PlayerTransitionKind.ReturnedFromAfk, id, now.Name, null));
-            }
-
+            _afk.Remove(id);
             _stillSince[id] = clock;
             return;
         }
 
-        var moved = Math.Abs(now.X - was.X) > epsilon || Math.Abs(now.Y - was.Y) > epsilon;
+        // Squared-distance check so epsilon is a true movement radius (per-axis would treat diagonal
+        // movement of dx=dy=0.8, epsilon=1 — distance ≈ 1.13 — as still).
+        var dx = now.X - was.X;
+        var dy = now.Y - was.Y;
+        var moved = (dx * dx) + (dy * dy) > epsilon * epsilon;
         if (moved)
         {
             _stillSince[id] = clock;
@@ -118,6 +135,23 @@ private void UpdateAfk(
         }
     }
 
+    /// <summary>Drops per-member AFK/stillness state for ids no longer present in the team snapshot.</summary>
+    /// <param name="current">The members in the latest snapshot, keyed by Steam id.</param>
+    private void PruneDepartedMembers(Dictionary<ulong, TeamMemberSnapshot> current)
+    {
+        if (_stillSince.Count == 0 && _afk.Count == 0)
+        {
+            return;
+        }
+
+        foreach (var id in _stillSince.Keys.Where(id => !current.ContainsKey(id)).ToList())
+        {
+            _stillSince.Remove(id);
+        }
+
+        _afk.RemoveWhere(id => !current.ContainsKey(id));
+    }
+
     /// <summary>The members currently flagged AFK and how long each has been still, as of <paramref name="now"/>.</summary>
     /// <param name="now">The current wall-clock time used to compute each member's still duration.</param>
     public IReadOnlyList<AfkMember> CurrentAfk(DateTimeOffset now)
@@ -139,7 +173,9 @@ public IReadOnlyList<AfkMember> CurrentAfk(DateTimeOffset now)
     }
 
     private static (float X, float Y)? ResolveDeathLocation(
-        ulong steamId, TeamInfoSnapshot snapshot, TeamMemberSnapshot previous)
+        ulong steamId,
+        TeamInfoSnapshot snapshot,
+        TeamMemberSnapshot previous)
     {
         // Leader: the single DeathNote is the true death spot (player respawns elsewhere).
         if (steamId == snapshot.LeaderSteamId && snapshot.DeathNote is { } note)

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -32,7 +32,8 @@ internal sealed partial class ConnectionSupervisor(
     IEventBus eventBus,
     IClock clock,
     IOptions<ConnectionOptions> options,
-    ILogger<ConnectionSupervisor> logger) : IConnectionSupervisor, ITeamChatSender, IRustServerQuery, IAfkState, IAsyncDisposable
+    ILogger<ConnectionSupervisor> logger)
+    : IConnectionSupervisor, ITeamChatSender, IRustServerQuery, IAfkState, IAsyncDisposable
 {
     private readonly ConcurrentDictionary<(ulong Guild, Guid Server), Handle> _connections = new();
     private readonly SemaphoreSlim _gate = new(1, 1);
@@ -41,6 +42,20 @@ internal sealed partial class ConnectionSupervisor(
     private readonly CancellationTokenSource _shutdown = new();
     private bool _disposed;
 
+    /// <inheritdoc />
+    public Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(
+        ulong guildId,
+        Guid serverId,
+        CancellationToken cancellationToken)
+    {
+        if (_liveSockets.TryGetValue((guildId, serverId), out var live))
+        {
+            return Task.FromResult<IReadOnlyList<AfkMember>?>(live.Tracker.CurrentAfk(clock.UtcNow));
+        }
+
+        return Task.FromResult<IReadOnlyList<AfkMember>?>(null);
+    }
+
     /// <inheritdoc />
     public async ValueTask DisposeAsync()
     {
@@ -259,18 +274,6 @@ public async Task<TeamChatSendResult> SendAsync(
         }
     }
 
-    /// <inheritdoc />
-    public Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(
-        ulong guildId, Guid serverId, CancellationToken cancellationToken)
-    {
-        if (_liveSockets.TryGetValue((guildId, serverId), out var live))
-        {
-            return Task.FromResult<IReadOnlyList<AfkMember>?>(live.Tracker.CurrentAfk(clock.UtcNow));
-        }
-
-        return Task.FromResult<IReadOnlyList<AfkMember>?>(null);
-    }
-
     [LoggerMessage(Level = LogLevel.Error, Message = "Connection loop for server {ServerId} faulted.")]
     private static partial void LogLoopFaulted(ILogger logger, Exception exception, Guid serverId);
 

src/RustPlusBot.Features.Players/Relaying/PlayerEventRelay.cs

@@ -39,7 +39,8 @@ public async Task RelayAsync(PlayerStateChangedEvent evt, CancellationToken canc
         foreach (var t in evt.Transitions)
         {
             await teamChatSender
-                .SendAsync(evt.GuildId, evt.ServerId, renderer.RenderLine(t, evt.Dimensions, culture), cancellationToken)
+                .SendAsync(evt.GuildId, evt.ServerId, renderer.RenderLine(t, evt.Dimensions, culture),
+                    cancellationToken)
                 .ConfigureAwait(false);
             if (channelId is { } id)
             {

tests/RustPlusBot.Features.Commands.Tests/AfkCommandHandlerTests.cs

@@ -38,7 +38,10 @@ public async Task Reports_none_when_empty()
     public async Task Lists_afk_members_with_durations()
     {
         _afk.GetAfkMembersAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>())
-            .Returns(new List<AfkMember> { new(1, "Bob", TimeSpan.FromMinutes(6)) });
+            .Returns(new List<AfkMember>
+            {
+                new(1, "Bob", TimeSpan.FromMinutes(6))
+            });
         var reply = await new AfkCommandHandler(_afk, _localizer).ExecuteAsync(Ctx(), CancellationToken.None);
         Assert.Contains("Bob", reply, StringComparison.Ordinal);
     }

tests/RustPlusBot.Features.Connections.Tests/TeamStateTrackerAfkTests.cs

@@ -5,11 +5,17 @@ namespace RustPlusBot.Features.Connections.Tests;
 
 public sealed class TeamStateTrackerAfkTests
 {
-    private static readonly TimeSpan Threshold = TimeSpan.FromMinutes(5);
     private const float Eps = 1f;
+    private static readonly TimeSpan Threshold = TimeSpan.FromMinutes(5);
 
-    private static TeamMemberSnapshot Member(ulong id, float x, float y, bool online = true, bool alive = true)
-        => new(id, $"P{id}", x, y, online, alive, DateTimeOffset.UnixEpoch, DateTimeOffset.UnixEpoch);
+    private static TeamMemberSnapshot Member(
+        ulong id,
+        float x,
+        float y,
+        bool online = true,
+        bool alive = true,
+        DateTimeOffset death = default)
+        => new(id, $"P{id}", x, y, online, alive, DateTimeOffset.UnixEpoch, death);
 
     private static TeamInfoSnapshot Team(params TeamMemberSnapshot[] m) => new(1, m);
 
@@ -18,9 +24,9 @@ public void Still_for_threshold_emits_one_BecameAfk()
     {
         var t = new TeamStateTracker();
         var t0 = DateTimeOffset.UnixEpoch;
-        t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps);                       // prime
+        t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps); // prime
         Assert.Empty(t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(2), Threshold, Eps)); // still, < threshold
-        var afk = t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps);     // crossed
+        var afk = t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps); // crossed
         Assert.Single(afk, x => x.Kind == PlayerTransitionKind.BecameAfk && x.Location == (0f, 0f));
         Assert.Empty(t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(9), Threshold, Eps)); // latched, no repeat
     }
@@ -31,20 +37,38 @@ public void Moving_after_afk_emits_ReturnedFromAfk()
         var t = new TeamStateTracker();
         var t0 = DateTimeOffset.UnixEpoch;
         t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps);
-        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps);          // BecameAfk
+        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps); // BecameAfk
         var back = t.Diff(Team(Member(1, 50, 50)), t0.AddMinutes(7), Threshold, Eps);
         Assert.Single(back, x => x.Kind == PlayerTransitionKind.ReturnedFromAfk && x.Location == null);
     }
 
     [Fact]
-    public void Going_offline_while_afk_emits_ReturnedFromAfk()
+    public void Going_offline_while_afk_clears_silently_without_ReturnedFromAfk()
     {
         var t = new TeamStateTracker();
         var t0 = DateTimeOffset.UnixEpoch;
         t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps);
-        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps);          // BecameAfk
+        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps); // BecameAfk
         var off = t.Diff(Team(Member(1, 0, 0, online: false)), t0.AddMinutes(7), Threshold, Eps);
-        Assert.Contains(off, x => x.Kind == PlayerTransitionKind.ReturnedFromAfk);
+        // The Disconnect transition speaks for them; no contradictory "is back" line.
+        Assert.DoesNotContain(off, x => x.Kind == PlayerTransitionKind.ReturnedFromAfk);
+        Assert.Contains(off, x => x.Kind == PlayerTransitionKind.Disconnect);
+        Assert.Empty(t.CurrentAfk(t0.AddMinutes(7)));
+    }
+
+    [Fact]
+    public void Dying_while_afk_clears_silently_even_if_already_respawned()
+    {
+        var t = new TeamStateTracker();
+        var t0 = DateTimeOffset.UnixEpoch;
+        t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps);
+        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(6), Threshold, Eps); // BecameAfk
+        // Slow poll: died and already respawned (IsAlive true), but LastDeathTime advanced.
+        var died = t.Diff(
+            Team(Member(1, 0, 0, alive: true, death: t0.AddMinutes(7))), t0.AddMinutes(8), Threshold, Eps);
+        Assert.DoesNotContain(died, x => x.Kind == PlayerTransitionKind.ReturnedFromAfk);
+        Assert.Contains(died, x => x.Kind == PlayerTransitionKind.Death);
+        Assert.Empty(t.CurrentAfk(t0.AddMinutes(8)));
     }
 
     [Fact]
@@ -65,4 +89,30 @@ public void Small_jitter_below_epsilon_still_counts_as_still()
         var afk = t.Diff(Team(Member(1, 0.5f, 0.5f)), t0.AddMinutes(6), Threshold, Eps); // < 1 unit move
         Assert.Single(afk, x => x.Kind == PlayerTransitionKind.BecameAfk);
     }
+
+    [Fact]
+    public void Diagonal_move_beyond_epsilon_radius_counts_as_moved()
+    {
+        var t = new TeamStateTracker();
+        var t0 = DateTimeOffset.UnixEpoch;
+        t.Diff(Team(Member(1, 0, 0)), t0, Threshold, Eps);
+        // dx=dy=0.8 → distance ≈ 1.13 > epsilon 1; per-axis would wrongly call this "still".
+        var afk = t.Diff(Team(Member(1, 0.8f, 0.8f)), t0.AddMinutes(6), Threshold, Eps);
+        Assert.DoesNotContain(afk, x => x.Kind == PlayerTransitionKind.BecameAfk);
+    }
+
+    [Fact]
+    public void Departed_member_state_is_pruned()
+    {
+        var t = new TeamStateTracker();
+        var t0 = DateTimeOffset.UnixEpoch;
+        t.Diff(Team(Member(1, 0, 0), Member(2, 0, 0)), t0, Threshold, Eps);
+        t.Diff(Team(Member(1, 0, 0), Member(2, 0, 0)), t0.AddMinutes(6), Threshold, Eps); // both BecameAfk
+        Assert.Equal(2, t.CurrentAfk(t0.AddMinutes(6)).Count);
+        // Member 2 leaves the team (absent from the snapshot entirely).
+        t.Diff(Team(Member(1, 0, 0)), t0.AddMinutes(7), Threshold, Eps);
+        var afk = t.CurrentAfk(t0.AddMinutes(7));
+        Assert.Single(afk);
+        Assert.Equal(1UL, afk[0].SteamId);
+    }
 }