diff --git a/src/Sleezer/Download/Clients/Soulseek/SlskdDirectoryPartitioner.cs b/src/Sleezer/Download/Clients/Soulseek/SlskdDirectoryPartitioner.cs
new file mode 100644
index 0000000..1878d9a
--- /dev/null
+++ b/src/Sleezer/Download/Clients/Soulseek/SlskdDirectoryPartitioner.cs
@@ -0,0 +1,70 @@
+using NzbDrone.Plugin.Sleezer.Download.Clients.Soulseek.Models;
+
+namespace NzbDrone.Plugin.Sleezer.Download.Clients.Soulseek;
+
+/// <summary>One item's share of a peer directory, and the files no tracked item claimed.</summary>
+public record SlskdDirectoryPartition(
+    List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> Owners,
+    SlskdDownloadDirectory? Unclaimed);
+
+/// <summary>
+/// Splits one peer directory's transfers into per-item slices. Two Lidarr albums
+/// can share a peer directory, so the group belongs to every item that enqueued
+/// part of it — not to whichever item happens to own the first file.
+/// </summary>
+public static class SlskdDirectoryPartitioner
+{
+    /// <summary>Splits a peer directory into one slice per owning item, plus the rest.</summary>
+    public static SlskdDirectoryPartition Partition(
+        SlskdDownloadDirectory directory,
+        IEnumerable<SlskdDownloadItem> candidates,
+        string username)
+    {
+        List<SlskdDownloadFile> files = directory.Files ?? [];
+        if (files.Count == 0)
+            return new SlskdDirectoryPartition([], null);
+
+        List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> owners = [];
+        HashSet<string> claimed = new(StringComparer.OrdinalIgnoreCase);
+
+        foreach (SlskdDownloadItem candidate in candidates)
+        {
+            // An item with no username yet is still a candidate for any peer.
+            if (candidate.Username != null &&
+                !string.Equals(candidate.Username, username, StringComparison.OrdinalIgnoreCase))
+                continue;
+
+            // Deliberately not deduped against `claimed`: two items can legitimately
+            // enqueue the same remote file, and one transfer serves both.
+            List<SlskdDownloadFile> owned = files.Where(f => candidate.OwnsAcceptedFile(f.Filename)).ToList();
+            if (owned.Count == 0)
+                continue;
+
+            owners.Add((candidate, new SlskdDownloadDirectory(directory.Directory, owned.Count, owned)));
+            foreach (SlskdDownloadFile file in owned)
+                claimed.Add(file.Filename);
+        }
+
+        List<SlskdDownloadFile> unclaimed = files.Where(f => !claimed.Contains(f.Filename)).ToList();
+
+        return new SlskdDirectoryPartition(
+            owners,
+            unclaimed.Count > 0 ? new SlskdDownloadDirectory(directory.Directory, unclaimed.Count, unclaimed) : null);
+    }
+
+    /// <summary>Adds the item whose ID hashes the whole directory, if it isn't already an owner.</summary>
+    public static List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> WithKeyedOwner(
+        SlskdDirectoryPartition partition,
+        SlskdDownloadItem? keyed,
+        SlskdDownloadDirectory directory)
+    {
+        List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> owners = [.. partition.Owners];
+
+        // Returning early on the hash match would starve a co-owner that enqueued
+        // only part of the directory — the same starvation this class exists to fix.
+        if (keyed != null && !owners.Any(owner => ReferenceEquals(owner.Item, keyed)))
+            owners.Add((keyed, directory));
+
+        return owners;
+    }
+}
diff --git a/src/Sleezer/Download/Clients/Soulseek/SlskdDownloadManager.cs b/src/Sleezer/Download/Clients/Soulseek/SlskdDownloadManager.cs
index 4c4e6e1..1212cf4 100644
--- a/src/Sleezer/Download/Clients/Soulseek/SlskdDownloadManager.cs
+++ b/src/Sleezer/Download/Clients/Soulseek/SlskdDownloadManager.cs
@@ -837,92 +837,127 @@ private void ProcessUserTransfers(
             string hash = SlskdDownloadItem.GetStableMD5Id(dir.Files?.Select(f => f.Filename) ?? []);
             currentIdSet.TryAdd(hash, true);
 
-            // A multi-disc item's ID hashes ALL its files, but slskd reports
-            // transfers per remote directory — the per-directory hash never
-            // matches, so fall back to matching by enqueued-file membership.
-            SlskdDownloadItem? item = GetItem(definitionId, hash)
-                ?? FindItemOwningDirectory(definitionId, userTransfers.Username, dir);
-            if (item == null)
+            foreach ((SlskdDownloadItem item, SlskdDownloadDirectory slice) in ResolveDirectoryOwners(definitionId, settings, userTransfers.Username, dir))
             {
-                _logger.Trace("[def={DefinitionId}] Unknown item {Hash}: checking history", definitionId, hash);
-                DownloadHistory? history = FindGrabOwningDirectory(hash, dir);
+                currentIdSet.TryAdd(item.ID, true);
+                ApplyDirectoryToItem(settings, userTransfers.Username, item, slice);
+            }
+        }
+    }
 
