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/channels.py

@@ -175,15 +175,17 @@ def discover_channels(
 
     rows = _discovery_rows(db, user)
 
-    # Enrich stub channels' metadata (uses the API key — no write scope needed). Re-read
-    # the rows afterwards so the response carries the fresh subscriber counts/thumbnails.
+    # Enrich stub channels' metadata (uses the API key — no write scope needed). The Channel
+    # objects are identity-mapped, so apply_channel_details mutates the very rows we already hold
+    # (fresh subscriber counts/thumbnails carry through without a re-query). Only the title can
+    # change, which affects the tie-break order → re-sort in Python instead of re-hitting the DB.
     need = [ch.id for ch, _, _ in rows if ch.details_synced_at is None][:DISCOVERY_ENRICH_CAP]
     if need:
         try:
             with quota.attribute(user.id, quota.QuotaAction.CHANNELS_DISCOVER), YouTubeClient(db, user) as yt:
                 apply_channel_details(db, yt.get_channels(need))
             db.commit()
-            rows = _discovery_rows(db, user)
+            rows = sorted(rows, key=lambda r: (-int(r[1]), (r[0].title or "").lower()))
         except YouTubeError as exc:
             log.warning("discovery: channel enrich failed (user %s): %s", user.id, exc)
             db.rollback()
@@ -418,11 +420,18 @@ def reset_backfill(
     channel = db.get(Channel, channel_id)
     if channel is None:
         raise HTTPException(status_code=404, detail="Unknown channel")
-    sub = _user_subscription(db, user, channel_id)
     channel.backfill_done = False
     channel.backfill_cursor = None
     channel.recent_synced_at = None
-    sub.deep_requested = True
+    # Re-arm the demand-driven deep scheduler for this channel. run_deep_backfill gates on an
+    # EXISTS over subscriptions with deep_requested=True, so flip it on EVERY subscriber rather
+    # than requiring the admin to be personally subscribed (they reset from the manager, not
+    # their own feed). No-op row count if the channel has no subscribers.
+    db.execute(
+        update(Subscription)
+        .where(Subscription.channel_id == channel_id)
+        .values(deep_requested=True)
+    )
     db.commit()
     with quota.attribute(user.id, quota.QuotaAction.VIDEOS_BACKFILL_RECENT):
         run_recent_backfill(db, [channel], max_channels=1)
@@ -455,25 +464,30 @@ def subscribe(
     ).scalar_one_or_none()
     if existing is not None:
         raise HTTPException(status_code=409, detail="Already subscribed to this channel.")
-    try:
-        with quota.attribute(user.id, quota.QuotaAction.CHANNELS_SUBSCRIBE), YouTubeClient(db, user) as yt:
+    with quota.attribute(user.id, quota.QuotaAction.CHANNELS_SUBSCRIBE), YouTubeClient(db, user) as yt:
+        try:
             yt_sub_id = yt.insert_subscription(channel_id)
-            # Enrich a stub channel (title/thumbnail/subscriber count) so it shows up
-            # properly right away; no video pull here.
-            if channel.details_synced_at is None:
+        except YouTubeError as exc:
+            # Already following on YouTube but not recorded here (a desync — e.g. a stale import
+            # dropped the local row, so it resurfaced in discovery). That's not a failure: the end
+            # state the user wanted already holds, so record it locally and move on. The next
+            # subscription resync fills in the resource id. Any other YouTube error is a real
+            # problem — surface it with a clear message (422, not a 502 that the client would
+            # mistake for a transient "connection lost").
+            msg = str(exc).lower()
+            if "already exists" in msg or "duplicate" in msg:
+                yt_sub_id = ""
+            else:
+                raise HTTPException(status_code=422, detail=f"YouTube couldn't subscribe you: {exc}")
+        # Enrich a stub channel (title/thumbnail/subscriber count) so it shows up properly right
+        # away, on BOTH the normal and the desync path — a resurfaced stub still needs metadata to
+        # render. Keep the client open (we're still inside the `with`); a metadata failure here
+        # must not block recording the subscription the user asked for.
+        if channel.details_synced_at is None:
+            try:
                 apply_channel_details(db, yt.get_channels([channel_id]))
-    except YouTubeError as exc:
-        # Already following on YouTube but not recorded here (a desync — e.g. a stale import
-        # dropped the local row, so it resurfaced in discovery). That's not a failure: the end
-        # state the user wanted already holds, so record it locally and move on. The next
-        # subscription resync fills in the resource id. Any other YouTube error is a real
-        # problem — surface it with a clear message (422, not a 502 that the client would
-        # mistake for a transient "connection lost").
-        msg = str(exc).lower()
-        if "already exists" in msg or "duplicate" in msg:
-            yt_sub_id = ""
-        else:
-            raise HTTPException(status_code=422, detail=f"YouTube couldn't subscribe you: {exc}")
+            except YouTubeError as exc:
+                log.warning("subscribe: stub enrich failed (%s): %s", channel_id, exc)
     db.add(
         Subscription(
             user_id=user.id,