diff --git a/LANCommander.Launcher.Avalonia/ViewModels/DownloadQueueViewModel.cs b/LANCommander.Launcher.Avalonia/ViewModels/DownloadQueueViewModel.cs
index 1cde4fca..0ee4b4f9 100644
--- a/LANCommander.Launcher.Avalonia/ViewModels/DownloadQueueViewModel.cs
+++ b/LANCommander.Launcher.Avalonia/ViewModels/DownloadQueueViewModel.cs
@@ -11,6 +11,7 @@ using LANCommander.Launcher.Avalonia.Services;
 using LANCommander.Launcher.Models;
 using LANCommander.Launcher.Services;
 using LANCommander.SDK.Enums;
+using LANCommander.SDK.Models;
 using LANCommander.SDK.Services;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -92,6 +93,7 @@ public partial class DownloadQueueViewModel : ViewModelBase
 
         _installService.OnQueueChanged += OnQueueChanged;
         _installService.OnProgress += OnProgress;
+        _installService.OnTaskProgressUpdate += OnTaskProgressUpdate;
         _installService.OnInstallComplete += OnInstallComplete;
         _installService.OnInstallFail += OnInstallFail;
 
@@ -104,6 +106,37 @@ public partial class DownloadQueueViewModel : ViewModelBase
         return Task.CompletedTask;
     }
 
+    private Task OnTaskProgressUpdate(InstallTaskProgress taskProgress)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            var item = QueueItems.FirstOrDefault(i => i.Id == taskProgress.QueueItemId);
+            if (item == null)
+                return;
+
+            var task = item.Tasks.FirstOrDefault(t => t.Id == taskProgress.TaskId);
+            if (task == null)
+                return;
+
+            task.Status = taskProgress.TaskStatus;
+            task.Progress = taskProgress.Progress;
+            task.BytesTransferred = taskProgress.BytesTransferred;
+            task.TotalBytes = taskProgress.TotalBytes;
+            task.TransferSpeed = taskProgress.TransferSpeed;
+            task.ErrorMessage = taskProgress.ErrorMessage;
+
+            item.CurrentTask = task;
+
+            // Update current status from task
+            if (item == CurrentItem)
+            {
+                CurrentStatus = taskProgress.TaskTitle;
+            }
+        });
+
+        return Task.CompletedTask;
+    }
+
     private Task OnProgress(InstallProgress progress)
     {
         _taskbarProgressService.SetProgress(progress.Progress);
@@ -364,9 +397,18 @@ public partial class InstallQueueItemViewModel : ViewModelBase
     [ObservableProperty]
     private bool _isUpdate;
 
-    public bool IsActive => Status != InstallStatus.Queued && 
-                           Status != InstallStatus.Complete && 
-                           Status != InstallStatus.Failed && 
+    [ObservableProperty]
+    private ObservableCollection<InstallTaskItemViewModel> _tasks = new();
+
+    [ObservableProperty]
+    private InstallTaskItemViewModel? _currentTask;
+
+    [ObservableProperty]
+    private bool _hasTasks;
+
+    public bool IsActive => Status != InstallStatus.Queued &&
+                           Status != InstallStatus.Complete &&
+                           Status != InstallStatus.Failed &&
                            Status != InstallStatus.Canceled;
 
     public bool IsQueued => Status == InstallStatus.Queued;
@@ -390,6 +432,15 @@ public partial class InstallQueueItemViewModel : ViewModelBase
         CoverId = item.CoverId;
         IconId = item.IconId;
         IsUpdate = item.IsUpdate;
+
+        if (item.Tasks != null && item.Tasks.Count > 0)
+        {
+            foreach (var taskDef in item.Tasks.OrderBy(t => t.Order))
+            {
+                Tasks.Add(new InstallTaskItemViewModel(taskDef));
+            }
+            HasTasks = true;
+        }
     }
 
     private static string FormatBytes(long bytes)
diff --git a/LANCommander.Launcher.Avalonia/ViewModels/InstallTaskItemViewModel.cs b/LANCommander.Launcher.Avalonia/ViewModels/InstallTaskItemViewModel.cs
new file mode 100644
index 00000000..6bfd7641
--- /dev/null
+++ b/LANCommander.Launcher.Avalonia/ViewModels/InstallTaskItemViewModel.cs
@@ -0,0 +1,59 @@
+using System;
+using CommunityToolkit.Mvvm.ComponentModel;
+using LANCommander.SDK.Enums;
+using LANCommander.SDK.Models;
+
+namespace LANCommander.Launcher.Avalonia.ViewModels;
+
+public partial class InstallTaskItemViewModel : ViewModelBase
+{
+    [ObservableProperty]
+    private Guid _id;
+
+    [ObservableProperty]
+    private string _title = string.Empty;
+
+    [ObservableProperty]
+    private InstallTaskType _type;
+
+    [ObservableProperty]
+    private InstallTaskStatus _status = InstallTaskStatus.Queued;
+
+    [ObservableProperty]
+    private float _progress;
+
+    [ObservableProperty]
+    private bool _reportsProgress;
+
+    [ObservableProperty]
+    private bool _isCritical;
+
+    [ObservableProperty]
+    private string? _errorMessage;
+
+    [ObservableProperty]
+    private long _bytesTransferred;
+
+    [ObservableProperty]
+    private long _totalBytes;
+
+    [ObservableProperty]
+    private long _transferSpeed;
+
+    public bool IsCompleted => Status == InstallTaskStatus.Completed;
+    public bool IsRunning => Status == InstallTaskStatus.Running;
+    public bool IsFailed => Status == InstallTaskStatus.Failed;
+    public bool IsQueued => Status == InstallTaskStatus.Queued;
+    public bool IsSkipped => Status == InstallTaskStatus.Skipped;
+
+    public InstallTaskItemViewModel() { }
+
+    public InstallTaskItemViewModel(InstallTaskDefinition taskDef)
+    {
+        Id = taskDef.Id;
+        Title = taskDef.Title;
+        Type = taskDef.Type;
+        ReportsProgress = taskDef.ReportsProgress;
+        IsCritical = taskDef.IsCritical;
+    }
+}
diff --git a/LANCommander.Launcher.Avalonia/Views/DownloadQueuePageView.axaml b/LANCommander.Launcher.Avalonia/Views/DownloadQueuePageView.axaml
index 68c7a97b..44bc4c04 100644
--- a/LANCommander.Launcher.Avalonia/Views/DownloadQueuePageView.axaml
+++ b/LANCommander.Launcher.Avalonia/Views/DownloadQueuePageView.axaml
@@ -114,6 +114,51 @@
                                            IsVisible="{Binding TimeRemainingText, Converter={x:Static StringConverters.IsNotNullOrEmpty}}" />
                             </Grid>
 
+                            <!-- Task list -->
+                            <ItemsControl Grid.Row="3"
+                                          ItemsSource="{Binding CurrentItem.Tasks}"
+                                          IsVisible="{Binding CurrentItem.HasTasks}"
+                                          Margin="0,12,0,0">
+                                <ItemsControl.ItemTemplate>
+                                    <DataTemplate DataType="vm:InstallTaskItemViewModel">
+                                        <Grid ColumnDefinitions="20,*,Auto"
+                                              Margin="0,2">
+                                            <!-- Status icon -->
+                                            <Panel Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center">
+                                                <TextBlock Text="&#x2713;" Foreground="#4CAF50" FontSize="11"
+                                                           IsVisible="{Binding IsCompleted}" />
+                                                <TextBlock Text="&#x25CF;" Foreground="#2196F3" FontSize="8"
+                                                           IsVisible="{Binding IsRunning}"
+                                                           VerticalAlignment="Center" HorizontalAlignment="Center" />
+                                                <TextBlock Text="&#x2715;" Foreground="IndianRed" FontSize="11"
+                                                           IsVisible="{Binding IsFailed}" />
+                                                <TextBlock Text="&#x2015;" Opacity="0.3" FontSize="11"
+                                                           IsVisible="{Binding IsQueued}" />
+                                            </Panel>
+
+                                            <!-- Task title -->
+                                            <TextBlock Grid.Column="1"
+                                                       Text="{Binding Title}"
+                                                       FontSize="12"
+                                                       Opacity="0.8"
+                                                       VerticalAlignment="Center"
+                                                       TextTrimming="CharacterEllipsis" />
+
+                                            <!-- Error message for failed tasks -->
+                                            <TextBlock Grid.Column="2"
+                                                       Text="{Binding ErrorMessage}"
+                                                       FontSize="10"
+                                                       Foreground="IndianRed"
+                                                       Opacity="0.8"
+                                                       VerticalAlignment="Center"
+                                                       IsVisible="{Binding IsFailed}"
+                                                       MaxWidth="200"
+                                                       TextTrimming="CharacterEllipsis" />
+                                        </Grid>
+                                    </DataTemplate>
+                                </ItemsControl.ItemTemplate>
+                            </ItemsControl>
+
                         </Grid>
                     </Border>
                 </Border>
