fix(plex,audit): E30 review round 1 — the people job keeps going, HU genres everywhere, results as data

- people_enrich: a failed TMDB lookup or a dead headshot is skipped, not the end of the run (a dead
  file is marked and left for a week; three failures in a row end it); portraits wait for the Plex
  module switch; a no-Plex original keeps its own cache key, so the resize still replaces it; the job
  entry lives in the plex domain (run_people_enrich)
- person-image takes only a headshot-shaped CDN url (no query variants of one file)
- every synced row gets Hungarian genres, and a HU genre filter matches the word as picked too;
  migration 0094 fills the rows no overlay reached
- a job run's audit row carries its result as data; audit_clear / demo_reset store their counts
- one credit-column list for the prune and the enrichment order; _overlay_pass typed
- tests: batch skip + stop, HU bio stored, dead headshots, module switch, the person-image route,
  the job body, genre filter + facet write + twin fallback, tagline/summary fallbacks, audit data,
  the reader's alphabet at every remaining collated() call site

backend/app/plex/tmdb.py

@@ -24,7 +24,7 @@ from app import logs, sysconfig
 from app.config import settings
 from app.models import PlexItem, PlexPerson, PlexShow
 from app.plex.cards import display_title
-from app.plex.people import people_by_credits
+from app.plex.people import people_by_credits, warm_portraits
 
 log = logs.get_logger(__name__)
 # Politeness throttle: TMDB tolerates ~50 req/s; ~33/s leaves comfortable headroom for a shared host.
@@ -417,6 +417,19 @@ def run_enrich(db: Session) -> dict:
     return {"enriched": n, **({"countries_coded": coded} if coded else {})}
 
 
+def run_people_enrich(db: Session) -> dict:
+    """Scheduler entry point of people_enrich (E30 S6): a batch of person bios (the most-credited
+    first) and a batch of portraits. Each half is a no-op — never an error — without its TMDB key /
+    without Plex."""
+    batch = settings.people_enrich_batch
+    if sysconfig.get_str(db, "tmdb_api_key"):
+        with TmdbClient(db) as tmdb:
+            bios = enrich_people_batch(db, tmdb, batch)
+    else:
+        bios = {"skipped": "tmdb_api_key not set"}
+    return {"bios": bios, "portraits": warm_portraits(db, batch)}
+
+
 def resolve_library_guids(
     db: Session,
     entries: list[dict] | None,
@@ -627,14 +640,21 @@ def enrich_person(db: Session, person: PlexPerson) -> bool:
     return True
 
 
+# Lookups failing this many people in a row end a people batch: TMDB itself is degraded, and hammering
+# it helps nobody. One person failing alone is skipped, so an id TMDB keeps refusing never stalls the rest.
+_PEOPLE_FAILS_IN_A_ROW = 3
+
+
 def enrich_people_batch(db: Session, tmdb: TmdbClient, limit: int) -> dict:
     """Fetch up to `limit` linked, not-yet-enriched people (E30 S6), the most-credited first, so a
     person page reads its bio from the row instead of waiting on TMDB. Each person is committed as it
-    lands: a page open during the run already sees it. A transient TmdbError ends the batch (TMDB is
-    degraded; hammering it helps nobody) and the rest wait for the next run."""
+    lands: a page open during the run already sees it. A failed lookup is skipped (left unstamped for the
+    next run); _PEOPLE_FAILS_IN_A_ROW of them in a row end the batch."""
     ids = people_by_credits(db, "bio", limit)
-    done = 0
+    done = failed = in_a_row = 0
     for pid in ids:
+        if in_a_row >= _PEOPLE_FAILS_IN_A_ROW:
+            break
         person = db.get(PlexPerson, pid)
         # A page open may have enriched this person since the select: skip, don't fetch twice.
         if person is None or person.tmdb_enriched_at is not None:
@@ -643,13 +663,14 @@ def enrich_people_batch(db: Session, tmdb: TmdbClient, limit: int) -> dict:
             _fetch_person_into(tmdb, person)
         except TmdbError as exc:
             db.rollback()
+            failed, in_a_row = failed + 1, in_a_row + 1
             log.warning(
-                "the TMDB person batch stopped on a failed lookup",
+                "a TMDB person lookup in the batch failed",
                 extra=logs.event(
                     "plex.tmdb.people_batch_failed", person_id=pid, reason=type(exc).__name__
                 ),
             )
-            return {"enriched": done, "failed": 1}
+            continue
         db.commit()
-        done += 1
-    return {"enriched": done}
+        done, in_a_row = done + 1, 0
+    return {"enriched": done, **({"failed": failed} if failed else {})}