Detect reconnect-time logout by account presence, not token fetch

The Reconnecting handler decided "logged out" from whether a token could be
fetched right then -- but reconnecting happens precisely when the network is
flaky, and fetching a token can require a refresh round-trip that fails
transiently, which read as a false logout and tore down a listener that
should have kept retrying. Switch the signal to IsSignedIn (a local-only
account-presence read that flips only on a real logout), now available from
the merged OAuth fixes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: myieye

backend/FwLite/FwLiteShared.Tests/Projects/LexboxProjectServiceTests.cs

@@ -11,7 +11,7 @@ public class LexboxProjectServiceTests
     private readonly MemoryCache _cache = new(new MemoryCacheOptions());
 
     [Fact]
-    public async Task HandleReconnecting_WithValidToken_KeepsCacheAndDoesNotStop()
+    public async Task HandleReconnecting_WhenSignedIn_KeepsCacheAndDoesNotStop()
     {
         var connection = new object();
         _cache.Set(CacheKey, connection);
@@ -23,15 +23,15 @@ await LexboxProjectService.HandleReconnecting(
             NullLogger.Instance,
             connection,
             () => { stopCalled = true; return Task.CompletedTask; },
-            hasValidToken: true,
+            isSignedIn: true,
             exception: null);
 
         _cache.TryGetValue(CacheKey, out _).Should().BeTrue();
         stopCalled.Should().BeFalse();
     }
 
     [Fact]
-    public async Task HandleReconnecting_WithNoToken_EvictsCacheAndStopsConnection()
+    public async Task HandleReconnecting_WhenLoggedOut_EvictsCacheAndStopsConnection()
     {
         var connection = new object();
         _cache.Set(CacheKey, connection);
@@ -43,18 +43,18 @@ await LexboxProjectService.HandleReconnecting(
             NullLogger.Instance,
             connection,
             () => { stopCalled = true; return Task.CompletedTask; },
-            hasValidToken: false,
+            isSignedIn: false,
             exception: null);
 
         _cache.TryGetValue(CacheKey, out _).Should().BeFalse();
         stopCalled.Should().BeTrue();
     }
 
     [Fact]
-    public async Task HandleReconnecting_WithNoToken_DoesNotEvictAReplacementConnection()
+    public async Task HandleReconnecting_WhenLoggedOut_DoesNotEvictAReplacementConnection()
     {
         // A replacement can be cached between this connection entering Reconnecting and the handler running;
-        // evicting it would orphan a live connection. The handler must still stop ITSELF (it has no token).
+        // evicting it would orphan a live connection. The handler must still stop ITSELF (it's logged out).
         var replacement = new object();
         _cache.Set(CacheKey, replacement);
         var stopCalled = false;
@@ -65,7 +65,7 @@ await LexboxProjectService.HandleReconnecting(
             NullLogger.Instance,
             connection: new object(),
             () => { stopCalled = true; return Task.CompletedTask; },
-            hasValidToken: false,
+            isSignedIn: false,
             exception: null);
 
         _cache.TryGetValue(CacheKey, out object? cached).Should().BeTrue();

backend/FwLite/FwLiteShared/Projects/LexboxProjectService.cs

@@ -460,31 +460,33 @@ internal static async Task EvictAndStopIfCached(string cacheKey, IMemoryCache ca
     }
 
     // Internal for unit tests. The retry policy never gives up; this breaks the loop when the user is
-    // logged out. We treat "no token" as "logged out" — distinguishing a transient token failure from a
-    // real logout is OAuthClient's job (see its failure classifier), not ours. Once the user signs back
-    // in, OnAuthenticationChangedAsync rebuilds the listener.
+    // logged out. Logged-out is tested by account presence (IsSignedIn), not by whether a token can be
+    // fetched right now: reconnecting happens precisely when the network is flaky, and fetching a token
+    // can require a refresh round-trip that fails transiently — which would be a false logout. Account
+    // presence is a local-only read and only flips on a real logout. Once the user signs back in,
+    // OnAuthenticationChangedAsync rebuilds the listener.
     internal static async Task HandleReconnecting(
         string cacheKey,
         IMemoryCache cache,
         ILogger logger,
         object connection,
         Func<Task> stopConnection,
-        bool hasValidToken,
+        bool isSignedIn,
         Exception? exception)
     {
         if (exception is not null)
             logger.LogWarning(exception, "SignalR connection reconnecting");
         else
             logger.LogInformation("SignalR connection reconnecting");
 
-        if (hasValidToken) return;
+        if (isSignedIn) return;
 
         // Same guard as the Closed handler: a replacement connection may have been cached since this one
         // started reconnecting; only evict the entry if it is still ours. Stopping ourselves is right
-        // regardless — we are the connection that has no token.
+        // regardless — this connection belongs to a signed-out user.
         if (cache.TryGetValue(cacheKey, out object? cached) && ReferenceEquals(cached, connection))
             cache.Remove(cacheKey);
-        logger.LogWarning("SignalR reconnect aborted: no auth token (logged out); stopping connection");
+        logger.LogWarning("SignalR reconnect aborted: user is logged out; stopping connection");
         try
         {
             await stopConnection();
@@ -593,8 +595,8 @@ internal class AdaptiveRetryPolicy(INetworkStatus networkStatus) : IRetryPolicy
             var cacheKey = HubConnectionCacheKey(server);
             connection.Reconnecting += async exception =>
             {
-                var hasValidToken = await clientFactory.GetClient(server).GetCurrentToken() is not null;
-                await HandleReconnecting(cacheKey, cache, logger, connection, () => connection.StopAsync(), hasValidToken, exception);
+                var isSignedIn = await clientFactory.GetClient(server).IsSignedIn();
+                await HandleReconnecting(cacheKey, cache, logger, connection, () => connection.StopAsync(), isSignedIn, exception);
             };
             await connection.StartAsync(stoppingToken);
             // intentionally AFTER StartAsync (see catch comment)