-                if (history != null)
-                {
-                    item = new SlskdDownloadItem(history.Release)
-                    {
-                        // The grab's id, not the recomputed content hash: a
-                        // retry grab carries an -rN suffix and a multi-disc
-                        // grab hashes ALL discs — Lidarr tracks both under
-                        // the id it was handed at grab time.
-                        ID = history.DownloadId
-                    };
-                }
-                else if (settings.Inclusive)
-                {
-                    item = new SlskdDownloadItem(CreateReleaseInfoFromDirectory(userTransfers.Username, dir));
-                }
+    /// <summary>
+    /// Every tracked item with a stake in one peer directory, each paired with
+    /// just its own transfers — two Lidarr albums can share a peer directory.
+    /// </summary>
+    private List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> ResolveDirectoryOwners(
+        int definitionId,
+        SlskdProviderSettings settings,
+        string username,
+        SlskdDownloadDirectory dir)
+    {
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(dir, GetItemsForDef(definitionId), username);
 
-                if (item == null)
-                    continue;
+        // A multi-disc item's ID hashes ALL its files, but slskd reports transfers
+        // per remote directory — that hash only hits for a single-directory item.
+        SlskdDownloadItem? keyed = GetItem(definitionId, SlskdDownloadItem.GetStableMD5Id(dir.Files?.Select(f => f.Filename) ?? []));
+        List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> owners = SlskdDirectoryPartitioner.WithKeyedOwner(partition, keyed, dir);
 
-                SubscribeStateChanges(item, definitionId);
-                AddItem(definitionId, item);
-            }
-            else
-            {
-                currentIdSet.TryAdd(item.ID, true);
-            }
+        if (partition.Unclaimed is { } unclaimed &&
+            AdoptUnknownDirectory(definitionId, settings, username, unclaimed) is { } adopted)
+            owners.Add((adopted, unclaimed));
 
-            item.Username ??= userTransfers.Username;
-            item.SlskdDownloadDirectory = dir;
-
-            // slskd echoes the batch id on every transfer — the only copy that
-            // survives a restart. A batch always carried a destination, so slskd
-            // placed the discs pre-merged: restoring both stops a needless merge
-            // from moving a same-named root folder belonging to another download,
-            // and lets the ConfirmedSubdirectory gate in HandleEventAsync trust a
-            // multi-disc completion.
-            if (item.BatchId == null &&
-                dir.Files?.Select(f => f.BatchId).FirstOrDefault(id => !string.IsNullOrEmpty(id)) is { } recoveredBatchId)
-            {
-                item.BatchId = recoveredBatchId;
-                item.DiscFoldersMerged = true;
-            }
+        return owners;
+    }
 
