feat: Manual Focus ordering + Mac sleep/wake resilience (#415)

## Summary

Reworks the PolyPilot dashboard Focus strip to give full manual control
over session ordering, adds Mac sleep/wake resilience, and improves card
scroll stability.

## Features

### 🎯 Manual Focus Ordering
- `FocusOrder` list in `OrganizationState` — full manual control, no
auto-sorting
- `GetFocusSessions()` returns sessions in exact `FocusOrder` sequence;
bootstraps from all non-worker sessions on first use (upgrade path)
- **⬆ / ⬇** reorder buttons on each Focus strip card
- **✕** remove button to evict a session from the Focus strip
- `AddToFocus(sessionName)` called in `SendPromptAsync` so sending a
message re-adds it automatically
- `FocusOrder` persisted in `SaveOrganizationCore()` snapshot (was
missing — data loss bug fixed)

### 🤖 Worker Filtering
- Workers excluded from Focus strip by both `Role == Worker` and
name-pattern regex (`-[Ww]orker-\d+`)
- Orchestrators show an **active worker count badge** when workers are
processing

### 💤 Mac Sleep/Wake Resilience
- `MacSleepWakeMonitor`: subscribes to `NSWorkspaceDidWakeNotification`
/ `NSWorkspaceWillSleepNotification` via ObjC P/Invoke on
`NSWorkspace.sharedWorkspace.notificationCenter`
- Triggers `CheckConnectionHealthAsync` immediately on wake — fixes
PolyPilot stalling after Mac sleep

### 🖱 Card Scroll Stability
- `wasAtBottom` tracking in the textarea auto-resize script: if the card
was scrolled to the bottom before a keypress, it stays pinned after the
textarea grows — prevents jitter while typing during streaming

### 🔄 WsBridgeServer Stability
- `AcceptLoopAsync` now uses exponential backoff on accept failures to
prevent tight failure loops

## Bug Fixes (from code review)
- **FocusOrder not persisted**: `SaveOrganizationCore()` now includes
`FocusOrder = Organization.FocusOrder.ToList()` in the state snapshot
- **Cached worker regex**: Extracted `private static readonly Regex
WorkerNamePattern` — was re-compiled on every `GetFocusSessions` and
`AddToFocus` call
- **TurnEndFallbackTests flakiness**: Increased timing margins
(50ms→200ms wait) so tests don't fail under parallel test load

## Technical Details
- `MarkFocusHandled` kept as `=> DemoteFocusSession(sessionName)` for
backward compatibility
- `FocusOverride` enum and `SessionMeta.HandledAt` kept in model for
JSON round-trip compatibility
- `MacSleepWakeMonitor` uses ObjC P/Invoke because `NSWorkspace` has no
direct .NET binding on Mac Catalyst; falls back to
`NSNotificationCenter.DefaultCenter` if the ObjC call fails

---------

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

Author: PureWeen

PolyPilot.Tests/DashboardFeatureTests.cs

@@ -182,23 +182,27 @@ public void HealMultiAgentGroups_Phase4_PreservesRolesInActualMultiAgentGroup()
     #region GetFocusSessions logic
 
     [Fact]
-    public void GetFocusSessions_ReturnsProcessingSessions()
+    public void GetFocusSessions_Bootstrap_IncludesAllNonWorkerSessions()
     {
         var svc = CreateService();
 
-        var processing = new AgentSessionInfo { Name = "active-session", Model = "m", IsProcessing = true };
+        var active = new AgentSessionInfo { Name = "active-session", Model = "m", IsProcessing = true };
         var idle = new AgentSessionInfo { Name = "idle-session", Model = "m", IsProcessing = false };
-        idle.LastUpdatedAt = DateTime.Now.AddDays(-2); // old, not in 24h window
 
-        InjectSession(svc, processing);
+        InjectSession(svc, active);
         InjectSession(svc, idle);
         svc.Organization.Sessions.Add(new SessionMeta { SessionName = "active-session", GroupId = SessionGroup.DefaultId });
         svc.Organization.Sessions.Add(new SessionMeta { SessionName = "idle-session", GroupId = SessionGroup.DefaultId });
+        // FocusOrder is empty — bootstraps from all sessions
 
         var focus = svc.GetFocusSessions();
 
+        // Both sessions appear (no filtering by processing status)
         Assert.Contains(focus, s => s.Name == "active-session");
-        Assert.DoesNotContain(focus, s => s.Name == "idle-session");
+        Assert.Contains(focus, s => s.Name == "idle-session");
+        // FocusOrder was populated
+        Assert.Contains(svc.Organization.FocusOrder, n => n == "active-session");
+        Assert.Contains(svc.Organization.FocusOrder, n => n == "idle-session");
     }
 
     [Fact]
@@ -207,182 +211,199 @@ public void GetFocusSessions_ReturnsSessionsWithUnreadMessages()
         var svc = CreateService();
 
         var unread = new AgentSessionInfo { Name = "unread-session", Model = "m", IsProcessing = false };
-        unread.LastUpdatedAt = DateTime.Now.AddDays(-2); // old
         unread.History.Add(ChatMessage.AssistantMessage("Response pending your attention"));
 
-        var idle = new AgentSessionInfo { Name = "idle-session", Model = "m", IsProcessing = false };
-        idle.LastUpdatedAt = DateTime.Now.AddDays(-2);
-
         InjectSession(svc, unread);
-        InjectSession(svc, idle);
         svc.Organization.Sessions.Add(new SessionMeta { SessionName = "unread-session", GroupId = SessionGroup.DefaultId });
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "idle-session", GroupId = SessionGroup.DefaultId });
 
         var focus = svc.GetFocusSessions();
 
         Assert.Contains(focus, s => s.Name == "unread-session");