diff --git a/LANCommander.Launcher.Avalonia/Views/DownloadQueueView.axaml b/LANCommander.Launcher.Avalonia/Views/DownloadQueueView.axaml
index 70a26473..21b4779d 100644
--- a/LANCommander.Launcher.Avalonia/Views/DownloadQueueView.axaml
+++ b/LANCommander.Launcher.Avalonia/Views/DownloadQueueView.axaml
@@ -71,7 +71,7 @@
                     <Border Padding="8" CornerRadius="6" 
                             Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
                             IsVisible="{Binding CurrentItem, Converter={x:Static ObjectConverters.IsNotNull}}">
-                        <Grid RowDefinitions="Auto,Auto,Auto">
+                        <Grid RowDefinitions="Auto,Auto,Auto,Auto">
                             <!-- Title and Cancel -->
                             <DockPanel Grid.Row="0">
                                 <Button DockPanel.Dock="Right"
@@ -96,11 +96,41 @@
                             </StackPanel>
                             
                             <!-- Progress Bar -->
-                            <ProgressBar Grid.Row="2" 
-                                         Value="{Binding CurrentProgress}" 
+                            <ProgressBar Grid.Row="2"
+                                         Value="{Binding CurrentProgress}"
                                          Minimum="0" Maximum="1"
                                          Height="4"
                                          Margin="0,4,0,0" />
+
+                            <!-- Task list (compact) -->
+                            <ItemsControl Grid.Row="3"
+                                          ItemsSource="{Binding CurrentItem.Tasks}"
+                                          IsVisible="{Binding CurrentItem.HasTasks}"
+                                          Margin="0,6,0,0">
+                                <ItemsControl.ItemTemplate>
+                                    <DataTemplate DataType="vm:InstallTaskItemViewModel">
+                                        <Grid ColumnDefinitions="14,*" Margin="0,1">
+                                            <Panel Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center">
+                                                <TextBlock Text="&#x2713;" Foreground="#4CAF50" FontSize="9"
+                                                           IsVisible="{Binding IsCompleted}" />
+                                                <TextBlock Text="&#x25CF;" Foreground="#2196F3" FontSize="7"
+                                                           IsVisible="{Binding IsRunning}"
+                                                           VerticalAlignment="Center" HorizontalAlignment="Center" />
+                                                <TextBlock Text="&#x2715;" Foreground="IndianRed" FontSize="9"
+                                                           IsVisible="{Binding IsFailed}" />
+                                                <TextBlock Text="&#x2015;" Opacity="0.3" FontSize="9"
+                                                           IsVisible="{Binding IsQueued}" />
+                                            </Panel>
+                                            <TextBlock Grid.Column="1"
+                                                       Text="{Binding Title}"
+                                                       FontSize="10"
+                                                       Opacity="0.7"
+                                                       VerticalAlignment="Center"
+                                                       TextTrimming="CharacterEllipsis" />
+                                        </Grid>
+                                    </DataTemplate>
+                                </ItemsControl.ItemTemplate>
+                            </ItemsControl>
                         </Grid>
                     </Border>
                     
diff --git a/LANCommander.Launcher.Models/DownloadQueueRedistributable.cs b/LANCommander.Launcher.Models/DownloadQueueRedistributable.cs
index f4b44cbc..f7cc4c9d 100644
--- a/LANCommander.Launcher.Models/DownloadQueueRedistributable.cs
+++ b/LANCommander.Launcher.Models/DownloadQueueRedistributable.cs
@@ -1,17 +1,11 @@
 using LANCommander.SDK.Enums;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using LANCommander.SDK.Models;
 
 namespace LANCommander.Launcher.Models
 {
     public class DownloadQueueRedistributable : IInstallQueueItem
     {
         public Guid Id { get; set; }
-        public Guid[] AddonIds { get; set; }
-        public Dictionary<Guid, string?> AddonVersions { get; set; }
         public string Title { get; set; }
         public string Version { get; set; }
         public string InstallDirectory { get; set; }
@@ -26,12 +20,10 @@ namespace LANCommander.Launcher.Models
             {
                 switch (Status)
                 {
+                    case InstallStatus.Starting:
                     case InstallStatus.Downloading:
                     case InstallStatus.InstallingRedistributables:
-                    case InstallStatus.InstallingMods:
-                    case InstallStatus.InstallingExpansions:
                     case InstallStatus.RunningScripts:
-                    case InstallStatus.DownloadingSaves:
                         return true;
 
                     default:
@@ -41,10 +33,18 @@ namespace LANCommander.Launcher.Models
         }
         public InstallStatus Status { get; set; }
         public SDK.Models.Redistributable Redistributable { get; set; }
-        public float Progress { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public double TransferSpeed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public long BytesDownloaded { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public long TotalBytes { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public InstallPlanItemType ItemType => InstallPlanItemType.Redistributable;
+        public Guid? DependsOnId { get; set; }
+        public List<InstallTaskDefinition> Tasks { get; set; } = new();
+        public Guid? CurrentTaskId { get; set; }
+        public float Progress
+        {
+            get => BytesDownloaded / (float)Math.Max(TotalBytes, 1);
+            set { }
+        }
+        public double TransferSpeed { get; set; }
+        public long BytesDownloaded { get; set; }
+        public long TotalBytes { get; set; }
         public CancellationTokenSource CancellationToken { get; set; } = new();
 
         public DownloadQueueRedistributable(SDK.Models.Redistributable redistributable)
@@ -52,7 +52,16 @@ namespace LANCommander.Launcher.Models
             Redistributable = redistributable;
             Id = redistributable.Id;
             Title = redistributable.Name;
-            Version = redistributable.Archives.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version;
+            Version = redistributable.Archives?.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version;
+            QueuedOn = DateTime.Now;
+            Status = InstallStatus.Queued;
+        }
+
+        public DownloadQueueRedistributable(InstallPlanItem planItem, SDK.Models.Redistributable redistributable) : this(redistributable)
+        {
+            InstallDirectory = planItem.InstallDirectory;
+            DependsOnId = planItem.DependsOnId;
+            Tasks = planItem.Tasks;
         }
     }
 }
diff --git a/LANCommander.Launcher.Models/IInstallQueueItem.cs b/LANCommander.Launcher.Models/IInstallQueueItem.cs
index 3cdbec74..919aca6a 100644
--- a/LANCommander.Launcher.Models/IInstallQueueItem.cs
+++ b/LANCommander.Launcher.Models/IInstallQueueItem.cs
@@ -1,9 +1,5 @@
 using LANCommander.SDK.Enums;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using LANCommander.SDK.Models;
 
 namespace LANCommander.Launcher.Models
 {
@@ -25,5 +21,9 @@ namespace LANCommander.Launcher.Models
         long BytesDownloaded { get; set; }
         long TotalBytes { get; set; }
         CancellationTokenSource CancellationToken { get; set; }
+        InstallPlanItemType ItemType { get; }
+        Guid? DependsOnId { get; set; }
+        List<InstallTaskDefinition> Tasks { get; set; }
+        Guid? CurrentTaskId { get; set; }
     }
 }
diff --git a/LANCommander.Launcher.Models/InstallQueueGame.cs b/LANCommander.Launcher.Models/InstallQueueGame.cs
index a5a1eb62..16c0676d 100644
--- a/LANCommander.Launcher.Models/InstallQueueGame.cs
+++ b/LANCommander.Launcher.Models/InstallQueueGame.cs
@@ -1,9 +1,5 @@
 using LANCommander.SDK.Enums;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using LANCommander.SDK.Models;
 
 namespace LANCommander.Launcher.Models
 {
@@ -44,10 +40,17 @@ namespace LANCommander.Launcher.Models
         }
         public InstallStatus Status { get; set; }
         public SDK.Models.Game Game { get; set; }
+        public InstallPlanItemType ItemType => InstallPlanItemType.Game;
+        public Guid? DependsOnId { get; set; }
+        public List<InstallTaskDefinition> Tasks { get; set; } = new();
+        public Guid? CurrentTaskId { get; set; }
         public float Progress {
             get
             {
-                return BytesDownloaded / (float)TotalBytes;
+                if (Tasks != null && Tasks.Count > 0)
+                    return BytesDownloaded / (float)Math.Max(TotalBytes, 1);
+
+                return BytesDownloaded / (float)Math.Max(TotalBytes, 1);
             }
             set { }
         }
@@ -61,19 +64,26 @@ namespace LANCommander.Launcher.Models
             Game = game;
             Id = game.Id;
             Title = game.Title;
-            Version = game.Archives.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version;
+            Version = game.Archives?.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version;
             QueuedOn = DateTime.Now;
             Status = InstallStatus.Queued;
 
-            var cover = game.Media.FirstOrDefault(m => m.Type == SDK.Enums.MediaType.Cover);
+            var cover = game.Media?.FirstOrDefault(m => m.Type == SDK.Enums.MediaType.Cover);
 
             if (cover != null)
                 CoverId = cover.Id;
 
-            var icon = game.Media.FirstOrDefault(m => m.Type == SDK.Enums.MediaType.Icon);
+            var icon = game.Media?.FirstOrDefault(m => m.Type == SDK.Enums.MediaType.Icon);
 
             if (icon != null)
                 IconId = icon.Id;
         }
+
+        public InstallQueueGame(InstallPlanItem planItem, SDK.Models.Game game) : this(game)
+        {
+            InstallDirectory = planItem.InstallDirectory;
+            DependsOnId = planItem.DependsOnId;
+            Tasks = planItem.Tasks;
+        }
     }
 }
