diff --git a/windows/AirBridge.App/Pages/DevicesPage.xaml b/windows/AirBridge.App/Pages/DevicesPage.xaml
index 8e5bd0e..dc91853 100644
--- a/windows/AirBridge.App/Pages/DevicesPage.xaml
+++ b/windows/AirBridge.App/Pages/DevicesPage.xaml
@@ -2,11 +2,12 @@
 <Page x:Class="AirBridge.App.Pages.DevicesPage"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-      xmlns:models="using:AirBridge.Core.Models"
+      xmlns:vm="using:AirBridge.App.ViewModels"
       Background="Transparent">
 
-    <Grid Margin="24,16" RowSpacing="16">
+    <Grid Margin="24,16" RowSpacing="12">
         <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="*"/>
@@ -44,8 +45,23 @@
                  Severity="Informational"
                  Message="{x:Bind ViewModel.StatusMessage, Mode=OneWay}"/>
 
+        <!-- Error banner (scan/connection failure) -->
+        <InfoBar Grid.Row="2"
+                 IsOpen="{x:Bind ViewModel.HasError, Mode=OneWay}"
+                 IsClosable="True"
+                 Severity="Error"
+                 Title="Connection Error"
+                 Message="{x:Bind ViewModel.ErrorMessage, Mode=OneWay}"
+                 CloseButtonClick="DeviceErrorBar_CloseButtonClick">
+            <InfoBar.ActionButton>
+                <Button Content="Retry"
+                        Style="{StaticResource AccentButtonStyle}"
+                        Command="{x:Bind ViewModel.ToggleScanCommand}"/>
+            </InfoBar.ActionButton>
+        </InfoBar>
+
         <!-- Device list -->
-        <ListView Grid.Row="2"
+        <ListView Grid.Row="3"
                   ItemsSource="{x:Bind ViewModel.Devices}"
                   SelectionMode="None"
                   ScrollViewer.VerticalScrollBarVisibility="Auto">
@@ -57,7 +73,7 @@
                 </Style>
             </ListView.ItemContainerStyle>
             <ListView.ItemTemplate>
-                <DataTemplate x:DataType="models:DeviceInfo">
+                <DataTemplate x:DataType="vm:DeviceItemViewModel">
                     <Border Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
                             BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
                             BorderThickness="1"
@@ -78,7 +94,7 @@
                                       Foreground="{ThemeResource AccentTextFillColorPrimaryBrush}"
                                       VerticalAlignment="Center"/>
 
-                            <!-- Device info -->
+                            <!-- Device info + reconnecting indicator -->
                             <StackPanel Grid.Column="1" VerticalAlignment="Center" Spacing="2">
                                 <TextBlock Text="{x:Bind DeviceName}"
                                            Style="{StaticResource BodyStrongTextBlockStyle}"/>
@@ -88,6 +104,17 @@
                                     <Run Text=":"/>
                                     <Run Text="{x:Bind Port}"/>
                                 </TextBlock>
+
+                                <!-- Reconnecting row — visible only when reconnecting -->
+                                <StackPanel Orientation="Horizontal"
+                                            Spacing="6"
+                                            Visibility="{x:Bind IsReconnecting, Mode=OneWay, Converter={StaticResource BoolToVisibility}}">
+                                    <ProgressRing Width="14" Height="14" IsActive="True"/>
+                                    <TextBlock Text="Reconnecting&#x2026;"
+                                               Style="{StaticResource CaptionTextBlockStyle}"
+                                               Foreground="{ThemeResource SystemFillColorCautionBrush}"
+                                               VerticalAlignment="Center"/>
+                                </StackPanel>
                             </StackPanel>
 
                             <!-- Connect / Paired button -->
@@ -98,7 +125,7 @@
                                 <Button Content="Connect"
                                         Style="{StaticResource AccentButtonStyle}"
                                         Visibility="{x:Bind IsPaired, Converter={StaticResource BoolToVisibilityNegated}}"
-                                        Tag="{x:Bind}"
+                                        Tag="{x:Bind Device}"
                                         Click="ConnectButton_Click"/>
                             </StackPanel>
                         </Grid>
