feat: search reindex, worker improvements, person IDs, user display names

- add admin POST /api/v1/admin/reindex-search endpoint + event-driven handler
- backfill persons from movie_cast/movie_crew into persons table
- paginate person list_page/backfill_from_credits_batch to cap memory
- concurrent worker event dispatch with semaphore (max 8)
- graceful worker shutdown (drain in-flight tasks on SIGINT)
- always ack events, log handler errors as warnings (no infinite retry)
- NATS ack_wait 600s, AtomicBool guard against concurrent reindex
- add username/display_name to UserSummaryDto and users list
- add person_id to CastMemberDto/CrewMemberDto via get_movie_profile use case
- add movie_id to wrapup MovieRef, person_id to wrapup PersonStat
- thread tmdb_person_id through wrapup cast pipeline
- add is_federated to FeedEntryDto
- cap orphaned persons query with LIMIT 500
- add SPA link to classic site footer

crates/application/src/movies/get_movie_profile.rs

@@ -0,0 +1,78 @@
+use domain::{
+    errors::DomainError,
+    models::{CastMember, CrewMember, ExternalPersonId, MovieProfile, PersonId},
+    value_objects::MovieId,
+};
+use uuid::Uuid;
+
+use crate::context::AppContext;
+
+pub struct GetMovieProfileQuery {
+    pub movie_id: Uuid,
+}
+
+pub struct CastMemberWithId {
+    pub person_id: PersonId,
+    pub tmdb_person_id: u64,
+    pub name: String,
+    pub character: String,
+    pub billing_order: u32,
+    pub profile_path: Option<String>,
+}
+
+pub struct CrewMemberWithId {
+    pub person_id: PersonId,
+    pub tmdb_person_id: u64,
+    pub name: String,
+    pub job: String,
+    pub department: String,
+    pub profile_path: Option<String>,
+}
+
+pub struct MovieProfileResult {
+    pub profile: MovieProfile,
+    pub cast: Vec<CastMemberWithId>,
+    pub crew: Vec<CrewMemberWithId>,
+}
+
+fn resolve_cast(member: &CastMember) -> CastMemberWithId {
+    let ext = ExternalPersonId::new(format!("tmdb:{}", member.tmdb_person_id));
+    CastMemberWithId {
+        person_id: PersonId::from_external(&ext),
+        tmdb_person_id: member.tmdb_person_id,
+        name: member.name.clone(),
+        character: member.character.clone(),
+        billing_order: member.billing_order,
+        profile_path: member.profile_path.clone(),
+    }
+}
+
+fn resolve_crew(member: &CrewMember) -> CrewMemberWithId {
+    let ext = ExternalPersonId::new(format!("tmdb:{}", member.tmdb_person_id));
+    CrewMemberWithId {
+        person_id: PersonId::from_external(&ext),
+        tmdb_person_id: member.tmdb_person_id,
+        name: member.name.clone(),
+        job: member.job.clone(),
+        department: member.department.clone(),
+        profile_path: member.profile_path.clone(),
+    }
+}
+
+pub async fn execute(
+    ctx: &AppContext,
+    query: GetMovieProfileQuery,
+) -> Result<Option<MovieProfileResult>, DomainError> {
+    let movie_id = MovieId::from_uuid(query.movie_id);
+    let profile = ctx.repos.movie_profile.get_by_movie_id(&movie_id).await?;
+
+    Ok(profile.map(|p| {
+        let cast = p.cast.iter().map(resolve_cast).collect();
+        let crew = p.crew.iter().map(resolve_crew).collect();
+        MovieProfileResult {
+            profile: p,
+            cast,
+            crew,
+        }
+    }))
+}

crates/application/src/movies/mod.rs

@@ -1,10 +1,13 @@
 pub mod commands;
 pub mod discovery_indexer;
 pub mod enrich_movie;
+pub mod get_movie_profile;
 pub mod get_movies;
 pub mod queries;
+pub mod reindex_search;
 pub mod search_cleanup;
 pub mod sync_poster;
 
 pub use discovery_indexer::MovieDiscoveryIndexer;
+pub use reindex_search::SearchReindexHandler;
 pub use search_cleanup::SearchCleanupHandler;

crates/application/src/movies/reindex_search.rs

