E5 S6: enriched person page (TMDB bio + birth facts + Known-for rail)

The person page now leads with a TMDB bio, lazily fetched the first time it's
opened (off the S2-linked `tmdb_person_id`) and then served from the row:

- Migration 0072: ADD-only nullable person columns on plex_people — biography,
  birthday, deathday, place_of_birth, known_for_department, also_known_as,
  known_for ([{tmdb_id, media_type, title}]), tmdb_enriched_at.
- tmdb.py: TmdbClient.fetch_person (/person/{id}+combined_credits), parse_person
  (bio + a popularity-ranked, deduped known_for), apply_person, enrich_person
  (lazy one-shot, key+id guarded, commits, 404 stamps the watermark).
- people.py person_detail: loads the full person row, lazily enriches (best-effort
  — never fails the page), serves the bio fields + resolves known_for to library
  rows by guid (in-library only, popularity order).
- FE PlexPersonView: bio/birth-facts/aka hero + a "Known for" Carousel rail above
  the existing Movies/Shows filmography; PlexPersonDetail type + i18n (en+hu).

Tests: test_plex_person_bio.py (6: parse / lazy-enrich guards / serve) + extended
PlexPersonView.dom.test.tsx + the unknown-name contract in test_plex_person.py.
Browser-E2E'd on Jim Carrey (live TMDB enrich → bio 1937 chars, born 1962-01-17
Newmarket, Known-for resolved). Gate: vitest 337, backend lane 402.

backend/app/models.py

@@ -1259,6 +1259,18 @@ class PlexPerson(Base, TimestampMixin, UpdatedAtMixin):
     # TMDB person id, linked by name from a title's TMDB credits (E5 S2 lays the foundation; the /person
     # biography fetch + person-page render land in S6). NULL until a TMDB-enriched title names this person.
     tmdb_person_id: Mapped[int | None] = mapped_column(Integer)
+    # --- TMDB person enrichment (E5 S6): fetched from /person/{tmdb_person_id} the first time the person
+    #     page is opened, then SERVED FROM THE ROW. `tmdb_enriched_at` is the watermark (set even on a
+    #     no-op fetch so it isn't retried every open). `known_for` = top combined-credits [{tmdb_id,
+    #     media_type, title}], resolved to library rows by guid at serve time (like recommendations). ---
+    biography: Mapped[str | None] = mapped_column(Text)
+    birthday: Mapped[str | None] = mapped_column(String(10))  # "YYYY-MM-DD", served as-is
+    deathday: Mapped[str | None] = mapped_column(String(10))
+    place_of_birth: Mapped[str | None] = mapped_column(Text)
+    known_for_department: Mapped[str | None] = mapped_column(String(64))
+    also_known_as: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [str]
+    known_for: Mapped[list | None] = mapped_column(JSONB(none_as_null=True))  # [{tmdb_id, media_type, title}]
+    tmdb_enriched_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
 
 
 class PlexCollection(Base, TimestampMixin, UpdatedAtMixin):

backend/app/plex/tmdb.py

@@ -119,6 +119,10 @@ class TmdbClient:
         """Resolve an external id (imdb_id / tvdb_id) to TMDB items via /find."""
         return self._get(f"/find/{external_id}", {"external_source": source})
 