@@ -108,7 +135,7 @@
         </ListView>
 
         <!-- Bottom status bar -->
-        <TextBlock Grid.Row="3"
+        <TextBlock Grid.Row="4"
                    Foreground="{ThemeResource TextFillColorSecondaryBrush}"
                    Style="{StaticResource CaptionTextBlockStyle}">
             <Run Text="{x:Bind ViewModel.Devices.Count, Mode=OneWay}"/>
diff --git a/windows/AirBridge.App/Pages/DevicesPage.xaml.cs b/windows/AirBridge.App/Pages/DevicesPage.xaml.cs
index 56bbb77..2a990f0 100644
--- a/windows/AirBridge.App/Pages/DevicesPage.xaml.cs
+++ b/windows/AirBridge.App/Pages/DevicesPage.xaml.cs
@@ -31,4 +31,7 @@ private async void ConnectButton_Click(object sender, RoutedEventArgs e)
             await dialog.ShowAsync();
         }
     }
+
+    private void DeviceErrorBar_CloseButtonClick(InfoBar sender, object args)
+        => ViewModel.DismissErrorCommand.Execute(null);
 }
diff --git a/windows/AirBridge.App/Pages/TransferPage.xaml b/windows/AirBridge.App/Pages/TransferPage.xaml
index 8c9c559..b24b67f 100644
--- a/windows/AirBridge.App/Pages/TransferPage.xaml
+++ b/windows/AirBridge.App/Pages/TransferPage.xaml
@@ -5,8 +5,9 @@
       xmlns:vm="using:AirBridge.App.ViewModels"
       Background="Transparent">
 
-    <Grid Margin="24,16" RowSpacing="16">
+    <Grid Margin="24,16" RowSpacing="12">
         <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="*"/>
@@ -39,8 +40,23 @@
                  Severity="Informational"
                  Message="{x:Bind ViewModel.ConnectedDeviceName, Mode=OneWay}"/>
 
+        <!-- Error banner (connection drop / transfer failure) -->
+        <InfoBar Grid.Row="2"
+                 IsOpen="{x:Bind ViewModel.HasError, Mode=OneWay}"
+                 IsClosable="True"
+                 Severity="Error"
+                 Title="Transfer Error"
+                 Message="{x:Bind ViewModel.ErrorMessage, Mode=OneWay}"
+                 CloseButtonClick="TransferErrorBar_CloseButtonClick">
+            <InfoBar.ActionButton>
+                <Button Content="Retry"
+                        Style="{StaticResource AccentButtonStyle}"
+                        Command="{x:Bind ViewModel.RetrySendCommand}"/>
+            </InfoBar.ActionButton>
+        </InfoBar>
+
         <!-- Transfer list -->
-        <ListView Grid.Row="2"
+        <ListView Grid.Row="3"
                   ItemsSource="{x:Bind ViewModel.Transfers}"
                   SelectionMode="None"
                   ScrollViewer.VerticalScrollBarVisibility="Auto">
@@ -59,6 +75,7 @@
                             CornerRadius="8"
                             Padding="16,12">
                         <StackPanel Spacing="8">
+                            <!-- File name + status badge -->
                             <Grid>
                                 <Grid.ColumnDefinitions>
                                     <ColumnDefinition Width="*"/>
@@ -76,7 +93,25 @@
                                                Foreground="White"/>
                                 </Border>
                             </Grid>
+
+                            <!-- Progress bar -->
                             <ProgressBar Value="{x:Bind Progress, Mode=OneWay}" Maximum="1.0"/>
+
+                            <!-- Speed + ETA row (only while active) -->
+                            <Grid Visibility="{x:Bind IsActive, Mode=OneWay, Converter={StaticResource BoolToVisibility}}">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="*"/>
+                                    <ColumnDefinition Width="Auto"/>
+                                </Grid.ColumnDefinitions>
+                                <TextBlock Grid.Column="0"
+                                           Text="{x:Bind SpeedText, Mode=OneWay}"
+                                           Style="{StaticResource CaptionTextBlockStyle}"
+                                           Foreground="{ThemeResource TextFillColorSecondaryBrush}"/>
+                                <TextBlock Grid.Column="1"
+                                           Text="{x:Bind EtaText, Mode=OneWay}"
+                                           Style="{StaticResource CaptionTextBlockStyle}"
+                                           Foreground="{ThemeResource TextFillColorSecondaryBrush}"/>
+                            </Grid>
                         </StackPanel>
                     </Border>
                 </DataTemplate>
