bring in more recency while widening the time window a little at the same time

Author: seboslaw

.env.example

@@ -68,6 +68,7 @@ FEEDGEN_RANKER="graph"
 # FEEDGEN_CANDIDATE_WINDOW_HOURS=24      # a candidate's like must be this recent
 # FEEDGEN_FRESHNESS_HOURS=24             # drop posts created older than this
 # FEEDGEN_HALF_LIFE_HOURS=6              # post-age time-decay half-life
+# FEEDGEN_CANDIDATE_RECENCY_HALFLIFE_HOURS=12  # like-recency half-life at candidate selection (0=off)
 # FEEDGEN_SMOOTHING=0.5                  # path-count exponent (boosts multi-path posts)
 # FEEDGEN_POPULARITY_PENALTY=0.3         # score /= likeCount^penalty
 # FEEDGEN_CURATOR_BRANCHING_POWER=1      # normalization (0 = off)

src/algos/for-you.ts

@@ -8,7 +8,13 @@ import {
   ensureViewerBackfilled,
   backfillSeedColikers,
 } from '../ranker/backfill'
-import { cacheRankedList, getRankedList, rankedListKey, getSeen } from '../redis'
+import {
+  cacheRankedList,
+  recacheRankedList,
+  getRankedList,
+  rankedListKey,
+  getSeen,
+} from '../redis'
 
 const cfRanker: Ranker = new CollaborativeFilterRanker()
 const graphRanker: Ranker = new GraphRanker()
