feat: duplicates settle themselves: retitled copies across releases link, alike versions on one album are dismissed, and a file in another song's slot is removed so the album is fetched again (M498 #6159-#6162)

The operator's library had 536 groups waiting for review, 2026-10-19. A sample
showed most were one recording under two titles on two releases.

- The headline and the Duplicates count leave out cross-release groups, which
  the resolver keeps and links: the headline read 3,479 when 536 needed review.
- Any group spanning albums is cross_release and is linked as one song,
  whatever its titles say. Nothing is deleted.
- One album, two versions named as such ("Lovesick (Instrumental)") and not
  byte-identical: a new class, distinct, dismissed by the resolver.
- One album, one recording under different song titles (mismatch): the
  album's cached MusicBrainz track list decides. When exactly one slot's song
  is as long as the file and every other slot's song is clearly not, the other
  copies are removed and their tracks marked missing, so the reacquisition
  sweeper wants the album back. Otherwise the group stays for review.
- The duplicates_found notice moves from the sweep to the resolver: it names
  only groups a pass first left for review.
- Resolved automatically lists dismissals and wrong-slot removals beside
  merges.

Migration 0094 adds 'distinct' to the class CHECK (rule 36).

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

internal/library/notify_test.go

@@ -1,7 +1,6 @@
 package library
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -155,68 +154,54 @@ func TestNotifyStillMissing_NamesOnlyTheTracksStillGone(t *testing.T) {
 	}
 }
 
-func TestDuplicateSweep_NotifiesOnlyWhenSomethingNewIsProposed(t *testing.T) {
+// Admins hear about a duplicate group once, when a resolver pass first leaves
+// it for them. A group the resolver settles or links is never news, and a
+// group already seen by an earlier pass is not news again.
+func TestResolveDuplicates_TellsAdminsOnlyOfNewGroupsLeftForThem(t *testing.T) {
 	pool := newPool(t)
 	admin := notifyingAdmin(t, pool)
 	ctx := context.Background()
 	q := dbq.New(pool)
 	dir := t.TempDir()
-	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-
-	_, album, artist := seedTrack(t, pool, filepath.Join(dir, "seed.mp3"))
-	// Same audio-stream hash: an exact pair, whatever the prints say.
-	pair := func(name string, b byte, seed uint64) {
-		t.Helper()
-		for i := 1; i <= 2; i++ {
-			tr, err := q.UpsertTrack(ctx, dbq.UpsertTrackParams{
-				Title: name, AlbumID: album.ID, ArtistID: artist.ID, DurationMs: 200000,
-				FilePath: filepath.Join(dir, fmt.Sprintf("%s-%d.mp3", name, i)), FileSize: 100, FileFormat: "mp3",
-			})
-			if err != nil {
-				t.Fatalf("track %s: %v", name, err)
-			}
-			if err := q.UpsertTrackFingerprint(ctx, dbq.UpsertTrackFingerprintParams{
-				TrackID: tr.ID, AudioStreamSha256: bytes.Repeat([]byte{b}, 32),
-				Chromaprint: randomPrint(seed+uint64(i), printLen), FingerprintVersion: fingerprintVersion,
-				ChromaprintLengthSec: defaultChromaprintLengthSec,
-			}); err != nil {
-				t.Fatalf("fingerprint %s: %v", name, err)
-			}
-		}
+	first, album, artist := seedTrack(t, pool, filepath.Join(dir, "a.mp3"))
+	if _, err := pool.Exec(ctx, `UPDATE tracks SET title = 'Alpha' WHERE id = $1`, first.ID); err != nil {
+		t.Fatal(err)
 	}
-	sweep := func() {
-		t.Helper()
-		if _, err := runDuplicateSweep(ctx, pool, logger, DefaultFingerprintSettings, duplicateCandidatePage); err != nil {
-			t.Fatalf("sweep: %v", err)
-		}
+	second, err := q.UpsertTrack(ctx, dbq.UpsertTrackParams{
+		Title: "Beta", AlbumID: album.ID, ArtistID: artist.ID,
+		DurationMs: 1000, FilePath: filepath.Join(dir, "b.mp3"), FileSize: 100, FileFormat: "mp3",
+	})
+	if err != nil {
+		t.Fatal(err)
 	}
-	markAllRead := func() {
-		t.Helper()
-		if _, err := q.MarkAllNotificationsRead(ctx, dbq.MarkAllNotificationsReadParams{UserID: admin.ID}); err != nil {
-			t.Fatalf("mark read: %v", err)
-		}
+	// One album, one recording under two song titles, no track list to decide.
+	var groupID pgtype.UUID
+	if err := pool.QueryRow(ctx,
+		`INSERT INTO duplicate_groups (member_key, tier) VALUES ('notify-review', 'exact') RETURNING id`,
+	).Scan(&groupID); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `INSERT INTO duplicate_group_members (group_id, track_id) VALUES ($1, $2), ($1, $3)`,
+		groupID, first.ID, second.ID); err != nil {
+		t.Fatal(err)
 	}
 
-	pair("first", 1, 100)
-	sweep()
+	if _, err := ResolveDuplicates(ctx, pool, nil, "", true); err != nil {
+		t.Fatal(err)
+	}
 	got := unreadNotices(t, pool, admin)
 	if len(got) != 1 || got[0].kind != string(notifications.KindDuplicatesFound) || got[0].count != 1 ||
-		len(got[0].items) != 1 || got[0].items[0] != "Delete Test Artist – first" {
-		t.Fatalf("after the first sweep notices = %+v, want one duplicates_found naming the first pair", got)
+		len(got[0].items) != 1 || got[0].items[0] == "" {
+		t.Fatalf("after the first pass notices = %+v, want one duplicates_found naming the group", got)
 	}
 
-	// Read, then swept again with nothing new: no reminder.
-	markAllRead()
-	sweep()
+	if _, err := q.MarkAllNotificationsRead(ctx, dbq.MarkAllNotificationsReadParams{UserID: admin.ID}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := ResolveDuplicates(ctx, pool, nil, "", true); err != nil {
+		t.Fatal(err)
+	}
 	if got := unreadNotices(t, pool, admin); len(got) != 0 {
-		t.Fatalf("a sweep that found nothing new notified: %+v", got)
-	}
-
-	// A new pair is news, and the notice is about it alone: the first was read.
-	pair("second", 2, 200)
-	sweep()
-	got = unreadNotices(t, pool, admin)
-	if len(got) != 1 || got[0].count != 1 || len(got[0].items) != 1 || got[0].items[0] != "Delete Test Artist – second" {
-		t.Fatalf("after a new pair notices = %+v, want one naming only the new pair", got)
+		t.Fatalf("a group an earlier pass saw was told again: %+v", got)
 	}
 }