diff --git a/windows/AirBridge.App/Pages/TransferPage.xaml.cs b/windows/AirBridge.App/Pages/TransferPage.xaml.cs
index 551879e..9dcd331 100644
--- a/windows/AirBridge.App/Pages/TransferPage.xaml.cs
+++ b/windows/AirBridge.App/Pages/TransferPage.xaml.cs
@@ -36,4 +36,7 @@ private async void SendFileButton_Click(object sender, RoutedEventArgs e)
 
         await ViewModel.SendFileCommand.ExecuteAsync(file.Path);
     }
+
+    private void TransferErrorBar_CloseButtonClick(InfoBar sender, object args)
+        => ViewModel.DismissErrorCommand.Execute(null);
 }
diff --git a/windows/AirBridge.App/Services/DeviceConnectionService.cs b/windows/AirBridge.App/Services/DeviceConnectionService.cs
index 8bda839..c1dcfb7 100644
--- a/windows/AirBridge.App/Services/DeviceConnectionService.cs
+++ b/windows/AirBridge.App/Services/DeviceConnectionService.cs
@@ -68,6 +68,9 @@ public void RemoveMessageHandlers(string deviceId)
     /// <summary>Raised with the device ID when an active session is closed or drops.</summary>
     public event EventHandler<string>? DeviceDisconnected;
 
+    /// <summary>Raised with the device ID when an automatic reconnect attempt begins.</summary>
+    public event EventHandler<string>? DeviceReconnecting;
+
     // ── Existing fields ─────────────────────────────────────────────────────
 
     /// <summary>PIN from a pending inbound pairing request, or null if none.</summary>
@@ -214,10 +217,12 @@ void OnDisconnect(object? s, string id)
             }
 
             // Session dropped — retry from attempt 1 (reset loop).
+            DeviceReconnecting?.Invoke(this, device.DeviceId);
             attempt = 0; // loop increment will make it 1
             continue;
 
             Backoff:
+            DeviceReconnecting?.Invoke(this, device.DeviceId);
             var delayMs = (int)Math.Min(
                 Math.Pow(BackoffBase, attempt - 1) * 1000,
                 BackoffMaxMs);
diff --git a/windows/AirBridge.App/ViewModels/DevicesViewModel.cs b/windows/AirBridge.App/ViewModels/DevicesViewModel.cs
index 2c2ed12..974a48f 100644
--- a/windows/AirBridge.App/ViewModels/DevicesViewModel.cs
+++ b/windows/AirBridge.App/ViewModels/DevicesViewModel.cs
@@ -6,6 +6,39 @@
 
 namespace AirBridge.App.ViewModels;
 
+/// <summary>
+/// Wraps a <see cref="DeviceInfo"/> with runtime UI state (e.g. reconnecting indicator).
+/// </summary>
+public sealed partial class DeviceItemViewModel : ObservableObject
+{
+    /// <summary>The underlying device model.</summary>
+    public DeviceInfo Device { get; }
+
+    private bool _isReconnecting;
+    /// <summary>True while an automatic reconnect attempt is in progress for this device.</summary>
+    public bool IsReconnecting
+    {
+        get => _isReconnecting;
+        set => SetProperty(ref _isReconnecting, value);
+    }
+
+    /// <summary>Convenience passthrough: device name.</summary>
+    public string DeviceName  => Device.DeviceName;
+    /// <summary>Convenience passthrough: IP address.</summary>
+    public string IpAddress   => Device.IpAddress;
+    /// <summary>Convenience passthrough: port.</summary>
+    public int    Port        => Device.Port;
+    /// <summary>Convenience passthrough: device type.</summary>
+    public DeviceType DeviceType => Device.DeviceType;
+    /// <summary>Convenience passthrough: pairing state.</summary>
+    public bool   IsPaired    => Device.IsPaired;
+    /// <summary>Convenience passthrough: device ID.</summary>
+    public string DeviceId    => Device.DeviceId;
+
+    /// <summary>Creates a new wrapper around <paramref name="device"/>.</summary>
+    public DeviceItemViewModel(DeviceInfo device) => Device = device;
+}
+
 /// <summary>
 /// ViewModel for the Devices page. Exposes discovered devices and controls
 /// for starting/stopping mDNS scanning and initiating a connection.