@@ -28,6 +34,7 @@ export const handler = async (
   feed: FeedDef,
 ) => {
   const cacheKey = rankedListKey(feed.rkey, viewerDid)
+  const offset = parseCursor(params.cursor)
 
   let ranked = await getRankedList(ctx.redis, cacheKey)
   if (!ranked) {
@@ -47,9 +54,15 @@ export const handler = async (
     // (never blocks the skeleton response). On completion it invalidates this
     // viewer's cached lists so the next load reflects the denser graph.
     if (viewerDid) void backfillSeedColikers(ctx, viewerDid)
+  } else if (offset === 0 && viewerDid) {
+    // A no-cursor request is a refresh: re-demote posts seen since this snapshot
+    // was built so the reload surfaces the next unseen posts. Cheap — reuses the
+    // cached set and preserves the TTL, so the periodic recompute still brings in
+    // genuinely-new graph content on schedule.
+    ranked = await orderBySeen(ctx, viewerDid, ranked)
+    await recacheRankedList(ctx.redis, cacheKey, ranked)
   }
 
-  const offset = parseCursor(params.cursor)
   const slice = ranked.slice(offset, offset + params.limit)
   const nextOffset = offset + slice.length
   const cursor = nextOffset < ranked.length ? String(nextOffset) : undefined

src/config.ts

@@ -92,6 +92,11 @@ export type RankingConfig = {
   freshnessHours: number
   // exponential time-decay half-life on post age, in hours
   halfLifeHours: number
+  // exponential decay half-life on a candidate's most-recent co-liker like, in
+  // hours — applied at candidate SELECTION so fresh, lightly-corroborated posts
+  // compete for the top-N instead of being cut before the post-age decay runs.
+  // 0 = off (pure corroboration ordering).
+  candidateRecencyHalfLifeHours: number
   // path-count exponent — boosts posts reached via many independent paths
   smoothing: number
   // popularity penalty exponent: score divided by likeCount^penalty

src/graph/csr-like-graph.ts

@@ -314,11 +314,16 @@ export class CsrLikeGraph implements ILikeGraph {
     )
     const scoreAcc = new Map<number, number>()
     const raters = new Map<number, number>()
+    // most-recent co-liker-like time (tsMin) per candidate — drives the recency
+    // weight applied at selection so fresh posts survive the top-N cut.
+    const lastTs = new Map<number, number>()
     const cand: number[] = []
     const candRn: number[] = []
+    const candTs: number[] = []
     for (const [c, wc] of curators) {
       cand.length = 0
       candRn.length = 0
+      candTs.length = 0
       const seenPosts = new Set<number>()
       let rn = 0
       let stop = false
@@ -340,6 +345,7 @@ export class CsrLikeGraph implements ILikeGraph {
           seenPosts.add(post)
           cand.push(post)
           candRn.push(++rn)
+          candTs.push(ts)
           if (++visits > budget) {
             stop = true
             break
@@ -361,6 +367,7 @@ export class CsrLikeGraph implements ILikeGraph {
           seenPosts.add(post)
           cand.push(post)
           candRn.push(++rn)
+          candTs.push(ts)
           if (++visits > budget) break
         }
       }
@@ -375,15 +382,27 @@ export class CsrLikeGraph implements ILikeGraph {
           r.coraterDecay > 0 ? Math.pow(1 - r.coraterDecay, candRn[t] - 1) : 1
         scoreAcc.set(post, (scoreAcc.get(post) ?? 0) + norm * factor)
         raters.set(post, (raters.get(post) ?? 0) + 1)
+        const prev = lastTs.get(post)
+        if (prev === undefined || candTs[t] > prev) lastTs.set(post, candTs[t])
       }
       if (visits > budget) break
     }
 
-    // 5. eligibility + num_paths^smoothing, top maxCandidates
+    // 5. eligibility + num_paths^smoothing, weighted by co-liker-like recency so
+    // fresh (recently-liked) posts survive the top-maxCandidates cut instead of
+    // being dropped before finalize's post-age decay can rank them.
+    const recencyOn = r.candidateRecencyHalfLifeHours > 0
+    const nowMin = toTsMin(Date.now())
+    const halfLifeMin = r.candidateRecencyHalfLifeHours * 60
     const scored: { post: number; raw: number }[] = []
     for (const [post, acc] of scoreAcc) {
       if ((raters.get(post) ?? 0) < r.minEligibleRaters) continue
-      scored.push({ post, raw: Math.pow(acc, r.smoothing) })
+      let raw = Math.pow(acc, r.smoothing)
+      if (recencyOn) {
+        const ageMin = Math.max(0, nowMin - (lastTs.get(post) ?? nowMin))
+        raw *= Math.pow(0.5, ageMin / halfLifeMin)
+      }
+      scored.push({ post, raw })
     }
     scored.sort((a, b) => b.raw - a.raw)
     const top = scored.slice(0, candidateLimit)

src/graph/like-graph.ts

@@ -239,13 +239,18 @@ export class LikeGraph implements ILikeGraph {
     )
     const scoreAcc = new Map<number, number>()
     const raters = new Map<number, number>()
+    // most-recent co-liker-like time (tsMin) per candidate — drives the recency
+    // weight applied at selection so fresh posts survive the top-N cut.
+    const lastTs = new Map<number, number>()
     const cand: number[] = [] // postInt
     const candRn: number[] = [] // 1-based recency rank
+    const candTs: number[] = [] // tsMin of the co-liker like
     for (const [c, wc] of curators) {
       const arr = this.fwd[c]
       if (!arr) continue
       cand.length = 0
       candRn.length = 0
+      candTs.length = 0
       const seenPosts = new Set<number>()
       let rn = 0
       // walk recent-first (from the end); arr = [postInt, tsMin, …]
@@ -262,6 +267,7 @@ export class LikeGraph implements ILikeGraph {
         rn++
         cand.push(post)
         candRn.push(rn)
+        candTs.push(ts)
         if (++visits > budget) break
       }
       const deg = cand.length
@@ -274,15 +280,27 @@ export class LikeGraph implements ILikeGraph {
           r.coraterDecay > 0 ? Math.pow(1 - r.coraterDecay, candRn[t] - 1) : 1
         scoreAcc.set(post, (scoreAcc.get(post) ?? 0) + norm * factor)
         raters.set(post, (raters.get(post) ?? 0) + 1)
+        const prev = lastTs.get(post)
+        if (prev === undefined || candTs[t] > prev) lastTs.set(post, candTs[t])
       }
       if (visits > budget) break
     }
 
-    // 5. eligibility + num_paths^smoothing, take top maxCandidates
+    // 5. eligibility + num_paths^smoothing, weighted by co-liker-like recency so
+    // fresh (recently-liked) posts survive the top-maxCandidates cut instead of
+    // being dropped before finalize's post-age decay can rank them.
+    const recencyOn = r.candidateRecencyHalfLifeHours > 0
+    const nowMin = toTsMin(Date.now())
+    const halfLifeMin = r.candidateRecencyHalfLifeHours * 60
     const scored: { post: number; raw: number }[] = []
     for (const [post, acc] of scoreAcc) {
       if ((raters.get(post) ?? 0) < r.minEligibleRaters) continue
-      scored.push({ post, raw: Math.pow(acc, r.smoothing) })
+      let raw = Math.pow(acc, r.smoothing)
+      if (recencyOn) {
+        const ageMin = Math.max(0, nowMin - (lastTs.get(post) ?? nowMin))
+        raw *= Math.pow(0.5, ageMin / halfLifeMin)
+      }
+      scored.push({ post, raw })
     }
     scored.sort((a, b) => b.raw - a.raw)
     const top = scored.slice(0, candidateLimit)

src/index.ts

@@ -30,6 +30,8 @@ const run = async () => {
       maybeInt(process.env.FEEDGEN_CANDIDATE_WINDOW_HOURS) ?? 24,
     freshnessHours: maybeInt(process.env.FEEDGEN_FRESHNESS_HOURS) ?? 24,
     halfLifeHours: maybeInt(process.env.FEEDGEN_HALF_LIFE_HOURS) ?? 6,
+    candidateRecencyHalfLifeHours:
+      maybeFloat(process.env.FEEDGEN_CANDIDATE_RECENCY_HALFLIFE_HOURS) ?? 12,
     smoothing: maybeFloat(process.env.FEEDGEN_SMOOTHING) ?? 0.5,
     popularityPenalty:
       maybeFloat(process.env.FEEDGEN_POPULARITY_PENALTY) ?? 0.3,

src/redis.ts

@@ -24,6 +24,21 @@ export const cacheRankedList = async (
   }
 }
 
+// Overwrite an existing ranked list while preserving its TTL (SET … KEEPTTL).
+// Used to persist a re-ranked snapshot on refresh without postponing the
+// periodic recompute that the original expiry triggers.
+export const recacheRankedList = async (
+  redis: Redis,
+  key: string,
+  uris: string[],
+): Promise<void> => {
+  try {
+    await redis.set(key, JSON.stringify(uris), 'KEEPTTL')
+  } catch (err) {
+    console.error('redis recache write failed', err)
+  }
+}
+
 export const getRankedList = async (
   redis: Redis,
   key: string,