-        Assert.DoesNotContain(focus, s => s.Name == "idle-session");
     }
 
     [Fact]
-    public void GetFocusSessions_FocusOverrideIncluded_AlwaysShows()
+    public void AddToFocus_AddsSessionToBottom()
     {
         var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["first", "second"]);
+        var session = new AgentSessionInfo { Name = "new-session", Model = "m" };
+        InjectSession(svc, session);
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "new-session", GroupId = SessionGroup.DefaultId });
 
-        var session = new AgentSessionInfo { Name = "pinned-session", Model = "m", IsProcessing = false };
-        session.LastUpdatedAt = DateTime.Now.AddDays(-10); // very old, would not appear normally
+        svc.AddToFocus("new-session");
 
-        InjectSession(svc, session);
-        svc.Organization.Sessions.Add(new SessionMeta
-        {
-            SessionName = "pinned-session",
-            GroupId = SessionGroup.DefaultId,
-            FocusOverride = FocusOverride.Included
-        });
+        Assert.Equal(["first", "second", "new-session"], svc.Organization.FocusOrder);
+    }
 
-        var focus = svc.GetFocusSessions();
+    [Fact]
+    public void AddToFocus_AlreadyPresent_IsIdempotent()
+    {
+        var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["first", "second"]);
+
+        svc.AddToFocus("first");
 
-        Assert.Contains(focus, s => s.Name == "pinned-session");
+        Assert.Equal(["first", "second"], svc.Organization.FocusOrder);
     }
 
     [Fact]
-    public void GetFocusSessions_FocusOverrideExcluded_NeverShows()
+    public void RemoveFromFocus_RemovesSession()
     {
         var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["first", "second", "third"]);
 
-        // This session IS processing, but is explicitly excluded from Focus
-        var session = new AgentSessionInfo { Name = "excluded-session", Model = "m", IsProcessing = true };
-        InjectSession(svc, session);
-        svc.Organization.Sessions.Add(new SessionMeta
-        {
-            SessionName = "excluded-session",
-            GroupId = SessionGroup.DefaultId,
-            FocusOverride = FocusOverride.Excluded
-        });
+        svc.RemoveFromFocus("second");
 
-        var focus = svc.GetFocusSessions();
+        Assert.Equal(["first", "third"], svc.Organization.FocusOrder);
+    }
+
+    [Fact]
+    public void RemoveFromFocus_NonExistent_DoesNotThrow()
+    {
+        var svc = CreateService();
+        svc.Organization.FocusOrder.Add("only");
+
+        svc.RemoveFromFocus("ghost");
 
-        Assert.DoesNotContain(focus, s => s.Name == "excluded-session");
+        Assert.Equal(["only"], svc.Organization.FocusOrder);
     }
 
     [Fact]
-    public void GetFocusSessions_WorkersInMultiAgentGroup_ExcludedFromFocus()
+    public void PromoteFocusSession_MovesUp()
     {
         var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["a", "b", "c"]);
 
