@audiofool/moondog 0.1.0 → 0.2.0-beta.2

package/src/profile/listening-profile-projection.mjs

@@ -1,5 +1,6 @@
 import { uuidV5 } from "../core/uuid-v5.mjs";
 import { musicProviderLabel } from "./music-providers.mjs";
+import { recordedMeasures } from "./recorded-measures.mjs";
 
 export const LISTENING_PROFILE_SCHEMA_VERSION = "listening-profile/1";
 export const LISTENING_PROFILE_EVIDENCE_NAMESPACE =
@@ -86,6 +87,60 @@ function signalNote(value) {
   return value === "historical attention only" ? "" : ` It helps ${signalPhrase(value)}.`;
 }
 
+// A basis states each measure for the plays that recorded it, so an unrecorded
+// one never reads as no time or no skips.
+function listeningTime(aggregate) {
+  const { time } = recordedMeasures(aggregate);
+  if (time === "none") return "";
+  const minutesText = `${minutes(aggregate.playedMs)} minutes`;
+  return time === "all"
+    ? `, ${minutesText} in all`
+    : `, ${minutesText} across the ${plural(aggregate.timedPlayCount, "timed play")}`;
+}
+
+function skipSentence(aggregate) {
+  const { skips } = recordedMeasures(aggregate);
+  if (skips === "none") return "";
+  const skipped = aggregate.skippedCount === 0
+    ? "Never skipped"
+    : `Skipped ${plural(aggregate.skippedCount, "time")}`;
+  return skips === "all"
+    ? ` ${skipped}.`
+    : ` ${skipped} in the ${plural(aggregate.skipKnownCount, "play")} with skip data.`;
+}
+
+function unskippedNote(aggregate) {
+  const { skips } = recordedMeasures(aggregate);
+  if (skips === "none") return "";
+  return skips === "all"
+    ? ` (${aggregate.engagedPlayCount} not skipped)`
+    : ` (${aggregate.skipKnownCount - aggregate.skippedCount} of the ${aggregate.skipKnownCount} with skip data not skipped)`;
+}
+
+// Minutes gate and rank listen-again picks only when every play recorded its
+// length; otherwise the play counts decide.
+function fullyTimed(aggregate) {
+  return recordedMeasures(aggregate).time === "all";
+}
+
+// A row states minutes only when every play recorded its length, because a
+// partial total undercounts and can't compare rows. It states skips, and plays
+// not skipped, only when some play recorded whether it was skipped.
+function recordedMinutes(aggregate, key = "listening_minutes") {
+  return fullyTimed(aggregate) ? { [key]: minutes(aggregate.playedMs) } : {};
+}
+
+function recordedSkips(aggregate, key = "explicit_skips") {
+  return recordedMeasures(aggregate).skips === "none" ? {} : { [key]: aggregate.skippedCount };
+}
+
+// Summary rows use this. Listen-again and back-to-back picks always state
+// engaged_play_count: their play floors count a play without skip data as
+// engaged, and the agent's candidate checks read it.
+function recordedEngagedPlays(aggregate, key = "engaged_play_count") {
+  return recordedMeasures(aggregate).skips === "none" ? {} : { [key]: aggregate.engagedPlayCount };
+}
+
 function aggregateEvidenceId(subjectId, kind, key) {
   return uuidV5(
     `${subjectId}\0${kind}\0${key}`,
@@ -164,13 +219,15 @@ function aggregateHistoryArc(rows) {
     }
 
     const aggregate = years.get(year) ?? {
-      eventCount: 0,
+      playCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
       trackRefs: new Set(),
       artists: new Map(),
     };
-    aggregate.eventCount += 1;
+    aggregate.playCount += 1;
     aggregate.playedMs += row.playedMs;
+    if (row.timed) aggregate.timedPlayCount += 1;
     aggregate.trackRefs.add(metadata.trackRefId);
 
     const artistKey = normalizedText(metadata.artist);
@@ -178,9 +235,11 @@ function aggregateHistoryArc(rows) {
       name: metadata.artist,
       playCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
     };
     artist.playCount += 1;
     artist.playedMs += row.playedMs;
+    if (row.timed) artist.timedPlayCount += 1;
     if (metadata.artistKnown) aggregate.artists.set(artistKey, artist);
     years.set(year, aggregate);
   }
@@ -199,8 +258,8 @@ function aggregateHistoryArc(rows) {
 
       return {
         year,
-        event_count: aggregate.eventCount,
-        listening_minutes: minutes(aggregate.playedMs),
+        event_count: aggregate.playCount,
+        ...recordedMinutes(aggregate),
         distinct_tracks: aggregate.trackRefs.size,
         first_observed_tracks: firstObservedTracks,
         ...(topArtist
@@ -208,7 +267,7 @@ function aggregateHistoryArc(rows) {
               top_artist: {
                 name: topArtist.name,
                 play_count: topArtist.playCount,
-                listening_minutes: minutes(topArtist.playedMs),
+                ...recordedMinutes(topArtist),
               },
             }
           : {}),
@@ -288,46 +347,58 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
     }
 
     const aggregate = aggregates.get(observedSeasonIndex) ?? {
-      eventCount: 0,
+      playCount: 0,
       engagedPlayCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
+      skipKnownCount: 0,
       activeMonths: new Set(),
       trackRefs: new Set(),
       artists: new Map(),
       tracks: new Map(),
     };
-    aggregate.eventCount += 1;
+    aggregate.playCount += 1;
     if (!row.skipped) aggregate.engagedPlayCount += 1;
     aggregate.playedMs += row.playedMs;
+    if (row.timed) aggregate.timedPlayCount += 1;
+    if (row.skipKnown) aggregate.skipKnownCount += 1;
     aggregate.activeMonths.add(observedMonthIndex);
     aggregate.trackRefs.add(trackKey);
 
     const artistKey = normalizedText(metadata.artist);
     const artist = aggregate.artists.get(artistKey) ?? {
       name: metadata.artist,
-      eventCount: 0,
+      playCount: 0,
       engagedPlayCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
+      skipKnownCount: 0,
       trackRefs: new Set(),
     };
-    artist.eventCount += 1;
+    artist.playCount += 1;
     if (!row.skipped) artist.engagedPlayCount += 1;
     artist.playedMs += row.playedMs;
+    if (row.timed) artist.timedPlayCount += 1;
+    if (row.skipKnown) artist.skipKnownCount += 1;
     artist.trackRefs.add(trackKey);
     if (metadata.artistKnown) aggregate.artists.set(artistKey, artist);
 
     const track = aggregate.tracks.get(trackKey) ?? {
       ...metadata,
       trackKey,
-      eventCount: 0,
+      playCount: 0,
       engagedPlayCount: 0,
       skippedCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
+      skipKnownCount: 0,
     };
-    track.eventCount += 1;
+    track.playCount += 1;
     if (row.skipped) track.skippedCount += 1;
     else track.engagedPlayCount += 1;
     track.playedMs += row.playedMs;
+    if (row.timed) track.timedPlayCount += 1;
+    if (row.skipKnown) track.skipKnownCount += 1;
     aggregate.tracks.set(trackKey, track);
     aggregates.set(observedSeasonIndex, aggregate);
   }
@@ -361,8 +432,8 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
         if (right.engagedPlayCount !== left.engagedPlayCount) {
           return right.engagedPlayCount - left.engagedPlayCount;
         }
-        if (right.eventCount !== left.eventCount) {
-          return right.eventCount - left.eventCount;
+        if (right.playCount !== left.playCount) {
+          return right.playCount - left.playCount;
         }
         return lexicalCompare(left.name, right.name);
       },
@@ -375,8 +446,8 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
         if (right.engagedPlayCount !== left.engagedPlayCount) {
           return right.engagedPlayCount - left.engagedPlayCount;
         }
-        if (right.eventCount !== left.eventCount) {
-          return right.eventCount - left.eventCount;
+        if (right.playCount !== left.playCount) {
+          return right.playCount - left.playCount;
         }
         const titleOrder = lexicalCompare(left.title, right.title);
         if (titleOrder !== 0) return titleOrder;
@@ -392,9 +463,14 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
       end_month: monthKey(lastMonthIndex),
       retained_month_count: lastMonthIndex - firstMonthIndex + 1,
       active_month_count: aggregate?.activeMonths.size ?? 0,
-      event_count: aggregate?.eventCount ?? 0,
-      engaged_play_count: aggregate?.engagedPlayCount ?? 0,
-      listening_minutes: minutes(aggregate?.playedMs ?? 0),
+      event_count: aggregate?.playCount ?? 0,
+      // A season with no plays has a true zero for each measure the history records.
+      ...(aggregate
+        ? { ...recordedEngagedPlays(aggregate), ...recordedMinutes(aggregate) }
+        : {
+            ...(eventAnalysis.recorded.skips === "none" ? {} : { engaged_play_count: 0 }),
+            ...(eventAnalysis.recorded.time === "none" ? {} : { listening_minutes: 0 }),
+          }),
       distinct_tracks: trackRefs.size,
       first_observed_tracks: firstObservedTracks,
       returning_tracks: trackRefs.size - firstObservedTracks,
@@ -402,9 +478,9 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
         ? {
             leading_artist: {
               name: leadingArtist.name,
-              event_count: leadingArtist.eventCount,
-              engaged_play_count: leadingArtist.engagedPlayCount,
-              listening_minutes: minutes(leadingArtist.playedMs),
+              event_count: leadingArtist.playCount,
+              ...recordedEngagedPlays(leadingArtist),
+              ...recordedMinutes(leadingArtist),
               distinct_tracks: leadingArtist.trackRefs.size,
             },
           }
@@ -418,10 +494,10 @@ function aggregateListeningSeasons(subjectId, eventAnalysis, explanations) {
               ...(signatureTrack.release
                 ? { release: signatureTrack.release }
                 : {}),
-              play_count: signatureTrack.eventCount,
-              engaged_play_count: signatureTrack.engagedPlayCount,
-              listening_minutes: minutes(signatureTrack.playedMs),
-              explicit_skips: signatureTrack.skippedCount,
+              play_count: signatureTrack.playCount,
+              ...recordedEngagedPlays(signatureTrack),
+              ...recordedMinutes(signatureTrack),
+              ...recordedSkips(signatureTrack),
             },
           }
         : {}),