-            // With a non-default subdirectory pattern, slskd places transfers
-            // somewhere the leaf-name guess can't predict — derive it.
-            if (item.DerivedSubdirectory == null && item.ConfirmedSubdirectory == null &&
-                settings.GetDestinationConfig() is { UsesDefaultPattern: false } destinationConfig &&
-                dir.Files?.FirstOrDefault()?.Filename is { Length: > 0 } firstFile)
-            {
-                item.DerivedSubdirectory = SlskdPathResolver.ResolveSubdirectory(
-                    destinationConfig,
-                    userTransfers.Username,
-                    firstFile,
-                    item.BatchId,
-                    item.BatchId != null ? item.ID : null);
-            }
+    /// <summary>
+    /// Re-attaches transfers no tracked item claimed to the grab that started
+    /// them, or (inclusive mode) builds an item from the directory itself.
+    /// </summary>
+    private SlskdDownloadItem? AdoptUnknownDirectory(
+        int definitionId,
+        SlskdProviderSettings settings,
+        string username,
+        SlskdDownloadDirectory dir)
+    {
+        string hash = SlskdDownloadItem.GetStableMD5Id(dir.Files?.Select(f => f.Filename) ?? []);
+        _logger.Trace("[def={DefinitionId}] Unknown item {Hash}: checking history", definitionId, hash);
+        DownloadHistory? history = FindGrabOwningDirectory(hash, dir);
 
-            // Fallback trigger for post-process: if the transfer poll sees all
-            // files completed before the event poll has caught up with the matching
-            // DownloadDirectoryComplete event, enqueue here. Without this, Lidarr
-            // can see status=Completed and start importing before the scan runs.
-            // _postProcessed.TryAdd dedupes against the event-path trigger.
-            if (item.AllAcceptedFilesCompleted())
-                EnqueuePostProcess(item, settings);
+        SlskdDownloadItem? item = null;
+        if (history != null)
+        {
+            item = new SlskdDownloadItem(history.Release)
+            {
+                // The grab's id, not the recomputed content hash: a
+                // retry grab carries an -rN suffix and a multi-disc
+                // grab hashes ALL discs — Lidarr tracks both under
+                // the id it was handed at grab time.
+                ID = history.DownloadId
+            };
+        }
+        else if (settings.Inclusive)
+        {
+            item = new SlskdDownloadItem(CreateReleaseInfoFromDirectory(username, dir));
         }
+
+        if (item == null)
+            return null;
+
+        // AddItem overwrites by ID, and the history probe matches on the enqueued
+        // set — so a live item's own rejected file would rebuild it here and drop
+        // the transfer state it has accumulated.
+        if (GetItem(definitionId, item.ID) != null)
+            return null;
+
+        SubscribeStateChanges(item, definitionId);
+        AddItem(definitionId, item);
+        return item;
     }
 
-    private SlskdDownloadItem? FindItemOwningDirectory(int definitionId, string username, SlskdDownloadDirectory dir)
+    /// <summary>Attaches one item's share of a peer directory and its derived state.</summary>
+    private void ApplyDirectoryToItem(
+        SlskdProviderSettings settings,
+        string username,
+        SlskdDownloadItem item,
+        SlskdDownloadDirectory dir)
     {
-        string? probeFile = dir.Files?.FirstOrDefault()?.Filename;
-        if (string.IsNullOrEmpty(probeFile))
-            return null;
+        item.Username ??= username;
+        item.SlskdDownloadDirectory = dir;
+
+        // slskd echoes the batch id on every transfer — the only copy that
+        // survives a restart. A batch always carried a destination, so slskd
+        // placed the discs pre-merged: restoring both stops a needless merge
+        // from moving a same-named root folder belonging to another download,
+        // and lets the ConfirmedSubdirectory gate in HandleEventAsync trust a
+        // multi-disc completion.
+        if (item.BatchId == null &&
+            dir.Files?.Select(f => f.BatchId).FirstOrDefault(id => !string.IsNullOrEmpty(id)) is { } recoveredBatchId)
+        {
+            item.BatchId = recoveredBatchId;
+            item.DiscFoldersMerged = true;
+        }
+
+        // With a non-default subdirectory pattern, slskd places transfers
+        // somewhere the leaf-name guess can't predict — derive it.
+        if (item.DerivedSubdirectory == null && item.ConfirmedSubdirectory == null &&
+            settings.GetDestinationConfig() is { UsesDefaultPattern: false } destinationConfig &&
+            dir.Files?.FirstOrDefault()?.Filename is { Length: > 0 } firstFile)
+        {
+            item.DerivedSubdirectory = SlskdPathResolver.ResolveSubdirectory(
+                destinationConfig,
+                username,
+                firstFile,
+                item.BatchId,
+                item.BatchId != null ? item.ID : null);
+        }
 
-        return GetItemsForDef(definitionId).FirstOrDefault(i =>
-            (i.Username == null || string.Equals(i.Username, username, StringComparison.OrdinalIgnoreCase)) &&
-            i.OwnsFile(probeFile));
+        // Fallback trigger for post-process: if the transfer poll sees all
+        // files completed before the event poll has caught up with the matching
+        // DownloadDirectoryComplete event, enqueue here. Without this, Lidarr
+        // can see status=Completed and start importing before the scan runs.
+        // _postProcessed.TryAdd dedupes against the event-path trigger.
+        if (item.AllAcceptedFilesCompleted())
+            EnqueuePostProcess(item, settings);
     }
 
     // Restart re-attach: -rN retry and multi-disc grab ids never equal the