-        var maGroup = new SessionGroup { Id = "ma-group", Name = "MyTeam", IsMultiAgent = true };
-        svc.Organization.Groups.Add(maGroup);
+        svc.PromoteFocusSession("b");
 
-        var worker = new AgentSessionInfo { Name = "MyTeam-worker-1", Model = "m", IsProcessing = true };
-        var orch = new AgentSessionInfo { Name = "MyTeam-orchestrator", Model = "m", IsProcessing = true };
-        InjectSession(svc, worker);
-        InjectSession(svc, orch);
+        Assert.Equal(["b", "a", "c"], svc.Organization.FocusOrder);
+    }
 
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "MyTeam-worker-1", GroupId = "ma-group", Role = MultiAgentRole.Worker });
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "MyTeam-orchestrator", GroupId = "ma-group", Role = MultiAgentRole.Orchestrator });
+    [Fact]
+    public void PromoteFocusSession_AlreadyFirst_NoChange()
+    {
+        var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["a", "b", "c"]);
 
-        var focus = svc.GetFocusSessions();
+        svc.PromoteFocusSession("a");
 
-        // Workers should not appear in Focus (they're managed by orchestrator)
-        Assert.DoesNotContain(focus, s => s.Name == "MyTeam-worker-1");
-        // Orchestrator (Role != Worker) should appear since it's processing
-        Assert.Contains(focus, s => s.Name == "MyTeam-orchestrator");
+        Assert.Equal(["a", "b", "c"], svc.Organization.FocusOrder);
     }
 
     [Fact]
-    public void GetFocusSessions_ProcessingFirstInSort()
+    public void DemoteFocusSession_MovesDown()
     {
         var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["a", "b", "c"]);
 
-        var processing = new AgentSessionInfo { Name = "processing", Model = "m", IsProcessing = true };
-        var unread = new AgentSessionInfo { Name = "unread", Model = "m", IsProcessing = false };
-        unread.History.Add(ChatMessage.AssistantMessage("Pending attention"));
-        unread.LastUpdatedAt = DateTime.Now.AddMinutes(-5);
+        svc.DemoteFocusSession("b");
 
-        InjectSession(svc, processing);
-        InjectSession(svc, unread);
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "processing", GroupId = SessionGroup.DefaultId });
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "unread", GroupId = SessionGroup.DefaultId });
+        Assert.Equal(["a", "c", "b"], svc.Organization.FocusOrder);
+    }
+
+    [Fact]
+    public void DemoteFocusSession_AlreadyLast_NoChange()
+    {
+        var svc = CreateService();
+        svc.Organization.FocusOrder.AddRange(["a", "b", "c"]);
+
+        svc.DemoteFocusSession("c");
+
+        Assert.Equal(["a", "b", "c"], svc.Organization.FocusOrder);
+    }
+
+    [Fact]
+    public void GetFocusSessions_RespectsManualFocusOrder()
+    {
+        var svc = CreateService();
+
+        var a = new AgentSessionInfo { Name = "a", Model = "m", IsProcessing = true };
+        var b = new AgentSessionInfo { Name = "b", Model = "m", IsProcessing = false };
+        InjectSession(svc, a);
+        InjectSession(svc, b);
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "a", GroupId = SessionGroup.DefaultId });
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "b", GroupId = SessionGroup.DefaultId });
+        // Manually put b before a — no auto-sort should override this
+        svc.Organization.FocusOrder.AddRange(["b", "a"]);
 
         var focus = svc.GetFocusSessions();
         var names = focus.Select(s => s.Name).ToList();
 
-        // Processing comes before unread
-        Assert.True(names.IndexOf("processing") < names.IndexOf("unread"),
-            "Processing session should sort before unread session");
+        Assert.Equal(["b", "a"], names);
     }
 
     [Fact]
