Session B (night2): streaks/hot-list engine — producer + form heat + THE LENS

RESURRECT verdict: the Session-23 engine existed, was pure, tested, and
mounted — it starved because every producer was external and unarmed
(tank01-prefetch via n8n, offline Python flow). The snapshot pipeline is
now the producer: each run merges slate players' real game logs (already
fetched for archetypes — zero extra calls) into rosterlogs:{sport}.

- computeFormHeat: hot hitters (7d AVG), hot sluggers (SLG), hot shooters
  (FG%) — correct sum/sum rate math, season baseline else prior stretch,
  min-sample refusals, never extrapolated.
- streakLens: no raw streak renders alone — built-vs opponents, tonight's
  matchup + opposing SP w/ ERA, step-up/step-down difficulty, one-line
  read. Absent context = say less, never invent.
- /api/streaks/:sport: heat merged into the feed, lens applied from cached
  schedule + pitchers (time-bounded, can never hang the route), snapshot
  grade letters joined.
- ACCEPTANCE (live statsapi, real 2026 logs): 32 rows found — Turang
  12-gm on-base, Reynolds 8-gm on-base, Pratt 7-gm on-base + 3-gm
  multi-hit, Meidroth 5-gm on-base, Cortes 5-gm on-base.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/services/snapshotService.js

@@ -169,6 +169,28 @@ async function pushTickerItems(events, deps) {
   await deps.cacheSet('ticker:items', merged, TICKER_TTL);
 }
 
+// Session 60 (night2/B) — accumulate slate players' game logs into the
+// roster blob the streaks/hot-list engines read. Merge by nameKey (newer
+// entry wins), cap the blob, 72h TTL (a player off the slate for 3 days
+// ages out — honest churn, not a leak).
+const ROSTERLOGS_TTL = 72 * 3600;
+const ROSTERLOGS_CAP = 300;
+
+async function mergeRosterLogs(sport, entries, deps) {
+  if (!entries || entries.length === 0) return;
+  try {
+    const key = `rosterlogs:${sport}`;
+    const existing = await deps.cacheGet(key);
+    const byKey = new Map();
+    for (const e of Array.isArray(existing) ? existing : []) byKey.set(nameKey(e.name), e);
+    for (const e of entries) byKey.set(nameKey(e.name), e); // fresh resolve wins
+    const merged = [...byKey.values()].slice(-ROSTERLOGS_CAP);
+    await deps.cacheSet(key, merged, ROSTERLOGS_TTL);
+  } catch (e) {
+    console.warn(`[snapshot] rosterlogs merge failed for ${sport}:`, e.message);
+  }
+}
+
 const ACTIVE_SPORTS = ['mlb', 'nba', 'wnba', 'soccer'];
 
 /**
@@ -271,6 +293,14 @@ async function runSnapshot(sport, opts = {}) {
   // (statsapi/ESPN), never guessed. Feeds the ledger team/opponent columns
   // and the slate join guard (a prop only attaches to its own game).
   const teamByPlayer = {};
+  // Session 60 (night2/B) — THE STREAKS PRODUCER. The aggregator (streaks +
+  // hot lists) starved because its data producers were all external and
+  // unarmed (tank01-prefetch via n8n, the offline Python grading flow).
+  // The stats resolve above already fetched each slate player's game log —
+  // accumulate it into the `rosterlogs:{sport}` blob rosterLogs.loadRosterLogs
+  // reads FIRST. Zero extra API calls; the pipeline now feeds its own
+  // free layer.
+  const logEntries = [];
   await mapLimit(players, STATS_CONCURRENCY, async (player) => {
     try {
       const stats = await deps.resolveStats(player, sp);
@@ -278,9 +308,20 @@ async function runSnapshot(sport, opts = {}) {
         const c = deps.classify(sp, stats.classifierInput || {});
         archByPlayer[player] = c.primary ? c.primary.name : null;
         if (stats.team) teamByPlayer[player] = stats.team;
+        if (Array.isArray(stats.rawLog) && stats.rawLog.length > 0) {
+          logEntries.push({
+            name: normalizeName(player).display || player,
+            playerId: stats.playerId ?? null,
+            team: stats.team || null,
+            group: stats.group || null,
+            seasonRaw: stats.seasonRaw || null,
+            games: stats.rawLog,
+          });
+        }
       }
     } catch { /* graceful — no badge */ }
   });
+  await mergeRosterLogs(sp, logEntries, deps);
 
   const enriched = graded.map((g) => ({
     ...g,