diff --git a/.github/workflows/build-and-release.yml b/.github/workflows/build-and-release.yml
index 234ae3e..3611921 100644
--- a/.github/workflows/build-and-release.yml
+++ b/.github/workflows/build-and-release.yml
@@ -102,20 +102,18 @@ jobs:
 
       - name: Create SHA-256 checksum
         shell: pwsh
-        env:
-          APP_VERSION: ${{ steps.version.outputs.number }}
         run: |
-          $installer = Get-Item "artifacts\OneNoteBackupExporter_Setup_$env:APP_VERSION.exe"
+          $installer = Get-Item "artifacts\OneNoteBackupExporter_Setup.exe"
           $hash = (Get-FileHash $installer.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
           "$hash  $($installer.Name)" | Set-Content "$($installer.FullName).sha256" -Encoding ascii
 
       - name: Upload build artifact
         uses: actions/upload-artifact@v4
         with:
-          name: OneNoteBackupExporter-${{ steps.version.outputs.number }}
+          name: OneNoteBackupExporter-Windows-x64
           path: |
-            artifacts/OneNoteBackupExporter_Setup_${{ steps.version.outputs.number }}.exe
-            artifacts/OneNoteBackupExporter_Setup_${{ steps.version.outputs.number }}.exe.sha256
+            artifacts/OneNoteBackupExporter_Setup.exe
+            artifacts/OneNoteBackupExporter_Setup.exe.sha256
           if-no-files-found: error
           retention-days: 14
 
@@ -131,7 +129,7 @@ jobs:
       - name: Download installer artifact
         uses: actions/download-artifact@v4
         with:
-          name: OneNoteBackupExporter-${{ needs.build.outputs.version }}
+          name: OneNoteBackupExporter-Windows-x64
           path: artifacts
 
       - name: Create release and upload installer
diff --git a/AboutWindow.xaml b/AboutWindow.xaml
new file mode 100644
index 0000000..04ae14a
--- /dev/null
+++ b/AboutWindow.xaml
@@ -0,0 +1,91 @@
+<Window x:Class="OneNoteExporter.AboutWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Icon="icon.ico"
+        Title="About OneNote Backup Exporter"
+        Width="430" Height="305"
+        ResizeMode="NoResize"
+        ShowInTaskbar="False"
+        WindowStartupLocation="CenterOwner"
+        Background="{StaticResource BgPage}">
+
+    <Border Margin="18"
+            Padding="22"
+            Background="{StaticResource BgCard}"
+            BorderBrush="{StaticResource BorderColor}"
+            BorderThickness="1"
+            CornerRadius="8">
+        <Grid>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+                <RowDefinition Height="Auto"/>
+            </Grid.RowDefinitions>
+
+            <Grid Grid.Row="0">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                </Grid.ColumnDefinitions>
+
+                <Image Grid.Column="0"
+                       Source="icon.ico"
+                       Width="52" Height="52"
+                       Margin="0,0,15,0"/>
+
+                <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                    <TextBlock Text="OneNote Backup Exporter"
+                               FontSize="19"
+                               FontWeight="Bold"
+                               Foreground="{StaticResource PrimaryBlue}"/>
+                    <TextBlock x:Name="VersionText"
+                               Margin="0,4,0,0"
+                               FontSize="13"
+                               FontWeight="SemiBold"
+                               Foreground="{StaticResource TextPrimary}"/>
+                    <TextBlock x:Name="BuildText"
+                               Margin="0,2,0,0"
+                               FontSize="11"
+                               Foreground="{StaticResource TextSecondary}"/>
+                </StackPanel>
+            </Grid>
+
+            <Border Grid.Row="1"
+                    Margin="0,18,0,14"
+                    Padding="12,9"
+                    Background="{StaticResource InfoBg}"
+                    BorderBrush="{StaticResource InfoBorder}"
+                    BorderThickness="1"
+                    CornerRadius="5">
+                <TextBlock Text="Reliable backups and exports for OneNote Desktop."
+                           TextAlignment="Center"
+                           Foreground="{StaticResource InfoFg}"
+                           FontSize="12"/>
+            </Border>
+
+            <StackPanel Grid.Row="2">
+                <TextBlock Text="Supports OneNote packages, PDF, XPS and local backup copies."
+                           TextWrapping="Wrap"
+                           TextAlignment="Center"
+                           Foreground="{StaticResource TextSecondary}"
+                           FontSize="12"/>
+                <TextBlock Text="© 2026 JLI Software"
+                           Margin="0,8,0,0"
+                           TextAlignment="Center"
+                           Foreground="{StaticResource TextSecondary}"
+                           FontSize="11"/>
+            </StackPanel>
+
+            <Button Grid.Row="3"
+                    Content="Close"
+                    Style="{StaticResource SmallButtonStyle}"
+                    Width="90"
+                    Margin="0,16,0,0"
+                    HorizontalAlignment="Right"
+                    IsDefault="True"
+                    IsCancel="True"
+                    Click="CloseButton_Click"/>
+        </Grid>
+    </Border>
+</Window>
diff --git a/AboutWindow.xaml.cs b/AboutWindow.xaml.cs
new file mode 100644
index 0000000..e51f624
--- /dev/null
+++ b/AboutWindow.xaml.cs
@@ -0,0 +1,31 @@
+using System.Reflection;
+using System.Windows;
+
+namespace OneNoteExporter;
+
+public partial class AboutWindow : Window
+{
+    public AboutWindow()
+    {
+        InitializeComponent();
+
+        var assembly = Assembly.GetExecutingAssembly();
+        var informationalVersion = assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+            .InformationalVersion;
+        var versionParts = informationalVersion?.Split('+', 2);
+        var version = versionParts is { Length: > 0 } && !string.IsNullOrWhiteSpace(versionParts[0])
+            ? versionParts[0]
+            : assembly.GetName().Version?.ToString(3) ?? "Unknown";
+        var configuration = assembly
+            .GetCustomAttribute<AssemblyConfigurationAttribute>()?
+            .Configuration ?? "Release";
+
+        VersionText.Text = $"Version {version}";
+        BuildText.Text = versionParts is { Length: 2 }
+            ? $"{configuration} build · {versionParts[1][..Math.Min(7, versionParts[1].Length)]}"
+            : $"{configuration} build";
+    }
+
+    private void CloseButton_Click(object sender, RoutedEventArgs e) => Close();
+}
diff --git a/App.xaml b/App.xaml
index ac8316b..d1d9307 100644
--- a/App.xaml
+++ b/App.xaml
@@ -146,6 +146,27 @@
             </Style.Triggers>
         </Style>
 
+        <!-- Compact header button for About/version information -->
+        <Style x:Key="AboutButtonStyle" TargetType="Button">
+            <Setter Property="Width" Value="30"/>
+            <Setter Property="Height" Value="30"/>
+            <Setter Property="Padding" Value="0"/>
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="BorderBrush" Value="{StaticResource BorderColor}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Foreground" Value="{StaticResource PrimaryBlue}"/>
+            <Setter Property="FontSize" Value="14"/>
+            <Setter Property="FontWeight" Value="Bold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template" Value="{StaticResource BorderedButtonTemplate}"/>
+            <Style.Triggers>
+                <Trigger Property="IsMouseOver" Value="True">
+                    <Setter Property="Background" Value="#EEF4FF"/>
+                    <Setter Property="BorderBrush" Value="{StaticResource PrimaryBlue}"/>
+                </Trigger>
+            </Style.Triggers>
+        </Style>
+
         <!-- ===== TextBox Style ===== -->
         <Style TargetType="TextBox">
             <Setter Property="Padding"       Value="8,6"/>
diff --git a/App.xaml.cs b/App.xaml.cs
index e7f40dc..6221243 100644
--- a/App.xaml.cs
+++ b/App.xaml.cs
@@ -1,5 +1,6 @@
 using System.Windows;
 using System.Windows.Threading;
+using OneNoteExporter.Helpers;
 
 namespace OneNoteExporter;
 
@@ -16,7 +17,9 @@ protected override void OnStartup(StartupEventArgs e)
     private void OnDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
     {
         MessageBox.Show(
-            $"An unexpected error occurred:\n\n{e.Exception.Message}",
+            UserFacingError.Describe(
+                e.Exception,
+                "An unexpected error occurred. Please restart the app and try again."),
             "OneNote Exporter – Error",
             MessageBoxButton.OK,
             MessageBoxImage.Error);
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..9f58c92
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,10 @@
+# Changelog
+
+## 1.2.0
+
+- Improved reliability with a serialized OneNote COM worker, safe cancellation, and bounded connection recovery.
+- Protected existing backups with staging files and atomic replacement.
+- Added safer PDF/XPS handling for large notebooks, including automatic per-section export.
+- Prevented filename collisions while preserving OneNote section-group folders.
+- Added an About dialog with version and build information.
+- Standardized all user-facing errors, progress messages, and release tooling in English.
diff --git a/CLAUDE.md b/CLAUDE.md
index 661ad2a..e5e9088 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -12,8 +12,10 @@ Single-project WPF app, no subprocesses:
 
 ```
 MainWindow.xaml / .xaml.cs   (UI + code-behind)
-    ↕ direct method calls
-Services/OneNoteService.cs   (OneNote COM API wrapper)
+    ↕ async calls
+Services/OneNoteComWorker.cs (serialized STA thread + message pump)
+    ↕ synchronous calls on the owning STA thread
+Services/OneNoteService.cs   (low-level OneNote COM API wrapper)
     ↕ COM API
 OneNote Desktop
 ```
@@ -26,17 +28,19 @@ OneNoteExporterC#/
 ├── OneNoteExporter.sln
 ├── App.xaml                  Global styles (colors, buttons, inputs)
 ├── App.xaml.cs               Global exception handler
+├── AboutWindow.xaml/.cs      About dialog with runtime version/build metadata
 ├── MainWindow.xaml           Full UI layout
 ├── MainWindow.xaml.cs        All UI logic, async export flow
 ├── Models/
 │   └── Models.cs             NotebookInfo, ExportResult, VersionInfo,
 │                             BackupAvailability, NotebookViewModel
 ├── Services/
-│   └── OneNoteService.cs     COM wrapper: GetNotebooks, ExportNotebook,
-│                             ExportAllNotebooks, GetVersionInfo, Dispose
+│   ├── OneNoteComWorker.cs   Dedicated STA owner, serialized async facade
+│   └── OneNoteService.cs     Low-level hierarchy and publish COM calls
 └── Helpers/
-    └── FileHelper.cs         Local backup path, CopyLocalBackup, OpenFolder,
-                              GetDefaultDownloadsPath
+    ├── FileHelper.cs         Local backup path, CopyLocalBackup, OpenFolder,
+    │                         GetDefaultDownloadsPath
+    └── UserFacingError.cs    Stable English error text and language-neutral codes
 ```
 
 ## Development Commands
@@ -52,6 +56,17 @@ dotnet run
 dotnet publish -c Release -r win-x64 --self-contained true
 ```
 
+## Release Asset Naming
+
+Public release assets must use stable, version-independent names so `releases/latest`
+download URLs remain permanent:
+
+- `OneNoteBackupExporter_Setup.exe`
+- `OneNoteBackupExporter_Setup.exe.sha256`
+
+Do not add the version number to public release asset filenames. Keep the semantic version
+in the project, installer metadata, Git tag, GitHub release title, and About dialog instead.
+
 ## Critical Technical Details
 
 ### COM Compatibility
@@ -60,17 +75,25 @@ dotnet publish -c Release -r win-x64 --self-contained true
 - **Do NOT add `<UseWindowsForms>true</UseWindowsForms>`** – causes namespace conflict with the COM `Application` class
 
 ### Threading Model
-- `OneNoteService` methods are synchronous and blocking (COM calls + polling with `Thread.Sleep`)
-- Always call service methods via `Task.Run(...)` from the UI layer
+- `OneNoteComWorker` owns `OneNoteService` and its COM object on one dedicated STA thread
+- All OneNote COM calls are dispatched through that thread's WPF `Dispatcher` message pump
+- Public worker methods are async and serialized; do not wrap them in `Task.Run(...)`
+- Export file polling runs asynchronously outside the STA thread while the serialization gate remains held
 - Use `IProgress<string>` for progress reporting (marshals back to UI thread automatically via `Progress<T>`)
-- Use `CancellationToken` for cooperative cancellation; `ct.WaitHandle.WaitOne(ms)` replaces `Thread.Sleep` in polling loops for cancellation-aware waits
+- Use `CancellationToken` for cooperative cancellation and `Task.Delay(..., ct)` in polling loops
 
 ### Export Process
-1. `OneNoteService` is initialized at window load via `Task.Run(() => new OneNoteService())`
-2. `GetNotebooks()` retrieves all notebooks via `GetHierarchy()` XML parse
-3. `ExportNotebook()` calls `OpenHierarchy()` then `Publish()` with the appropriate `PublishFormat` enum
-4. After `Publish()` returns (immediately), the service polls the output file until size is stable for 10 seconds (file write monitoring)
-5. Timeout: 20 min for local notebooks, 30 min for cloud (SharePoint/OneDrive)
+1. `OneNoteComWorker.CreateAsync()` starts the STA thread and creates `OneNoteService` there
+2. `GetNotebooksAsync()` retrieves all notebooks via `GetHierarchy()` XML parse on the worker
+3. `ExportNotebookAsync()` publishes to a unique same-directory staging file on the STA worker
+4. Recoverable COM/RPC failures get one bounded retry; disconnected COM objects are recreated and validated on the STA thread
+5. Async file polling waits until size is stable for 10 seconds while the STA message pump stays responsive
+6. A successful staging file atomically replaces the final export; previous good backups remain untouched on failure
+7. Timeout: 20 min for local notebooks, 30 min for cloud (SharePoint/OneDrive); polling timeouts are not retried
+8. OneNote does not expose notebook byte size through COM. Whole-notebook PDF/XPS
+   jobs therefore show a preflight choice: automatically split into individual
+   section exports (recommended), switch to `.onepkg`, or explicitly try the whole
+   rendered export anyway
 
 ### Export Formats
 | UI value | PublishFormat | Extension |
@@ -86,15 +109,18 @@ dotnet publish -c Release -r win-x64 --self-contained true
 - When selected in dropdown: all notebooks auto-checked, checkboxes disabled, warning shown
 
 ### OneNote COM Cleanup
-- `OneNoteService.Dispose()` is called in `MainWindow.Window_Closing`
-- `Dispose()` calls `Marshal.ReleaseComObject()` – does NOT kill the OneNote process
+- `OneNoteComWorker.Dispose()` is called in `MainWindow.Window_Closing`
+- The worker releases the COM object on its owning STA thread and does NOT kill OneNote
 - OneNote continues running in background after app closes (by design, avoids "could not be started on last attempt" error)
 
 ### Known COM Errors
 | HResult | Cause | Action |
 |---|---|---|
-| `0x8004201A` | Password-protected sections or offline | Show message, suggest unlocking |
-| `0x800706BA` | RPC timeout (large notebook, PDF/XPS) | Suggest .onepkg format |
+| `0x8004201A` | Export file already exists | Report the target-file collision |
+| `0x8004201D` | Notebook is not fully synchronized | Ask the user to finish sync |
+| `0x80042023` | OneNote internal timeout | Report timeout; suggest .onepkg for large PDF/XPS jobs |
+| `0x80042030` | A modal OneNote dialog blocks COM | Ask the user to close the dialog |
+| `0x800706BA` | OneNote RPC server unavailable/disconnected | Reconnect once, then report actionable COM guidance |
 | `0x80070005` | Access denied | Check permissions |
 | `0x80042010` | Notebook not accessible | Open in OneNote first |
 
@@ -102,7 +128,7 @@ dotnet publish -c Release -r win-x64 --self-contained true
 
 ### Layout (3-row Grid)
 ```
-Row 0 (Auto):   Header – title (#0078d7) + version badge (dynamic color)
+Row 0 (Auto):   Header – title, OneNote status badge and About/version button
 Row 1 (*):      Notebook list (ScrollViewer + ItemsControl with CheckBoxes)
 Row 2 (Auto):   Export section (path, format dropdown, warning, buttons, status)
 ```
@@ -121,7 +147,10 @@ Row 2 (Auto):   Export section (path, format dropdown, warning, buttons, status)
 - List background: `#F8F9FA`
 
 ### UI Language
-**English** – all UI strings are in English (matching the original Go/Wails frontend).
+**English** – all user-facing UI, error, progress, dialog, status, and completion strings
+must remain in English. Do not display raw `Exception.Message` values because Windows and
+OneNote COM messages follow the operating-system language. Use `UserFacingError` and a
+language-neutral HRESULT/error code while keeping internal diagnostic output non-sensitive.
 
 ### Key Behaviors
 - Export button disabled until ≥1 notebook selected; text = `"Export N notebook(s)"`
diff --git a/Helpers/FileHelper.cs b/Helpers/FileHelper.cs
index d407a98..9acc0b1 100644
--- a/Helpers/FileHelper.cs
+++ b/Helpers/FileHelper.cs
@@ -63,7 +63,9 @@ public static BackupAvailability CheckLocalBackupAvailable()
             {
                 Available = false,
                 Reason    = "read_error",
-                Message   = $"Error reading backup folder: {ex.Message}",
+                Message   = UserFacingError.Describe(
+                    ex,
+                    "The OneNote backup folder could not be read."),
                 Path      = backupPath
             };
         }
@@ -104,7 +106,13 @@ public static ExportResult CopyLocalBackup(string destPath)
         }
         catch (Exception ex)
         {
-            return new ExportResult { Success = false, Message = $"Error copying backup: {ex.Message}" };
+            return new ExportResult
+            {
+                Success = false,
+                Message = UserFacingError.Describe(
+                    ex,
+                    "The local OneNote backup could not be copied.")
+            };
         }
     }
 
