fix: every library album is matched to MusicBrainz before it is listed, by its tags, its artist's discography or a search, and checked against its tracks (M502 #5569)

The one-time listing took only albums whose tags already named their
release group and artist, and left 340 off the list. The rest are now
matched: the release their tags name, else the artist's release groups
called what the album is called, else a MusicBrainz search by artist and
title. A group found by name is taken only when its tracks agree with the
album's (by disc and number, then title; length and title, or recording),
so a partial copy still matches and a same-titled other album does not.

library_album_matches records each album the listing decided, listed or
unmatched with why, so an album taken off the list is never re-listed. The
albums no match was found for are named on the Held tab. Album rows with
no tracks are no longer counted.

The length and title checks move from the importer to release, shared by
both.

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

internal/db/queries/wanted.sql

@@ -258,30 +258,76 @@ SELECT DISTINCT ON (a.release_group_mbid)
           (SELECT COUNT(*) FROM tracks t WHERE t.album_id = a.id AND t.missing_since IS NULL) DESC, a.id
 ON CONFLICT (release_group_mbid) DO NOTHING;
 
--- name: ListLibraryAlbumsToName :many
--- Library albums from before the cutoff that carry a release id but no
--- release group yet: the listing asks MusicBrainz for each. '' marks one
--- MusicBrainz could not name, so it is asked once.
-SELECT a.id, a.title, a.mbid FROM albums a
- WHERE a.release_group_mbid IS NULL AND a.mbid IS NOT NULL AND a.mbid <> ''
+-- name: RecordListedAlbums :exec
+-- The albums ListLibraryAlbums takes are decided as listed by their tags,
+-- so the matching that follows leaves them alone (#5569).
+INSERT INTO library_album_matches (album_id, outcome, method, release_group_mbid)
+SELECT a.id, 'listed', 'tags', a.release_group_mbid
+  FROM albums a
+  JOIN artists ar ON ar.id = a.artist_id
+ WHERE a.release_group_mbid IS NOT NULL AND a.release_group_mbid <> ''
+   AND ar.mbid IS NOT NULL AND ar.mbid <> ''
    AND a.created_at <= sqlc.arg(cutoff)::timestamptz
+   AND EXISTS (SELECT 1 FROM tracks t WHERE t.album_id = a.id)
+ON CONFLICT (album_id) DO NOTHING;
+
+-- name: ListAlbumsToMatch :many
+-- Library albums from before the cutoff that the listing has not decided:
+-- each is matched to MusicBrainz (#5569). An album row with no tracks is
+-- not an album in the library.
+SELECT a.id, a.title, a.mbid, a.release_group_mbid, ar.name AS artist_name, ar.mbid AS artist_mbid
+  FROM albums a
+  JOIN artists ar ON ar.id = a.artist_id
+ WHERE a.created_at <= sqlc.arg(cutoff)::timestamptz
+   AND EXISTS (SELECT 1 FROM tracks t WHERE t.album_id = a.id)
+   AND NOT EXISTS (SELECT 1 FROM library_album_matches m WHERE m.album_id = a.id)
  ORDER BY a.created_at, a.id
  LIMIT sqlc.arg(max_rows);
 
+-- name: ListAlbumTracksToMatch :many
+-- What an album's tracks say about themselves, to check a match against.
+SELECT title, disc_number, track_number, duration_ms, mbid
+  FROM tracks
+ WHERE album_id = $1
+ ORDER BY disc_number NULLS FIRST, track_number NULLS LAST, title;
+
 -- name: SetAlbumReleaseGroup :exec
-UPDATE albums SET release_group_mbid = sqlc.arg(release_group_mbid)
- WHERE id = sqlc.arg(id) AND release_group_mbid IS NULL;
+-- Names a matched album's release group, filling only what nothing named.
+UPDATE albums SET release_group_mbid = sqlc.arg(release_group_mbid), updated_at = now()
+ WHERE id = sqlc.arg(id) AND (release_group_mbid IS NULL OR release_group_mbid = '');
+
+-- name: InsertLibraryWant :execrows
+-- Puts one matched album on the list as held, from just before its first
+-- lost track if it has one. A group already on the list is left as it is.
+INSERT INTO wants (release_group_mbid, artist_mbid, artist_name, title, primary_type, first_release_date,
+                   reason, album_id, wanted_at, fulfilled_at)
+VALUES (sqlc.arg(release_group_mbid), sqlc.arg(artist_mbid), sqlc.arg(artist_name), sqlc.arg(title),
+        sqlc.arg(primary_type), sqlc.arg(first_release_date), 'library', sqlc.arg(album_id)::uuid, now(),
+        COALESCE((SELECT MIN(t.missing_since) FROM tracks t WHERE t.album_id = sqlc.arg(album_id)::uuid)
+                 - interval '1 second', now()))
+ON CONFLICT (release_group_mbid) DO NOTHING;
+
+-- name: RecordAlbumMatch :exec
+INSERT INTO library_album_matches (album_id, outcome, method, release_group_mbid, detail)
+VALUES (sqlc.arg(album_id), sqlc.arg(outcome), sqlc.arg(method), sqlc.arg(release_group_mbid), sqlc.arg(detail))
+ON CONFLICT (album_id) DO UPDATE
+   SET outcome = EXCLUDED.outcome, method = EXCLUDED.method,
+       release_group_mbid = EXCLUDED.release_group_mbid, detail = EXCLUDED.detail, decided_at = now();
 
 -- name: FinishLibraryListing :one
--- The listing is done: count the albums from before the cutoff it could not
--- list, because nothing names them to MusicBrainz.
-UPDATE acquisition_settings s
+-- The listing is done: count the albums no match was found for.
+UPDATE acquisition_settings
    SET library_listed_at = now(),
-       library_unlisted = (
-         SELECT COUNT(*) FROM albums a
-          WHERE a.created_at <= s.library_listing_started_at
-            AND NOT EXISTS (SELECT 1 FROM wants w
-                             WHERE w.album_id = a.id
-                                OR (a.release_group_mbid <> '' AND w.release_group_mbid = a.release_group_mbid)))
- WHERE s.id = true AND s.library_listed_at IS NULL
+       library_unlisted = (SELECT COUNT(*) FROM library_album_matches WHERE outcome = 'unmatched')
+ WHERE id = true AND library_listed_at IS NULL
 RETURNING library_listed_at, library_unlisted;
+
+-- name: ListUnmatchedLibraryAlbums :many
+-- The albums the listing could not match, for the Held tab.
+SELECT m.album_id, a.title, ar.name AS artist_name, m.detail
+  FROM library_album_matches m
+  JOIN albums a ON a.id = m.album_id
+  JOIN artists ar ON ar.id = a.artist_id
+ WHERE m.outcome = 'unmatched'
+ ORDER BY ar.name, a.title
+ LIMIT sqlc.arg(max_rows);