fix: a slot emptied of another song's file drops that file's recording MBID, so missing-pair folding cannot fold it into the copy kept (M498)

On 2026-10-20 twelve of the 24 slots the resolver emptied were folded by MBID
into the kept copy, so their albums were never wanted back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/library/duplicate_resolve_test.go

@@ -381,10 +381,20 @@ func seedTrackList(t *testing.T, pool *pgxpool.Pool, album dbq.Album, songs map[
 func TestResolveDuplicates_RemovesACopyFromAnotherSongsSlot_Integration(t *testing.T) {
 	f := newOneAlbumFixture(t, "acoustic", "Void", "Reach")
 	seedTrackList(t, f.pool, f.album, map[string]int{"Void": 220500, "Reach": 281000})
+	// The wrong file is Void's recording, so it carries Void's MBID.
+	if _, err := f.pool.Exec(context.Background(),
+		`UPDATE tracks SET mbid = 'rec-void' WHERE id = ANY($1)`, []pgtype.UUID{f.a.ID, f.b.ID}); err != nil {
+		t.Fatal(err)
+	}
 	res, err := ResolveDuplicates(context.Background(), f.pool, nil, "", true)
 	if err != nil {
 		t.Fatal(err)
 	}
+	// Twelve slots were lost this way on 2026-10-20: folded by that MBID into
+	// the copy kept, and so never wanted back.
+	if pairs, err := PairMissingTracks(context.Background(), f.pool, nil); err != nil || pairs.Folded() != 0 {
+		t.Fatalf("missing-pair pass = %+v, %v; want the emptied slot left alone", pairs, err)
+	}
 	if res.WrongFiles != 1 || !exists(f.aPath) || exists(f.bPath) {
 		t.Fatalf("result %+v, void exists %v, reach exists %v; want only Reach's copy removed",
 			res, exists(f.aPath), exists(f.bPath))

internal/library/duplicate_settle.go

@@ -225,7 +225,9 @@ func neverRead(ctx context.Context, q *dbq.Queries, rg string) bool {
 
 // removeWrongSlots deletes each loser's file, then marks its track missing in
 // the same transaction that closes the group. The row is kept, with its likes
-// and plays: it is the slot, and a good copy fetched again takes it over. A
+// and plays: it is the slot, and a good copy fetched again takes it over. Its
+// recording MBID is dropped, being the wrong file's, so missing-pair folding
+// does not fold the slot into the copy that was kept. A
 // file that cannot be removed stops the group; the ones already gone are still
 // marked, and the group waits for the next pass.
 func removeWrongSlots(
@@ -253,6 +255,9 @@ func removeWrongSlots(
 		if _, err := tq.MarkTracksMissing(ctx, gone); err != nil {
 			return fmt.Errorf("mark missing: %w", err)
 		}
+		if err := tq.ClearTrackMbids(ctx, gone); err != nil {
+			return fmt.Errorf("clear mbids: %w", err)
+		}
 		if err := logTrackChanges(ctx, tq, gone); err != nil {
 			return fmt.Errorf("log changes: %w", err)
 		}