v0.0.3: Stability, crash recovery, multi-version COM, edge cases

Stability fixes (confirmed by triple-model code review):
- Fix COM object leaks: ReleaseComObject on all transient IVirtualDesktop,
  IApplicationView, IServiceProvider10 objects with try/finally
- Fix Process object leaks: using var on all Process.GetProcessById calls
- LL hook safety: SendMessageTimeout replaces SendMessage (100ms,
  SMTO_ABORTIFHUNG), removed Trace.WriteLine from hook callback
- Explorer restart: ClearAll() releases stale COM refs before reinit
- TOCTOU: try/catch ObjectDisposedException on BeginInvoke

Crash recovery:
- TrackerPersistence: JSON state at %LOCALAPPDATA% with thread-safe file lock
- RecoverOrphanedDesktops() on startup removes desktops from previous crash
- Desktop naming with [MVD] prefix for Task View identification

Multi-version COM adapters:
- Split IVirtualDesktopManagerInternal into 24H2 and Pre24H2 vtable layouts
- DesktopManagerAdapter factory with build-number selection + smoke test fallback
- App now works on all Windows 11 versions (21H2 through 24H2+)

Edge cases:
- Admin-elevated windows: detect via token query, show balloon tip
- In-flight guard: HashSet prevents re-entrant Toggle on same hwnd
- Maximize animation: 250ms delay after desktop switch for visible animation
- PostMessage/WM_SYSCOMMAND/SC_MAXIMIZE added to NativeMethods

Author: shanselman

README.md

@@ -21,16 +21,19 @@ The app runs in the system tray. Right-click the tray icon for options:
 
 ## How It Works
 
-1. **Maximize** — creates a new virtual desktop, moves the window there, switches to it, and maximizes the window. The desktop is named after the process.
+1. **Maximize** — creates a new virtual desktop, moves the window there, switches to it, and maximizes the window. The desktop is named `[MVD] ProcessName` so you can identify it in Task View.
 2. **Auto-restore on un-maximize** — if you restore/un-maximize a tracked window, it's automatically sent back to its original desktop and the temp desktop is cleaned up.
 3. **Auto-restore on close** — closing a tracked window triggers the same cleanup.
 4. **Toggle** — pressing the hotkey on an already-tracked window restores it.
+5. **Crash recovery** — if the app is killed or crashes, orphaned desktops are automatically cleaned up on next launch.
 
 ## Requirements
 
-- **Windows 11 24H2** or later
+- **Windows 11** (any version — 21H2 through 24H2+)
 - Self-contained — no .NET installation required
 
+The app auto-detects your Windows build and selects the correct COM vtable layout. If a future Windows update breaks things, the app enters degraded mode and checks for updates automatically.
+
 ### Shift+Click Compatibility
 
 Shift+Click works wherever Windows 11 Snap Layouts works — apps that correctly handle `WM_NCHITTEST` and return `HTMAXBUTTON`. This includes:
@@ -68,12 +71,14 @@ src/MaximizeToVirtualDesktop/
 ├── VirtualDesktopService.cs    COM wrapper, 4 operations, Explorer restart recovery
 ├── WindowMonitor.cs            SetWinEventHook for close/un-maximize detection
 ├── MaximizeButtonHook.cs       WH_MOUSE_LL for Shift+Click on maximize button
+├── TrackerPersistence.cs       JSON crash recovery in %LOCALAPPDATA%
 └── Interop/
     ├── NativeMethods.cs        P/Invoke declarations
