Fix For You feed: drop self-recs and space out same-author posts

Two ranking bugs reported by users, both in the shared finalize()
back-half of the ranker:

- Own posts appeared in the feed. In pure CF a taste-neighbor liking
  your post makes it a candidate, so you got recommended back to
  yourself. Thread the viewer DID into finalize() and drop posts whose
  author is the viewer. Applied across all three rankers (graph, CF,
  and cold-start popularity, which a seedless signed-in viewer also
  hits).

- 2-3 posts by the same author in a row. perAuthorCap limited an
  author's total count but output was strictly score-sorted, so their
  posts clustered. Replace the cap-only loop with spaced round-robin:
  per-author buckets emitted highest-score-first, skipping any author
  seen within the last FEEDGEN_AUTHOR_MIN_GAP slots. Best-effort — the
  gap relaxes when only one author is left, so no content is dropped.

New knob FEEDGEN_AUTHOR_MIN_GAP (default 3), no code change needed to
tune. No API change; defaults live in code.

Author: seboslaw

.env.example

@@ -92,4 +92,5 @@ FEEDGEN_RANKER="graph"
 # FEEDGEN_MAX_FEED_SIZE=1000             # cached ranked-list length
 # FEEDGEN_INCLUDE_REPLIES=false          # true to include replies
 # FEEDGEN_PER_AUTHOR_CAP=3               # diversification: max posts per author
+# FEEDGEN_AUTHOR_MIN_GAP=3               # diversification: min slots between an author's posts (0 = off)
 # FEEDGEN_CACHE_TTL_SECONDS=600          # per-viewer ranked-list cache TTL

src/config.ts

@@ -124,6 +124,10 @@ export type RankingConfig = {
   includeReplies: boolean
   // diversification: max posts from a single author in the final list
   perAuthorCap: number
+  // diversification: minimum number of slots between two posts by the same
+  // author, so an author's capped posts are spread out instead of clustered.
+  // Best-effort — relaxed when no other author is available (0 = off).
+  authorMinGap: number
   // TTL of the cached per-viewer ranked list, in seconds
   cacheTtlSeconds: number
   // On a viewer's first request, how many of their most-recent likes to import

src/index.ts

@@ -49,6 +49,7 @@ const run = async () => {
     maxFeedSize: maybeInt(process.env.FEEDGEN_MAX_FEED_SIZE) ?? 1000,
     includeReplies: process.env.FEEDGEN_INCLUDE_REPLIES === 'true',
     perAuthorCap: maybeInt(process.env.FEEDGEN_PER_AUTHOR_CAP) ?? 3,
+    authorMinGap: maybeInt(process.env.FEEDGEN_AUTHOR_MIN_GAP) ?? 3,
     cacheTtlSeconds: maybeInt(process.env.FEEDGEN_CACHE_TTL_SECONDS) ?? 600,
     inlineBackfillLimit:
       maybeInt(process.env.FEEDGEN_INLINE_BACKFILL_LIMIT) ?? 100,

src/ranker/collaborative.ts

@@ -124,6 +124,10 @@ export class CollaborativeFilterRanker implements Ranker {
     }
     if (rawScores.size === 0) return []
 
-    return finalize(ctx, rawScores, { applyPopularityPenalty: true, content })
+    return finalize(ctx, rawScores, {
+      applyPopularityPenalty: true,
+      content,
+      viewerDid,
+    })
   }
 }

src/ranker/finalize.ts

@@ -13,6 +13,10 @@ export type FinalizeOptions = {
   // least one with the allowlist — undeclared posts always pass, so the feed
   // biases toward these languages without starving. Empty/undefined = off.
   languages?: string[]
+  // the requesting viewer's DID. Their own authored posts are dropped so the
+  // feed never recommends you back to yourself (a taste-neighbor liking your
+  // post makes it a candidate). null/undefined for anonymous viewers.
+  viewerDid?: string | null
 }
 
 // Shared back half of every ranker: hydrate candidate metadata, apply
