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/db/queries/duplicates.sql

@@ -184,26 +184,6 @@ UPDATE duplicate_groups
    SET status = 'dismissed', resolved_at = now()
  WHERE id = sqlc.arg(id) AND status = 'pending';
 
--- name: ListDuplicateGroupsDetectedSince :many
--- Pending proposals first made at or after `since`: what a sweep that started
--- then found for the first time, each named by one of its songs, and `total`
--- of them however many are listed. A refreshed proposal keeps its detected_at,
--- so a sweep that only re-finds known groups lists none (M489: admins are told
--- about new duplicates, not reminded of the same ones every sweep).
-SELECT ar.name AS artist_name, t.title, count(*) OVER ()::bigint AS total
-  FROM duplicate_groups g
-  JOIN LATERAL (SELECT m.track_id
-                  FROM duplicate_group_members m
-                 WHERE m.group_id = g.id
-                 ORDER BY m.track_id
-                 LIMIT 1) one ON true
-  JOIN tracks t ON t.id = one.track_id
-  JOIN artists ar ON ar.id = t.artist_id
- WHERE g.status = 'pending'
-   AND g.detected_at >= sqlc.arg(since)
- ORDER BY g.detected_at DESC, g.id
- LIMIT sqlc.arg(n);
-
 -- name: ListDuplicateGroupsForResolve :many
 -- Every pending group's present copies, for the resolver (M498 #5435): what it
 -- needs to classify the group and to choose the copy to keep. One row per copy,
@@ -211,8 +191,12 @@ SELECT ar.name AS artist_name, t.title, count(*) OVER ()::bigint AS total
 -- same album claims the same disc and track number: tags that do not fit the
 -- album, which the survivor rule weighs against a copy. source_verdict says
 -- whether the copy is a video rip ('suspect') or one the operator kept ('fine').
+-- prior_class is the class the last pass gave the group, NULL for a group no
+-- pass has seen. release_group_mbid is the album's MusicBrainz group, from its
+-- tags or the library listing's match; '' when neither names one.
 SELECT g.id                  AS group_id,
        g.tier,
+       g.class               AS prior_class,
        t.id                  AS track_id,
        t.album_id,
        t.title,
@@ -221,6 +205,7 @@ SELECT g.id                  AS group_id,
        t.file_path,
        t.file_format,
        t.file_size,
+       t.duration_ms,
        t.added_at,
        t.disc_number,
        t.track_number,
@@ -229,11 +214,14 @@ SELECT g.id                  AS group_id,
                 WHERE o.album_id = t.album_id AND o.id <> t.id AND o.missing_since IS NULL
                   AND t.track_number IS NOT NULL
                   AND o.disc_number IS NOT DISTINCT FROM t.disc_number
-                  AND o.track_number = t.track_number)::boolean AS position_clash
+                  AND o.track_number = t.track_number)::boolean AS position_clash,
+       COALESCE(NULLIF(al.release_group_mbid, ''), lam.release_group_mbid, '')::text AS release_group_mbid
   FROM duplicate_groups g
   JOIN duplicate_group_members m ON m.group_id = g.id
   JOIN tracks t   ON t.id = m.track_id
   JOIN artists    ON artists.id = t.artist_id
+  JOIN albums al  ON al.id = t.album_id
+  LEFT JOIN library_album_matches lam ON lam.album_id = t.album_id AND lam.outcome = 'listed'
  WHERE g.status = 'pending'
    AND t.missing_since IS NULL
  ORDER BY g.id, t.id;
@@ -251,5 +239,12 @@ UPDATE duplicate_groups g
    AND g.status = 'pending'
    AND (g.class IS DISTINCT FROM v.class OR g.resolve_note IS DISTINCT FROM NULLIF(v.note, ''));
 
+-- name: SettleDuplicateGroupAutomatically :execrows
+-- The resolver closing a group itself: 'dismissed' for versions that are not
+-- duplicates, 'merged' when it removed the wrong copies. Only a pending group.
+UPDATE duplicate_groups
+   SET status = sqlc.arg(status), resolved_at = now(), resolved_automatically = true
+ WHERE id = sqlc.arg(id) AND status = 'pending';
+
 -- name: MarkDuplicateGroupResolvedAutomatically :exec
 UPDATE duplicate_groups SET resolved_automatically = true WHERE id = sqlc.arg(id);