feat(ux): add hotkey recorder and overhaul onboarding flow

Introduces major user experience enhancements, including a live hotkey
recorder, a redesigned onboarding process, and improved window management.
These changes are supported by a significant refactoring of OS services
and improved hardware monitoring robustness.

- Implements a live hotkey recorder in Settings, allowing users to set
  shortcuts by pressing key combinations instead of typing them.
- Overhauls the onboarding experience to be non-modal and more robust. A
  skip option is added, and the app now fully initializes in the
  background while the onboarding window is active.
- Improves Result Window behavior, ensuring it opens centered, focused,
  800x500 px window, and remembers its position and size across sessions.
- Enhances `HardwareMonitoringService` to fail gracefully on
  unsupported platforms (e.g., macOS ARM64). The dashboard UI now
  adapts by hiding the monitoring sidebar when it's unavailable.
- Decomposes the monolithic `IOsService` into smaller,
  single-responsibility services (`IHotkeyService`, `IClipboardService`,
  `IActiveWindowService`, `ISystemService`) to improve modularity.
- Improves the build process to dynamically set the `RuntimeIdentifier`
  based on both OS and architecture (x64/arm64).

Author: LSXPrime

ProseFlow.Application/DTOs/HotkeyData.cs

@@ -0,0 +1,8 @@
+namespace ProseFlow.Application.DTOs;
+
+/// <summary>
+/// A technology-agnostic Data Transfer Object for representing a captured hotkey combination.
+/// </summary>
+/// <param name="Key">The primary, non-modifier key that was pressed (e.g., "A", "J", "F5").</param>
+/// <param name="Modifiers">A list of modifier keys that were held down (e.g., ["Ctrl", "Shift"]).</param>
+public record HotkeyData(string Key, IReadOnlyList<string> Modifiers);

ProseFlow.Application/Events/AppEvents.cs