diff --git a/LANCommander.Launcher.Models/InstallQueueTool.cs b/LANCommander.Launcher.Models/InstallQueueTool.cs
index b48ac2ef..f9e2a4de 100644
--- a/LANCommander.Launcher.Models/InstallQueueTool.cs
+++ b/LANCommander.Launcher.Models/InstallQueueTool.cs
@@ -1,12 +1,11 @@
 using LANCommander.SDK.Enums;
+using LANCommander.SDK.Models;
 
 namespace LANCommander.Launcher.Models;
 
 public class InstallQueueTool : IInstallQueueItem
 {
     public Guid Id { get; set; }
-    public Guid[] AddonIds { get; set; }
-    public Dictionary<Guid, string?> AddonVersions { get; set; }
     public string Title { get; set; }
     public string Version { get; set; }
     public string InstallDirectory { get; set; }
@@ -38,14 +37,18 @@ public class InstallQueueTool : IInstallQueueItem
             }
         }
     }
-    
+
     public InstallStatus Status { get; set; }
     public SDK.Models.Tool Tool { get; set; }
-    
+    public InstallPlanItemType ItemType => InstallPlanItemType.Tool;
+    public Guid? DependsOnId { get; set; }
+    public List<InstallTaskDefinition> Tasks { get; set; } = new();
+    public Guid? CurrentTaskId { get; set; }
+
     public float Progress {
         get
         {
-            return BytesDownloaded / (float)TotalBytes;
+            return BytesDownloaded / (float)Math.Max(TotalBytes, 1);
         }
         set { }
     }
@@ -59,8 +62,15 @@ public class InstallQueueTool : IInstallQueueItem
         Tool = tool;
         Id = tool.Id;
         Title = tool.Name;
-        Version = tool.Archives.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version ?? "";
+        Version = tool.Archives?.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version ?? "";
         QueuedOn = DateTime.Now;
         Status = InstallStatus.Queued;
     }
+
+    public InstallQueueTool(InstallPlanItem planItem, SDK.Models.Tool tool) : this(tool)
+    {
+        InstallDirectory = planItem.InstallDirectory;
+        DependsOnId = planItem.DependsOnId;
+        Tasks = planItem.Tasks;
+    }
 }
\ No newline at end of file
diff --git a/LANCommander.Launcher.Services/InstallService.cs b/LANCommander.Launcher.Services/InstallService.cs
index a1039e69..a5b0d695 100644
--- a/LANCommander.Launcher.Services/InstallService.cs
+++ b/LANCommander.Launcher.Services/InstallService.cs
@@ -1,4 +1,4 @@
-using LANCommander.Launcher.Data.Models;
+using LANCommander.Launcher.Data.Models;
 using LANCommander.Launcher.Models;
 using LANCommander.SDK.Enums;
 using LANCommander.SDK.Exceptions;
@@ -6,7 +6,10 @@ using LANCommander.SDK.Extensions;
 using Microsoft.Extensions.Logging;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using LANCommander.SDK.Models;
 using LANCommander.SDK.Services;
+using Game = LANCommander.Launcher.Data.Models.Game;
+using Tool = LANCommander.Launcher.Data.Models.Tool;
 
 namespace LANCommander.Launcher.Services
 {
@@ -23,11 +26,14 @@ namespace LANCommander.Launcher.Services
         private Stopwatch Stopwatch { get; set; }
 
         public ObservableCollection<IInstallQueueItem> Queue { get; set; }
-        
+
         public delegate Task OnProgressHandler(InstallProgress progress);
 
         public event OnProgressHandler OnProgress;
 
+        public delegate Task OnTaskProgressUpdateHandler(InstallTaskProgress progress);
+        public event OnTaskProgressUpdateHandler OnTaskProgressUpdate;
+
         public delegate Task OnQueueChangedHandler();
         public event OnQueueChangedHandler OnQueueChanged;
 
@@ -54,7 +60,7 @@ namespace LANCommander.Launcher.Services
             _redistributableClient = redistributableClient;
             _toolClient = toolClient;
             _mediaClient = mediaClient;
-            
+
             Stopwatch = new Stopwatch();
 
             Queue = new ObservableCollection<IInstallQueueItem>();
@@ -62,8 +68,9 @@ namespace LANCommander.Launcher.Services
             Queue.CollectionChanged += (sender, e) =>
             {
                 OnQueueChanged?.Invoke();
-            }; 
+            };
 
+            // Legacy progress forwarding for backward compatibility
             _gameClient.OnInstallProgressUpdate += (e) =>
             {
                 OnProgress?.Invoke(e);
@@ -74,17 +81,29 @@ namespace LANCommander.Launcher.Services
                 OnProgress?.Invoke(e);
             };
 
-            // _gameClient.OnArchiveExtractionProgress += Games_OnArchiveExtractionProgress;
-            // _gameClient.OnArchiveEntryExtractionProgress += Games_OnArchiveEntryExtractionProgress;
+            // New task-level progress forwarding
+            _gameClient.OnTaskProgress += OnSdkTaskProgress;
+            _toolClient.OnTaskProgress += OnSdkTaskProgress;
         }
 
-        private void Games_OnArchiveExtractionProgress(long position, long length, SDK.Models.Game game)
+        private void OnSdkTaskProgress(InstallTaskProgress taskProgress)
         {
-            OnQueueChanged?.Invoke();
-        }
+            // Update the matching queue item's current task and progress
+            var queueItem = Queue.FirstOrDefault(i => i.Id == taskProgress.QueueItemId);
 
-        private void Games_OnArchiveEntryExtractionProgress(object sender, SDK.ArchiveEntryExtractionProgressArgs e)
-        {
+            if (queueItem != null)
+            {
+                queueItem.CurrentTaskId = taskProgress.TaskId;
+
+                if (taskProgress.TaskStatus == InstallTaskStatus.Running && taskProgress.TotalBytes > 0)
+                {
+                    queueItem.BytesDownloaded = taskProgress.BytesTransferred;
+                    queueItem.TotalBytes = taskProgress.TotalBytes;
+                    queueItem.TransferSpeed = taskProgress.TransferSpeed;
+                }
+            }
+
+            OnTaskProgressUpdate?.Invoke(taskProgress);
             OnQueueChanged?.Invoke();
         }
 
@@ -99,7 +118,7 @@ namespace LANCommander.Launcher.Services
         public async Task Add(Game game, string installDirectory = "", SDK.Models.Game[]? addons = null)
         {
             var gameInfo = await _gameClient.GetAsync(game.Id);
-            
+
             // TODO: Throw exception (and gracefully handle) when gameInfo == null
             // Game probably couldn't be found or deserialized from server
 
@@ -116,6 +135,7 @@ namespace LANCommander.Launcher.Services
                 }
             }
 
+            // Clear completed items for this game
             try
             {
                 var gameCompletedQueueItems = Queue.Where(i => i.Status == InstallStatus.Complete && i.Id == game.Id).ToList();
@@ -129,49 +149,81 @@ namespace LANCommander.Launcher.Services
             }
             catch (Exception ex)
             {
-
             }
 