-    └── VirtualDesktopCom.cs    Vendored COM interfaces (from MScholtes/VirtualDesktop)
+    ├── VirtualDesktopCom.cs    Vendored COM interfaces (from MScholtes/VirtualDesktop)
+    └── DesktopManagerAdapter.cs Multi-version COM vtable adapter
 ```
 
-**Zero NuGet dependencies.** COM interop declarations are vendored from [MScholtes/VirtualDesktop](https://github.com/MScholtes/VirtualDesktop) (MIT license, actively maintained).
+**Zero NuGet dependencies.** COM interop declarations are vendored from [MScholtes/VirtualDesktop](https://github.com/MScholtes/VirtualDesktop) (MIT license, actively maintained). The app ships two vtable layouts (pre-24H2 and 24H2+) and auto-selects the correct one with a smoke test fallback.
 
 ## Design Principles
 
@@ -84,7 +89,7 @@ src/MaximizeToVirtualDesktop/
 ## Known Limitations
 
 - **Elevated windows** — cannot move windows running as Administrator from a non-elevated instance.
-- **App crash** — if the app crashes, temporary desktops may remain. They're named after the process for easy identification.
+- **App crash** — if the app crashes, temporary desktops are cleaned up automatically on next launch. They're prefixed with `[MVD]` in Task View for easy manual identification.
 
 ## The Virtual Desktop GUID Problem
 
@@ -97,8 +102,9 @@ This is the single biggest fragility in this app. When it breaks, the app shows
 ### How to update the GUIDs
 
 1. Check [MScholtes/VirtualDesktop](https://github.com/MScholtes/VirtualDesktop) — Markus Scholtes maintains per-build interface files (e.g., `VirtualDesktop11-24H2.cs`) and typically updates within days of a new Windows build. Huge thanks to him for doing this thankless work for the entire community.
-2. Copy the updated GUIDs into `src/MaximizeToVirtualDesktop/Interop/VirtualDesktopCom.cs`
-3. The fragile GUIDs are on these interfaces:
+2. If it's a **vtable change** (new/removed methods, same GUIDs), add a new adapter class in `DesktopManagerAdapter.cs` and a new COM interface in `VirtualDesktopCom.cs`.
+3. If it's a **GUID change**, update the GUIDs on the affected interfaces.
+4. The fragile GUIDs are on these interfaces:
 
 | Interface | What it does | Stable? |
 |-----------|-------------|---------|

src/MaximizeToVirtualDesktop/FullScreenManager.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using MaximizeToVirtualDesktop.Interop;
 
 namespace MaximizeToVirtualDesktop;
@@ -11,6 +12,12 @@ internal sealed class FullScreenManager
 {
     private readonly VirtualDesktopService _vds;
     private readonly FullScreenTracker _tracker;
+    private readonly HashSet<IntPtr> _inFlight = new();
+
+    /// <summary>
+    /// Callback to show a notification balloon (set by TrayApplication).
+    /// </summary>
+    public Action<string, string>? ShowBalloon { get; set; }
 
     public FullScreenManager(VirtualDesktopService vds, FullScreenTracker tracker)
     {
@@ -29,13 +36,26 @@ public void Toggle(IntPtr hwnd)
             return;
         }
 
-        if (_tracker.IsTracked(hwnd))
+        if (!_inFlight.Add(hwnd))
         {
-            Restore(hwnd);
+            Trace.WriteLine($"FullScreenManager: hwnd {hwnd} already in-flight, ignoring.");
+            return;
         }
-        else
+
+        try
         {
-            MaximizeToDesktop(hwnd);
+            if (_tracker.IsTracked(hwnd))
+            {
+                Restore(hwnd);
+            }
+            else
+            {
+                MaximizeToDesktop(hwnd);
+            }
+        }
+        finally
+        {
+            _inFlight.Remove(hwnd);
         }
     }
 
@@ -81,14 +101,15 @@ public void MaximizeToDesktop(IntPtr hwnd)
         }
 
         // 3. Name the desktop after the window title (or process name as fallback)
+        string? processName = null;
         try
         {
             NativeMethods.GetWindowThreadProcessId(hwnd, out int processId);
-            var process = Process.GetProcessById(processId);
-            var name = !string.IsNullOrWhiteSpace(process.MainWindowTitle)
+            using var process = Process.GetProcessById(processId);
+            processName = !string.IsNullOrWhiteSpace(process.MainWindowTitle)
                 ? process.MainWindowTitle
                 : process.ProcessName;
-            _vds.SetDesktopName(tempDesktop, name);
+            _vds.SetDesktopName(tempDesktop, $"[MVD] {processName}");
         }
         catch
         {
@@ -100,6 +121,7 @@ public void MaximizeToDesktop(IntPtr hwnd)
         {
             Trace.WriteLine("FullScreenManager: Failed to move window, rolling back desktop creation.");
             _vds.RemoveDesktop(tempDesktop);
+            Marshal.ReleaseComObject(tempDesktop);
             return;
         }
 
@@ -109,17 +131,36 @@ public void MaximizeToDesktop(IntPtr hwnd)
             // Rollback: move window back, remove desktop
             Trace.WriteLine("FullScreenManager: Failed to switch desktop, rolling back.");
             var origDesktop = _vds.FindDesktop(originalDesktopId.Value);
-            if (origDesktop != null) _vds.MoveWindowToDesktop(hwnd, origDesktop);
+            try
+            {
+                if (origDesktop != null) _vds.MoveWindowToDesktop(hwnd, origDesktop);
+            }
+            finally
+            {
+                if (origDesktop != null) Marshal.ReleaseComObject(origDesktop);
+            }
             _vds.RemoveDesktop(tempDesktop);
+            Marshal.ReleaseComObject(tempDesktop);
             return;
         }
 
-        // 6. Maximize the window
-        NativeMethods.ShowWindow(hwnd, NativeMethods.SW_MAXIMIZE);
+        // 6. Maximize the window — delay lets desktop switch animation finish first
+        bool elevated = NativeMethods.IsWindowElevated(hwnd);
+        if (elevated)
+        {
+            Trace.WriteLine("FullScreenManager: Window is elevated, cannot maximize via UIPI.");
+            ShowBalloon?.Invoke("Elevated Window",
+                "Window was moved to a new desktop but could not be maximized (it's running as Administrator). Press Win+↑ to maximize it.");
+        }
+        else
+        {
+            Thread.Sleep(250);
+            NativeMethods.ShowWindow(hwnd, NativeMethods.SW_MAXIMIZE);
+        }
         NativeMethods.SetForegroundWindow(hwnd);
 
         // 7. Track it
-        _tracker.Track(hwnd, originalDesktopId.Value, tempDesktop, originalPlacement);
+        _tracker.Track(hwnd, originalDesktopId.Value, tempDesktopId.Value, tempDesktop, processName, originalPlacement);
 
         Trace.WriteLine($"FullScreenManager: Successfully maximized {hwnd} to desktop {tempDesktopId}");
     }
@@ -149,32 +190,30 @@ public void Restore(IntPtr hwnd)
             NativeMethods.SetWindowPlacement(hwnd, ref placement);
         }
 
-        // 2. Move window back to original desktop
-        if (windowStillExists)
+        // 2. Move window back to original desktop and switch back
+        var origDesktop = _vds.FindDesktop(entry.OriginalDesktopId);
+        try
         {
-            var origDesktop = _vds.FindDesktop(entry.OriginalDesktopId);
             if (origDesktop != null)
             {
-                _vds.MoveWindowToDesktop(hwnd, origDesktop);
+                if (windowStillExists) _vds.MoveWindowToDesktop(hwnd, origDesktop);
+                _vds.SwitchToDesktop(origDesktop);
             }
             else
             {
-                // Original desktop was removed by user — leave window on current desktop
                 Trace.WriteLine("FullScreenManager: Original desktop no longer exists, leaving window on current.");
             }
         }
-
-        // 3. Switch back to original desktop
-        var origDesktopForSwitch = _vds.FindDesktop(entry.OriginalDesktopId);
-        if (origDesktopForSwitch != null)
+        finally
         {
-            _vds.SwitchToDesktop(origDesktopForSwitch);
+            if (origDesktop != null) Marshal.ReleaseComObject(origDesktop);
         }
 
-        // 4. Remove temp desktop (tolerates failure — user may have already removed it)
+        // 3. Remove temp desktop and release its COM reference
         _vds.RemoveDesktop(entry.TempDesktop);
+        Marshal.ReleaseComObject(entry.TempDesktop);
 
-        // 5. Set focus on the restored window
+        // 4. Set focus on the restored window
         if (windowStillExists)
         {
             NativeMethods.SetForegroundWindow(hwnd);
@@ -195,13 +234,18 @@ public void HandleWindowDestroyed(IntPtr hwnd)
 
         // Switch back to original desktop first
         var origDesktop = _vds.FindDesktop(entry.OriginalDesktopId);
-        if (origDesktop != null)
+        try
+        {
+            if (origDesktop != null) _vds.SwitchToDesktop(origDesktop);
+        }
+        finally
         {
-            _vds.SwitchToDesktop(origDesktop);
+            if (origDesktop != null) Marshal.ReleaseComObject(origDesktop);
         }
 
-        // Then remove the temp desktop
+        // Then remove the temp desktop and release its COM reference
         _vds.RemoveDesktop(entry.TempDesktop);
+        Marshal.ReleaseComObject(entry.TempDesktop);
     }
 
     /// <summary>

src/MaximizeToVirtualDesktop/FullScreenTracker.cs

@@ -1,12 +1,15 @@
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using MaximizeToVirtualDesktop.Interop;
 
 namespace MaximizeToVirtualDesktop;
 
 internal sealed record TrackingEntry(
     IntPtr Hwnd,
     Guid OriginalDesktopId,
+    Guid TempDesktopId,
     IVirtualDesktop TempDesktop,
+    string? ProcessName,
     NativeMethods.WINDOWPLACEMENT OriginalPlacement);
 
 /// <summary>
@@ -29,27 +32,54 @@ public bool IsTracked(IntPtr hwnd)
         lock (_lock) return _entries.GetValueOrDefault(hwnd);
     }
 
-    public void Track(IntPtr hwnd, Guid originalDesktopId, IVirtualDesktop tempDesktop,
+    public void Track(IntPtr hwnd, Guid originalDesktopId, Guid tempDesktopId,
+        IVirtualDesktop tempDesktop, string? processName,
         NativeMethods.WINDOWPLACEMENT originalPlacement)
     {
         lock (_lock)
         {
-            _entries[hwnd] = new TrackingEntry(hwnd, originalDesktopId, tempDesktop, originalPlacement);
+            _entries[hwnd] = new TrackingEntry(hwnd, originalDesktopId, tempDesktopId,
+                tempDesktop, processName, originalPlacement);
             Trace.WriteLine($"FullScreenTracker: Now tracking {hwnd} (total: {_entries.Count})");
         }
+        PersistToDisk();
     }
 
     public TrackingEntry? Untrack(IntPtr hwnd)
     {
+        TrackingEntry? entry;
         lock (_lock)
         {
-            if (_entries.Remove(hwnd, out var entry))
+            if (_entries.Remove(hwnd, out entry))
             {
                 Trace.WriteLine($"FullScreenTracker: Untracked {hwnd} (total: {_entries.Count})");
-                return entry;
             }
-            return null;
+            else
+            {
+                return null;
+            }
+        }
+        PersistToDisk();
+        return entry;
+    }
+
+    /// <summary>
+    /// Clear all entries, releasing COM references. Called when Explorer restarts
+    /// (Windows destroys all virtual desktops, making our tracked refs stale).
+    /// </summary>
+    public void ClearAll()
+    {
+        lock (_lock)
+        {
+            foreach (var entry in _entries.Values)
+            {
+                try { Marshal.ReleaseComObject(entry.TempDesktop); } catch { }
+            }
+            var count = _entries.Count;
+            _entries.Clear();
+            Trace.WriteLine($"FullScreenTracker: Cleared {count} stale entries (Explorer restart).");
         }
+        TrackerPersistence.Delete();
     }
 
     /// <summary>Returns all tracked entries (snapshot).</summary>
@@ -73,4 +103,15 @@ public int Count
     {
         get { lock (_lock) return _entries.Count; }
     }
+
+    private void PersistToDisk()
+    {
+        List<TrackerPersistence.PersistedEntry> snapshot;
+        lock (_lock)
+        {
+            snapshot = _entries.Values.Select(e =>
+                new TrackerPersistence.PersistedEntry(e.TempDesktopId, e.ProcessName, DateTime.UtcNow)).ToList();
+        }
+        TrackerPersistence.Save(snapshot);
+    }
 }