@@ -13,9 +46,10 @@ namespace AirBridge.App.ViewModels;
 public sealed partial class DevicesViewModel : ObservableObject
 {
     private readonly DeviceConnectionService _connection;
+    private readonly Microsoft.UI.Dispatching.DispatcherQueue _dispatcher;
 
-    /// <summary>Live list of devices found on the LAN.</summary>
-    public ObservableCollection<DeviceInfo> Devices => _connection.DiscoveredDevices;
+    /// <summary>Live list of devices found on the LAN, wrapped with UI state.</summary>
+    public ObservableCollection<DeviceItemViewModel> Devices { get; } = new();
 
     [ObservableProperty]
     private bool _isScanning = true;
@@ -26,14 +60,86 @@ public sealed partial class DevicesViewModel : ObservableObject
     [ObservableProperty]
     private string _statusMessage = "Scanning for devices\u2026";
 
+    [ObservableProperty]
+    private bool _hasError;
+
+    [ObservableProperty]
+    private string _errorMessage = string.Empty;
+
     /// <summary>Raised when the user requests a connection to a device.</summary>
     public event EventHandler<DeviceInfo>? ConnectRequested;
 
     public DevicesViewModel(DeviceConnectionService connection)
     {
         _connection = connection;
+        _dispatcher = Microsoft.UI.Dispatching.DispatcherQueue.GetForCurrentThread();
+
+        // Mirror raw DiscoveredDevices into Devices (wrapped)
+        _connection.DiscoveredDevices.CollectionChanged += OnDiscoveredDevicesChanged;
+        foreach (var d in _connection.DiscoveredDevices)
+            Devices.Add(new DeviceItemViewModel(d));
+
+        _connection.DeviceConnected    += OnDeviceConnected;
+        _connection.DeviceDisconnected += OnDeviceDisconnected;
+        _connection.DeviceReconnecting += OnDeviceReconnecting;
     }
 
+    private void OnDiscoveredDevicesChanged(object? sender,
+        System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+    {
+        _dispatcher?.TryEnqueue(() =>
+        {
+            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add
+                && e.NewItems is not null)
+            {
+                foreach (DeviceInfo d in e.NewItems)
+                    Devices.Add(new DeviceItemViewModel(d));
+            }
+            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove
+                     && e.OldItems is not null)
+            {
+                foreach (DeviceInfo d in e.OldItems)
+                {
+                    var vm = Devices.FirstOrDefault(x => x.DeviceId == d.DeviceId);
+                    if (vm is not null) Devices.Remove(vm);
+                }
+            }
+            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
+            {
+                Devices.Clear();
+            }
+        });
+    }
+
+    private void OnDeviceConnected(object? sender, string deviceId)
+    {
+        _dispatcher?.TryEnqueue(() =>
+        {
+            var vm = Devices.FirstOrDefault(x => x.DeviceId == deviceId);
+            if (vm is not null) vm.IsReconnecting = false;
+            HasError = false;
+        });
+    }
+
+    private void OnDeviceDisconnected(object? sender, string deviceId)
+    {
+        // Disconnection itself is not an error — reconnect may follow.
+        // If no reconnect arrives, it will just stay disconnected.
+    }
+
+    private void OnDeviceReconnecting(object? sender, string deviceId)
+    {
+        _dispatcher?.TryEnqueue(() =>
+        {
+            var vm = Devices.FirstOrDefault(x => x.DeviceId == deviceId);
+            if (vm is not null) vm.IsReconnecting = true;
+        });
+    }
+
+    /// <summary>Dismisses the current error banner.</summary>
+    [RelayCommand]
+    private void DismissError() => HasError = false;
+
     /// <summary>Starts or stops mDNS device scanning.</summary>
     [RelayCommand]
     private async Task ToggleScanAsync()