@@ -15,6 +15,26 @@ public enum NotificationType { Info, Success, Warning, Error }
 
 public static class AppEvents
 {
+    /// <summary>
+    /// Configuration flag to enable or disable the floating menu feature globally.
+    /// </summary>
+    public static bool IsShowFloatingMenuEnabled = true;
+
+    /// <summary>
+    /// Configuration flag to enable or disable the result window display feature globally.
+    /// </summary>
+    public static bool IsShowResultWindowEnabled = true;
+
+    /// <summary>
+    /// Configuration flag to enable or disable system notifications (toasts) globally.
+    /// </summary>
+    public static bool IsShowNotificationEnabled = true;
+    
+    /// <summary>
+    /// Configuration flag to enable or disable the conflict resolution UI globally.
+    /// </summary>
+    public static bool IsResolveConflictsEnabled = true;
+
     /// <summary>
     /// Raised when the Action Orchestration Service needs the UI to display the Floating Action Menu.
     /// The UI layer subscribes to this, shows the menu, and returns the user's selection.
@@ -27,12 +47,13 @@ public static class AppEvents
     /// </summary>
     public static async Task<ActionExecutionRequest?> RequestFloatingMenuAsync(IEnumerable<Action> availableActions, string activeAppContext)
     {
+        if (!IsShowFloatingMenuEnabled) return null;
+
         return ShowFloatingMenuRequested is not null
             ? await ShowFloatingMenuRequested.Invoke(availableActions, activeAppContext)
             : await Task.FromResult<ActionExecutionRequest?>(null);
     }
 
-
     /// <summary>
     /// Raised when a result needs to be displayed in a window.
     /// The UI subscribes and is responsible for showing the window and then returning a Task
@@ -46,13 +67,14 @@ public static class AppEvents
     /// <returns>A RefinementRequest if the user wants to refine, otherwise null.</returns>
     public static async Task<RefinementRequest?> RequestResultWindowAsync(ResultWindowData data)
     {
+        if (!IsShowResultWindowEnabled) return null;
+
         return ShowResultWindowAndAwaitRefinement is not null
             ? await ShowResultWindowAndAwaitRefinement.Invoke(data)
             : await Task.FromResult<RefinementRequest?>(null);
         // Graceful failure
     }
 
-
     /// <summary>
     /// Raised to show a system notification (toast).
     /// The UI layer subscribes to this to display feedback.
@@ -64,9 +86,11 @@ public static class AppEvents
     /// </summary>
     public static void RequestNotification(string message, NotificationType type)
     {
+        if (!IsShowNotificationEnabled) return;
+
         ShowNotificationRequested?.Invoke(message, type);
     }
-    
+
     /// <summary>
     /// Raised when the Action Management Service detects conflicts during an import.
     /// The UI layer subscribes to this, shows a resolution dialog, and returns the user's choices.
@@ -79,6 +103,8 @@ public static void RequestNotification(string message, NotificationType type)
     /// <returns>A list of resolved conflicts, or null if the user cancelled the operation.</returns>
     public static async Task<List<ActionConflict>?> RequestConflictResolutionAsync(List<ActionConflict> conflicts)
     {
+        if (!IsResolveConflictsEnabled) return null;
+
         return ResolveConflictsRequested is not null
             ? await ResolveConflictsRequested.Invoke(conflicts)
             : await Task.FromResult<List<ActionConflict>?>(null);

ProseFlow.Application/Interfaces/IHotkeyRecordingService.cs

@@ -0,0 +1,38 @@
+using ProseFlow.Application.DTOs;
+
+namespace ProseFlow.Application.Interfaces;
+
+/// <summary>
+/// Defines a contract for a service that can globally capture a single hotkey combination.
+/// This acts as a mediator between the global hook and the UI for configuration purposes.
+/// </summary>
+public interface IHotkeyRecordingService
+{
+    /// <summary>
+    /// Fired when a valid, complete hotkey combination has been detected while in recording mode.
+    /// The event payload is a technology-agnostic DTO.
+    /// </summary>
+    event Action<HotkeyData> HotkeyDetected;
+    
+    /// <summary>
+    /// Fired when the state of pressed modifiers changes during recording, providing live feedback.
+    /// The string payload is a user-friendly representation of the current state (e.g., "Ctrl+Shift...").
+    /// </summary>
+    event Action<string> RecordingStateUpdated;
+
+    /// <summary>
+    /// Gets a value indicating whether the service is currently listening for a single hotkey input.
+    /// </summary>
+    bool IsRecording { get; }
+
+    /// <summary>
+    /// Puts the service into recording mode.
+    /// It will listen for the next valid key combination press.
+    /// </summary>
+    void BeginRecording();
+
+    /// <summary>
+    /// Takes the service out of recording mode.
+    /// </summary>
+    void EndRecording();
+}

ProseFlow.Application/Services/ActionOrchestrationService.cs

@@ -6,6 +6,7 @@
 using ProseFlow.Application.Interfaces;
 using ProseFlow.Core.Enums;
 using ProseFlow.Core.Interfaces;
+using ProseFlow.Core.Interfaces.Os;
 using ProseFlow.Core.Models;
 using Action = ProseFlow.Core.Models.Action;
 
@@ -14,30 +15,36 @@ namespace ProseFlow.Application.Services;
 public class ActionOrchestrationService : IDisposable
 {
     private readonly IServiceScopeFactory _scopeFactory;
-    private readonly IOsService _osService;
     private readonly IReadOnlyDictionary<string, IAiProvider> _providers;
     private readonly ILocalSessionService _localSessionService;
     private readonly ILogger<ActionOrchestrationService> _logger;
+    
+    private readonly IHotkeyService _hotkeyService;
+    private readonly IActiveWindowService _activeWindowService;
+    private readonly IClipboardService _clipboardService;
 
-    public ActionOrchestrationService(IServiceScopeFactory scopeFactory, IOsService osService,
+    public ActionOrchestrationService(IServiceScopeFactory scopeFactory, IHotkeyService hotkeyService, IActiveWindowService activeWindowService,
+        IClipboardService clipboardService,
         IEnumerable<IAiProvider> providers, ILocalSessionService localSessionService, ILogger<ActionOrchestrationService> logger)
     {
         _scopeFactory = scopeFactory;
-        _osService = osService;
+        _hotkeyService = hotkeyService;
+        _activeWindowService = activeWindowService;
+        _clipboardService = clipboardService;
         _localSessionService = localSessionService;
         _providers = providers.ToDictionary(p => p.Name, p => p, StringComparer.OrdinalIgnoreCase);
         _logger = logger;
     }
 
     public void Initialize()
     {
-        _osService.ActionMenuHotkeyPressed += async () => await HandleActionMenuHotkeyAsync();
-        _osService.SmartPasteHotkeyPressed += async () => await HandleSmartPasteHotkeyAsync();
+        _hotkeyService.ActionMenuHotkeyPressed += async () => await HandleActionMenuHotkeyAsync();
+        _hotkeyService.SmartPasteHotkeyPressed += async () => await HandleSmartPasteHotkeyAsync();
     }
 
     private async Task HandleActionMenuHotkeyAsync()
     {
-        var activeAppContext = await _osService.GetActiveWindowProcessNameAsync();
+        var activeAppContext = await _activeWindowService.GetActiveWindowProcessNameAsync();
         var allActions = await ExecuteQueryAsync(unitOfWork => unitOfWork.Actions.GetAllOrderedAsync());
 
         // Filter actions based on context
@@ -98,7 +105,7 @@ private async Task ProcessRequestAsync(ActionExecutionRequest request)
 
         try
         {
-            var userInput = await _osService.GetSelectedTextAsync();
+            var userInput = await _clipboardService.GetSelectedTextAsync();
             if (string.IsNullOrWhiteSpace(userInput))
             {
                 AppEvents.RequestNotification("No text selected or clipboard is empty.", NotificationType.Warning);
@@ -192,7 +199,7 @@ await LogToHistoryAsync(
                     latencyMs,
                     aiResponse.TokensPerSecond);
 
-                await _osService.PasteTextAsync(aiResponse.Content);
+                await _clipboardService.PasteTextAsync(aiResponse.Content);
             }
 
             overallStopwatch.Stop();
@@ -305,7 +312,7 @@ private async Task LogToHistoryAsync(string actionName, string providerType, str
 
     public void Dispose()
     {
-        _osService.Dispose();
+        _hotkeyService.Dispose();
         foreach (var provider in _providers.Values)
         {
             provider.Dispose();

ProseFlow.Core/Interfaces/IActiveWindowTracker.cs

@@ -0,0 +1,13 @@
+namespace ProseFlow.Core.Interfaces.Os;
+
+/// <summary>
+/// Defines the contract for a service that tracks the active window.
+/// </summary>
+public interface IActiveWindowService
+{
+    /// <summary>
+    /// Gets the process name of the currently active window.
+    /// </summary>
+    /// <returns>The active window's process name.</returns>
+    Task<string> GetActiveWindowProcessNameAsync();
+}

ProseFlow.Core/Interfaces/IOsService.cs

@@ -0,0 +1,19 @@
+namespace ProseFlow.Core.Interfaces.Os;
+
+/// <summary>
+/// Defines the contract for a service that handles clipboard interactions.
+/// </summary>
+public interface IClipboardService
+{
+    /// <summary>
+    /// Attempts to get the currently selected text by simulating a copy action.
+    /// </summary>
+    /// <returns>The selected text, or null if no text is selected or could be copied.</returns>
+    Task<string?> GetSelectedTextAsync();
+
+    /// <summary>
+    /// Pastes the specified text at the current cursor position by simulating a paste action.
+    /// </summary>
+    /// <param name="text">The text to paste.</param>
+    Task PasteTextAsync(string text);
+}

ProseFlow.Core/Interfaces/Os/IActiveWindowService.cs

@@ -0,0 +1,29 @@
+namespace ProseFlow.Core.Interfaces.Os;
+
+/// <summary>
+/// Defines the contract for a service that manages global hotkeys.
+/// </summary>
+public interface IHotkeyService : IDisposable
+{
+    /// <summary>
+    /// Fired when the hotkey combination for the Action Menu is pressed.
+    /// </summary>
+    event Action? ActionMenuHotkeyPressed;
+
+    /// <summary>
+    /// Fired when the hotkey combination for Smart Paste is pressed.
+    /// </summary>
+    event Action? SmartPasteHotkeyPressed;
+
+    /// <summary>
+    /// Starts the global hook to listen for keyboard events.
+    /// </summary>
+    Task StartHookAsync();
+
+    /// <summary>
+    /// Updates the hotkey combinations from string configurations.
+    /// </summary>
+    /// <param name="actionMenuHotkey">The hotkey string for the Action Menu.</param>
+    /// <param name="smartPasteHotkey">The hotkey string for Smart Paste.</param>
+    void UpdateHotkeys(string actionMenuHotkey, string smartPasteHotkey);
+}

ProseFlow.Core/Interfaces/Os/IClipboardService.cs

@@ -0,0 +1,13 @@
+namespace ProseFlow.Core.Interfaces.Os;
+
+/// <summary>
+/// Defines the contract for a service that handles general OS-level interactions.
+/// </summary>
+public interface ISystemService
+{
+    /// <summary>
+    /// Configures the application to launch automatically at login.
+    /// </summary>
+    /// <param name="isEnabled">True to enable launch at login, false to disable.</param>
+    void SetLaunchAtLogin(bool isEnabled);
+}