fix(snooze): early-kill pure-pumper sources at >=80% ad_rate / >=10 sample [FFM-847] (#221)

Standard 30%/30-sample gate (#214) misses sources that pump ~100% ads at
low volume — they take 1-7 days to self-snooze on accumulation. Cohort
sources 148/149/155/156 (FFM-847) are mid-band stuck for this reason.

Adds criterion 3a as additive sub-gate: ad_rate >= 80% with >=10 processed
memes -> snooze with reason 'extreme_ad_rate' (distinct from 'high_ad_rate'
for monitoring attribution). Standard 3b gate stays intact.

Sample-size floor of 10 protects against noise; the 80% threshold is well
above any noise band, so the existing 30-meme floor is unnecessary for
extreme cases.

Per CEO greenlight on FFM-847 comment 097e1f25.

Author: ohld

src/storage/service.py

@@ -69,7 +69,9 @@ async def maybe_auto_snooze_source(
     Snoozes the source if any criterion is met:
       1. 3 consecutive parse attempts returned 0 posts.
       2. like_rate < 10% with at least 100 total reactions.
-      3. ad_rate > 30% over rolling 7d window with >= 30 processed memes.
+      3a. ad_rate >= 80% over rolling 7d window with >= 10 processed memes
+          (early-kill for extreme pumpers).
+      3b. ad_rate > 30% over rolling 7d window with >= 30 processed memes.
     Returns the snooze reason string if snoozed, None otherwise.
     """
     source = await fetch_one(select(meme_source).where(meme_source.c.id == meme_source_id))
@@ -140,9 +142,24 @@ async def maybe_auto_snooze_source(
         ),
         {"sid": meme_source_id},
     )
-    if ad_stats and ad_stats["n_processed"] >= 30:
+    if ad_stats and ad_stats["n_processed"] >= 10:
         ad_rate = ad_stats["n_ads"] / ad_stats["n_processed"]
-        if ad_rate > 0.30:
+        # Criterion 3a: pure-pumper early-kill. A 100%-ad source has no legitimate
+        # signal regardless of volume; the 30-meme floor only protects against
+        # noise, which doesn't apply at >=80% ad_rate.
+        if ad_rate >= 0.80:
+            await update_meme_source(
+                meme_source_id,
+                status=MemeSourceStatus.SNOOZED.value,
+                data={
+                    **updated_data,
+                    "snoozed_reason": "extreme_ad_rate",
+                    "snoozed_at": now_iso,
+                },
+            )
+            return "extreme_ad_rate"
+        # Criterion 3b: standard high-ad-rate gate.
+        if ad_stats["n_processed"] >= 30 and ad_rate > 0.30:
             await update_meme_source(
                 meme_source_id,
                 status=MemeSourceStatus.SNOOZED.value,

tests/test_auto_snooze.py

@@ -286,3 +286,68 @@ async def test_failed_pipeline_memes_excluded_from_denominator(conn: AsyncConnec
     result = await maybe_auto_snooze_source(SOURCE_ID, new_posts_count=5)
 
     assert result == "high_ad_rate"
+
+
+# Criterion 3a: extreme_ad_rate early-kill (FFM-847 follow-up).
+# Pure-pumper sources that post few but ~100% ad memes never reach the 30-meme
+# sample threshold on volume alone. Catch them at >=80% ad_rate with >=10 processed.
+
+
+@pytest.mark.asyncio
+async def test_snooze_on_extreme_ad_rate_below_standard_sample(conn: AsyncConnection):
+    """100% ad_rate with 12 processed memes (below the 30-meme standard threshold)
+    must early-kill via 'extreme_ad_rate'."""
+    await create_meme_source(conn, id=SOURCE_ID, status="parsing_enabled")
+    await _seed_memes(conn, source_id=SOURCE_ID, n_ad=12, n_ok=0)
+    await conn.commit()
+
+    result = await maybe_auto_snooze_source(SOURCE_ID, new_posts_count=5)
+
+    assert result == "extreme_ad_rate"
+    source = await fetch_one(meme_source.select().where(meme_source.c.id == SOURCE_ID))
+    assert source["status"] == MemeSourceStatus.SNOOZED.value
+    assert source["data"]["snoozed_reason"] == "extreme_ad_rate"
+
+
+@pytest.mark.asyncio
+async def test_snooze_on_extreme_ad_rate_at_80_pct_boundary(conn: AsyncConnection):
+    """Threshold is `>= 0.80`. Exactly 80% (8 ad / 10 processed) must snooze."""
+    await create_meme_source(conn, id=SOURCE_ID, status="parsing_enabled")
+    await _seed_memes(conn, source_id=SOURCE_ID, n_ad=8, n_ok=2)
+    await conn.commit()
+
+    result = await maybe_auto_snooze_source(SOURCE_ID, new_posts_count=5)
+
+    assert result == "extreme_ad_rate"
+
+
+@pytest.mark.asyncio
+async def test_no_snooze_on_extreme_ad_rate_below_min_sample(conn: AsyncConnection):
+    """9 processed memes (9 ad = 100% ad_rate) is below the 10-meme minimum sample
+    for the early-kill. Don't snooze — wait for one more meme."""
+    await create_meme_source(conn, id=SOURCE_ID, status="parsing_enabled")
+    await _seed_memes(conn, source_id=SOURCE_ID, n_ad=9, n_ok=0)
+    await conn.commit()
+
+    result = await maybe_auto_snooze_source(SOURCE_ID, new_posts_count=5)
+
+    assert result is None
+    source = await fetch_one(meme_source.select().where(meme_source.c.id == SOURCE_ID))
+    assert source["status"] == MemeSourceStatus.PARSING_ENABLED.value
+
+
+@pytest.mark.asyncio
+async def test_no_snooze_just_below_extreme_threshold(conn: AsyncConnection):
+    """79% ad_rate (mid-band: too high to be healthy, too low for early-kill, sample
+    too small for standard gate) must NOT snooze. Wait for the standard gate to
+    kick in once n_processed >= 30."""
+    await create_meme_source(conn, id=SOURCE_ID, status="parsing_enabled")
+    # 11 ad + 3 ok = 14 processed, ad_rate ≈ 78.6% — under 80%, under 30 sample
+    await _seed_memes(conn, source_id=SOURCE_ID, n_ad=11, n_ok=3)
+    await conn.commit()
+
+    result = await maybe_auto_snooze_source(SOURCE_ID, new_posts_count=5)
+
+    assert result is None
+    source = await fetch_one(meme_source.select().where(meme_source.c.id == SOURCE_ID))
+    assert source["status"] == MemeSourceStatus.PARSING_ENABLED.value