@@ -0,0 +1,165 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::{IndexableDocument, MovieFilter, collections::PageParams},
+    ports::EventHandler,
+};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use crate::context::AppContext;
+
+const BATCH_SIZE: u32 = 500;
+
+pub struct SearchReindexHandler {
+    ctx: AppContext,
+    running: AtomicBool,
+}
+
+impl SearchReindexHandler {
+    pub fn new(ctx: AppContext) -> Self {
+        Self {
+            ctx,
+            running: AtomicBool::new(false),
+        }
+    }
+}
+
+#[async_trait]
+impl EventHandler for SearchReindexHandler {
+    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
+        if !matches!(event, DomainEvent::SearchReindexRequested) {
+            return Ok(());
+        }
+
+        if self.running.swap(true, Ordering::SeqCst) {
+            tracing::info!("search reindex already running, skipping");
+            return Ok(());
+        }
+
+        let result = self.run_reindex().await;
+        self.running.store(false, Ordering::SeqCst);
+        result
+    }
+}
+
+impl SearchReindexHandler {
+    async fn run_reindex(&self) -> Result<(), DomainError> {
+        tracing::info!("search reindex started");
+
+        let movies_indexed = self.reindex_movies().await?;
+        let backfilled = self.backfill_persons().await?;
+        if backfilled > 0 {
+            tracing::info!(backfilled, "backfilled missing persons from credits");
+        }
+        let persons_indexed = self.reindex_persons().await?;
+
+        tracing::info!(movies_indexed, persons_indexed, "search reindex completed");
+        Ok(())
+    }
+
+    async fn reindex_movies(&self) -> Result<u64, DomainError> {
+        let mut count: u64 = 0;
+        let mut offset: u32 = 0;
+        loop {
+            let page = self
+                .ctx
+                .repos
+                .movie
+                .list_movies(
+                    &PageParams {
+                        limit: BATCH_SIZE,
+                        offset,
+                    },
+                    &MovieFilter::default(),
+                )
+                .await?;
+
+            for summary in &page.items {
+                let movie_id = summary.movie.id().clone();
+                let profile = self
+                    .ctx
+                    .repos
+                    .movie_profile
+                    .get_by_movie_id(&movie_id)
+                    .await?;
+
+                if let Err(e) = self
+                    .ctx
+                    .repos
+                    .search_command
+                    .index(IndexableDocument::Movie {
+                        id: movie_id.clone(),
+                        movie: Box::new(summary.movie.clone()),
+                        profile: profile.map(Box::new),
+                    })
+                    .await
+                {
+                    tracing::warn!(movie_id = %movie_id.value(), "reindex movie failed: {e}");
+                }
+                count += 1;
+            }
+
+            if (page.items.len() as u32) < BATCH_SIZE {
+                break;
+            }
+            offset += BATCH_SIZE;
+            tokio::task::yield_now().await;
+        }
+        Ok(count)
+    }
+
+    async fn backfill_persons(&self) -> Result<u64, DomainError> {
+        let mut total = 0u64;
+        loop {
+            let (count, has_more) = self
+                .ctx
+                .repos
+                .person_command
+                .backfill_from_credits_batch(BATCH_SIZE)
+                .await?;
+            total += count;
+            if !has_more {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        Ok(total)
+    }
+
+    async fn reindex_persons(&self) -> Result<u64, DomainError> {
+        let mut count: u64 = 0;
+        let mut offset: u32 = 0;
+        loop {
+            let persons = self
+                .ctx
+                .repos
+                .person_query
+                .list_page(BATCH_SIZE, offset)
+                .await?;
+
+            for person in &persons {
+                if let Err(e) = self
+                    .ctx
+                    .repos
+                    .search_command
+                    .index(IndexableDocument::Person {
+                        id: person.id().clone(),
+                        person: Box::new(person.clone()),
+                    })
+                    .await
+                {
+                    tracing::warn!(person = %person.name(), "reindex person failed: {e}");
+                }
+                count += 1;
+            }
+
+            if (persons.len() as u32) < BATCH_SIZE {
+                break;
+            }
+            offset += BATCH_SIZE;
+            tokio::task::yield_now().await;
+        }
+        Ok(count)
+    }
+}