fix(mixes): close three intent gaps found in the system-playlists audit

Three discovery-mix defects from the intent audit (Scribe note #1254),
all sharing the same root pattern — skips treated as non-events:

- Deep Cuts (#1257): eligibility counted only unskipped plays, so a
  track skipped twice with zero completed listens read as "barely
  heard" and kept being re-offered. Tracks with >=2 skips no longer
  qualify; a single accidental skip doesn't banish.

- Rediscover (#1258): a skip on a rediscover-sourced play — the user
  explicitly declining the resurfacing invitation — changed nothing,
  so declined tracks re-qualified the next day forever. Such tracks
  now sit out 90 days.

- On This Day (#1256): day-of-year distance used plain ABS, so
  Dec 28 vs Jan 3 read as 359 days apart and the window silently
  gutted itself for ~3 weeks around every New Year. Now circular
  (LEAST(d, 365-d)), anchored on the build-date parameter instead of
  now() so it's testable and consistent with the mix's daily
  determinism.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TsF3cNoKrqCYsU78cXC8U6

internal/playlists/system_mixes_db_test.go

@@ -0,0 +1,179 @@
+package playlists_test
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
+)
+
+// seedTrackForArtist creates another track under an existing artist +
+// album pair. seedTrack's mbid-less upsert never dedupes artists, and
+// Deep Cuts' affinity rule needs several tracks sharing one artist_id.
+func seedTrackForArtist(t *testing.T, pool *pgxpool.Pool, title string, albumID, artistID pgtype.UUID) dbq.Track {
+	t.Helper()
+	track, err := dbq.New(pool).UpsertTrack(context.Background(), dbq.UpsertTrackParams{
+		Title: title, AlbumID: albumID, ArtistID: artistID,
+		DurationMs: 1000,
+		FilePath:   filepath.Join(t.TempDir(), fmt.Sprintf("%s.mp3", title)),
+		FileSize:   100, FileFormat: "mp3",
+	})
+	if err != nil {
+		t.Fatalf("seed track for artist: %v", err)
+	}
+	return track
+}
+
+// seedSourcedPlayEvent is seedPlayEvent plus a source tag — needed by
+// the Rediscover cooldown, which keys off rediscover-sourced skips.
+func seedSourcedPlayEvent(t *testing.T, pool *pgxpool.Pool, userID, trackID pgtype.UUID, startedAt time.Time, wasSkipped bool, source string) {
+	t.Helper()
+	_, err := pool.Exec(context.Background(), `
+		WITH s AS (
+			INSERT INTO play_sessions (user_id, started_at, last_event_at)
+			VALUES ($1, $3, $3)
+			RETURNING id
+		)
+		INSERT INTO play_events (user_id, track_id, session_id, started_at, was_skipped, source)
+		SELECT $1, $2, s.id, $3, $4, $5 FROM s
+	`, userID, trackID, startedAt, wasSkipped, source)
+	if err != nil {
+		t.Fatalf("seed sourced play_event: %v", err)
+	}
+}
+
+// idSet collapses candidate rows into a lookup by track id.
+func idSet[T any](rows []T, id func(T) pgtype.UUID) map[pgtype.UUID]bool {
+	out := make(map[pgtype.UUID]bool, len(rows))
+	for _, r := range rows {
+		out[id(r)] = true
+	}
+	return out
+}
+
+func TestListDeepCutsTracks_SkippedTracksExcluded(t *testing.T) {
+	// #1257: eligibility used to count only unskipped plays, so a track
+	// skipped repeatedly (and never finished) read as "barely heard".
+	pool := newPool(t)
+	q := dbq.New(pool)
+	u := seedUser(t, pool, "dc1")
+	now := time.Now().UTC()
+
+	// Affinity artist: 5 non-skip plays on the heavy track.
+	heavy := seedTrack(t, pool, "dc1-heavy", "dc1-artist")
+	for p := 0; p < 5; p++ {
+		seedPlayEvent(t, pool, u.ID, heavy.ID, now.Add(-time.Duration(p+1)*time.Hour), false)
+	}
+	// Actively rejected: two skips, zero completed plays.
+	rejected := seedTrackForArtist(t, pool, "dc1-rejected", heavy.AlbumID, heavy.ArtistID)
+	seedPlayEvent(t, pool, u.ID, rejected.ID, now.Add(-2*time.Hour), true)
+	seedPlayEvent(t, pool, u.ID, rejected.ID, now.Add(-3*time.Hour), true)
+	// Genuinely unexplored.
+	unheard := seedTrackForArtist(t, pool, "dc1-unheard", heavy.AlbumID, heavy.ArtistID)
+	// One accidental skip stays below the threshold.
+	oneSkip := seedTrackForArtist(t, pool, "dc1-oneskip", heavy.AlbumID, heavy.ArtistID)
+	seedPlayEvent(t, pool, u.ID, oneSkip.ID, now.Add(-4*time.Hour), true)
+
+	rows, err := q.ListDeepCutsTracks(context.Background(), dbq.ListDeepCutsTracksParams{
+		UserID: u.ID, Column2: "2026-07-03",
+	})
+	if err != nil {
+		t.Fatalf("ListDeepCutsTracks: %v", err)
+	}
+	got := idSet(rows, func(r dbq.ListDeepCutsTracksRow) pgtype.UUID { return r.ID })
+	if got[rejected.ID] {
+		t.Error("twice-skipped track qualified as a deep cut; skips must disqualify")
+	}
+	if !got[unheard.ID] {
+		t.Error("unexplored track missing from deep cuts")
+	}
+	if !got[oneSkip.ID] {
+		t.Error("single accidental skip must not banish a track")
+	}
+	if got[heavy.ID] {
+		t.Error("heavily-played track must not be a deep cut")
+	}
+}
+
+func TestListOnThisDayTracks_WrapsYearBoundary(t *testing.T) {
+	// #1256: plain ABS on day-of-year made Dec 28 vs Jan 3 read as 359
+	// days apart. The build date parameter anchors "today" so the wrap
+	// is testable at any run date.
+	pool := newPool(t)
+	q := dbq.New(pool)
+	u := seedUser(t, pool, "otd1")
+
+	// Played Dec 28, 2025 — 6 circular days from the Jan 3 build date.
+	winter := seedTrack(t, pool, "otd1-winter", "otd1-artist")
+	seedPlayEvent(t, pool, u.ID, winter.ID,
+		time.Date(2025, 12, 28, 12, 0, 0, 0, time.UTC), false)
+	// Played mid-March — far outside the ±10-day window.
+	spring := seedTrack(t, pool, "otd1-spring", "otd1-artist")
+	seedPlayEvent(t, pool, u.ID, spring.ID,
+		time.Date(2025, 3, 15, 12, 0, 0, 0, time.UTC), false)
+
+	rows, err := q.ListOnThisDayTracks(context.Background(), dbq.ListOnThisDayTracksParams{
+		UserID: u.ID, Column2: "2026-01-03",
+	})
+	if err != nil {
+		t.Fatalf("ListOnThisDayTracks: %v", err)
+	}
+	got := idSet(rows, func(r dbq.ListOnThisDayTracksRow) pgtype.UUID { return r.ID })
+	if !got[winter.ID] {
+		t.Error("play 6 calendar days across the year boundary must qualify (circular DOY)")
+	}
+	if got[spring.ID] {
+		t.Error("play ~70 days away must not qualify")
+	}
+}
+
+func TestListRediscoverTracks_SkippedResurfacingCoolsDown(t *testing.T) {
+	// #1258: a skip on a rediscover-sourced play is a declined
+	// invitation — the track sits out ~90 days instead of re-qualifying
+	// the next day. Skips from other surfaces don't cool down, and the
+	// cooldown expires.
+	pool := newPool(t)
+	q := dbq.New(pool)
+	u := seedUser(t, pool, "rd1")
+	now := time.Now().UTC()
+
+	eligible := func(name string, playsAge time.Duration) dbq.Track {
+		tk := seedTrack(t, pool, name, name+"-artist")
+		for p := 0; p < 3; p++ {
+			seedPlayEvent(t, pool, u.ID, tk.ID,
+				now.Add(-playsAge-time.Duration(p)*time.Hour), false)
+		}
+		return tk
+	}
+
+	// Declined 5 days ago from Rediscover itself → cooling down.
+	declined := eligible("rd1-declined", 60*24*time.Hour)
+	seedSourcedPlayEvent(t, pool, u.ID, declined.ID, now.Add(-5*24*time.Hour), true, "rediscover")
+	// Skipped 5 days ago, but from a different surface → still eligible.
+	otherSkip := eligible("rd1-otherskip", 60*24*time.Hour)
+	seedSourcedPlayEvent(t, pool, u.ID, otherSkip.ID, now.Add(-5*24*time.Hour), true, "radio")
+	// Declined 100 days ago → cooldown expired, eligible again.
+	lapsed := eligible("rd1-lapsed", 120*24*time.Hour)
+	seedSourcedPlayEvent(t, pool, u.ID, lapsed.ID, now.Add(-100*24*time.Hour), true, "rediscover")
+
+	rows, err := q.ListRediscoverTracks(context.Background(), u.ID)
+	if err != nil {
+		t.Fatalf("ListRediscoverTracks: %v", err)
+	}
+	got := idSet(rows, func(r dbq.ListRediscoverTracksRow) pgtype.UUID { return r.ID })
+	if got[declined.ID] {
+		t.Error("track declined from rediscover 5 days ago must be cooling down")
+	}
+	if !got[otherSkip.ID] {
+		t.Error("skip from a non-rediscover surface must not cool the track down")
+	}
+	if !got[lapsed.ID] {
+		t.Error("cooldown must expire after ~90 days")
+	}
+}