@audiofool/moondog 0.1.0 → 0.2.0-beta.3

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

@@ -1,5 +1,7 @@
+import { createAvoidGate } from "../core/listener-avoids.mjs";
 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 =
@@ -25,6 +27,27 @@ const extendedSequenceMinimumPlays = 5;
 const backToBackMinimumConsecutivePlays = 2;
 const backToBackMinimumPlayedMs = 30_000;
 const backToBackMaximumGapMinutes = 30;
+// Movement compares an artist's share of each year's plays, so a year with
+// less listening overall, or fewer records, does not read as fading. Play
+// counts are the measure because every dated play records one.
+const movementMinimumPlays = 20;
+const movementMinimumYears = 3;
+// A year counts only when the history holds this many plays in it.
+const movementMinimumYearPlays = 50;
+// The latest year is read only when the artist has, or at its earlier share
+// would have, this many plays in it, so a few plays more or less, such as in a
+// barely started partial year, cannot swing a label.
+const movementMinimumLatestPlays = 10;
+const movementSeriesYears = 12;
+const movementViewLimit = 5;
+const returningMinimumGapYears = 2;
+const returningMinimumPlays = 3;
+const burstMinimumPeakShare = 0.7;
+// A burst drops off at once: the next counted year holds under a tenth of the
+// peak year's share. A decline that tapers is fading.
+const burstMaximumAfterRatio = 0.1;
+const fadingMaximumRatio = 0.5;
+const risingMinimumRatio = 2;
 const monthlyActivityMaximumMonths = 240;
 const listeningSeasonMaximumSeasons = 80;
 const spotifyExtendedHistorySystem = "spotify-extended-history";
