diff --git a/TinfoilVibeServer/Services/ROMArchiveReader.cs b/TinfoilVibeServer/Services/ROMArchiveReader.cs
index cecad01..f5ef348 100644
--- a/TinfoilVibeServer/Services/ROMArchiveReader.cs
+++ b/TinfoilVibeServer/Services/ROMArchiveReader.cs
@@ -17,7 +17,7 @@ namespace TinfoilVibeServer.Services
     /// <summary>
     /// Reads a ROM archive (zip / 7z / rar) from a stream.
     /// </summary>
-    public sealed class RomArchiveReader : IDisposable
+    public sealed class RomArchiveReader : IDisposable, IAsyncDisposable
     {
         private readonly ZipArchive?   _zipArchive;
         private readonly IArchive?    _archive;
@@ -165,9 +165,31 @@ namespace TinfoilVibeServer.Services
         /// </summary>
         public void Dispose()
         {
-            _zipArchive?.Dispose();
-            _archive?.Dispose();
-            _archiveStream?.Dispose();
+            DisposeAsync().GetAwaiter().GetResult();
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            // Dispose ZipArchive (no async support – just dispose synchronously)
+            if (_zipArchive is IAsyncDisposable asyncZip)
+                await asyncZip.DisposeAsync().ConfigureAwait(false);
+            else
+                _zipArchive?.Dispose();
+            // Dispose SharpCompress IArchive (no async support)
+            if (_archive is IAsyncDisposable asyncArc)
+                await asyncArc.DisposeAsync().ConfigureAwait(false);
+            else
+                _archive?.Dispose();
+            // Dispose the underlying stream (may support async)
+            if (_archiveStream is IAsyncDisposable asyncStream)
+                await asyncStream.DisposeAsync().ConfigureAwait(false);
+            else
+                _archiveStream?.Dispose();
+            // Avoid double‑dispose if the caller disposes again.
+            // (not strictly required but prevents accidental misuse)
+            // _zipArchive = null; // not possible – fields are readonly
+            // _archive = null;
+            // _archiveStream = null;
         }
 
         /// <summary>
diff --git a/TinfoilVibeServer/Services/SnapshotService.cs b/TinfoilVibeServer/Services/SnapshotService.cs
index 281993e..161c1ef 100644
--- a/TinfoilVibeServer/Services/SnapshotService.cs
+++ b/TinfoilVibeServer/Services/SnapshotService.cs
@@ -24,7 +24,7 @@ public interface ISnapshotService
     Task RebuildSnapshotAsync(CancellationToken cancellationToken = default);
     SnapshotService.ROMSnapshot GetSnapshot();
     
-    Task AddToSnapshotAsync(FileEntry entry);
+    Task AddToSnapshotAsync(FileEntry entry, CancellationToken cancellationToken = default);
     Task BuildSnapshotAsync(CancellationToken cancellationToken = default);
     void GetArchiveName(string titleId);
     char GetArchivePathSeparator();
@@ -308,13 +308,13 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
 
     #region Snapshot logic
 
-    public Task AddToSnapshotAsync(FileEntry entry)
+    public async Task AddToSnapshotAsync(FileEntry entry, CancellationToken cancellationToken = default)
     {
         // Update lookup tables
         if (entry.Hash == null)
         {
             _logger.LogWarning("Cannot add entry {Path} to snapshot: no hash", entry.Path);
-            return Task.CompletedTask;
+            return;
         }
 
         var lastModified = File.GetLastWriteTimeUtc(entry.Path.Contains(ArchivePathSeparator) ? entry.Path.Split(ArchivePathSeparator)[0] : entry.Path);
@@ -343,8 +343,9 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
         }
 
         // Persist snapshot to disk
-        PersistSnapshotAsync();
-        return Task.CompletedTask;
+        var titleIds = entry.Titles.Aggregate("", (current, titles) => $"{current} ,{titles.TitleId}");
+        _logger.LogInformation("Added {Path} to snapshot, titleIds=[{TitleIds}]", entry.Path, titleIds);
+        await PersistSnapshotAsync(cancellationToken);
     }
 
     /* ==============================================================
@@ -452,7 +453,8 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                 {
                     //var titleInfo = _titleDatabaseService.GetAsync(ncaMetadataWithHash.TitleId).Result;
                     var fileEntryFromFileName = new FileEntry(file, fileInfo.Length, ncaMetadataWithHash.Hash, [ncaMetadataWithHash]);
-                    AddToSnapshotAsync(fileEntryFromFileName);
+                    var addToSnapshotAsync = AddToSnapshotAsync(fileEntryFromFileName, cancellationToken);
+                    addToSnapshotAsync.Wait(cancellationToken);
                     cancellationToken.ThrowIfCancellationRequested();
                     yield return fileEntryFromFileName;
                     continue;
@@ -472,7 +474,8 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                 if (title != null)
                 {
                     var romEntry = new FileEntry(file, nspStreamLength, hash, [title]);
-                    AddToSnapshotAsync(romEntry);
+                    var addToSnapshotAsync = AddToSnapshotAsync(romEntry, cancellationToken);
+                    addToSnapshotAsync.Wait(cancellationToken);
                     titles.Add((title.TitleId, nspStreamLength, title));
                     cancellationToken.ThrowIfCancellationRequested();
                     yield return romEntry;
@@ -486,7 +489,7 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                     if (_archiveLookup.ContainsKey(file)) continue;
                     if (processedFiles.Contains(file)) continue;
                     _logger.LogDebug("Extracting hash for {File}", file);
-                    Stopwatch stopwatch = Stopwatch.StartNew();
+                    var stopwatch = Stopwatch.StartNew();
                     hash = ComputeFirstStreamHashAsync(file, cancellationToken).Result;
                     stopwatch.Stop();
                     if (!string.IsNullOrEmpty(hash))
@@ -527,7 +530,8 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                     foreach (var title in titles)
                     {
                         var archiveEntry = new FileEntry(file + ArchivePathSeparator + title.Item1, title.Item2, title.Item3.Hash, [title.Item3]);
-                        AddToSnapshotAsync(archiveEntry);
+                        var addToSnapshotAsync = AddToSnapshotAsync(archiveEntry, cancellationToken);
+                        addToSnapshotAsync.Wait(cancellationToken);
                         cancellationToken.ThrowIfCancellationRequested();
                         yield return archiveEntry;
                     }
@@ -564,11 +568,15 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
             }
             catch (IOException ex) when (attempt < _options.MaxRetryCount - 1)
             {
-                var delay = (int)((attempt+1) * _options.DebounceTimeoutMs * _options.RetryMultiplier);
-                _logger.LogWarning(ex, "Attempt {Attempt} failed for {Path}. Retrying after {Delay}.",
-                    attempt + 1, file, delay);
+                var delay = (int)((attempt + 1) * _options.DebounceTimeoutMs * _options.RetryMultiplier);
+                _logger.LogWarning(ex, "Failed to load {Path}. Attempt {Attempt}, Retrying after {Delay}.",
+                    file, attempt + 1, delay);
                 await Task.Delay(delay, cancellationToken);
             }
+            catch (IOException) when (attempt >= _options.MaxRetryCount - 1)
+            {
+                _logger.LogWarning("Load {Path} failed after {retries} attempts", file, attempt + 1);
+            }
         }
         return null;
     }
@@ -859,7 +867,7 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                     // The first stream is the first entry returned by GetContentInfos().
                     try
                     {
-                        using var reader = new RomArchiveReader(filePath);
+                        await using var reader = new RomArchiveReader(filePath);
 
                         var first = reader.GetEntries().FirstOrDefault();
                         if (first == null) return ComputeFullHash(filePath);
@@ -871,35 +879,29 @@ public sealed class SnapshotService : IDisposable, ISnapshotService, IHostedServ
                     }
                     catch
                     {
-                        // On error, fall back to the full file hash
-                        await using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
-                        var ncaMetadataWithHash = _nspExtractor.ExtractFromStream(fs);
-                        return ncaMetadataWithHash?.Hash ?? string.Empty;
+                        // ignored
                     }
                 }
-                else
-                {
-                    await using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
-                    var ncaMetadataWithHash = _nspExtractor.ExtractFromStream(fs);
-                    return ncaMetadataWithHash?.Hash ?? string.Empty;
-                }
+
+                await using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+                var ncaMetadataWithHash = _nspExtractor.ExtractFromStream(fs);
+                return ncaMetadataWithHash?.Hash ?? string.Empty;
             }
             catch (IOException ex) when (attempt < _options.MaxRetryCount - 1)
             {
                 var delay = (int)((attempt + 1) * _options.DebounceTimeoutMs * _options.RetryMultiplier);
-                _logger.LogWarning(ex, "Attempt {Attempt} failed for {Path}. Retrying after {Delay}.",
-                    attempt + 1, filePath, delay);
+                _logger.LogWarning(ex, "Failed to load {Path}. Attempt {Attempt}, Retrying after {Delay}.",
+                    filePath, attempt + 1, delay);
                 await Task.Delay(delay, cancellationToken);
             }
-            catch (IOException)
+            catch (IOException) when (attempt >= _options.MaxRetryCount - 1)
             {
-                _logger.LogWarning("Attempt to load {Path} failed after {retries}", filePath, attempt + 1);
+                _logger.LogWarning("Load {Path} failed after {retries} attempts", filePath, attempt + 1);
                 return null;
             }
         }
 
         return string.Empty;
-        throw new IOException($"Failed to compute hash for {filePath} after {_options.MaxRetryCount} attempts");
     }
 
     private static string ComputeFullHash(string filePath)