diff --git a/tests/Sleezer.Tests/Sleezer.Tests.csproj b/tests/Sleezer.Tests/Sleezer.Tests.csproj
index 2f7b10d..1646202 100644
--- a/tests/Sleezer.Tests/Sleezer.Tests.csproj
+++ b/tests/Sleezer.Tests/Sleezer.Tests.csproj
@@ -107,6 +107,8 @@
              LinkBase="SourceUnderTest" />
     <Compile Include="..\..\src\Sleezer\Download\Clients\Soulseek\SlskdPathResolver.cs"
              LinkBase="SourceUnderTest" />
+    <Compile Include="..\..\src\Sleezer\Download\Clients\Soulseek\SlskdDirectoryPartitioner.cs"
+             LinkBase="SourceUnderTest" />
     <Compile Include="..\..\src\Sleezer\Download\Clients\Soulseek\SlskdStatusResolver.cs"
              LinkBase="SourceUnderTest" />
     <!-- Watchdog cancel path. Only the API *interface* is pulled in (tests fake it),
diff --git a/tests/Sleezer.Tests/SlskdDirectoryPartitionerTests.cs b/tests/Sleezer.Tests/SlskdDirectoryPartitionerTests.cs
new file mode 100644
index 0000000..fd94d63
--- /dev/null
+++ b/tests/Sleezer.Tests/SlskdDirectoryPartitionerTests.cs
@@ -0,0 +1,194 @@
+using System.Text.Json;
+using NzbDrone.Core.Parser.Model;
+using NzbDrone.Plugin.Sleezer.Download.Clients.Soulseek;
+using NzbDrone.Plugin.Sleezer.Download.Clients.Soulseek.Models;
+using Xunit;
+
+namespace Sleezer.Tests;
+
+// slskd reports transfers per peer directory, and two Lidarr albums can share
+// one (the single/EP pluck takes a track out of a compilation folder). Handing
+// the whole group to whoever owns file[0] starved the other item until it timed
+// out and blocklisted a healthy release.
+public class SlskdDirectoryPartitionerTests
+{
+    private const string Dir = @"@@peer\Artist\Album";
+    private const string Peer = "peer";
+
+    private static SlskdDownloadItem Item(params string[] names)
+    {
+        string source = "[" + string.Join(",", names.Select(n =>
+            $"{{\"Filename\":{JsonSerializer.Serialize(Dir + "\\" + n)},\"Size\":1000}}")) + "]";
+        return new SlskdDownloadItem(new ReleaseInfo { Source = source, Title = "t", DownloadUrl = "u" });
+    }
+
+    private static SlskdDownloadFile Transfer(string name) => new(
+        Id: name, Username: Peer, Direction: "Download", Filename: Dir + "\\" + name,
+        Size: 1000, StartOffset: 0, State: "InProgress",
+        RequestedAt: DateTime.UtcNow, EnqueuedAt: DateTime.UtcNow, StartedAt: DateTime.UtcNow,
+        BytesTransferred: 0, AverageSpeed: 0, BytesRemaining: 0,
+        ElapsedTime: TimeSpan.Zero, PercentComplete: 0, RemainingTime: TimeSpan.Zero, EndedAt: null);
+
+    private static SlskdDownloadDirectory Group(params string[] names) =>
+        new(Dir, names.Length, names.Select(Transfer).ToList());
+
+    private static string[] Names(SlskdDownloadDirectory? dir) =>
+        dir?.Files?.Select(f => Path.GetFileName(f.Filename.Replace('\\', '/'))).ToArray() ?? [];
+
+    private static SlskdDownloadDirectory SliceFor(SlskdDirectoryPartition partition, SlskdDownloadItem item) =>
+        partition.Owners.Single(o => ReferenceEquals(o.Item, item)).Slice;
+
+    [Fact]
+    public void A_sole_owner_takes_the_whole_directory()
+    {
+        SlskdDownloadItem item = Item("01.flac", "02.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(Group("01.flac", "02.flac"), [item], Peer);
+
+        (SlskdDownloadItem owner, SlskdDownloadDirectory slice) = Assert.Single(partition.Owners);
+        Assert.Same(item, owner);
+        Assert.Equal(new[] { "01.flac", "02.flac" }, Names(slice));
+        Assert.Equal(2, slice.FileCount);
+        Assert.Null(partition.Unclaimed);
+    }
+
+    // The anti-starvation lock: before the split, one of these two got nothing.
+    [Fact]
+    public void Two_items_sharing_a_directory_each_get_their_own_files()
+    {
+        SlskdDownloadItem album = Item("01.flac", "02.flac");
+        SlskdDownloadItem single = Item("03.flac");
+        SlskdDownloadDirectory group = Group("01.flac", "02.flac", "03.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(group, [album, single], Peer);
+
+        Assert.Equal(2, partition.Owners.Count);
+        Assert.Equal(new[] { "01.flac", "02.flac" }, Names(SliceFor(partition, album)));
+        Assert.Equal(new[] { "03.flac" }, Names(SliceFor(partition, single)));
+        Assert.Null(partition.Unclaimed);
+        Assert.Equal(3, group.Files!.Count);
+    }
+
+    [Fact]
+    public void The_owner_of_the_first_file_does_not_take_the_rest()
+    {
+        SlskdDownloadItem album = Item("02.flac", "03.flac");
+        SlskdDownloadItem single = Item("01.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(
+            Group("01.flac", "02.flac", "03.flac"), [album, single], Peer);
+
+        Assert.Equal(new[] { "02.flac", "03.flac" }, Names(SliceFor(partition, album)));
+        Assert.Equal(new[] { "01.flac" }, Names(SliceFor(partition, single)));
+        Assert.Null(partition.Unclaimed);
+    }
+
+    [Fact]
+    public void An_enqueue_rejected_file_is_not_this_items_transfer()
+    {
+        SlskdDownloadItem item = Item("01.flac", "02.flac");
+        item.MarkEnqueueFailed([Dir + @"\02.flac"]);
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(Group("01.flac", "02.flac"), [item], Peer);
+
+        Assert.Equal(new[] { "01.flac" }, Names(Assert.Single(partition.Owners).Slice));
+        Assert.Equal(new[] { "02.flac" }, Names(partition.Unclaimed));
+    }
+
+    [Fact]
+    public void Files_no_tracked_item_enqueued_are_unclaimed()
+    {
+        SlskdDownloadItem item = Item("01.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(
+            Group("foreign.flac", "stranger.flac"), [item], Peer);
+
+        Assert.Empty(partition.Owners);
+        Assert.Equal(new[] { "foreign.flac", "stranger.flac" }, Names(partition.Unclaimed));
+    }
+
+    [Fact]
+    public void A_candidate_bound_to_another_peer_is_not_an_owner()
+    {
+        SlskdDownloadItem elsewhere = Item("01.flac");
+        elsewhere.Username = "other-peer";
+        SlskdDownloadItem unbound = Item("02.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(
+            Group("01.flac", "02.flac"), [elsewhere, unbound], Peer);
+
+        (SlskdDownloadItem owner, SlskdDownloadDirectory slice) = Assert.Single(partition.Owners);
+        Assert.Same(unbound, owner);
+        Assert.Equal(new[] { "02.flac" }, Names(slice));
+        Assert.Equal(new[] { "01.flac" }, Names(partition.Unclaimed));
+    }
+
+    [Fact]
+    public void One_transfer_serves_both_items_that_enqueued_the_same_file()
+    {
+        SlskdDownloadItem album = Item("01.flac", "02.flac");
+        SlskdDownloadItem single = Item("01.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(
+            Group("01.flac", "02.flac"), [album, single], Peer);
+
+        Assert.Equal(new[] { "01.flac", "02.flac" }, Names(SliceFor(partition, album)));
+        Assert.Equal(new[] { "01.flac" }, Names(SliceFor(partition, single)));
+        Assert.Null(partition.Unclaimed);
+    }
+
+    [Fact]
+    public void A_directory_with_no_files_yields_nothing()
+    {
+        SlskdDownloadItem item = Item("01.flac");
+
+        SlskdDirectoryPartition empty = SlskdDirectoryPartitioner.Partition(new SlskdDownloadDirectory(Dir, 0, []), [item], Peer);
+        SlskdDirectoryPartition missing = SlskdDirectoryPartitioner.Partition(new SlskdDownloadDirectory(Dir, 0, null), [item], Peer);
+
+        Assert.Empty(empty.Owners);
+        Assert.Null(empty.Unclaimed);
+        Assert.Empty(missing.Owners);
+        Assert.Null(missing.Unclaimed);
+    }
+
+    // The manager also looks an item up by the hash of the whole directory.
+    // Taking that match as the only owner starves anyone who enqueued a subset.
+    [Fact]
+    public void A_co_owner_survives_the_whole_directory_hash_matching_another_item()
+    {
+        SlskdDownloadItem whole = Item("01.flac", "02.flac", "03.flac");
+        SlskdDownloadItem plucked = Item("02.flac");
+        SlskdDownloadDirectory dir = Group("01.flac", "02.flac", "03.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(dir, [whole, plucked], Peer);
+        List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> owners =
+            SlskdDirectoryPartitioner.WithKeyedOwner(partition, whole, dir);
+
+        Assert.Equal(2, owners.Count);
+        Assert.Single(owners, o => ReferenceEquals(o.Item, whole));
+        Assert.Equal(["02.flac"], Names(owners.Single(o => ReferenceEquals(o.Item, plucked)).Slice));
+    }
+
+    [Fact]
+    public void An_item_the_partition_missed_is_added_with_the_whole_directory()
+    {
+        SlskdDownloadItem keyed = Item("01.flac");
+        SlskdDownloadDirectory dir = Group("01.flac");
+
+        List<(SlskdDownloadItem Item, SlskdDownloadDirectory Slice)> owners =
+            SlskdDirectoryPartitioner.WithKeyedOwner(new SlskdDirectoryPartition([], null), keyed, dir);
+
+        Assert.Equal(["01.flac"], Names(Assert.Single(owners).Slice));
+    }
+
+    [Fact]
+    public void Without_a_hash_match_the_partitioned_owners_stand_alone()
+    {
+        SlskdDownloadItem item = Item("01.flac");
+        SlskdDownloadDirectory dir = Group("01.flac");
+
+        SlskdDirectoryPartition partition = SlskdDirectoryPartitioner.Partition(dir, [item], Peer);
+
+        Assert.Single(SlskdDirectoryPartitioner.WithKeyedOwner(partition, null, dir));
+    }
+}