@@ -122,7 +130,8 @@ public static void OpenFolder(string path)
         }
         catch (Exception ex)
         {
-            Debug.WriteLine($"Failed to open folder: {ex.Message}");
+            Debug.WriteLine(
+                UserFacingError.Describe(ex, "The destination folder could not be opened."));
         }
     }
 
diff --git a/Helpers/UserFacingError.cs b/Helpers/UserFacingError.cs
new file mode 100644
index 0000000..e750416
--- /dev/null
+++ b/Helpers/UserFacingError.cs
@@ -0,0 +1,25 @@
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace OneNoteExporter.Helpers;
+
+/// <summary>
+/// Creates stable English error messages without exposing localized Windows or COM text.
+/// </summary>
+public static class UserFacingError
+{
+    public static string Describe(Exception exception, string message)
+        => $"{message} ({GetTechnicalCode(exception)})";
+
+    public static string GetTechnicalCode(Exception exception)
+    {
+        Exception relevantException = exception.InnerException ?? exception;
+
+        return relevantException switch
+        {
+            COMException comException => $"COM 0x{comException.HResult:X8}",
+            Win32Exception win32Exception => $"Windows error {win32Exception.NativeErrorCode}",
+            _ => $"error 0x{relevantException.HResult:X8}"
+        };
+    }
+}
diff --git a/MainWindow.xaml b/MainWindow.xaml
index 1bb281a..0210c67 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -32,6 +32,7 @@
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="*"/>
                     <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
 
                 <TextBlock Grid.Column="0"
@@ -48,12 +49,20 @@
                         BorderThickness="1"
                         CornerRadius="4"
                         Padding="8,4"
+                        Margin="0,0,9,0"
                         VerticalAlignment="Center">
                     <TextBlock x:Name="VersionText"
                                Text="Checking OneNote installation..."
                                Foreground="{StaticResource InfoFg}"
                                FontSize="12"/>
                 </Border>
+
+                <Button Grid.Column="2"
+                        Content="?"
+                        Style="{StaticResource AboutButtonStyle}"
+                        ToolTip="About and version"
+                        AutomationProperties.Name="About and version"
+                        Click="AboutButton_Click"/>
             </Grid>
         </Border>
 
@@ -339,6 +348,21 @@
                                FontSize="12"/>
                 </Border>
 
+                <!-- PDF/XPS reliability warning -->
+                <Border x:Name="RenderedFormatWarning"
+                        Background="{StaticResource WarningBg}"
+                        BorderBrush="{StaticResource WarningBorder}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="10,7"
+                        Margin="0,0,0,10"
+                        Visibility="Collapsed">
+                    <TextBlock x:Name="RenderedFormatWarningText"
+                               TextWrapping="Wrap"
+                               Foreground="{StaticResource WarningFg}"
+                               FontSize="12"/>
+                </Border>
+
                 <!-- Export + Cancel buttons -->
                 <Grid Margin="0,0,0,8">
                     <Grid.ColumnDefinitions>
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 0dcb399..7ae4b48 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -16,9 +16,10 @@ public partial class MainWindow : Window
 {
     // ── State ────────────────────────────────────────────────────────────────
 
-    private OneNoteService?       _service;
+    private OneNoteComWorker?     _service;
     private CancellationTokenSource? _exportCts;
     private bool                  _exportInProgress = false;
+    private bool                  _isLocalBackupMode = false;
 
     private readonly ObservableCollection<NotebookViewModel> _notebooks = new();
 
@@ -50,8 +51,8 @@ private async Task InitOneNoteServiceAsync()
 
         try
         {
-            _service = await Task.Run(() => new OneNoteService());
-            var info = await Task.Run(() => _service.GetVersionInfo());
+            _service = await OneNoteComWorker.CreateAsync();
+            var info = await _service.GetVersionInfoAsync();
 
             if (info.OneNoteInstalled)
                 SetVersionBadge($"✓ {info.OneNoteVersion}", StatusKind.Success);
@@ -61,7 +62,9 @@ private async Task InitOneNoteServiceAsync()
         catch (Exception ex)
         {
             _service = null;
-            SetVersionBadge($"⚠  {ex.Message}", StatusKind.Error);
+            SetVersionBadge(
+                $"⚠  {UserFacingError.Describe(ex, "OneNote Desktop connection failed.")}",
+                StatusKind.Error);
         }
     }
 
@@ -77,7 +80,7 @@ private async Task LoadNotebooksAsync()
             if (_service == null)
                 throw new InvalidOperationException("OneNote Helper is not available.");
 
-            var list = await Task.Run(() => _service.GetNotebooks());
+            var list = await _service.GetNotebooksAsync();
 
             ShowNotebookOverlay(OverlayKind.None);
 
@@ -96,7 +99,11 @@ private async Task LoadNotebooksAsync()
         }
         catch (Exception ex)
         {
-            ShowNotebookOverlay(OverlayKind.Error, $"Error loading notebooks: {ex.Message}");
+            ShowNotebookOverlay(
+                OverlayKind.Error,
+                UserFacingError.Describe(
+                    ex,
+                    "Notebooks could not be loaded. Open OneNote Desktop and try again."));
         }
 
         UpdateExportButtonState();
@@ -111,6 +118,27 @@ private string GetSelectedFormat()
         return "onepkg";
     }
 
+    private static bool IsRenderedFormat(string format)
+        => format.Equals("pdf", StringComparison.OrdinalIgnoreCase) ||
+           format.Equals("xps", StringComparison.OrdinalIgnoreCase);
+
+    private void UpdateRenderedFormatWarning(string format)
+    {
+        bool isRenderedFormat = IsRenderedFormat(format);
+        RenderedFormatWarning.Visibility = isRenderedFormat
+            ? Visibility.Visible
+            : Visibility.Collapsed;
+
+        if (!isRenderedFormat) return;
+
+        string formatName = format.Equals("pdf", StringComparison.OrdinalIgnoreCase)
+            ? "PDF"
+            : "XPS";
+        RenderedFormatWarningText.Text =
+            $"⚠ Whole-notebook {formatName} exports can fail in OneNote for large notebooks. " +
+            "Before export, the app will offer the safer section-by-section mode.";
+    }
+
     private void UpdateExportButtonState()
     {
         if (GetSelectedFormat() == "localbackup") return; // handled by ApplyLocalBackupMode
@@ -121,7 +149,7 @@ private void UpdateExportButtonState()
         int sectionCount  = _notebooks.Sum(nb => nb.Sections.Count(s => s.IsSelected));
 
         bool hasAny = notebookCount > 0 || sectionCount > 0;
-        ExportButton.IsEnabled = hasAny;
+        ExportButton.IsEnabled = hasAny && !_exportInProgress;
 
         ExportButton.Content = (notebookCount, sectionCount) switch
         {
@@ -143,7 +171,7 @@ private void UpdateLocalBackupOption()
         }
         else
         {
-            LocalBackupItem.Content  = $"Local Backup Copy – Not available ({avail.Reason})";
+            LocalBackupItem.Content  = $"Local Backup Copy – Not available ({avail.Message})";
             LocalBackupItem.IsEnabled = false;
         }
     }