@@ -86,6 +109,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}`,
@@ -142,6 +219,10 @@ function trackFields(track) {
       track?.identity_status === "resolved" ? "resolved" : "provisional",
     title,
     artist,
+    // Every credited artist, so an Avoid on a featured artist also keeps the track out.
+    artists: (Array.isArray(track?.artist_credits) ? track.artist_credits : [])
+      .map((credit) => (typeof credit?.name === "string" ? credit.name.trim() : ""))
+      .filter(Boolean),
     artistKnown: Boolean(track?.artist_credits?.[0]?.name?.trim()),
     release,
   };
@@ -164,13 +245,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 +261,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 +284,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 +293,7 @@ function aggregateHistoryArc(rows) {
               top_artist: {
                 name: topArtist.name,
                 play_count: topArtist.playCount,
-                listening_minutes: minutes(topArtist.playedMs),
+                ...recordedMinutes(topArtist),
               },
             }
           : {}),
@@ -216,6 +301,109 @@ function aggregateHistoryArc(rows) {
     });
 }
 
+// Years with plays, oldest first. Years before the most recent twelve roll
+// into one entry so a long history stays small.
+function yearlyPlays(years) {
+  const series = [...years.entries()]
+    .sort(([left], [right]) => left - right)
+    .map(([year, value]) => ({ year, plays: value.playCount }));
+  if (series.length <= movementSeriesYears) return series;
+  const earlier = series.slice(0, -movementSeriesYears);
+  return [
+    {
+      from_year: earlier[0].year,
+      to_year: earlier.at(-1).year,
+      plays: earlier.reduce((sum, item) => sum + item.plays, 0),
+    },
+    ...series.slice(-movementSeriesYears),
+  ];
+}
+
+function meanShare(items) {
+  return items.reduce((sum, item) => sum + item.share, 0) / items.length;
+}
+
+// A deterministic label for how an artist's share of yearly plays moved, from
+// its first year to the latest counted year. Checked in order: returning (at
+// least two counted years with no plays, then back in the latest two), burst
+// (one year that is not the latest holds 70% of the share and the next year
+// drops off at once), then fading or rising (the latest share is at most half,
+// or at least twice, the mean share of the years before it), else steady.
+// Fading also needs the recent window to agree: an artist played again at its
+// earlier share there is returning. Too few plays or years is unknown.
+function artistTrajectory(artist, yearTotals, referenceYear, recentTotal) {
+  const firstYear = Math.min(...artist.years.keys());
+  let counted = [...yearTotals.entries()]
+    .filter(([year, total]) => year >= firstYear && total >= movementMinimumYearPlays)
+    .sort(([left], [right]) => left - right)
+    .map(([year, total]) => {
+      const plays = artist.years.get(year)?.playCount ?? 0;
+      return { year, plays, total, share: plays / total };
+    });
+  const readable = (item, before) =>
+    Math.max(item.plays, meanShare(before) * item.total) >= movementMinimumLatestPlays;
+  if (counted.length > 1 && counted.at(-1).year === referenceYear &&
+    !readable(counted.at(-1), counted.slice(0, -1))) {
+    counted = counted.slice(0, -1);
+  }
+  const plays = counted.reduce((sum, item) => sum + item.plays, 0);
+  if (counted.length < movementMinimumYears || plays < movementMinimumPlays) {
+    return "unknown";
+  }
+  const latest = counted.at(-1);
+  const lastAbsent = counted.slice(0, -1).findLastIndex((item) => item.plays === 0);
+  if (lastAbsent >= 0 && lastAbsent >= counted.length - 3) {
+    let gapStart = lastAbsent;
+    while (gapStart > 0 && counted[gapStart - 1].plays === 0) gapStart -= 1;
+    const returnedPlays = counted
+      .slice(lastAbsent + 1)
+      .reduce((sum, item) => sum + item.plays, 0);
+    if (
+      lastAbsent - gapStart + 1 >= returningMinimumGapYears &&
+      counted.slice(0, gapStart).some((item) => item.plays > 0) &&
+      latest.plays > 0 &&
+      returnedPlays >= returningMinimumPlays
+    ) {
+      return "returning";
+    }
+  }
+  const shareSum = counted.reduce((sum, item) => sum + item.share, 0);
+  const peakIndex = counted.reduce(
+    (best, item, index) => (item.share > counted[best].share ? index : best),
+    0,
+  );
+  const peak = counted[peakIndex];
+  if (
+    peak !== latest &&
+    peak.share >= shareSum * burstMinimumPeakShare &&
+    counted[peakIndex + 1].share < peak.share * burstMaximumAfterRatio
+  ) {
+    return "burst";
+  }
+  const before = counted.slice(0, -1);
+  if (!readable(latest, before)) return "unknown";
+  const beforeShare = meanShare(before);
+  if (latest.share <= beforeShare * fadingMaximumRatio) {
+    const recentShare = recentTotal > 0 ? artist.recentPlayCount / recentTotal : 0;
+    if (
+      artist.recentPlayCount < movementMinimumLatestPlays ||
+      recentShare <= beforeShare * fadingMaximumRatio
+    ) {
+      return "fading";
+    }
+    return recentShare >= beforeShare ? "returning" : "steady";
+  }
+  if (latest.share >= beforeShare * risingMinimumRatio) return "rising";
+  return "steady";
+}
+
+// ACT-R base-level activation at the history's latest play: the log of the
+// summed play ages in days (at least one) to the power -0.5. Recent plays
+// weigh more, and an old archive is read against its own end, not today.
+function activation(sum) {
+  return Math.round(Math.log(sum) * 100) / 100;
+}
+
 function monthIndex(monthKey) {
   if (!/^\d{4}-(?:0[1-9]|1[0-2])$/u.test(monthKey)) return null;
   const year = Number(monthKey.slice(0, 4));
@@ -288,46 +476,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 +561,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 +575,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 +592,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 +607,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 +623,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),
             },
           }
         : {}),
@@ -559,6 +764,7 @@ function aggregateMonthlyActivity(subjectId, eventAnalysis, explanations) {
 
 function aggregateEvents(subjectId, eventRows, explanations) {
   const eligible = [];
+  const moondogStarted = [];
   let incognitoEventsExcluded = 0;
   let rawPlayedMs = 0;
   let eventsWithPlayedDuration = 0;
@@ -572,13 +778,24 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       incognitoEventsExcluded += 1;
       continue;
     }
+    // Moondog chose these, so they are not the listener's own attention.
+    if (row.moondog_suggestion_id) {
+      moondogStarted.push(row);
+      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(
@@ -598,6 +815,15 @@ function aggregateEvents(subjectId, eventRows, explanations) {
   const recentCutoff = latest
     ? new Date(Date.parse(latest) - recentWindowDays * dayMs).toISOString()
     : null;
+  const latestMs = latest ? Date.parse(latest) : null;
+  const referenceYear = latest ? Number(latest.slice(0, 4)) : null;
+  const yearTotals = new Map();
+  let recentTotal = 0;
+  for (const row of eligible) {
+    const year = Number(row.event.occurred_at.slice(0, 4));
+    if (Number.isInteger(year)) yearTotals.set(year, (yearTotals.get(year) ?? 0) + 1);
+    if (row.event.occurred_at >= recentCutoff) recentTotal += 1;
+  }
 
   function aggregate(rows, windowKind) {
     const artists = new Map();
@@ -613,6 +839,8 @@ function aggregateEvents(subjectId, eventRows, explanations) {
         engagedPlayCount: 0,
         skippedCount: 0,
         playedMs: 0,
+        timedPlayCount: 0,
+        skipKnownCount: 0,
         firstPlayedAt: occurredAt,
         lastPlayedAt: occurredAt,
         engagedPlayedAt: [],
@@ -620,6 +848,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 +864,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,13 +883,22 @@ function aggregateEvents(subjectId, eventRows, explanations) {
         engagedPlayCount: 0,
         skippedCount: 0,
         playedMs: 0,
+        timedPlayCount: 0,
+        skipKnownCount: 0,
         trackRefs: new Set(),
         years: new Map(),
         firstPlayedAt: occurredAt,
         lastPlayedAt: occurredAt,
+        activationSum: 0,
+        recentPlayCount: 0,
       };
       artist.playCount += 1;
+      if (occurredAt >= recentCutoff) artist.recentPlayCount += 1;
+      artist.activationSum +=
+        Math.max((latestMs - Date.parse(occurredAt)) / dayMs, 1) ** -0.5;
       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 +936,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 +946,18 @@ 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),
+          ...(windowKind === "lifetime"
+            ? {
+                first_played_at: item.firstPlayedAt,
+                yearly_plays: yearlyPlays(item.years),
+                activation: activation(item.activationSum),
+                trajectory: artistTrajectory(item, yearTotals, referenceYear, recentTotal),
+              }
+            : {}),
           last_played_at: item.lastPlayedAt,
           evidence_id: evidenceId,
         };
@@ -733,7 +984,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 +998,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 +1037,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 +1058,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,
@@ -812,15 +1070,18 @@ function aggregateEvents(subjectId, eventRows, explanations) {
       (row) => row.event.extensions?.["spotify.offline"] === true,
     ).length,
     incognito_events_excluded: incognitoEventsExcluded,
+    ...(moondogStarted.length ? { moondog_started_events_excluded: moondogStarted.length } : {}),
   };
   return {
     eligible,
+    moondogStarted,
     earliest,
     latest,
     recentCutoff,
     rawPlayedMs,
     eventsWithPlayedDuration,
     profiledPlayedMs: eligible.reduce((sum, row) => sum + row.playedMs, 0),
+    recorded,
     lifetime,
     recent,
     historyArc,
@@ -879,7 +1140,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 +1154,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 +1262,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 +1308,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 +1320,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,
@@ -1249,11 +1514,9 @@ function backToBackTracks(
     byTrack.set(metadata.trackRefId, aggregate);
   }
 
-  const avoids = combinedAvoids(direct.avoids, evidence.avoids);
+  const avoided = historyAvoidCheck(direct, evidence);
   return [...byTrack.values()]
-    .filter(
-      (item) => !avoids.some((avoid) => assertionMatchesTrack(avoid, item)),
-    )
+    .filter((item) => !avoided(item))
     .sort((left, right) => {
       if (
         right.maximumConsecutivePlays !== left.maximumConsecutivePlays
@@ -1307,7 +1570,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 +1583,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 +1625,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 +1659,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 +1735,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 +1757,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 +1773,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 +1835,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();
@@ -1783,6 +2058,13 @@ function combinedAvoids(listenerAvoids, providerAvoids) {
   return [...selected.values()];
 }
 
+// The shared Avoid check of every play path (src/core/listener-avoids.mjs), for history tracks.
+function historyAvoidCheck(direct, evidence) {
+  const gate = createAvoidGate(combinedAvoids(direct.avoids, evidence.avoids));
+  return (track) => gate.size > 0 &&
+    gate.avoidsTrack({ title: track.title, artist_credit: track.artist, artists: track.artists?.length ? track.artists : [track.artist] });
+}
+
 function assertionMatchesTrack(assertion, track) {
   if (assertion.entity_type === "artist") {
     return normalizedText(assertion.label) === normalizedText(track.artist);
@@ -1817,9 +2099,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 +2117,7 @@ function rediscoveryPeakYear(track) {
       explicit_skips: aggregate.skippedCount,
       listening_minutes: minutes(aggregate.playedMs),
       played_ms: aggregate.playedMs,
+      plays: aggregate,
     }))[0] ?? null;
 }
 
@@ -1846,8 +2130,8 @@ 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 avoided = historyAvoidCheck(direct, evidence);
+  const candidates = [...eventAnalysis.lifetime.tracks.values()]
     .map((track) => {
       const lastPlayedMs = Date.parse(track.lastPlayedAt);
       const quietDays = Math.floor((latestMs - lastPlayedMs) / dayMs);
@@ -1864,15 +2148,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)),
-    )
+        !avoided(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 +2182,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 +2200,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 +2210,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,
@@ -1959,8 +2245,8 @@ function historicalReturnTracks(
   direct,
   explanations,
 ) {
-  const avoids = combinedAvoids(direct.avoids, evidence.avoids);
-  return [...eventAnalysis.lifetime.tracks.values()]
+  const avoided = historyAvoidCheck(direct, evidence);
+  const candidates = [...eventAnalysis.lifetime.tracks.values()]
     .map((track) => ({
       track,
       returns: historicalReturnGaps(track),
@@ -1971,10 +2257,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)),
-    )
+        !avoided(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 +2277,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 +2302,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 +2321,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,
@@ -2076,15 +2364,16 @@ function timeCapsuleTracks(
   explanations,
   maximum,
 ) {
-  const avoids = combinedAvoids(direct.avoids, evidence.avoids);
+  const avoided = historyAvoidCheck(direct, evidence);
   const byYear = new Map();
   for (const track of eventAnalysis.lifetime.tracks.values()) {
-    if (avoids.some((item) => assertionMatchesTrack(item, track))) continue;
+    if (avoided(track)) continue;
     const peak = rediscoveryPeakYear(track);
     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 +2388,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 +2406,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 +2415,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 +2430,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 +2443,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,22 +2459,42 @@ 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,
     };
   });
 }
 
+// Plays Moondog started, one row per song, kept apart from the listener's own rankings.
+// Adopted means the listener later played the song again on their own.
+function moondogSuggestionTracks(rows, adoptedSuggestionIds) {
+  const tracks = new Map();
+  for (const row of rows) {
+    const metadata = trackFields(row.track);
+    const track = tracks.get(metadata.trackRefId) ?? {
+      label: metadata.title, artist_credit: metadata.artist, play_count: 0,
+      last_played_at: row.event.occurred_at, adopted: false,
+    };
+    track.play_count += 1;
+    if (row.event.occurred_at > track.last_played_at) track.last_played_at = row.event.occurred_at;
+    track.adopted ||= adoptedSuggestionIds.has(row.moondog_suggestion_id);
+    tracks.set(metadata.trackRefId, track);
+  }
+  return [...tracks.values()].sort((left, right) => right.play_count - left.play_count ||
+    descendingTimestamp(left.last_played_at, right.last_played_at) || lexicalCompare(left.label, right.label));
+}
+
 export function projectListeningProfile({
   subjectId,
   eventRows = [],
   profileEvidence = [],
   tasteEvents = [],
   maxItems = 10,
+  adoptedSuggestionIds = new Set(),
 } = {}) {
   if (typeof subjectId !== "string" || !subjectId.trim()) {
     throw new TypeError("Listening profile subject ID is required");
@@ -2324,6 +2639,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 +2653,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 +2669,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,
@@ -2387,6 +2708,14 @@ export function projectListeningProfile({
         history_arc: events.historyArc,
         monthly_activity: monthlyActivity,
         listening_seasons: listeningSeasons,
+        movement: Object.fromEntries(
+          ["fading", "returning", "rising"].map((label) => [
+            label,
+            events.lifetime.rankedArtists
+              .filter((artist) => artist.trajectory === label)
+              .slice(0, Math.min(maxItems, movementViewLimit)),
+          ]),
+        ),
         artist_relationships: slice(relationships, maxItems),
         year_transitions: slice(transitions, 12),
         release_depth: slice(releases, maxItems),
@@ -2415,6 +2744,10 @@ export function projectListeningProfile({
             timeCapsuleMinimumPlayedMs,
           ),
           relationship_minimum_years: relationshipMinimumYears,
+          movement_minimum_plays: movementMinimumPlays,
+          movement_minimum_years: movementMinimumYears,
+          movement_minimum_year_plays: movementMinimumYearPlays,
+          movement_minimum_latest_plays: movementMinimumLatestPlays,
           continuity_artist_limit: continuityArtistLimit,
           release_minimum_distinct_tracks: releaseMinimumDistinctTracks,
           session_gap_minutes: sessionGapMinutes,
@@ -2432,7 +2765,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 +2825,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.",
@@ -2510,10 +2845,43 @@ export function projectListeningProfile({
               "Taste Profile, Wrapped, and Sound Capsule are Spotify's reading of you, not something you said.",
             ]
           : []),
+        ...(events.moondogStarted.length > 0
+          ? [
+              "Songs Moondog queued or played for you are left out of the rankings. Playing one again later on your own counts as yours.",
+            ]
+          : []),
         "What you tell Moondog counts for more than what the data suggests, you can undo it any time, and it never rewrites your history.",
       ],
     },
     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),
+      ...(events.moondogStarted.length ? { moondog_suggestions: moondogSuggestionTracks(events.moondogStarted, adoptedSuggestionIds) } : {}),
+      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),
   };