-    public void GetFocusSessions_HandledSessions_SortToBottom()
+    public void GetFocusSessions_WorkersInMultiAgentGroup_ExcludedFromFocus()
     {
         var svc = CreateService();
 
-        var unhandled = new AgentSessionInfo { Name = "unhandled", Model = "m", IsProcessing = false };
-        unhandled.LastUpdatedAt = DateTime.Now.AddMinutes(-30);
-        unhandled.History.Add(ChatMessage.AssistantMessage("Needs attention"));
+        var maGroup = new SessionGroup { Id = "ma-group", Name = "MyTeam", IsMultiAgent = true };
+        svc.Organization.Groups.Add(maGroup);
 
-        var handled = new AgentSessionInfo { Name = "handled", Model = "m", IsProcessing = false };
-        handled.LastUpdatedAt = DateTime.Now.AddMinutes(-5); // More recent but handled
+        var worker = new AgentSessionInfo { Name = "MyTeam-worker-1", Model = "m", IsProcessing = true };
+        var orch = new AgentSessionInfo { Name = "MyTeam-orchestrator", Model = "m", IsProcessing = true };
+        InjectSession(svc, worker);
+        InjectSession(svc, orch);
 
-        InjectSession(svc, unhandled);
-        InjectSession(svc, handled);
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "unhandled", GroupId = SessionGroup.DefaultId });
-        svc.Organization.Sessions.Add(new SessionMeta
-        {
-            SessionName = "handled",
-            GroupId = SessionGroup.DefaultId,
-            HandledAt = DateTime.Now.AddMinutes(-10)
-        });
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "MyTeam-worker-1", GroupId = "ma-group", Role = MultiAgentRole.Worker });
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "MyTeam-orchestrator", GroupId = "ma-group", Role = MultiAgentRole.Orchestrator });
+        // Workers must not bootstrap into FocusOrder
+        // Orchestrator should be in FocusOrder (bootstrap adds non-workers)
 
         var focus = svc.GetFocusSessions();
-        var names = focus.Select(s => s.Name).ToList();
 
-        // Unhandled (even with older activity) sorts before handled
-        Assert.True(names.IndexOf("unhandled") < names.IndexOf("handled"),
-            "Unhandled sessions should sort before handled sessions");
+        // Workers should not appear in Focus (they're managed by orchestrator)
+        Assert.DoesNotContain(focus, s => s.Name == "MyTeam-worker-1");
+        // Orchestrator (Role != Worker) should appear
+        Assert.Contains(focus, s => s.Name == "MyTeam-orchestrator");
     }
 
     [Fact]
-    public void GetFocusSessions_OldestWaitingFirst_WithinUnhandled()
+    public void GetFocusSessions_WorkerByNamePattern_ExcludedFromFocusEvenIfRoleNone()
     {
         var svc = CreateService();
+        // Worker session with Role=None (corruption — should still be excluded by name pattern)
+        var worker = new AgentSessionInfo { Name = "AGR-worker-1", Model = "m", IsProcessing = true };
+        InjectSession(svc, worker);
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "AGR-worker-1", GroupId = SessionGroup.DefaultId, Role = MultiAgentRole.None });
 
-        // "newer" session updated 5 min ago (less urgent — user saw it more recently)
-        var newer = new AgentSessionInfo { Name = "newer", Model = "m", IsProcessing = false };
-        newer.LastUpdatedAt = DateTime.Now.AddMinutes(-5);
-        newer.History.Add(ChatMessage.AssistantMessage("Recent message"));
+        var focus = svc.GetFocusSessions();
 
-        // "older" session waiting 60 min (more urgent — waiting longest)
-        var older = new AgentSessionInfo { Name = "older", Model = "m", IsProcessing = false };
-        older.LastUpdatedAt = DateTime.Now.AddMinutes(-60);
-        older.History.Add(ChatMessage.AssistantMessage("Waiting a long time"));
+        Assert.DoesNotContain(focus, s => s.Name == "AGR-worker-1");
+        Assert.DoesNotContain(svc.Organization.FocusOrder, n => n == "AGR-worker-1");
+    }
 
-        InjectSession(svc, newer);
-        InjectSession(svc, older);
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "newer", GroupId = SessionGroup.DefaultId });
-        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "older", GroupId = SessionGroup.DefaultId });
+    [Fact]
+    public void GetFocusSessions_SessionsRemovedFromFocusOrder_NotReturned()
+    {
+        var svc = CreateService();
 
+        var a = new AgentSessionInfo { Name = "a", Model = "m" };
+        var b = new AgentSessionInfo { Name = "b", Model = "m" };
+        InjectSession(svc, a);
+        InjectSession(svc, b);
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "a", GroupId = SessionGroup.DefaultId });
+        svc.Organization.Sessions.Add(new SessionMeta { SessionName = "b", GroupId = SessionGroup.DefaultId });
+        svc.Organization.FocusOrder.AddRange(["a", "b"]);
+
+        svc.RemoveFromFocus("b");
         var focus = svc.GetFocusSessions();
