feat: Lidarr searches for a better copy of a rip that has none (M498 #5447)

The operator chose option 2: an album holding a video rip that is the only
copy of its song is searched in Lidarr (AlbumSearch), at most once a week
and ten albums a pass. Lidarr grabs only when the quality profile allows an
upgrade, so nothing is removed and the rip stays held back either way.

- lidarr.Client.SearchAlbums posts the AlbumSearch command.
- ListAlbumsWithSoleCopyRips finds the albums: a held-back rip with no
  present clean copy sharing its song or its pending group, and not searched
  in the last week (audit action lidarr_rip_search).
- Suspect sources shows when Lidarr last searched the track's album.

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

internal/library/duplicate_resolve_test.go

@@ -82,6 +82,7 @@ type fakeLidarr struct {
 	releases      []lidarr.AlbumRelease
 	releaseTracks map[int][]lidarr.ReleaseTrack
 	setCalls      [][2]int
+	searchCalls   [][]int
 }
 
 func (f *fakeLidarr) ListUnmappedTrackFiles(context.Context) ([]lidarr.TrackFile, error) {
@@ -116,6 +117,11 @@ func (f *fakeLidarr) ListReleaseTracks(_ context.Context, releaseID int) ([]lida
 	return f.releaseTracks[releaseID], nil
 }
 
+func (f *fakeLidarr) SearchAlbums(_ context.Context, albumIDs []int) error {
+	f.searchCalls = append(f.searchCalls, albumIDs)
+	return nil
+}
+
 func (f *fakeLidarr) SetMonitoredRelease(_ context.Context, albumID, releaseID int) error {
 	f.setCalls = append(f.setCalls, [2]int{albumID, releaseID})
 	for i := range f.releases {
@@ -502,3 +508,60 @@ func TestResolveDuplicates_HoldsBackRips_Integration(t *testing.T) {
 		t.Errorf("set on an unflagged track: %d, %v; want 0 rows", n, err)
 	}
 }
+
+// A rip that is the only copy of its song: Lidarr is asked to search its album
+// for a better release (#5447), once a week at most, and the rip is not touched.
+// A rip with a clean copy elsewhere is not searched for.
+func TestResolveDuplicates_SearchesForASoleCopyRip_Integration(t *testing.T) {
+	f := newCrossReleaseRipFixture(t)
+	ctx := context.Background()
+	exec := func(sql string, args ...any) {
+		t.Helper()
+		if _, err := f.pool.Exec(ctx, sql, args...); err != nil {
+			t.Fatalf("exec %q: %v", sql, err)
+		}
+	}
+	// The single's rip has a clean copy on the album: never searched for.
+	exec(`UPDATE albums SET release_group_mbid = 'rg-single' WHERE id = $1`, f.rip.AlbumID)
+	lid := &fakeLidarr{album: lidarr.LidarrAlbum{ID: 77, ForeignAlbumID: "rg-single"}}
+	if _, err := ResolveDuplicates(ctx, f.pool, nil, "", lid, true); err != nil {
+		t.Fatal(err)
+	}
+	if len(lid.searchCalls) != 0 {
+		t.Fatalf("searched %v while a clean copy exists", lid.searchCalls)
+	}
+
+	// Without the group and the song link, the rip is the only copy.
+	exec(`DELETE FROM duplicate_groups WHERE id = $1`, f.groupID)
+	exec(`UPDATE tracks SET song_id = NULL WHERE id IN ($1, $2)`, f.rip.ID, f.clean.ID)
+	res, err := ResolveDuplicates(ctx, f.pool, nil, "", lid, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.RipSearches != 1 || len(lid.searchCalls) != 1 || len(lid.searchCalls[0]) != 1 || lid.searchCalls[0][0] != 77 {
+		t.Fatalf("rip searches %d, calls %v; want album 77 searched once", res.RipSearches, lid.searchCalls)
+	}
+	if !exists(f.ripPath) {
+		t.Error("the rip was removed; a search must not touch it")
+	}
+
+	// The next pass, inside the week, leaves the album alone.
+	if res, err := ResolveDuplicates(ctx, f.pool, nil, "", lid, true); err != nil || res.RipSearches != 0 {
+		t.Errorf("second pass searched %d (%v), want 0", res.RipSearches, err)
+	}
+	var searchedAt pgtype.Timestamptz
+	rows, err := dbq.New(f.pool).ListSuspectSourceTracks(ctx, dbq.ListSuspectSourceTracksParams{
+		Pattern: SuspectSourcePattern, PageLimit: 10,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, r := range rows {
+		if r.ID == f.rip.ID {
+			searchedAt = r.SearchedAt
+		}
+	}
+	if !searchedAt.Valid {
+		t.Error("the suspect-sources report doesn't show the search")
+	}
+}