@@ -48,7 +154,18 @@ private async Task ToggleScanAsync()
         {
             IsScanning    = true;
             StatusMessage = "Scanning for devices\u2026";
-            await _connection.StartDiscoveryAsync();
+            try
+            {
+                await _connection.StartDiscoveryAsync();
+                HasError = false;
+            }
+            catch (Exception ex)
+            {
+                IsScanning    = false;
+                StatusMessage = "Scan failed";
+                ErrorMessage  = $"Failed to start scanning: {ex.Message}";
+                HasError      = true;
+            }
         }
     }
 
diff --git a/windows/AirBridge.App/ViewModels/TransferViewModel.cs b/windows/AirBridge.App/ViewModels/TransferViewModel.cs
index 5e40413..a8b9439 100644
--- a/windows/AirBridge.App/ViewModels/TransferViewModel.cs
+++ b/windows/AirBridge.App/ViewModels/TransferViewModel.cs
@@ -5,6 +5,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 
 namespace AirBridge.App.ViewModels;
 
@@ -15,6 +16,7 @@ public sealed class TransferItem : ObservableObject
     public long   TotalBytes { get; }
 
     private double _progress;
+    /// <summary>Transfer progress in the range [0, 1].</summary>
     public double Progress
     {
         get => _progress;
@@ -22,12 +24,97 @@ public double Progress
     }
 
     private string _status = "Queued";
+    /// <summary>Human-readable status label (e.g. "Queued", "Complete ✓", "Failed").</summary>
     public string Status
     {
         get => _status;
         set => SetProperty(ref _status, value);
     }
 
