fix: address review feedback.

- Fix Resume() ignoring Pending state, causing queued downloads to stall after ProcessPendingDownloads() enqueues them (P1)

- Preserve sidecar files (.cm-info.json, preview image) on download failure so manual retry can succeed; only delete sidecars on explicit cancel or dismiss (P2)

- Add Dismiss action to TrackedDownload, ownloadProgressItemViewModel, and ProgressManagerPage so users can clean up failed downloads without retrying, orphaning sidecars in the process

- Fix KeyNotFoundException crash in UpdateJsonForDownload when Dismiss fires a state-change event after the download was already removed from the tracking dictionary on failure

- Add unit tests: Resume_WhileInPendingState_SetsStateToWorking,
OnFailed_SidecarFilesPreservedForRetry, OnCancelled_SidecarFilesAreDeleted

Author: NeuralFault

StabilityMatrix.Avalonia/ViewModels/Base/PausableProgressItemViewModelBase.cs

@@ -15,7 +15,8 @@ public abstract partial class PausableProgressItemViewModelBase : ProgressItemVi
         nameof(IsCompleted),
         nameof(CanPauseResume),
         nameof(CanCancel),
-        nameof(CanRetry)
+        nameof(CanRetry),
+        nameof(CanDismiss)
     )]
     private ProgressState state = ProgressState.Inactive;
 
@@ -40,6 +41,12 @@ public abstract partial class PausableProgressItemViewModelBase : ProgressItemVi
     /// </summary>
     public virtual bool SupportsRetry => false;
 
+    /// <summary>
+    /// Override to true in subclasses that support dismissing a failed item,
+    /// which runs full sidecar cleanup before removing the entry.
+    /// </summary>
+    public virtual bool SupportsDismiss => false;
+
     public bool CanPauseResume => SupportsPauseResume && !IsCompleted && !IsPending;
     public bool CanCancel => SupportsCancel && !IsCompleted;
 
@@ -48,6 +55,11 @@ public abstract partial class PausableProgressItemViewModelBase : ProgressItemVi
     /// </summary>
     public bool CanRetry => SupportsRetry && State == ProgressState.Failed;
 
+    /// <summary>
+    /// True only when this item supports dismiss AND is in the Failed state.
+    /// </summary>
+    public bool CanDismiss => SupportsDismiss && State == ProgressState.Failed;
+
     private AsyncRelayCommand? pauseCommand;
     public IAsyncRelayCommand PauseCommand => pauseCommand ??= new AsyncRelayCommand(Pause);
 
@@ -68,6 +80,11 @@ public abstract partial class PausableProgressItemViewModelBase : ProgressItemVi
 
     public virtual Task Retry() => Task.CompletedTask;
 
+    private AsyncRelayCommand? dismissCommand;
+    public IAsyncRelayCommand DismissCommand => dismissCommand ??= new AsyncRelayCommand(Dismiss);
+
+    public virtual Task Dismiss() => Task.CompletedTask;
+
     [RelayCommand]
     private Task TogglePauseResume()
     {

StabilityMatrix.Avalonia/ViewModels/Progress/DownloadProgressItemViewModel.cs

@@ -76,6 +76,12 @@ private void OnProgressStateChanged(ProgressState state)
     /// </summary>
     public override bool SupportsRetry => true;
 
+    /// <summary>
+    /// Downloads support dismiss, which cleans up all sidecar files when
+    /// the user discards a failed download without retrying.
+    /// </summary>
+    public override bool SupportsDismiss => true;
+
     /// <inheritdoc />
     public override Task Cancel()
     {
@@ -106,4 +112,13 @@ public override Task Retry()
         download.ResetAttempts();
         return downloadService.TryRestartDownload(download);
     }
+
+    /// <inheritdoc />
+    /// Runs full cleanup (temp file + sidecar files) for a failed download the user
+    /// chooses not to retry, then transitions to Cancelled so the service removes it.
+    public override Task Dismiss()
+    {
+        download.Dismiss();
+        return Task.CompletedTask;
+    }
 }

StabilityMatrix.Avalonia/Views/ProgressManagerPage.axaml

@@ -122,6 +122,15 @@
                                         ToolTip.Tip="Retry download">
                                         <ui:SymbolIcon Symbol="Refresh" />
                                     </Button>
+
+                                    <!--  Dismiss button: cleans up sidecar files for failed downloads that won't be retried  -->
+                                    <Button
+                                        Classes="transparent-full"
+                                        Command="{Binding DismissCommand}"
+                                        IsVisible="{Binding CanDismiss}"
+                                        ToolTip.Tip="Dismiss and clean up">
+                                        <ui:SymbolIcon Symbol="Delete" />
+                                    </Button>
                                 </StackPanel>
 
                                 <ProgressBar

StabilityMatrix.Core/Models/TrackedDownload.cs

@@ -217,7 +217,11 @@ internal void Resume()
         // Cancel any pending auto-retry delay since we're resuming now.
         CancelRetryDelay();
 
