feat(taste): era/decade taste facet — #1530

Milestone #160 Opt 2 (era half). A third taste facet alongside artists
+ genre tags: signed weights over decade buckets ("1990s") derived from
albums.release_date, rebuilt daily and scored into the taste match.

- Migration 0045: taste_profile_eras table (mirrors taste_profile_tags)
  + taste_tuning.era_scale column (DEFAULT 0.5).
- Build side (internal/taste): Config.EraScale ([0,1] damper, mirrors
  EnrichedTagScale), accumulate folds each play/like's decade at
  base*EraScale, persist atomic-replaces the era rows.
- Scorer (internal/recommendation): TasteProfile gains an era term (own
  tanh scale + additive 0.15 share so it never weakens the existing
  artist/tag signal when a track is undated); candidate queries return
  album release_date; decadeOf mirrors the builder helper.
- Tuning lab: era_scale threaded through recsettings + admin API + web
  card (auto-renders the new row) + Go/web tests.

Mood facet deferred to #1534 (partial enrichment coverage + needs
candidate-side enriched-tag loading).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

internal/db/dbq/taste_profile.sql.go

@@ -20,6 +20,15 @@ func (q *Queries) DeleteTasteProfileArtistsForUser(ctx context.Context, userID p
 	return err
 }
 
+const deleteTasteProfileErasForUser = `-- name: DeleteTasteProfileErasForUser :exec
+DELETE FROM taste_profile_eras WHERE user_id = $1
+`
+
+func (q *Queries) DeleteTasteProfileErasForUser(ctx context.Context, userID pgtype.UUID) error {
+	_, err := q.db.Exec(ctx, deleteTasteProfileErasForUser, userID)
+	return err
+}
+
 const deleteTasteProfileTagsForUser = `-- name: DeleteTasteProfileTagsForUser :exec
 DELETE FROM taste_profile_tags WHERE user_id = $1
 `
@@ -45,6 +54,22 @@ func (q *Queries) InsertTasteProfileArtist(ctx context.Context, arg InsertTasteP
 	return err
 }
 
+const insertTasteProfileEra = `-- name: InsertTasteProfileEra :exec
+INSERT INTO taste_profile_eras (user_id, era, weight)
+VALUES ($1, $2, $3)
+`
+
+type InsertTasteProfileEraParams struct {
+	UserID pgtype.UUID
+	Era    string
+	Weight float64
+}
+
+func (q *Queries) InsertTasteProfileEra(ctx context.Context, arg InsertTasteProfileEraParams) error {
+	_, err := q.db.Exec(ctx, insertTasteProfileEra, arg.UserID, arg.Era, arg.Weight)
+	return err
+}
+
 const insertTasteProfileTag = `-- name: InsertTasteProfileTag :exec
 INSERT INTO taste_profile_tags (user_id, tag, weight)
 VALUES ($1, $2, $3)
@@ -87,21 +112,23 @@ func (q *Queries) ListLikedArtistIDsForUser(ctx context.Context, userID pgtype.U
 }
 
 const listLikedTrackTasteInputsForUser = `-- name: ListLikedTrackTasteInputsForUser :many
-SELECT t.id AS track_id, t.artist_id, t.genre
+SELECT t.id AS track_id, t.artist_id, t.genre, a.release_date
 FROM general_likes gl
 JOIN tracks t ON t.id = gl.track_id