+    def fetch_person(self, person_id: int) -> dict | None:
+        """One person's bio + combined credits (E5 S6), in a single append_to_response request."""
+        return self._get(f"/person/{person_id}", {"append_to_response": "combined_credits"})
+
 
 def guid_to_tmdb_id(guid: str | None, media_type: str, tmdb: TmdbClient) -> int | None:
     """Map a stored canonical guid to a TMDB id. `tmdb:` is direct; `imdb:`/`tvdb:` go through /find
@@ -377,3 +381,67 @@ def serve_block(db: Session, row) -> dict | None:
         "recommendations": resolve_recs(db, row.recommendations),
         "backdrops": row.backdrops or [],
     }
+
+
+# --- Person enrichment (E5 S6) -------------------------------------------------------------------
+# A person's bio + birth facts + a "Known for" credit pool, fetched once (the first person-page open)
+# and served from the plex_people row. `known_for` stores the top combined-credits ids; the person
+# endpoint resolves them to library rows by guid at serve time (like recommendations).
+
+_KNOWN_FOR_MAX = 15
+
+
+def parse_person(payload: dict) -> dict:
+    """TMDB /person/{id} (+combined_credits) → the persisted bio fields. `known_for` = the person's
+    most-popular movie/tv credits (deduped by id), top `_KNOWN_FOR_MAX`, resolved to library later."""
+    credits = (payload.get("combined_credits") or {}).get("cast") or []
+    seen: set[int] = set()
+    known: list[dict] = []
+    for c in sorted(credits, key=lambda c: c.get("popularity") or 0, reverse=True):
+        tid, mt = c.get("id"), c.get("media_type")
+        if not tid or mt not in ("movie", "tv") or tid in seen:
+            continue
+        seen.add(tid)
+        known.append({"tmdb_id": tid, "media_type": mt, "title": c.get("title") or c.get("name")})
+        if len(known) >= _KNOWN_FOR_MAX:
+            break
+    return {
+        "biography": (payload.get("biography") or "").strip() or None,
+        "birthday": payload.get("birthday") or None,
+        "deathday": payload.get("deathday") or None,
+        "place_of_birth": payload.get("place_of_birth") or None,
+        "known_for_department": payload.get("known_for_department") or None,
+        "also_known_as": payload.get("also_known_as") or None,
+        "known_for": known or None,
+    }
+
+
+def apply_person(row: PlexPerson, parsed: dict) -> None:
+    row.biography = parsed["biography"]
+    row.birthday = parsed["birthday"]
+    row.deathday = parsed["deathday"]
+    row.place_of_birth = parsed["place_of_birth"]
+    row.known_for_department = parsed["known_for_department"]
+    row.also_known_as = parsed["also_known_as"]
+    row.known_for = parsed["known_for"]
+    row.tmdb_enriched_at = datetime.now(timezone.utc)
+
+
+def enrich_person(db: Session, person: PlexPerson) -> bool:
+    """Lazily fetch + persist one person's TMDB bio (first person-page open), committing the write so it
+    survives regardless of the read path. No-op (False) without a key or a `tmdb_person_id`; a transient
+    error leaves `tmdb_enriched_at` NULL so the next open retries. A 404 (deleted person) stamps the
+    watermark with empty fields so we don't refetch it every open."""
+    if not person.tmdb_person_id or not sysconfig.get_str(db, "tmdb_api_key"):
+        return False
+    try:
+        with TmdbClient(db) as tmdb:
+            payload = tmdb.fetch_person(person.tmdb_person_id)
+    except TmdbError:
+        return False
+    if payload is None:
+        person.tmdb_enriched_at = datetime.now(timezone.utc)
+    else:
+        apply_person(person, parse_person(payload))
+    db.commit()
+    return True

backend/app/routes/plex/people.py

@@ -1,5 +1,7 @@
 """Plex people: cast/crew filter-chip cards + a single person's filmography page."""
 
+import logging
+
 from fastapi import APIRouter, Depends
 from sqlalchemy import func, or_, select
 from sqlalchemy.orm import Session
@@ -14,11 +16,65 @@ from app.models import (
     User,
 )
 from app.plex import rollup
+from app.plex import tmdb as plex_tmdb
 from app.plex.cards import movie_card, show_card
 from app.plex.query import split_csv
 from app.routes.plex._shared import _content_libs
 
 router = APIRouter(prefix="/api/plex", tags=["plex"])