-        var names = focus.Select(s => s.Name).ToList();
 
-        // Oldest waiting session sorts first (triage order)
-        Assert.True(names.IndexOf("older") < names.IndexOf("newer"),
-            "Oldest waiting session should sort before more recently active sessions");
+        Assert.Contains(focus, s => s.Name == "a");
+        Assert.DoesNotContain(focus, s => s.Name == "b");
     }
 
     [Fact]
-    public void MarkFocusHandled_SetsHandledAtOnMeta()
+    public void MarkFocusHandled_DemotesSession()
     {
         var svc = CreateService();
         svc.Organization.Sessions.Add(new SessionMeta { SessionName = "my-session", GroupId = SessionGroup.DefaultId });
+        svc.Organization.FocusOrder.AddRange(["my-session", "other"]);
 
-        var before = DateTime.Now;
         svc.MarkFocusHandled("my-session");
-        var after = DateTime.Now;
 
-        var meta = svc.Organization.Sessions.First(m => m.SessionName == "my-session");
-        Assert.NotNull(meta.HandledAt);
-        Assert.InRange(meta.HandledAt!.Value, before, after);
+        // MarkFocusHandled demotes (moves to bottom), does NOT remove
+        Assert.Equal(["other", "my-session"], svc.Organization.FocusOrder);
     }
 
     [Fact]

PolyPilot.Tests/StateChangeCoalescerTests.cs

@@ -70,12 +70,12 @@ public async Task SeparateBursts_FireSeparately()
             svc.NotifyStateChangedCoalesced();
         // Wait well beyond the coalesce window (150ms) to ensure the timer fires,
         // even under heavy CI/GC load. Previous 300ms was flaky under load.
-        await Task.Delay(500);
+        await Task.Delay(800);
 
         // Second burst after timer has fired
         for (int i = 0; i < 10; i++)
             svc.NotifyStateChangedCoalesced();
-        await Task.Delay(500);
+        await Task.Delay(800);
 
         // Each burst should produce ~1 notification
         Assert.InRange(fireCount, 2, 4);

PolyPilot.Tests/TurnEndFallbackTests.cs

@@ -82,7 +82,7 @@ public async Task FallbackTimer_NotCancelled_FiresAfterDelay()
             catch (OperationCanceledException) { }
         });
 
-        await Task.Delay(200);
+        await Task.Delay(500);
         Assert.True(fired, "Fallback timer should fire when CTS is not cancelled");
     }
 
@@ -209,7 +209,7 @@ public async Task ToolFallback_NoTurnStart_EventuallyFires()
             catch (OperationCanceledException) { }
         });
 
-        await Task.Delay(400);
+        await Task.Delay(800);
         Assert.True(completeResponseFired, "Fallback must fire when no TurnStart or SessionIdle arrives");
     }
 }

PolyPilot/App.xaml.cs

@@ -5,10 +5,12 @@ namespace PolyPilot;
 public partial class App : Application
 {
 	private readonly CopilotService _copilotService;
+	private readonly WsBridgeServer _bridgeServer;
 
-	public App(INotificationManagerService notificationService, CopilotService copilotService)
+	public App(INotificationManagerService notificationService, CopilotService copilotService, WsBridgeServer bridgeServer)
 	{
 		_copilotService = copilotService;
+		_bridgeServer = bridgeServer;
 		InitializeComponent();
 		_ = notificationService.InitializeAsync();
 
@@ -39,6 +41,15 @@ protected override Window CreateWindow(IActivationState? activationState)
 			window.Width = 1400;
 			window.Height = 900;
 		}
+
+#if MACCATALYST
+		// Subscribe to NSWorkspace sleep/wake and screen-lock/unlock notifications so we
+		// can proactively recover the copilot connection and re-sync mobile clients.
+		// App.OnResume() only fires when the app is re-activated by the user, not on
+		// system wake or lock-screen unlock without clicking PolyPilot.
+		PolyPilot.Platforms.MacCatalyst.MacSleepWakeMonitor.Register(_copilotService, _bridgeServer);
+#endif
+
 		return window;
 	}