fix(playlists): Songs-like mixes no longer vanish after a quiet week

PickSeedArtists had a hard 7-day window with no fallback: a week
without listening emptied the seed pool, produceSeedMixes returned
zero playlists, and the daily atomic-replace build deleted every
existing "Songs like X" mix until the user played something again
(#1255).

The query now falls back through widening engagement windows — 7d →
30d → all-time → liked artists — the same tiered shape that fixed the
identical vanish for For You's seeds (PickTopPlayedTracksForUser).
Like-boost scoring is preserved in every tier.

All returned rows share the winning tier, and produceSeedMixes maps it
onto the rule-#131 pick-kind ladder (7d = tier1 exact, 30d = tier2,
all-time/liked = tier3) and stamps the built tracks — the #1270
provenance pipeline then attributes plays and skips to seed freshness,
so the metrics card can say whether stale-seeded mixes actually
perform worse.

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

internal/playlists/seed_selection_test.go

@@ -46,6 +46,26 @@ func TestPickSeedArtistsFromRows_Empty(t *testing.T) {
 	}
 }
 
+func TestPickKindForSeedTier(t *testing.T) {
+	// The seed query's fallback tiers map onto the rule-#131 ladder:
+	// fresh 7-day engagement is the exact desire, everything past the
+	// 30-day step-back collapses into the far tier (#1255).
+	cases := []struct {
+		tier int32
+		want string
+	}{
+		{0, pickKindTier1},
+		{1, pickKindTier2},
+		{2, pickKindTier3},
+		{3, pickKindTier3},
+	}
+	for _, c := range cases {
+		if got := pickKindForSeedTier(c.tier); got != c.want {
+			t.Errorf("pickKindForSeedTier(%d) = %q, want %q", c.tier, got, c.want)
+		}
+	}
+}
+
 // userIDHash is the per-user, per-day hash that drives the daily-
 // determinism RNGs. Same family as tieBreakHash, just keyed on user
 // ID instead of track ID.

internal/playlists/system.go

@@ -147,8 +147,28 @@ const (
 	pickKindDormant   = "dormant"
 	pickKindCrossUser = "cross_user"
 	pickKindRandom    = "random"
+	pickKindTier1     = "tier1"
+	pickKindTier2     = "tier2"
+	pickKindTier3     = "tier3"
 )
 
+// pickKindForSeedTier maps PickSeedArtists' seed-pool fallback tier
+// onto the rule-#131 pick-kind ladder: fresh 7-day engagement pins the
+// mix's exact desire (tier1), the 30-day window steps back a little
+// (tier2), and all-time / liked-only seeds are the far fallback
+// (tier3). Stamped mix-wide — seed staleness is a property of the
+// whole build, and it's what the metrics breakdown attributes skips to.
+func pickKindForSeedTier(tier int32) string {
+	switch tier {
+	case 0:
+		return pickKindTier1
+	case 1:
+		return pickKindTier2
+	default:
+		return pickKindTier3
+	}
+}
+
 const systemMixLength = 25
 
 // systemMixWeights are the fixed scoring weights used by the cron worker.
@@ -389,8 +409,11 @@ func produceForYou(
 }
 
 // produceSeedMixes: up to 3 "Songs like {artist}" mixes. Seed
-// artists rotate daily-deterministically. The base seed-artist
-// query failing is fatal; per-artist failures are logged + skipped.
+// artists rotate daily-deterministically; the seed query falls back
+// through widening engagement windows (#1255) and every returned row
+// shares the winning tier, stamped onto the built tracks as their
+// pick_kind. The base seed-artist query failing is fatal; per-artist
+// failures are logged + skipped.
 func produceSeedMixes(
 	ctx context.Context, q *dbq.Queries, logger *slog.Logger,
 	userID pgtype.UUID, dateStr string, now time.Time,
@@ -399,6 +422,10 @@ func produceSeedMixes(
 	if err != nil {
 		return nil, fmt.Errorf("pick seed artists: %w", err)
 	}
+	seedTierKind := ""
+	if len(seedRows) > 0 {
+		seedTierKind = pickKindForSeedTier(seedRows[0].Tier)
+	}
 	seedRowsLocal := make([]seedArtistRow, 0, len(seedRows))
 	for _, r := range seedRows {
 		seedRowsLocal = append(seedRowsLocal, seedArtistRow{
@@ -443,6 +470,9 @@ func produceSeedMixes(
 		if len(tracks) == 0 {
 			continue
 		}
+		for i := range tracks {
+			tracks[i].PickKind = seedTierKind
+		}
 		out = append(out, builtPlaylist{
 			Name:         fmt.Sprintf("Songs like %s", artistRow.Name),
 			Variant:      "songs_like_artist",

internal/playlists/system_test.go

@@ -135,6 +135,59 @@ func TestBuildSystemPlaylists_SufficientActivity(t *testing.T) {
 	}
 }
 
+func TestBuildSystemPlaylists_StaleActivity_SongsLikeSurvives(t *testing.T) {
+	// #1255: the seed-artist query's old hard 7-day window emptied the
+	// pool after a quiet week, and the atomic-replace build then deleted
+	// every "Songs like X" mix. With the tiered fallback, plays that are
+	// ~20 days old (outside 7d, inside 30d) must still seed the mixes —
+	// and the built tracks carry the tier2 stamp so metrics can compare
+	// stale-seeded mixes against fresh ones.
+	pool := newPool(t)
+	logger := discardLogger()
+	u := seedUser(t, pool, "stale1")
+	old := time.Now().UTC().Add(-20 * 24 * time.Hour)
+	for a := 0; a < 4; a++ {
+		for k := 0; k < 3; k++ {
+			tk := seedTrack(t, pool,
+				"stale1-track-"+string(rune('A'+a))+string(rune('0'+k)),
+				"stale1-artist-"+string(rune('A'+a)))
+			for p := 0; p < 3; p++ {
+				seedPlayEvent(t, pool, u.ID, tk.ID,
+					old.Add(-time.Duration(a*10+k+p)*time.Hour), false)
+			}
+		}
+	}
+
+	if err := playlists.BuildSystemPlaylists(context.Background(), pool, logger, u.ID, time.Now().UTC(), t.TempDir()); err != nil {
+		t.Fatalf("build: %v", err)
+	}
+
+	rows, err := pool.Query(context.Background(), `
+		SELECT DISTINCT COALESCE(pt.pick_kind, '<null>')
+		  FROM playlist_tracks pt
+		  JOIN playlists p ON p.id = pt.playlist_id
+		 WHERE p.user_id = $1 AND p.system_variant = 'songs_like_artist'
+	`, u.ID)
+	if err != nil {
+		t.Fatalf("query pick_kinds: %v", err)
+	}
+	defer rows.Close()
+	var kinds []string
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err != nil {
+			t.Fatalf("scan: %v", err)
+		}
+		kinds = append(kinds, k)
+	}
+	if len(kinds) == 0 {
+		t.Fatal("expected songs_like_artist tracks from the 30-day fallback tier; got none (the vanish bug)")
+	}
+	if len(kinds) != 1 || kinds[0] != "tier2" {
+		t.Errorf("pick_kinds = %v, want exactly [tier2] (30-day fallback seeds)", kinds)
+	}
+}
+
 func TestBuildSystemPlaylists_QuarantineExcluded(t *testing.T) {
 	pool := newPool(t)
 	logger := discardLogger()