-            if (!Queue.Any(i => i.Id == game.Id && i.Status == InstallStatus.Queued))
+            if (Queue.Any(i => i.Id == game.Id && i.Status == InstallStatus.Queued))
+                return;
+
+            // Generate install plan from SDK
+            var addonIds = addons?.Select(x => x.Id).ToArray();
+            var plan = await _gameClient.GenerateInstallPlanAsync(game.Id, installDirectory, addonIds);
+
+            // Add each plan item to the queue
+            foreach (var planItem in plan.Items.OrderBy(i => i.Order))
             {
-                var queueItem = new InstallQueueGame(gameInfo);
+                // Skip if already queued
+                if (Queue.Any(i => i.Id == planItem.EntityId && i.Status.ValueIsIn(InstallStatus.Queued, InstallStatus.Starting, InstallStatus.Downloading)))
+                    continue;
 
-                queueItem.InstallDirectory = installDirectory;
+                IInstallQueueItem queueItem;
 
-                if (addons != null && addons.Length > 0)
+                switch (planItem.Type)
                 {
-                    var versions = addons.ToLookup(addon => addon.Id, x => x.Archives.OrderByDescending(a => a.CreatedOn).FirstOrDefault()?.Version);
-                    var addonIds = addons.Select(x => x.Id).ToArray() ?? [];
+                    case InstallPlanItemType.Game:
+                    case InstallPlanItemType.Addon:
+                        var addonGame = planItem.Type == InstallPlanItemType.Addon
+                            ? await _gameClient.GetAsync(planItem.EntityId)
+                            : gameInfo;
+                        queueItem = new InstallQueueGame(planItem, addonGame);
 
-                    queueItem.AddonIds = addonIds;
-                    queueItem.AddonVersions = addonIds.ToDictionary(x => x, y => versions[y]?.FirstOrDefault());
+                        if (addons != null && planItem.Type == InstallPlanItemType.Game)
+                        {
+                            var gameQueueItem = (InstallQueueGame)queueItem;
+                            gameQueueItem.AddonIds = addonIds;
+                            gameQueueItem.AddonVersions = addons.ToDictionary(
+                                a => a.Id,
+                                a => a.Archives?.OrderByDescending(ar => ar.CreatedOn).FirstOrDefault()?.Version);
+                        }
+                        break;
+
+                    case InstallPlanItemType.Redistributable:
+                        var redist = gameInfo.Redistributables?.FirstOrDefault(r => r.Id == planItem.EntityId);
+                        if (redist == null)
+                            continue;
+                        queueItem = new DownloadQueueRedistributable(planItem, redist);
+                        break;
+
+                    case InstallPlanItemType.Tool:
+                        var tool = await _toolClient.GetAsync(planItem.EntityId);
+                        queueItem = new InstallQueueTool(planItem, tool);
+                        break;
+
+                    default:
+                        continue;
                 }
 
-                if (Queue.Any(i => i.State))
-                    Queue.Add(queueItem);
-                else
+                Queue.Add(queueItem);
+            }
+
+            // Start processing if nothing active
+            if (!Queue.Any(i => i.State))
+            {
+                var firstItem = Queue.FirstOrDefault(i => i.Status == InstallStatus.Queued);
+                if (firstItem != null)
                 {
-                    Logger?.LogTrace("Download queue is empty, starting the game download immediately");
-
-                    queueItem.Status = InstallStatus.Starting;
-
-                    Queue.Add(queueItem);
-
+                    firstItem.Status = InstallStatus.Starting;
                     await Next();
                 }
-
-                OnQueueChanged?.Invoke();
             }
+
+            OnQueueChanged?.Invoke();
         }
-        
+
         public async Task Add(SDK.Models.Tool tool, string installDirectory = "")
         {
             var toolInfo = await _toolClient.GetAsync(tool.Id);
-            
-            // TODO: Throw exception (and gracefully handle) when gameInfo == null
-            // Game probably couldn't be found or deserialized from server
 
-            Logger?.LogTrace("Adding game {ToolName} to the queue", toolInfo.Name);
+            Logger?.LogTrace("Adding tool {ToolName} to the queue", toolInfo.Name);
 
             try
             {
@@ -186,30 +238,34 @@ namespace LANCommander.Launcher.Services
             }
             catch (Exception ex)
             {
-
             }
 
-            if (!Queue.Any(i => i.Id == tool.Id && i.Status == InstallStatus.Queued))
+            if (Queue.Any(i => i.Id == tool.Id && i.Status == InstallStatus.Queued))
+                return;
+
+            // Generate install plan from SDK
+            var plan = await _toolClient.GenerateInstallPlanAsync(toolInfo, installDirectory);
+
+            foreach (var planItem in plan.Items.OrderBy(i => i.Order))
             {
-                var queueItem = new InstallQueueTool(toolInfo);
+                if (Queue.Any(i => i.Id == planItem.EntityId && i.Status.ValueIsIn(InstallStatus.Queued, InstallStatus.Starting, InstallStatus.Downloading)))
+                    continue;
 
-                queueItem.InstallDirectory = installDirectory;
+                var queueItem = new InstallQueueTool(planItem, toolInfo);
+                Queue.Add(queueItem);
+            }
 
-                if (Queue.Any(i => i.State))
-                    Queue.Add(queueItem);
-                else
+            if (!Queue.Any(i => i.State))
+            {
+                var firstItem = Queue.FirstOrDefault(i => i.Status == InstallStatus.Queued);
+                if (firstItem != null)
                 {
-                    Logger?.LogTrace("Download queue is empty, starting the tool download immediately");
-
-                    queueItem.Status = InstallStatus.Starting;
-
-                    Queue.Add(queueItem);
-
+                    firstItem.Status = InstallStatus.Starting;
                     await Next();
                 }
-
-                OnQueueChanged?.Invoke();
             }
+
+            OnQueueChanged?.Invoke();
         }
 
         public void Remove(Guid id)
@@ -218,7 +274,7 @@ namespace LANCommander.Launcher.Services
 
             if (queueItem != null)
             {
-                Logger?.LogTrace("Removing the game {GameTitle} from the queue", queueItem.Title);
+                Logger?.LogTrace("Removing the item {Title} from the queue", queueItem.Title);
 
                 Remove(queueItem);
             }
