feat: a wanted list — follow artists on release-type profiles; requests and re-acquisition become wants (M502 #5520)

Minstrel keeps its own list of what it is to get, keyed by MusicBrainz
release group. A want comes from an approved request, a new release by a
followed artist, or an album whose files went missing, and is held once the
library has a full edition of it.

- Migration 0081: release_type_profiles (Standard seeded: Album, EP,
  Single, studio only), follows, follow_seen_groups and wants.
  lidarr_requests becomes requests with plain *_mbid columns; approved
  album and track requests move onto the wanted list, approved artist
  requests become follows, and the library's album artists start out
  followed. missing_reacquisitions and the retry settings go.
- internal/wanted: follows are checked against MusicBrainz discographies
  daily. The first check sets a baseline, and only releases after it are
  wanted unless the follow asked for what already exists. Profiles filter
  by primary and secondary type, so live recordings stay out unless a
  profile ticks Live.
- internal/requests (was lidarrrequests): approving puts the request on
  the wanted list, and an artist request can be approved on a chosen
  profile. A request completes when its want is held.
- The re-acquisition sweeper wants a missing album back instead of asking
  Lidarr; searching for it is the search schedule's (#5521).
- Web: an admin Wanted page (Wanted, Missing files, Held, Following), a
  follow control on artist pages, a release-type profiles card on
  Integrations, "Approve on a profile" on Requests, and want state on
  Missing files. The artist detail API returns the artist's MBID.
- Android: the request body sends artist_mbid, album_mbid and track_mbid.

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

internal/api/admin_library_missing.go

@@ -2,12 +2,10 @@ package api
 
 import (
 	"net/http"
-	"time"
 
 	"github.com/jackc/pgx/v5/pgtype"
 
 	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
-	"git.fabledsword.com/bvandeusen/minstrel/internal/reacquisition"
 )
 
 // missingTrackView is one track whose file the scan could not find.
@@ -30,19 +28,13 @@ type missingTrackView struct {
 	LastPlayedAt *string `json:"last_played_at"`
 }
 
-// reacquisitionStateView is what the sweeper has done about one album
-// (milestone #290), attached to the group so the operator can tell "nothing
-// has happened yet" from "asked twice, still nothing" without cross-checking
-// the Requests queue.
-//
-// NextAttemptAt is computed rather than stored: the schedule is a function of
-// the attempt count and the current settings, so persisting it would go stale
-// the moment an operator edited the backoff.
+// reacquisitionStateView is what the wanted list says about one album
+// (milestone #290, M502 #5520): when it was wanted back, and when the library
+// held it again. A missing album with no want yet is still inside the grace
+// window, or MusicBrainz cannot name it.
 type reacquisitionStateView struct {
-	Attempts      int     `json:"attempts"`
-	LastAttemptAt *string `json:"last_attempt_at"`
-	NextAttemptAt *string `json:"next_attempt_at"`
-	GaveUpAt      *string `json:"gave_up_at"`
+	WantedAt *string `json:"wanted_at"`
+	HeldAt   *string `json:"held_at"`
 }
 
 // missingGroupView is a directory's worth of missing tracks.
@@ -159,15 +151,14 @@ func groupMissingByDirectory(rows []dbq.ListMissingTracksRow) []missingGroupView
 	return groups
 }
 
-// attachReacquisitionState decorates each group with what the sweeper has
-// done about its album (milestone #290).
+// attachReacquisitionState decorates each group with its album's want.
 //
 // Best-effort: this is context on a list whose primary job is showing what is
 // missing, so a failure here leaves the groups bare rather than failing the
 // page. One batched query for the whole page, not one per group.
 //
-// A group is keyed by directory while re-acquisition is keyed by album, and
-// those line up in practice (an album's files live in one folder) but are not
+// A group is keyed by directory while a want is keyed by album, and those
+// line up in practice (an album's files live in one folder) but are not
 // guaranteed to — a directory holding two albums takes the first album's
 // state, which is the same album its first track belongs to.
 func (h *handlers) attachReacquisitionState(
@@ -191,60 +182,34 @@ func (h *handlers) attachReacquisitionState(
 		ids = append(ids, row.AlbumID)
 	}
 
-	states, err := q.GetReacquisitionForAlbums(r.Context(), ids)
+	wants, err := q.GetWantsForAlbums(r.Context(), ids)
 	if err != nil {
-		h.logger.Warn("admin missing: reacquisition state lookup failed", "err", err)
+		h.logger.Warn("admin missing: want lookup failed", "err", err)
 		return
 	}
-	byAlbum := make(map[string]dbq.MissingReacquisition, len(states))
-	for _, s := range states {
-		byAlbum[uuidToString(s.AlbumID)] = s
-	}
-
-	// The settings service is optional in contexts that only wire routing
-	// (tests), and the backoff projection is decoration on a list whose real
-	// job is elsewhere — so fall back to the shipped defaults rather than
-	// making this a nil-pointer waiting to happen (rule #48).
-	cfg := reacquisition.Defaults
-	if h.reacqSettings != nil {
-		cfg = h.reacqSettings.Get()
+	// Newest want first, so the first seen per album is its current one.
+	byAlbum := make(map[string]dbq.GetWantsForAlbumsRow, len(wants))
+	for _, w := range wants {
+		if _, seen := byAlbum[uuidToString(w.AlbumID)]; !seen {
+			byAlbum[uuidToString(w.AlbumID)] = w
+		}
 	}
 	for i := range groups {
 		albumID, ok := dirAlbum[groups[i].Directory]
 		if !ok {
 			continue
 		}
-		state, ok := byAlbum[uuidToString(albumID)]
+		w, ok := byAlbum[uuidToString(albumID)]
 		if !ok {
 			continue
 		}
-		groups[i].Reacquisition = buildReacquisitionState(state, cfg.Backoff(state.Attempts))
-	}
-}
-
-// buildReacquisitionState renders one album's attempt record, projecting the
-// next attempt from the last one plus the backoff the current settings imply.
-func buildReacquisitionState(
-	state dbq.MissingReacquisition,
-	backoff time.Duration,
-) *reacquisitionStateView {
-	out := &reacquisitionStateView{Attempts: int(state.Attempts)}
-	if state.LastAttemptAt.Valid {
-		s := formatTimestamp(state.LastAttemptAt)
-		out.LastAttemptAt = &s
-		// Only meaningful while more attempts remain; an album that has given
-		// up has no next attempt to promise.
-		if !state.GaveUpAt.Valid {
-			next := formatTimestamp(pgtype.Timestamptz{
-				Time:  state.LastAttemptAt.Time.Add(backoff),
-				Valid: true,
-			})
-			out.NextAttemptAt = &next
+		view := &reacquisitionStateView{}
+		wantedAt := formatTimestamp(w.WantedAt)
+		view.WantedAt = &wantedAt
+		if w.FulfilledAt.Valid {
+			heldAt := formatTimestamp(w.FulfilledAt)
+			view.HeldAt = &heldAt
 		}
+		groups[i].Reacquisition = view
 	}
-	if state.GaveUpAt.Valid {
-		s := formatTimestamp(state.GaveUpAt)
-		out.GaveUpAt = &s
-	}
-	return out
 }