fix(deferred): close backend correctness/efficiency tails from the hygiene sweep

Verified each deferred per-subsystem item against current source, then fixed the
real ones (tradeoffs left as-is, see siftlode-ops/CODE-HYGIENE.md closeout):

- search BUG-3: don't finalise shorts_probed on un-enriched stubs (enrichment
  failure/omitted rows) — restores the scheduler's enriched_at guard so a real
  Short can't leak into the feed and never get reclassified.
- downloads GC: 4th pass reaps orphaned errored, fileless, unreferenced assets
  (they carry no TTL, so the expiry passes never cleared them).
- downloads B6: quota/edit errors now return a structured {code,reason,limit}
  the trilingual client localises, instead of hardcoded English + dot-decimal GB.
- channels BB1: reset-backfill re-arms deep sync on every subscriber (bulk update)
  instead of 404ing when the admin isn't personally subscribed.
- channels BB2: enrich the stub on BOTH the normal and "already exists" desync
  path (nest the insert try inside the client `with`).
- channels CB3: drop the redundant second _discovery_rows read (identity-mapped
  rows are already enriched; re-sort in Python for the title tie-break).
- playlists PC1: read the live playlist once in push() and share it with plan_push
  + push_playlist (halves read-quota, closes the second TOCTOU window).
- playlists PC2/PC5: batch the cover thumbnails in one window query (was N+1);
  rename combines count+duration into one aggregate + a single cover lookup.
- messages MB2: get_thread only resolves a messageable partner OR one we already
  share a thread with (closes the user-enumeration oracle).
- messages MB3: push a live unread-count to the user's other tabs after mark-read.
- messages MC4: list_conversations uses DISTINCT ON + grouped COUNT instead of
  loading the whole message history into memory.
- config AB3: per-spec allow_empty so smtp_user/youtube_api_proxy can be blanked
  to disable them rather than snapping back to the env default.

backend/app/routes/playlists.py

@@ -92,19 +92,12 @@ def _remove_item(db: Session, pl: Playlist, video_id: str, *, mark_dirty: bool)
 
 
 def _summary(
-    db: Session,
     pl: Playlist,
     count: int,
     total_duration: int = 0,
     has_video: bool | None = None,
+    cover: str | None = None,
 ) -> dict:
-    cover = db.scalar(
-        select(Video.thumbnail_url)
-        .join(PlaylistItem, PlaylistItem.video_id == Video.id)
-        .where(PlaylistItem.playlist_id == pl.id)
-        .order_by(PlaylistItem.position)
-        .limit(1)
-    )
     out = {
         "id": pl.id,
         "name": pl.name,
@@ -121,18 +114,6 @@ def _summary(
     return out
 
 
-def _total_duration(db: Session, playlist_id: int) -> int:
-    return (
-        db.scalar(
-            select(func.coalesce(func.sum(Video.duration_seconds), 0))
-            .select_from(PlaylistItem)
-            .join(Video, Video.id == PlaylistItem.video_id)
-            .where(PlaylistItem.playlist_id == playlist_id)
-        )
-        or 0
-    )
-
-
 @router.get("")
 def list_playlists(
     contains: str | None = None,
@@ -183,13 +164,34 @@ def list_playlists(
             .scalars()
             .all()
         )
+    # Batch the cover thumbnails (first item per playlist by position) in ONE window query
+    # instead of a per-playlist SELECT inside _summary (the old N+1).
+    rn = func.row_number().over(
+        partition_by=PlaylistItem.playlist_id,
+        order_by=PlaylistItem.position,
+    ).label("rn")
+    first_items = (
+        select(
+            PlaylistItem.playlist_id.label("pid"),
+            Video.thumbnail_url.label("thumb"),
+            rn,
+        )
+        .join(Video, Video.id == PlaylistItem.video_id)
+        .where(PlaylistItem.playlist_id.in_(ids))
+        .subquery()
+    )
+    covers = dict(
+        db.execute(
+            select(first_items.c.pid, first_items.c.thumb).where(first_items.c.rn == 1)
+        ).all()
+    )
     return [
         _summary(
-            db,
             p,
             counts.get(p.id, 0),
             durations.get(p.id, 0),
             (p.id in member) if contains else None,
+            covers.get(p.id),
         )
         for p in pls
     ]
@@ -207,7 +209,7 @@ def create_playlist(
     pl = Playlist(user_id=user.id, name=name, position=_next_playlist_position(db, user.id))
     db.add(pl)
     db.commit()
-    return _summary(db, pl, 0)
+    return _summary(pl, 0)
 
 
 def _watch_later(db: Session, user: User) -> Playlist:
@@ -350,13 +352,23 @@ def push(
         )
     try:
         with quota.attribute(user.id, quota.QuotaAction.PLAYLISTS_PUSH):
-            plan = plan_push(db, user, pl)
+            # Read the live playlist ONCE (linked playlists only) and share it with both the
+            # plan and the push, halving read-quota and closing the second read→write TOCTOU
+            # window. A fresh export (no yt_playlist_id) reads nothing.
+            live = None
+            if pl.yt_playlist_id:
+                with YouTubeClient(db, user) as yt:
+                    live = (
+                        list(yt.iter_playlist_items_with_ids(pl.yt_playlist_id)),
+                        yt.get_playlist_snippet(pl.yt_playlist_id),
+                    )
+            plan = plan_push(db, user, pl, live=live)
             if plan["units_estimate"] > quota.remaining_today(db):
                 raise HTTPException(
                     status_code=429,
                     detail="Not enough YouTube quota left today for this sync.",
                 )
-            return push_playlist(db, user, pl)
+            return push_playlist(db, user, pl, live=live)
     except YouTubeError:
         db.rollback()
         raise HTTPException(status_code=422, detail="YouTube playlist sync failed.")
@@ -405,10 +417,25 @@ def rename_playlist(
             pl.name = name
             recompute_dirty(db, pl)
     db.commit()
-    count = db.scalar(
-        select(func.count()).where(PlaylistItem.playlist_id == pl.id)
+    # One aggregate for count + duration (outer join so an empty playlist still returns 0),
+    # plus a single cover lookup — was 3 separate round-trips.
+    count, total = db.execute(
+        select(
+            func.count(PlaylistItem.id),
+            func.coalesce(func.sum(Video.duration_seconds), 0),
+        )
+        .select_from(PlaylistItem)
+        .outerjoin(Video, Video.id == PlaylistItem.video_id)
+        .where(PlaylistItem.playlist_id == pl.id)
+    ).one()
+    cover = db.scalar(
+        select(Video.thumbnail_url)
+        .join(PlaylistItem, PlaylistItem.video_id == Video.id)
+        .where(PlaylistItem.playlist_id == pl.id)
+        .order_by(PlaylistItem.position)
+        .limit(1)
     )
-    return _summary(db, pl, count or 0, _total_duration(db, pl.id))
+    return _summary(pl, count or 0, total or 0, cover=cover)
 
 
 @router.delete("/{playlist_id}")