@@ -572,13 +648,19 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       incognitoEventsExcluded += 1;
       continue;
     }
+    const skipped =
+      event?.event_type === "play_skipped" ||
+      event?.extensions?.["spotify.skipped"] === true;
     eligible.push({
       event,
       track: row.track,
       playedMs,
-      skipped:
-        event?.event_type === "play_skipped" ||
-        event?.extensions?.["spotify.skipped"] === true,
+      timed: hasPlayedDuration,
+      skipped,
+      // Only Spotify's extended history says whether a play was skipped, and
+      // not for every play.
+      skipKnown:
+        skipped || typeof event?.extensions?.["spotify.skipped"] === "boolean",
     });
   }
   const earliest = eligible.reduce(
@@ -613,6 +695,8 @@ function aggregateEvents(subjectId, eventRows, explanations) {
         engagedPlayCount: 0,
         skippedCount: 0,
         playedMs: 0,
+        timedPlayCount: 0,
+        skipKnownCount: 0,
         firstPlayedAt: occurredAt,
         lastPlayedAt: occurredAt,
         engagedPlayedAt: [],
@@ -620,6 +704,8 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       };
       track.playCount += 1;
       track.playedMs += row.playedMs;
+      if (row.timed) track.timedPlayCount += 1;
+      if (row.skipKnown) track.skipKnownCount += 1;
       if (row.skipped) track.skippedCount += 1;
       else {
         track.engagedPlayCount += 1;
@@ -634,9 +720,13 @@ function aggregateEvents(subjectId, eventRows, explanations) {
           engagedPlayCount: 0,
           skippedCount: 0,
           playedMs: 0,
+          timedPlayCount: 0,
+          skipKnownCount: 0,
         };
         yearAggregate.playCount += 1;
         yearAggregate.playedMs += row.playedMs;
+        if (row.timed) yearAggregate.timedPlayCount += 1;
+        if (row.skipKnown) yearAggregate.skipKnownCount += 1;
         if (row.skipped) yearAggregate.skippedCount += 1;
         else yearAggregate.engagedPlayCount += 1;
         track.years.set(year, yearAggregate);
@@ -649,6 +739,8 @@ function aggregateEvents(subjectId, eventRows, explanations) {
         engagedPlayCount: 0,
         skippedCount: 0,
         playedMs: 0,
+        timedPlayCount: 0,
+        skipKnownCount: 0,
         trackRefs: new Set(),
         years: new Map(),
         firstPlayedAt: occurredAt,
@@ -656,6 +748,8 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       };
       artist.playCount += 1;
       artist.playedMs += row.playedMs;
+      if (row.timed) artist.timedPlayCount += 1;
+      if (row.skipKnown) artist.skipKnownCount += 1;
       if (row.skipped) artist.skippedCount += 1;
       else artist.engagedPlayCount += 1;
       artist.trackRefs.add(trackKey);
@@ -693,7 +787,7 @@ function aggregateEvents(subjectId, eventRows, explanations) {
             evidenceId,
             dimension: "taste.artist_familiarity",
             value: item.name,
-            basis: `${plural(item.playCount, "play")} across ${plural(item.trackRefs.size, "track")}, ${minutes(item.playedMs)} minutes in all${windowKind === "recent" ? `, in the ${recentWindowDays} days up to ${day(latest)}` : `, from ${day(item.firstPlayedAt)} to ${day(item.lastPlayedAt)}`}.`,
+            basis: `${plural(item.playCount, "play")} across ${plural(item.trackRefs.size, "track")}${listeningTime(item)}${windowKind === "recent" ? `, in the ${recentWindowDays} days up to ${day(latest)}` : `, from ${day(item.firstPlayedAt)} to ${day(item.lastPlayedAt)}`}.`,
             name: `listening-artist-${windowKind}`,
             confidence: confidenceForCount(item.playCount),
             limitation:
@@ -703,10 +797,10 @@ function aggregateEvents(subjectId, eventRows, explanations) {
         return {
           name: item.name,
           play_count: item.playCount,
-          engaged_play_count: item.engagedPlayCount,
-          listening_minutes: minutes(item.playedMs),
+          ...recordedEngagedPlays(item),
+          ...recordedMinutes(item),
           distinct_tracks: item.trackRefs.size,
-          explicit_skips: item.skippedCount,
+          ...recordedSkips(item),
           last_played_at: item.lastPlayedAt,
           evidence_id: evidenceId,
         };
@@ -733,7 +827,7 @@ function aggregateEvents(subjectId, eventRows, explanations) {
             evidenceId,
             dimension: "taste.track_familiarity",
             value: `${item.title} - ${item.artist}`,
-            basis: `${plural(item.playCount, "play")}, ${minutes(item.playedMs)} minutes in all${windowKind === "recent" ? `, in the ${recentWindowDays} days up to ${day(latest)}` : `, from ${day(item.firstPlayedAt)} to ${day(item.lastPlayedAt)}`}. ${item.skippedCount === 0 ? "Never skipped" : `Skipped ${plural(item.skippedCount, "time")}`}.`,
+            basis: `${plural(item.playCount, "play")}${listeningTime(item)}${windowKind === "recent" ? `, in the ${recentWindowDays} days up to ${day(latest)}` : `, from ${day(item.firstPlayedAt)} to ${day(item.lastPlayedAt)}`}.${skipSentence(item)}`,
             name: `listening-track-${windowKind}`,
             confidence: confidenceForCount(item.playCount),
             limitation:
@@ -747,9 +841,9 @@ function aggregateEvents(subjectId, eventRows, explanations) {
           ...(item.release ? { release: item.release } : {}),
           identity_status: item.identityStatus,
           play_count: item.playCount,
-          engaged_play_count: item.engagedPlayCount,
-          listening_minutes: minutes(item.playedMs),
-          explicit_skips: item.skippedCount,
+          ...recordedEngagedPlays(item),
+          ...recordedMinutes(item),
+          ...recordedSkips(item),
           last_played_at: item.lastPlayedAt,
           evidence_id: evidenceId,
         };
@@ -786,6 +880,11 @@ function aggregateEvents(subjectId, eventRows, explanations) {
   const rowsWithOfflineState = eligible.filter(
     (row) => typeof row.event.extensions?.["spotify.offline"] === "boolean",
   );
+  const recorded = recordedMeasures({
+    playCount: eligible.length,
+    timedPlayCount: eligible.filter((row) => row.timed).length,
+    skipKnownCount: eligible.filter((row) => row.skipKnown).length,
+  });
   const context = {
     reference_date: latest,
     recent_window_days: recentWindowDays,
@@ -802,7 +901,9 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       ({ reason }) => normalizedText(reason.trim()) === "trackdone",
     ).length,
     skip_state_events: rowsWithSkipState.length,
-    explicit_skips: eligible.filter((row) => row.skipped).length,
+    ...(recorded.skips === "none"
+      ? {}
+      : { explicit_skips: eligible.filter((row) => row.skipped).length }),
     shuffle_state_events: rowsWithShuffleState.length,
     shuffle_events: rowsWithShuffleState.filter(
       (row) => row.event.extensions?.["spotify.shuffle"] === true,
@@ -821,6 +922,7 @@ function aggregateEvents(subjectId, eventRows, explanations) {
     rawPlayedMs,
     eventsWithPlayedDuration,
     profiledPlayedMs: eligible.reduce((sum, row) => sum + row.playedMs, 0),
+    recorded,
     lifetime,
     recent,
     historyArc,
@@ -879,7 +981,7 @@ function artistRelationships(subjectId, eventAnalysis, explanations) {
           evidenceId,
           dimension: "taste.artist_continuity",
           value: artist.name,
-          basis: `${artist.name} shows up in ${plural(activeYears, "year")} of your history, from ${firstYear} to ${lastYear}: ${plural(artist.playCount, "play")}, ${minutes(artist.playedMs)} minutes in all.`,
+          basis: `${artist.name} shows up in ${plural(activeYears, "year")} of your history, from ${firstYear} to ${lastYear}: ${plural(artist.playCount, "play")}${listeningTime(artist)}.`,
           name: "listening-artist-continuity",
           confidence: confidenceForCount(artist.playCount),
           limitation:
@@ -893,7 +995,7 @@ function artistRelationships(subjectId, eventAnalysis, explanations) {
         active_years: activeYears,
         span_years: spanYears,
         play_count: artist.playCount,
-        listening_minutes: minutes(artist.playedMs),
+        ...recordedMinutes(artist),
         evidence_id: evidenceId,
       };
     });
@@ -1001,12 +1103,16 @@ function releaseDepth(subjectId, eventAnalysis, explanations) {
       playCount: 0,
       engagedPlayCount: 0,
       playedMs: 0,
+      timedPlayCount: 0,
+      skipKnownCount: 0,
       years: new Set(),
     };
     release.trackRefs.add(metadata.trackRefId);
     release.playCount += 1;
     if (!row.skipped) release.engagedPlayCount += 1;
     release.playedMs += row.playedMs;
+    if (row.timed) release.timedPlayCount += 1;
+    if (row.skipKnown) release.skipKnownCount += 1;
     if (Number.isInteger(year)) release.years.add(year);
     releases.set(key, release);
   }
@@ -1043,7 +1149,7 @@ function releaseDepth(subjectId, eventAnalysis, explanations) {
           evidenceId,
           dimension: "taste.release_depth",
           value: `${release.title} - ${release.artist}`,
-          basis: `You played ${plural(release.trackRefs.size, "different track")} from ${release.title}: ${plural(release.playCount, "play")}, ${minutes(release.playedMs)} minutes in all${years.length > 0 ? `, across ${plural(years.length, "year")}` : ""}.`,
+          basis: `You played ${plural(release.trackRefs.size, "different track")} from ${release.title}: ${plural(release.playCount, "play")}${listeningTime(release)}${years.length > 0 ? `, across ${plural(years.length, "year")}` : ""}.`,
           name: "listening-release-depth",
           confidence: confidenceForCount(release.engagedPlayCount),
           limitation:
@@ -1055,8 +1161,8 @@ function releaseDepth(subjectId, eventAnalysis, explanations) {
         artist_credit: release.artist,
         distinct_tracks: release.trackRefs.size,
         play_count: release.playCount,
-        engaged_play_count: release.engagedPlayCount,
-        listening_minutes: minutes(release.playedMs),
+        ...recordedEngagedPlays(release),
+        ...recordedMinutes(release),
         ...(Number.isInteger(firstYear) ? { first_year: firstYear } : {}),
         ...(Number.isInteger(lastYear) ? { last_year: lastYear } : {}),
         active_years: years.length,
@@ -1307,7 +1413,7 @@ function backToBackTracks(
         play_count: lifetime?.playCount ?? item.playsInBursts,
         engaged_play_count:
           lifetime?.engagedPlayCount ?? item.playsInBursts,
-        explicit_skips: lifetime?.skippedCount ?? 0,
+        ...(lifetime ? recordedSkips(lifetime) : {}),
         burst_count: item.burstCount,
         maximum_consecutive_plays: item.maximumConsecutivePlays,
         plays_in_bursts: item.playsInBursts,
@@ -1320,8 +1426,13 @@ function backToBackTracks(
 }
 
 function deduplicateProfileEvidence(records) {
+  // A live library read is a complete snapshot: the newest one replaces older
+  // reads, so an unsaved song or unfollowed artist drops out after a re-sync.
+  const latestLibraryRead = records.reduce((latest, record) => record.provenance?.source_system === "spotify_web_api" &&
+    (record.provenance.captured_at ?? "") > latest ? record.provenance.captured_at : latest, "");
   const selected = new Map();
   for (const record of records) {
+    if (record.provenance?.source_system === "spotify_web_api" && record.provenance.captured_at !== latestLibraryRead) continue;
     const current = selected.get(record.evidence_key);
     const capturedAt = record.provenance?.captured_at ?? "";
     const currentCapturedAt = current?.provenance?.captured_at ?? "";
@@ -1357,14 +1468,17 @@ function persistedExplanation(record) {
     taste_artist_ranked: `Spotify's exported Taste Profile ranked this artist reference at position ${attributes.rank}.`,
     provider_interpretation: `Spotify supplied this provider-generated ${label.replaceAll("_", " ")} narrative in ${source}.`,
     sound_capsule_artist_ranked: `Spotify Sound Capsule ranked this artist at position ${attributes.rank} for ${attributes.period}.`,
+    top_artist_ranked: `Spotify ranked this artist at position ${attributes.rank} of your top artists for ${attributes.period}, as of ${record.provenance.captured_at}.`,
+    top_track_ranked: `Spotify ranked this track at position ${attributes.rank} of your top tracks for ${attributes.period}, as of ${record.provenance.captured_at}.`,
     sound_capsule_track_ranked: `Spotify Sound Capsule ranked this track label at position ${attributes.rank} for ${attributes.period}.`,
     sound_capsule_highlight: `Spotify Sound Capsule emitted a ${attributes.highlight_type} highlight dated ${record.observed_at}.`,
     wrapped_metric: `Spotify Wrapped reported ${attributes.value} ${attributes.unit} for ${label} in ${attributes.period}.`,
     sound_capsule_period_metric: `Spotify Sound Capsule reported ${attributes.stream_count} streams and ${attributes.played_seconds} played seconds for ${attributes.period}.`,
   };
   const limitationByClass = {
-    explicit:
-      "This is an explicit current provider state, but the export does not include the original action timestamp.",
+    explicit: record.provenance?.source_system === "spotify_web_api"
+      ? "This is your saved state in Spotify when Moondog read it; it shows what you keep, not how often you play it."
+      : "This is an explicit current provider state, but the export does not include the original action timestamp.",
     curated:
       "Playlist inclusion is a curatorial signal, not proof of a permanent preference or the reason for inclusion.",
     behavioral:
@@ -1388,6 +1502,8 @@ function persistedExplanation(record) {
     provider_interpretation: "provider.interpretation",
     sound_capsule_artist_ranked: "provider.artist_rank",
     sound_capsule_track_ranked: "provider.track_rank",
+    top_artist_ranked: "provider.artist_rank",
+    top_track_ranked: "provider.track_rank",
     sound_capsule_highlight: "provider.highlight",
     wrapped_metric: "provider.metric",
     sound_capsule_period_metric: "provider.metric",
@@ -1462,7 +1578,7 @@ function evidenceGroups(records, eventAnalysis, explanations) {
       label: record.entity.label,
       artist_credit: record.entity.artist_credit,
       ...(record.entity.release ? { release: record.entity.release } : {}),
-      ...(metric ? { listening_minutes: minutes(metric.playedMs) } : {}),
+      ...(metric ? recordedMinutes(metric) : {}),
       evidence_id: record.profile_evidence_id,
     }));
 
@@ -1484,7 +1600,7 @@ function evidenceGroups(records, eventAnalysis, explanations) {
       artist_credit: group.entity.artist_credit,
       ...(group.entity.release ? { release: group.entity.release } : {}),
       playlist_count: group.playlists.size,
-      playlist_names: [...group.playlists].sort(lexicalCompare).slice(0, 3),
+      playlist_names: [...group.playlists].sort(lexicalCompare),
       last_added_at: group.lastAddedAt,
       evidence_id: group.evidenceId,
     }));
@@ -1500,7 +1616,7 @@ function evidenceGroups(records, eventAnalysis, explanations) {
     })
     .map(({ record, metric }) => ({
       name: record.entity.label,
-      ...(metric ? { listening_minutes: minutes(metric.playedMs) } : {}),
+      ...(metric ? recordedMinutes(metric) : {}),
       evidence_id: record.profile_evidence_id,
     }));
 
@@ -1562,10 +1678,12 @@ function evidenceGroups(records, eventAnalysis, explanations) {
     "wrapped_artist_ranked",
     "taste_artist_ranked",
     "sound_capsule_artist_ranked",
+    "top_artist_ranked",
   ]);
   const providerTrackKinds = new Set([
     "wrapped_track_ranked",
     "sound_capsule_track_ranked",
+    "top_track_ranked",
   ]);
   function providerRanked(kinds, outputType) {
     const groups = new Map();
@@ -1817,9 +1935,10 @@ function rediscoverySignal(track, evidence, direct) {
 }
 
 function rediscoveryPeakYear(track) {
+  const byTime = fullyTimed(track);
   return [...track.years.entries()]
     .sort(([leftYear, left], [rightYear, right]) => {
-      if (right.playedMs !== left.playedMs) {
+      if (byTime && right.playedMs !== left.playedMs) {
         return right.playedMs - left.playedMs;
       }
       if (right.playCount !== left.playCount) {
@@ -1834,6 +1953,7 @@ function rediscoveryPeakYear(track) {
       explicit_skips: aggregate.skippedCount,
       listening_minutes: minutes(aggregate.playedMs),
       played_ms: aggregate.playedMs,
+      plays: aggregate,
     }))[0] ?? null;
 }
 
@@ -1847,7 +1967,7 @@ function rediscoveryTracks(
   const latestMs = Date.parse(eventAnalysis.latest ?? "");
   if (!Number.isFinite(latestMs)) return [];
   const avoids = combinedAvoids(direct.avoids, evidence.avoids);
-  return [...eventAnalysis.lifetime.tracks.values()]
+  const candidates = [...eventAnalysis.lifetime.tracks.values()]
     .map((track) => {
       const lastPlayedMs = Date.parse(track.lastPlayedAt);
       const quietDays = Math.floor((latestMs - lastPlayedMs) / dayMs);
@@ -1864,15 +1984,17 @@ function rediscoveryTracks(
         quietDays >= recentWindowDays &&
         track.playCount >= rediscoveryMinimumPlays &&
         track.engagedPlayCount >= rediscoveryMinimumEngagedPlays &&
-        track.playedMs >= rediscoveryMinimumPlayedMs &&
+        (!fullyTimed(track) || track.playedMs >= rediscoveryMinimumPlayedMs) &&
         track.engagedPlayCount >= track.skippedCount &&
         !avoids.some((item) => assertionMatchesTrack(item, track)),
-    )
+    );
+  const byTime = candidates.every(({ track }) => fullyTimed(track));
+  return candidates
     .sort((left, right) => {
       if (right.signal.rank !== left.signal.rank) {
         return right.signal.rank - left.signal.rank;
       }
-      if (right.track.playedMs !== left.track.playedMs) {
+      if (byTime && right.track.playedMs !== left.track.playedMs) {
         return right.track.playedMs - left.track.playedMs;
       }
       if (right.track.engagedPlayCount !== left.track.engagedPlayCount) {
@@ -1896,7 +2018,7 @@ function rediscoveryTracks(
           evidenceId,
           dimension: "listening.rediscovery_candidate",
           value: `${track.title} - ${track.artist}`,
-          basis: `${plural(track.playCount, "play")} (${track.engagedPlayCount} not skipped), ${minutes(track.playedMs)} minutes in all, from ${day(track.firstPlayedAt)} to ${day(track.lastPlayedAt)}. Then nothing for ${plural(quietDays, "day")}, up to the latest play in your history. The strongest reason to bring it back is ${signalPhrase(signal.value)}.`,
+          basis: `${plural(track.playCount, "play")}${unskippedNote(track)}${listeningTime(track)}, from ${day(track.firstPlayedAt)} to ${day(track.lastPlayedAt)}. Then nothing for ${plural(quietDays, "day")}, up to the latest play in your history. The strongest reason to bring it back is ${signalPhrase(signal.value)}.`,
           name: "listening-track-rediscovery",
           confidence:
             signal.rank === 4
@@ -1914,8 +2036,8 @@ function rediscoveryTracks(
         identity_status: track.identityStatus,
         play_count: track.playCount,
         engaged_play_count: track.engagedPlayCount,
-        listening_minutes: minutes(track.playedMs),
-        explicit_skips: track.skippedCount,
+        ...recordedMinutes(track),
+        ...recordedSkips(track),
         first_played_at: track.firstPlayedAt,
         last_played_at: track.lastPlayedAt,
         quiet_days: quietDays,
@@ -1924,7 +2046,7 @@ function rediscoveryTracks(
           ? {
               peak_year: peak.year,
               peak_year_play_count: peak.play_count,
-              peak_year_listening_minutes: peak.listening_minutes,
+              ...recordedMinutes(peak.plays, "peak_year_listening_minutes"),
             }
           : {}),
         evidence_id: evidenceId,
@@ -1960,7 +2082,7 @@ function historicalReturnTracks(
   explanations,
 ) {
   const avoids = combinedAvoids(direct.avoids, evidence.avoids);
-  return [...eventAnalysis.lifetime.tracks.values()]
+  const candidates = [...eventAnalysis.lifetime.tracks.values()]
     .map((track) => ({
       track,
       returns: historicalReturnGaps(track),
@@ -1971,10 +2093,12 @@ function historicalReturnTracks(
         returns.length > 0 &&
         track.playCount >= historicalReturnMinimumPlays &&
         track.engagedPlayCount >= historicalReturnMinimumEngagedPlays &&
-        track.playedMs >= historicalReturnMinimumPlayedMs &&
+        (!fullyTimed(track) || track.playedMs >= historicalReturnMinimumPlayedMs) &&
         track.engagedPlayCount >= track.skippedCount &&
         !avoids.some((item) => assertionMatchesTrack(item, track)),
-    )
+    );
+  const byTime = candidates.every(({ track }) => fullyTimed(track));
+  return candidates
     .sort((left, right) => {
       if (right.returns.length !== left.returns.length) {
         return right.returns.length - left.returns.length;
@@ -1989,7 +2113,7 @@ function historicalReturnTracks(
       if (right.signal.rank !== left.signal.rank) {
         return right.signal.rank - left.signal.rank;
       }
-      if (right.track.playedMs !== left.track.playedMs) {
+      if (byTime && right.track.playedMs !== left.track.playedMs) {
         return right.track.playedMs - left.track.playedMs;
       }
       if (right.track.engagedPlayCount !== left.track.engagedPlayCount) {
@@ -2014,7 +2138,7 @@ function historicalReturnTracks(
           evidenceId,
           dimension: "listening.historical_return",
           value: `${track.title} - ${track.artist}`,
-          basis: `${plural(track.playCount, "play")} (${track.engagedPlayCount} not skipped), ${minutes(track.playedMs)} minutes in all, from ${day(track.firstPlayedAt)} to ${day(track.lastPlayedAt)}. It came back ${returns.length === 1 ? "once" : `${returns.length} times`} after ${historicalReturnMinimumGapDays}+ days away; the longest time away was ${plural(longestGapDays, "day")}.${signalNote(signal.value)}`,
+          basis: `${plural(track.playCount, "play")}${unskippedNote(track)}${listeningTime(track)}, from ${day(track.firstPlayedAt)} to ${day(track.lastPlayedAt)}. It came back ${returns.length === 1 ? "once" : `${returns.length} times`} after ${historicalReturnMinimumGapDays}+ days away; the longest time away was ${plural(longestGapDays, "day")}.${signalNote(signal.value)}`,
           name: "listening-track-historical-return",
           confidence: confidenceForCount(
             track.engagedPlayCount + returns.length,
@@ -2033,8 +2157,8 @@ function historicalReturnTracks(
         identity_status: track.identityStatus,
         play_count: track.playCount,
         engaged_play_count: track.engagedPlayCount,
-        listening_minutes: minutes(track.playedMs),
-        explicit_skips: track.skippedCount,
+        ...recordedMinutes(track),
+        ...recordedSkips(track),
         first_played_at: track.firstPlayedAt,
         last_played_at: track.lastPlayedAt,
         return_count: returns.length,
@@ -2084,7 +2208,8 @@ function timeCapsuleTracks(
     if (
       !peak ||
       peak.engaged_play_count < timeCapsuleMinimumEngagedPlays ||
-      peak.listening_minutes < minutes(timeCapsuleMinimumPlayedMs) ||
+      (fullyTimed(peak.plays) &&
+        peak.listening_minutes < minutes(timeCapsuleMinimumPlayedMs)) ||
       peak.engaged_play_count < peak.explicit_skips
     ) {
       continue;
@@ -2099,11 +2224,14 @@ function timeCapsuleTracks(
   }
   if (byYear.size < timeCapsuleMinimumYears) return [];
 
+  const byTime = [...byYear.values()].every((values) =>
+    values.every(({ track }) => fullyTimed(track)),
+  );
   const rankedYears = [...byYear.entries()]
     .sort(([left], [right]) => left - right)
     .map(([year, values]) => {
       values.sort((left, right) => {
-        if (right.peak.played_ms !== left.peak.played_ms) {
+        if (byTime && right.peak.played_ms !== left.peak.played_ms) {
           return right.peak.played_ms - left.peak.played_ms;
         }
         if (
@@ -2114,7 +2242,7 @@ function timeCapsuleTracks(
         if (right.signal.rank !== left.signal.rank) {
           return right.signal.rank - left.signal.rank;
         }
-        if (right.track.playedMs !== left.track.playedMs) {
+        if (byTime && right.track.playedMs !== left.track.playedMs) {
           return right.track.playedMs - left.track.playedMs;
         }
         const titleOrder = lexicalCompare(left.track.title, right.track.title);
@@ -2123,7 +2251,9 @@ function timeCapsuleTracks(
       return {
         year,
         values,
-        strength: values[0].peak.played_ms,
+        strength: byTime
+          ? values[0].peak.played_ms
+          : values[0].peak.engaged_play_count,
       };
     });
   const selectedYears = evenlySpaced(rankedYears, maximum).sort(
@@ -2136,6 +2266,7 @@ function timeCapsuleTracks(
         ({ track }) => !usedArtists.has(normalizedText(track.artist)),
       ) ?? values[0];
     const { track, peak, signal } = selected;
+    const peakPlays = track.years.get(year);
     usedArtists.add(normalizedText(track.artist));
     const evidenceId = aggregateEvidenceId(
       subjectId,
@@ -2148,7 +2279,7 @@ function timeCapsuleTracks(
         evidenceId,
         dimension: "listening.time_capsule_representative",
         value: `${track.title} - ${track.artist}`,
-        basis: `${year} is this song's biggest year in your history: ${plural(peak.play_count, "play")} (${peak.engaged_play_count} not skipped), ${peak.listening_minutes} minutes in all. Songs you asked me to keep out are never picked.${signalNote(signal.value)}`,
+        basis: `${year} is this song's biggest year in your history: ${plural(peak.play_count, "play")}${unskippedNote(peakPlays)}${listeningTime(peakPlays)}. Songs you asked me to keep out are never picked.${signalNote(signal.value)}`,
         name: "listening-time-capsule",
         confidence: confidenceForCount(peak.engaged_play_count, 0.55, 0.88),
         limitation:
@@ -2164,10 +2295,10 @@ function timeCapsuleTracks(
       capsule_year: year,
       year_play_count: peak.play_count,
       year_engaged_play_count: peak.engaged_play_count,
-      year_listening_minutes: peak.listening_minutes,
-      year_explicit_skips: peak.explicit_skips,
+      ...recordedMinutes(peakPlays, "year_listening_minutes"),
+      ...recordedSkips(peakPlays, "year_explicit_skips"),
       lifetime_play_count: track.playCount,
-      lifetime_listening_minutes: minutes(track.playedMs),
+      ...recordedMinutes(track, "lifetime_listening_minutes"),
       representative_signal: signal.value,
       evidence_id: evidenceId,
     };
@@ -2324,6 +2455,7 @@ export function projectListeningProfile({
           if (system.startsWith("spotify")) return "spotify";
           if (system.startsWith("listenbrainz")) return "listenbrainz";
           if (system === "youtube_music") return "youtube_music";
+          if (system === "lastfm") return "lastfm";
           return "other";
         })
         .filter(Boolean),
@@ -2337,6 +2469,9 @@ export function projectListeningProfile({
     .filter(Boolean)
     .sort()
     .at(-1) ?? null;
+  const lengthNote = events.recorded.time === "all"
+    ? ""
+    : " if every play has a recorded length";
   return {
     summary: {
       schema_version: LISTENING_PROFILE_SCHEMA_VERSION,
@@ -2350,7 +2485,9 @@ export function projectListeningProfile({
         cross_format_linked_events: crossFormatLinkedRows.length,
         cross_format_ambiguous_tracks: crossFormatAmbiguousTracks,
         cross_format_ambiguous_events: crossFormatAmbiguousRows.length,
-        listening_hours: hours(events.profiledPlayedMs),
+        ...(events.recorded.time === "none"
+          ? {}
+          : { listening_hours: hours(events.profiledPlayedMs) }),
         earliest_played_at: events.earliest,
         latest_played_at: events.latest,
         profile_evidence_records: deduplicatedEvidence.length,
@@ -2432,7 +2569,9 @@ export function projectListeningProfile({
       },
       curated_preferences: {
         saved_tracks: slice(evidence.savedTracks, maxItems),
-        playlist_anchors: slice(evidence.playlistAnchors, maxItems),
+        playlist_anchors: slice(evidence.playlistAnchors, maxItems).map((item) => ({
+          ...item, playlist_names: item.playlist_names.slice(0, 3),
+        })),
         followed_artists: slice(evidence.followedArtists, maxItems),
         saved_albums: slice(evidence.savedAlbums, maxItems),
         avoids: slice(combinedAvoids(direct.avoids, evidence.avoids), maxItems),
@@ -2490,8 +2629,8 @@ export function projectListeningProfile({
             ]
           : []),
         "A song counts as new the first time it shows up in your history, which is not always when you found it.",
-        "Songs worth another listen need at least 3 plays, 2 of them not skipped, 10 minutes in all, and nothing in the last 90 days. They are nudges to listen again, not claims that you love them.",
-        "Songs that came back need at least 3 plays, none skipped, 10 minutes in all, and one gap of at least 180 days. That is a pattern, not proof you missed them or left them on purpose.",
+        `Songs worth another listen need at least 3 plays, 2 of them not skipped, 10 minutes in all${lengthNote}, and nothing in the last 90 days. They are nudges to listen again, not claims that you love them.`,
+        `Songs that came back need at least 3 plays, none skipped, 10 minutes in all${lengthNote}, and one gap of at least 180 days. That is a pattern, not proof you missed them or left them on purpose.`,
         "The Time Machine needs at least two years with enough listening and picks at most one song per year. A pick does not mean the song defined that year, or that you still love it.",
         "An artist counts as staying with you after at least two years in your history, including the latest. How much your top artists change year to year says nothing about whether your taste really changed.",
         "A record counts as one you went deep on after at least three of its tracks. That does not mean you played the whole album, in order, or that you own or like it.",
@@ -2514,6 +2653,33 @@ export function projectListeningProfile({
       ],
     },
     explanations,
+    // Host-only complete evidence catalogs. Bound pages after selecting a section.
+    catalog: {
+      history_artists: events.lifetime.rankedArtists,
+      history_tracks: events.lifetime.rankedTracks,
+      recent_artists: events.recent.rankedArtists,
+      recent_tracks: events.recent.rankedTracks,
+      history_years: events.historyArc,
+      history_releases: releases,
+      saved_tracks: evidence.savedTracks,
+      playlist_tracks: evidence.playlistAnchors,
+      saved_albums: evidence.savedAlbums,
+      followed_artists: evidence.followedArtists,
+      provider_genres: evidence.genres,
+      listener_preferences: direct.preferences,
+      listener_avoids: combinedAvoids(direct.avoids, evidence.avoids),
+      provider_evidence: deduplicatedEvidence.map((record) => ({
+        evidence_id: record.profile_evidence_id,
+        evidence_kind: record.evidence_kind,
+        entity_type: record.entity.entity_type,
+        label: record.entity.label ?? "Unresolved provider label",
+        ...(record.entity.artist_credit ? { artist_credit: record.entity.artist_credit } : {}),
+        source_label: musicProviderLabel(record.provenance.source_system),
+        observed_at: record.observed_at,
+        ...Object.fromEntries(["rank", "period", "text", "playlist_name", "playlist_position", "value", "unit", "stream_count", "played_seconds"]
+          .filter((key) => record.attributes[key] !== undefined).map((key) => [key, record.attributes[key]])),
+      })),
+    },
     // Host-only consumers need every exclusion, not the bounded display sample.
     lyricExclusions: combinedAvoids(direct.avoids, evidence.avoids),
   };