-        if (ProgressState != ProgressState.Inactive && ProgressState != ProgressState.Paused)
+        if (
+            ProgressState != ProgressState.Inactive
+            && ProgressState != ProgressState.Paused
+            && ProgressState != ProgressState.Pending
+        )
         {
             Logger.Warn(
                 "Attempted to resume download {Download} but it is not paused ({State})",
@@ -272,6 +276,33 @@ public void Pause()
         OnProgressStateChanged(ProgressState);
     }
 
+    /// <summary>
+    /// Cleans up temp file and all sidecar files (e.g. .cm-info.json, preview image)
+    /// for a download that has already failed and will not be retried.
+    /// This transitions the state to <see cref="ProgressState.Cancelled"/> so the
+    /// service removes the tracking entry.
+    /// </summary>
+    public void Dismiss()
+    {
+        if (ProgressState != ProgressState.Failed)
+        {
+            Logger.Warn(
+                "Attempted to dismiss download {Download} but it is not in a failed state ({State})",
+                FileName,
+                ProgressState
+            );
+            return;
+        }
+
+        Logger.Debug("Dismissing failed download {Download}", FileName);
+
+        DoCleanup();
+
+        OnProgressStateChanging(ProgressState.Cancelled);
+        ProgressState = ProgressState.Cancelled;
+        OnProgressStateChanged(ProgressState);
+    }
+
     public void Cancel()
     {
         if (ProgressState is not (ProgressState.Working or ProgressState.Inactive))
@@ -313,9 +344,12 @@ public void SetPending()
     }
 
     /// <summary>
-    /// Deletes the temp file and any extra cleanup files
+    /// Deletes the temp file and, optionally, any extra cleanup files (e.g. sidecar metadata).
+    /// Pass <paramref name="includeExtraCleanupFiles"/> as <c>false</c> when the download
+    /// failed but may be retried — sidecar files (.cm-info.json, preview image) should survive
+    /// so a manual retry doesn't need to recreate them.
     /// </summary>
-    private void DoCleanup()
+    private void DoCleanup(bool includeExtraCleanupFiles = true)
     {
         try
         {
@@ -326,6 +360,9 @@ private void DoCleanup()
             Logger.Warn("Failed to delete temp file {TempFile}", TempFileName);
         }
 
+        if (!includeExtraCleanupFiles)
+            return;
+
         foreach (var extraFile in ExtraCleanupFileNames)
         {
             try
@@ -440,11 +477,17 @@ private void OnDownloadTaskCompleted(Task task)
             ProgressState = ProgressState.Success;
         }
 
-        // For failed or cancelled, delete the temp files
-        if (ProgressState is ProgressState.Failed or ProgressState.Cancelled)
+        // For cancelled, delete the temp file and any sidecar metadata.
+        // For failed, only delete the temp file — sidecar files (.cm-info.json, preview image)
+        // are preserved so a manual retry doesn't need to recreate them.
+        if (ProgressState is ProgressState.Cancelled)
         {
             DoCleanup();
         }
+        else if (ProgressState is ProgressState.Failed)
+        {
+            DoCleanup(includeExtraCleanupFiles: false);
+        }
         // For pause, just do nothing
 
         OnProgressStateChanged(ProgressState);

StabilityMatrix.Core/Services/TrackedDownloadService.cs

@@ -245,12 +245,17 @@ private void AdjustSemaphoreCount()
     /// </summary>
     private void UpdateJsonForDownload(TrackedDownload download)
     {
+        // The download may have already been removed from the dictionary (e.g. it failed and was
+        // then dismissed). In that case there is nothing to persist, so skip silently.
+        if (!downloads.TryGetValue(download.Id, out var downloadInfo))
+            return;
+
         // Serialize to json
         var json = JsonSerializer.Serialize(download);
         var jsonBytes = Encoding.UTF8.GetBytes(json);
 
         // Write to file
-        var (_, fs) = downloads[download.Id];
+        var (_, fs) = downloadInfo;
         fs.Seek(0, SeekOrigin.Begin);
         fs.Write(jsonBytes);
         fs.Flush();

StabilityMatrix.Tests/Models/TrackedDownloadTests.cs

@@ -0,0 +1,178 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using NSubstitute;
+using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.FileInterfaces;
+using StabilityMatrix.Core.Models.Progress;
+using StabilityMatrix.Core.Services;
+
+namespace StabilityMatrix.Tests.Models;
+
+[TestClass]
+public class TrackedDownloadTests
+{
+    private string tempDir = null!;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+        Directory.CreateDirectory(tempDir);
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        if (Directory.Exists(tempDir))
+            Directory.Delete(tempDir, recursive: true);
+    }
+
+    private TrackedDownload CreateDownload(IDownloadService downloadService)
+    {
+        var download = new TrackedDownload
+        {
+            Id = Guid.NewGuid(),
+            SourceUrl = new Uri("https://example.com/model.safetensors"),
+            DownloadDirectory = new DirectoryPath(tempDir),
+            FileName = "model.safetensors",
+            TempFileName = "model.safetensors.partial",
+        };
+        download.SetDownloadService(downloadService);
+        return download;
+    }
+
+    // Resume() must proceed when the state is Pending (queued resume fix).
+
+    [TestMethod]
+    public async Task Resume_WhileInPendingState_SetsStateToWorking()
+    {
+        // Arrange – download service that blocks forever until cancelled.
+        var downloadService = Substitute.For<IDownloadService>();
+        downloadService
+            .ResumeDownloadToFileAsync(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<long>(),
+                Arg.Any<IProgress<ProgressReport>>(),
+                Arg.Any<string?>(),
+                Arg.Any<CancellationToken>()
+            )
+            .Returns(callInfo =>
+            {
+                var ct = callInfo.Arg<CancellationToken>();
+                return Task.Delay(Timeout.Infinite, ct);
+            });
+
+        var download = CreateDownload(downloadService);
+        download.SetPending(); // Simulate being queued
+
+        // Act
+        download.Resume();
+
+        // Assert – Resume() must not have returned early; state is now Working.
+        Assert.AreEqual(ProgressState.Working, download.ProgressState);
+
+        // Cleanup – cancel and wait for the task to finish.
+        var cancelledTcs = new TaskCompletionSource();
+        download.ProgressStateChanged += (_, state) =>
+        {
+            if (state == ProgressState.Cancelled)
+                cancelledTcs.TrySetResult();
+        };
+        download.Cancel();
+        await cancelledTcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+    }
+
+    // Sidecar files (.cm-info.json, preview image) must survive a failed
+    // download so a manual retry can succeed without recreating them.
+
+    [TestMethod]
+    public async Task OnFailed_SidecarFilesPreservedForRetry()
+    {
+        // Arrange – create sidecar files that ModelImportService would have written.
+        var sidecarPath = Path.Combine(tempDir, "model.cm-info.json");
+        var previewPath = Path.Combine(tempDir, "model.preview.png");
+        await File.WriteAllTextAsync(sidecarPath, "{}");
+        await File.WriteAllTextAsync(previewPath, "PNG");
+
+        // Download service that immediately throws a non-transient error
+        // (InvalidOperationException is not an IOException/AuthenticationException,
+        //  so it goes straight to Failed without any auto-retry attempts).
+        var downloadService = Substitute.For<IDownloadService>();
+        downloadService
+            .ResumeDownloadToFileAsync(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<long>(),
+                Arg.Any<IProgress<ProgressReport>>(),
+                Arg.Any<string?>(),
+                Arg.Any<CancellationToken>()
+            )
+            .Returns(Task.FromException(new InvalidOperationException("Simulated download error")));
+
+        var download = CreateDownload(downloadService);
+        download.ExtraCleanupFileNames.Add(sidecarPath);
+        download.ExtraCleanupFileNames.Add(previewPath);
+
+        var failedTcs = new TaskCompletionSource();
+        download.ProgressStateChanged += (_, state) =>
+        {
+            if (state == ProgressState.Failed)
+                failedTcs.TrySetResult();
+        };
+
+        // Act
+        download.Start();
+        await failedTcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        // Assert – sidecar files must still exist for a potential manual retry.
+        Assert.IsTrue(File.Exists(sidecarPath), ".cm-info.json should be preserved after failure");
+        Assert.IsTrue(File.Exists(previewPath), "Preview image should be preserved after failure");
+    }
+
+    [TestMethod]
+    public async Task OnCancelled_SidecarFilesAreDeleted()
+    {
+        // Sidecar files should still be cleaned up when the user explicitly cancels.
+        var sidecarPath = Path.Combine(tempDir, "model.cm-info.json");
+        var previewPath = Path.Combine(tempDir, "model.preview.png");
+        await File.WriteAllTextAsync(sidecarPath, "{}");
+        await File.WriteAllTextAsync(previewPath, "PNG");
+
+        var downloadService = Substitute.For<IDownloadService>();
+        downloadService
+            .ResumeDownloadToFileAsync(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<long>(),
+                Arg.Any<IProgress<ProgressReport>>(),
+                Arg.Any<string?>(),
+                Arg.Any<CancellationToken>()
+            )
+            .Returns(callInfo =>
+            {
+                var ct = callInfo.Arg<CancellationToken>();
+                return Task.Delay(Timeout.Infinite, ct);
+            });
+
+        var download = CreateDownload(downloadService);
+        download.ExtraCleanupFileNames.Add(sidecarPath);
+        download.ExtraCleanupFileNames.Add(previewPath);
+
+        var cancelledTcs = new TaskCompletionSource();
+        download.ProgressStateChanged += (_, state) =>
+        {
+            if (state == ProgressState.Cancelled)
+                cancelledTcs.TrySetResult();
+        };
+
+        download.Start();
+        download.Cancel();
+        await cancelledTcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        Assert.IsFalse(File.Exists(sidecarPath), ".cm-info.json should be deleted on cancel");
+        Assert.IsFalse(File.Exists(previewPath), "Preview image should be deleted on cancel");
+    }
+}