@@ -228,7 +284,7 @@ namespace LANCommander.Launcher.Services
         {
             if (queueItem != null)
             {
-                Logger?.LogTrace("Removing the game {GameTitle} from the queue", queueItem.Title);
+                Logger?.LogTrace("Removing the item {Title} from the queue", queueItem.Title);
 
                 Queue.Remove(queueItem);
             }
@@ -237,28 +293,50 @@ namespace LANCommander.Launcher.Services
         public async Task CancelInstallAsync(Guid queueItemId)
         {
             var queueItem = Queue.FirstOrDefault(i => i.Id == queueItemId);
-            
+
+            if (queueItem == null)
+                return;
+
             await queueItem.CancellationToken.CancelAsync();
-            
+
             queueItem.Status = InstallStatus.Canceled;
-            
+
             OnQueueChanged?.Invoke();
-            
+
             Logger?.LogTrace("Canceling install queue item {QueueItem}", queueItem.Title);
         }
 
         public async Task Next()
         {
-            var currentItem = Queue.FirstOrDefault(i => i.Status.ValueIsIn(InstallStatus.Queued, InstallStatus.Starting));
+            var pendingItems = Queue.Where(i => i.Status.ValueIsIn(InstallStatus.Queued, InstallStatus.Starting));
 
-            if (currentItem == null)
-                return;
+            foreach (var candidate in pendingItems)
+            {
+                // Check dependency — skip items whose dependency hasn't completed
+                if (candidate.DependsOnId.HasValue)
+                {
+                    var dependency = Queue.FirstOrDefault(i => i.Id == candidate.DependsOnId.Value);
 
-            if (currentItem is InstallQueueGame gameQueueItem)
-                await Next(gameQueueItem);
+                    if (dependency != null && dependency.Status != InstallStatus.Complete)
+                        continue;
+                }
 
-            if (currentItem is InstallQueueTool toolQueueItem)
-                await Next(toolQueueItem);
+                // Found an eligible item — process it
+                switch (candidate)
+                {
+                    case InstallQueueGame gameQueueItem:
+                        await Next(gameQueueItem);
+                        return;
+
+                    case InstallQueueTool toolQueueItem:
+                        await Next(toolQueueItem);
+                        return;
+
+                    case DownloadQueueRedistributable redistQueueItem:
+                        await Next(redistQueueItem);
+                        return;
+                }
+            }
         }
 
         private async Task Next(InstallQueueGame queueItem)
@@ -338,7 +416,7 @@ namespace LANCommander.Launcher.Services
             {
                 localTool = await _toolService.GetAsync(queueItem.Id);
                 remoteTool = await _toolClient.GetAsync(queueItem.Id);
-                
+
                 if (remoteTool == null)
                 {
                     Logger?.LogError("Tool info could not be retrieved from the server");
@@ -351,7 +429,7 @@ namespace LANCommander.Launcher.Services
                 if (localTool == null)
                 {
                     Logger?.LogError("Tool does not exist in local database, importing");
-                    
+
                     await _importService.ImportToolAsync(queueItem.Id);
 
                     await Next(queueItem);
@@ -361,7 +439,7 @@ namespace LANCommander.Launcher.Services
 
                 if (localTool.Installed)
                 {
-                    // Modify
+                    // Modify — currently no-op
                 }
                 else
                 {
@@ -373,20 +451,40 @@ namespace LANCommander.Launcher.Services
             }
         }
 
+        private async Task Next(DownloadQueueRedistributable queueItem)
+        {
+            try
+            {
+                await InstallRedistributable(queueItem);
+            }
+            catch (Exception ex)
+            {
+                Logger?.LogError(ex, "An error occurred while installing redistributable {Title}", queueItem.Title);
+            }
+        }
+
         public async Task Install(InstallQueueGame currentItem, Game localGame, SDK.Models.Game remoteGame)
         {
             using (var operation = Logger.BeginOperation("Installing game {GameTitle} ({GameId})", localGame.Title, localGame.Id))
             {
-                string installDirectory;
-
                 currentItem.Status = InstallStatus.Downloading;
                 OnQueueChanged?.Invoke();
 
                 try
                 {
-                    var gameFileList = await _gameClient.InstallAsync(remoteGame.Id, currentItem.InstallDirectory, currentItem.AddonIds, cancellationToken: currentItem.CancellationToken.Token);
-                    installDirectory = gameFileList.InstallDirectory;
-                    UpdateGameState(currentItem, localGame, installDirectory);
+                    // Build a plan item from the queue item's tasks
+                    var planItem = new InstallPlanItem
+                    {
+                        EntityId = currentItem.Id,
+                        Title = currentItem.Title,
+                        Type = currentItem.ItemType,
+                        InstallDirectory = currentItem.InstallDirectory,
+                        Tasks = currentItem.Tasks,
+                    };
+
+                    var result = await _gameClient.ExecuteInstallPlanItemAsync(planItem, currentItem.CancellationToken.Token);
+
+                    UpdateGameState(currentItem, localGame, result.InstallDirectory);
                 }
                 catch (InstallCanceledException ex)
                 {
@@ -397,13 +495,19 @@ namespace LANCommander.Launcher.Services
                 catch (InstallException ex)
                 {
                     Logger?.LogError(ex, "An error occurred during install, removing from queue");
-                    Queue.Remove(currentItem);
+                    currentItem.Status = InstallStatus.Failed;
+                    OnQueueChanged?.Invoke();
+                    OnInstallFail?.Invoke(localGame);
+                    await Next();
                     return;
                 }
                 catch (Exception ex)
                 {
                     Logger?.LogError(ex, "An unknown error occurred during install, removing from queue");
-                    Queue.Remove(currentItem);
+                    currentItem.Status = InstallStatus.Failed;
+                    OnQueueChanged?.Invoke();
+                    OnInstallFail?.Invoke(localGame);
+                    await Next();
                     return;
                 }
 
@@ -433,32 +537,27 @@ namespace LANCommander.Launcher.Services
                 }
                 #endregion
 
-                if (currentItem is InstallQueueGame)
+                currentItem.CompletedOn = DateTime.Now;
+                currentItem.Status = InstallStatus.Complete;
+                currentItem.Progress = 1;
+                currentItem.BytesDownloaded = currentItem.TotalBytes;
+
+                try
                 {
-                    currentItem.CompletedOn = DateTime.Now;
-                    currentItem.Status = InstallStatus.Complete;
-                    currentItem.Progress = 1;
-                    currentItem.BytesDownloaded = currentItem.TotalBytes;
-
-                    try
-                    {
-                        await _gameService.UpdateAsync(localGame);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logger?.LogError(ex, "An unknown error occurred while trying to write changes to the database after install of game {GameTitle} ({GameId})", localGame.Title, localGame.Id);
-                    }
-
-                    OnQueueChanged?.Invoke();
-
-                    Logger?.LogTrace("Install of game {GameTitle} ({GameId}) complete!", localGame.Title, localGame.Id);
-
-                    // ShowCompletedNotification(currentItem);
-
-                    OnInstallComplete?.Invoke(localGame);
-
-                    operation.Complete();
+                    await _gameService.UpdateAsync(localGame);
                 }
+                catch (Exception ex)
+                {
+                    Logger?.LogError(ex, "An unknown error occurred while trying to write changes to the database after install of game {GameTitle} ({GameId})", localGame.Title, localGame.Id);
+                }
+
+                OnQueueChanged?.Invoke();
+
+                Logger?.LogTrace("Install of game {GameTitle} ({GameId}) complete!", localGame.Title, localGame.Id);
+
+                OnInstallComplete?.Invoke(localGame);
+
+                operation.Complete();
             }
 
             await Next();
@@ -473,7 +572,16 @@ namespace LANCommander.Launcher.Services
 
                 try
                 {
-                    var result = await _toolClient.InstallAsync(remoteTool, currentItem.InstallDirectory);
+                    var planItem = new InstallPlanItem
+                    {
+                        EntityId = currentItem.Id,
+                        Title = currentItem.Title,
+                        Type = InstallPlanItemType.Tool,
+                        InstallDirectory = currentItem.InstallDirectory,
+                        Tasks = currentItem.Tasks,
+                    };
+
+                    var result = await _toolClient.ExecuteInstallPlanItemAsync(planItem, currentItem.CancellationToken.Token);
 
                     UpdateToolState(currentItem, localTool, result.InstallDirectory);
                 }
@@ -509,12 +617,10 @@ namespace LANCommander.Launcher.Services
                 {
                     Logger?.LogError(ex, "An unknown error occurred while trying to write changes to the database after install of tool {ToolName} ({ToolId})", localTool.Name, localTool.Id);
                 }
-                
-                OnQueueChanged?.Invoke();
-                
-                Logger?.LogTrace("Install of tool {ToolName} ({ToolId}) complete!", localTool.Name, localTool.Id);
 
-                // OnInstallComplete?.Invoke(localTool);
+                OnQueueChanged?.Invoke();
+
+                Logger?.LogTrace("Install of tool {ToolName} ({ToolId}) complete!", localTool.Name, localTool.Id);
 
                 operation.Complete();
             }
@@ -522,6 +628,53 @@ namespace LANCommander.Launcher.Services
             await Next();
         }
 
+        private async Task InstallRedistributable(DownloadQueueRedistributable currentItem)
+        {
+            currentItem.Status = InstallStatus.Downloading;
+            OnQueueChanged?.Invoke();
+
+            try
+            {
+                var planItem = new InstallPlanItem
+                {
+                    EntityId = currentItem.Id,
+                    Title = currentItem.Title,
+                    Type = InstallPlanItemType.Redistributable,
+                    InstallDirectory = currentItem.InstallDirectory,
+                    Tasks = currentItem.Tasks,
+                    DependsOnId = currentItem.DependsOnId,
+                };
+
+                await _gameClient.ExecuteInstallPlanItemAsync(planItem, currentItem.CancellationToken.Token);
+            }
+            catch (InstallCanceledException)
+            {
+                Logger?.LogError("Redistributable install canceled");
+                currentItem.Status = InstallStatus.Canceled;
+                OnQueueChanged?.Invoke();
+                await Next();
+                return;
+            }
+            catch (Exception ex)
+            {
+                Logger?.LogError(ex, "Redistributable {Title} failed to install", currentItem.Title);
+                currentItem.Status = InstallStatus.Failed;
+                OnQueueChanged?.Invoke();
+                await Next();
+                return;
+            }
+
+            currentItem.CompletedOn = DateTime.Now;
+            currentItem.Status = InstallStatus.Complete;
+            currentItem.Progress = 1;
+
+            OnQueueChanged?.Invoke();
+
+            Logger?.LogTrace("Install of redistributable {Title} complete!", currentItem.Title);
+
+            await Next();
+        }
+
         private static void UpdateGameState(InstallQueueGame currentItem, Game localGame, string installDirectory)
         {
             localGame.InstallDirectory = installDirectory;
@@ -550,7 +703,7 @@ namespace LANCommander.Launcher.Services
                 }
             }
         }
-        
+
         private static void UpdateToolState(InstallQueueTool currentItem, Tool localTool, string installDirectory)
         {
             localTool.InstallDirectory = installDirectory;
@@ -566,7 +719,7 @@ namespace LANCommander.Launcher.Services
                 currentItem.Status = InstallStatus.Moving;
 
                 OnQueueChanged?.Invoke();
-                
+
                 var newInstallDirectory = await _gameClient.GetInstallDirectory(remoteGame, currentItem.InstallDirectory);
 
                 newInstallDirectory = await _gameClient.MoveAsync(remoteGame, localGame.InstallDirectory, newInstallDirectory);
@@ -582,34 +735,6 @@ namespace LANCommander.Launcher.Services
 
                 operation.Complete();
             }
-
         }
-
-        /*private void ShowCompletedNotification(IDownloadQueueItem queueItem)
-        {
-            var builder = new ToastContentBuilder();
-
-            if (queueItem.IsUpdate)
-                builder.AddText("Game Updated")
-                    .AddText($"{queueItem.Title} has finished updating!");
-            else
-                builder.AddText("Game Installed")
-                    .AddText($"{queueItem.Title} has finished installing!");
-
-            builder.AddArgument("gameId", queueItem.Id.ToString())
-                .AddButton(
-                    new ToastButton()
-                        .SetContent("Play")
-                        .AddArgument("action", "play")
-                )
-                .AddButton(
-                    new ToastButton()
-                        .SetContent("View in Library")
-                        .AddArgument("action", "viewInLibrary")
-                );
-                //.Show
-                // .AddAppLogoOverride()
-                //.Show();
-        }*/
     }
 }
diff --git a/LANCommander.SDK/Clients/GameClient.cs b/LANCommander.SDK/Clients/GameClient.cs
index ddd91d39..b16e8950 100644
--- a/LANCommander.SDK/Clients/GameClient.cs
+++ b/LANCommander.SDK/Clients/GameClient.cs
@@ -85,6 +85,9 @@ namespace LANCommander.SDK.Services
         public delegate void OnInstallProgressUpdateHandler(InstallProgress e);
         public event OnInstallProgressUpdateHandler OnInstallProgressUpdate;
 