@@ -36,6 +40,7 @@ export const finalize = async (
   for (const [uri, raw] of rawScores) {
     const meta = metas.get(uri)
     if (!meta) continue // unhydratable (deleted/blocked) — drop
+    if (opts.viewerDid && meta.author_did === opts.viewerDid) continue // no self-recs
     if (meta.is_adult) continue
     if (meta.is_reply && !cfg.includeReplies) continue // top-level posts only
     if (opts.content === 'image' && !meta.is_image) continue
@@ -62,15 +67,48 @@ export const finalize = async (
 
   scored.sort((a, b) => b.score - a.score)
 
-  // Diversification: cap how many posts a single author can contribute.
-  const perAuthor = new Map<string, number>()
-  const out: string[] = []
+  // Diversification: cap each author's total contribution AND space their posts
+  // apart so the feed never shows a run of the same author. Bucket per author in
+  // descending score order (scored is already sorted, so appending preserves
+  // it), capped at perAuthorCap.
+  const buckets = new Map<string, { uri: string; score: number }[]>()
   for (const item of scored) {
-    const count = perAuthor.get(item.author) ?? 0
-    if (count >= cfg.perAuthorCap) continue
-    perAuthor.set(item.author, count + 1)
-    out.push(item.uri)
-    if (out.length >= cfg.maxFeedSize) break
+    let bucket = buckets.get(item.author)
+    if (!bucket) {
+      bucket = []
+      buckets.set(item.author, bucket)
+    }
+    if (bucket.length < cfg.perAuthorCap) bucket.push(item)
+  }
+
+  // Emit by repeatedly taking the highest-scoring available post whose author
+  // hasn't appeared within the last `authorMinGap` slots. If every remaining
+  // author is inside that window (e.g. only one author is left), relax the gap
+  // and take the best available anyway — spacing is best-effort and never a
+  // reason to drop otherwise-eligible content.
+  const heads = [...buckets.entries()].map(([author, items]) => ({
+    author,
+    items,
+    ptr: 0,
+  }))
+  const lastSlot = new Map<string, number>() // author → slot of their last post
+  const out: string[] = []
+  while (out.length < cfg.maxFeedSize) {
+    let best: (typeof heads)[number] | null = null
+    let fallback: (typeof heads)[number] | null = null
+    for (const h of heads) {
+      if (h.ptr >= h.items.length) continue
+      const score = h.items[h.ptr].score
+      if (!fallback || score > fallback.items[fallback.ptr].score) fallback = h
+      const last = lastSlot.get(h.author)
+      if (last !== undefined && out.length - last <= cfg.authorMinGap) continue
+      if (!best || score > best.items[best.ptr].score) best = h
+    }
+    const chosen = best ?? fallback
+    if (!chosen) break // all buckets drained
+    out.push(chosen.items[chosen.ptr].uri)
+    chosen.ptr++
+    lastSlot.set(chosen.author, out.length - 1)
   }
 
   return out

src/ranker/graph.ts

@@ -61,6 +61,6 @@ export class GraphRanker implements Ranker {
 
     return raw.size === 0
       ? []
-      : finalize(ctx, raw, { applyPopularityPenalty: true, content })
+      : finalize(ctx, raw, { applyPopularityPenalty: true, content, viewerDid })
   }
 }

src/ranker/popularity.ts

@@ -10,7 +10,7 @@ import { finalize } from './finalize'
 export class PopularityRanker implements Ranker {
   async rank(
     ctx: AppContext,
-    _viewerDid: string | null,
+    viewerDid: string | null,
     content: ContentFilter,
     languages: string[] = [],
   ): Promise<string[]> {
@@ -42,6 +42,7 @@ export class PopularityRanker implements Ranker {
       applyPopularityPenalty: false,
       content,
       languages,
+      viewerDid,
     })
   }
 }