Bump version.

.github/workflows/pr-winui-build.yml

@@ -1,125 +0,0 @@
-name: PR WinUI Build
-
-on:
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
-
-permissions:
-  contents: read
-  packages: read
-
-jobs:
-  build-winui:
-    name: Build project (${{ matrix.platform }})
-    if: github.event.pull_request.draft == false
-    runs-on: windows-latest
-    continue-on-error: ${{ contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.pull_request.author_association) }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - platform: x86
-            rid: win-x86
-          - platform: x64
-            rid: win-x64
-          - platform: ARM64
-            rid: win-arm64
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup .NET SDK
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 10.0.x
-          source-url: https://nuget.pkg.github.com/bkaankose/index.json
-        env:
-          NUGET_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Restore WinUI project dependencies
-        run: dotnet restore Wino.Mail.WinUI/Wino.Mail.WinUI.csproj --configfile nuget.config -p:Platform=${{ matrix.platform }} -p:RuntimeIdentifier=${{ matrix.rid }}
-
-      - name: Build WinUI project
-        run: dotnet build Wino.Mail.WinUI/Wino.Mail.WinUI.csproj --configuration Release --no-restore -p:Platform=${{ matrix.platform }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:GenerateAppxPackageOnBuild=false -p:AppxPackageSigningEnabled=false
-
-  core-tests:
-    name: Run Core tests
-    if: github.event.pull_request.draft == false
-    runs-on: windows-latest
-    continue-on-error: ${{ contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.pull_request.author_association) }}
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup .NET SDK
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 10.0.x
-          source-url: https://nuget.pkg.github.com/bkaankose/index.json
-        env:
-          NUGET_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Restore Core test projects
-        shell: pwsh
-        run: |
-          $coreTests = Get-ChildItem -Path . -Recurse -Filter "*Core*.Tests.csproj" | ForEach-Object { $_.FullName }
-          if (-not $coreTests) {
-            throw "No Core test projects were found."
-          }
-
-          foreach ($project in $coreTests) {
-            dotnet restore $project --configfile nuget.config
-          }
-
-      - name: Run Core test projects
-        shell: pwsh
-        run: |
-          New-Item -ItemType Directory -Path TestResults -Force | Out-Null
-          $coreTests = Get-ChildItem -Path . -Recurse -Filter "*Core*.Tests.csproj"
-          if (-not $coreTests) {
-            throw "No Core test projects were found."
-          }
-
-          foreach ($project in $coreTests) {
-            $name = $project.BaseName
-            dotnet test $project.FullName --configuration Release --no-restore --verbosity normal --logger "trx;LogFileName=$name.trx" --results-directory TestResults
-          }
-
-      - name: Upload Core test result artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: core-test-results
-          path: TestResults/*.trx
-          if-no-files-found: warn
-
-      - name: Publish Core test report
-        if: always()
-        uses: EnricoMi/publish-unit-test-result-action/windows@v2
-        with:
-          trx_files: TestResults/*.trx
-          check_name: Core test results
-
-  enforce-for-non-maintainers:
-    name: Enforce required checks (non-maintainers)
-    if: github.event.pull_request.draft == false && !contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.pull_request.author_association)
-    runs-on: ubuntu-latest
-    needs:
-      - build-winui
-      - core-tests
-
-    steps:
-      - name: Fail when build or tests fail for non-maintainers
-        if: needs.build-winui.result != 'success' || needs.core-tests.result != 'success'
-        run: |
-          echo "WinUI build and Core tests must pass for non-maintainer pull requests."
-          exit 1
-
-      - name: Confirm build and test success for non-maintainers
-        run: echo "WinUI build and Core tests passed."

AGENTS.md

@@ -150,6 +150,8 @@ private string searchQuery = string.Empty;
 - For dependency properties in WinUI code, always prefer `[GeneratedDependencyProperty]` from CommunityToolkit over manual `DependencyProperty.Register(...)` declarations.
 - When a `[RelayCommand]` needs enable/disable logic, prefer the command's `CanExecute` over binding `Button.IsEnabled` in XAML; use `[NotifyCanExecuteChangedFor]` on dependent properties and call `NotifyCanExecuteChanged()` explicitly when non-generated state affects the command.
 - In ViewModels, update all UI-bound properties/collections via `ExecuteUIThread(...)` (especially after awaited calls and any use of `ConfigureAwait(false)`).
+- `ConfigureAwait(false)` continues execution on a background thread. Any UI-bound property change, `INotifyPropertyChanged` notification, collection mutation, or similar UI-facing state update after that point must be marshaled back with `ExecuteUIThread(...)` or the appropriate dispatcher call, otherwise the app can crash.
+- Messenger messages are raised from a background thread by default, while UI control event handlers such as `Button.Click` start on the UI thread. Be deliberate when combining dispatcher usage with `ConfigureAwait(false)` so post-await UI updates always return to the UI thread.
 - ViewModels should only handle UI interaction/state and delegate business logic to services; account-management work belongs in `WinoAccountProfileService`, and preferences import/export/apply logic belongs in `PreferencesService`.
 - In `EventDetailsPageViewModel.LoadAttendeesAsync`, never mutate `CurrentEvent.Attendees` outside `ExecuteUIThread(...)`.
 - Never create pure C# controls or controls that heavily manipulate UI structure from `.cs` files. Define controls in XAML and keep UI composition in XAML.

CHANGELOG.md

@@ -1,7 +0,0 @@
-Released on April 15. Second bugfix/improvements update for v2 beta testing.
-
--  [Ability to delete custom themes](https://github.com/bkaankose/Wino-Mail/issues/844)
--  [[Proposal] Reply/Reply all sets focus to the "To" line versus Body](https://github.com/bkaankose/Wino-Mail/issues/844274)
-- Email categories. Online sync for Outlook, offline use for IMAP/Gmail.
-- Handling of read-only calendars.
-- Implemented a new Github action workflow to trigger beta releases on demand.

Wino.Calendar.ViewModels/CalendarAppShellViewModel.cs

@@ -169,6 +169,7 @@ public partial class CalendarAppShellViewModel : CalendarBaseViewModel,
 
         var activationContext = parameters as ShellModeActivationContext;
         var shouldRunStartupFlows = activationContext?.IsInitialActivation ?? true;
+        var navigationArgs = activationContext?.Parameter as CalendarPageNavigationArgs;
 
         PreferencesService.PreferenceChanged -= PreferencesServiceChanged;
         PreferencesService.PreferenceChanged += PreferencesServiceChanged;
@@ -178,7 +179,14 @@ public partial class CalendarAppShellViewModel : CalendarBaseViewModel,
         await InitializeAccountCalendarsAsync();
         ValidateConfiguredNewEventCalendar();
 
-        TodayClicked();
+        if (navigationArgs != null)
+        {
+            NavigationService.Navigate(WinoPage.CalendarPage, navigationArgs);
+        }
+        else if (shouldRunStartupFlows || _calendarPageViewModel.CurrentVisibleRange == null)
+        {
+            TodayClicked();
+        }
     }
 
     public override void OnNavigatedFrom(NavigationMode mode, object parameters)

Wino.Calendar.ViewModels/CalendarPageViewModel.cs

@@ -634,7 +634,7 @@ public partial class CalendarPageViewModel : CalendarBaseViewModel,
         }
     }
 
-    public async Task ApplyDisplayRequestAsync(CalendarDisplayRequest request, bool forceReload = false)
+    public async Task ApplyDisplayRequestAsync(CalendarDisplayRequest request, bool forceReload = false, CalendarItemTarget pendingTarget = null)
     {
         var lifetimeVersion = CurrentPageLifetimeVersion;
         var hasLoadingLock = await WaitForCalendarLoadingLockAsync(lifetimeVersion).ConfigureAwait(false);
@@ -718,6 +718,11 @@ public partial class CalendarPageViewModel : CalendarBaseViewModel,
             await _notificationBuilder.ClearCalendarTaskbarBadgeAsync().ConfigureAwait(false);
             _isCalendarBadgeClearedForPageLifetime = true;
         }
+
+        if (loadSucceeded && pendingTarget != null && IsPageActive(lifetimeVersion))
+        {
+            await NavigateToPendingCalendarTargetAsync(pendingTarget).ConfigureAwait(false);
+        }
     }
 
     public Task ReloadCurrentVisibleRangeAsync()
@@ -745,6 +750,31 @@ public partial class CalendarPageViewModel : CalendarBaseViewModel,
         NavigateEvent(new CalendarItemViewModel(calendarItem), CalendarEventTargetType.Single);
     }
 
+    private async Task NavigateToPendingCalendarTargetAsync(CalendarItemTarget target)
+    {
+        CalendarItemViewModel calendarItemViewModel = null;
+
+        if (_loadedCalendarItems.TryGetValue(target.Item.Id, out var loadedCalendarItemViewModel))
+        {
+            calendarItemViewModel = loadedCalendarItemViewModel;
+        }
+        else
+        {
+            var targetItem = await _calendarService.GetCalendarItemTargetAsync(target).ConfigureAwait(false);
+            if (targetItem == null)
+                return;
+
+            targetItem.AssignedCalendar ??= AccountCalendarStateService.ActiveCalendars.FirstOrDefault(calendar => calendar.Id == targetItem.CalendarId);
+            calendarItemViewModel = new CalendarItemViewModel(targetItem);
+        }
+
+        await ExecuteUIThread(() =>
+        {
+            DisplayDetailsCalendarItemViewModel = calendarItemViewModel;
+            NavigateEvent(calendarItemViewModel, target.TargetType);
+        }).ConfigureAwait(false);
+    }
+
     private async Task<List<CalendarItemViewModel>> LoadCalendarItemsAsync(DateRange loadedDateWindow, long lifetimeVersion)
     {
         var loadedItems = new Dictionary<Guid, CalendarItemViewModel>();
@@ -819,7 +849,7 @@ public partial class CalendarPageViewModel : CalendarBaseViewModel,
     }
 
     public async void Receive(LoadCalendarMessage message)
-        => await ApplyDisplayRequestAsync(message.DisplayRequest, message.ForceReload);
+        => await ApplyDisplayRequestAsync(message.DisplayRequest, message.ForceReload, message.PendingTarget);
 
     public void Receive(CalendarSettingsUpdatedMessage message)
     {

Wino.Core.Domain/Constants.cs

@@ -24,6 +24,7 @@ public static class Constants
     public const string ToastModeKey = nameof(ToastModeKey);
     public const string ToastModeMail = nameof(ToastModeMail);
     public const string ToastModeCalendar = nameof(ToastModeCalendar);
+    public const string ToastDismissActionKey = nameof(ToastDismissActionKey);
     public const string ToastStoreUpdateActionKey = nameof(ToastStoreUpdateActionKey);
     public const string ToastStoreUpdateActionInstall = nameof(ToastStoreUpdateActionInstall);
     public const string ClientLogFile = "Client_.log";

Wino.Core.Domain/Enums/WinoPage.cs

@@ -19,6 +19,7 @@ public enum WinoPage
     AboutPage,
     PersonalizationPage,
     MessageListPage,
+    MailNotificationSettingsPage,
     MailListPage,
     ReadComposePanePage,
     AppPreferencesPage,

Wino.Core.Domain/Interfaces/IPreferencesService.cs

@@ -192,6 +192,16 @@ public interface IPreferencesService : INotifyPropertyChanged
     /// </summary>
     Guid? StartupEntityId { get; set; }
 
+    /// <summary>
+    /// Setting: First action button displayed on mail toast notifications.
+    /// </summary>
+    MailOperation FirstMailNotificationAction { get; set; }
+
+    /// <summary>
+    /// Setting: Second action button displayed on mail toast notifications.
+    /// </summary>
+    MailOperation SecondMailNotificationAction { get; set; }
+
 
 
     /// <summary>

Wino.Core.Domain/Models/Calendar/CalendarPageNavigationArgs.cs

@@ -1,4 +1,5 @@
-using System;
+#nullable enable
+using System;
 
 namespace Wino.Core.Domain.Models.Calendar;
 
@@ -18,4 +19,9 @@ public class CalendarPageNavigationArgs
     /// Force reloading the calendar data even when the target range does not change.
     /// </summary>
     public bool ForceReload { get; set; }
+
+    /// <summary>
+    /// Optional event target to navigate to after the calendar page loads the requested range.
+    /// </summary>
+    public CalendarItemTarget? PendingTarget { get; set; }
 }

Wino.Core.Domain/Models/Settings/SettingsNavigationItemInfo.cs

@@ -68,6 +68,11 @@ public static class SettingsNavigationInfoProvider
                 Translator.SettingsMessageList_Description,
                 "\uE8C4",
                 searchKeywords: Translator.SettingsSearch_MessageList_Keywords),
+            new(WinoPage.MailNotificationSettingsPage,
+                Translator.SettingsMailNotifications_Title,
+                Translator.SettingsMailNotifications_Description,
+                "\uE7F4",
+                searchKeywords: Translator.SettingsSearch_MailNotifications_Keywords),
             new(WinoPage.ReadComposePanePage,
                 Translator.SettingsReadComposePane_Title,
                 Translator.SettingsReadComposePane_Description,
@@ -149,6 +154,7 @@ public static class SettingsNavigationInfoProvider
             WinoPage.PersonalizationPage => Translator.SettingsPersonalization_Title,
             WinoPage.AboutPage => Translator.SettingsAbout_Title,
             WinoPage.MessageListPage => Translator.SettingsMessageList_Title,
+            WinoPage.MailNotificationSettingsPage => Translator.SettingsMailNotifications_Title,
             WinoPage.ReadComposePanePage => Translator.SettingsReadComposePane_Title,
             WinoPage.AppPreferencesPage => Translator.SettingsAppPreferences_Title,
             WinoPage.CalendarSettingsPage => Translator.CalendarSettings_Preferences_Title,

Wino.Core.Domain/Translations/en_US/resources.json

@@ -84,6 +84,7 @@
     "Buttons_Delete": "Delete",
     "Buttons_Deny": "Deny",
     "Buttons_Discard": "Discard",
+    "Buttons_Dismiss": "Dismiss",
     "Buttons_Edit": "Edit",
     "Buttons_EnableImageRendering": "Enable",
     "Buttons_Multiselect": "Select Multiple",
@@ -910,6 +911,14 @@
     "SettingsMarkAsRead_WhenSelected": "When selected",
     "SettingsMessageList_Description": "Change how your messages should be organized in mail list.",
     "SettingsMessageList_Title": "Message List",
+    "SettingsMailNotifications_Title": "Notifications",
+    "SettingsMailNotifications_Description": "Notification settings and preferences for mails.",
+    "SettingsMailNotifications_Actions_Title": "App notification actions.",
+    "SettingsMailNotifications_Actions_Description": "Customize the button behaviors on the notifications as you like.",
+    "SettingsMailNotifications_FirstAction_Title": "First notification action",
+    "SettingsMailNotifications_FirstAction_Description": "Choose the first button shown on mail notifications.",
+    "SettingsMailNotifications_SecondAction_Title": "Second notification action",
+    "SettingsMailNotifications_SecondAction_Description": "Choose the second button shown on mail notifications.",
     "SettingsNoAccountSetupMessage": "You didn't setup any accounts yet.",
     "SettingsNotifications_Description": "Turn on or off notifications for this account.",
     "SettingsNotifications_Title": "Notifications",
@@ -946,6 +955,7 @@
     "SettingsSearch_About_Keywords": "about;version;website;privacy;github;donate;store;support",
     "SettingsSearch_KeyboardShortcuts_Keywords": "shortcut;shortcuts;hotkey;hotkeys;keyboard;keys",
     "SettingsSearch_MessageList_Keywords": "message;messages;list;threading;threads;avatar;preview;sender",
+    "SettingsSearch_MailNotifications_Keywords": "mail;notification;notifications;toast;action;actions;reply;reply all;forward;archive;delete;junk;read",
     "SettingsSearch_ReadComposePane_Keywords": "reader;compose;composer;font;fonts;external content;display;reading",
     "SettingsSearch_SignatureAndEncryption_Keywords": "signature;signatures;encryption;certificate;certificates;s mime;smime;security",
     "SettingsSearch_Storage_Keywords": "storage;cache;caching;mime;disk;space;cleanup;clean up;local data",

Wino.Core/Extensions/GoogleIntegratorExtensions.cs

@@ -14,27 +14,32 @@ namespace Wino.Core.Extensions;
 
 public static class GoogleIntegratorExtensions
 {
-    private static string GetNormalizedLabelName(string labelName)
+    private static bool TryGetKnownFolderLabelName(string labelName, out string normalizedLabelName)
     {
-        // 1. Remove CATEGORY_ prefix.
-        var normalizedLabelName = labelName.Replace(ServiceConstants.CATEGORY_PREFIX, string.Empty);
+        normalizedLabelName = string.Empty;
 
-        // 2. Normalize label name by capitalizing first letter.
-        normalizedLabelName = char.ToUpper(normalizedLabelName[0]) + normalizedLabelName.Substring(1).ToLower();
+        if (string.IsNullOrEmpty(labelName))
+            return false;
 
-        return normalizedLabelName;
+        var knownFolderKey = labelName.Replace(ServiceConstants.CATEGORY_PREFIX, string.Empty);
+
+        if (!ServiceConstants.KnownFolderDictionary.ContainsKey(knownFolderKey))
+            return false;
+
+        normalizedLabelName = char.ToUpper(knownFolderKey[0]) + knownFolderKey.Substring(1).ToLower();
+
+        return true;
     }
 
     public static MailItemFolder GetLocalFolder(this Label label, ListLabelsResponse labelsResponse, Guid accountId)
     {
-        var normalizedLabelName = GetFolderName(label.Name);
+        var folderName = GetFolderName(label.Name);
 
-        // Even though we normalize the label name, check is done by capitalizing the label name.
-        var capitalNormalizedLabelName = normalizedLabelName.ToUpper();
+        var lookupLabelName = GetLookupLabelName(label.Name);
 
-        bool isSpecialFolder = ServiceConstants.KnownFolderDictionary.ContainsKey(capitalNormalizedLabelName);
+        bool isSpecialFolder = ServiceConstants.KnownFolderDictionary.ContainsKey(lookupLabelName);
 
-        var specialFolderType = isSpecialFolder ? ServiceConstants.KnownFolderDictionary[capitalNormalizedLabelName] : SpecialFolderType.Other;
+        var specialFolderType = isSpecialFolder ? ServiceConstants.KnownFolderDictionary[lookupLabelName] : SpecialFolderType.Other;
 
         // We used to support FOLDER_HIDE_IDENTIFIER to hide invisible folders.
         // However, a lot of people complained that they don't see their folders after the initial sync
@@ -59,7 +64,7 @@ public static class GoogleIntegratorExtensions
         {
             TextColorHex = label.Color?.TextColor,
             BackgroundColorHex = label.Color?.BackgroundColor,
-            FolderName = normalizedLabelName,
+            FolderName = folderName,
             RemoteFolderId = label.Id,
             Id = Guid.NewGuid(),
             MailAccountId = accountId,
@@ -104,7 +109,29 @@ public static class GoogleIntegratorExtensions
         return labelsResponse.Labels.FirstOrDefault(a => a.Name == parentLabelName)?.Id ?? string.Empty;
     }
 
+    public static string GetLookupLabelName(string fullFolderName)
+    {
+        var folderName = GetLastFolderName(fullFolderName);
+
+        if (string.IsNullOrEmpty(folderName))
+            return string.Empty;
+
+        return folderName.Replace(ServiceConstants.CATEGORY_PREFIX, string.Empty);
+    }
+
     public static string GetFolderName(string fullFolderName)
+    {
+        var lastPart = GetLastFolderName(fullFolderName);
+
+        if (string.IsNullOrEmpty(lastPart))
+            return string.Empty;
+
+        return TryGetKnownFolderLabelName(lastPart, out var normalizedLabelName)
+            ? normalizedLabelName
+            : lastPart;
+    }
+
+    private static string GetLastFolderName(string fullFolderName)
     {
         if (string.IsNullOrEmpty(fullFolderName)) return string.Empty;
 
@@ -113,9 +140,7 @@ public static class GoogleIntegratorExtensions
 
         string[] parts = fullFolderName.Split(ServiceConstants.FOLDER_SEPERATOR_CHAR);
 
-        var lastPart = parts[parts.Length - 1];
-
-        return GetNormalizedLabelName(lastPart);
+        return parts[parts.Length - 1];
     }
 
     public static List<RemoteAccountAlias> GetRemoteAliases(this ListSendAsResponse response)

Wino.Core/Synchronizers/GmailSynchronizer.cs

@@ -904,7 +904,7 @@ public class GmailSynchronizer : WinoSynchronizer<IClientServiceRequest, Message
 
                 if (ShouldUpdateFolder(remoteFolder, existingLocalFolder))
                 {
-                    existingLocalFolder.FolderName = remoteFolder.Name;
+                    existingLocalFolder.FolderName = GoogleIntegratorExtensions.GetFolderName(remoteFolder.Name);
                     existingLocalFolder.TextColorHex = remoteFolder.Color?.TextColor;
                     existingLocalFolder.BackgroundColorHex = remoteFolder.Color?.BackgroundColor;
 
@@ -998,9 +998,9 @@ public class GmailSynchronizer : WinoSynchronizer<IClientServiceRequest, Message
     private bool ShouldUpdateFolder(Label remoteFolder, MailItemFolder existingLocalFolder)
     {
         var remoteFolderName = GoogleIntegratorExtensions.GetFolderName(remoteFolder.Name);
-        var localFolderName = GoogleIntegratorExtensions.GetFolderName(existingLocalFolder.FolderName);
+        var localFolderName = existingLocalFolder.FolderName ?? string.Empty;
 
-        bool isNameChanged = !localFolderName.Equals(remoteFolderName, StringComparison.OrdinalIgnoreCase);
+        bool isNameChanged = !localFolderName.Equals(remoteFolderName, StringComparison.Ordinal);
         bool isColorChanged = existingLocalFolder.BackgroundColorHex != remoteFolder.Color?.BackgroundColor ||
                 existingLocalFolder.TextColorHex != remoteFolder.Color?.TextColor;
 

Wino.Mail.ViewModels/MailListPageViewModel.cs

@@ -23,7 +23,6 @@ using Wino.Core.Domain.Models.MailItem;
 using Wino.Core.Domain.Models.Menus;
 using Wino.Core.Domain.Models.Navigation;
 using Wino.Core.Domain.Models.Reader;
-using Wino.Core.Domain.Models.Synchronization;
 using Wino.Core.Requests.Mail;
 using Wino.Core.Services;
 using Wino.Mail.ViewModels.Collections;
@@ -486,26 +485,29 @@ public partial class MailListPageViewModel : MailBaseViewModel,
     {
         if (!CanSynchronize) return;
 
+        _notificationBuilder.CreateNotificationsAsync(MailCollection.SelectedItems.Select(a => a.MailCopy));
+        return;
+
         // Only synchronize listed folders.
 
         // When doing linked inbox sync, we need to save the sync id to report progress back only once.
         // Otherwise, we will report progress for each folder and that's what we don't want.
 
-        trackingSynchronizationId = Guid.NewGuid();
-        completedTrackingSynchronizationCount = 0;
+        //trackingSynchronizationId = Guid.NewGuid();
+        //completedTrackingSynchronizationCount = 0;
 
-        foreach (var folder in ActiveFolder.HandlingFolders)
-        {
-            var options = new MailSynchronizationOptions()
-            {
-                AccountId = folder.MailAccountId,
-                Type = MailSynchronizationType.CustomFolders,
-                SynchronizationFolderIds = [folder.Id],
-                GroupedSynchronizationTrackingId = trackingSynchronizationId
-            };
+        //foreach (var folder in ActiveFolder.HandlingFolders)
+        //{
+        //    var options = new MailSynchronizationOptions()
+        //    {
+        //        AccountId = folder.MailAccountId,
+        //        Type = MailSynchronizationType.CustomFolders,
+        //        SynchronizationFolderIds = [folder.Id],
+        //        GroupedSynchronizationTrackingId = trackingSynchronizationId
+        //    };
 
-            Messenger.Send(new NewMailSynchronizationRequested(options));
-        }
+        //    Messenger.Send(new NewMailSynchronizationRequested(options));
+        //}
     }
 
     [RelayCommand]

Wino.Mail.ViewModels/MailNotificationSettingsPageViewModel.cs

@@ -0,0 +1,135 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain;
+
+namespace Wino.Mail.ViewModels;
+
+public partial class MailNotificationSettingsPageViewModel : MailBaseViewModel
+{
+    private static readonly MailOperation[] SupportedMailNotificationActions =
+    [
+        MailOperation.MarkAsRead,
+        MailOperation.SoftDelete,
+        MailOperation.MoveToJunk,
+        MailOperation.Archive,
+        MailOperation.Reply,
+        MailOperation.ReplyAll,
+        MailOperation.Forward
+    ];
+
+    private readonly IPreferencesService _preferencesService;
+    private bool _isUpdatingSelection;
+    private bool _isLoaded;
+
+    public ObservableCollection<MailNotificationActionOption> AvailableNotificationActions { get; } = [];
+
+    [ObservableProperty]
+    public partial MailNotificationActionOption SelectedFirstAction { get; set; }
+
+    [ObservableProperty]
+    public partial MailNotificationActionOption SelectedSecondAction { get; set; }
+
+    public MailNotificationSettingsPageViewModel(IPreferencesService preferencesService)
+    {
+        _preferencesService = preferencesService;
+
+        foreach (var action in SupportedMailNotificationActions)
+        {
+            AvailableNotificationActions.Add(new MailNotificationActionOption(action, GetOperationDisplayText(action)));
+        }
+
+        InitializeSelections();
+        _isLoaded = true;
+    }
+
+    partial void OnSelectedFirstActionChanged(MailNotificationActionOption value)
+    {
+        if (!_isLoaded || _isUpdatingSelection || value == null)
+            return;
+
+        EnsureDistinctSelections(changedSelection: value, isFirstSelection: true);
+        _preferencesService.FirstMailNotificationAction = value.Operation;
+    }
+
+    partial void OnSelectedSecondActionChanged(MailNotificationActionOption value)
+    {
+        if (!_isLoaded || _isUpdatingSelection || value == null)
+            return;
+
+        EnsureDistinctSelections(changedSelection: value, isFirstSelection: false);
+        _preferencesService.SecondMailNotificationAction = value.Operation;
+    }
+
+    private void InitializeSelections()
+    {
+        var firstAction = ResolveSupportedAction(_preferencesService.FirstMailNotificationAction, MailOperation.MarkAsRead);
+        var secondAction = ResolveSupportedAction(_preferencesService.SecondMailNotificationAction, MailOperation.SoftDelete);
+
+        if (secondAction == firstAction)
+        {
+            secondAction = GetFallbackDistinctAction(firstAction);
+        }
+
+        SelectedFirstAction = GetOption(firstAction);
+        SelectedSecondAction = GetOption(secondAction);
+
+        _preferencesService.FirstMailNotificationAction = firstAction;
+        _preferencesService.SecondMailNotificationAction = secondAction;
+    }
+
+    private void EnsureDistinctSelections(MailNotificationActionOption changedSelection, bool isFirstSelection)
+    {
+        var otherSelection = isFirstSelection ? SelectedSecondAction : SelectedFirstAction;
+        if (otherSelection?.Operation != changedSelection.Operation)
+            return;
+
+        _isUpdatingSelection = true;
+
+        var fallbackAction = GetFallbackDistinctAction(changedSelection.Operation);
+        var fallbackOption = GetOption(fallbackAction);
+
+        if (isFirstSelection)
+        {
+            SelectedSecondAction = fallbackOption;
+            _preferencesService.SecondMailNotificationAction = fallbackAction;
+        }
+        else
+        {
+            SelectedFirstAction = fallbackOption;
+            _preferencesService.FirstMailNotificationAction = fallbackAction;
+        }
+
+        _isUpdatingSelection = false;
+    }
+
+    private MailNotificationActionOption GetOption(MailOperation action)
+        => AvailableNotificationActions.First(option => option.Operation == action);
+
+    private static MailOperation ResolveSupportedAction(MailOperation action, MailOperation fallbackAction)
+        => SupportedMailNotificationActions.Contains(action) ? action : fallbackAction;
+
+    private static MailOperation GetFallbackDistinctAction(MailOperation excludedAction)
+        => SupportedMailNotificationActions.First(action => action != excludedAction);
+
+    private static string GetOperationDisplayText(MailOperation action)
+        => action switch
+        {
+            MailOperation.MarkAsRead => Translator.MailOperation_MarkAsRead,
+            MailOperation.SoftDelete => Translator.MailOperation_Delete,
+            MailOperation.MoveToJunk => Translator.MailOperation_MarkAsJunk,
+            MailOperation.Archive => Translator.MailOperation_Archive,
+            MailOperation.Reply => Translator.MailOperation_Reply,
+            MailOperation.ReplyAll => Translator.MailOperation_ReplyAll,
+            MailOperation.Forward => Translator.MailOperation_Forward,
+            _ => action.ToString()
+        };
+}
+
+public sealed class MailNotificationActionOption(MailOperation operation, string displayText)
+{
+    public MailOperation Operation { get; } = operation;
+    public string DisplayText { get; } = displayText;
+}

Wino.Mail.WinUI/Activation/AppNotificationActivationBuffer.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Windows.AppNotifications;
+
+namespace Wino.Mail.WinUI.Activation;
+
+internal sealed record BufferedAppNotificationActivation(string Argument, IReadOnlyDictionary<string, string>? UserInput);
+
+internal sealed class AppNotificationActivationBuffer
+{
+    private readonly ConcurrentQueue<BufferedAppNotificationActivation> _pendingActivations = new();
+    private readonly SemaphoreSlim _pendingSignal = new(0);
+
+    public void Enqueue(AppNotificationActivatedEventArgs args)
+    {
+        var copiedUserInput = args.UserInput == null
+            ? null
+            : new Dictionary<string, string>(args.UserInput, StringComparer.Ordinal);
+
+        _pendingActivations.Enqueue(new BufferedAppNotificationActivation(args.Argument, copiedUserInput));
+        _pendingSignal.Release();
+    }
+
+    public bool TryDequeue(out BufferedAppNotificationActivation activation)
+        => _pendingActivations.TryDequeue(out activation!);
+
+    public async Task<BufferedAppNotificationActivation?> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken = default)
+    {
+        if (!_pendingActivations.IsEmpty && TryDequeue(out var queuedActivation))
+            return queuedActivation;
+
+        if (!await _pendingSignal.WaitAsync(timeout, cancellationToken))
+            return null;
+
+        return TryDequeue(out var activation) ? activation : null;
+    }
+}

Wino.Mail.WinUI/Activation/CalendarEntryBootstrapActivation.cs

@@ -0,0 +1,207 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.Windows.AppLifecycle;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.Storage;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Mail.WinUI.Activation;
+
+internal enum PendingBootstrapActivationKind
+{
+    Launch,
+    Protocol,
+    File
+}
+
+internal sealed class PendingBootstrapActivation
+{
+    public PendingBootstrapActivationKind Kind { get; init; }
+    public WinoApplicationMode Mode { get; init; } = WinoApplicationMode.Mail;
+    public string? LaunchArguments { get; init; }
+    public string? TileId { get; init; }
+    public string? ProtocolUri { get; init; }
+    public string[] FilePaths { get; init; } = [];
+    public DateTimeOffset CreatedAtUtc { get; init; } = DateTimeOffset.UtcNow;
+}
+
+internal static class CalendarEntryBootstrapActivation
+{
+    private const string PendingActivationKey = "PendingCalendarEntryBootstrapActivation";
+    private const string KindKey = "Kind";
+    private const string ModeKey = "Mode";
+    private const string LaunchArgumentsKey = "LaunchArguments";
+    private const string TileIdKey = "TileId";
+    private const string ProtocolUriKey = "ProtocolUri";
+    private const string FilePathsKey = "FilePaths";
+    private const string CreatedAtUtcKey = "CreatedAtUtc";
+    private static readonly TimeSpan PendingActivationLifetime = TimeSpan.FromMinutes(1);
+
+    public static bool ShouldBootstrapToMailHost(AppActivationArguments activationArgs)
+        => TryCreatePendingActivation(activationArgs, out _);
+
+    public static bool QueuePendingActivation(AppActivationArguments activationArgs)
+    {
+        if (!TryCreatePendingActivation(activationArgs, out var pendingActivation))
+            return false;
+
+        ApplicationData.Current.LocalSettings.Values[PendingActivationKey] = CreateCompositeValue(pendingActivation!);
+        return true;
+    }
+
+    public static void ClearPendingActivation()
+        => ApplicationData.Current.LocalSettings.Values.Remove(PendingActivationKey);
+
+    public static PendingBootstrapActivation? ConsumePendingActivation()
+    {
+        if (!ApplicationData.Current.LocalSettings.Values.TryGetValue(PendingActivationKey, out var pendingActivationValue) ||
+            pendingActivationValue is not ApplicationDataCompositeValue compositeValue)
+        {
+            return null;
+        }
+
+        ClearPendingActivation();
+
+        try
+        {
+            var pendingActivation = ParseCompositeValue(compositeValue);
+            if (pendingActivation == null)
+                return null;
+
+            if (DateTimeOffset.UtcNow - pendingActivation.CreatedAtUtc > PendingActivationLifetime)
+                return null;
+
+            return pendingActivation;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private static ApplicationDataCompositeValue CreateCompositeValue(PendingBootstrapActivation pendingActivation)
+    {
+        var compositeValue = new ApplicationDataCompositeValue
+        {
+            [KindKey] = pendingActivation.Kind.ToString(),
+            [ModeKey] = pendingActivation.Mode.ToString(),
+            [LaunchArgumentsKey] = pendingActivation.LaunchArguments ?? string.Empty,
+            [TileIdKey] = pendingActivation.TileId ?? string.Empty,
+            [ProtocolUriKey] = pendingActivation.ProtocolUri ?? string.Empty,
+            [FilePathsKey] = string.Join("\n", pendingActivation.FilePaths),
+            [CreatedAtUtcKey] = pendingActivation.CreatedAtUtc.ToString("o")
+        };
+
+        return compositeValue;
+    }
+
+    private static PendingBootstrapActivation? ParseCompositeValue(ApplicationDataCompositeValue compositeValue)
+    {
+        if (!Enum.TryParse(compositeValue[KindKey]?.ToString(), ignoreCase: true, out PendingBootstrapActivationKind kind) ||
+            !Enum.TryParse(compositeValue[ModeKey]?.ToString(), ignoreCase: true, out WinoApplicationMode mode) ||
+            !DateTimeOffset.TryParse(compositeValue[CreatedAtUtcKey]?.ToString(), out var createdAtUtc))
+        {
+            return null;
+        }
+
+        return new PendingBootstrapActivation
+        {
+            Kind = kind,
+            Mode = mode,
+            LaunchArguments = GetOptionalCompositeString(compositeValue, LaunchArgumentsKey),
+            TileId = GetOptionalCompositeString(compositeValue, TileIdKey),
+            ProtocolUri = GetOptionalCompositeString(compositeValue, ProtocolUriKey),
+            FilePaths = GetOptionalCompositeString(compositeValue, FilePathsKey)?
+                .Split(['\n'], StringSplitOptions.RemoveEmptyEntries)
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray() ?? [],
+            CreatedAtUtc = createdAtUtc
+        };
+    }
+
+    private static string? GetOptionalCompositeString(ApplicationDataCompositeValue compositeValue, string key)
+    {
+        if (!compositeValue.TryGetValue(key, out var value))
+            return null;
+
+        var stringValue = value?.ToString();
+        return string.IsNullOrWhiteSpace(stringValue) ? null : stringValue;
+    }
+
+    public static bool LaunchMailHost()
+    {
+        var mailAppUserModelId = AppEntryConstants.GetAppUserModelId(WinoApplicationMode.Mail);
+        var appEntries = Package.Current.GetAppListEntriesAsync().AsTask().GetAwaiter().GetResult();
+        var mailEntry = appEntries.FirstOrDefault(entry =>
+            string.Equals(entry.AppUserModelId, mailAppUserModelId, StringComparison.OrdinalIgnoreCase));
+
+        return mailEntry != null && mailEntry.LaunchAsync().AsTask().GetAwaiter().GetResult();
+    }
+
+    private static bool TryCreatePendingActivation(AppActivationArguments activationArgs, out PendingBootstrapActivation? pendingActivation)
+    {
+        pendingActivation = null;
+
+        if (activationArgs.Kind == ExtendedActivationKind.Launch &&
+            activationArgs.Data is ILaunchActivatedEventArgs launchArgs)
+        {
+            var resolvedMode = AppModeActivationResolver.Resolve(launchArgs.Arguments, launchArgs.TileId, Environment.CommandLine);
+            if (resolvedMode != WinoApplicationMode.Calendar)
+                return false;
+
+            pendingActivation = new PendingBootstrapActivation
+            {
+                Kind = PendingBootstrapActivationKind.Launch,
+                Mode = resolvedMode,
+                LaunchArguments = launchArgs.Arguments,
+                TileId = launchArgs.TileId
+            };
+
+            return true;
+        }
+
+        if (activationArgs.Kind == ExtendedActivationKind.Protocol &&
+            activationArgs.Data is IProtocolActivatedEventArgs protocolArgs &&
+            protocolArgs.Uri != null &&
+            (string.Equals(protocolArgs.Uri.Scheme, "webcal", StringComparison.OrdinalIgnoreCase) ||
+             string.Equals(protocolArgs.Uri.Scheme, "webcals", StringComparison.OrdinalIgnoreCase)))
+        {
+            pendingActivation = new PendingBootstrapActivation
+            {
+                Kind = PendingBootstrapActivationKind.Protocol,
+                Mode = WinoApplicationMode.Calendar,
+                ProtocolUri = protocolArgs.Uri.AbsoluteUri
+            };
+
+            return true;
+        }
+
+        if (activationArgs.Kind == ExtendedActivationKind.File &&
+            activationArgs.Data is IFileActivatedEventArgs fileArgs)
+        {
+            var filePaths = fileArgs.Files?
+                .OfType<IStorageItem>()
+                .Where(item => string.Equals(Path.GetExtension(item.Path), ".ics", StringComparison.OrdinalIgnoreCase))
+                .Select(item => item.Path)
+                .Where(path => !string.IsNullOrWhiteSpace(path))
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+
+            if (filePaths == null || filePaths.Length == 0)
+                return false;
+
+            pendingActivation = new PendingBootstrapActivation
+            {
+                Kind = PendingBootstrapActivationKind.File,
+                Mode = WinoApplicationMode.Calendar,
+                FilePaths = filePaths
+            };
+
+            return true;
+        }
+
+        return false;
+    }
+}

Wino.Mail.WinUI/Activation/ToastActivationResolver.cs

@@ -41,9 +41,14 @@ internal static class ToastActivationResolver
             return calendarAction == Constants.ToastCalendarNavigateAction;
         }
 
+        if (toastArguments.TryGetValue(Constants.ToastDismissActionKey, out string _))
+        {
+            return false;
+        }
+
         if (toastArguments.TryGetValue(Constants.ToastActionKey, out MailOperation mailAction))
         {
-            return mailAction == MailOperation.Navigate;
+            return mailAction is MailOperation.Navigate or MailOperation.Reply or MailOperation.ReplyAll or MailOperation.Forward;
         }
 
         return true;
@@ -52,5 +57,6 @@ internal static class ToastActivationResolver
     private static bool ContainsKnownToastKey(NotificationArguments toastArguments)
         => toastArguments.TryGetValue(Constants.ToastStoreUpdateActionKey, out string _) ||
            toastArguments.TryGetValue(Constants.ToastCalendarActionKey, out string _) ||
+           toastArguments.TryGetValue(Constants.ToastDismissActionKey, out string _) ||
            toastArguments.TryGetValue(Constants.ToastActionKey, out string _);
 }

Wino.Mail.WinUI/App.xaml.cs

@@ -36,6 +36,7 @@ using Wino.Mail.ViewModels;
 using Wino.Mail.ViewModels.Data;
 using Wino.Mail.WinUI.Activation;
 using Wino.Mail.WinUI.Extensions;
+using Wino.Mail.WinUI.Helpers;
 using Wino.Mail.WinUI.Interfaces;
 using Wino.Mail.WinUI.Models;
 using Wino.Mail.WinUI.Services;
@@ -66,13 +67,19 @@ public partial class App : WinoApplication,
     private bool _hasConfiguredAccounts;
     private bool _isExiting;
     private bool _activationInfrastructureInitialized;
+    private bool _appHostInfrastructureInitialized;
+    private bool _appNotificationsRegistered;
     private int _initialNotificationActivationHandled;
     private int _initialShareActivationHandled;
     private CancellationTokenSource? _autoSynchronizationLoopCts;
     private readonly SemaphoreSlim _autoSynchronizationSemaphore = new(1, 1);
     private readonly SemaphoreSlim _activationInfrastructureSemaphore = new(1, 1);
+    private readonly SemaphoreSlim _appHostInfrastructureSemaphore = new(1, 1);
     private readonly ConcurrentDictionary<Guid, int> _inboxSyncCounters = [];
+    private readonly AppNotificationActivationBuffer _bufferedAppNotificationActivations = new();
     private NativeTrayIcon? _trayIcon;
+    private readonly record struct NotificationActivationRoute(bool RequiresForegroundWindow, Func<Task>? ExecuteAsync);
+    private readonly record struct ShellWindowActivationResult(IWinoShellWindow? ShellWindow, bool WasCreated);
 
     internal bool IsExiting => _isExiting;
 
@@ -83,6 +90,7 @@ public partial class App : WinoApplication,
         Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
         CryptographyContext.Register(typeof(WindowsSecureMimeContext));
 
+        EnsureAppNotificationRegistration();
         RegisterRecipients();
     }
 
@@ -271,12 +279,16 @@ public partial class App : WinoApplication,
         shellWindow.Close();
     }
 
-    private async Task ActivateWindowAsync(WindowEx window)
+    private async Task ActivateWindowAsync(WindowEx window, bool applyThemeToWindow = true)
     {
         var windowManager = Services.GetRequiredService<IWinoWindowManager>();
         MainWindow = window;
         windowManager.ActivateWindow(window);
-        await NewThemeService.ApplyThemeToActiveWindowAsync();
+
+        if (applyThemeToWindow)
+        {
+            await NewThemeService.ApplyThemeToActiveWindowAsync();
+        }
     }
 
     private Task ExitApplicationAsync()
@@ -358,6 +370,7 @@ public partial class App : WinoApplication,
         services.AddTransient(typeof(AccountDetailsPageViewModel));
         services.AddTransient(typeof(SignatureManagementPageViewModel));
         services.AddTransient(typeof(MessageListPageViewModel));
+        services.AddTransient(typeof(MailNotificationSettingsPageViewModel));
         services.AddTransient(typeof(ReadComposePanePageViewModel));
         services.AddTransient(typeof(MergedAccountDetailsPageViewModel));
         services.AddTransient(typeof(AppPreferencesPageViewModel));
@@ -409,6 +422,12 @@ public partial class App : WinoApplication,
         => Services.GetRequiredService<IWinoWindowManager>().GetWindow(WinoWindowKind.Shell) is IWinoShellWindow;
 
     private async Task EnsureActivationInfrastructureAsync()
+    {
+        await EnsureCoreActivationInfrastructureAsync();
+        await EnsureAppHostInfrastructureAsync();
+    }
+
+    private async Task EnsureCoreActivationInfrastructureAsync()
     {
         if (_activationInfrastructureInitialized)
             return;
@@ -420,7 +439,7 @@ public partial class App : WinoApplication,
             if (_activationInfrastructureInitialized)
                 return;
 
-            TryRegisterAppNotifications();
+            EnsureAppNotificationRegistration();
 
             await Services.GetRequiredService<ReleaseLocalAccountDataCleanupService>()
                 .RunIfNeededAsync();
@@ -431,18 +450,8 @@ public partial class App : WinoApplication,
             _preferencesService = Services.GetRequiredService<IPreferencesService>();
             _accountService = Services.GetRequiredService<IAccountService>();
 
-            EnsureWindowManagerConfigured();
-            EnsureTrayIconCreated();
-
             _hasConfiguredAccounts = (await _accountService.GetAccountsAsync()).Any();
 
-            if (_hasConfiguredAccounts)
-            {
-                _preferencesService.PreferenceChanged -= PreferencesServiceChanged;
-                _preferencesService.PreferenceChanged += PreferencesServiceChanged;
-                RestartAutoSynchronizationLoop();
-            }
-
             _activationInfrastructureInitialized = true;
         }
         finally
@@ -451,6 +460,38 @@ public partial class App : WinoApplication,
         }
     }
 
+    private async Task EnsureAppHostInfrastructureAsync()
+    {
+        await EnsureCoreActivationInfrastructureAsync();
+
+        if (_appHostInfrastructureInitialized)
+            return;
+
+        await _appHostInfrastructureSemaphore.WaitAsync();
+
+        try
+        {
+            if (_appHostInfrastructureInitialized)
+                return;
+
+            EnsureWindowManagerConfigured();
+            EnsureTrayIconCreated();
+
+            if (_hasConfiguredAccounts)
+            {
+                _preferencesService!.PreferenceChanged -= PreferencesServiceChanged;
+                _preferencesService.PreferenceChanged += PreferencesServiceChanged;
+                RestartAutoSynchronizationLoop();
+            }
+
+            _appHostInfrastructureInitialized = true;
+        }
+        finally
+        {
+            _appHostInfrastructureSemaphore.Release();
+        }
+    }
+
     private bool TryMarkInitialNotificationActivationHandled()
         => Interlocked.Exchange(ref _initialNotificationActivationHandled, 1) == 0;
 
@@ -461,115 +502,123 @@ public partial class App : WinoApplication,
     {
         base.OnLaunched(args);
 
-        await EnsureActivationInfrastructureAsync();
+        await EnsureCoreActivationInfrastructureAsync();
 
-        var activationArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
+        var activationArgs = ResolveStartupActivation();
 
-        if (activationArgs.Kind == ExtendedActivationKind.ShareTarget &&
-            TryMarkInitialShareActivationHandled())
-        {
-            LogActivation("Processing share target activation from OnLaunched.");
+        if (await TryHandleStartupAppNotificationActivationAsync(activationArgs))
+            return;
 
-            if (await HandleShareTargetActivationAsync(activationArgs, activateWindow: true))
-                return;
-        }
+        await EnsureAppHostInfrastructureAsync();
 
         var hasAnyAccount = _hasConfiguredAccounts;
-        if (!IsStartupTaskLaunch() && !hasAnyAccount)
+        var isStartupTaskLaunch = activationArgs.Kind == ExtendedActivationKind.StartupTask;
+
+        if (!hasAnyAccount && !isStartupTaskLaunch)
         {
-            CreateWelcomeWindow();
-            await NewThemeService.InitializeAsync();
-            MainWindow?.Activate();
-            LogActivation("Welcome window created and activated.");
+            await LaunchWelcomeWindowAsync();
             return;
         }
 
-        // Check if launched from toast notification.
-        if (IsNotificationActivation(out AppNotificationActivatedEventArgs toastArgs) &&
-            TryMarkInitialNotificationActivationHandled())
-        {
-            LogActivation($"Processing notification activation from OnLaunched. Arguments: {toastArgs.Argument}");
-            await HandleToastActivationAsync(toastArgs.Argument, toastArgs.UserInput);
+        if (await TryHandleLaunchActivationAsync(args, activationArgs))
             return;
-        }
 
-        if (ToastActivationResolver.TryParse(args.Arguments, out var launchToastArguments) &&
-            TryMarkInitialNotificationActivationHandled())
-        {
-            LogActivation($"Processing toast launch activation from OnLaunched. Arguments: {args.Arguments}");
-            await HandleToastActivationAsync(launchToastArguments);
-            return;
-        }
-
-        // Check if launched by startup task.
-        bool isStartupTaskLaunch = IsStartupTaskLaunch();
-
-        if (isStartupTaskLaunch && !hasAnyAccount)
-        {
-            CreateWelcomeWindow();
-        }
-        else
-        {
-            CreateWindow(args);
-        }
-
-        // Initialize theme service after window creation.
-        // Theme service requires the window to exist to properly load and apply themes.
-        await NewThemeService.InitializeAsync();
-
-        if (hasAnyAccount)
-        {
-            // Wino account loading and activation.
-            await LoadInitialWinoAccountAsync();
-        }
-
-        LogActivation("Theme service initialized.");
-
-        // If startup task launch, keep window hidden (system tray only).
-        // Otherwise, activate the window normally.
-        if (isStartupTaskLaunch)
-        {
-            LogActivation("Launched by startup task. Window created but hidden (system tray only).");
-        }
-        else
-        {
-            // Normal launch - show and activate the window.
-            // The What's New dialog is shown from MailAppShellViewModel.OnNavigatedTo once XamlRoot is ready.
-            MainWindow?.Activate();
-            LogActivation("Window created and activated.");
-        }
+        await CompleteStandardLaunchAsync(args, hasAnyAccount, isStartupTaskLaunch);
     }
 
-    public async Task HandleInitialActivationAsync()
+    private AppActivationArguments ResolveStartupActivation()
     {
         var activationArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
+        if (Program.TryConsumeDeferredAppNotificationStartup())
+        {
+            LogActivation($"Resolved deferred COM activation after notification registration. Kind: {activationArgs.Kind}");
+        }
 
+        return activationArgs;
+    }
+
+    private async Task<bool> TryHandleStartupAppNotificationActivationAsync(AppActivationArguments activationArgs)
+    {
         if (activationArgs.Kind != ExtendedActivationKind.AppNotification ||
             activationArgs.Data is not AppNotificationActivatedEventArgs toastArgs ||
             !TryMarkInitialNotificationActivationHandled())
         {
-            return;
+            return false;
         }
 
-        LogActivation($"Processing initial notification activation from application startup. Arguments: {toastArgs.Argument}");
+        LogActivation($"Processing app-notification activation from startup. Arguments: {toastArgs.Argument}");
 
-        await EnsureActivationInfrastructureAsync();
-        await HandleToastActivationAsync(toastArgs.Argument, toastArgs.UserInput);
+        if (!TryResolveNotificationActivationRoute(toastArgs, out var route))
+        {
+            await HandleToastActivationAsync(toastArgs.Argument, toastArgs.UserInput);
+
+            if (!IsAppRunning())
+            {
+                LogActivation("Startup app-notification activation completed without a window. Exiting transient process.");
+                ExitApplication();
+            }
+
+            return true;
+        }
+
+        if (route.RequiresForegroundWindow)
+        {
+            await EnsureAppHostInfrastructureAsync();
+            await route.ExecuteAsync!.Invoke();
+            return true;
+        }
+
+        await route.ExecuteAsync!.Invoke();
+
+        if (!IsAppRunning())
+        {
+            LogActivation("Background startup app-notification activation completed. Exiting without creating app host.");
+            ExitApplication();
+        }
+
+        return true;
     }
 
     private void AppNotificationInvoked(AppNotificationManager sender, AppNotificationActivatedEventArgs args)
     {
+        if (!_activationInfrastructureInitialized)
+        {
+            LogActivation($"Buffering app notification activation until infrastructure is ready. Arguments: {args.Argument}");
+            _bufferedAppNotificationActivations.Enqueue(args);
+            return;
+        }
+
         // AppNotification callbacks are not guaranteed to run on the UI thread.
         // Marshal toast handling to the window dispatcher before touching window APIs.
-        if (MainWindow?.DispatcherQueue?.TryEnqueue(() => _ = HandleToastActivationAsync(args.Argument, args.UserInput)) == true)
+        if (TryEnqueueActivationOnUiThread(() => _ = HandleToastActivationAsync(args.Argument, args.UserInput)))
             return;
 
         LogActivation($"Processing notification activation from NotificationInvoked. Arguments: {args.Argument}");
         _ = HandleToastActivationAsync(args.Argument, args.UserInput);
     }
 
-    private void TryRegisterAppNotifications()
+    private bool TryResolveNotificationActivationRoute(AppNotificationActivatedEventArgs notificationArgs,
+                                                       out NotificationActivationRoute route)
     {
+        route = default;
+
+        if (!ToastActivationResolver.TryParse(notificationArgs.Argument, out var toastArguments))
+            return false;
+
+        return TryCreateNotificationActivationRoute(toastArguments, notificationArgs.UserInput, out route);
+    }
+
+    private void EnsureAppNotificationRegistration()
+    {
+        if (!Program.ShouldRegisterAppNotifications())
+        {
+            LogActivation("Skipping app notification registration for non-host entry activation.");
+            return;
+        }
+
+        if (_appNotificationsRegistered)
+            return;
+
         var notificationManager = AppNotificationManager.Default;
 
         notificationManager.NotificationInvoked -= AppNotificationInvoked;
@@ -578,6 +627,7 @@ public partial class App : WinoApplication,
         try
         {
             notificationManager.Register();
+            _appNotificationsRegistered = true;
         }
         catch (Exception ex)
         {
@@ -590,60 +640,17 @@ public partial class App : WinoApplication,
     /// </summary>
     private async Task HandleToastActivationAsync(NotificationArguments toastArguments, IDictionary<string, string>? userInput = null)
     {
-        LogActivation("Handling app notification activation.");
-
-        if (toastArguments.TryGetValue(Constants.ToastStoreUpdateActionKey, out string storeUpdateAction) &&
-            storeUpdateAction == Constants.ToastStoreUpdateActionInstall)
+        if (!TryCreateNotificationActivationRoute(toastArguments, userInput, out var route))
         {
-            await HandleStoreUpdateToastAsync();
+            LogActivation("App notification activation did not match any known handler.");
             return;
         }
 
-        // Check calendar reminder toast activation first.
-        if (toastArguments.TryGetValue(Constants.ToastCalendarActionKey, out string calendarAction) &&
-            toastArguments.TryGetValue(Constants.ToastCalendarItemIdKey, out string calendarItemIdString) &&
-            Guid.TryParse(calendarItemIdString, out Guid calendarItemId))
-        {
-            if (calendarAction == Constants.ToastCalendarNavigateAction)
-            {
-                await HandleCalendarToastNavigationAsync(calendarItemId);
-                return;
-            }
+        LogActivation(route.RequiresForegroundWindow
+            ? "Handling foreground app notification activation."
+            : "Handling background app notification activation.");
 
-            if (calendarAction == Constants.ToastCalendarSnoozeAction)
-            {
-                await HandleCalendarToastSnoozeAsync(userInput, calendarItemId);
-                return;
-            }
-
-            if (calendarAction == Constants.ToastCalendarJoinOnlineAction)
-            {
-                await HandleCalendarToastJoinOnlineAsync(calendarItemId);
-                return;
-            }
-        }
-
-        // Check if this is a navigation toast (user clicked the notification).
-        if (toastArguments.TryGetValue(Constants.ToastActionKey, out MailOperation action) &&
-            Guid.TryParse(toastArguments[Constants.ToastMailUniqueIdKey], out Guid mailItemUniqueId))
-        {
-            if (action == MailOperation.Navigate)
-            {
-                // User clicked notification - create window if needed and navigate.
-                await HandleToastNavigationAsync(mailItemUniqueId);
-            }
-            else
-            {
-                // User clicked action button (Mark as Read, Delete, etc.)
-                // Execute action without window and exit.
-
-                await HandleToastActionAsync(action, mailItemUniqueId);
-            }
-
-            return;
-        }
-
-        LogActivation("App notification activation did not match any known handler.");
+        await route.ExecuteAsync!.Invoke();
     }
 
     private Task HandleToastActivationAsync(string toastArgument, IDictionary<string, string>? userInput = null)
@@ -694,6 +701,37 @@ public partial class App : WinoApplication,
         return true;
     }
 
+    private async Task<bool> TryHandleLaunchActivationAsync(Microsoft.UI.Xaml.LaunchActivatedEventArgs args,
+                                                            AppActivationArguments activationArgs)
+    {
+        if (activationArgs.Kind == ExtendedActivationKind.ShareTarget &&
+            TryMarkInitialShareActivationHandled())
+        {
+            LogActivation("Processing share target activation from OnLaunched.");
+
+            if (await HandleShareTargetActivationAsync(activationArgs, activateWindow: true))
+                return true;
+        }
+
+        if (Program.TryConsumePendingBootstrapActivation(out var pendingBootstrapActivation))
+        {
+            LogActivation($"Processing pending bootstrap activation. Kind: {pendingBootstrapActivation.Kind}, Mode: {pendingBootstrapActivation.Mode}");
+
+            if (await HandlePendingBootstrapActivationAsync(pendingBootstrapActivation))
+                return true;
+        }
+
+        if (ToastActivationResolver.TryParse(args.Arguments, out var launchToastArguments) &&
+            TryMarkInitialNotificationActivationHandled())
+        {
+            LogActivation($"Processing toast launch activation from OnLaunched. Arguments: {args.Arguments}");
+            await HandleToastActivationAsync(launchToastArguments);
+            return true;
+        }
+
+        return false;
+    }
+
     private async Task<MailShareRequest?> ExtractMailShareRequestAsync(ShareTargetActivatedEventArgs shareTargetArgs)
     {
         var shareOperation = shareTargetArgs.ShareOperation;
@@ -740,22 +778,36 @@ public partial class App : WinoApplication,
         }
     }
 
-    private async Task<IWinoShellWindow?> EnsureShellWindowAsync(WinoApplicationMode mode, bool activateWindow, bool suppressStartupFlows = true)
+    private async Task LaunchWelcomeWindowAsync()
+    {
+        CreateWelcomeWindow();
+        await NewThemeService.InitializeAsync();
+        MainWindow?.Activate();
+        LogActivation("Welcome window created and activated.");
+    }
+
+    private async Task<ShellWindowActivationResult> EnsureShellWindowAsync(WinoApplicationMode mode,
+                                                                           bool activateWindow,
+                                                                           bool suppressStartupFlows = true,
+                                                                           object? activationParameter = null)
     {
         var windowManager = Services.GetRequiredService<IWinoWindowManager>();
         var navigationService = Services.GetRequiredService<INavigationService>();
         var shellWindow = windowManager.GetWindow(WinoWindowKind.Shell) as IWinoShellWindow;
+        var wasCreated = false;
 
         if (shellWindow == null)
         {
             LogActivation($"Creating shell window for {mode} activation.");
+            wasCreated = true;
 
             CreateWindow(
                 null,
                 AppEntryConstants.GetModeLaunchArgument(mode),
                 new ShellModeActivationContext
                 {
-                    SuppressStartupFlows = suppressStartupFlows
+                    SuppressStartupFlows = suppressStartupFlows,
+                    Parameter = activationParameter
                 });
 
             await NewThemeService.InitializeAsync();
@@ -769,18 +821,22 @@ public partial class App : WinoApplication,
         }
         else
         {
+            ApplyShellWindowTaskbarIdentity(shellWindow, mode);
             navigationService.ChangeApplicationMode(mode, new ShellModeActivationContext
             {
-                SuppressStartupFlows = suppressStartupFlows
+                SuppressStartupFlows = suppressStartupFlows,
+                Parameter = activationParameter
             });
         }
 
+        ApplyShellWindowTaskbarIdentity(shellWindow, mode);
+
         if (activateWindow && shellWindow is WindowEx window)
         {
-            await ActivateWindowAsync(window);
+            await ActivateWindowAsync(window, applyThemeToWindow: wasCreated);
         }
 
-        return shellWindow;
+        return new ShellWindowActivationResult(shellWindow, wasCreated);
     }
 
     private async Task HandleStoreUpdateToastAsync()
@@ -797,18 +853,42 @@ public partial class App : WinoApplication,
     private async Task HandleCalendarToastNavigationAsync(Guid calendarItemId)
     {
         var calendarService = Services.GetRequiredService<ICalendarService>();
-        var navigationService = Services.GetRequiredService<INavigationService>();
+        var fallbackNavigationArgs = new CalendarPageNavigationArgs
+        {
+            RequestDefaultNavigation = true
+        };
+
+        if (!HasShellWindow())
+        {
+            await EnsureShellWindowAsync(
+                WinoApplicationMode.Calendar,
+                activateWindow: true,
+                activationParameter: fallbackNavigationArgs);
+        }
 
         var calendarItem = await calendarService.GetCalendarItemAsync(calendarItemId);
         if (calendarItem == null)
+        {
+            LogActivation($"Calendar notification navigation item was not found for {calendarItemId}. Opening calendar shell only.");
+
+            await EnsureShellWindowAsync(
+                WinoApplicationMode.Calendar,
+                activateWindow: true,
+                activationParameter: fallbackNavigationArgs);
             return;
+        }
 
         var target = new CalendarItemTarget(calendarItem, CalendarEventTargetType.Single);
+        var navigationArgs = new CalendarPageNavigationArgs
+        {
+            NavigationDate = calendarItem.LocalStartDate,
+            PendingTarget = target
+        };
 
-        await EnsureShellWindowAsync(WinoApplicationMode.Calendar, activateWindow: true);
-
-        navigationService.ChangeApplicationMode(Core.Domain.Enums.WinoApplicationMode.Calendar);
-        navigationService.Navigate(WinoPage.EventDetailsPage, target);
+        await EnsureShellWindowAsync(
+            WinoApplicationMode.Calendar,
+            activateWindow: true,
+            activationParameter: navigationArgs);
     }
 
     private async Task HandleCalendarToastSnoozeAsync(IDictionary<string, string>? userInput, Guid calendarItemId)
@@ -837,6 +917,38 @@ public partial class App : WinoApplication,
         await nativeAppService.LaunchUriAsync(joinUri);
     }
 
+    private async Task CompleteStandardLaunchAsync(Microsoft.UI.Xaml.LaunchActivatedEventArgs args,
+                                                   bool hasAnyAccount,
+                                                   bool isStartupTaskLaunch)
+    {
+        if (isStartupTaskLaunch && !hasAnyAccount)
+        {
+            CreateWelcomeWindow();
+        }
+        else
+        {
+            CreateWindow(args);
+        }
+
+        await NewThemeService.InitializeAsync();
+
+        if (hasAnyAccount)
+        {
+            await LoadInitialWinoAccountAsync();
+        }
+
+        LogActivation("Theme service initialized.");
+
+        if (isStartupTaskLaunch)
+        {
+            LogActivation("Launched by startup task. Window created but hidden (system tray only).");
+            return;
+        }
+
+        MainWindow?.Activate();
+        LogActivation("Window created and activated.");
+    }
+
     private bool TryGetSnoozeDurationMinutes(IDictionary<string, string>? userInput, out int snoozeDurationMinutes)
     {
         snoozeDurationMinutes = _preferencesService?.DefaultSnoozeDurationInMinutes ?? 0;
@@ -860,7 +972,6 @@ public partial class App : WinoApplication,
     private async Task HandleToastNavigationAsync(Guid mailItemUniqueId)
     {
         var mailService = Services.GetRequiredService<IMailService>();
-        var navigationService = Services.GetRequiredService<INavigationService>();
 
         var account = await mailService.GetMailAccountByUniqueIdAsync(mailItemUniqueId);
         if (account == null)
@@ -885,7 +996,6 @@ public partial class App : WinoApplication,
         var shellWindowAlreadyExists = HasShellWindow();
 
         await EnsureShellWindowAsync(WinoApplicationMode.Mail, activateWindow: true);
-        navigationService.ChangeApplicationMode(Core.Domain.Enums.WinoApplicationMode.Mail);
 
         if (shellWindowAlreadyExists)
         {
@@ -985,6 +1095,86 @@ public partial class App : WinoApplication,
         }
     }
 
+    private async Task HandleToastComposeActionAsync(MailOperation action, Guid mailItemUniqueId)
+    {
+        LogActivation($"Handling compose toast action: {action} for mail {mailItemUniqueId}");
+
+        var mailService = Services.GetRequiredService<IMailService>();
+        var folderService = Services.GetRequiredService<IFolderService>();
+        var mimeFileService = Services.GetRequiredService<IMimeFileService>();
+        var navigationService = Services.GetRequiredService<INavigationService>();
+        var requestDelegator = Services.GetRequiredService<IWinoRequestDelegator>();
+        var mailShellViewModel = Services.GetRequiredService<MailAppShellViewModel>();
+
+        var mailItem = await mailService.GetSingleMailItemAsync(mailItemUniqueId);
+        if (mailItem == null)
+        {
+            LogActivation($"Compose toast mail item was not found for {mailItemUniqueId}.");
+            return;
+        }
+
+        var account = await mailService.GetMailAccountByUniqueIdAsync(mailItemUniqueId) ?? mailItem.AssignedAccount;
+        if (account == null)
+        {
+            LogActivation($"Compose toast account was not found for {mailItemUniqueId}.");
+            return;
+        }
+
+        var draftFolder = await folderService.GetSpecialFolderByAccountIdAsync(account.Id, SpecialFolderType.Draft);
+        if (draftFolder == null)
+        {
+            LogActivation($"Compose toast draft folder is missing for account {account.Id}.");
+            return;
+        }
+
+        var mimeInformation = await mimeFileService.GetMimeMessageInformationAsync(mailItem.FileId, account.Id);
+        if (mimeInformation?.MimeMessage == null)
+        {
+            LogActivation($"Compose toast MIME payload was not found for mail {mailItemUniqueId}.");
+            return;
+        }
+
+        await EnsureShellWindowAsync(WinoApplicationMode.Mail, activateWindow: true);
+
+        if (mailShellViewModel.MenuItems.TryGetAccountMenuItem(account.Id, out IAccountMenuItem accountMenuItem))
+        {
+            await mailShellViewModel.ChangeLoadedAccountAsync(accountMenuItem, navigateInbox: false);
+        }
+
+        if (mailShellViewModel.MenuItems.TryGetSpecialFolderMenuItem(account.Id, SpecialFolderType.Draft, out var draftFolderMenuItem))
+        {
+            await mailShellViewModel.NavigateFolderAsync(draftFolderMenuItem);
+        }
+
+        var draftOptions = new DraftCreationOptions
+        {
+            Reason = action switch
+            {
+                MailOperation.Reply => DraftCreationReason.Reply,
+                MailOperation.ReplyAll => DraftCreationReason.ReplyAll,
+                MailOperation.Forward => DraftCreationReason.Forward,
+                _ => DraftCreationReason.Empty
+            },
+            ReferencedMessage = new ReferencedMessage
+            {
+                MimeMessage = mimeInformation.MimeMessage,
+                MailCopy = mailItem
+            }
+        };
+
+        var (draftMailCopy, draftBase64MimeMessage) = await mailService.CreateDraftAsync(account.Id, draftOptions);
+        var draftPreparationRequest = new DraftPreparationRequest(account, draftMailCopy, draftBase64MimeMessage, draftOptions.Reason, mailItem);
+
+        await requestDelegator.ExecuteAsync(draftPreparationRequest);
+        navigationService.Navigate(WinoPage.ComposePage,
+                                   new MailItemViewModel(draftMailCopy),
+                                   NavigationReferenceFrame.RenderingFrame,
+                                   NavigationTransitionType.DrillIn);
+    }
+
+    private static bool IsComposeToastAction(MailOperation action)
+        => action is MailOperation.Reply or MailOperation.ReplyAll or MailOperation.Forward;
+
     /// <summary>
     /// Creates the main window and activates it.
     /// </summary>
@@ -1039,6 +1229,7 @@ public partial class App : WinoApplication,
                     ? resolvedActivationMode
                     : AppModeActivationResolver.Resolve(args?.Arguments, GetCurrentLaunchTileId(), Environment.CommandLine, defaultMode);
 
+            ApplyShellWindowTaskbarIdentity(shellWindow, targetMode);
             navigationService.ChangeApplicationMode(targetMode, activationContextOverride);
             return;
         }
@@ -1072,6 +1263,18 @@ public partial class App : WinoApplication,
         shellWindow.HandleAppActivation(args?.Arguments, GetCurrentLaunchTileId(), Environment.CommandLine);
     }
 
+    private static void ApplyShellWindowTaskbarIdentity(IWinoShellWindow? shellWindow, WinoApplicationMode mode)
+    {
+        if (shellWindow is not WindowEx window)
+            return;
+
+        var packagedApplicationId = AppEntryConstants.GetPackagedApplicationId(mode);
+        if (packagedApplicationId == null)
+            return;
+
+        WindowAppUserModelIdHelper.TrySet(window, AppEntryConstants.GetAppUserModelId(mode));
+    }
+
     private void CreateWelcomeWindow()
     {
         LogActivation("Creating welcome window.");
@@ -1550,7 +1753,7 @@ public partial class App : WinoApplication,
                 // Handle toast notification activation
                 var toastArgs = (AppNotificationActivatedEventArgs)args.Data;
                 LogActivation($"Processing redirected notification activation. Arguments: {toastArgs.Argument}");
-                _ = HandleToastActivationAsync(toastArgs.Argument, toastArgs.UserInput);
+                await HandleToastActivationAsync(toastArgs.Argument, toastArgs.UserInput);
             }
             else if (args.Kind == ExtendedActivationKind.ShareTarget)
             {
@@ -1570,7 +1773,7 @@ public partial class App : WinoApplication,
                         {
                             shouldActivateWindow = ToastActivationResolver.ShouldBringToForeground(launchToastArguments);
                             LogActivation($"Processing redirected toast launch activation. Arguments: {launchArgs.Arguments}");
-                            _ = HandleToastActivationAsync(launchToastArguments);
+                            await HandleToastActivationAsync(launchToastArguments);
                         }
                         else
                         {
@@ -1600,12 +1803,89 @@ public partial class App : WinoApplication,
         }
 
         // Dispatch to UI thread since this is called from Program.OnActivated.
-        if (MainWindow?.DispatcherQueue.TryEnqueue(() => _ = HandleRedirectedActivationAsync()) == true)
+        if (TryEnqueueActivationOnUiThread(() => _ = HandleRedirectedActivationAsync()))
             return;
 
         _ = HandleRedirectedActivationAsync();
     }
 
+    private bool TryCreateNotificationActivationRoute(NotificationArguments toastArguments,
+                                                      IDictionary<string, string>? userInput,
+                                                      out NotificationActivationRoute route)
+    {
+        if (toastArguments.TryGetValue(Constants.ToastStoreUpdateActionKey, out string storeUpdateAction) &&
+            storeUpdateAction == Constants.ToastStoreUpdateActionInstall)
+        {
+            route = new NotificationActivationRoute(true, HandleStoreUpdateToastAsync);
+            return true;
+        }
+
+        if (toastArguments.TryGetValue(Constants.ToastDismissActionKey, out string _))
+        {
+            route = new NotificationActivationRoute(false, () =>
+            {
+                LogActivation("Handling notification dismiss action.");
+                return Task.CompletedTask;
+            });
+            return true;
+        }
+
+        if (toastArguments.TryGetValue(Constants.ToastCalendarActionKey, out string calendarAction) &&
+            toastArguments.TryGetValue(Constants.ToastCalendarItemIdKey, out string calendarItemIdString) &&
+            Guid.TryParse(calendarItemIdString, out Guid calendarItemId))
+        {
+            route = calendarAction switch
+            {
+                Constants.ToastCalendarNavigateAction => new NotificationActivationRoute(true, () => HandleCalendarToastNavigationAsync(calendarItemId)),
+                Constants.ToastCalendarSnoozeAction => new NotificationActivationRoute(false, () => HandleCalendarToastSnoozeAsync(userInput, calendarItemId)),
+                Constants.ToastCalendarJoinOnlineAction => new NotificationActivationRoute(false, () => HandleCalendarToastJoinOnlineAsync(calendarItemId)),
+                _ => default
+            };
+
+            return route.ExecuteAsync != null;
+        }
+
+        if (toastArguments.TryGetValue(Constants.ToastActionKey, out MailOperation action) &&
+            Guid.TryParse(toastArguments[Constants.ToastMailUniqueIdKey], out Guid mailItemUniqueId))
+        {
+            if (action == MailOperation.Navigate)
+            {
+                route = new NotificationActivationRoute(true, () => HandleToastNavigationAsync(mailItemUniqueId));
+                return true;
+            }
+
+            if (IsComposeToastAction(action))
+            {
+                route = new NotificationActivationRoute(true, () => HandleToastComposeActionAsync(action, mailItemUniqueId));
+                return true;
+            }
+
+            route = new NotificationActivationRoute(false, () => HandleToastActionAsync(action, mailItemUniqueId));
+            return true;
+        }
+
+        route = default;
+        return false;
+    }
+
+    private async Task<bool> HandlePendingBootstrapActivationAsync(PendingBootstrapActivation pendingBootstrapActivation)
+    {
+        if (pendingBootstrapActivation.Mode != WinoApplicationMode.Calendar)
+            return false;
+
+        var navigationArgs = new CalendarPageNavigationArgs
+        {
+            RequestDefaultNavigation = true
+        };
+
+        await EnsureShellWindowAsync(
+            WinoApplicationMode.Calendar,
+            activateWindow: true,
+            activationParameter: navigationArgs);
+
+        return true;
+    }
+
     private static string AppendLaunchArgument(string? launchArguments, string launchArgument)
     {
         return string.IsNullOrWhiteSpace(launchArguments)
@@ -1686,6 +1966,32 @@ public partial class App : WinoApplication,
         return null;
     }
 
+    private bool TryEnqueueActivationOnUiThread(Action action)
+    {
+        var dispatcherQueue = MainWindow?.DispatcherQueue;
+
+        if (dispatcherQueue == null)
+        {
+            var windowManager = Services.GetService<IWinoWindowManager>();
+            var currentWindow = windowManager?.ActiveWindow
+                               ?? windowManager?.GetWindow(WinoWindowKind.Shell)
+                               ?? windowManager?.GetWindow(WinoWindowKind.Welcome);
+
+            dispatcherQueue = currentWindow?.DispatcherQueue;
+        }
+
+        if (dispatcherQueue == null)
+            return false;
+
+        if (dispatcherQueue.HasThreadAccess)
+        {
+            action();
+            return true;
+        }
+
+        return dispatcherQueue.TryEnqueue(() => action());
+    }
+
 }
 
 

Wino.Mail.WinUI/Controls/Calendar/CalendarItemControl.xaml

@@ -20,8 +20,7 @@
         CornerRadius="4"
         DoubleTapped="ControlDoubleTapped"
         RightTapped="ControlRightTapped"
-        Tapped="ControlTapped"
-        ToolTipService.ToolTip="{x:Bind CalendarItem.DisplayTitle, Mode=OneWay}">
+        Tapped="ControlTapped">
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="5" />
             <ColumnDefinition Width="*" />
@@ -36,6 +35,9 @@
                 Placement="BottomEdgeAlignedLeft"
                 ShowMode="Auto" />
         </Grid.ContextFlyout>
+        <ToolTipService.ToolTip>
+            <ToolTip Content="{x:Bind CalendarItem.DisplayTitle, Mode=OneWay}" />
+        </ToolTipService.ToolTip>
 
 
         <Grid

Wino.Mail.WinUI/Controls/Calendar/CalendarPeriodControl.xaml.cs

@@ -443,10 +443,13 @@ public sealed partial class CalendarPeriodControl : UserControl, INotifyProperty
             return;
         }
 
-        calendarItemViewModel.DisplayingPeriod = new TimeRange(
+        DispatcherQueue.TryEnqueue(() =>
+        {
+            calendarItemViewModel.DisplayingPeriod = new TimeRange(
             date.ToDateTime(TimeOnly.MinValue),
             date.AddDays(1).ToDateTime(TimeOnly.MinValue));
-        calendarItemViewModel.CalendarSettings = CalendarSettings;
+            calendarItemViewModel.CalendarSettings = CalendarSettings;
+        });
     }
 
     private static VisibleDateRange CreateLayoutRange(VisibleDateRange visibleRange, CalendarSettings calendarSettings)

Wino.Mail.WinUI/Package.appxmanifest

@@ -23,7 +23,7 @@
   <Identity
     Name="58272BurakKSE.WinoMailPreview"
     Publisher="CN=51FBDAF3-E212-4149-89A2-A2636B3BC911"
-    Version="2.0.2.0" />
+    Version="2.0.3.0" />
 
   <mp:PhoneIdentity PhoneProductId="3879fcfb-a561-4599-9103-e0c9b35a271f" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
 
@@ -133,18 +133,6 @@
       </uap:VisualElements>
 
       <Extensions>
-        <desktop:Extension Category="windows.toastNotificationActivation">
-          <desktop:ToastNotificationActivation ToastActivatorCLSID="44c05d2b-aa1d-4e59-9d7d-8b4c8607cb8d" />
-        </desktop:Extension>
-
-        <com:Extension Category="windows.comServer">
-          <com:ComServer>
-            <com:ExeServer Executable="Wino.Mail.WinUI.exe" Arguments="----AppNotificationActivated:" DisplayName="Calendar toast activator">
-              <com:Class Id="44c05d2b-aa1d-4e59-9d7d-8b4c8607cb8d" DisplayName="Calendar toast activator"/>
-            </com:ExeServer>
-          </com:ComServer>
-        </com:Extension>
-
         <uap:Extension Category="windows.protocol">
           <uap:Protocol Name="webcal">
             <uap:DisplayName>Calendar Protocol</uap:DisplayName>

Wino.Mail.WinUI/Program.cs

@@ -13,38 +13,87 @@ namespace Wino.Mail.WinUI;
 
 public class Program
 {
+    private const string AppNotificationActivatedCommandLinePrefix = "----AppNotificationActivated:";
     private const string SingleInstanceKey = "WinoMailSingleInstance";
     private const string ForceAlternateModeSignalEventName = "Local\\WinoMailForceAlternateMode";
+    private const string MailHostRunningMutexName = "Local\\WinoMailMailHostRunning";
     private const int VkControl = 0x11;
 
     private static bool _forceAlternateModeOnLaunch;
     private static EventWaitHandle? _forceAlternateModeSignalHandle;
+    private static Mutex? _mailHostRunningMutex;
+    private static PendingBootstrapActivation? _pendingBootstrapActivation;
+    private static bool _hasDeferredAppNotificationStartup;
+    private static bool _shouldRegisterAppNotifications;
 
     [STAThread]
     static int Main(string[] args)
     {
         WinRT.ComWrappersSupport.InitializeComWrappers();
-        bool isRedirect = DecideRedirection();
+
+        if (TryCaptureCommandLineToastActivation(args))
+        {
+            _shouldRegisterAppNotifications = true;
+            EnsureMailHostRunningMutex();
+            StartApplication();
+            return 0;
+        }
+
+        var activationArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
+        var shouldBootstrapCalendarEntry = CalendarEntryBootstrapActivation.ShouldBootstrapToMailHost(activationArgs);
+        _shouldRegisterAppNotifications = !shouldBootstrapCalendarEntry;
+
+        if (shouldBootstrapCalendarEntry && !IsMailHostRunning())
+        {
+            if (CalendarEntryBootstrapActivation.QueuePendingActivation(activationArgs) &&
+                CalendarEntryBootstrapActivation.LaunchMailHost())
+            {
+                return 0;
+            }
+
+            CalendarEntryBootstrapActivation.ClearPendingActivation();
+        }
+
+        _pendingBootstrapActivation = CalendarEntryBootstrapActivation.ConsumePendingActivation();
+        bool isRedirect = DecideRedirection(activationArgs);
 
         if (!isRedirect)
         {
-            Application.Start((p) =>
-            {
-                var context = new DispatcherQueueSynchronizationContext(
-                    DispatcherQueue.GetForCurrentThread());
-                SynchronizationContext.SetSynchronizationContext(context);
-                var app = new App();
-                _ = app.HandleInitialActivationAsync();
-            });
+            EnsureMailHostRunningMutex();
+            StartApplication();
         }
 
         return 0;
     }
 
-    private static bool DecideRedirection()
+    public static bool ShouldRegisterAppNotifications()
+        => _shouldRegisterAppNotifications;
+
+    internal static bool TryConsumeDeferredAppNotificationStartup()
+    {
+        if (!_hasDeferredAppNotificationStartup)
+            return false;
+
+        _hasDeferredAppNotificationStartup = false;
+        return true;
+    }
+
+    internal static bool TryConsumePendingBootstrapActivation(out PendingBootstrapActivation activation)
+    {
+        if (_pendingBootstrapActivation == null)
+        {
+            activation = null!;
+            return false;
+        }
+
+        activation = _pendingBootstrapActivation;
+        _pendingBootstrapActivation = null;
+        return true;
+    }
+
+    private static bool DecideRedirection(AppActivationArguments args)
     {
         bool isRedirect = false;
-        AppActivationArguments args = AppInstance.GetCurrent().GetActivatedEventArgs();
         _forceAlternateModeOnLaunch = args.Kind == ExtendedActivationKind.Launch && IsCtrlKeyDown();
 
         AppInstance keyInstance = AppInstance.FindOrRegisterForKey(SingleInstanceKey);
@@ -69,6 +118,60 @@ public class Program
         return isRedirect;
     }
 
+    private static bool TryCaptureCommandLineToastActivation(string[] args)
+    {
+        var commandLine = Environment.CommandLine;
+        var prefixIndex = commandLine.IndexOf(AppNotificationActivatedCommandLinePrefix, StringComparison.OrdinalIgnoreCase);
+
+        if (prefixIndex < 0)
+            return false;
+
+        // Do not touch AppInstance.GetActivatedEventArgs here. For app-notification cold starts,
+        // Windows App SDK expects the app to register AppNotificationManager first and then
+        // resolve the activation inside App.OnLaunched.
+        _hasDeferredAppNotificationStartup = true;
+        return true;
+    }
+
+    private static void StartApplication()
+    {
+        Application.Start((p) =>
+        {
+            var context = new DispatcherQueueSynchronizationContext(
+                DispatcherQueue.GetForCurrentThread());
+            SynchronizationContext.SetSynchronizationContext(context);
+            _ = new App();
+        });
+    }
+
+    private static bool IsMailHostRunning()
+    {
+        try
+        {
+            if (!Mutex.TryOpenExisting(MailHostRunningMutexName, out var existingMutex))
+                return false;
+
+            existingMutex.Dispose();
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static void EnsureMailHostRunningMutex()
+    {
+        try
+        {
+            _mailHostRunningMutex ??= new Mutex(false, MailHostRunningMutexName);
+        }
+        catch
+        {
+            _mailHostRunningMutex = null;
+        }
+    }
+
     [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
     private static extern IntPtr CreateEvent(
         IntPtr lpEventAttributes, bool bManualReset,

Wino.Mail.WinUI/Services/NavigationService.cs

@@ -79,6 +79,7 @@ public class NavigationService : NavigationServiceBase, INavigationService
         WinoPage.AboutPage,
         WinoPage.PersonalizationPage,
         WinoPage.MessageListPage,
+        WinoPage.MailNotificationSettingsPage,
         WinoPage.ReadComposePanePage,
         WinoPage.AppPreferencesPage,
         WinoPage.AliasManagementPage,
@@ -142,6 +143,7 @@ public class NavigationService : NavigationServiceBase, INavigationService
             WinoPage.AboutPage => typeof(AboutPage),
             WinoPage.PersonalizationPage => typeof(PersonalizationPage),
             WinoPage.MessageListPage => typeof(MessageListPage),
+            WinoPage.MailNotificationSettingsPage => typeof(MailNotificationSettingsPage),
             WinoPage.ReadComposePanePage => typeof(ReadComposePanePage),
             WinoPage.MailRenderingPage => typeof(MailRenderingPage),
             WinoPage.ComposePage => typeof(ComposePage),
@@ -241,7 +243,19 @@ public class NavigationService : NavigationServiceBase, INavigationService
         _statePersistanceService.AppModeTitle = GetApplicationModeTitle(mode);
 
         if (coreFrame.Content is IShellHost activeShell && activeShell.HasShellContent && currentMode == mode)
+        {
+            if (activationContext?.Parameter != null)
+            {
+                activeShell.ActivateMode(mode, new ShellModeActivationContext
+                {
+                    IsInitialActivation = false,
+                    SuppressStartupFlows = activationContext.SuppressStartupFlows,
+                    Parameter = activationContext.Parameter
+                });
+            }
+
             return true;
+        }
 
         _pendingInnerShellTransition = isInitialShellNavigation
             ? null
@@ -502,7 +516,7 @@ public class NavigationService : NavigationServiceBase, INavigationService
             : DateOnly.FromDateTime(args.NavigationDate.Date);
 
         var displayRequest = new CalendarDisplayRequest(_statePersistanceService.CalendarDisplayType, targetDate);
-        return new LoadCalendarMessage(displayRequest, args.ForceReload);
+        return new LoadCalendarMessage(displayRequest, args.ForceReload, args.PendingTarget);
     }
 
     private bool NavigateInnerShellFrame(Frame frame, Type pageType, object? parameter, NavigationTransitionType transition)

Wino.Mail.WinUI/Services/NotificationBuilder.cs

@@ -17,6 +17,7 @@ using Wino.Core.Domain.Entities.Shared;
 using Wino.Core.Domain.Enums;
 using Wino.Core.Domain.Extensions;
 using Wino.Core.Domain.Interfaces;
+using Wino.Helpers;
 using Wino.Mail.WinUI.Activation;
 using Wino.Messaging.UI;
 
@@ -26,6 +27,16 @@ public class NotificationBuilder : INotificationBuilder
 {
     private const string NotificationIconRootUri = "ms-appx:///Assets/NotificationIcons/";
     private static int _calendarTaskbarBadgeCount;
+    private static readonly MailOperation[] SupportedMailNotificationActions =
+    [
+        MailOperation.MarkAsRead,
+        MailOperation.SoftDelete,
+        MailOperation.MoveToJunk,
+        MailOperation.Archive,
+        MailOperation.Reply,
+        MailOperation.ReplyAll,
+        MailOperation.Forward
+    ];
 
     private readonly IAccountService _accountService;
     private readonly IFolderService _folderService;
@@ -76,6 +87,7 @@ public class NotificationBuilder : INotificationBuilder
                 builder.AddText(Translator.Notifications_MultipleNotificationsTitle);
                 builder.AddText(string.Format(Translator.Notifications_MultipleNotificationsMessage, mailCount));
                 builder.AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
+                builder.AddButton(CreateDismissButton());
                 builder.SetAudioUri(new Uri("ms-winsoundevent:Notification.Mail"));
 
                 ShowNotification(builder);
@@ -167,6 +179,7 @@ public class NotificationBuilder : INotificationBuilder
         builder.AddButton(new AppNotificationButton(Translator.Buttons_FixAccount)
             .AddArgument(Constants.ToastMailAccountIdKey, account.Id.ToString())
             .AddArgument(Constants.ToastModeKey, Constants.ToastModeMail));
+        builder.AddButton(CreateDismissButton());
 
         ShowNotification(builder);
     }
@@ -177,6 +190,7 @@ public class NotificationBuilder : INotificationBuilder
         builder.AddText(Translator.Exception_WebView2RuntimeMissing_Title);
         builder.AddText(Translator.Exception_WebView2RuntimeMissing_Message);
         builder.AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
+        builder.AddButton(CreateDismissButton());
 
         ShowNotification(builder);
     }
@@ -188,6 +202,7 @@ public class NotificationBuilder : INotificationBuilder
         builder.AddText(Translator.Notifications_StoreUpdateAvailableMessage);
         builder.AddArgument(Constants.ToastStoreUpdateActionKey, Constants.ToastStoreUpdateActionInstall);
         builder.AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
+        builder.AddButton(CreateDismissButton());
 
         ShowNotification(builder, "store-update-available");
     }
@@ -255,6 +270,8 @@ public class NotificationBuilder : INotificationBuilder
                 .AddArgument(Constants.ToastModeKey, Constants.ToastModeCalendar));
         }
 
+        builder.AddButton(CreateDismissButton());
+
         var tag = $"calendar-reminder-{calendarItem.Id:N}-{reminderDurationInSeconds}";
         ShowNotification(builder, tag);
 
@@ -288,9 +305,11 @@ public class NotificationBuilder : INotificationBuilder
         builder.AddArgument(Constants.ToastMailUniqueIdKey, mailItem.UniqueId.ToString());
         builder.AddArgument(Constants.ToastActionKey, MailOperation.Navigate.ToString());
         builder.AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
-        builder.AddButton(GetMarkAsReadButton(mailItem.UniqueId));
-        builder.AddButton(GetDeleteButton(mailItem.UniqueId));
-        builder.AddButton(GetArchiveButton(mailItem.UniqueId));
+
+        var (firstAction, secondAction) = GetConfiguredMailNotificationActions();
+        builder.AddButton(CreateMailNotificationActionButton(firstAction, mailItem.UniqueId));
+        builder.AddButton(CreateMailNotificationActionButton(secondAction, mailItem.UniqueId));
+        builder.AddButton(CreateDismissButton());
         builder.SetAudioUri(new Uri("ms-winsoundevent:Notification.Mail"));
 
         ShowNotification(builder, mailItem.UniqueId.ToString());
@@ -347,26 +366,55 @@ public class NotificationBuilder : INotificationBuilder
         return string.Format(Translator.CalendarReminder_StartedMinutesAgo, minutesAgo);
     }
 
-    private AppNotificationButton GetArchiveButton(Guid mailUniqueId)
-        => new AppNotificationButton(Translator.MailOperation_Archive)
-            .SetIcon(GetNotificationIconUri("mail-archive"))
+    private (MailOperation FirstAction, MailOperation SecondAction) GetConfiguredMailNotificationActions()
+    {
+        var firstAction = ResolveMailNotificationAction(_preferencesService.FirstMailNotificationAction, MailOperation.MarkAsRead);
+        var secondAction = ResolveMailNotificationAction(_preferencesService.SecondMailNotificationAction, MailOperation.SoftDelete);
+
+        if (secondAction == firstAction)
+        {
+            secondAction = SupportedMailNotificationActions.First(action => action != firstAction);
+        }
+
+        return (firstAction, secondAction);
+    }
+
+    private static MailOperation ResolveMailNotificationAction(MailOperation configuredAction, MailOperation fallbackAction)
+        => SupportedMailNotificationActions.Contains(configuredAction) ? configuredAction : fallbackAction;
+
+    private AppNotificationButton CreateMailNotificationActionButton(MailOperation action, Guid mailUniqueId)
+    {
+        var button = new AppNotificationButton(XamlHelpers.GetOperationString(action))
             .AddArgument(Constants.ToastMailUniqueIdKey, mailUniqueId.ToString())
-            .AddArgument(Constants.ToastActionKey, MailOperation.Archive.ToString())
+            .AddArgument(Constants.ToastActionKey, action.ToString())
             .AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
 
-    private AppNotificationButton GetDeleteButton(Guid mailUniqueId)
-        => new AppNotificationButton(Translator.MailOperation_Delete)
-            .SetIcon(GetNotificationIconUri("mail-delete"))
-            .AddArgument(Constants.ToastMailUniqueIdKey, mailUniqueId.ToString())
-            .AddArgument(Constants.ToastActionKey, MailOperation.SoftDelete.ToString())
-            .AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
+        var iconUri = GetMailActionIconUri(action);
+        if (iconUri != null)
+        {
+            button.SetIcon(iconUri);
+        }
 
-    private AppNotificationButton GetMarkAsReadButton(Guid mailUniqueId)
-        => new AppNotificationButton(Translator.MailOperation_MarkAsRead)
-            .SetIcon(GetNotificationIconUri("mail-markread"))
-            .AddArgument(Constants.ToastMailUniqueIdKey, mailUniqueId.ToString())
-            .AddArgument(Constants.ToastActionKey, MailOperation.MarkAsRead.ToString())
-            .AddArgument(Constants.ToastModeKey, Constants.ToastModeMail);
+        return button;
+    }
+
+    private static Uri? GetMailActionIconUri(MailOperation action)
+        => action switch
+        {
+            MailOperation.Archive => GetNotificationIconUri("mail-archive"),
+            MailOperation.SoftDelete => GetNotificationIconUri("mail-delete"),
+            MailOperation.MarkAsRead => GetNotificationIconUri("mail-markread"),
+            MailOperation.MoveToJunk => GetNotificationIconUri("mail-junk"),
+            MailOperation.Reply => GetNotificationIconUri("mail-reply"),
+            MailOperation.ReplyAll => GetNotificationIconUri("mail-replyall"),
+            MailOperation.Forward => GetNotificationIconUri("mail-forward"),
+            _ => null
+        };
+
+    private static AppNotificationButton CreateDismissButton()
+        => new AppNotificationButton(Translator.Buttons_Dismiss)
+            .SetIcon(GetNotificationIconUri("dismiss"))
+            .AddArgument(Constants.ToastDismissActionKey, bool.TrueString);
 
     private static AppNotificationBuilder CreateBuilder(AppNotificationScenario scenario = AppNotificationScenario.Default)
         => new AppNotificationBuilder().SetScenario(scenario);

Wino.Mail.WinUI/Services/PreferencesService.cs

@@ -237,6 +237,18 @@ public class PreferencesService(IConfigurationService configurationService) : Ob
         set => SaveProperty(propertyName: nameof(StartupEntityId), value);
     }
 
+    public MailOperation FirstMailNotificationAction
+    {
+        get => _configurationService.Get(nameof(FirstMailNotificationAction), MailOperation.MarkAsRead);
+        set => SetPropertyAndSave(nameof(FirstMailNotificationAction), value);
+    }
+
+    public MailOperation SecondMailNotificationAction
+    {
+        get => _configurationService.Get(nameof(SecondMailNotificationAction), MailOperation.SoftDelete);
+        set => SetPropertyAndSave(nameof(SecondMailNotificationAction), value);
+    }
+
     public AppLanguage CurrentLanguage
     {
         get => _configurationService.Get(nameof(CurrentLanguage), TranslationService.DefaultAppLanguage);

Wino.Mail.WinUI/Views/Abstract/MailNotificationSettingsPageAbstract.cs

@@ -0,0 +1,5 @@
+using Wino.Mail.ViewModels;
+
+namespace Wino.Views.Abstract;
+
+public abstract class MailNotificationSettingsPageAbstract : SettingsPageBase<MailNotificationSettingsPageViewModel> { }

Wino.Mail.WinUI/Views/Calendar/CalendarPage.xaml.cs

@@ -71,14 +71,20 @@ public sealed partial class CalendarPage : CalendarPageAbstract, ITitleBarSearch
         }
 
         var anchorDate = DateOnly.FromDateTime(DateTime.Now.Date);
+        CalendarItemTarget? pendingTarget = null;
 
         if (e.Parameter is CalendarPageNavigationArgs args && !args.RequestDefaultNavigation)
         {
             anchorDate = DateOnly.FromDateTime(args.NavigationDate.Date);
+            pendingTarget = args.PendingTarget;
+        }
+        else if (e.Parameter is CalendarPageNavigationArgs pendingArgs)
+        {
+            pendingTarget = pendingArgs.PendingTarget;
         }
 
         var request = new CalendarDisplayRequest(ViewModel.StatePersistanceService.CalendarDisplayType, anchorDate);
-        WeakReferenceMessenger.Default.Send(new LoadCalendarMessage(request));
+        WeakReferenceMessenger.Default.Send(new LoadCalendarMessage(request, PendingTarget: pendingTarget));
     }
 
     protected override void OnNavigatedFrom(NavigationEventArgs e)

Wino.Mail.WinUI/Views/Settings/MailNotificationSettingsPage.xaml

@@ -0,0 +1,49 @@
+<abstract:MailNotificationSettingsPageAbstract
+    x:Class="Wino.Views.Settings.MailNotificationSettingsPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:abstract="using:Wino.Views.Abstract"
+    xmlns:controls="using:CommunityToolkit.WinUI.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:domain="using:Wino.Core.Domain"
+    xmlns:mailViewModels="using:Wino.Mail.ViewModels"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d">
+
+    <ScrollViewer>
+        <StackPanel Spacing="{StaticResource SettingsCardSpacing}">
+            <controls:SettingsExpander
+                Description="{x:Bind domain:Translator.SettingsMailNotifications_Actions_Description}"
+                Header="{x:Bind domain:Translator.SettingsMailNotifications_Actions_Title}"
+                IsExpanded="True">
+                <controls:SettingsExpander.HeaderIcon>
+                    <PathIcon Data="F1 M 6.347656 16.25 L 3.701172 16.25 C 3.375651 16.25 3.064779 16.18327 2.768555 16.049805 C 2.472331 15.916342 2.211914 15.737305 1.987305 15.512695 C 1.762695 15.288086 1.583659 15.02767 1.450195 14.731445 C 1.316732 14.435222 1.25 14.12435 1.25 13.798828 L 1.25 3.701172 C 1.25 3.375652 1.316732 3.064779 1.450195 2.768555 C 1.583659 2.472332 1.762695 2.211914 1.987305 1.987305 C 2.211914 1.762695 2.472331 1.58366 2.768555 1.450195 C 3.064779 1.316732 3.375651 1.25 3.701172 1.25 L 16.298828 1.25 C 16.624348 1.25 16.935221 1.316732 17.231445 1.450195 C 17.527668 1.58366 17.788086 1.762695 18.012695 1.987305 C 18.237305 2.211914 18.41634 2.472332 18.549805 2.768555 C 18.683268 3.064779 18.75 3.375652 18.75 3.701172 L 18.75 13.798828 C 18.75 14.13737 18.681641 14.454753 18.544922 14.750977 C 18.408203 15.047201 18.22591 15.30599 17.998047 15.527344 C 17.770182 15.748698 17.504883 15.924479 17.202148 16.054688 C 16.899414 16.184896 16.582031 16.25 16.25 16.25 L 13.652344 16.25 L 10.46875 19.794922 C 10.345052 19.931641 10.188802 20 10 20 C 9.811197 20 9.654947 19.931641 9.53125 19.794922 Z M 15.625 7.5 C 15.79427 7.5 15.940754 7.438151 16.064453 7.314453 C 16.18815 7.190756 16.25 7.044271 16.25 6.875 C 16.25 6.705729 16.18815 6.559245 16.064453 6.435547 C 15.940754 6.31185 15.79427 6.25 15.625 6.25 L 4.375 6.25 C 4.205729 6.25 4.059245 6.31185 3.935547 6.435547 C 3.811849 6.559245 3.75 6.705729 3.75 6.875 C 3.75 7.044271 3.811849 7.190756 3.935547 7.314453 C 4.059245 7.438151 4.205729 7.5 4.375 7.5 Z M 15.625 11.25 C 15.79427 11.25 15.940754 11.188151 16.064453 11.064453 C 16.18815 10.940756 16.25 10.794271 16.25 10.625 C 16.25 10.455729 16.18815 10.309245 16.064453 10.185547 C 15.940754 10.06185 15.79427 10 15.625 10 L 4.375 10 C 4.205729 10 4.059245 10.06185 3.935547 10.185547 C 3.811849 10.309245 3.75 10.455729 3.75 10.625 C 3.75 10.794271 3.811849 10.940756 3.935547 11.064453 C 4.059245 11.188151 4.205729 11.25 4.375 11.25 Z " />
+                </controls:SettingsExpander.HeaderIcon>
+                <controls:SettingsExpander.Items>
+                    <controls:SettingsCard Description="{x:Bind domain:Translator.SettingsMailNotifications_FirstAction_Description}" Header="{x:Bind domain:Translator.SettingsMailNotifications_FirstAction_Title}">
+
+                        <ComboBox ItemsSource="{x:Bind ViewModel.AvailableNotificationActions, Mode=OneWay}" SelectedItem="{x:Bind ViewModel.SelectedFirstAction, Mode=TwoWay}">
+                            <ComboBox.ItemTemplate>
+                                <DataTemplate x:DataType="mailViewModels:MailNotificationActionOption">
+                                    <TextBlock Text="{x:Bind DisplayText}" />
+                                </DataTemplate>
+                            </ComboBox.ItemTemplate>
+                        </ComboBox>
+                    </controls:SettingsCard>
+
+                    <controls:SettingsCard Description="{x:Bind domain:Translator.SettingsMailNotifications_SecondAction_Description}" Header="{x:Bind domain:Translator.SettingsMailNotifications_SecondAction_Title}">
+
+                        <ComboBox ItemsSource="{x:Bind ViewModel.AvailableNotificationActions, Mode=OneWay}" SelectedItem="{x:Bind ViewModel.SelectedSecondAction, Mode=TwoWay}">
+                            <ComboBox.ItemTemplate>
+                                <DataTemplate x:DataType="mailViewModels:MailNotificationActionOption">
+                                    <TextBlock Text="{x:Bind DisplayText}" />
+                                </DataTemplate>
+                            </ComboBox.ItemTemplate>
+                        </ComboBox>
+                    </controls:SettingsCard>
+                </controls:SettingsExpander.Items>
+            </controls:SettingsExpander>
+
+        </StackPanel>
+    </ScrollViewer>
+</abstract:MailNotificationSettingsPageAbstract>

Wino.Mail.WinUI/Views/Settings/MailNotificationSettingsPage.xaml.cs

@@ -0,0 +1,11 @@
+using Wino.Views.Abstract;
+
+namespace Wino.Views.Settings;
+
+public sealed partial class MailNotificationSettingsPage : MailNotificationSettingsPageAbstract
+{
+    public MailNotificationSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

Wino.Mail.WinUI/Views/WinoAppShell.xaml.cs

@@ -89,7 +89,16 @@ public sealed partial class WinoAppShell : Views.Abstract.WinoAppShellAbstract,
     public void ActivateMode(WinoApplicationMode mode, ShellModeActivationContext activationContext)
     {
         if (_activeMode == mode && InnerShellFrame.Content != null)
+        {
+            if (activationContext.Parameter != null)
+            {
+                ViewModel.SetCurrentMode(mode);
+                ViewModel.CurrentClient.Activate(activationContext);
+                NotifyTitleBarContentChanged();
+            }
+
             return;
+        }
 
         DeactivateCurrentMode();
         ResetShellModeNavigationState();

Wino.Messages/Client/Calendar/LoadCalendarMessage.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using Wino.Core.Domain.Models.Calendar;
 
 namespace Wino.Messaging.Client.Calendar;
@@ -7,4 +8,8 @@ namespace Wino.Messaging.Client.Calendar;
 /// </summary>
 /// <param name="DisplayRequest">Display type and anchor date to resolve.</param>
 /// <param name="ForceReload">Force a reload even if the resolved range did not change.</param>
-public record LoadCalendarMessage(CalendarDisplayRequest DisplayRequest, bool ForceReload = false);
+/// <param name="PendingTarget">Optional event target to open after the requested range is loaded.</param>
+public record LoadCalendarMessage(
+    CalendarDisplayRequest DisplayRequest,
+    bool ForceReload = false,
+    CalendarItemTarget? PendingTarget = null);

Wino.Services/AccountService.cs

@@ -538,6 +538,26 @@ public class AccountService : BaseDatabaseService, IAccountService
             }
         }
 
+        if (localAliases.Count == 0 && !string.IsNullOrWhiteSpace(account.Address))
+        {
+            var fallbackAddress = account.Address.Trim();
+            var fallbackAlias = new MailAccountAlias()
+            {
+                AccountId = account.Id,
+                AliasAddress = fallbackAddress,
+                IsPrimary = true,
+                IsRootAlias = true,
+                IsVerified = true,
+                ReplyToAddress = fallbackAddress,
+                Id = Guid.NewGuid(),
+                Source = AliasSource.ProviderDiscovered,
+                SendCapability = AliasSendCapability.Confirmed
+            };
+
+            await Connection.InsertAsync(fallbackAlias, typeof(MailAccountAlias)).ConfigureAwait(false);
+            localAliases.Add(fallbackAlias);
+        }
+
         // Make sure there is only 1 root alias and 1 primary alias selected.
 
         bool shouldUpdatePrimary = localAliases.Count(a => a.IsPrimary) != 1;