+        public delegate void OnTaskProgressHandler(InstallTaskProgress progress);
+        public event OnTaskProgressHandler OnTaskProgress;
+
         private const string PlayerAliasFilename = "PlayerAlias";
         private const string KeyFilename = "Key";
 
@@ -669,6 +672,482 @@ namespace LANCommander.SDK.Services
             return installResult;
         }
 
+        /// <summary>
+        /// Generates an install plan for a game, producing a list of queue items and their tasks
+        /// without executing anything.
+        /// </summary>
+        public async Task<InstallPlan> GenerateInstallPlanAsync(Guid gameId, string installDirectory, Guid[] addonIds = null)
+        {
+            var plan = new InstallPlan();
+            var game = await GetAsync(gameId);
+
+            if (string.IsNullOrWhiteSpace(installDirectory))
+                installDirectory = settingsProvider.CurrentValue.Games.InstallDirectories.First();
+
+            var destination = await GetInstallDirectory(game, installDirectory);
+
+            // Handle standalone mods — need base game first
+            if (game.Type == GameType.StandaloneMod && game.BaseGameId != Guid.Empty)
+            {
+                var baseGame = await GetAsync(game.BaseGameId);
+                var baseDestination = await GetInstallDirectory(baseGame, installDirectory);
+
+                if (!Directory.Exists(baseDestination))
+                {
+                    var basePlan = await GenerateInstallPlanAsync(game.BaseGameId, installDirectory);
+                    plan.Items.AddRange(basePlan.Items);
+                }
+
+                destination = baseDestination;
+            }
+
+            // Base game item
+            var gameItem = new InstallPlanItem
+            {
+                EntityId = game.Id,
+                Title = game.Title,
+                Type = InstallPlanItemType.Game,
+                InstallDirectory = destination,
+                Order = plan.Items.Count,
+            };
+
+            int taskOrder = 0;
+
+            gameItem.Tasks.Add(new InstallTaskDefinition
+            {
+                Type = InstallTaskType.DownloadAndExtract,
+                Title = $"Download {game.Title}",
+                Order = taskOrder++,
+                TargetId = game.Id,
+                TargetName = game.Title,
+                IsCritical = true,
+                ReportsProgress = true,
+            });
+
+            gameItem.Tasks.Add(new InstallTaskDefinition
+            {
+                Type = InstallTaskType.WriteManifest,
+                Title = "Write manifest",
+                Order = taskOrder++,
+                TargetId = game.Id,
+                TargetName = game.Title,
+                IsCritical = true,
+            });
+
+            gameItem.Tasks.Add(new InstallTaskDefinition
+            {
+                Type = InstallTaskType.WriteScripts,
+                Title = "Save scripts",
+                Order = taskOrder++,
+                TargetId = game.Id,
+                TargetName = game.Title,
+                IsCritical = false,
+            });
+
+            gameItem.Tasks.Add(new InstallTaskDefinition
+            {
+                Type = InstallTaskType.DownloadSaves,
+                Title = "Download saves",
+                Order = taskOrder++,
+                TargetId = game.Id,
+                TargetName = game.Title,
+                IsCritical = false,
+                ReportsProgress = true,
+            });
+
+            if (game.Scripts != null && game.Scripts.Any())
+            {
+                gameItem.Tasks.Add(new InstallTaskDefinition
+                {
+                    Type = InstallTaskType.RunInstallScript,
+                    Title = "Run install script",
+                    Order = taskOrder++,
+                    TargetId = game.Id,
+                    TargetName = game.Title,
+                    IsCritical = false,
+                });
+
+                gameItem.Tasks.Add(new InstallTaskDefinition
+                {
+                    Type = InstallTaskType.RunKeyChangeScript,
+                    Title = "Apply key",
+                    Order = taskOrder++,
+                    TargetId = game.Id,
+                    TargetName = game.Title,
+                    IsCritical = false,
+                });
+
+                gameItem.Tasks.Add(new InstallTaskDefinition
+                {
+                    Type = InstallTaskType.RunNameChangeScript,
+                    Title = "Apply player name",
+                    Order = taskOrder++,
+                    TargetId = game.Id,
+                    TargetName = game.Title,
+                    IsCritical = false,
+                });
+            }
+
+            if (game.Media != null)
+            {
+                foreach (var manual in game.Media.Where(m => m.Type == MediaType.Manual))
+                {
+                    gameItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.DownloadManual,
+                        Title = $"Download manual",
+                        Order = taskOrder++,
+                        TargetId = manual.Id,
+                        TargetName = game.Title,
+                        IsCritical = false,
+                    });
+                }
+            }
+
+            plan.Items.Add(gameItem);
+
+            // Redistributable items
+            if (game.Redistributables != null)
+            {
+                foreach (var redist in game.Redistributables)
+                {
+                    var redistItem = new InstallPlanItem
+                    {
+                        EntityId = redist.Id,
+                        Title = redist.Name,
+                        Type = InstallPlanItemType.Redistributable,
+                        InstallDirectory = destination,
+                        Order = plan.Items.Count,
+                        DependsOnId = game.Id,
+                    };
+
+                    redistItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.DownloadAndExtract,
+                        Title = $"Download {redist.Name}",
+                        Order = 0,
+                        TargetId = redist.Id,
+                        TargetName = redist.Name,
+                        IsCritical = true,
+                        ReportsProgress = true,
+                        Parameters = new Dictionary<string, string>
+                        {
+                            ["ParentGameId"] = game.Id.ToString(),
+                        },
+                    });
+
+                    redistItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.RunRedistributableInstallScript,
+                        Title = $"Install {redist.Name}",
+                        Order = 1,
+                        TargetId = redist.Id,
+                        TargetName = redist.Name,
+                        IsCritical = false,
+                        Parameters = new Dictionary<string, string>
+                        {
+                            ["ParentGameId"] = game.Id.ToString(),
+                        },
+                    });
+
+                    plan.Items.Add(redistItem);
+                }
+            }
+
+            // Addon items
+            if (addonIds != null)
+            {
+                foreach (var addonId in addonIds)
+                {
+                    var addon = await GetAsync(addonId);
+
+                    var addonItem = new InstallPlanItem
+                    {
+                        EntityId = addon.Id,
+                        Title = addon.Title,
+                        Type = InstallPlanItemType.Addon,
+                        InstallDirectory = destination,
+                        Order = plan.Items.Count,
+                        DependsOnId = game.Id,
+                    };
+
+                    int addonTaskOrder = 0;
+
+                    addonItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.DownloadAndExtract,
+                        Title = $"Download {addon.Title}",
+                        Order = addonTaskOrder++,
+                        TargetId = addon.Id,
+                        TargetName = addon.Title,
+                        IsCritical = true,
+                        ReportsProgress = true,
+                    });
+
+                    addonItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.WriteManifest,
+                        Title = "Write manifest",
+                        Order = addonTaskOrder++,
+                        TargetId = addon.Id,
+                        TargetName = addon.Title,
+                        IsCritical = true,
+                    });
+
+                    addonItem.Tasks.Add(new InstallTaskDefinition
+                    {
+                        Type = InstallTaskType.WriteScripts,
+                        Title = "Save scripts",
+                        Order = addonTaskOrder++,
+                        TargetId = addon.Id,
+                        TargetName = addon.Title,
+                        IsCritical = false,
+                    });
+
+                    if (addon.Scripts != null && addon.Scripts.Any())
+                    {
+                        addonItem.Tasks.Add(new InstallTaskDefinition
+                        {
+                            Type = InstallTaskType.RunInstallScript,
+                            Title = "Run install script",
+                            Order = addonTaskOrder++,
+                            TargetId = addon.Id,
+                            TargetName = addon.Title,
+                            IsCritical = false,
+                        });
+
+                        addonItem.Tasks.Add(new InstallTaskDefinition
+                        {
+                            Type = InstallTaskType.RunKeyChangeScript,
+                            Title = "Apply key",
+                            Order = addonTaskOrder++,
+                            TargetId = addon.Id,
+                            TargetName = addon.Title,
+                            IsCritical = false,
+                        });
+
+                        addonItem.Tasks.Add(new InstallTaskDefinition
+                        {
+                            Type = InstallTaskType.RunNameChangeScript,
+                            Title = "Apply player name",
+                            Order = addonTaskOrder++,
+                            TargetId = addon.Id,
+                            TargetName = addon.Title,
+                            IsCritical = false,
+                        });
+                    }
+
+                    plan.Items.Add(addonItem);
+                }
+            }
+
+            return plan;
+        }
+
+        /// <summary>
+        /// Executes a single install plan item's tasks in order, firing OnTaskProgress events for each.
+        /// </summary>
+        public async Task<InstallResult> ExecuteInstallPlanItemAsync(InstallPlanItem planItem, CancellationToken cancellationToken = default)
+        {
+            var installResult = new InstallResult(planItem.InstallDirectory, planItem.EntityId);
+
+            switch (planItem.Type)
+            {
+                case InstallPlanItemType.Game:
+                case InstallPlanItemType.Addon:
+                    await ExecuteGamePlanItemAsync(planItem, installResult, cancellationToken);
+                    break;
+
+                case InstallPlanItemType.Redistributable:
+                    await ExecuteRedistributablePlanItemAsync(planItem, installResult, cancellationToken);
+                    break;
+
+                case InstallPlanItemType.Tool:
+                    var toolResult = await toolClient.ExecuteInstallPlanItemAsync(planItem, cancellationToken);
+                    installResult.InstallDirectory = toolResult.InstallDirectory;
+                    break;
+            }
+
+            return installResult;
+        }
+
+        private async Task ExecuteGamePlanItemAsync(InstallPlanItem planItem, InstallResult installResult, CancellationToken cancellationToken)
+        {
+            var game = await GetAsync(planItem.EntityId);
+            var gameFileList = installResult.FileList;
+            SDK.Models.Manifest.Game manifest = null;
+
+            foreach (var taskDef in planItem.Tasks.OrderBy(t => t.Order))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var taskProgress = new InstallTaskProgress
+                {
+                    QueueItemId = planItem.EntityId,
+                    TaskId = taskDef.Id,
+                    TaskType = taskDef.Type,
+                    TaskTitle = taskDef.Title,
+                    TaskStatus = InstallTaskStatus.Running,
+                };
+
+                OnTaskProgress?.Invoke(taskProgress);
+
+                try
+                {
+                    switch (taskDef.Type)
+                    {
+                        case InstallTaskType.DownloadAndExtract:
+                            var result = await RetryHelper.RetryOnExceptionAsync(10, TimeSpan.FromMilliseconds(500), new ExtractionResult(), async () =>
+                            {
+                                return await Task.Run(async () => await DownloadAndExtractAsync(game, planItem.InstallDirectory, cancellationToken));
+                            });
+
+                            if (!result.Success && !result.Canceled)
+                                throw new InstallException("Could not extract the installer. Retry the install or check your connection");
+                            else if (result.Canceled)
+                                throw new InstallCanceledException("Game install was canceled");
+
+                            game.InstallDirectory = result.Directory;
+                            installResult.InstallDirectory = result.Directory;
+                            planItem.InstallDirectory = result.Directory;
+
+                            gameFileList.BaseGame.AddFiles(result.Files?
+                                .Where(x => !x.EntryPath.EndsWith("/"))
+                                .Select(x => new GameInstallationFileListEntry.FileEntry
+                                {
+                                    EntryPath = x.EntryPath,
+                                    LocalPath = x.LocalPath,
+                                }) ?? []);
+                            break;
+
+                        case InstallTaskType.WriteManifest:
+                            manifest = await RetryHelper.RetryOnExceptionAsync(10, TimeSpan.FromSeconds(1), (SDK.Models.Manifest.Game)null, async () =>
+                            {
+                                return await WriteManifestAsync(planItem.InstallDirectory, game);
+                            });
+
+                            if (manifest == null)
+                                throw new InstallException("Could not grab the manifest file. Retry the install or check your connection");
+
+                            gameFileList.BaseGame.Manifest = manifest;
+                            break;
+
+                        case InstallTaskType.WriteScripts:
+                            await WriteScriptsAsync(planItem.InstallDirectory, game);
+                            break;
+
+                        case InstallTaskType.DownloadSaves:
+                            await saveClient.DownloadAsync(planItem.InstallDirectory, game.Id);
+                            break;
+
+                        case InstallTaskType.RunInstallScript:
+                            await scriptClient.Game_RunInstallScriptAsync(planItem.InstallDirectory, game.Id);
+                            break;
+
+                        case InstallTaskType.RunKeyChangeScript:
+                            var allocatedKey = await GetAllocatedKeyAsync(game.Id);
+                            await scriptClient.Game_RunKeyChangeScriptAsync(planItem.InstallDirectory, game.Id, allocatedKey);
+                            break;
+
+                        case InstallTaskType.RunNameChangeScript:
+                            var alias = await profileClient.GetAliasAsync();
+                            await scriptClient.Game_RunNameChangeScriptAsync(planItem.InstallDirectory, game.Id, alias);
+                            break;
+
+                        case InstallTaskType.DownloadManual:
+                            // Manual download handled by caller (InstallService) since it needs MediaClient
+                            break;
+                    }
+
+                    taskProgress.TaskStatus = InstallTaskStatus.Completed;
+                    taskProgress.Progress = 1.0f;
+                    OnTaskProgress?.Invoke(taskProgress);
+                }
+                catch (InstallCanceledException)
+                {
+                    taskProgress.TaskStatus = InstallTaskStatus.Canceled;
+                    OnTaskProgress?.Invoke(taskProgress);
+                    throw;
+                }
+                catch (Exception ex) when (!taskDef.IsCritical)
+                {
+                    logger?.LogError(ex, "Non-critical task {TaskTitle} failed for {GameTitle} ({GameId})", taskDef.Title, game.Title, game.Id);
+                    taskProgress.TaskStatus = InstallTaskStatus.Failed;
+                    taskProgress.ErrorMessage = ex.Message;
+                    OnTaskProgress?.Invoke(taskProgress);
+                }
+            }
+        }
+
+        private async Task ExecuteRedistributablePlanItemAsync(InstallPlanItem planItem, InstallResult installResult, CancellationToken cancellationToken)
+        {
+            // RedistributableClient.InstallAsync bundles download + install into one operation.
+            // We fire task progress for both tasks but execute them as one call.
+            var firstTask = planItem.Tasks.OrderBy(t => t.Order).FirstOrDefault();
+            if (firstTask == null)
+                return;
+
+            // Get parent game context from task parameters
+            Guid parentGameId = Guid.Empty;
+            if (firstTask.Parameters.TryGetValue("ParentGameId", out var parentGameIdStr))
+                Guid.TryParse(parentGameIdStr, out parentGameId);
+
+            var taskProgress = new InstallTaskProgress
+            {
+                QueueItemId = planItem.EntityId,
+                TaskId = firstTask.Id,
+                TaskType = firstTask.Type,
+                TaskTitle = firstTask.Title,
+                TaskStatus = InstallTaskStatus.Running,
+            };
+
+            OnTaskProgress?.Invoke(taskProgress);
+
+            try
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var game = parentGameId != Guid.Empty ? await GetAsync(parentGameId) : null;
+
+                if (game != null)
+                {
+                    game.InstallDirectory = planItem.InstallDirectory;
+
+                    var redist = game.Redistributables?.FirstOrDefault(r => r.Id == planItem.EntityId);
+
+                    if (redist != null)
+                        await redistributableClient.InstallAsync(redist, game);
+                }
+
+                // Mark all tasks as completed
+                foreach (var taskDef in planItem.Tasks.OrderBy(t => t.Order))
+                {
+                    OnTaskProgress?.Invoke(new InstallTaskProgress
+                    {
+                        QueueItemId = planItem.EntityId,
+                        TaskId = taskDef.Id,
+                        TaskType = taskDef.Type,
+                        TaskTitle = taskDef.Title,
+                        TaskStatus = InstallTaskStatus.Completed,
+                        Progress = 1.0f,
+                    });
+                }
+            }
+            catch (InstallCanceledException)
+            {
+                taskProgress.TaskStatus = InstallTaskStatus.Canceled;
+                OnTaskProgress?.Invoke(taskProgress);
+                throw;
+            }
+            catch (Exception ex)
+            {
+                logger?.LogError(ex, "Redistributable {RedistName} failed to install", planItem.Title);
+                taskProgress.TaskStatus = InstallTaskStatus.Failed;
+                taskProgress.ErrorMessage = ex.Message;
+                OnTaskProgress?.Invoke(taskProgress);
+            }
+        }
+
         public async Task<InstallResult> UninstallAsync(string installDirectory, Guid gameId)
         {
             var installResult = new InstallResult(installDirectory, gameId);
diff --git a/LANCommander.SDK/Clients/ToolClient.cs b/LANCommander.SDK/Clients/ToolClient.cs
index a47d8a32..571b0ef9 100644
--- a/LANCommander.SDK/Clients/ToolClient.cs
+++ b/LANCommander.SDK/Clients/ToolClient.cs
@@ -15,6 +15,7 @@ using Force.Crc32;
 using LANCommander.SDK.Abstractions;
 using LANCommander.SDK.Exceptions;
 using LANCommander.SDK.Factories;
+using Action = System.Action;
 
 namespace LANCommander.SDK.Services
 {
@@ -90,6 +91,117 @@ namespace LANCommander.SDK.Services
                 .StreamAsync();
         }
 
+        public delegate void OnTaskProgressHandler(InstallTaskProgress progress);
+        public event OnTaskProgressHandler OnTaskProgress;
+
+        public async Task<InstallPlan> GenerateInstallPlanAsync(Tool tool, string installDirectory)
+        {
+            var plan = new InstallPlan();
+
+            var toolItem = new InstallPlanItem
+            {
+                EntityId = tool.Id,
+                Title = tool.Name,
+                Type = InstallPlanItemType.Tool,
+                InstallDirectory = installDirectory,
+                Order = 0,
+            };
+
+            int taskOrder = 0;
+
+            toolItem.Tasks.Add(new InstallTaskDefinition
+            {
+                Type = InstallTaskType.DownloadAndExtract,
+                Title = $"Download {tool.Name}",
+                Order = taskOrder++,
+                TargetId = tool.Id,
+                TargetName = tool.Name,
+                IsCritical = true,
+                ReportsProgress = true,
+            });
+
+            if (tool.Scripts != null && tool.Scripts.Any())
+            {
+                toolItem.Tasks.Add(new InstallTaskDefinition
+                {
+                    Type = InstallTaskType.RunInstallScript,
+                    Title = "Run install script",
+                    Order = taskOrder++,
+                    TargetId = tool.Id,
+                    TargetName = tool.Name,
+                    IsCritical = false,
+                });
+            }
+
+            plan.Items.Add(toolItem);
+
+            return plan;
+        }
+
+        public async Task<InstallResult> ExecuteInstallPlanItemAsync(InstallPlanItem planItem, CancellationToken cancellationToken = default)
+        {
+            var tool = await GetAsync(planItem.EntityId);
+            var installResult = new InstallResult();
+
+            foreach (var taskDef in planItem.Tasks.OrderBy(t => t.Order))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var taskProgress = new InstallTaskProgress
+                {
+                    QueueItemId = planItem.EntityId,
+                    TaskId = taskDef.Id,
+                    TaskType = taskDef.Type,
+                    TaskTitle = taskDef.Title,
+                    TaskStatus = InstallTaskStatus.Running,
+                };
+
+                OnTaskProgress?.Invoke(taskProgress);
+
+                try
+                {
+                    switch (taskDef.Type)
+                    {
+                        case InstallTaskType.DownloadAndExtract:
+                            var result = await RetryHelper.RetryOnExceptionAsync(10,
+                                TimeSpan.FromMilliseconds(500), new ExtractionResult(),
+                                async () => await Task.Run(async () => await DownloadAndExtractAsync(tool, planItem.InstallDirectory, cancellationToken)));
+
+                            if (!result.Success && !result.Canceled)
+                                throw new InstallException("Could not extract the tool. Retry the install or check your connection");
+                            else if (result.Canceled)
+                                throw new InstallCanceledException("Tool install was canceled");
+
+                            installResult.InstallDirectory = result.Directory;
+                            break;
+
+                        case InstallTaskType.RunInstallScript:
+                            await scriptClient.Tool_RunInstallScriptAsync(planItem.InstallDirectory, tool.Id);
+                            break;
+                    }
+
+                    taskProgress.TaskStatus = InstallTaskStatus.Completed;
+                    taskProgress.Progress = 1.0f;
+                    OnTaskProgress?.Invoke(taskProgress);
+                }
+                catch (InstallCanceledException)
+                {
+                    taskProgress.TaskStatus = InstallTaskStatus.Canceled;
+                    OnTaskProgress?.Invoke(taskProgress);
+                    throw;
+                }
+                catch (Exception ex) when (!taskDef.IsCritical)
+                {
+                    logger?.LogError(ex, "Non-critical task {TaskTitle} failed for tool {ToolName}", taskDef.Title, tool.Name);
+                    taskProgress.TaskStatus = InstallTaskStatus.Failed;
+                    taskProgress.ErrorMessage = ex.Message;
+                    OnTaskProgress?.Invoke(taskProgress);
+                }
+            }
+
+            return installResult;
+        }
+
         public async Task InstallAsync(Game game)
         {
             foreach (var tool in game.Tools)
diff --git a/LANCommander.SDK/Enums/InstallPlanItemType.cs b/LANCommander.SDK/Enums/InstallPlanItemType.cs
new file mode 100644
index 00000000..8788532e
--- /dev/null
+++ b/LANCommander.SDK/Enums/InstallPlanItemType.cs
@@ -0,0 +1,10 @@
+namespace LANCommander.SDK.Enums
+{
+    public enum InstallPlanItemType
+    {
+        Game,
+        Addon,
+        Redistributable,
+        Tool
+    }
+}
diff --git a/LANCommander.SDK/Enums/InstallTaskStatus.cs b/LANCommander.SDK/Enums/InstallTaskStatus.cs
new file mode 100644
index 00000000..319a2eb0
--- /dev/null
+++ b/LANCommander.SDK/Enums/InstallTaskStatus.cs
@@ -0,0 +1,12 @@
+namespace LANCommander.SDK.Enums
+{
+    public enum InstallTaskStatus
+    {
+        Queued,
+        Running,
+        Completed,
+        Failed,
+        Skipped,
+        Canceled
+    }
+}
diff --git a/LANCommander.SDK/Enums/InstallTaskType.cs b/LANCommander.SDK/Enums/InstallTaskType.cs
new file mode 100644
index 00000000..137152b7
--- /dev/null
+++ b/LANCommander.SDK/Enums/InstallTaskType.cs
@@ -0,0 +1,17 @@
+namespace LANCommander.SDK.Enums
+{
+    public enum InstallTaskType
+    {
+        DownloadAndExtract,
+        WriteManifest,
+        WriteScripts,
+        VerifyFiles,
+        DownloadSaves,
+        RunInstallScript,
+        RunKeyChangeScript,
+        RunNameChangeScript,
+        RunRedistributableInstallScript,
+        DownloadManual,
+        MoveFiles
+    }
+}
diff --git a/LANCommander.SDK/Models/InstallPlan.cs b/LANCommander.SDK/Models/InstallPlan.cs
new file mode 100644
index 00000000..34a65313
--- /dev/null
+++ b/LANCommander.SDK/Models/InstallPlan.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace LANCommander.SDK.Models
+{
+    public class InstallPlan
+    {
+        public List<InstallPlanItem> Items { get; set; } = new();
+    }
+}
diff --git a/LANCommander.SDK/Models/InstallPlanItem.cs b/LANCommander.SDK/Models/InstallPlanItem.cs
new file mode 100644
index 00000000..0bc4862b
--- /dev/null
+++ b/LANCommander.SDK/Models/InstallPlanItem.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using LANCommander.SDK.Enums;
+
+namespace LANCommander.SDK.Models
+{
+    public class InstallPlanItem
+    {
+        public Guid EntityId { get; set; }
+        public string Title { get; set; }
+        public InstallPlanItemType Type { get; set; }
+        public string InstallDirectory { get; set; }
+        public int Order { get; set; }
+        public List<InstallTaskDefinition> Tasks { get; set; } = new();
+        public Guid? DependsOnId { get; set; }
+    }
+}
diff --git a/LANCommander.SDK/Models/InstallTaskDefinition.cs b/LANCommander.SDK/Models/InstallTaskDefinition.cs
new file mode 100644
index 00000000..ba4c1fdf
--- /dev/null
+++ b/LANCommander.SDK/Models/InstallTaskDefinition.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using LANCommander.SDK.Enums;
+
+namespace LANCommander.SDK.Models
+{
+    public class InstallTaskDefinition
+    {
+        public Guid Id { get; set; } = Guid.NewGuid();
+        public InstallTaskType Type { get; set; }
+        public string Title { get; set; }
+        public int Order { get; set; }
+        public Guid TargetId { get; set; }
+        public string TargetName { get; set; }
+        public bool IsCritical { get; set; }
+        public bool ReportsProgress { get; set; }
+        public Dictionary<string, string> Parameters { get; set; } = new();
+    }
+}
diff --git a/LANCommander.SDK/Models/InstallTaskProgress.cs b/LANCommander.SDK/Models/InstallTaskProgress.cs
new file mode 100644
index 00000000..28aeb638
--- /dev/null
+++ b/LANCommander.SDK/Models/InstallTaskProgress.cs
@@ -0,0 +1,21 @@
+using System;
+using LANCommander.SDK.Enums;
+
+namespace LANCommander.SDK.Models
+{
+    public class InstallTaskProgress
+    {
+        public Guid QueueItemId { get; set; }
+        public Guid TaskId { get; set; }
+        public InstallTaskType TaskType { get; set; }
+        public string TaskTitle { get; set; }
+        public InstallTaskStatus TaskStatus { get; set; }
+        public float Progress { get; set; }
+        public long BytesTransferred { get; set; }
+        public long TotalBytes { get; set; }
+        public long TransferSpeed { get; set; }
+        public TimeSpan TimeRemaining { get; set; }
+        public bool Indeterminate { get; set; }
+        public string ErrorMessage { get; set; }
+    }
+}