fix: address remaining PR 84 review threads

managedcode · KSemenenko · Mar 16, 2026 · Mar 14, 2026 · Mar 14, 2026 · Mar 14, 2026
commit 77601674f16c1e42e6ec25592651ea79d2217e18
diff --git a/DotPilot.Tests/Chat/ViewModels/ChatModelTests.cs b/DotPilot.Tests/Chat/ViewModels/ChatModelTests.cs
@@ -100,6 +100,34 @@ public async Task RefreshIgnoresCancellationDuringWorkspaceProbe()
         (await model.FeedbackMessage).Should().BeEmpty();
     }
 
+    [Test]
+    public async Task RefreshInvalidatesTheFleetProviderSnapshotAfterProviderChanges()
+    {
+        using var commandScope = CodexCliTestScope.Create(nameof(ChatModelTests));
+        commandScope.WriteVersionCommand("codex", "codex version 1.0.0");
+        commandScope.WriteCodexMetadata("gpt-5.4", "gpt-5.4");
+        await using var fixture = await CreateFixtureAsync();
+        var model = ActivatorUtilities.CreateInstance<ChatModel>(fixture.Provider);
+
+        var initialBoard = await model.FleetBoard;
+        initialBoard.Should().NotBeNull();
+        initialBoard!.Providers.Should().Contain(provider =>
+            provider.DisplayName == "Codex" &&
+            provider.StatusLabel == "Disabled");
+
+        (await fixture.WorkspaceState.UpdateProviderAsync(
+            new UpdateProviderPreferenceCommand(AgentProviderKind.Codex, true),
+            CancellationToken.None)).ShouldSucceed();
+
+        await model.Refresh(CancellationToken.None);
+
+        var refreshedBoard = await model.FleetBoard;
+        refreshedBoard.Should().NotBeNull();
+        refreshedBoard!.Providers.Should().Contain(provider =>
+            provider.DisplayName == "Codex" &&
+            provider.StatusLabel == "Ready");
+    }
+
     [Test]
     public async Task FleetBoardShowsTheActiveSessionWhileStreamingAndClearsAfterCompletion()
     {

diff --git a/DotPilot.Tests/Host/Power/DesktopSleepPreventionServiceTests.cs b/DotPilot.Tests/Host/Power/DesktopSleepPreventionServiceTests.cs
@@ -0,0 +1,99 @@
+using System.Diagnostics;
+using DotPilot.Core.ChatSessions;
+using DotPilot.Core.ControlPlaneDomain;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace DotPilot.Tests.Host.Power;
+
+public sealed class DesktopSleepPreventionServiceTests
+{
+    [Test]
+    public async Task ServiceTracksSessionActivityLifecycle()
+    {
+        if (OperatingSystem.IsLinux() && !CommandExists("systemd-inhibit"))
+        {
+            Assert.Ignore("systemd-inhibit is not available on this machine.");
+        }
+
+        if (OperatingSystem.IsMacOS() && !CommandExists("caffeinate"))
+        {
+            Assert.Ignore("caffeinate is not available on this machine.");
+        }
+
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddSingleton(TimeProvider.System);
+        services.AddAgentSessions(new AgentSessionStorageOptions
+        {
+            UseInMemoryDatabase = true,
+            InMemoryDatabaseName = Guid.NewGuid().ToString("N"),
+        });
+        services.AddSingleton<DesktopSleepPreventionService>();
+
+        await using var provider = services.BuildServiceProvider();
+        var monitor = provider.GetRequiredService<ISessionActivityMonitor>();
+        var sleepPrevention = provider.GetRequiredService<DesktopSleepPreventionService>();
+
+        using var lease = monitor.BeginActivity(
+            new SessionActivityDescriptor(
+                SessionId.New(),
+                "Sleep prevention session",
+                AgentProfileId.New(),
+                "Sleep agent",
+                "Debug Provider"));
+
+        await WaitForAsync(static service => service.IsSleepPreventionActive, sleepPrevention);
+
+        lease.Dispose();
+
+        await WaitForAsync(static service => !service.IsSleepPreventionActive, sleepPrevention);
+    }
+
+    private static async Task WaitForAsync(
+        Func<DesktopSleepPreventionService, bool> predicate,
+        DesktopSleepPreventionService service)
+    {
+        var timeoutAt = DateTimeOffset.UtcNow.AddSeconds(5);
+        while (DateTimeOffset.UtcNow < timeoutAt)
+        {
+            if (predicate(service))
+            {
+                return;
+            }
+
+            await Task.Delay(50);
+        }
+
+        predicate(service).Should().BeTrue();
+    }
+
+    private static bool CommandExists(string commandName)
+    {
+        try
+        {
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = "sh",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            };
+            startInfo.ArgumentList.Add("-c");
+            startInfo.ArgumentList.Add($"command -v {commandName}");
+
+            using var process = Process.Start(startInfo);
+            if (process is null)
+            {
+                return false;
+            }
+
+            process.WaitForExit(2000);
+            return process.ExitCode == 0;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}
diff --git a/DotPilot/Host/Power/DesktopSleepPreventionService.cs b/DotPilot/Host/Power/DesktopSleepPreventionService.cs
@@ -18,6 +18,8 @@ public sealed class DesktopSleepPreventionService : IDisposable
     private readonly Lock gate = new();
     private Process? inhibitorProcess;
     private bool isSleepPreventionActive;
+    private bool isSleepPreventionPending;
+    private long stateVersion;
 
     public DesktopSleepPreventionService(
         ISessionActivityMonitor sessionActivityMonitor,
@@ -71,62 +73,68 @@ private void ApplySessionActivityState()
 
     private void AcquireSleepPrevention()
     {
-        lock (gate)
+        var acquisition = TryBeginAcquisition();
+        if (!acquisition.ShouldAcquire)
         {
-            if (isSleepPreventionActive)
-            {
-                return;
-            }
+            return;
         }
 
         try
         {
             if (OperatingSystem.IsWindows())
             {
                 AcquireWindowsSleepPrevention();
- SetActiveState("SetThreadExecutionState");
+ CompleteWindowsAcquisition(acquisition.Version, "SetThreadExecutionState");
                 return;
             }
 
             if (OperatingSystem.IsMacOS())
             {
- SetProcessState(StartMacOsInhibitorProcess());
+ CompleteProcessAcquisition(acquisition.Version, StartMacOsInhibitorProcess());
                 return;
             }
 
             if (OperatingSystem.IsLinux())
             {
-                SetProcessState(StartLinuxInhibitorProcess());
+                CompleteProcessAcquisition(acquisition.Version, StartLinuxInhibitorProcess());
+                return;
             }
+
+            CancelPendingAcquisition(acquisition.Version);
         }
         catch (Exception exception)
         {
             ShellSleepPreventionLog.AcquireFailed(logger, exception);
+            CancelPendingAcquisition(acquisition.Version);
             ReleaseSleepPrevention();
         }
     }
 
     private void ReleaseSleepPrevention()
     {
         Process? processToStop;
+        bool shouldReleaseWindows;
         bool wasActive;
 
         lock (gate)
         {
-            if (!isSleepPreventionActive && inhibitorProcess is null)
+            stateVersion++;
+            if (!isSleepPreventionActive && !isSleepPreventionPending && inhibitorProcess is null)
             {
                 return;
             }
 
-            if (OperatingSystem.IsWindows() && isSleepPreventionActive)
-            {
-                ReleaseWindowsSleepPrevention();
-            }
-
+            shouldReleaseWindows = OperatingSystem.IsWindows() && isSleepPreventionActive;
             processToStop = inhibitorProcess;
             inhibitorProcess = null;
             wasActive = isSleepPreventionActive;
             isSleepPreventionActive = false;
+            isSleepPreventionPending = false;
+        }
+
+        if (shouldReleaseWindows)
+        {
+            ReleaseWindowsSleepPrevention();
         }
 
         StopProcess(processToStop);
@@ -139,29 +147,79 @@ private void ReleaseSleepPrevention()
         StateChanged?.Invoke(this, EventArgs.Empty);
     }
 
-    private void SetProcessState(Process process)
+    private (bool ShouldAcquire, long Version) TryBeginAcquisition()
+    {
+        lock (gate)
+        {
+            if (isSleepPreventionActive || isSleepPreventionPending)
+            {
+                return (false, stateVersion);
+            }
+
+            stateVersion++;
+            isSleepPreventionPending = true;
+            return (true, stateVersion);
+        }
+    }
+
+    private void CompleteProcessAcquisition(long version, Process process)
     {
+        var acquired = false;
         lock (gate)
         {
-            inhibitorProcess = process;
-            isSleepPreventionActive = true;
+            if (isSleepPreventionPending && !isSleepPreventionActive && version == stateVersion)
+            {
+                inhibitorProcess = process;
+                isSleepPreventionActive = true;
+                isSleepPreventionPending = false;
+                acquired = true;
+            }
+        }
+
+        if (!acquired)
+        {
+            StopProcess(process);
+            return;
         }
 
         ShellSleepPreventionLog.Acquired(logger, process.ProcessName);
         StateChanged?.Invoke(this, EventArgs.Empty);
     }
 
-    private void SetActiveState(string mechanism)
+    private void CompleteWindowsAcquisition(long version, string mechanism)
     {
+        var acquired = false;
         lock (gate)
         {
-            isSleepPreventionActive = true;
+            if (isSleepPreventionPending && !isSleepPreventionActive && version == stateVersion)
+            {
+                isSleepPreventionActive = true;
+                isSleepPreventionPending = false;
+                acquired = true;
+            }
+        }
+
+        if (!acquired)
+        {
+            ReleaseWindowsSleepPrevention();
+            return;
         }
 
         ShellSleepPreventionLog.Acquired(logger, mechanism);
         StateChanged?.Invoke(this, EventArgs.Empty);
     }
 
+    private void CancelPendingAcquisition(long version)
+    {
+        lock (gate)
+        {
+            if (isSleepPreventionPending && !isSleepPreventionActive && version == stateVersion)
+            {
+                isSleepPreventionPending = false;
+            }
+        }
+    }
+
     private static void AcquireWindowsSleepPrevention()
     {
         var result = SetThreadExecutionState(EsContinuous | EsSystemRequired);

diff --git a/DotPilot/Presentation/Chat/ViewModels/ChatModel.cs b/DotPilot/Presentation/Chat/ViewModels/ChatModel.cs
@@ -94,6 +94,7 @@ public async ValueTask Refresh(CancellationToken cancellationToken)
                 return;
             }
 
+            fleetProviderSnapshotStale = true;
             _workspaceRefresh.Raise();
             _sessionRefresh.Raise();
             await EnsureSelectedChatAsync(cancellationToken);