+log = logging.getLogger("siftlode.plex")
+
+
+def _resolve_known_for(
+    db: Session,
+    known_for: list | None,
+    uid: int,
+    movie_lib_ids: list[int],
+    show_lib_ids: list[int],
+) -> list[dict]:
+    """The person's TMDB "Known for" credits (top by popularity) that are IN our library, as cards, in
+    popularity order. Matched by the canonical guid `tmdb:<id>`; out-of-library credits are dropped."""
+    if not known_for:
+        return []
+    guids = [f"tmdb:{k['tmdb_id']}" for k in known_for if k.get("tmdb_id")]
+    if not guids:
+        return []
+    movies: dict[str, PlexItem] = {}
+    if movie_lib_ids:
+        for m in db.execute(
+            select(PlexItem).where(
+                PlexItem.kind == "movie",
+                PlexItem.library_id.in_(movie_lib_ids),
+                PlexItem.guid.in_(guids),
+            )
+        ).scalars():
+            movies.setdefault(m.guid, m)
+    shows: dict[str, PlexShow] = {}
+    if show_lib_ids:
+        for s in db.execute(
+            select(PlexShow).where(
+                PlexShow.library_id.in_(show_lib_ids), PlexShow.guid.in_(guids)
+            )
+        ).scalars():
+            shows.setdefault(s.guid, s)
+    m_states = {
+        s.item_id: s
+        for s in db.execute(
+            select(PlexState).where(
+                PlexState.user_id == uid,
+                PlexState.item_id.in_([m.id for m in movies.values()] or [0]),
+            )
+        ).scalars()
+    }
+    show_statuses = rollup.state_map(db, uid, [s.id for s in shows.values()])
+    out: list[dict] = []
+    for k in known_for:
+        g = f"tmdb:{k.get('tmdb_id')}"
+        if g in movies:
+            out.append(movie_card(movies[g], m_states.get(movies[g].id)))
+        elif g in shows:
+            out.append(show_card(shows[g], show_statuses.get(shows[g].id, "new")))
+    return out
 
 
 @router.get("/people/cards")
@@ -88,8 +144,18 @@ def person_detail(
     libraries) whose cast OR directors include this name — the inverse of the cast-name → library-filter
     link. The name string is the identity key (Plex cast carries no stable per-person id), so distinct
     people who share a name share a page. Each section is capped at _PERSON_SECTION_MAX. An unknown name
-    simply returns empty sections."""
-    photo = db.scalar(select(PlexPerson.photo_thumb).where(PlexPerson.name == name))
+    simply returns empty sections.
+
+    E5 S6: the first time a page is opened, the person's TMDB bio + "Known for" credits are lazily
+    fetched (from the S2-linked `tmdb_person_id`) and persisted, then served from the row on every open.
+    """
+    person = db.execute(select(PlexPerson).where(PlexPerson.name == name)).scalars().first()
+    # Lazy one-time bio enrich — best-effort, never fail the page if TMDB is down / the id is stale.
+    if person is not None and person.tmdb_person_id and person.tmdb_enriched_at is None:
+        try:
+            plex_tmdb.enrich_person(db, person)
+        except Exception:  # noqa: BLE001 — enrichment is optional; the filmography still renders
+            log.warning("person bio enrich failed for %s", name, exc_info=True)
     movie_lib_ids, show_lib_ids = _content_libs(db)
 
     movies: list[dict] = []
@@ -136,4 +202,19 @@ def person_detail(
         statuses = rollup.state_map(db, user.id, [s.id for s in show_rows])
         shows = [show_card(sh, statuses.get(sh.id, "new")) for sh in show_rows]
 
-    return {"name": name, "photo": photo, "movies": movies, "shows": shows}
+    known_for = _resolve_known_for(
+        db, person.known_for if person else None, user.id, movie_lib_ids, show_lib_ids
+    )
+    return {
+        "name": name,
+        "photo": person.photo_thumb if person else None,
+        "biography": person.biography if person else None,
+        "birthday": person.birthday if person else None,
+        "deathday": person.deathday if person else None,
+        "place_of_birth": person.place_of_birth if person else None,
+        "known_for_department": person.known_for_department if person else None,
+        "also_known_as": (person.also_known_as if person else None) or [],
+        "known_for": known_for,
+        "movies": movies,
+        "shows": shows,
+    }