Fix force-sync not clearing stale IsProcessing when streaming guard is stuck

The streaming guard (_remoteStreamingSessions) blocks SyncRemoteSessions from
updating IsProcessing. If TurnStart fires but TurnEnd is lost (connection drop),
the guard stays active forever, causing permanent stale 'busy/sending' state
that even the sync button can't fix.

ForceRefreshRemoteAsync now:
- Applies server's authoritative IsProcessing to ALL sessions (bypasses guards)
- Clears stuck streaming guards for sessions the server reports as idle

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: PureWeen

PolyPilot.Tests/BridgeDisconnectTests.cs

@@ -348,4 +348,32 @@ public async Task SyncRemoteSessions_AllowsSessionsListToClearProcessing()
 
         Assert.False(session.IsProcessing);
     }
+
+    [Fact]
+    public async Task ForceSync_ClearsIsProcessing_EvenWithStreamingGuard()
+    {
+        // Scenario: Streaming guard is stuck (TurnStart received but TurnEnd lost).
+        // SyncRemoteSessions skips the session. But ForceRefreshRemoteAsync should
+        // always apply the server's authoritative IsProcessing state.
+        var svc = CreateRemoteService();
+        await AddRemoteSession(svc, "stuck-session");
+        var session = svc.GetSession("stuck-session")!;
+
+        // Session appears processing with a stuck streaming guard
+        session.IsProcessing = true;
+        svc.SetRemoteStreamingGuardForTesting("stuck-session", true);
+
+        // SyncRemoteSessions should skip (streaming guard active)
+        _bridgeClient.Sessions = new() { new SessionSummary { Name = "stuck-session", IsProcessing = false } };
+        svc.SyncRemoteSessions();
+        Assert.True(session.IsProcessing); // Guard blocks the update
+
+        // Force sync should override the streaming guard
+        _bridgeClient.SessionHistories["stuck-session"] = new List<ChatMessage>();
+        var result = await svc.ForceRefreshRemoteAsync("stuck-session");
+
+        Assert.True(result.Success);
+        Assert.False(session.IsProcessing);
+        Assert.False(svc.IsRemoteStreamingGuardActive("stuck-session"));
+    }
 }

PolyPilot/Services/CopilotService.Bridge.cs

@@ -740,6 +740,27 @@ public async Task<SyncResult> ForceRefreshRemoteAsync(string? activeSessionName
                 }
             }
 
+            // Force-sync processing state for ALL sessions from the server snapshot.
+            // SyncRemoteSessions skips sessions in _remoteStreamingSessions, but a user-initiated
+            // force sync should always apply the server's authoritative IsProcessing state.
+            // Also clear stuck streaming guards — if the server says a session is idle,
+            // any lingering guard from a dropped connection should be cleared.
+            foreach (var rs in _bridgeClient.Sessions)
+            {
+                if (_sessions.TryGetValue(rs.Name, out var syncState))
+                {
+                    if (syncState.Info.IsProcessing != rs.IsProcessing)
+                        Debug($"[SYNC] '{rs.Name}' IsProcessing {syncState.Info.IsProcessing} -> {rs.IsProcessing}");
+                    syncState.Info.IsProcessing = rs.IsProcessing;
+                    syncState.Info.ProcessingStartedAt = rs.ProcessingStartedAt;
+                    syncState.Info.ToolCallCount = rs.ToolCallCount;
+                    syncState.Info.ProcessingPhase = rs.ProcessingPhase;
+                    // Clear stuck streaming guard if server says session is idle
+                    if (!rs.IsProcessing)
+                        _remoteStreamingSessions.TryRemove(rs.Name, out _);
+                }
+            }
+
             // Snapshot post-sync state
             var postSyncSessionCount = _sessions.Count;
             var postSyncMessageCount = 0;