+    private string _speedText = string.Empty;
+    /// <summary>Formatted transfer speed, e.g. "1.2 MB/s".</summary>
+    public string SpeedText
+    {
+        get => _speedText;
+        set => SetProperty(ref _speedText, value);
+    }
+
+    private string _etaText = string.Empty;
+    /// <summary>Formatted estimated time remaining, e.g. "~3s" or "~1m 20s".</summary>
+    public string EtaText
+    {
+        get => _etaText;
+        set => SetProperty(ref _etaText, value);
+    }
+
+    private bool _isActive;
+    /// <summary>True while the transfer is actively sending/receiving bytes.</summary>
+    public bool IsActive
+    {
+        get => _isActive;
+        set => SetProperty(ref _isActive, value);
+    }
+
+    // ── Speed / ETA tracking ─────────────────────────────────────────────
+    private readonly Stopwatch _stopwatch = Stopwatch.StartNew();
+    private long _lastBytes;
+
+    /// <summary>
+    /// Updates <see cref="Progress"/>, <see cref="SpeedText"/>, and <see cref="EtaText"/>
+    /// from a raw byte-transferred count.
+    /// </summary>
+    public void UpdateProgress(long bytesTransferred)
+    {
+        Progress  = TotalBytes > 0 ? bytesTransferred / (double)TotalBytes : 1.0;
+        IsActive  = true;
+
+        var elapsedSec = _stopwatch.Elapsed.TotalSeconds;
+        if (elapsedSec > 0.1)
+        {
+            var deltaBytes = bytesTransferred - _lastBytes;
+            var speedBps   = deltaBytes / elapsedSec; // bytes per second since last update
+
+            SpeedText = FormatSpeed(speedBps);
+
+            var remaining = TotalBytes - bytesTransferred;
+            if (speedBps > 0)
+                EtaText = FormatEta(remaining / speedBps);
+            else
+                EtaText = string.Empty;
+
+            _lastBytes = bytesTransferred;
+            _stopwatch.Restart();
+        }
+
+        Status = $"{FormatBytes(bytesTransferred)} / {FormatBytes(TotalBytes)}";
+    }
+
+    private static string FormatSpeed(double bytesPerSec)
+        => bytesPerSec switch
+        {
+            >= 1024 * 1024 * 1024 => $"{bytesPerSec / (1024.0 * 1024 * 1024):F1} GB/s",
+            >= 1024 * 1024        => $"{bytesPerSec / (1024.0 * 1024):F1} MB/s",
+            >= 1024               => $"{bytesPerSec / 1024.0:F0} KB/s",
+            _                     => $"{bytesPerSec:F0} B/s"
+        };
+
+    private static string FormatBytes(long bytes)
+        => bytes switch
+        {
+            >= 1024L * 1024 * 1024 => $"{bytes / (1024.0 * 1024 * 1024):F2} GB",
+            >= 1024 * 1024         => $"{bytes / (1024.0 * 1024):F1} MB",
+            >= 1024                => $"{bytes / 1024.0:F0} KB",
+            _                      => $"{bytes} B"
+        };
+
+    private static string FormatEta(double seconds)
+    {
+        if (seconds < 60) return $"~{(int)seconds}s";
+        var m = (int)(seconds / 60);
+        var s = (int)(seconds % 60);
+        return $"~{m}m {s}s";
+    }
+
     public TransferItem(string fileName, long totalBytes)
     {
         FileName   = fileName;
@@ -50,6 +137,14 @@ public sealed partial class TransferViewModel : ObservableObject
     [ObservableProperty] private bool   _canSend;
     [ObservableProperty] private string _connectedDeviceName = "No device connected";
 
+    [ObservableProperty] private bool   _hasError;
+    [ObservableProperty] private string _errorMessage = string.Empty;
+
+    /// <summary>
+    /// Path of the last file attempted, stored so the Retry command can re-trigger the send.
+    /// </summary>
+    private string? _lastFilePath;
+
     private string? _connectedDeviceId;
 
     public TransferViewModel(IFileTransferService transfer, DeviceConnectionService connection)
@@ -71,15 +166,24 @@ public TransferViewModel(IFileTransferService transfer, DeviceConnectionService
     }
 
     private void OnDeviceConnected(object? sender, string deviceId)
-        => RegisterDevice(deviceId);
+    {
+        RegisterDevice(deviceId);
+        _dispatcher?.TryEnqueue(() => HasError = false);
+    }
 
     private void OnDeviceDisconnected(object? sender, string deviceId)
     {
         if (_connectedDeviceId != deviceId) return;
         _connectedDeviceId  = null;
         _transfer.SetChannel(null);
-        ConnectedDeviceName = "No device connected";
-        CanSend             = false;
+        _dispatcher?.TryEnqueue(() =>
+        {
+            ConnectedDeviceName = "No device connected";
+            CanSend             = false;
+            // Show a non-fatal banner — the connection manager will auto-reconnect.
+            ErrorMessage        = $"Connection to {deviceId} lost. Reconnecting\u2026";
+            HasError            = true;
+        });
     }
 
     private void RegisterDevice(string deviceId)
@@ -87,22 +191,40 @@ private void RegisterDevice(string deviceId)
         _connectedDeviceId  = deviceId;
         var channel         = _connection.GetActiveSession(deviceId);
         _transfer.SetChannel(channel);
-        ConnectedDeviceName = deviceId;
-        CanSend             = channel is not null;
+        _dispatcher?.TryEnqueue(() =>
+        {
+            ConnectedDeviceName = deviceId;
+            CanSend             = channel is not null;
+        });
 
         // Register receive handler so inbound transfers are written to Downloads/AirBridge.
         _connection.RemoveMessageHandlers(deviceId);
         _connection.AddMessageHandler(deviceId, _transfer.CreateReceiveHandler());
     }
 