@@ -152,6 +180,7 @@ private void ApplyLocalBackupMode(bool enable)
     {
         if (enable)
         {
+            _isLocalBackupMode = true;
             BackupWarning.Visibility = Visibility.Visible;
 
             foreach (var nb in _notebooks)
@@ -170,12 +199,17 @@ private void ApplyLocalBackupMode(bool enable)
         }
         else
         {
+            bool wasLocalBackupMode = _isLocalBackupMode;
+            _isLocalBackupMode = false;
             BackupWarning.Visibility = Visibility.Collapsed;
 
-            foreach (var nb in _notebooks)
+            if (wasLocalBackupMode)
             {
-                nb.IsSelected = false;
-                nb.IsEnabled  = true;
+                foreach (var nb in _notebooks)
+                {
+                    nb.IsSelected = false;
+                    nb.IsEnabled  = true;
+                }
             }
 
             UpdateExportButtonState();
@@ -285,8 +319,10 @@ private void FormatCombo_SelectionChanged(object sender, SelectionChangedEventAr
         // Guard: may fire before UI is fully initialised
         if (BackupWarning == null) return;
 
-        bool isLocalBackup = GetSelectedFormat() == "localbackup";
+        string format = GetSelectedFormat();
+        bool isLocalBackup = format == "localbackup";
         ApplyLocalBackupMode(isLocalBackup);
+        UpdateRenderedFormatWarning(format);
     }
 
     private void Notebook_SelectionChanged(object sender, RoutedEventArgs e)
@@ -295,6 +331,12 @@ private void Notebook_SelectionChanged(object sender, RoutedEventArgs e)
     private void Section_SelectionChanged(object sender, RoutedEventArgs e)
         => UpdateExportButtonState();
 
+    private void AboutButton_Click(object sender, RoutedEventArgs e)
+    {
+        var aboutWindow = new AboutWindow { Owner = this };
+        aboutWindow.ShowDialog();
+    }
+
     private async void ExpandSections_Click(object sender, RoutedEventArgs e)
     {
         if (sender is not Button btn || btn.DataContext is not NotebookViewModel nb) return;
@@ -305,25 +347,38 @@ private async void ExpandSections_Click(object sender, RoutedEventArgs e)
             await LoadSectionsAsync(nb);
     }
 
-    private async Task LoadSectionsAsync(NotebookViewModel nb)
+    private async Task<bool> LoadSectionsAsync(
+        NotebookViewModel nb,
+        CancellationToken ct = default)
     {
-        if (_service == null) return;
+        if (_service == null) return false;
 
         nb.IsLoadingSections = true;
 
         try
         {
-            var sections = await Task.Run(() => _service.GetSections(nb.Id));
+            var sections = await _service.GetSectionsAsync(nb.Id, ct);
+            ct.ThrowIfCancellationRequested();
 
             nb.Sections.Clear();
             foreach (var s in sections)
                 nb.Sections.Add(new SectionViewModel(s));
 
             nb.HasSectionsLoaded = true;
+            return true;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
         }
         catch (Exception ex)
         {
-            ShowStatus($"Could not load sections for '{nb.Name}': {ex.Message}", StatusKind.Error);
+            ShowStatus(
+                UserFacingError.Describe(
+                    ex,
+                    $"Sections for '{nb.Name}' could not be loaded."),
+                StatusKind.Error);
+            return false;
         }
         finally
         {
@@ -331,6 +386,101 @@ private async Task LoadSectionsAsync(NotebookViewModel nb)
         }
     }
 
+    private async Task<bool> ConvertNotebookJobsToSectionsAsync(
+        List<NotebookViewModel> notebookJobs,
+        List<(NotebookViewModel Notebook, SectionViewModel Section)> sectionJobs,
+        string format,
+        CancellationToken ct)
+    {
+        int notebookIndex = 0;
+
+        foreach (var notebook in notebookJobs)
+        {
+            ct.ThrowIfCancellationRequested();
+            notebookIndex++;
+            ShowProgress(
+                $"Preparing safer {format.ToUpperInvariant()} export...\n" +
+                $"Loading sections for notebook {notebookIndex}/{notebookJobs.Count}: " +
+                notebook.Name);
+
+            if (!notebook.HasSectionsLoaded && !await LoadSectionsAsync(notebook, ct))
+            {
+                HideProgress();
+                return false;
+            }
+
+            if (notebook.Sections.Count == 0)
+            {
+                HideProgress();
+                ShowStatus(
+                    $"No exportable sections were found in '{notebook.Name}'. " +
+                    "Use a OneNote package for a complete backup.",
+                    StatusKind.Warning);
+                return false;
+            }
+
+            ct.ThrowIfCancellationRequested();
+
+            foreach (var section in notebook.Sections)
+            {
+                bool alreadyQueued = sectionJobs.Any(job => job.Section.Id == section.Id);
+                if (!alreadyQueued)
+                    sectionJobs.Add((notebook, section));
+            }
+        }
+
+        notebookJobs.Clear();
+        return true;
+    }
+
+    private async Task<(bool Continue, string Format)> ApplyRenderedExportGuardAsync(
+        List<NotebookViewModel> notebookJobs,
+        List<(NotebookViewModel Notebook, SectionViewModel Section)> sectionJobs,
+        string format,
+        CancellationToken ct)
+    {
+        if (!IsRenderedFormat(format) || notebookJobs.Count == 0)
+            return (true, format);
+
+        var warningWindow = new RenderedExportWarningWindow(
+            format,
+            notebookJobs.Count,
+            sectionJobs.Count > 0)
+        {
+            Owner = this
+        };
+        warningWindow.ShowDialog();
+
+        switch (warningWindow.Choice)
+        {
+            case RenderedExportChoice.IndividualSections:
+                bool converted = await ConvertNotebookJobsToSectionsAsync(
+                    notebookJobs, sectionJobs, format, ct);
+                return (converted, format);
+
+            case RenderedExportChoice.OneNotePackage:
+                SelectFormat("onepkg");
+                return (true, "onepkg");
+
+            case RenderedExportChoice.WholeNotebook:
+                return (true, format);
+
+            default:
+                return (false, format);
+        }
+    }
+
+    private void SelectFormat(string format)
+    {
+        var item = FormatCombo.Items
+            .OfType<ComboBoxItem>()
+            .FirstOrDefault(candidate => string.Equals(
+                candidate.Tag?.ToString(), format, StringComparison.OrdinalIgnoreCase));
+
+        if (item != null)
+            FormatCombo.SelectedItem = item;
+    }
+
     private async void ExportButton_Click(object sender, RoutedEventArgs e)
     {
         if (_exportInProgress)
@@ -385,7 +535,22 @@ private async void ExportButton_Click(object sender, RoutedEventArgs e)
             if (format == "localbackup")
                 await RunLocalBackupAsync(destPath);
             else
-                await RunComExportAsync(notebookJobs!, sectionJobs!, destPath, format, _exportCts.Token);
+            {
+                var prepared = await ApplyRenderedExportGuardAsync(
+                    notebookJobs!, sectionJobs!, format, _exportCts.Token);
+
+                if (!prepared.Continue)
+                    return;
+
+                _exportCts.Token.ThrowIfCancellationRequested();
+                await RunComExportAsync(
+                    notebookJobs!, sectionJobs!, destPath, prepared.Format, _exportCts.Token);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            HideProgress();
+            ShowStatus("Export cancelled.", StatusKind.Warning);
         }
         finally
         {
@@ -401,7 +566,7 @@ private void CancelButton_Click(object sender, RoutedEventArgs e)
         if (!_exportInProgress) return;
 
         var confirm = MessageBox.Show(
-            "Do you really want to cancel the export?\n\nWarning: This will terminate OneNote and OneNoteHelper processes!",
+            "Do you really want to cancel the export?\n\nThe current export will stop without closing OneNote.",
             "Cancel Export",
             MessageBoxButton.YesNo,
             MessageBoxImage.Warning);
@@ -410,11 +575,7 @@ private void CancelButton_Click(object sender, RoutedEventArgs e)
 
         ShowStatus("Cancelling export...", StatusKind.Warning);
 
-        // Cancel via token
         _exportCts?.Cancel();
-
-        // Fallback: force-kill processes (mirrors Go CancelExport behaviour)
-        KillProcess("ONENOTE.EXE");
     }
 
     // ── Export implementations ───────────────────────────────────────────────
@@ -441,7 +602,9 @@ private async Task RunLocalBackupAsync(string destPath)
         catch (Exception ex)
         {
             HideProgress();
-            ShowStatus($"❌ Error during export: {ex.Message}", StatusKind.Error);
+            ShowStatus(
+                $"❌ {UserFacingError.Describe(ex, "The local backup export could not be completed.")}",
+                StatusKind.Error);
         }
     }
 
@@ -452,6 +615,8 @@ private async Task RunComExportAsync(
         string format,
         CancellationToken ct)
     {
+        ct.ThrowIfCancellationRequested();
+
         if (_service == null)
         {
             ShowStatus("OneNote Helper is not available. Please ensure OneNote Desktop is installed.", StatusKind.Error);
@@ -469,7 +634,7 @@ private async Task RunComExportAsync(
         // ── Notebook-level exports ────────────────────────────────────────────
         foreach (var nb in notebookJobs)
         {
-            if (ct.IsCancellationRequested) break;
+            ct.ThrowIfCancellationRequested();
             jobIndex++;
 
             var label    = $"Notebook {jobIndex}/{totalJobs}: {nb.Name}";
@@ -480,10 +645,17 @@ private async Task RunComExportAsync(
 
             try
             {
-                var result = await Task.Run(
-                    () => _service.ExportNotebook(nb.Id, destPath, format, progress, ct), ct);
+                var result = await _service.ExportNotebookAsync(
+                    nb.Id, destPath, format, progress, ct);
 
-                if (result.Success) { successCount++; messages.Add($"✓ {nb.Name}"); }
+                if (result.Success)
+                {
+                    successCount++;
+                    string retryNote = result.RecoveredAfterRetry
+                        ? " (recovered after COM retry)"
+                        : "";
+                    messages.Add($"✓ {nb.Name}{retryNote}");
+                }
                 else                { failCount++;    messages.Add($"✗ {nb.Name}: {result.Message}"); }
             }
             catch (OperationCanceledException)
@@ -495,7 +667,9 @@ private async Task RunComExportAsync(
             catch (Exception ex)
             {
                 failCount++;
-                messages.Add($"✗ {nb.Name}: {ex.Message}");
+                messages.Add(
+                    $"✗ {nb.Name}: " +
+                    UserFacingError.Describe(ex, "The export could not be completed."));
             }
 
             await Task.Delay(300, CancellationToken.None);
@@ -504,7 +678,7 @@ private async Task RunComExportAsync(
         // ── Section-level exports ─────────────────────────────────────────────
         foreach (var (nb, sec) in sectionJobs)
         {
-            if (ct.IsCancellationRequested) break;
+            ct.ThrowIfCancellationRequested();
             jobIndex++;
 
             var label    = $"Section {jobIndex}/{totalJobs}: {sec.Name}  ({nb.Name})";
@@ -515,10 +689,17 @@ private async Task RunComExportAsync(
 
             try
             {
-                var result = await Task.Run(
-                    () => _service.ExportSection(sec.Info, destPath, format, progress, ct), ct);
+                var result = await _service.ExportSectionAsync(
+                    sec.Info, destPath, format, progress, ct);
 
-                if (result.Success) { successCount++; messages.Add($"✓ {nb.Name}  /  {sec.Name}"); }
+                if (result.Success)
+                {
+                    successCount++;
+                    string retryNote = result.RecoveredAfterRetry
+                        ? " (recovered after COM retry)"
+                        : "";
+                    messages.Add($"✓ {nb.Name}  /  {sec.Name}{retryNote}");
+                }
                 else                { failCount++;    messages.Add($"✗ {nb.Name}  /  {sec.Name}: {result.Message}"); }
             }
             catch (OperationCanceledException)
@@ -530,7 +711,9 @@ private async Task RunComExportAsync(
             catch (Exception ex)
             {
                 failCount++;
-                messages.Add($"✗ {nb.Name}  /  {sec.Name}: {ex.Message}");
+                messages.Add(
+                    $"✗ {nb.Name}  /  {sec.Name}: " +
+                    UserFacingError.Describe(ex, "The export could not be completed."));
             }
 
             await Task.Delay(300, CancellationToken.None);
@@ -548,11 +731,11 @@ private async Task RunComExportAsync(
 
     // ── Utilities ────────────────────────────────────────────────────────────
 
-    private static void StartDialogWatcher(CancellationToken ct)
+    private void StartDialogWatcher(CancellationToken ct)
     {
         _ = Task.Run(() =>
         {
-            while (!ct.IsCancellationRequested)
+            while (!ct.IsCancellationRequested && _exportInProgress)
             {
                 try
                 {
@@ -586,24 +769,4 @@ private static void StartDialogWatcher(CancellationToken ct)
         });
     }
 
-    private static void KillProcess(string processName)
-    {
-        try
-        {
-            var psi = new ProcessStartInfo
-            {
-                FileName               = "taskkill",
-                Arguments              = $"/F /IM {processName}",
-                UseShellExecute        = false,
-                CreateNoWindow         = true,
-                RedirectStandardOutput = true
-            };
-            using var p = Process.Start(psi);
-            p?.WaitForExit(5000);
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine($"KillProcess({processName}): {ex.Message}");
-        }
-    }
 }
diff --git a/Models/Models.cs b/Models/Models.cs
index 83bf809..8bd727a 100644
--- a/Models/Models.cs
+++ b/Models/Models.cs
@@ -20,8 +20,9 @@ public class SectionInfo
     public string NotebookId   { get; set; } = "";
     public string NotebookName { get; set; } = "";
     public string NotebookPath { get; set; } = "";
-    public string GroupName    { get; set; } = ""; // empty when section is directly in notebook
-    public bool   IsCloud      { get; set; }
+    public string GroupName      { get; set; } = ""; // empty when section is directly in notebook
+    public string ExportFileStem { get; set; } = ""; // collision-safe; UI continues to show Name
+    public bool   IsCloud        { get; set; }
 }
 
 public class ExportResult
@@ -29,11 +30,12 @@ public class ExportResult
     public bool   Success      { get; set; }
     public string Message      { get; set; } = "";
     public string ExportedPath { get; set; } = "";
+    public int    AttemptCount { get; set; } = 1;
+    public bool   RecoveredAfterRetry { get; set; }
 }
 
 public class VersionInfo
 {
-    public string Version           { get; set; } = "2.0.0";
     public bool   OneNoteInstalled  { get; set; }
     public string OneNoteVersion    { get; set; } = "";
 }
diff --git a/OneNoteExporter.csproj b/OneNoteExporter.csproj
index 999f627..3502d10 100644
--- a/OneNoteExporter.csproj
+++ b/OneNoteExporter.csproj
@@ -12,7 +12,7 @@
 
     <AssemblyName>OneNoteExporter</AssemblyName>
     <RootNamespace>OneNoteExporter</RootNamespace>
-    <Version>1.1.0</Version>
+    <Version>1.2.0</Version>
     <ApplicationIcon>icon.ico</ApplicationIcon>
   </PropertyGroup>
 
diff --git a/README.md b/README.md
index e551a9e..d11dd59 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,9 @@
 # OneNote Backup Exporter
 
 A Windows desktop application to export OneNote notebooks to portable formats.  
-Talks directly to OneNote Desktop via the COM AP.
+Talks directly to OneNote Desktop via the COM API.
 
-![version](https://img.shields.io/badge/version-1.1.0-blueviolet?style=flat-square)
+![version](https://img.shields.io/badge/version-1.2.0-blueviolet?style=flat-square)
 ![platform](https://img.shields.io/badge/platform-Windows%2010%2F11-0078D7?style=flat-square&logo=windows&logoColor=white)
 ![license](https://img.shields.io/badge/license-MIT-brightgreen?style=flat-square)
 ![built with](https://img.shields.io/badge/built%20with-.NET%2010%20%2F%20WPF-512BD4?style=flat-square&logo=dotnet&logoColor=white)
@@ -20,9 +20,16 @@ Talks directly to OneNote Desktop via the COM AP.
 
 ## Download
 
-Go to [Releases](../../releases/latest) and download the latest
-`OneNoteBackupExporter_Setup_<version>.exe`. Run the installer, done. A matching
-`.sha256` file is included so the download can be verified.
+[Download the latest installer](https://github.com/jli-software/OneNoteBackupExporter/releases/latest/download/OneNoteBackupExporter_Setup.exe)
+or view the [latest release](../../releases/latest). The public asset names remain stable
+across releases:
+
+- `OneNoteBackupExporter_Setup.exe`
+- `OneNoteBackupExporter_Setup.exe.sha256`
+
+The matching [SHA-256 checksum](https://github.com/jli-software/OneNoteBackupExporter/releases/latest/download/OneNoteBackupExporter_Setup.exe.sha256)
+can be used to verify the download. The installed application version is available in the
+About dialog.
 
 ## Automated builds and releases
 
@@ -53,12 +60,16 @@ The Microsoft Store version of OneNote is not supported.
 | Format | Notes |
 |---|---|
 | OneNote Package (.onepkg) | Recommended. Full-fidelity, re-importable into OneNote. |
-| XPS Document (.xps) | Good layout preservation. |
-| PDF Document (.pdf) | Universal, slightly lower quality on complex pages. |
+| XPS Document (.xps) | Good layout preservation. Large whole notebooks can be split into safer per-section exports. |
+| PDF Document (.pdf) | Universal, slightly lower quality on complex pages. Large whole notebooks can be split into safer per-section exports. |
 | Local Backup Copy | Copies the raw backup folder from `%LOCALAPPDATA%\Microsoft\OneNote\16.0\Sicherung`. Fastest option, all notebooks at once. |
 
 ## Notes
 
 - Password-protected sections cannot be exported. Unlock them in OneNote first.
 - Cloud notebooks (OneDrive, SharePoint) must be synced before export. Large notebooks can take several minutes.
-- If PDF or XPS export times out on a large notebook, use the OneNote Package format instead.
+- OneNote does not expose notebook size through its COM interface. Before a whole-notebook
+  PDF/XPS export, the app therefore offers to export each section separately (recommended),
+  create a complete `.onepkg` backup, or consciously try the whole rendered export. Split
+  exports include all exportable, unlocked sections and preserve section groups as folders
+  to avoid filename collisions. Use `.onepkg` when a single complete backup is required.
diff --git a/RenderedExportWarningWindow.xaml b/RenderedExportWarningWindow.xaml
new file mode 100644
index 0000000..64c8697
--- /dev/null
+++ b/RenderedExportWarningWindow.xaml
@@ -0,0 +1,101 @@
+<Window x:Class="OneNoteExporter.RenderedExportWarningWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Icon="icon.ico"
+        Title="Large PDF/XPS export"
+        Width="560" Height="430"
+        MinWidth="520" MinHeight="410"
+        ResizeMode="NoResize"
+        ShowInTaskbar="False"
+        WindowStartupLocation="CenterOwner"
+        Background="{StaticResource BgPage}">
+
+    <Border Margin="18"
+            Padding="22"
+            Background="{StaticResource BgCard}"
+            BorderBrush="{StaticResource BorderColor}"
+            BorderThickness="1"
+            CornerRadius="8">
+        <Grid>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+                <RowDefinition Height="Auto"/>
+            </Grid.RowDefinitions>
+
+            <TextBlock Grid.Row="0"
+                       x:Name="TitleText"
+                       FontSize="18"
+                       FontWeight="Bold"
+                       Foreground="{StaticResource PrimaryBlue}"/>
+
+            <TextBlock Grid.Row="1"
+                       x:Name="ExplanationText"
+                       Margin="0,10,0,14"
+                       TextWrapping="Wrap"
+                       FontSize="13"
+                       LineHeight="19"
+                       Foreground="{StaticResource TextPrimary}"/>
+
+            <Border Grid.Row="2"
+                    Padding="12,10"
+                    Background="{StaticResource WarningBg}"
+                    BorderBrush="{StaticResource WarningBorder}"
+                    BorderThickness="1"
+                    CornerRadius="5">
+                <TextBlock Text="OneNote does not report a notebook's size through its COM interface, so the app cannot reliably detect a 300 MB notebook before export."
+                           TextWrapping="Wrap"
+                           FontSize="12"
+                           Foreground="{StaticResource WarningFg}"/>
+            </Border>
+
+            <StackPanel Grid.Row="3" Margin="0,16,0,0">
+                <Button x:Name="SectionsButton"
+                        Style="{StaticResource PrimaryButtonStyle}"
+                        IsDefault="True"
+                        HorizontalContentAlignment="Left"
+                        Padding="14,10"
+                        Click="SectionsButton_Click">
+                    <StackPanel>
+                        <TextBlock Text="Recommended: Export as individual sections"
+                                   FontWeight="SemiBold"/>
+                        <TextBlock x:Name="SectionsDescriptionText"
+                                   Margin="0,3,0,0"
+                                   FontSize="11"
+                                   FontWeight="Normal"
+                                   TextWrapping="Wrap"/>
+                    </StackPanel>
+                </Button>
+
+                <Button x:Name="OneNotePackageButton"
+                        Content="Create a complete OneNote package (.onepkg) instead"
+                        Style="{StaticResource GrayButtonStyle}"
+                        Margin="0,8,0,0"
+                        HorizontalContentAlignment="Left"
+                        Padding="14,9"
+                        Click="OneNotePackageButton_Click"/>
+
+                <Button x:Name="WholeNotebookButton"
+                        Margin="0,8,0,0"
+                        HorizontalAlignment="Left"
+                        Padding="0"
+                        Background="Transparent"
+                        BorderThickness="0"
+                        Foreground="{StaticResource TextSecondary}"
+                        Cursor="Hand"
+                        Click="WholeNotebookButton_Click"/>
+            </StackPanel>
+
+            <Button Grid.Row="4"
+                    Content="Cancel"
+                    Style="{StaticResource SmallButtonStyle}"
+                    Width="90"
+                    Margin="0,16,0,0"
+                    HorizontalAlignment="Right"
+                    IsCancel="True"
+                    Click="CancelButton_Click"/>
+        </Grid>
+    </Border>
+</Window>
diff --git a/RenderedExportWarningWindow.xaml.cs b/RenderedExportWarningWindow.xaml.cs
new file mode 100644
index 0000000..d1f82e1
--- /dev/null
+++ b/RenderedExportWarningWindow.xaml.cs
@@ -0,0 +1,70 @@
+using System.Windows;
+
+namespace OneNoteExporter;
+
+public enum RenderedExportChoice
+{
+    Cancel,
+    IndividualSections,
+    OneNotePackage,
+    WholeNotebook
+}
+
+public partial class RenderedExportWarningWindow : Window
+{
+    public RenderedExportChoice Choice { get; private set; } = RenderedExportChoice.Cancel;
+
+    public RenderedExportWarningWindow(
+        string exportFormat,
+        int notebookCount,
+        bool hasSelectedSections)
+    {
+        InitializeComponent();
+
+        string formatName = exportFormat.Equals("pdf", StringComparison.OrdinalIgnoreCase)
+            ? "PDF"
+            : "XPS";
+        string notebookLabel = notebookCount == 1
+            ? "the selected notebook"
+            : $"the {notebookCount} selected notebooks";
+
+        TitleText.Text = $"Whole-notebook {formatName} exports can fail when they are large";
+        ExplanationText.Text =
+            $"OneNote Desktop must render {notebookLabel} through its own {formatName} engine. " +
+            "For large notebooks this engine can time out or disconnect from the app.";
+        SectionsDescriptionText.Text =
+            $"The app loads all exportable sections automatically and creates one {formatName} " +
+            "file per section. Locked sections are not included. " +
+            "Smaller render jobs are significantly more reliable.";
+        WholeNotebookButton.Content =
+            $"Try the whole {formatName} export anyway (may fail for large notebooks)";
+
+        if (hasSelectedSections)
+        {
+            OneNotePackageButton.IsEnabled = false;
+            OneNotePackageButton.Content =
+                "OneNote package requires no individually selected sections";
+            OneNotePackageButton.ToolTip =
+                "Cancel, deselect the individual sections, and try again to create a complete package.";
+        }
+    }
+
+    private void Complete(RenderedExportChoice choice)
+    {
+        Choice = choice;
+        DialogResult = choice != RenderedExportChoice.Cancel;
+        Close();
+    }
+
+    private void SectionsButton_Click(object sender, RoutedEventArgs e)
+        => Complete(RenderedExportChoice.IndividualSections);
+
+    private void OneNotePackageButton_Click(object sender, RoutedEventArgs e)
+        => Complete(RenderedExportChoice.OneNotePackage);
+
+    private void WholeNotebookButton_Click(object sender, RoutedEventArgs e)
+        => Complete(RenderedExportChoice.WholeNotebook);
+
+    private void CancelButton_Click(object sender, RoutedEventArgs e)
+        => Complete(RenderedExportChoice.Cancel);
+}
diff --git a/Services/OneNoteComWorker.cs b/Services/OneNoteComWorker.cs
new file mode 100644
index 0000000..7cfa72d
--- /dev/null
+++ b/Services/OneNoteComWorker.cs
@@ -0,0 +1,324 @@
+using System.Windows.Threading;
+using OneNoteExporter.Models;
+
+namespace OneNoteExporter.Services;
+
+/// <summary>
+/// Owns the OneNote COM service on a dedicated STA thread. All operations are
+/// dispatched through the thread's message pump and therefore run serially.
+/// </summary>
+public sealed class OneNoteComWorker : IDisposable
+{
+    private const int MaxExportAttempts = 2;
+    private static readonly TimeSpan ExportRetryDelay = TimeSpan.FromSeconds(5);
+
+    private readonly Thread _thread;
+    private readonly SemaphoreSlim _operationGate = new(1, 1);
+    private readonly TaskCompletionSource _started =
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private readonly TaskCompletionSource _stopped =
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    private Dispatcher? _dispatcher;
+    private OneNoteService? _service;
+    private int _disposeState;
+
+    private OneNoteComWorker()
+    {
+        _thread = new Thread(RunMessageLoop)
+        {
+            IsBackground = true,
+            Name = "OneNote COM STA Worker"
+        };
+        _thread.SetApartmentState(ApartmentState.STA);
+        _thread.Start();
+    }
+
+    public static async Task<OneNoteComWorker> CreateAsync()
+    {
+        var worker = new OneNoteComWorker();
+
+        try
+        {
+            await worker._started.Task.ConfigureAwait(false);
+            return worker;
+        }
+        catch
+        {
+            worker.Dispose();
+            throw;
+        }
+    }
+
+    public Task<VersionInfo> GetVersionInfoAsync(CancellationToken ct = default)
+        => RunSerializedAsync(
+            () => InvokeAsync(service => service.GetVersionInfo(), ct), ct);
+
+    public Task<List<NotebookInfo>> GetNotebooksAsync(CancellationToken ct = default)
+        => RunSerializedAsync(
+            () => InvokeAsync(service => service.GetNotebooks(), ct), ct);
+
+    public Task<List<SectionInfo>> GetSectionsAsync(
+        string notebookId,
+        CancellationToken ct = default)
+        => RunSerializedAsync(
+            () => InvokeAsync(service => service.GetSections(notebookId), ct), ct);
+
+    public Task<ExportResult> ExportNotebookAsync(
+        string notebookId,
+        string destinationPath,
+        string exportFormat = "onepkg",
+        IProgress<string>? progress = null,
+        CancellationToken ct = default)
+        => RunSerializedAsync(
+            () => ExportAsync(
+                service => service.BeginNotebookExport(
+                    notebookId, destinationPath, exportFormat, progress),
+                exportFormat,
+                progress,
+                ct),
+            ct);
+
+    public Task<ExportResult> ExportSectionAsync(
+        SectionInfo section,
+        string destinationPath,
+        string exportFormat = "onepkg",
+        IProgress<string>? progress = null,
+        CancellationToken ct = default)
+        => RunSerializedAsync(
+            () => ExportAsync(
+                service => service.BeginSectionExport(
+                    section, destinationPath, exportFormat, progress),
+                exportFormat,
+                progress,
+                ct),
+            ct);
+
+    private async Task<ExportResult> ExportAsync(
+        Func<OneNoteService, PendingExport> beginExport,
+        string exportFormat,
+        IProgress<string>? progress,
+        CancellationToken ct)
+    {
+        bool connectionRecoveryAttempted = false;
+
+        for (int attempt = 1; attempt <= MaxExportAttempts; attempt++)
+        {
+            try
+            {
+                var pending = await InvokeAsync(beginExport, ct).ConfigureAwait(false);
+                var result = await OneNoteService.WaitForFileAsync(
+                        pending.StagingPath, pending.IsCloud, progress, ct)
+                    .ConfigureAwait(false);
+
+                if (!result.Success)
+                {
+                    result.Message +=
+                        " The existing backup was not changed. A temporary staging " +
+                        "file may be retained until automatic cleanup.";
+                    return result;
+                }
+
+                progress?.Report("Finalizing export and replacing the previous backup...");
+                var finalResult = OneNoteService.FinalizeExport(pending, result);
+                finalResult.AttemptCount = attempt;
+                finalResult.RecoveredAfterRetry = attempt > 1;
+
+                if (finalResult.RecoveredAfterRetry)
+                {
+                    finalResult.Message +=
+                        $" Export succeeded after OneNote communication recovery " +
+                        $"(attempt {attempt}/{MaxExportAttempts}).";
+                }
+
+                return finalResult;
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex) when (
+                attempt < MaxExportAttempts &&
+                OneNoteService.IsRecoverableComFailure(ex))
+            {
+                string failure = OneNoteService.DescribeComFailure(ex);
+                bool resetConnection = OneNoteService.RequiresComConnectionReset(ex);
+
+                progress?.Report(
+                    $"OneNote communication failed: {failure}. " +
+                    $"Automatic retry {attempt + 1}/{MaxExportAttempts} in " +
+                    $"{ExportRetryDelay.TotalSeconds:0} seconds...");
+
+                await Task.Delay(ExportRetryDelay, ct).ConfigureAwait(false);
+
+                if (resetConnection)
+                {
+                    progress?.Report("Reconnecting to OneNote Desktop...");
+
+                    try
+                    {
+                        await RecreateServiceAsync(ct).ConfigureAwait(false);
+                        connectionRecoveryAttempted = true;
+                        progress?.Report(
+                            $"OneNote connection restored. Retrying export " +
+                            $"({attempt + 1}/{MaxExportAttempts})...");
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (Exception recoveryException)
+                    {
+                        return OneNoteService.CreateConnectionRecoveryFailure(
+                            ex, recoveryException);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                return OneNoteService.CreateExportFailure(
+                    ex, attempt, exportFormat, connectionRecoveryAttempted);
+            }
+        }
+
+        throw new InvalidOperationException("The export retry loop ended unexpectedly.");
+    }
+
+    private async Task RecreateServiceAsync(CancellationToken ct)
+        => _ = await InvokeOnWorkerAsync(
+            () =>
+            {
+                var previousService = _service;
+                var candidateService = new OneNoteService();
+
+                try
+                {
+                    candidateService.ValidateConnection();
+                }
+                catch
+                {
+                    candidateService.Dispose();
+                    throw;
+                }
+
+                _service = candidateService;
+                previousService?.Dispose();
+                return true;
+            },
+            ct).ConfigureAwait(false);
+
+    private async Task<T> RunSerializedAsync<T>(
+        Func<Task<T>> operation,
+        CancellationToken ct)
+    {
+        ObjectDisposedException.ThrowIf(
+            Volatile.Read(ref _disposeState) != 0,
+            this);
+
+        await _operationGate.WaitAsync(ct).ConfigureAwait(false);
+
+        try
+        {
+            ObjectDisposedException.ThrowIf(
+                Volatile.Read(ref _disposeState) != 0,
+                this);
+            return await operation().ConfigureAwait(false);
+        }
+        finally
+        {
+            _operationGate.Release();
+        }
+    }
+
+    private async Task<T> InvokeAsync<T>(
+        Func<OneNoteService, T> operation,
+        CancellationToken ct)
+        => await InvokeOnWorkerAsync(
+                () => operation(_service
+                    ?? throw new InvalidOperationException("OneNote is not initialized.")),
+                ct)
+            .ConfigureAwait(false);
+
+    private async Task<T> InvokeOnWorkerAsync<T>(
+        Func<T> operation,
+        CancellationToken ct)
+    {
+        ObjectDisposedException.ThrowIf(
+            Volatile.Read(ref _disposeState) != 0,
+            this);
+
+        await _started.Task.ConfigureAwait(false);
+
+        var dispatcher = _dispatcher
+            ?? throw new InvalidOperationException("The OneNote COM worker did not start.");
+
+        var dispatcherOperation = dispatcher.InvokeAsync(
+            () =>
+            {
+                ct.ThrowIfCancellationRequested();
+                return operation();
+            },
+            DispatcherPriority.Normal,
+            ct);
+
+        return await dispatcherOperation.Task.ConfigureAwait(false);
+    }
+
+    private void RunMessageLoop()
+    {
+        _dispatcher = Dispatcher.CurrentDispatcher;
+
+        try
+        {
+            _service = new OneNoteService();
+
+            if (Volatile.Read(ref _disposeState) != 0)
+            {
+                _started.TrySetCanceled();
+                return;
+            }
+
+            _started.TrySetResult();
+            Dispatcher.Run();
+        }
+        catch (OperationCanceledException) when (Volatile.Read(ref _disposeState) != 0)
+        {
+            _started.TrySetCanceled();
+        }
+        catch (Exception ex)
+        {
+            _started.TrySetException(ex);
+        }
+        finally
+        {
+            _service?.Dispose();
+            _service = null;
+            _stopped.TrySetResult();
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Interlocked.CompareExchange(ref _disposeState, 1, 0) != 0)
+        {
+            _stopped.Task.GetAwaiter().GetResult();
+            return;
+        }
+
+        _operationGate.Wait();
+
+        try
+        {
+            var dispatcher = _dispatcher;
+            if (dispatcher != null && !dispatcher.HasShutdownStarted)
+                dispatcher.BeginInvokeShutdown(DispatcherPriority.Send);
+
+            if (Thread.CurrentThread != _thread)
+                _stopped.Task.GetAwaiter().GetResult();
+        }
+        finally
+        {
+            _operationGate.Release();
+        }
+    }
+}
diff --git a/Services/OneNoteService.cs b/Services/OneNoteService.cs
index 8c86afc..25fa893 100644
--- a/Services/OneNoteService.cs
+++ b/Services/OneNoteService.cs
@@ -1,29 +1,30 @@
-using System.Diagnostics;
 using System.IO;
 using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
 using System.Xml.Linq;
 using Microsoft.Office.Interop.OneNote;
+using OneNoteExporter.Helpers;
 using OneNoteExporter.Models;
 
 namespace OneNoteExporter.Services;
 
+internal sealed record PendingExport(
+    string StagingPath,
+    string FinalPath,
+    bool IsCloud);
+
 /// <summary>
-/// Wraps the OneNote COM API. Must be constructed and called on a background thread
-/// (via Task.Run) because COM calls and Thread.Sleep block.
-/// Dispose() must be called when the application closes.
+/// Synchronous OneNote COM API implementation owned by <see cref="OneNoteComWorker"/>.
+/// Construction, all calls and disposal must stay on that worker's STA thread.
 /// </summary>
-public class OneNoteService : IDisposable
+internal sealed class OneNoteService : IDisposable
 {
     private Application? _oneNote;
     private bool _disposed = false;
-    private bool _oneNoteWasRunning = false;
-    private bool _oneNoteClosedAttempted = false;
 
     public OneNoteService()
     {
-        var oneNoteProcesses = Process.GetProcessesByName("ONENOTE");
-        _oneNoteWasRunning = oneNoteProcesses.Length > 0;
-
         try
         {
             _oneNote = new Application();
@@ -86,174 +87,143 @@ public List<NotebookInfo> GetNotebooks()
         return notebooks;
     }
 
+    public void ValidateConnection()
+    {
+        if (_oneNote == null)
+            throw new InvalidOperationException("OneNote is not initialized.");
+
+        _oneNote.GetHierarchy("", HierarchyScope.hsNotebooks, out _);
+    }
+
     /// <summary>
-    /// Exports a single notebook. Blocks the calling thread until finished.
-    /// Call via Task.Run from the UI layer.
+    /// Starts a notebook export and returns as soon as OneNote accepted the
+    /// publish request. File completion is monitored outside the STA thread.
     /// </summary>
-    public ExportResult ExportNotebook(
+    public PendingExport BeginNotebookExport(
         string notebookId,
         string destinationPath,
         string exportFormat = "onepkg",
-        IProgress<string>? progress = null,
-        CancellationToken ct = default)
+        IProgress<string>? progress = null)
     {
         if (_oneNote == null)
             throw new InvalidOperationException("OneNote is not initialized.");
 
-        TryCloseOneNoteGracefully(progress);
+        // Get notebook name and path from hierarchy
+        _oneNote.GetHierarchy(notebookId, HierarchyScope.hsSelf, out string xml);
+        var xdoc         = XDocument.Parse(xml);
+        var notebookName = xdoc.Root?.Attribute("name")?.Value ?? "Notebook";
+        var notebookPath = xdoc.Root?.Attribute("path")?.Value ?? "";
 
-        var result = new ExportResult();
+        bool isCloud = notebookPath.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
+                       notebookPath.StartsWith("http://",  StringComparison.OrdinalIgnoreCase);
 
-        try
-        {
-            // Get notebook name and path from hierarchy
-            _oneNote.GetHierarchy(notebookId, HierarchyScope.hsSelf, out string xml);
-            var xdoc         = XDocument.Parse(xml);
-            var notebookName = xdoc.Root?.Attribute("name")?.Value ?? "Notebook";
-            var notebookPath = xdoc.Root?.Attribute("path")?.Value ?? "";
-
-            bool isCloud = notebookPath.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
-                           notebookPath.StartsWith("http://",  StringComparison.OrdinalIgnoreCase);
-
-            progress?.Report($"Exporting: {notebookName} (format: {exportFormat})");
-
-            // Determine file extension and PublishFormat
-            string fileExtension = exportFormat.ToLowerInvariant() switch
-            {
-                "xps" => ".xps",
-                "pdf" => ".pdf",
-                _     => ".onepkg"
-            };
-
-            PublishFormat publishFormat = exportFormat.ToLowerInvariant() switch
-            {
-                "xps" => PublishFormat.pfXPS,
-                "pdf" => PublishFormat.pfPDF,
-                _     => PublishFormat.pfOneNotePackage
-            };
+        progress?.Report($"Exporting: {notebookName} (format: {exportFormat})");
 
-            // Sanitize filename
-            var sanitizedName = string.Join("_", notebookName.Split(Path.GetInvalidFileNameChars()));
-            var fullPath      = Path.Combine(destinationPath, sanitizedName + fileExtension);
+        string fileExtension = exportFormat.ToLowerInvariant() switch
+        {
+            "xps" => ".xps",
+            "pdf" => ".pdf",
+            _     => ".onepkg"
+        };
 
-            Directory.CreateDirectory(destinationPath);
+        PublishFormat publishFormat = exportFormat.ToLowerInvariant() switch
+        {
+            "xps" => PublishFormat.pfXPS,
+            "pdf" => PublishFormat.pfPDF,
+            _     => PublishFormat.pfOneNotePackage
+        };
 
-            // Open notebook (required for cloud notebooks)
-            _oneNote.OpenHierarchy(notebookPath, "", out string openedId, CreateFileType.cftNone);
+        var sanitizedName = string.Join("_", notebookName.Split(Path.GetInvalidFileNameChars()));
+        var finalPath     = Path.Combine(destinationPath, sanitizedName + fileExtension);
+        var stagingPath   = CreateStagingPath(destinationPath, sanitizedName, fileExtension);
 
-            // Remove existing file so WaitForFile doesn't detect the old file as done
-            if (File.Exists(fullPath))
-            {
-                progress?.Report("Removing previous export file...");
-                File.Delete(fullPath);
-            }
+        Directory.CreateDirectory(destinationPath);
+        CleanupStaleStagingFiles(
+            destinationPath, sanitizedName, fileExtension, DateTime.UtcNow.AddDays(-2));
 
-            // Trigger the export (Publish returns immediately; OneNote writes async)
-            progress?.Report("OneNote is writing in the background...");
-            _oneNote.Publish(openedId, fullPath, publishFormat, "");
+        _oneNote.OpenHierarchy(notebookPath, "", out string openedId, CreateFileType.cftNone);
 
-            // Wait for the file to appear and stabilise
-            result = WaitForFile(fullPath, isCloud, progress, ct);
+        progress?.Report("OneNote is writing to a protected staging file...");
 
-            if (result.Success)
-                result.ExportedPath = fullPath;
-        }
-        catch (OperationCanceledException)
-        {
-            result.Success = false;
-            result.Message = "Export cancelled.";
-        }
-        catch (UnauthorizedAccessException ex)
+        try
         {
-            result.Success = false;
-            result.Message = $"Access denied: {ex.Message}";
+            _oneNote.Publish(openedId, stagingPath, publishFormat, "");
         }
-        catch (COMException ex) when (ex.HResult == unchecked((int)0x8004201A))
+        catch
         {
-            result.Success = false;
-            result.Message = "OneNote Error 0x8004201A: Cannot export. " +
-                             "The notebook may have password-protected sections or be offline.";
+            TryDeleteStagingFile(stagingPath);
+            throw;
         }
-        catch (COMException ex) when (ex.HResult == unchecked((int)0x800706BA))
+
+        return new PendingExport(stagingPath, finalPath, isCloud);
+    }
+
+    private static string CreateStagingPath(
+        string directory,
+        string sanitizedName,
+        string fileExtension)
+        => Path.Combine(
+            directory,
+            $".{sanitizedName}.{Guid.NewGuid():N}.partial{fileExtension}");
+
+    private static void TryDeleteStagingFile(string stagingPath)
+    {
+        try
         {
-            result.Success = false;
-            result.Message = "OneNote RPC timeout (0x800706BA). " +
-                             "Large notebooks may fail with PDF/XPS. Try .onepkg format instead.";
+            if (File.Exists(stagingPath))
+                File.Delete(stagingPath);
         }
-        catch (COMException ex)
+        catch (IOException)
         {
-            result.Success = false;
-            result.Message = $"OneNote COM error 0x{ex.HResult:X}: {ex.Message}";
+            // OneNote may still hold the file after a broken RPC call. A unique
+            // staging path keeps later attempts and the last good export safe.
         }
-        catch (Exception ex)
+        catch (UnauthorizedAccessException)
         {
-            result.Success = false;
-            result.Message = $"Error during export: {ex.Message}";
+            // Preserve the original export failure; cleanup can happen later.
         }
-
-        return result;
     }
 
-    /// <summary>
-    /// Exports all notebooks sequentially. Calls ExportNotebook for each.
-    /// </summary>
-    public ExportResult ExportAllNotebooks(
-        string destinationPath,
-        string exportFormat = "onepkg",
-        IProgress<string>? progress = null,
-        CancellationToken ct = default)
+    private static void CleanupStaleStagingFiles(
+        string directory,
+        string sanitizedName,
+        string fileExtension,
+        DateTime olderThanUtc)
     {
-        var result       = new ExportResult { Success = true };
-        int exported     = 0, failed = 0;
-        var messages     = new List<string>();
+        string searchPattern = $".{sanitizedName}.*.partial{fileExtension}";
 
         try
         {
-            var notebooks = GetNotebooks();
-            progress?.Report($"Starting export of {notebooks.Count} notebook(s)...");
-
-            foreach (var nb in notebooks)
+            foreach (string path in Directory.EnumerateFiles(directory, searchPattern))
             {
-                ct.ThrowIfCancellationRequested();
-
-                progress?.Report($"Exporting {exported + failed + 1}/{notebooks.Count}: {nb.Name}");
-
-                var r = ExportNotebook(nb.Id, destinationPath, exportFormat, progress, ct);
-
-                if (r.Success)
+                try
                 {
-                    exported++;
-                    messages.Add($"✓ {nb.Name}");
+                    if (File.GetLastWriteTimeUtc(path) < olderThanUtc)
+                        File.Delete(path);
                 }
-                else
+                catch (IOException)
+                {
+                    // An active or locked OneNote write must never be disturbed.
+                }
+                catch (UnauthorizedAccessException)
                 {
-                    failed++;
-                    messages.Add($"✗ {nb.Name}: {r.Message}");
+                    // Cleanup is best-effort and must not prevent an export.
                 }
             }
-
-            result.Success      = failed == 0;
-            result.Message      = $"Export completed: {exported} successful, {failed} failed\n\n" +
-                                   string.Join("\n", messages);
-            result.ExportedPath = destinationPath;
         }
-        catch (OperationCanceledException)
+        catch (IOException)
         {
-            result.Success = false;
-            result.Message = "Export cancelled.";
+            // Directory enumeration is best-effort.
         }
-        catch (Exception ex)
+        catch (UnauthorizedAccessException)
         {
-            result.Success = false;
-            result.Message = $"Fatal export error: {ex.Message}";
+            // The export itself will provide the actionable permission error.
         }
-
-        return result;
     }
 
     /// <summary>
     /// Returns all exportable sections in a notebook (including those inside section groups).
-    /// Skips encrypted and recycle-bin entries. Call via Task.Run from the UI layer.
+    /// Skips encrypted and recycle-bin entries. Called by OneNoteComWorker on its STA thread.
     /// </summary>
     public List<SectionInfo> GetSections(string notebookId)
     {
@@ -277,113 +247,128 @@ public List<SectionInfo> GetSections(string notebookId)
         if (ns == null) return sections;
 
         CollectSections(xdoc.Root!, ns, notebookId, nbName, nbPath, isCloud, "", sections);
+        AssignCollisionSafeExportFileStems(sections);
         return sections;
     }
 
     /// <summary>
-    /// Exports a single section. Blocks the calling thread until finished.
-    /// Sections are written into a notebook-named subfolder to avoid filename collisions.
-    /// Call via Task.Run from the UI layer.
+    /// Starts a section export and returns as soon as OneNote accepted the
+    /// publish request. File completion is monitored outside the STA thread.
     /// </summary>
-    public ExportResult ExportSection(
+    public PendingExport BeginSectionExport(
         SectionInfo section,
         string destinationPath,
         string exportFormat = "onepkg",
-        IProgress<string>? progress = null,
-        CancellationToken ct = default)
+        IProgress<string>? progress = null)
     {
         if (_oneNote == null)
             throw new InvalidOperationException("OneNote is not initialized.");
 
-        TryCloseOneNoteGracefully(progress);
-
-        var result = new ExportResult();
+        progress?.Report($"Exporting section: {section.Name} (format: {exportFormat})");
 
-        try
+        string fileExtension = exportFormat.ToLowerInvariant() switch
         {
-            progress?.Report($"Exporting section: {section.Name} (format: {exportFormat})");
-
-            string fileExtension = exportFormat.ToLowerInvariant() switch
-            {
-                "xps" => ".xps",
-                "pdf" => ".pdf",
-                _     => ".onepkg"
-            };
-
-            PublishFormat publishFormat = exportFormat.ToLowerInvariant() switch
-            {
-                "xps" => PublishFormat.pfXPS,
-                "pdf" => PublishFormat.pfPDF,
-                _     => PublishFormat.pfOneNotePackage
-            };
-
-            // Sections go into a notebook-named subfolder to prevent filename clashes
-            var sanitizedNb  = string.Join("_", section.NotebookName.Split(Path.GetInvalidFileNameChars()));
-            var sanitizedSec = string.Join("_", section.Name.Split(Path.GetInvalidFileNameChars()));
-            var notebookDir  = Path.Combine(destinationPath, sanitizedNb);
-            var fullPath     = Path.Combine(notebookDir, sanitizedSec + fileExtension);
+            "xps" => ".xps",
+            "pdf" => ".pdf",
+            _     => ".onepkg"
+        };
 
-            Directory.CreateDirectory(notebookDir);
+        PublishFormat publishFormat = exportFormat.ToLowerInvariant() switch
+        {
+            "xps" => PublishFormat.pfXPS,
+            "pdf" => PublishFormat.pfPDF,
+            _     => PublishFormat.pfOneNotePackage
+        };
 
-            // Open the parent notebook (required before Publish on a section within it)
-            progress?.Report("Opening parent notebook...");
-            _oneNote.OpenHierarchy(section.NotebookPath, "", out _, CreateFileType.cftNone);
+        // Preserve section-group folders and use the collision-safe stem assigned
+        // while loading the full hierarchy, so split exports never overwrite peers.
+        var sanitizedNb  = string.Join("_", section.NotebookName.Split(Path.GetInvalidFileNameChars()));
+        var sanitizedSec = string.IsNullOrWhiteSpace(section.ExportFileStem)
+            ? SanitizeFileName(section.Name)
+            : section.ExportFileStem;
+        var notebookDir  = Path.Combine(destinationPath, sanitizedNb);
+        var sectionDir   = BuildSectionDirectory(notebookDir, section.GroupName);
+        var finalPath    = Path.Combine(sectionDir, sanitizedSec + fileExtension);
+        var stagingPath  = CreateStagingPath(sectionDir, sanitizedSec, fileExtension);
 
-            if (File.Exists(fullPath))
-            {
-                progress?.Report("Removing previous export file...");
-                File.Delete(fullPath);
-            }
+        Directory.CreateDirectory(sectionDir);
+        CleanupStaleStagingFiles(
+            sectionDir, sanitizedSec, fileExtension, DateTime.UtcNow.AddDays(-2));
 
-            progress?.Report("OneNote is writing in the background...");
-            _oneNote.Publish(section.Id, fullPath, publishFormat, "");
+        progress?.Report("Opening parent notebook...");
+        _oneNote.OpenHierarchy(section.NotebookPath, "", out _, CreateFileType.cftNone);
 
-            result = WaitForFile(fullPath, section.IsCloud, progress, ct);
+        progress?.Report("OneNote is writing to a protected staging file...");
 
-            if (result.Success)
-                result.ExportedPath = fullPath;
-        }
-        catch (OperationCanceledException)
-        {
-            result.Success = false;
-            result.Message = "Export cancelled.";
-        }
-        catch (UnauthorizedAccessException ex)
-        {
-            result.Success = false;
-            result.Message = $"Access denied: {ex.Message}";
-        }
-        catch (COMException ex) when (ex.HResult == unchecked((int)0x8004201A))
+        try
         {
-            result.Success = false;
-            result.Message = "Cannot export section (0x8004201A). It may be password-protected or offline.";
+            _oneNote.Publish(section.Id, stagingPath, publishFormat, "");
         }
-        catch (COMException ex) when (ex.HResult == unchecked((int)0x800706BA))
+        catch
         {
-            result.Success = false;
-            result.Message = "RPC timeout (0x800706BA). Try .onepkg format.";
+            TryDeleteStagingFile(stagingPath);
+            throw;
         }
-        catch (COMException ex)
+
+        return new PendingExport(stagingPath, finalPath, section.IsCloud);
+    }
+
+    private static string BuildSectionDirectory(string notebookDirectory, string groupName)
+    {
+        string currentDirectory = notebookDirectory;
+
+        foreach (string groupPart in groupName.Split(
+                     " / ", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
         {
-            result.Success = false;
-            result.Message = $"COM error 0x{ex.HResult:X}: {ex.Message}";
+            string sanitizedGroup = string.Join(
+                "_", groupPart.Split(Path.GetInvalidFileNameChars()));
+            currentDirectory = Path.Combine(currentDirectory, sanitizedGroup);
         }
-        catch (Exception ex)
+
+        return currentDirectory;
+    }
+
+    /// <summary>
+    /// Keeps normal section filenames readable, but adds a stable short ID only when
+    /// two sections would resolve to the same case-insensitive Windows path after
+    /// sanitizing their group and section names.
+    /// </summary>
+    private static void AssignCollisionSafeExportFileStems(List<SectionInfo> sections)
+    {
+        foreach (var section in sections)
+            section.ExportFileStem = SanitizeFileName(section.Name);
+
+        var collisions = sections
+            .GroupBy(GetSanitizedSectionRelativePath, StringComparer.OrdinalIgnoreCase)
+            .Where(group => group.Count() > 1);
+
+        foreach (var collision in collisions)
         {
-            result.Success = false;
-            result.Message = $"Error: {ex.Message}";
+            foreach (var section in collision)
+            {
+                byte[] hash = SHA256.HashData(Encoding.UTF8.GetBytes(section.Id));
+                string stableSuffix = Convert.ToHexString(hash.AsSpan(0, 4)).ToLowerInvariant();
+                section.ExportFileStem = $"{section.ExportFileStem}__{stableSuffix}";
+            }
         }
+    }
 
-        return result;
+    private static string GetSanitizedSectionRelativePath(SectionInfo section)
+    {
+        string directory = BuildSectionDirectory("", section.GroupName);
+        return Path.Combine(directory, section.ExportFileStem);
     }
 
+    private static string SanitizeFileName(string name)
+        => string.Join("_", name.Split(Path.GetInvalidFileNameChars()));
+
     // ── Private helpers ──────────────────────────────────────────────────────
 
     /// <summary>
     /// Polls until the exported file exists and its size has been stable for 10 seconds.
     /// Cloud notebooks get a 30-minute timeout; local notebooks get 20 minutes.
     /// </summary>
-    private static ExportResult WaitForFile(
+    internal static async Task<ExportResult> WaitForFileAsync(
         string fullPath,
         bool isCloud,
         IProgress<string>? progress,
@@ -397,7 +382,7 @@ private static ExportResult WaitForFile(
         long fileSize        = 0;
 
         // Initial wait – give OneNote a moment to start writing
-        if (ct.WaitHandle.WaitOne(checkIntervalMs)) ct.ThrowIfCancellationRequested();
+        await Task.Delay(checkIntervalMs, ct).ConfigureAwait(false);
 
         for (int i = 0; i < maxAttempts; i++)
         {
@@ -447,7 +432,7 @@ private static ExportResult WaitForFile(
                     progress?.Report($"Waiting for file creation... ({i * checkIntervalMs / 1000}s)");
             }
 
-            if (ct.WaitHandle.WaitOne(checkIntervalMs)) ct.ThrowIfCancellationRequested();
+            await Task.Delay(checkIntervalMs, ct).ConfigureAwait(false);
         }
 
         // Timed out
@@ -463,6 +448,156 @@ private static ExportResult WaitForFile(
         };
     }
 
+    internal static ExportResult FinalizeExport(
+        PendingExport pending,
+        ExportResult result)
+    {
+        File.Move(pending.StagingPath, pending.FinalPath, overwrite: true);
+        result.ExportedPath = pending.FinalPath;
+        return result;
+    }
+
+    internal static bool IsRecoverableComFailure(Exception exception)
+        => exception is COMException ex && ex.HResult is
+            unchecked((int)0x800706BA) or // RPC_S_SERVER_UNAVAILABLE
+            unchecked((int)0x80010108) or // RPC_E_DISCONNECTED
+            unchecked((int)0x800401FD) or // CO_E_OBJNOTCONNECTED
+            unchecked((int)0x8001010A) or // RPC_E_SERVERCALL_RETRYLATER
+            unchecked((int)0x80010001);   // RPC_E_CALL_REJECTED
+
+    internal static bool RequiresComConnectionReset(Exception exception)
+        => exception is COMException ex && ex.HResult is
+            unchecked((int)0x800706BA) or
+            unchecked((int)0x80010108) or
+            unchecked((int)0x800401FD);
+
+    internal static string DescribeComFailure(Exception exception)
+    {
+        if (exception is not COMException ex)
+            return UserFacingError.Describe(
+                exception,
+                "OneNote communication failed");
+
+        return ex.HResult switch
+        {
+            unchecked((int)0x800706BA) => "RPC connection lost (0x800706BA)",
+            unchecked((int)0x80010108) => "COM object disconnected (0x80010108)",
+            unchecked((int)0x800401FD) => "COM object is no longer connected (0x800401FD)",
+            unchecked((int)0x80010007) => "OneNote COM server stopped (0x80010007)",
+            unchecked((int)0x80010012) => "OneNote COM server unavailable (0x80010012)",
+            unchecked((int)0x80042023) => "OneNote internal timeout (0x80042023)",
+            unchecked((int)0x8001010A) => "OneNote is busy (0x8001010A)",
+            unchecked((int)0x80010001) => "OneNote rejected the COM call (0x80010001)",
+            _ => $"COM error 0x{ex.HResult:X8}"
+        };
+    }
+
+    internal static ExportResult CreateConnectionRecoveryFailure(
+        Exception originalException,
+        Exception recoveryException)
+        => new()
+        {
+            Success = false,
+            Message = $"OneNote communication failed: " +
+                      $"{DescribeComFailure(originalException)}. " +
+                      "The app tried to reconnect automatically, but OneNote Desktop " +
+                      "could not be initialized again " +
+                      $"({UserFacingError.GetTechnicalCode(recoveryException)}). " +
+                      "Open OneNote, wait until synchronization has finished, and retry. " +
+                      "The existing backup was not changed."
+        };
+
+    internal static ExportResult CreateExportFailure(
+        Exception exception,
+        int attemptCount,
+        string exportFormat,
+        bool connectionRecoveryAttempted)
+    {
+        string attemptSuffix = attemptCount > 1
+            ? $" after {attemptCount} attempts"
+            : "";
+        bool isRenderedFormat = exportFormat.Equals("pdf", StringComparison.OrdinalIgnoreCase) ||
+                                exportFormat.Equals("xps", StringComparison.OrdinalIgnoreCase);
+        string renderedFormatAdvice = isRenderedFormat
+            ? " OneNote's PDF/XPS renderer is less reliable for large notebooks; " +
+              "export the notebook as individual sections or use .onepkg for a " +
+              "complete backup."
+            : "";
+        string recoveryDetails = connectionRecoveryAttempted
+            ? " The app reconnected to OneNote automatically, but the connection failed again."
+            : "";
+
+        return exception switch
+        {
+            UnauthorizedAccessException ex => new ExportResult
+            {
+                Success = false,
+                Message = UserFacingError.Describe(
+                              ex,
+                              "Access to the destination folder was denied.") +
+                          " The existing backup was not changed."
+            },
+            COMException ex when ex.HResult == unchecked((int)0x8004201A) => new ExportResult
+            {
+                Success = false,
+                Message = "OneNote error 0x8004201A: The export file already exists."
+            },
+            COMException ex when ex.HResult == unchecked((int)0x800706BA) => new ExportResult
+            {
+                Success = false,
+                Message = $"OneNote COM/RPC connection lost (0x800706BA){attemptSuffix}." +
+                          recoveryDetails +
+                          " This is a OneNote Desktop communication failure, not a " +
+                          "destination-folder error. Open OneNote, wait until the notebook " +
+                          "is fully synchronized, and retry." + renderedFormatAdvice
+                          + " The existing backup was not changed."
+            },
+            COMException ex when ex.HResult == unchecked((int)0x80042023) => new ExportResult
+            {
+                Success = false,
+                Message = $"OneNote internal timeout (0x80042023){attemptSuffix}. " +
+                          "OneNote did not finish the export request in time." +
+                          renderedFormatAdvice
+            },
+            COMException ex when ex.HResult == unchecked((int)0x8004201D) => new ExportResult
+            {
+                Success = false,
+                Message = "OneNote reports that the notebook is not fully synchronized " +
+                          "(0x8004201D). Open it in OneNote, wait for synchronization, " +
+                          "and retry."
+            },
+            COMException ex when ex.HResult == unchecked((int)0x80042030) => new ExportResult
+            {
+                Success = false,
+                Message = "A modal OneNote dialog is blocking the export (0x80042030). " +
+                          "Close the dialog in OneNote and retry."
+            },
+            COMException ex when IsRecoverableComFailure(ex) => new ExportResult
+            {
+                Success = false,
+                Message = $"OneNote communication failed: {DescribeComFailure(ex)}" +
+                          $"{attemptSuffix}." + recoveryDetails +
+                          " Open OneNote and retry after it is responsive and synchronized." +
+                          renderedFormatAdvice
+            },
+            COMException ex => new ExportResult
+            {
+                Success = false,
+                Message = $"OneNote returned an unknown COM error (0x{ex.HResult:X8}). " +
+                          "Open OneNote, close any open dialogs, and try again. " +
+                          "The existing backup was not changed."
+            },
+            _ => new ExportResult
+            {
+                Success = false,
+                Message = UserFacingError.Describe(
+                              exception,
+                              "The export could not be completed.") +
+                          " The existing backup was not changed."
+            }
+        };
+    }
+
     /// <summary>
     /// Recursively walks a hierarchy XML element, collecting Section entries
     /// and descending into SectionGroups. Skips encrypted sections and the recycle bin.
@@ -501,30 +636,6 @@ private static void CollectSections(
         }
     }
 
-    private void TryCloseOneNoteGracefully(IProgress<string>? progress)
-    {
-        if (_oneNoteClosedAttempted) return;
-        _oneNoteClosedAttempted = true;
-
-        var procs = Process.GetProcessesByName("ONENOTE");
-        if (procs.Length == 0) return;
-
-        progress?.Report($"Closing {procs.Length} OneNote process(es) before export...");
-
-        foreach (var p in procs)
-        {
-            try
-            {
-                if (p.CloseMainWindow())
-                    p.WaitForExit(5000);
-            }
-            catch { /* ignore */ }
-            finally { p.Dispose(); }
-        }
-
-        Thread.Sleep(1000);
-    }
-
     private static string FormatBytes(long bytes)
     {
         string[] units = { "Bytes", "KB", "MB", "GB" };
@@ -546,8 +657,6 @@ public void Dispose()
             {
                 Marshal.ReleaseComObject(_oneNote);
                 _oneNote = null;
-                GC.Collect();
-                GC.WaitForPendingFinalizers();
             }
             catch { /* ignore cleanup errors */ }
         }
diff --git a/build.ps1 b/build.ps1
index 1dec800..29f71de 100644
--- a/build.ps1
+++ b/build.ps1
@@ -1,7 +1,7 @@
 #Requires -Version 5.1
 <#
 .SYNOPSIS
-    Baut das OneNoteExporter-Projekt und kopiert das fertige Release in den Ordner "build".
+    Builds the OneNoteExporter project and copies the release output to the "build" folder.
 #>
 
 Set-StrictMode -Version Latest
@@ -16,18 +16,18 @@ $ProjectFile = Join-Path $ProjectRoot 'OneNoteExporter.csproj'
 $Version = $ProjectXml.Project.PropertyGroup.Version | Select-Object -First 1
 
 if (-not $Version) {
-    throw 'Keine <Version> in OneNoteExporter.csproj gefunden.'
+    throw 'No <Version> was found in OneNoteExporter.csproj.'
 }
 
-# ── 1. build-Ordner leeren / anlegen ─────────────────────────────────────────
-Write-Host ">> Bereite build-Ordner vor..." -ForegroundColor Cyan
+# ── 1. Prepare build folder ───────────────────────────────────────────────────
+Write-Host ">> Preparing build folder..." -ForegroundColor Cyan
 if (Test-Path $BuildDir) {
     Remove-Item -Path $BuildDir -Recurse -Force
 }
 New-Item -ItemType Directory -Path $BuildDir | Out-Null
 
 # ── 2. dotnet publish (Release, self-contained, x64) ─────────────────────────
-Write-Host ">> Starte dotnet publish..." -ForegroundColor Cyan
+Write-Host ">> Starting dotnet publish..." -ForegroundColor Cyan
 dotnet publish $ProjectFile `
     -c Release `
     -r win-x64 `
@@ -36,16 +36,16 @@ dotnet publish $ProjectFile `
     "-p:Version=$Version"
 
 if ($LASTEXITCODE -ne 0) {
-    Write-Host "FEHLER: dotnet publish fehlgeschlagen (Exit-Code $LASTEXITCODE)." -ForegroundColor Red
+    Write-Host "ERROR: dotnet publish failed (exit code $LASTEXITCODE)." -ForegroundColor Red
     exit $LASTEXITCODE
 }
 
-# ── 3. Dateien in build-Ordner kopieren ──────────────────────────────────────
-Write-Host ">> Kopiere Dateien nach: $BuildDir" -ForegroundColor Cyan
+# ── 3. Copy files to build folder ─────────────────────────────────────────────
+Write-Host ">> Copying files to: $BuildDir" -ForegroundColor Cyan
 Copy-Item -Path "$PublishDir\*" -Destination $BuildDir -Recurse -Force
 
-# ── 4. Inno Setup – Installer bauen ──────────────────────────────────────────
-Write-Host ">> Suche Inno Setup Compiler (ISCC.exe)..." -ForegroundColor Cyan
+# ── 4. Build Inno Setup installer ─────────────────────────────────────────────
+Write-Host ">> Looking for Inno Setup Compiler (ISCC.exe)..." -ForegroundColor Cyan
 
 $IssFile  = Join-Path $ProjectRoot 'innosetup.iss'
 $IsssPaths = @(
@@ -58,22 +58,22 @@ $IsssPaths = @(
 $Iscc = $IsssPaths | Where-Object { Test-Path $_ } | Select-Object -First 1
 
 if (-not $Iscc) {
-    Write-Host "WARNUNG: ISCC.exe nicht gefunden - Installer wird übersprungen." -ForegroundColor Yellow
-    Write-Host "  -> Inno Setup installieren: https://jrsoftware.org/isdl.php" -ForegroundColor Yellow
+    Write-Host "WARNING: ISCC.exe was not found; installer creation will be skipped." -ForegroundColor Yellow
+    Write-Host "  -> Install Inno Setup: https://jrsoftware.org/isdl.php" -ForegroundColor Yellow
 }
 elseif (-not (Test-Path $IssFile)) {
-    Write-Host "WARNUNG: innosetup.iss nicht gefunden - Installer wird übersprungen." -ForegroundColor Yellow
+    Write-Host "WARNING: innosetup.iss was not found; installer creation will be skipped." -ForegroundColor Yellow
 }
 else {
-    Write-Host ">> Starte Inno Setup: $Iscc" -ForegroundColor Cyan
+    Write-Host ">> Starting Inno Setup: $Iscc" -ForegroundColor Cyan
     & $Iscc "/DMyAppVersion=$Version" $IssFile
     if ($LASTEXITCODE -ne 0) {
-        Write-Host "FEHLER: Inno Setup fehlgeschlagen (Exit-Code $LASTEXITCODE)." -ForegroundColor Red
+        Write-Host "ERROR: Inno Setup failed (exit code $LASTEXITCODE)." -ForegroundColor Red
         exit $LASTEXITCODE
     }
 
-    # Setup-EXE ausgeben
-    $SetupExe = Get-ChildItem -Path $ArtifactDir -Filter 'OneNoteBackupExporter_Setup_*.exe' |
+    # Print setup EXE details
+    $SetupExe = Get-ChildItem -Path $ArtifactDir -Filter 'OneNoteBackupExporter_Setup.exe' |
                 Sort-Object LastWriteTime -Descending |
                 Select-Object -First 1
     if ($SetupExe) {
@@ -82,9 +82,9 @@ else {
     }
 }
 
-# ── 5. Fertig ─────────────────────────────────────────────────────────────────
+# ── 5. Complete ───────────────────────────────────────────────────────────────
 Write-Host ""
-Write-Host "Fertig! Build liegt in: $BuildDir" -ForegroundColor Green
+Write-Host "Complete! Build output: $BuildDir" -ForegroundColor Green
 $exe = Join-Path $BuildDir 'OneNoteExporter.exe'
 if (Test-Path $exe) {
     $size = [math]::Round((Get-Item $exe).Length / 1MB, 1)
diff --git a/git-push.sh b/git-push.sh
index cbbde65..d9dd26c 100644
--- a/git-push.sh
+++ b/git-push.sh
@@ -1,16 +1,16 @@
 #!/usr/bin/env bash
-# git-push.sh – stage, commit und push auf main
+# git-push.sh – stage, commit, and push the current branch
 set -euo pipefail
 
-# Commit-Message als Argument oder interaktiv abfragen
+# Read the commit message from the arguments or prompt interactively
 if [[ $# -gt 0 ]]; then
   MSG="$*"
 else
-  read -rp "Commit-Message: " MSG
+  read -rp "Commit message: " MSG
 fi
 
 if [[ -z "$MSG" ]]; then
-  echo "FEHLER: Keine Commit-Message angegeben."
+  echo "ERROR: No commit message was provided."
   exit 1
 fi
 
@@ -21,4 +21,4 @@ git commit -m "$MSG"
 git push origin "$BRANCH"
 
 echo ""
-echo "Gepusht: $(git rev-parse --short HEAD) auf $BRANCH – $MSG"
+echo "Pushed: $(git rev-parse --short HEAD) to $BRANCH – $MSG"
diff --git a/innosetup.iss b/innosetup.iss
index 204f00f..b0779ad 100644
--- a/innosetup.iss
+++ b/innosetup.iss
@@ -1,44 +1,44 @@
-#define MyAppName      "OneNoteBackupExporter"
-#ifndef MyAppVersion
-  #define MyAppVersion "1.1.0"
-#endif
-#define MyAppPublisher "JLI Software"
-#define MyAppURL       "https://github.com/jli-software/OneNoteBackupExporter"
-#define MyAppExeName   "OneNoteExporter.exe"
-#define MyBuildDir     SourcePath + "build"
-#define MyOutputDir    SourcePath + "artifacts"
-
-[Setup]
-AppId={{BBAE42F6-2F7E-474E-9A2D-C771DB475E3F}
-AppName={#MyAppName}
-AppVersion={#MyAppVersion}
-AppPublisher={#MyAppPublisher}
-AppPublisherURL={#MyAppURL}
-AppSupportURL={#MyAppURL}
-AppUpdatesURL={#MyAppURL}
-DefaultDirName={autopf}\{#MyAppName}
-UninstallDisplayIcon={app}\{#MyAppExeName}
-ArchitecturesAllowed=x64compatible
-ArchitecturesInstallIn64BitMode=x64compatible
-DisableProgramGroupPage=yes
-OutputDir={#MyOutputDir}
-OutputBaseFilename=OneNoteBackupExporter_Setup_{#MyAppVersion}
-SolidCompression=yes
-WizardStyle=modern
-
-[Languages]
-Name: "english"; MessagesFile: "compiler:Default.isl"
-
-[Tasks]
-Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
-
-[Files]
-; Self-contained x64 publish output
-Source: "{#MyBuildDir}\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
-
-[Icons]
-Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
-Name: "{autodesktop}\{#MyAppName}";  Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
-
-[Run]
-Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
+#define MyAppName      "OneNoteBackupExporter"
+#ifndef MyAppVersion
+  #define MyAppVersion "1.2.0"
+#endif
+#define MyAppPublisher "JLI Software"
+#define MyAppURL       "https://github.com/jli-software/OneNoteBackupExporter"
+#define MyAppExeName   "OneNoteExporter.exe"
+#define MyBuildDir     SourcePath + "build"
+#define MyOutputDir    SourcePath + "artifacts"
+
+[Setup]
+AppId={{BBAE42F6-2F7E-474E-9A2D-C771DB475E3F}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={autopf}\{#MyAppName}
+UninstallDisplayIcon={app}\{#MyAppExeName}
+ArchitecturesAllowed=x64compatible
+ArchitecturesInstallIn64BitMode=x64compatible
+DisableProgramGroupPage=yes
+OutputDir={#MyOutputDir}
+OutputBaseFilename=OneNoteBackupExporter_Setup
+SolidCompression=yes
+WizardStyle=modern
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+; Self-contained x64 publish output
+Source: "{#MyBuildDir}\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Icons]
+Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+Name: "{autodesktop}\{#MyAppName}";  Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
diff --git a/release.sh b/release.sh
index abc01ce..e1a1918 100755
--- a/release.sh
+++ b/release.sh
@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# release.sh – passenden Release-Tag erstellen und zu GitHub pushen
-# GitHub Actions baut und veröffentlicht Installer und Prüfsumme automatisch.
+# release.sh – create the matching release tag and push it to GitHub
+# GitHub Actions builds and publishes the installer and checksum automatically.
 
 set -euo pipefail
 
 if [[ $# -ne 1 ]]; then
-  echo "Verwendung: $0 <version> (zum Beispiel: $0 1.2.0)"
+  echo "Usage: $0 <version> (for example: $0 1.2.0)"
   exit 1
 fi
 
@@ -13,28 +13,28 @@ VERSION="${1#v}"
 TAG="v${VERSION}"
 
 if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$ ]]; then
-  echo "FEHLER: Ungültige Version: $VERSION"
+  echo "ERROR: Invalid version: $VERSION"
   exit 1
 fi
 
 PROJECT_VERSION=$(sed -n 's:.*<Version>\([^<]*\)</Version>.*:\1:p' OneNoteExporter.csproj | head -n 1)
 if [[ "$VERSION" != "$PROJECT_VERSION" ]]; then
-  echo "FEHLER: Version $VERSION stimmt nicht mit der Projektversion $PROJECT_VERSION überein."
+  echo "ERROR: Version $VERSION does not match project version $PROJECT_VERSION."
   exit 1
 fi
 
 if [[ -n "$(git status --porcelain)" ]]; then
-  echo "FEHLER: Das Arbeitsverzeichnis enthält nicht committete Änderungen."
+  echo "ERROR: The working tree contains uncommitted changes."
   exit 1
 fi
 
 git fetch origin --tags
 if git rev-parse --verify --quiet "refs/tags/$TAG" >/dev/null; then
-  echo "FEHLER: Tag $TAG existiert bereits."
+  echo "ERROR: Tag $TAG already exists."
   exit 1
 fi
 
 git tag -a "$TAG" -m "Release $TAG"
 git push origin "$TAG"
 
-echo "Tag $TAG wurde gepusht. GitHub Actions erstellt jetzt das Release."
+echo "Tag $TAG was pushed. GitHub Actions will now create the release."