+JOIN albums a ON a.id = t.album_id
 WHERE gl.user_id = $1
 `
 
 type ListLikedTrackTasteInputsForUserRow struct {
-	TrackID  pgtype.UUID
-	ArtistID pgtype.UUID
-	Genre    *string
+	TrackID     pgtype.UUID
+	ArtistID    pgtype.UUID
+	Genre       *string
+	ReleaseDate pgtype.Date
 }
 
-// (track_id, artist_id, genre) for each track the user has explicitly
-// liked. Feeds the track-like bonus into the liked track's artist and
-// tags; track_id keys the enriched track_tags lookup (#1490).
+// (track_id, artist_id, genre, release_date) for each track the user has
+// explicitly liked. Feeds the track-like bonus into the liked track's artist,
+// tags, and era (#1530); track_id keys the enriched track_tags lookup (#1490).
 func (q *Queries) ListLikedTrackTasteInputsForUser(ctx context.Context, userID pgtype.UUID) ([]ListLikedTrackTasteInputsForUserRow, error) {
 	rows, err := q.db.Query(ctx, listLikedTrackTasteInputsForUser, userID)
 	if err != nil {
@@ -111,7 +138,12 @@ func (q *Queries) ListLikedTrackTasteInputsForUser(ctx context.Context, userID p
 	var items []ListLikedTrackTasteInputsForUserRow
 	for rows.Next() {
 		var i ListLikedTrackTasteInputsForUserRow
-		if err := rows.Scan(&i.TrackID, &i.ArtistID, &i.Genre); err != nil {
+		if err := rows.Scan(
+			&i.TrackID,
+			&i.ArtistID,
+			&i.Genre,
+			&i.ReleaseDate,
+		); err != nil {
 			return nil, err
 		}
 		items = append(items, i)
@@ -128,6 +160,7 @@ SELECT
     t.id AS track_id,
     t.artist_id,
     t.genre,
+    a.release_date,
     LEAST(GREATEST(
         COALESCE(pe.completion_ratio,
                  pe.duration_played_ms::float8 / NULLIF(t.duration_ms, 0),
@@ -135,6 +168,7 @@ SELECT
     (EXTRACT(epoch FROM now() - pe.started_at) / 86400.0)::float8 AS age_days
 FROM play_events pe
 JOIN tracks t ON t.id = pe.track_id
+JOIN albums a ON a.id = t.album_id
 WHERE pe.user_id = $1
   AND pe.started_at > now() - ($2::float8 * INTERVAL '1 day')
   AND NOT EXISTS (
@@ -149,11 +183,12 @@ type ListPlayEngagementInputsForUserParams struct {
 }
 
 type ListPlayEngagementInputsForUserRow struct {
-	TrackID    pgtype.UUID
-	ArtistID   pgtype.UUID
-	Genre      *string
-	Completion float64
-	AgeDays    float64
+	TrackID     pgtype.UUID
+	ArtistID    pgtype.UUID
+	Genre       *string
+	ReleaseDate pgtype.Date
+	Completion  float64
+	AgeDays     float64
 }
 
 // Taste profile (#796 phase 1). The daily build computes signed artist/tag
@@ -162,7 +197,8 @@ type ListPlayEngagementInputsForUserRow struct {
 // One row per play in the decay-relevant window. completion is the play's
 // completion ratio (precomputed column when present, else duration_played /
 // track duration, clamped to [0,1]); age_days drives the time-decay. Genre
-// is split into tags in Go. Quarantined tracks are excluded.
+// is split into tags in Go; release_date derives the decade for the era
+// facet (#1530). Quarantined tracks are excluded.
 func (q *Queries) ListPlayEngagementInputsForUser(ctx context.Context, arg ListPlayEngagementInputsForUserParams) ([]ListPlayEngagementInputsForUserRow, error) {
 	rows, err := q.db.Query(ctx, listPlayEngagementInputsForUser, arg.UserID, arg.Column2)
 	if err != nil {
@@ -176,6 +212,7 @@ func (q *Queries) ListPlayEngagementInputsForUser(ctx context.Context, arg ListP
 			&i.TrackID,
 			&i.ArtistID,
 			&i.Genre,
+			&i.ReleaseDate,
 			&i.Completion,
 			&i.AgeDays,
 		); err != nil {
@@ -228,6 +265,45 @@ func (q *Queries) ListTasteProfileArtistsForUser(ctx context.Context, arg ListTa
 	return items, nil
 }
 
+const listTasteProfileErasForUser = `-- name: ListTasteProfileErasForUser :many
+SELECT era, weight
+FROM taste_profile_eras
+WHERE user_id = $1
+ORDER BY weight DESC
+LIMIT $2
+`
+
+type ListTasteProfileErasForUserParams struct {
+	UserID pgtype.UUID
+	Limit  int32
+}
+
+type ListTasteProfileErasForUserRow struct {
+	Era    string
+	Weight float64
+}
+
+// Top-weighted taste eras (#1530); consumed by the scorer's era term.
+func (q *Queries) ListTasteProfileErasForUser(ctx context.Context, arg ListTasteProfileErasForUserParams) ([]ListTasteProfileErasForUserRow, error) {
+	rows, err := q.db.Query(ctx, listTasteProfileErasForUser, arg.UserID, arg.Limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []ListTasteProfileErasForUserRow
+	for rows.Next() {
+		var i ListTasteProfileErasForUserRow
+		if err := rows.Scan(&i.Era, &i.Weight); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const listTasteProfileTagsForUser = `-- name: ListTasteProfileTagsForUser :many
 SELECT tag, weight
 FROM taste_profile_tags