+    /// <summary>Dismisses the current error banner.</summary>
+    [RelayCommand]
+    private void DismissError() => HasError = false;
+
+    /// <summary>Retries the last failed send operation.</summary>
+    [RelayCommand]
+    private async Task RetrySendAsync()
+    {
+        HasError = false;
+        if (_lastFilePath is not null)
+            await SendFileAsync(_lastFilePath).ConfigureAwait(false);
+    }
+
     [RelayCommand]
     private async Task SendFileAsync(string filePath)
     {
         if (!CanSend || string.IsNullOrEmpty(filePath)) return;
 
+        _lastFilePath = filePath;
+
         var info = new FileInfo(filePath);
         var item = new TransferItem(info.Name, info.Length);
-        Transfers.Add(item);
+        _dispatcher?.TryEnqueue(() => Transfers.Add(item));
 
         try
         {
@@ -117,26 +239,42 @@ private async Task SendFileAsync(string filePath)
             var session = await _transfer.SendFileAsync(filePath, fakeDevice).ConfigureAwait(false);
 
             session.ProgressChanged += (_, bytes) => _dispatcher?.TryEnqueue(() =>
-            {
-                item.Progress = info.Length > 0 ? bytes / (double)info.Length : 1.0;
-                item.Status   = $"{bytes / 1024} KB / {info.Length / 1024} KB";
-            });
+                item.UpdateProgress(bytes));
+
             session.StateChanged += (_, state) => _dispatcher?.TryEnqueue(() =>
             {
-                item.Status = state switch
+                switch (state)
                 {
-                    AirBridge.Core.Interfaces.TransferState.Completed => "Complete ✓",
-                    AirBridge.Core.Interfaces.TransferState.Failed    => "Failed",
-                    AirBridge.Core.Interfaces.TransferState.Cancelled => "Cancelled",
-                    _ => item.Status,
-                };
-                if (state == AirBridge.Core.Interfaces.TransferState.Completed)
-                    item.Progress = 1.0;
+                    case AirBridge.Core.Interfaces.TransferState.Completed:
+                        item.Status   = "Complete \u2713";
+                        item.Progress = 1.0;
+                        item.IsActive = false;
+                        item.SpeedText = string.Empty;
+                        item.EtaText   = string.Empty;
+                        HasError = false;
+                        break;
+                    case AirBridge.Core.Interfaces.TransferState.Failed:
+                        item.Status   = "Failed";
+                        item.IsActive = false;
+                        ErrorMessage  = $"Transfer of \u201c{item.FileName}\u201d failed.";
+                        HasError      = true;
+                        break;
+                    case AirBridge.Core.Interfaces.TransferState.Cancelled:
+                        item.Status   = "Cancelled";
+                        item.IsActive = false;
+                        break;
+                }
             });
         }
         catch (Exception ex)
         {
-            item.Status = $"Failed: {ex.Message}";
+            _dispatcher?.TryEnqueue(() =>
+            {
+                item.Status  = "Failed";
+                item.IsActive = false;
+                ErrorMessage = $"Could not send \u201c{info.Name}\u201d: {ex.Message}";
+                HasError     = true;
+            });
         }
     }
 }
diff --git a/windows/AirBridge.Tests/Transport/Connection/TlsMessageChannelIntegrationTests.cs b/windows/AirBridge.Tests/Transport/Connection/TlsMessageChannelIntegrationTests.cs
index 099ecb0..0cf17c4 100644
--- a/windows/AirBridge.Tests/Transport/Connection/TlsMessageChannelIntegrationTests.cs
+++ b/windows/AirBridge.Tests/Transport/Connection/TlsMessageChannelIntegrationTests.cs
@@ -234,18 +234,20 @@ public async Task PongTimeout_ClosesChannel()
         client.Disconnected += (_, _) => disconnectTcs.TrySetResult(true);
 
         using var keepaliveCts = new CancellationTokenSource();
-        _ = client.StartKeepaliveAsync(keepaliveCts.Token);
+        var keepaliveTask = client.StartKeepaliveAsync(keepaliveCts.Token);
 
         // The channel should detect the dead connection within keepalive interval + pong timeout
         // (~40 s in production).  For CI we allow 50 s.
-        var disconnected = await Task.WhenAny(
+        await Task.WhenAny(
             disconnectTcs.Task,
             Task.Delay(TimeSpan.FromSeconds(50), cts.Token));
 
         Assert.True(disconnectTcs.Task.IsCompleted, "Channel should have closed after PONG timeout.");
         Assert.False(client.IsConnected);
 
+        // Cancel the keepalive loop and await the task so no dangling thread outlives the test.
         keepaliveCts.Cancel();
+        try { await keepaliveTask; } catch (OperationCanceledException) { }
         await client.DisposeAsync();
     }