Improved player

Cargo.lock

@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.2.10"
+version = "0.2.15"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1441,6 +1441,7 @@ dependencies = [
  "symphonia",
  "tokio",
  "tokio-cron-scheduler",
+ "tower",
  "tracing",
  "tracing-subscriber",
  "uuid",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.2.10"
+version = "0.3.0"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -11,6 +11,7 @@ serde = { version = "1", features = ["derive"] }
 openidconnect = "4.0"
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "json"] }
 tokio = { version = "1", features = ["sync", "fs", "io-util"] }
+tower = "0.5"
 base64 = "0.22"
 serde_json = "1"
 tracing = "0.1"

src/admin/mod.rs

@@ -227,6 +227,55 @@ impl App for AdminApp {
                 },
                 "admin_v2_reviews_bulk",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/users",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database,
+                              query: UrlQuery<v2::UsersQuery>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("admin pool")
+                                })
+                                .await;
+                            v2::users(session, db, pg_pool, query.0).await
+                        }
+                    })
+                },
+                "admin_v2_users",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/users/{id}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database, path: Path<PathId>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("admin pool")
+                                })
+                                .await;
+                            v2::user_detail(session, db, pg_pool, path.0.id).await
+                        }
+                    })
+                },
+                "admin_v2_user_detail",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/reviews/{id}/approve",
                 {
@@ -308,6 +357,32 @@ impl App for AdminApp {
                 }),
                 "admin_v2_metadata_backfill_run_options",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/jobs/artwork_backfill/run-options",
+                cot::router::method::post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session,
+                          db: Database,
+                          json: Json<v2::ArtworkBackfillRunRequest>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("admin pool")
+                                })
+                                .await;
+                            v2::run_artwork_backfill(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "admin_v2_artwork_backfill_run_options",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/jobs/{name}/run",
                 cot::router::method::post({

src/admin/v2.rs

@@ -1,4 +1,5 @@
 use std::collections::{HashMap, HashSet};
+use std::path::Path;
 
 use cot::db::{Database, Model};
 use cot::html::Html;
@@ -44,6 +45,13 @@ pub(super) struct LibraryQuery {
     pub(super) offset: Option<i64>,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct UsersQuery {
+    pub(super) search: Option<String>,
+    pub(super) limit: Option<i64>,
+    pub(super) offset: Option<i64>,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct BulkReviewsRequest {
     action: String,
@@ -75,10 +83,18 @@ pub struct MetadataBackfillRunRequest {
     local_genres: bool,
     #[serde(default = "default_true")]
     lastfm_tags: bool,
+    #[serde(default = "default_true")]
+    musicbrainz_tags: bool,
     #[serde(default)]
     overwrite: bool,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct ArtworkBackfillRunRequest {
+    #[serde(default)]
+    overwrite_existing: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct UpdateLibraryItemRequest {
     kind: String,
@@ -150,12 +166,75 @@ struct AdminDashboardDto {
     user: AdminUserDto,
     build: BuildDto,
     stats: OverviewStatsDto,
+    runtime: RuntimeOverviewDto,
     reviews: ReviewPageDto,
     jobs: Vec<JobDto>,
     recent_runs: Vec<JobRunDto>,
     library: LibraryOverviewDto,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminUsersPageDto {
+    items: Vec<AdminUserRowDto>,
+    total: i64,
+    limit: i64,
+    offset: i64,
+    search: Option<String>,
+    online_count: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminUserRowDto {
+    id: i64,
+    username: String,
+    display_name: Option<String>,
+    email: Option<String>,
+    role: String,
+    is_active: bool,
+    is_online: bool,
+    last_seen_ms: Option<i64>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminUserDetailDto {
+    user: AdminUserRowDto,
+    stats: AdminUserStatsDto,
+    recent_plays: Vec<AdminUserPlayDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminUserStatsDto {
+    plays: i64,
+    completed_plays: i64,
+    listened_seconds: i64,
+    liked_tracks: i64,
+    followed_artists: i64,
+    own_playlists: i64,
+    saved_playlists: i64,
+    uploaded_tracks: i64,
+    torrent_sessions: i64,
+    lastfm_connected: bool,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminUserPlayDto {
+    history_id: i64,
+    played_at: String,
+    duration_listened: Option<i32>,
+    completed: bool,
+    track_id: i64,
+    title: String,
+    artists: String,
+    release_id: i64,
+    release_title: String,
+    release_year: Option<i32>,
+    cover_url: Option<String>,
+    track_duration_seconds: f64,
+    uploader_name: String,
+    audio_format: Option<String>,
+    audio_bitrate: Option<i32>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct OverviewStatsDto {
     tracks: i64,
@@ -167,6 +246,40 @@ struct OverviewStatsDto {
     hidden_artists: i64,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct RuntimeOverviewDto {
+    agent: AgentStatusDto,
+    storage: Vec<StoragePathDto>,
+    node: NodeStatsDto,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AgentStatusDto {
+    status: String,
+    enabled: bool,
+    llm_configured: bool,
+    model: String,
+    concurrency: u64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct StoragePathDto {
+    label: String,
+    path: String,
+    exists: bool,
+    free_bytes: Option<u64>,
+    total_bytes: Option<u64>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct NodeStatsDto {
+    hostname: String,
+    os: &'static str,
+    arch: &'static str,
+    pid: u32,
+    cpu_count: usize,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct StatusCountDto {
     status: String,
@@ -191,6 +304,7 @@ struct MetadataTagDto {
 struct ReviewPageDto {
     items: Vec<ReviewDto>,
     total: i64,
+    total_all: i64,
     limit: i64,
     offset: i64,
     status: Option<String>,
@@ -565,6 +679,8 @@ pub async fn dashboard(
         limit: Some(80),
         offset: Some(0),
     };
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let runtime = load_runtime_overview(&config);
     let (reviews, stats, jobs, recent_runs, library) = tokio::try_join!(
         load_review_page(pool, reviews_query),
         load_overview_stats(pool),
@@ -582,6 +698,7 @@ pub async fn dashboard(
         },
         build: build_dto(),
         stats,
+        runtime,
         reviews,
         jobs,
         recent_runs,
@@ -606,6 +723,41 @@ pub async fn reviews(
     Json(page).into_response()
 }
 
+pub async fn users(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    query: UsersQuery,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let page = load_admin_users_page(pool, query)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(page).into_response()
+}
+
+pub async fn user_detail(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    user_id: i64,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let detail = load_admin_user_detail(pool, user_id)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    match detail {
+        Some(detail) => Json(detail).into_response(),
+        None => Ok(json_error(StatusCode::NOT_FOUND, "user not found")),
+    }
+}
+
 pub async fn bulk_reviews(
     session: Session,
     db: Database,
@@ -933,6 +1085,7 @@ pub async fn run_metadata_backfill(
         duration_seconds: body.duration_seconds,
         local_genres: body.local_genres,
         lastfm_tags: body.lastfm_tags,
+        musicbrainz_tags: body.musicbrainz_tags,
         overwrite: body.overwrite,
     };
     if !options.any_field() {
@@ -965,7 +1118,59 @@ pub async fn run_metadata_backfill(
         let duration_ms = start.elapsed().as_millis() as i64;
         match result {
             Ok(()) => {
-                let _ = run.set_completed(&db_for_task, duration_ms, &log.output()).await;
+                let _ = run
+                    .set_completed(&db_for_task, duration_ms, &log.output())
+                    .await;
+            }
+            Err(err) => {
+                let _ = run
+                    .set_failed(&db_for_task, duration_ms, &log.output(), &err.to_string())
+                    .await;
+            }
+        }
+    });
+
+    Json(JobRunStartedDto { ok: true, run_id }).into_response()
+}
+
+pub async fn run_artwork_backfill(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<ArtworkBackfillRunRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let options = crate::jobs::artwork_backfill::ArtworkBackfillOptions {
+        overwrite_existing: body.overwrite_existing,
+    };
+    let mut run = JobRun::create_running(&db, "artwork_backfill", "manual")
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to create job run: {e}")))?;
+    let run_id = run.id_val();
+    let (live_config, _) = AppConfig::load_with_db(&db).await;
+    let db_for_task = db.clone();
+    let pool_for_task = pool.clone();
+
+    tokio::spawn(async move {
+        let start = std::time::Instant::now();
+        let ctx = scheduler::JobContext {
+            config: std::sync::Arc::new(live_config),
+            db: db_for_task.clone(),
+            pool: pool_for_task.clone(),
+            run_id,
+            registry: std::sync::Arc::new(JobRegistry::new()),
+        };
+        let mut log = scheduler::JobLog::with_live_flush(pool_for_task.clone(), run_id);
+        let result = crate::jobs::artwork_backfill::run_with_options(&ctx, &mut log, options).await;
+        let duration_ms = start.elapsed().as_millis() as i64;
+        match result {
+            Ok(()) => {
+                let _ = run
+                    .set_completed(&db_for_task, duration_ms, &log.output())
+                    .await;
             }
             Err(err) => {
                 let _ = run
@@ -1233,11 +1438,13 @@ pub async fn update_library_item(
                     .map_err(|e| cot::Error::internal(e.to_string()))?;
                 }
             } else {
-                sqlx::query("DELETE FROM furumusic__track_artist WHERE track_id = $1 AND role = 'main'")
-                    .bind(body.id)
-                    .execute(pool)
-                    .await
-                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                sqlx::query(
+                    "DELETE FROM furumusic__track_artist WHERE track_id = $1 AND role = 'main'",
+                )
+                .bind(body.id)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
                 for (position, artist_id) in artist_ids.iter().enumerate() {
                     sqlx::query(
                         "INSERT INTO furumusic__track_artist (track_id, artist_id, role, position) VALUES ($1, $2, 'main', $3)",
@@ -1511,6 +1718,439 @@ async fn load_overview_stats(pool: &PgPool) -> anyhow::Result<OverviewStatsDto>
     })
 }
 
+#[derive(Debug, sqlx::FromRow)]
+struct AdminUserSqlRow {
+    id: i64,
+    username: String,
+    display_name: Option<String>,
+    email: Option<String>,
+    role: String,
+    is_active: bool,
+}
+
+async fn load_admin_users_page(
+    pool: &PgPool,
+    query: UsersQuery,
+) -> anyhow::Result<AdminUsersPageDto> {
+    let limit = query.limit.unwrap_or(40).clamp(10, 200);
+    let offset = query.offset.unwrap_or(0).max(0);
+    let search = query
+        .search
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_owned);
+    let pattern = search.as_ref().map(|value| format!("%{value}%"));
+
+    let mut count_qb =
+        QueryBuilder::<Postgres>::new("SELECT COUNT(*) FROM furumusic__user WHERE 1=1");
+    if let Some(pattern) = pattern.as_ref() {
+        count_qb.push(" AND (username ILIKE ");
+        count_qb.push_bind(pattern);
+        count_qb.push(" OR COALESCE(display_name, '') ILIKE ");
+        count_qb.push_bind(pattern);
+        count_qb.push(" OR COALESCE(email, '') ILIKE ");
+        count_qb.push_bind(pattern);
+        count_qb.push(")");
+    }
+    let total: i64 = count_qb.build_query_scalar().fetch_one(pool).await?;
+
+    let mut qb = QueryBuilder::<Postgres>::new(
+        "SELECT id, username::text, display_name, email, role::text, is_active FROM furumusic__user WHERE 1=1",
+    );
+    if let Some(pattern) = pattern.as_ref() {
+        qb.push(" AND (username ILIKE ");
+        qb.push_bind(pattern);
+        qb.push(" OR COALESCE(display_name, '') ILIKE ");
+        qb.push_bind(pattern);
+        qb.push(" OR COALESCE(email, '') ILIKE ");
+        qb.push_bind(pattern);
+        qb.push(")");
+    }
+    qb.push(" ORDER BY username ASC LIMIT ");
+    qb.push_bind(limit);
+    qb.push(" OFFSET ");
+    qb.push_bind(offset);
+    let rows: Vec<AdminUserSqlRow> = qb.build_query_as().fetch_all(pool).await?;
+
+    let active = crate::metrics::active_user_last_seen_ms();
+    let online_cutoff_ms = 60_000;
+    let items = rows
+        .into_iter()
+        .map(|row| admin_user_row(row, &active, online_cutoff_ms))
+        .collect::<Vec<_>>();
+    let online_count = active
+        .values()
+        .filter(|last_seen_ms| **last_seen_ms <= online_cutoff_ms)
+        .count() as i64;
+
+    Ok(AdminUsersPageDto {
+        items,
+        total,
+        limit,
+        offset,
+        search,
+        online_count,
+    })
+}
+
+async fn load_admin_user_detail(
+    pool: &PgPool,
+    user_id: i64,
+) -> anyhow::Result<Option<AdminUserDetailDto>> {
+    let row = sqlx::query_as::<_, AdminUserSqlRow>(
+        "SELECT id, username::text, display_name, email, role::text, is_active FROM furumusic__user WHERE id = $1",
+    )
+    .bind(user_id)
+    .fetch_optional(pool)
+    .await?;
+    let Some(row) = row else {
+        return Ok(None);
+    };
+
+    let active = crate::metrics::active_user_last_seen_ms();
+    let user = admin_user_row(row, &active, 60_000);
+    let (
+        plays,
+        completed_plays,
+        listened_seconds,
+        liked_tracks,
+        followed_artists,
+        own_playlists,
+        saved_playlists,
+        uploaded_tracks,
+        torrent_sessions,
+        lastfm_connected,
+    ) = tokio::try_join!(
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__play_history WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__play_history WHERE user_id = $1 AND completed"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COALESCE(SUM(duration_listened), 0)::bigint FROM furumusic__play_history WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__user_liked_track WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__user_followed_artist WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__playlist WHERE owner_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__saved_playlist WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(DISTINCT t.id) FROM furumusic__track t JOIN furumusic__media_file mf ON mf.id = t.audio_file_id WHERE mf.uploaded_by_user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, i64>(
+            "SELECT COUNT(*) FROM furumusic__torrent_session WHERE user_id = $1"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+        sqlx::query_scalar::<_, bool>(
+            "SELECT EXISTS(SELECT 1 FROM furumusic__lastfm_account WHERE user_id = $1 AND session_key <> '')"
+        )
+        .bind(user_id)
+        .fetch_one(pool),
+    )?;
+    let recent_plays = load_admin_user_recent_plays(pool, user_id, 30).await?;
+
+    Ok(Some(AdminUserDetailDto {
+        user,
+        stats: AdminUserStatsDto {
+            plays,
+            completed_plays,
+            listened_seconds,
+            liked_tracks,
+            followed_artists,
+            own_playlists,
+            saved_playlists,
+            uploaded_tracks,
+            torrent_sessions,
+            lastfm_connected,
+        },
+        recent_plays,
+    }))
+}
+
+async fn load_admin_user_recent_plays(
+    pool: &PgPool,
+    user_id: i64,
+    limit: i64,
+) -> anyhow::Result<Vec<AdminUserPlayDto>> {
+    let rows = sqlx::query_as::<_, AdminUserPlaySqlRow>(
+        r#"SELECT ph.id AS history_id,
+                  ph.played_at::text AS played_at,
+                  ph.duration_listened,
+                  ph.completed,
+                  t.id AS track_id,
+                  t.title::text AS title,
+                  COALESCE(NULLIF(STRING_AGG(a.name::text, ', ' ORDER BY ta.position), ''), 'Unknown artist') AS artists,
+                  t.release_id,
+                  COALESCE(r.title::text, '') AS release_title,
+                  r.year AS release_year,
+                  t.cover_file_id,
+                  r.cover_file_id AS release_cover_file_id,
+                  t.duration_seconds AS track_duration_seconds,
+                  COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
+                  mf.audio_format,
+                  mf.audio_bitrate
+           FROM furumusic__play_history ph
+           JOIN furumusic__track t ON t.id = ph.track_id
+           LEFT JOIN furumusic__release r ON r.id = t.release_id
+           LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
+           LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id AND ta.role = 'main'
+           LEFT JOIN furumusic__artist a ON a.id = ta.artist_id
+           WHERE ph.user_id = $1
+           GROUP BY ph.id, ph.played_at, ph.duration_listened, ph.completed, t.id, t.title,
+                    t.release_id, r.title, r.year, t.cover_file_id, r.cover_file_id,
+                    t.duration_seconds, mf.uploader_name, mf.audio_format, mf.audio_bitrate
+           ORDER BY ph.played_at DESC, ph.id DESC
+           LIMIT $2"#,
+    )
+    .bind(user_id)
+    .bind(limit)
+    .fetch_all(pool)
+    .await?;
+
+    Ok(rows
+        .into_iter()
+        .map(|row| AdminUserPlayDto {
+            history_id: row.history_id,
+            played_at: row.played_at,
+            duration_listened: row.duration_listened,
+            completed: row.completed,
+            track_id: row.track_id,
+            title: row.title,
+            artists: row.artists,
+            release_id: row.release_id,
+            release_title: row.release_title,
+            release_year: row.release_year,
+            cover_url: admin_track_cover_url(row.cover_file_id, row.release_cover_file_id),
+            track_duration_seconds: row.track_duration_seconds,
+            uploader_name: row.uploader_name,
+            audio_format: row.audio_format,
+            audio_bitrate: row.audio_bitrate,
+        })
+        .collect())
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct AdminUserPlaySqlRow {
+    history_id: i64,
+    played_at: String,
+    duration_listened: Option<i32>,
+    completed: bool,
+    track_id: i64,
+    title: String,
+    artists: String,
+    release_id: i64,
+    release_title: String,
+    release_year: Option<i32>,
+    cover_file_id: Option<i64>,
+    release_cover_file_id: Option<i64>,
+    track_duration_seconds: f64,
+    uploader_name: String,
+    audio_format: Option<String>,
+    audio_bitrate: Option<i32>,
+}
+
+fn admin_track_cover_url(track_cover: Option<i64>, release_cover: Option<i64>) -> Option<String> {
+    track_cover
+        .or(release_cover)
+        .map(|id| format!("/api/player/cover/{id}/medium"))
+}
+
+fn admin_user_row(
+    row: AdminUserSqlRow,
+    active: &HashMap<i64, i64>,
+    online_cutoff_ms: i64,
+) -> AdminUserRowDto {
+    let last_seen_ms = active.get(&row.id).copied();
+    AdminUserRowDto {
+        id: row.id,
+        username: row.username,
+        display_name: row.display_name,
+        email: row.email,
+        role: row.role,
+        is_active: row.is_active,
+        is_online: last_seen_ms.is_some_and(|value| value <= online_cutoff_ms),
+        last_seen_ms,
+    }
+}
+
+fn load_runtime_overview(config: &AppConfig) -> RuntimeOverviewDto {
+    let llm_configured = !config.agent_llm_url.trim().is_empty();
+    let agent_status = if !config.agent_enabled {
+        "disabled"
+    } else if !llm_configured {
+        "not_configured"
+    } else {
+        "enabled"
+    };
+
+    RuntimeOverviewDto {
+        agent: AgentStatusDto {
+            status: agent_status.to_owned(),
+            enabled: config.agent_enabled,
+            llm_configured,
+            model: config.agent_llm_model.clone(),
+            concurrency: config.agent_concurrency,
+        },
+        storage: vec![
+            storage_path_dto("Inbox", &config.agent_inbox_dir),
+            storage_path_dto("Library", &config.agent_storage_dir),
+        ],
+        node: NodeStatsDto {
+            hostname: node_hostname(),
+            os: std::env::consts::OS,
+            arch: std::env::consts::ARCH,
+            pid: std::process::id(),
+            cpu_count: std::thread::available_parallelism()
+                .map(|count| count.get())
+                .unwrap_or(1),
+        },
+    }
+}
+
+fn storage_path_dto(label: &str, raw_path: &str) -> StoragePathDto {
+    let path = raw_path.trim();
+    let path_ref = Path::new(path);
+    let usage = if path.is_empty() {
+        None
+    } else {
+        disk_usage(path_ref).or_else(|| {
+            path_ref
+                .parent()
+                .filter(|parent| !parent.as_os_str().is_empty())
+                .and_then(disk_usage)
+        })
+    };
+
+    StoragePathDto {
+        label: label.to_owned(),
+        path: path.to_owned(),
+        exists: !path.is_empty() && path_ref.exists(),
+        free_bytes: usage.map(|value| value.free_bytes),
+        total_bytes: usage.map(|value| value.total_bytes),
+    }
+}
+
+fn node_hostname() -> String {
+    std::env::var("HOSTNAME")
+        .or_else(|_| std::env::var("COMPUTERNAME"))
+        .unwrap_or_else(|_| "unknown".to_owned())
+}
+
+#[derive(Debug, Clone, Copy)]
+struct DiskUsage {
+    free_bytes: u64,
+    total_bytes: u64,
+}
+
+#[cfg(windows)]
+fn disk_usage(path: &Path) -> Option<DiskUsage> {
+    use std::os::windows::ffi::OsStrExt;
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn GetDiskFreeSpaceExW(
+            lpDirectoryName: *const u16,
+            lpFreeBytesAvailableToCaller: *mut u64,
+            lpTotalNumberOfBytes: *mut u64,
+            lpTotalNumberOfFreeBytes: *mut u64,
+        ) -> i32;
+    }
+
+    let mut wide: Vec<u16> = path.as_os_str().encode_wide().collect();
+    wide.push(0);
+
+    let mut free_available = 0_u64;
+    let mut total = 0_u64;
+    let mut total_free = 0_u64;
+    let ok = unsafe {
+        GetDiskFreeSpaceExW(
+            wide.as_ptr(),
+            &mut free_available,
+            &mut total,
+            &mut total_free,
+        )
+    };
+    (ok != 0).then_some(DiskUsage {
+        free_bytes: free_available,
+        total_bytes: total,
+    })
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn disk_usage(path: &Path) -> Option<DiskUsage> {
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+
+    #[repr(C)]
+    struct Statvfs {
+        f_bsize: std::ffi::c_ulong,
+        f_frsize: std::ffi::c_ulong,
+        f_blocks: std::ffi::c_ulong,
+        f_bfree: std::ffi::c_ulong,
+        f_bavail: std::ffi::c_ulong,
+        f_files: std::ffi::c_ulong,
+        f_ffree: std::ffi::c_ulong,
+        f_favail: std::ffi::c_ulong,
+        f_fsid: std::ffi::c_ulong,
+        f_flag: std::ffi::c_ulong,
+        f_namemax: std::ffi::c_ulong,
+        __f_spare: [std::ffi::c_int; 6],
+    }
+
+    unsafe extern "C" {
+        fn statvfs(path: *const std::ffi::c_char, buf: *mut Statvfs) -> std::ffi::c_int;
+    }
+
+    let c_path = CString::new(path.as_os_str().as_bytes()).ok()?;
+    let mut stat = std::mem::MaybeUninit::<Statvfs>::uninit();
+    let ok = unsafe { statvfs(c_path.as_ptr(), stat.as_mut_ptr()) };
+    if ok != 0 {
+        return None;
+    }
+    let stat = unsafe { stat.assume_init() };
+    let fragment_size = if stat.f_frsize > 0 {
+        stat.f_frsize as u64
+    } else {
+        stat.f_bsize as u64
+    };
+
+    Some(DiskUsage {
+        free_bytes: stat.f_bavail as u64 * fragment_size,
+        total_bytes: stat.f_blocks as u64 * fragment_size,
+    })
+}
+
+#[cfg(not(any(windows, target_os = "linux", target_os = "android")))]
+fn disk_usage(_path: &Path) -> Option<DiskUsage> {
+    None
+}
+
 async fn load_library_overview(pool: &PgPool) -> anyhow::Result<LibraryOverviewDto> {
     let stats = load_overview_stats(pool).await?;
     Ok(LibraryOverviewDto {
@@ -1529,6 +2169,7 @@ async fn load_review_page(pool: &PgPool, query: ReviewsQuery) -> anyhow::Result<
     let search_pattern = search.as_ref().map(|s| format!("%{s}%"));
 
     let total = count_reviews(pool, status.clone(), search_pattern.clone()).await?;
+    let total_all = count_reviews(pool, None, search_pattern.clone()).await?;
     let status_counts = load_review_status_counts(pool, None, search_pattern.clone()).await?;
 
     let mut qb = QueryBuilder::<Postgres>::new(
@@ -1554,6 +2195,7 @@ async fn load_review_page(pool: &PgPool, query: ReviewsQuery) -> anyhow::Result<
     Ok(ReviewPageDto {
         items,
         total,
+        total_all,
         limit,
         offset,
         status,

src/admin/views.rs

@@ -1472,6 +1472,7 @@ pub async fn metadata_backfill_run(
         duration_seconds: data.duration_seconds.is_some(),
         local_genres: data.local_genres.is_some(),
         lastfm_tags: data.lastfm_tags.is_some(),
+        musicbrainz_tags: true,
         overwrite: data.mode.as_deref() == Some("overwrite"),
     };
 

src/agent/cover_art.rs

@@ -128,13 +128,21 @@ pub async fn find_best_cover(folder: &Path, audio_files: &[PathBuf]) -> Option<C
         match tokio::fs::read(img_path).await {
             Ok(data) if !data.is_empty() => {
                 let mime = mime_for_image(img_path);
+                crate::metrics::record_agent_cover_lookup("folder", "ok", data.len());
                 return Some(CoverImage {
                     data,
                     mime_type: mime,
                     source: CoverSource::FolderFile(img_path.clone()),
                 });
             }
-            _ => continue,
+            Ok(_) => {
+                crate::metrics::record_agent_cover_lookup("folder", "empty", 0);
+                continue;
+            }
+            Err(_) => {
+                crate::metrics::record_agent_cover_lookup("folder", "error", 0);
+                continue;
+            }
         }
     }
 
@@ -143,10 +151,12 @@ pub async fn find_best_cover(folder: &Path, audio_files: &[PathBuf]) -> Option<C
         let path = audio_path.to_path_buf();
         let result = tokio::task::spawn_blocking(move || extract_embedded_cover(&path)).await;
         if let Ok(Some(cover)) = result {
+            crate::metrics::record_agent_cover_lookup("embedded", "ok", cover.data.len());
             return Some(cover);
         }
     }
 
+    crate::metrics::record_agent_cover_lookup("none", "not_found", 0);
     None
 }
 

src/agent/cover_variants.rs

@@ -74,6 +74,7 @@ fn generate_missing_variants_sync(
 
     let mut created = 0usize;
     for variant in variants {
+        let start = std::time::Instant::now();
         let path = variant_path(original_path, *variant);
         if path.exists() {
             continue;
@@ -88,12 +89,27 @@ fn generate_missing_variants_sync(
             .to_rgb8();
         let mut output = Vec::new();
         let mut encoder = JpegEncoder::new_with_quality(&mut output, variant.quality);
-        encoder.encode(
+        let result = encoder.encode(
             &resized,
             resized.width(),
             resized.height(),
             image::ExtendedColorType::Rgb8,
-        )?;
+        );
+        match result {
+            Ok(()) => crate::metrics::record_agent_cover_variant(
+                variant.name,
+                "ok",
+                start.elapsed(),
+            ),
+            Err(err) => {
+                crate::metrics::record_agent_cover_variant(
+                    variant.name,
+                    "error",
+                    start.elapsed(),
+                );
+                return Err(err.into());
+            }
+        }
         std::fs::write(path, output)?;
         created += 1;
     }

src/agent/normalize.rs

@@ -330,6 +330,7 @@ pub async fn normalize_batch(
     // If over 80% of context limit and more than 1 file, split
     let limit_80 = context_limit * 80 / 100;
     if estimated > limit_80 && files.len() > 1 {
+        crate::metrics::record_agent_llm_split("estimated_context");
         tracing::info!(
             estimated_tokens = estimated,
             context_limit,
@@ -419,6 +420,7 @@ pub async fn normalize_batch(
                 || err_str.contains("length")
                 || err_str.contains("token");
             if is_context_error {
+                crate::metrics::record_agent_llm_split("context_error");
                 tracing::warn!(
                     file_count = files.len(),
                     "LLM error suggests context overflow, splitting batch: {e}"
@@ -466,14 +468,40 @@ pub async fn normalize_batch(
             }
             return Err(e);
         }
-        Err(e) => return Err(e),
+        Err(e) => {
+            crate::metrics::record_agent_llm(
+                llm_model,
+                "error",
+                std::time::Duration::from_millis(duration_ms),
+                0,
+                0,
+                files.len(),
+                Some(estimated),
+            );
+            return Err(e);
+        }
     };
 
     let prompt_tokens = usage.prompt_tokens.unwrap_or(0) as u64;
     let completion_tokens = usage.completion_tokens.unwrap_or(0) as u64;
+    crate::metrics::record_agent_llm(
+        &resp_model,
+        "ok",
+        std::time::Duration::from_millis(duration_ms),
+        prompt_tokens,
+        completion_tokens,
+        files.len(),
+        Some(estimated),
+    );
 
     // Parse batch response
-    let results = parse_batch_response(&response_text, &files)?;
+    let results = match parse_batch_response(&response_text, &files) {
+        Ok(results) => results,
+        Err(error) => {
+            crate::metrics::record_agent_llm_parse_failure(&resp_model);
+            return Err(error);
+        }
+    };
 
     Ok(BatchNormalizeResult {
         results,

src/auth.rs

@@ -61,6 +61,7 @@ pub async fn get_session_user(session: &Session, db: &Database) -> Option<Authen
             display
         }
     };
+    crate::metrics::record_active_user(user.id_val());
     Some(AuthenticatedUser {
         id: user.id_val(),
         name,
@@ -75,9 +76,11 @@ pub async fn require_admin_or_redirect(
     db: &Database,
 ) -> Result<AuthenticatedUser, cot::response::Response> {
     let Some(user) = get_session_user(session, db).await else {
+        crate::metrics::record_authorization_denied("unauthenticated");
         return Err(redirect("/login"));
     };
     if user.role != Role::Admin {
+        crate::metrics::record_authorization_denied("forbidden");
         return Err("Forbidden"
             .with_status(cot::http::StatusCode::FORBIDDEN)
             .into_response()
@@ -96,6 +99,7 @@ pub async fn login(session: &Session, user_id: i64) -> cot::Result<()> {
         .insert(SESSION_USER_ID, user_id)
         .await
         .map_err(|e| cot::Error::internal(e.to_string()))?;
+    crate::metrics::record_active_user(user_id);
     Ok(())
 }
 

src/i18n/phrases.rs

@@ -272,6 +272,8 @@ translations! {
     // Player UI
     player_library:          "Library"                         , "Библиотека";
     player_artists:          "Artists"                         , "Артисты";
+    player_global_library:   "Global"                          , "Global";
+    player_featured_only_artists: "Featured only"               , "Только фиты";
     player_release:          "Release"                         , "Релиз";
     player_releases:         "Releases"                        , "Релизы";
     player_tracks:           "Tracks"                          , "Треки";
@@ -298,6 +300,7 @@ translations! {
     player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
     player_connection_lost: "Server connection lost"             , "Нет соединения с сервером";
     player_connection_lost_detail: "Player cannot reach the server. Retrying..." , "Плеер не может связаться с сервером. Повторяю...";
+    player_active_device:   "Active device"                   , "Активный девайс";
     player_no_results:       "No results found"                , "Ничего не найдено";
     player_new_playlist:     "New Playlist"                    , "Новый плейлист";
     player_rename_playlist:  "Rename Playlist"                 , "Переименовать плейлист";
@@ -386,7 +389,71 @@ translations! {
     player_saved_torrents:   "Saved torrents"                  , "Сохранённые торренты";
     player_refresh:          "Refresh"                         , "Обновить";
     player_no_saved_torrents: "No saved torrents"              , "Сохранённых торрентов нет";
+    player_import:           "Import"                          , "Импорт";
     player_upload:           "Upload"                          , "Загрузить";
+    player_my_uploads:       "My uploads"                      , "Мои загрузки";
+    player_my_uploaded_tracks: "My uploaded tracks"             , "Мои загруженные треки";
+    player_no_uploaded_tracks: "No uploaded tracks yet"         , "Загруженных треков пока нет";
+    player_needs_approval:   "Needs approval"                  , "Нужно подтверждение";
+    player_pending_or_failed: "pending or failed"               , "ожидают или с ошибкой";
+    player_no_tracks_need_approval: "No tracks need approval"   , "Нет треков для подтверждения";
+    player_queued_processing: "Queued / processing"             , "В очереди / обработке";
+    player_showing:          "Showing"                         , "Показано";
+    player_status:           "Status"                          , "Статус";
+    player_file:             "File"                            , "Файл";
+    player_created:          "Created"                         , "Создано";
+    player_updated:          "Updated"                         , "Обновлено";
+    player_error:            "Error"                           , "Ошибка";
+    player_pending:          "Pending"                         , "Ожидает";
+    player_artist:           "Artist"                          , "Артист";
+    player_album:            "Album"                           , "Альбом";
+    player_album_artists:    "Album artists"                   , "Артисты альбома";
+    player_featured:         "Featured"                        , "При участии";
+    player_featured_short:   "feat."                           , "уч.";
+    player_track_number:     "Track #"                         , "Трек #";
+    player_disc_number:      "Disc #"                          , "Диск #";
+    player_genre:            "Genre"                           , "Жанр";
+    player_notes:            "Notes"                           , "Заметки";
+    player_type_unchanged:   "Type unchanged"                  , "Тип без изменений";
+    player_visibility_unchanged: "Visibility unchanged"         , "Видимость без изменений";
+    player_visible:          "Visible"                         , "Видимый";
+    player_hidden:           "Hidden"                          , "Скрыт";
+    player_no_year:          "no year"                         , "год неизвестен";
+    player_apply:            "Apply"                           , "Применить";
+    player_edit:             "Edit"                            , "Редактировать";
+    player_edit_release:     "Edit release"                    , "Редактировать релиз";
+    player_edit_track:       "Edit track"                      , "Редактировать трек";
+    player_edit_metadata:    "Edit metadata"                   , "Редактировать метаданные";
+    player_metadata:         "Metadata"                        , "Метаданные";
+    player_release_metadata: "Release metadata"                , "Метаданные релиза";
+    player_track_metadata:   "Track metadata"                  , "Метаданные трека";
+    player_approve_metadata: "Approve metadata"                , "Подтвердить метаданные";
+    player_delete_review:    "Delete review"                   , "Удалить проверку";
+    player_approve:          "Approve"                         , "Подтвердить";
+    player_save_track:       "Save track"                      , "Сохранить трек";
+    player_save_release:     "Save release"                    , "Сохранить релиз";
+    player_artists_placeholder: "Artist, Artist"               , "Артист, артист";
+    player_artist_featured_placeholder: "Artist, Featured Artist" , "Артист, приглашённый артист";
+    player_release_type_album: "Album"                         , "Альбом";
+    player_release_type_single: "Single"                       , "Сингл";
+    player_release_type_ep:  "EP"                              , "EP";
+    player_release_type_compilation: "Compilation"             , "Сборник";
+    player_release_type_mixtape: "Mixtape"                     , "Микстейп";
+    player_release_type_live: "Live"                           , "Концерт";
+    player_release_type_soundtrack: "Soundtrack"               , "Саундтрек";
+    player_release_type_remix: "Remix"                         , "Ремикс";
+    player_release_type_demo: "Demo"                           , "Демо";
+    player_failed_load_uploaded_tracks: "Failed to load uploaded tracks" , "Не удалось загрузить загруженные треки";
+    player_failed_save_track: "Failed to save track"           , "Не удалось сохранить трек";
+    player_track_metadata_saved: "Track metadata saved"         , "Метаданные трека сохранены";
+    player_failed_save_release: "Failed to save release"       , "Не удалось сохранить релиз";
+    player_release_metadata_saved: "Release metadata saved"     , "Метаданные релиза сохранены";
+    player_failed_delete_review: "Failed to delete review"     , "Не удалось удалить проверку";
+    player_review_deleted:   "Review deleted"                  , "Проверка удалена";
+    player_failed_approve_review: "Failed to approve review"   , "Не удалось подтвердить проверку";
+    player_track_approved_imported: "Track approved and imported" , "Трек подтверждён и импортирован";
+    player_failed_update_selected_tracks: "Failed to update selected tracks" , "Не удалось обновить выбранные треки";
+    player_selected_tracks_updated: "Selected tracks updated"   , "Выбранные треки обновлены";
     player_choose_saved_or_add_torrent: "Choose a saved item or upload new files." , "Выберите сохранённый элемент или загрузите новые файлы.";
     player_local_files:      "Local audio files"               , "Локальные аудиофайлы";
     player_torrent_file:     "Torrent file"                    , "Torrent-файл";
@@ -414,6 +481,7 @@ translations! {
     player_seen:             "seen"                            , "видели";
     player_eta:              "eta"                             , "осталось";
     player_loading_history:  "Loading history..."              , "Загрузка истории...";
+    player_loading_more:     "Loading more..."                 , "Загружаю ещё...";
     player_failed_load_history: "Failed to load history"        , "Не удалось загрузить историю";
     player_total_plays:      "total plays"                     , "прослушиваний всего";
     player_play_history:     "Play history"                    , "История прослушиваний";

src/jobs/artwork_backfill.rs

@@ -15,12 +15,19 @@ pub struct ArtworkBackfillJob;
 const LASTFM_REQUEST_DELAY: std::time::Duration = std::time::Duration::from_millis(1200);
 const MAX_LASTFM_RELEASE_LOOKUPS: i64 = 200;
 const MAX_LASTFM_ARTIST_LOOKUPS: i64 = 200;
+const MAX_CAA_RELEASE_LOOKUPS: i64 = 200;
+
+#[derive(Debug, Clone, Copy)]
+pub struct ArtworkBackfillOptions {
+    pub overwrite_existing: bool,
+}
 
 #[derive(Debug, sqlx::FromRow)]
 struct ReleaseCandidate {
     id: i64,
     title: String,
     artist_name: Option<String>,
+    track_title: Option<String>,
 }
 
 #[derive(Debug, sqlx::FromRow)]
@@ -36,6 +43,13 @@ struct ArtworkRefCandidate {
     file_path: Option<String>,
 }
 
+#[derive(Debug, sqlx::FromRow)]
+struct ArtistImageRepairCandidate {
+    id: i64,
+    name: String,
+    media_file_id: i64,
+}
+
 #[derive(Debug, Deserialize)]
 struct LastfmAlbumResponse {
     album: Option<LastfmImageContainer>,
@@ -85,7 +99,10 @@ struct ArtworkStats {
     broken_release_refs_cleared: u64,
     broken_track_refs_cleared: u64,
     broken_artist_refs_cleared: u64,
+    remote_artist_album_fallback_refs_cleared: u64,
     release_local_assigned: u64,
+    release_caa_assigned: u64,
+    release_caa_not_found: u64,
     release_lastfm_assigned: u64,
     release_lastfm_not_found: u64,
     release_skipped_no_audio: u64,
@@ -114,66 +131,107 @@ impl Job for ArtworkBackfillJob {
     }
 
     async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
-        let storage_dir = ctx.config.agent_storage_dir.trim();
-        if storage_dir.is_empty() {
-            log.warn("agent_storage_dir is not configured, skipping artwork backfill");
-            return Ok(());
-        }
-
-        let client = Client::builder()
-            .user_agent(format!(
-                "furumusic-artwork-backfill/{}",
-                env!("CARGO_PKG_VERSION")
-            ))
-            .timeout(std::time::Duration::from_secs(20))
-            .build()?;
-        let mut stats = ArtworkStats::default();
-
-        let normalized_paths =
-            crate::media_paths::normalize_media_file_paths(&ctx.pool, storage_dir).await?;
-        if normalized_paths > 0 {
-            log.info(&format!(
-                "Media path normalization pass: rewrote {normalized_paths} media file path(s) to relative storage paths"
-            ));
-        } else {
-            log.info("Media path normalization pass: all media file paths are already relative");
-        }
-
-        repair_missing_artwork_refs(ctx, log, storage_dir, &mut stats).await?;
-        backfill_release_local(ctx, log, storage_dir, &mut stats).await?;
-
-        let api_key = ctx.config.lastfm_api_key.trim();
-        if api_key.is_empty() {
-            log.warn("lastfm_api_key is not configured; skipping Last.fm artwork fallback");
-        } else {
-            backfill_release_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?;
-            backfill_artist_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?;
-        }
-
-        backfill_artist_album_fallbacks(ctx, log, &mut stats).await?;
-        repair_cover_variants(ctx, log, storage_dir, &mut stats).await?;
-
-        log.info(&format!(
-            "Artwork backfill complete: broken_release_refs_cleared={}, broken_track_refs_cleared={}, broken_artist_refs_cleared={}, release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}",
-            stats.broken_release_refs_cleared,
-            stats.broken_track_refs_cleared,
-            stats.broken_artist_refs_cleared,
-            stats.release_local_assigned,
-            stats.release_lastfm_assigned,
-            stats.release_lastfm_not_found,
-            stats.release_skipped_no_audio,
-            stats.artist_lastfm_assigned,
-            stats.artist_lastfm_not_found,
-            stats.artist_album_fallback_assigned,
-            stats.variants_created,
-            stats.variants_unchanged,
-            stats.variants_missing_original,
-            stats.failed
-        ));
-        Ok(())
+        run_with_options(
+            ctx,
+            log,
+            ArtworkBackfillOptions {
+                overwrite_existing: false,
+            },
+        )
+        .await
     }
 }
 
+pub async fn run_with_options(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    options: ArtworkBackfillOptions,
+) -> anyhow::Result<()> {
+    let storage_dir = ctx.config.agent_storage_dir.trim();
+    if storage_dir.is_empty() {
+        log.warn("agent_storage_dir is not configured, skipping artwork backfill");
+        return Ok(());
+    }
+
+    log.info(&format!(
+        "Artwork backfill options: mode={}",
+        if options.overwrite_existing {
+            "overwrite_existing"
+        } else {
+            "missing_only"
+        }
+    ));
+
+    let client = Client::builder()
+        .user_agent(format!(
+            "furumusic-artwork-backfill/{}",
+            env!("CARGO_PKG_VERSION")
+        ))
+        .timeout(std::time::Duration::from_secs(20))
+        .build()?;
+    let musicbrainz_client =
+        crate::jobs::musicbrainz::MusicBrainzClient::new("furumusic-artwork-backfill")?;
+    let mut stats = ArtworkStats::default();
+
+    let normalized_paths =
+        crate::media_paths::normalize_media_file_paths(&ctx.pool, storage_dir).await?;
+    if normalized_paths > 0 {
+        log.info(&format!(
+            "Media path normalization pass: rewrote {normalized_paths} media file path(s) to relative storage paths"
+        ));
+    } else {
+        log.info("Media path normalization pass: all media file paths are already relative");
+    }
+
+    repair_missing_artwork_refs(ctx, log, storage_dir, &mut stats).await?;
+    repair_remote_artist_album_fallback_refs(ctx, log, &mut stats).await?;
+    backfill_release_local(ctx, log, storage_dir, options, &mut stats).await?;
+    backfill_release_coverartarchive(
+        ctx,
+        log,
+        storage_dir,
+        &musicbrainz_client,
+        options,
+        &mut stats,
+    )
+    .await?;
+
+    let api_key = ctx.config.lastfm_api_key.trim();
+    if api_key.is_empty() {
+        log.warn("lastfm_api_key is not configured; skipping Last.fm artwork fallback");
+    } else {
+        backfill_release_lastfm(ctx, log, storage_dir, api_key, &client, options, &mut stats)
+            .await?;
+        backfill_artist_lastfm(ctx, log, storage_dir, api_key, &client, options, &mut stats)
+            .await?;
+    }
+
+    backfill_artist_album_fallbacks(ctx, log, options, &mut stats).await?;
+    repair_cover_variants(ctx, log, storage_dir, &mut stats).await?;
+
+    log.info(&format!(
+        "Artwork backfill complete: broken_release_refs_cleared={}, broken_track_refs_cleared={}, broken_artist_refs_cleared={}, remote_artist_album_fallback_refs_cleared={}, release_local_assigned={}, release_caa_assigned={}, release_caa_not_found={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}",
+        stats.broken_release_refs_cleared,
+        stats.broken_track_refs_cleared,
+        stats.broken_artist_refs_cleared,
+        stats.remote_artist_album_fallback_refs_cleared,
+        stats.release_local_assigned,
+        stats.release_caa_assigned,
+        stats.release_caa_not_found,
+        stats.release_lastfm_assigned,
+        stats.release_lastfm_not_found,
+        stats.release_skipped_no_audio,
+        stats.artist_lastfm_assigned,
+        stats.artist_lastfm_not_found,
+        stats.artist_album_fallback_assigned,
+        stats.variants_created,
+        stats.variants_unchanged,
+        stats.variants_missing_original,
+        stats.failed
+    ));
+    Ok(())
+}
+
 async fn repair_missing_artwork_refs(
     ctx: &JobContext,
     log: &mut JobLog,
@@ -186,6 +244,71 @@ async fn repair_missing_artwork_refs(
     Ok(())
 }
 
+async fn repair_remote_artist_album_fallback_refs(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, ArtistImageRepairCandidate>(
+        r#"SELECT DISTINCT a.id,
+                  a.name::text AS name,
+                  a.image_file_id AS media_file_id
+             FROM furumusic__artist a
+             JOIN furumusic__media_file mf ON mf.id = a.image_file_id
+            WHERE a.image_file_id IS NOT NULL
+              AND a.is_hidden = false
+              AND mf.file_path NOT LIKE '%/__artist_image__/%'
+              AND EXISTS (
+                    SELECT 1
+                      FROM furumusic__release r
+                      JOIN furumusic__artwork_lookup_state s
+                        ON s.entity_kind = 'release'
+                       AND s.entity_id = r.id
+                       AND s.source IN ('lastfm', 'coverartarchive')
+                       AND s.status = 'found'
+                     WHERE r.cover_file_id = a.image_file_id
+                       AND r.is_hidden = false
+                  )
+            ORDER BY a.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if rows.is_empty() {
+        return Ok(());
+    }
+
+    log.info(&format!(
+        "Artist fallback repair pass: clearing {} remote release cover fallback(s)",
+        rows.len()
+    ));
+
+    for row in rows {
+        let result = sqlx::query(
+            r#"UPDATE furumusic__artist
+                  SET image_file_id = NULL,
+                      updated_at = $3
+                WHERE id = $1
+                  AND image_file_id = $2"#,
+        )
+        .bind(row.id)
+        .bind(row.media_file_id)
+        .bind(now_iso())
+        .execute(&ctx.pool)
+        .await?;
+
+        if result.rows_affected() > 0 {
+            stats.remote_artist_album_fallback_refs_cleared += 1;
+            log.warn(&format!(
+                "Artist {} \"{}\": cleared remote release cover fallback (media_file_id={})",
+                row.id, row.name, row.media_file_id
+            ));
+        }
+    }
+
+    Ok(())
+}
+
 async fn repair_missing_release_cover_refs(
     ctx: &JobContext,
     log: &mut JobLog,
@@ -360,6 +483,7 @@ async fn backfill_release_local(
     ctx: &JobContext,
     log: &mut JobLog,
     storage_dir: &str,
+    options: ArtworkBackfillOptions,
     stats: &mut ArtworkStats,
 ) -> anyhow::Result<()> {
     let releases = sqlx::query_as::<_, ReleaseCandidate>(
@@ -372,17 +496,26 @@ async fn backfill_release_local(
                      WHERE ra.release_id = r.id
                      ORDER BY ra.position
                      LIMIT 1
-                  ) AS artist_name
+                  ) AS artist_name,
+                  (
+                    SELECT t.title::text
+                      FROM furumusic__track t
+                     WHERE t.release_id = r.id
+                       AND t.is_hidden = false
+                     ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id
+                     LIMIT 1
+                  ) AS track_title
              FROM furumusic__release r
-            WHERE r.cover_file_id IS NULL
+            WHERE ($1 OR r.cover_file_id IS NULL)
               AND r.is_hidden = false
             ORDER BY r.id"#,
     )
+    .bind(options.overwrite_existing)
     .fetch_all(&ctx.pool)
     .await?;
 
     if releases.is_empty() {
-        log.info("Release local artwork pass: all visible releases already have covers");
+        log.info("Release local artwork pass: no eligible releases need local cover lookup");
         return Ok(());
     }
     log.info(&format!(
@@ -451,7 +584,7 @@ async fn backfill_release_local(
         .await
         {
             Ok(cover_file_id) => {
-                cover_art::assign_cover_to_release(&ctx.pool, release.id, cover_file_id).await?;
+                assign_cover_to_release(&ctx.pool, release.id, cover_file_id, options).await?;
                 stats.release_local_assigned += 1;
                 log.info(&format!(
                     "Release {} \"{}\": assigned local cover from {source_desc}",
@@ -471,12 +604,12 @@ async fn backfill_release_local(
     Ok(())
 }
 
-async fn backfill_release_lastfm(
+async fn backfill_release_coverartarchive(
     ctx: &JobContext,
     log: &mut JobLog,
     storage_dir: &str,
-    api_key: &str,
-    client: &Client,
+    client: &crate::jobs::musicbrainz::MusicBrainzClient,
+    options: ArtworkBackfillOptions,
     stats: &mut ArtworkStats,
 ) -> anyhow::Result<()> {
     let failed_cutoff = cutoff_iso(1);
@@ -502,25 +635,285 @@ async fn backfill_release_lastfm(
                        ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, ta.position
                        LIMIT 1
                     )
-                  ) AS artist_name
+                  ) AS artist_name,
+                  (
+                    SELECT t.title::text
+                      FROM furumusic__track t
+                     WHERE t.release_id = r.id
+                       AND t.is_hidden = false
+                     ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id
+                     LIMIT 1
+                  ) AS track_title
              FROM furumusic__release r
              LEFT JOIN furumusic__artwork_lookup_state s
                ON s.entity_kind = 'release'
               AND s.entity_id = r.id
-              AND s.source = 'lastfm'
-            WHERE r.cover_file_id IS NULL
+              AND s.source = 'coverartarchive'
+            WHERE ($3 OR r.cover_file_id IS NULL)
               AND r.is_hidden = false
               AND (
-                    s.entity_id IS NULL
+                    $3
+                 OR s.entity_id IS NULL
                  OR s.status = 'failed' AND s.last_attempt_at < $1
                  OR s.status = 'not_found' AND (s.attempt_count < 3 OR s.last_attempt_at < $2)
                  OR s.status = 'found' AND s.last_attempt_at < $1
               )
             ORDER BY s.last_attempt_at NULLS FIRST, r.id
-            LIMIT $3"#,
+            LIMIT $4"#,
     )
     .bind(&failed_cutoff)
     .bind(&not_found_cutoff)
+    .bind(options.overwrite_existing)
+    .bind(MAX_CAA_RELEASE_LOOKUPS)
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if releases.is_empty() {
+        log.info("Release Cover Art Archive pass: no eligible releases need lookup");
+        return Ok(());
+    }
+    log.info(&format!(
+        "Release Cover Art Archive pass: looking up {} release(s)",
+        releases.len()
+    ));
+
+    for (index, release) in releases.iter().enumerate() {
+        let Some(artist_name) = release
+            .artist_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+        else {
+            stats.release_caa_not_found += 1;
+            record_coverartarchive_lookup_state(
+                &ctx.pool,
+                "release",
+                release.id,
+                "not_found",
+                Some("release has no primary artist for MusicBrainz lookup"),
+                None,
+            )
+            .await?;
+            continue;
+        };
+
+        log.info(&format!(
+            "Release Cover Art Archive {}/{}: release {} \"{}\" by \"{}\"",
+            index + 1,
+            releases.len(),
+            release.id,
+            release.title,
+            artist_name
+        ));
+
+        let release_mbid = crate::jobs::musicbrainz::load_or_search_release_mbid(
+            &ctx.pool,
+            client,
+            release.id,
+            artist_name,
+            &release.title,
+            release.track_title.as_deref(),
+        )
+        .await;
+        let (release_mbid, release_group_mbid) = match release_mbid {
+            Ok(value) => value,
+            Err(err) => {
+                stats.failed += 1;
+                record_coverartarchive_lookup_state(
+                    &ctx.pool,
+                    "release",
+                    release.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.warn(&format!(
+                    "Release {} \"{}\": MusicBrainz lookup for cover art failed: {err}",
+                    release.id, release.title
+                ));
+                continue;
+            }
+        };
+
+        if release_mbid.is_none() && release_group_mbid.is_none() {
+            stats.release_caa_not_found += 1;
+            record_coverartarchive_lookup_state(
+                &ctx.pool,
+                "release",
+                release.id,
+                "not_found",
+                Some("MusicBrainz release match not found"),
+                None,
+            )
+            .await?;
+            continue;
+        }
+
+        match client
+            .fetch_cover_art_front_url(release_mbid.as_deref(), release_group_mbid.as_deref())
+            .await
+        {
+            Ok(Some(image_url)) => {
+                match download_remote_cover(client.http_client(), &image_url).await {
+                    Ok(cover) => match cover_art::save_cover_to_storage(
+                        &ctx.db,
+                        &ctx.pool,
+                        storage_dir,
+                        artist_name,
+                        &release.title,
+                        &cover,
+                    )
+                    .await
+                    {
+                        Ok(cover_file_id) => {
+                            assign_cover_to_release(&ctx.pool, release.id, cover_file_id, options)
+                                .await?;
+                            record_coverartarchive_lookup_state(
+                                &ctx.pool,
+                                "release",
+                                release.id,
+                                "found",
+                                None,
+                                Some(&image_url),
+                            )
+                            .await?;
+                            stats.release_caa_assigned += 1;
+                            log.info(&format!(
+                                "Release {} \"{}\": assigned Cover Art Archive cover",
+                                release.id, release.title
+                            ));
+                        }
+                        Err(err) => {
+                            stats.failed += 1;
+                            record_coverartarchive_lookup_state(
+                                &ctx.pool,
+                                "release",
+                                release.id,
+                                "failed",
+                                Some(&err.to_string()),
+                                Some(&image_url),
+                            )
+                            .await?;
+                            log.warn(&format!(
+                                "Release {} \"{}\": failed to save Cover Art Archive cover: {err}",
+                                release.id, release.title
+                            ));
+                        }
+                    },
+                    Err(err) => {
+                        stats.failed += 1;
+                        record_coverartarchive_lookup_state(
+                            &ctx.pool,
+                            "release",
+                            release.id,
+                            "failed",
+                            Some(&err.to_string()),
+                            Some(&image_url),
+                        )
+                        .await?;
+                        log.warn(&format!(
+                            "Release {} \"{}\": failed to download Cover Art Archive cover: {err}",
+                            release.id, release.title
+                        ));
+                    }
+                }
+            }
+            Ok(None) => {
+                stats.release_caa_not_found += 1;
+                record_coverartarchive_lookup_state(
+                    &ctx.pool,
+                    "release",
+                    release.id,
+                    "not_found",
+                    None,
+                    None,
+                )
+                .await?;
+            }
+            Err(err) => {
+                stats.failed += 1;
+                record_coverartarchive_lookup_state(
+                    &ctx.pool,
+                    "release",
+                    release.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.warn(&format!(
+                    "Release {} \"{}\": Cover Art Archive lookup failed: {err}",
+                    release.id, release.title
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn backfill_release_lastfm(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    api_key: &str,
+    client: &Client,
+    options: ArtworkBackfillOptions,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let failed_cutoff = cutoff_iso(1);
+    let not_found_cutoff = cutoff_iso(30);
+    let releases = sqlx::query_as::<_, ReleaseCandidate>(
+        r#"SELECT r.id,
+                  r.title::text AS title,
+                  COALESCE(
+                    (
+                      SELECT a.name::text
+                        FROM furumusic__release_artist ra
+                        JOIN furumusic__artist a ON a.id = ra.artist_id
+                       WHERE ra.release_id = r.id
+                       ORDER BY ra.position
+                       LIMIT 1
+                    ),
+                    (
+                      SELECT a.name::text
+                        FROM furumusic__track t
+                        JOIN furumusic__track_artist ta ON ta.track_id = t.id
+                        JOIN furumusic__artist a ON a.id = ta.artist_id
+                       WHERE t.release_id = r.id AND ta.role <> 'featuring'
+                       ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, ta.position
+                       LIMIT 1
+                    )
+                  ) AS artist_name,
+                  (
+                    SELECT t.title::text
+                      FROM furumusic__track t
+                     WHERE t.release_id = r.id
+                       AND t.is_hidden = false
+                     ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id
+                     LIMIT 1
+                  ) AS track_title
+             FROM furumusic__release r
+             LEFT JOIN furumusic__artwork_lookup_state s
+               ON s.entity_kind = 'release'
+              AND s.entity_id = r.id
+              AND s.source = 'lastfm'
+            WHERE ($3 OR r.cover_file_id IS NULL)
+              AND r.is_hidden = false
+              AND (
+                    $3
+                 OR s.entity_id IS NULL
+                 OR s.status = 'failed' AND s.last_attempt_at < $1
+                 OR s.status = 'not_found' AND (s.attempt_count < 3 OR s.last_attempt_at < $2)
+                 OR s.status = 'found' AND s.last_attempt_at < $1
+              )
+            ORDER BY s.last_attempt_at NULLS FIRST, r.id
+            LIMIT $4"#,
+    )
+    .bind(&failed_cutoff)
+    .bind(&not_found_cutoff)
+    .bind(options.overwrite_existing)
     .bind(MAX_LASTFM_RELEASE_LOOKUPS)
     .fetch_all(&ctx.pool)
     .await?;
@@ -580,7 +973,7 @@ async fn backfill_release_lastfm(
                 .await
                 {
                     Ok(cover_file_id) => {
-                        cover_art::assign_cover_to_release(&ctx.pool, release.id, cover_file_id)
+                        assign_cover_to_release(&ctx.pool, release.id, cover_file_id, options)
                             .await?;
                         record_lookup_state(
                             &ctx.pool,
@@ -680,12 +1073,37 @@ async fn backfill_release_lastfm(
     Ok(())
 }
 
+async fn assign_cover_to_release(
+    pool: &sqlx::PgPool,
+    release_id: i64,
+    cover_file_id: i64,
+    options: ArtworkBackfillOptions,
+) -> anyhow::Result<()> {
+    if options.overwrite_existing {
+        sqlx::query(
+            r#"UPDATE furumusic__release
+                  SET cover_file_id = $1,
+                      updated_at = $3
+                WHERE id = $2"#,
+        )
+        .bind(cover_file_id)
+        .bind(release_id)
+        .bind(now_iso())
+        .execute(pool)
+        .await?;
+    } else {
+        cover_art::assign_cover_to_release(pool, release_id, cover_file_id).await?;
+    }
+    Ok(())
+}
+
 async fn backfill_artist_lastfm(
     ctx: &JobContext,
     log: &mut JobLog,
     storage_dir: &str,
     api_key: &str,
     client: &Client,
+    options: ArtworkBackfillOptions,
     stats: &mut ArtworkStats,
 ) -> anyhow::Result<()> {
     let failed_cutoff = cutoff_iso(1);
@@ -699,21 +1117,25 @@ async fn backfill_artist_lastfm(
               AND s.entity_id = a.id
               AND s.source = 'lastfm'
             WHERE (
+                    $3
+                 OR
                     a.image_file_id IS NULL
                  OR mf.file_path NOT LIKE '%/__artist_image__/%'
                   )
               AND a.is_hidden = false
               AND (
-                    s.entity_id IS NULL
+                    $3
+                 OR s.entity_id IS NULL
                  OR s.status = 'failed' AND s.last_attempt_at < $1
                  OR s.status = 'not_found' AND (s.attempt_count < 3 OR s.last_attempt_at < $2)
                  OR s.status = 'found' AND s.last_attempt_at < $1
               )
             ORDER BY s.last_attempt_at NULLS FIRST, a.id
-            LIMIT $3"#,
+            LIMIT $4"#,
     )
     .bind(&failed_cutoff)
     .bind(&not_found_cutoff)
+    .bind(options.overwrite_existing)
     .bind(MAX_LASTFM_ARTIST_LOOKUPS)
     .fetch_all(&ctx.pool)
     .await?;
@@ -755,6 +1177,8 @@ async fn backfill_artist_lastfm(
                                           updated_at = $3
                                     WHERE id = $2
                                       AND (
+                                            $4
+                                         OR
                                             image_file_id IS NULL
                                          OR EXISTS (
                                                 SELECT 1
@@ -767,6 +1191,7 @@ async fn backfill_artist_lastfm(
                         .bind(image_file_id)
                         .bind(artist.id)
                         .bind(now_iso())
+                        .bind(options.overwrite_existing)
                         .execute(&ctx.pool)
                         .await?;
                         record_lookup_state(
@@ -826,7 +1251,7 @@ async fn backfill_artist_lastfm(
                     artist.id, artist.name
                 ));
                 stats.artist_lastfm_not_found += 1;
-                match assign_artist_album_fallback(ctx, artist.id).await {
+                match assign_artist_album_fallback(ctx, artist.id, options).await {
                     Ok(Some(media_file_id)) => {
                         stats.artist_album_fallback_assigned += 1;
                         log.info(&format!(
@@ -892,31 +1317,53 @@ async fn backfill_artist_lastfm(
 async fn backfill_artist_album_fallbacks(
     ctx: &JobContext,
     log: &mut JobLog,
+    options: ArtworkBackfillOptions,
     stats: &mut ArtworkStats,
 ) -> anyhow::Result<()> {
     let artists = sqlx::query_as::<_, ArtistCandidate>(
         r#"SELECT a.id, a.name::text AS name
              FROM furumusic__artist a
-            WHERE a.image_file_id IS NULL
+            WHERE ($1 OR a.image_file_id IS NULL)
               AND a.is_hidden = false
               AND EXISTS (
                     SELECT 1
                       FROM furumusic__release_artist ra
                       JOIN furumusic__release r ON r.id = ra.release_id
+                      JOIN furumusic__media_file mf ON mf.id = r.cover_file_id
                      WHERE ra.artist_id = a.id
                        AND r.cover_file_id IS NOT NULL
+                       AND mf.file_type = 'cover_art'
                        AND r.is_hidden = false
+                       AND NOT EXISTS (
+                            SELECT 1
+                              FROM furumusic__artwork_lookup_state s
+                             WHERE s.entity_kind = 'release'
+                               AND s.entity_id = r.id
+                               AND s.source IN ('lastfm', 'coverartarchive')
+                               AND s.status = 'found'
+                       )
                     UNION
                     SELECT 1
                       FROM furumusic__track_artist ta
                       JOIN furumusic__track t ON t.id = ta.track_id
                       JOIN furumusic__release r ON r.id = t.release_id
+                      JOIN furumusic__media_file mf ON mf.id = r.cover_file_id
                      WHERE ta.artist_id = a.id
                        AND r.cover_file_id IS NOT NULL
+                       AND mf.file_type = 'cover_art'
                        AND r.is_hidden = false
+                       AND NOT EXISTS (
+                            SELECT 1
+                              FROM furumusic__artwork_lookup_state s
+                             WHERE s.entity_kind = 'release'
+                               AND s.entity_id = r.id
+                               AND s.source IN ('lastfm', 'coverartarchive')
+                               AND s.status = 'found'
+                       )
                   )
             ORDER BY a.id"#,
     )
+    .bind(options.overwrite_existing)
     .fetch_all(&ctx.pool)
     .await?;
 
@@ -931,7 +1378,7 @@ async fn backfill_artist_album_fallbacks(
     ));
 
     for artist in artists {
-        match assign_artist_album_fallback(ctx, artist.id).await {
+        match assign_artist_album_fallback(ctx, artist.id, options).await {
             Ok(Some(media_file_id)) => {
                 stats.artist_album_fallback_assigned += 1;
                 log.info(&format!(
@@ -1016,6 +1463,7 @@ async fn repair_cover_variants(
 async fn assign_artist_album_fallback(
     ctx: &JobContext,
     artist_id: i64,
+    options: ArtworkBackfillOptions,
 ) -> anyhow::Result<Option<i64>> {
     let media_file_id: Option<i64> = sqlx::query_scalar(
         r#"SELECT media_file_id
@@ -1023,17 +1471,37 @@ async fn assign_artist_album_fallback(
                     SELECT DISTINCT r.cover_file_id AS media_file_id
                       FROM furumusic__release r
                       JOIN furumusic__release_artist ra ON ra.release_id = r.id
+                      JOIN furumusic__media_file mf ON mf.id = r.cover_file_id
                      WHERE ra.artist_id = $1
                        AND r.cover_file_id IS NOT NULL
+                       AND mf.file_type = 'cover_art'
                        AND r.is_hidden = false
+                       AND NOT EXISTS (
+                            SELECT 1
+                              FROM furumusic__artwork_lookup_state s
+                             WHERE s.entity_kind = 'release'
+                               AND s.entity_id = r.id
+                               AND s.source IN ('lastfm', 'coverartarchive')
+                               AND s.status = 'found'
+                       )
                     UNION
                     SELECT DISTINCT r.cover_file_id AS media_file_id
                       FROM furumusic__release r
                       JOIN furumusic__track t ON t.release_id = r.id
                       JOIN furumusic__track_artist ta ON ta.track_id = t.id
+                      JOIN furumusic__media_file mf ON mf.id = r.cover_file_id
                      WHERE ta.artist_id = $1
                        AND r.cover_file_id IS NOT NULL
+                       AND mf.file_type = 'cover_art'
                        AND r.is_hidden = false
+                       AND NOT EXISTS (
+                            SELECT 1
+                              FROM furumusic__artwork_lookup_state s
+                             WHERE s.entity_kind = 'release'
+                               AND s.entity_id = r.id
+                               AND s.source IN ('lastfm', 'coverartarchive')
+                               AND s.status = 'found'
+                       )
                   ) covers
             ORDER BY random()
             LIMIT 1"#,
@@ -1051,11 +1519,12 @@ async fn assign_artist_album_fallback(
               SET image_file_id = $1,
                   updated_at = $3
             WHERE id = $2
-              AND image_file_id IS NULL"#,
+              AND ($4 OR image_file_id IS NULL)"#,
     )
     .bind(media_file_id)
     .bind(artist_id)
     .bind(now_iso())
+    .bind(options.overwrite_existing)
     .execute(&ctx.pool)
     .await?;
 
@@ -1324,6 +1793,36 @@ async fn record_lookup_state(
     Ok(())
 }
 
+async fn record_coverartarchive_lookup_state(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    status: &str,
+    error: Option<&str>,
+    source_url: Option<&str>,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"INSERT INTO furumusic__artwork_lookup_state
+              (entity_kind, entity_id, source, status, attempt_count, last_attempt_at, last_error, source_url)
+           VALUES ($1, $2, 'coverartarchive', $3, 1, $4, $5, $6)
+           ON CONFLICT (entity_kind, entity_id, source) DO UPDATE SET
+              status = EXCLUDED.status,
+              attempt_count = furumusic__artwork_lookup_state.attempt_count + 1,
+              last_attempt_at = EXCLUDED.last_attempt_at,
+              last_error = EXCLUDED.last_error,
+              source_url = EXCLUDED.source_url"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .bind(status)
+    .bind(now_iso())
+    .bind(error)
+    .bind(source_url)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
 async fn reset_lookup_state(
     pool: &sqlx::PgPool,
     entity_kind: &str,
@@ -1333,7 +1832,7 @@ async fn reset_lookup_state(
         r#"DELETE FROM furumusic__artwork_lookup_state
             WHERE entity_kind = $1
               AND entity_id = $2
-              AND source = 'lastfm'"#,
+              AND source IN ('lastfm', 'coverartarchive')"#,
     )
     .bind(entity_kind)
     .bind(entity_id)

src/jobs/inbox_discover.rs

@@ -29,6 +29,8 @@ impl Job for InboxDiscoverJob {
     }
 
     async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        let run_start = std::time::Instant::now();
+        let run_outcome = "completed";
         // Prevent overlapping discover runs
         if DISCOVER_RUNNING
             .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
@@ -44,6 +46,19 @@ impl Job for InboxDiscoverJob {
             }
         }
         let _guard = Guard;
+        struct MetricsGuard {
+            start: std::time::Instant,
+            outcome: &'static str,
+        }
+        impl Drop for MetricsGuard {
+            fn drop(&mut self) {
+                crate::metrics::record_agent_discover_run(self.outcome, self.start.elapsed());
+            }
+        }
+        let mut metrics_guard = MetricsGuard {
+            start: run_start,
+            outcome: run_outcome,
+        };
 
         let config = &ctx.config;
 
@@ -97,6 +112,7 @@ impl Job for InboxDiscoverJob {
 
                 // Compute SHA-256 hash
                 let path_clone = file_path.to_path_buf();
+                let hash_start = std::time::Instant::now();
                 let (hash, file_size) =
                     match tokio::task::spawn_blocking(move || -> anyhow::Result<(String, i64)> {
                         let data = std::fs::read(&path_clone)?;
@@ -107,8 +123,12 @@ impl Job for InboxDiscoverJob {
                     })
                     .await?
                     {
-                        Ok(v) => v,
+                        Ok(v) => {
+                            crate::metrics::record_agent_file_hash(hash_start.elapsed(), v.1, "ok");
+                            v
+                        }
                         Err(e) => {
+                            crate::metrics::record_agent_file_hash(hash_start.elapsed(), 0, "error");
                             log.warn(&format!("Failed to hash {}: {e}", file_path.display()));
                             continue;
                         }
@@ -125,13 +145,18 @@ impl Job for InboxDiscoverJob {
 
                 // Extract raw metadata
                 let path_for_meta = file_path.to_path_buf();
+                let metadata_start = std::time::Instant::now();
                 let raw_meta = match tokio::task::spawn_blocking(move || {
                     crate::agent::metadata::extract(&path_for_meta)
                 })
                 .await?
                 {
-                    Ok(m) => m,
+                    Ok(m) => {
+                        crate::metrics::record_agent_metadata(metadata_start.elapsed(), "ok");
+                        m
+                    }
                     Err(e) => {
+                        crate::metrics::record_agent_metadata(metadata_start.elapsed(), "error");
                         log.warn(&format!(
                             "Failed to extract metadata from {}: {e}",
                             file_path.display()
@@ -189,6 +214,12 @@ impl Job for InboxDiscoverJob {
             "Discovered {} new files, skipped {} (hash known), skipped {} (already queued)",
             discovered, skipped_hash, skipped_existing
         ));
+        crate::metrics::record_agent_discover_files(
+            audio_files.len() as u64,
+            discovered,
+            skipped_hash,
+            skipped_existing,
+        );
 
         // Trigger inbox_process in background if new files were discovered
         // and no orchestrator is already running
@@ -219,6 +250,7 @@ impl Job for InboxDiscoverJob {
             }
         }
 
+        metrics_guard.outcome = run_outcome;
         Ok(())
     }
 }

src/jobs/inbox_process.rs

@@ -17,28 +17,99 @@ pub fn is_orchestrator_running() -> bool {
     ORCHESTRATOR_RUNNING.load(Ordering::SeqCst)
 }
 
-/// Try to acquire the PostgreSQL advisory lock for the orchestrator.
-/// Returns true if the lock was acquired (no other orchestrator is running).
-async fn try_acquire_orchestrator_lock(pool: &sqlx::PgPool) -> bool {
-    match sqlx::query_scalar::<_, bool>("SELECT pg_try_advisory_lock($1)")
-        .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
-        .fetch_one(pool)
-        .await
-    {
-        Ok(acquired) => acquired,
-        Err(e) => {
-            tracing::error!("Failed to acquire advisory lock: {e}");
-            false
-        }
+struct OrchestratorAdvisoryGuard {
+    conn: Option<sqlx::pool::PoolConnection<sqlx::Postgres>>,
+}
+
+impl Drop for OrchestratorAdvisoryGuard {
+    fn drop(&mut self) {
+        let Some(mut conn) = self.conn.take() else {
+            return;
+        };
+
+        tokio::spawn(async move {
+            match sqlx::query_scalar::<_, bool>("SELECT pg_advisory_unlock($1)")
+                .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
+                .fetch_one(&mut *conn)
+                .await
+            {
+                Ok(true) => tracing::info!("inbox_process: advisory lock released"),
+                Ok(false) => tracing::warn!(
+                    "inbox_process: advisory lock was not held by the guard connection"
+                ),
+                Err(e) => tracing::error!("inbox_process: failed to release advisory lock: {e}"),
+            }
+        });
     }
 }
 
-/// Release the PostgreSQL advisory lock for the orchestrator.
-async fn release_orchestrator_lock(pool: &sqlx::PgPool) {
-    let _ = sqlx::query("SELECT pg_advisory_unlock($1)")
+async fn connection_holds_orchestrator_lock(
+    conn: &mut sqlx::pool::PoolConnection<sqlx::Postgres>,
+) -> anyhow::Result<bool> {
+    let holds_lock = sqlx::query_scalar::<_, bool>(
+        r#"
+        SELECT EXISTS (
+            SELECT 1
+            FROM pg_locks
+            WHERE locktype = 'advisory'
+              AND pid = pg_backend_pid()
+              AND mode = 'ExclusiveLock'
+              AND granted
+              AND objsubid = 1
+              AND classid::bigint = (($1::bigint >> 32) & 4294967295::bigint)
+              AND objid::bigint = ($1::bigint & 4294967295::bigint)
+        )
+        "#,
+    )
+    .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
+    .fetch_one(&mut **conn)
+    .await?;
+
+    Ok(holds_lock)
+}
+
+/// Try to acquire the PostgreSQL advisory lock for the orchestrator.
+///
+/// The guard owns the same pooled connection that acquired the session-level
+/// lock. This matters because PostgreSQL session advisory locks must be
+/// released on the same connection, not just through the same pool.
+async fn try_acquire_orchestrator_lock(
+    pool: &sqlx::PgPool,
+) -> anyhow::Result<Option<OrchestratorAdvisoryGuard>> {
+    let mut conn = pool.acquire().await?;
+
+    // Older versions acquired the lock through the pool and could return a
+    // locked idle connection. If we get such a connection, drain that stale
+    // re-entrant lock before taking the new guarded lock.
+    let mut cleaned_stale_locks = 0u8;
+    while connection_holds_orchestrator_lock(&mut conn).await? {
+        let unlocked = sqlx::query_scalar::<_, bool>("SELECT pg_advisory_unlock($1)")
+            .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
+            .fetch_one(&mut *conn)
+            .await?;
+
+        cleaned_stale_locks = cleaned_stale_locks.saturating_add(u8::from(unlocked));
+        if cleaned_stale_locks >= 8 {
+            break;
+        }
+    }
+    if cleaned_stale_locks > 0 {
+        tracing::warn!(
+            count = cleaned_stale_locks,
+            "inbox_process: released stale advisory lock(s) from an idle pooled connection"
+        );
+    }
+
+    let acquired = sqlx::query_scalar::<_, bool>("SELECT pg_try_advisory_lock($1)")
         .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
-        .execute(pool)
-        .await;
+        .fetch_one(&mut *conn)
+        .await?;
+
+    if acquired {
+        Ok(Some(OrchestratorAdvisoryGuard { conn: Some(conn) }))
+    } else {
+        Ok(None)
+    }
 }
 
 use crate::agent::dto::{FolderContext, NormalizedFields, PathHints, RawMetadata};
@@ -83,10 +154,10 @@ impl Job for InboxProcessJob {
             .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
             .is_err()
         {
-            log.info(
+            log.warn(
                 "Another inbox_process orchestrator is already running (AtomicBool), skipping",
             );
-            return Ok(());
+            anyhow::bail!("another inbox_process orchestrator is already running in this process");
         }
         struct AtomicGuard;
         impl Drop for AtomicGuard {
@@ -98,27 +169,16 @@ impl Job for InboxProcessJob {
         let _atomic_guard = AtomicGuard;
 
         // --- Guard 2: PostgreSQL advisory lock (cross-process/binary safe) ---
-        if !try_acquire_orchestrator_lock(&ctx.pool).await {
-            log.info("Another inbox_process orchestrator holds the advisory lock, skipping");
-            return Ok(());
-        }
-        tracing::info!("inbox_process: advisory lock acquired");
-        let pool_for_unlock = ctx.pool.clone();
-        struct AdvisoryGuard {
-            pool: sqlx::PgPool,
-        }
-        impl Drop for AdvisoryGuard {
-            fn drop(&mut self) {
-                let pool = self.pool.clone();
-                tokio::spawn(async move {
-                    release_orchestrator_lock(&pool).await;
-                    tracing::info!("inbox_process: advisory lock released");
-                });
+        let _advisory_guard = match try_acquire_orchestrator_lock(&ctx.pool).await? {
+            Some(guard) => guard,
+            None => {
+                log.warn("Another inbox_process orchestrator holds the advisory lock");
+                anyhow::bail!(
+                    "inbox_process advisory lock is held by another database session; no in-process orchestrator is running"
+                );
             }
-        }
-        let _advisory_guard = AdvisoryGuard {
-            pool: pool_for_unlock,
         };
+        tracing::info!("inbox_process: advisory lock acquired");
 
         let config = Arc::clone(&ctx.config);
         let mut total_ok = 0u64;
@@ -307,12 +367,18 @@ async fn process_folder_batch(
 
         // Extract metadata (with 60s timeout)
         let path_for_meta = file_path.to_path_buf();
+        let metadata_start = std::time::Instant::now();
         let meta_future =
             tokio::task::spawn_blocking(move || crate::agent::metadata::extract(&path_for_meta));
         let raw_meta =
             match tokio::time::timeout(std::time::Duration::from_secs(60), meta_future).await {
-                Ok(Ok(Ok(m))) => m,
+                Ok(Ok(Ok(m))) => {
+                    crate::metrics::record_agent_metadata(metadata_start.elapsed(), "ok");
+                    m
+                }
                 Ok(Ok(Err(e))) => {
+                    crate::metrics::record_agent_metadata(metadata_start.elapsed(), "error");
+                    crate::metrics::record_agent_failed("metadata");
                     let msg = format!("{filename}: metadata error: {e}");
                     log.error(&msg);
                     let _ = review.set_failed(db, &msg).await;
@@ -320,6 +386,8 @@ async fn process_folder_batch(
                     continue;
                 }
                 Ok(Err(e)) => {
+                    crate::metrics::record_agent_metadata(metadata_start.elapsed(), "panic");
+                    crate::metrics::record_agent_failed("metadata");
                     let msg = format!("{filename}: metadata panic: {e}");
                     log.error(&msg);
                     let _ = review.set_failed(db, &msg).await;
@@ -327,6 +395,8 @@ async fn process_folder_batch(
                     continue;
                 }
                 Err(_) => {
+                    crate::metrics::record_agent_metadata(metadata_start.elapsed(), "timeout");
+                    crate::metrics::record_agent_failed("metadata");
                     let msg = format!("{filename}: metadata timeout (60s)");
                     log.error(&msg);
                     let _ = review.set_failed(db, &msg).await;
@@ -416,6 +486,7 @@ async fn process_folder_batch(
     // Lookup all unique artist queries
     let mut all_similar_artists = Vec::new();
     for q in &artist_queries {
+        let rag_start = std::time::Instant::now();
         match tokio::time::timeout(
             std::time::Duration::from_secs(30),
             crate::agent::rag::find_similar_artists(pool, q, 5),
@@ -423,6 +494,7 @@ async fn process_folder_batch(
         .await
         {
             Ok(Ok(results)) => {
+                crate::metrics::record_agent_rag("artist", "ok", rag_start.elapsed(), results.len());
                 for a in results {
                     if !all_similar_artists
                         .iter()
@@ -432,13 +504,20 @@ async fn process_folder_batch(
                     }
                 }
             }
-            Ok(Err(e)) => log.warn(&format!("RAG artist lookup failed for \"{q}\": {e}")),
-            Err(_) => log.warn(&format!("RAG artist lookup timed out for \"{q}\"")),
+            Ok(Err(e)) => {
+                crate::metrics::record_agent_rag("artist", "error", rag_start.elapsed(), 0);
+                log.warn(&format!("RAG artist lookup failed for \"{q}\": {e}"))
+            }
+            Err(_) => {
+                crate::metrics::record_agent_rag("artist", "timeout", rag_start.elapsed(), 0);
+                log.warn(&format!("RAG artist lookup timed out for \"{q}\""))
+            }
         }
     }
 
     let mut all_similar_releases = Vec::new();
     for q in &album_queries {
+        let rag_start = std::time::Instant::now();
         match tokio::time::timeout(
             std::time::Duration::from_secs(30),
             crate::agent::rag::find_similar_releases(pool, q, 5),
@@ -446,6 +525,7 @@ async fn process_folder_batch(
         .await
         {
             Ok(Ok(results)) => {
+                crate::metrics::record_agent_rag("release", "ok", rag_start.elapsed(), results.len());
                 for r in results {
                     if !all_similar_releases
                         .iter()
@@ -455,8 +535,14 @@ async fn process_folder_batch(
                     }
                 }
             }
-            Ok(Err(e)) => log.warn(&format!("RAG release lookup failed for \"{q}\": {e}")),
-            Err(_) => log.warn(&format!("RAG release lookup timed out for \"{q}\"")),
+            Ok(Err(e)) => {
+                crate::metrics::record_agent_rag("release", "error", rag_start.elapsed(), 0);
+                log.warn(&format!("RAG release lookup failed for \"{q}\": {e}"))
+            }
+            Err(_) => {
+                crate::metrics::record_agent_rag("release", "timeout", rag_start.elapsed(), 0);
+                log.warn(&format!("RAG release lookup timed out for \"{q}\""))
+            }
         }
     }
 
@@ -547,11 +633,14 @@ async fn process_folder_batch(
     let batch_result = match llm_result {
         Ok(r) => r,
         Err(e) => {
+            crate::metrics::record_agent_failed("llm");
+            crate::metrics::record_agent_folder_batch("failed", file_count, batch_start.elapsed());
             let err_msg = format!("Batch LLM call failed: {e}");
             log.error(&err_msg);
             // Mark all files as failed
             for mut p in prepared {
                 let _ = p.review.set_failed(db, &err_msg).await;
+                crate::metrics::record_agent_file_processed("failed", "failed");
             }
             let total_fail_count = failed_reviews.len() as u64 + file_count as u64;
             let duration_ms = batch_start.elapsed().as_millis() as i64;
@@ -612,6 +701,7 @@ async fn process_folder_batch(
 
         let result_json = serde_json::to_string(normalized).unwrap_or_default();
         let confidence = normalized.confidence.unwrap_or(0.0);
+        crate::metrics::observe_agent_confidence(confidence);
 
         let feat = if normalized.featured_artists.is_empty() {
             String::new()
@@ -655,9 +745,12 @@ async fn process_folder_batch(
             {
                 Ok(()) => {
                     let _ = p.review.set_auto_approved(db).await;
+                    crate::metrics::record_agent_file_processed("ok", "auto_approved");
                     ok_count += 1;
                 }
                 Err(e) => {
+                    crate::metrics::record_agent_failed("finalize");
+                    crate::metrics::record_agent_file_processed("failed", "failed");
                     let msg = format!("{filename}: finalize failed: {e}");
                     log.error(&msg);
                     let _ = p.review.set_failed(db, &msg).await;
@@ -671,6 +764,7 @@ async fn process_folder_batch(
             )
             .unwrap();
             let _ = p.review.save(db).await;
+            crate::metrics::record_agent_file_processed("ok", "pending_review");
             log.info(&format!(
                 "{filename}: manual review (confidence {confidence} < {})",
                 config.agent_confidence_threshold,
@@ -682,9 +776,11 @@ async fn process_folder_batch(
     let duration_ms = batch_start.elapsed().as_millis() as i64;
     if fail_count == 0 {
         let _ = run.set_completed(db, duration_ms, &log.output()).await;
+        crate::metrics::record_agent_folder_batch("completed", file_count, batch_start.elapsed());
     } else {
         let msg = format!("{fail_count} file(s) failed");
         let _ = run.set_failed(db, duration_ms, &log.output(), &msg).await;
+        crate::metrics::record_agent_folder_batch("failed", file_count, batch_start.elapsed());
     }
 
     (ok_count, fail_count)

src/jobs/metadata_backfill.rs

@@ -15,6 +15,7 @@ pub struct MetadataBackfillOptions {
     pub duration_seconds: bool,
     pub local_genres: bool,
     pub lastfm_tags: bool,
+    pub musicbrainz_tags: bool,
     pub overwrite: bool,
 }
 
@@ -26,6 +27,7 @@ impl MetadataBackfillOptions {
             || self.duration_seconds
             || self.local_genres
             || self.lastfm_tags
+            || self.musicbrainz_tags
     }
 
     fn needs_file_scan(self) -> bool {
@@ -59,6 +61,7 @@ struct LastfmReleaseTagRow {
     id: i64,
     title: String,
     artist_name: Option<String>,
+    track_title: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]
@@ -84,6 +87,22 @@ struct LastfmTagStats {
     failed: u64,
 }
 
+#[derive(Debug, Default)]
+struct MusicBrainzTagStats {
+    considered: u64,
+    updated_entities: u64,
+    tags_saved: u64,
+    skipped_existing: u64,
+    not_found: u64,
+    failed: u64,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum LastfmTagPassResult {
+    Completed,
+    RateLimited,
+}
+
 pub struct MetadataBackfillJob;
 
 #[async_trait::async_trait]
@@ -111,6 +130,7 @@ impl Job for MetadataBackfillJob {
                 duration_seconds: true,
                 local_genres: true,
                 lastfm_tags: true,
+                musicbrainz_tags: true,
                 overwrite: false,
             },
         )
@@ -137,10 +157,11 @@ pub async fn run_with_options(
     let mut failed = 0u64;
 
     log.info(&format!(
-        "Metadata backfill options: file_scan={}, local_genres={}, lastfm_tags={}, mode={}",
+        "Metadata backfill options: file_scan={}, local_genres={}, lastfm_tags={}, musicbrainz_tags={}, mode={}",
         options.needs_file_scan(),
         options.local_genres,
         options.lastfm_tags,
+        options.musicbrainz_tags,
         if options.overwrite {
             "overwrite"
         } else {
@@ -245,14 +266,9 @@ pub async fn run_with_options(
             let mut changed_tags = false;
             if options.local_genres {
                 if let (Some(track_id), Some(genre)) = (row.track_id, raw_meta.genre.as_deref()) {
-                    let saved = save_track_tag_text(
-                        &ctx.pool,
-                        track_id,
-                        genre,
-                        "file",
-                        options.overwrite,
-                    )
-                    .await?;
+                    let saved =
+                        save_track_tag_text(&ctx.pool, track_id, genre, "file", options.overwrite)
+                            .await?;
                     if saved > 0 {
                         local_tags_updated += saved;
                         changed_tags = true;
@@ -306,14 +322,28 @@ pub async fn run_with_options(
         LastfmTagStats::default()
     };
 
+    let musicbrainz_stats = if options.musicbrainz_tags {
+        log.info("Starting MusicBrainz tag backfill");
+        backfill_musicbrainz_tags(ctx, log, options.overwrite).await?
+    } else {
+        log.info("MusicBrainz tag backfill disabled for this run");
+        MusicBrainzTagStats::default()
+    };
+
     log.info(&format!(
-        "Metadata backfill complete: {scanned} scanned, {media_updated} media updated, {track_updated} tracks updated, {local_tags_updated} local tags saved, {unchanged} unchanged, {missing} missing, {failed} failed; Last.fm tags: considered={}, updated_entities={}, tags_saved={}, skipped_existing={}, not_found={}, failed={}",
+        "Metadata backfill complete: {scanned} scanned, {media_updated} media updated, {track_updated} tracks updated, {local_tags_updated} local tags saved, {unchanged} unchanged, {missing} missing, {failed} failed; Last.fm tags: considered={}, updated_entities={}, tags_saved={}, skipped_existing={}, not_found={}, failed={}; MusicBrainz tags: considered={}, updated_entities={}, tags_saved={}, skipped_existing={}, not_found={}, failed={}",
         lastfm_stats.considered,
         lastfm_stats.updated_entities,
         lastfm_stats.tags_saved,
         lastfm_stats.skipped_existing,
         lastfm_stats.not_found,
         lastfm_stats.failed,
+        musicbrainz_stats.considered,
+        musicbrainz_stats.updated_entities,
+        musicbrainz_stats.tags_saved,
+        musicbrainz_stats.skipped_existing,
+        musicbrainz_stats.not_found,
+        musicbrainz_stats.failed,
     ));
     Ok(())
 }
@@ -345,12 +375,277 @@ async fn backfill_lastfm_tags(
         .build()?;
 
     let mut stats = LastfmTagStats::default();
-    backfill_lastfm_artist_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?;
-    backfill_lastfm_release_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?;
-    backfill_lastfm_track_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?;
+    if backfill_lastfm_artist_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?
+        == LastfmTagPassResult::RateLimited
+    {
+        return Ok(stats);
+    }
+    if backfill_lastfm_release_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?
+        == LastfmTagPassResult::RateLimited
+    {
+        return Ok(stats);
+    }
+    if backfill_lastfm_track_tags(ctx, log, &client, api_key, overwrite, &mut stats).await?
+        == LastfmTagPassResult::RateLimited
+    {
+        return Ok(stats);
+    }
     Ok(stats)
 }
 
+async fn backfill_musicbrainz_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    overwrite: bool,
+) -> anyhow::Result<MusicBrainzTagStats> {
+    log.info("MusicBrainz tag backfill started");
+    let client = crate::jobs::musicbrainz::MusicBrainzClient::new("furumusic-metadata-backfill")?;
+    let mut stats = MusicBrainzTagStats::default();
+    backfill_musicbrainz_artist_tags(ctx, log, &client, overwrite, &mut stats).await?;
+    backfill_musicbrainz_release_tags(ctx, log, &client, overwrite, &mut stats).await?;
+    Ok(stats)
+}
+
+async fn backfill_musicbrainz_artist_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    client: &crate::jobs::musicbrainz::MusicBrainzClient,
+    overwrite: bool,
+    stats: &mut MusicBrainzTagStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, LastfmArtistTagRow>(
+        r#"SELECT DISTINCT a.id, a.name::text AS name
+           FROM furumusic__artist a
+           JOIN furumusic__track_artist ta ON ta.artist_id = a.id
+           JOIN furumusic__track t ON t.id = ta.track_id
+           WHERE a.is_hidden = false AND t.is_hidden = false
+           ORDER BY a.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    log.info(&format!(
+        "MusicBrainz artist tag pass: checking {} artist(s)",
+        rows.len()
+    ));
+    let total = rows.len();
+    for (index, row) in rows.into_iter().enumerate() {
+        if should_log_lastfm_item(index + 1, total, 25) {
+            log.info(&format!(
+                "MusicBrainz artist tags {}/{}: artist {} \"{}\"",
+                index + 1,
+                total,
+                row.id,
+                row.name
+            ));
+        }
+        if should_skip_source_entity(&ctx.pool, "artist", row.id, "musicbrainz", overwrite).await? {
+            stats.skipped_existing += 1;
+            continue;
+        }
+        stats.considered += 1;
+
+        let mbid =
+            match crate::jobs::musicbrainz::load_external_id(&ctx.pool, "artist", row.id, "artist")
+                .await?
+            {
+                Some(mbid) => Some(mbid),
+                None => match client.search_artist(&row.name).await {
+                    Ok(Some(found)) => {
+                        crate::jobs::musicbrainz::save_external_id(
+                            &ctx.pool,
+                            "artist",
+                            row.id,
+                            "artist",
+                            &found.mbid,
+                            found.score as f64 / 100.0,
+                        )
+                        .await?;
+                        Some(found.mbid)
+                    }
+                    Ok(None) => None,
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "MusicBrainz artist search failed for artist {} \"{}\": {err}",
+                            row.id, row.name
+                        ));
+                        None
+                    }
+                },
+            };
+
+        let Some(mbid) = mbid else {
+            stats.not_found += 1;
+            continue;
+        };
+        match client.lookup_artist_tags(&mbid).await {
+            Ok(tags) if !tags.is_empty() => {
+                let tags = musicbrainz_tags_to_candidates(&tags);
+                match replace_entity_tags(&ctx.pool, "artist", row.id, &tags, "musicbrainz", false)
+                    .await
+                {
+                    Ok(saved) => {
+                        stats.tags_saved += saved;
+                        stats.updated_entities += 1;
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "MusicBrainz artist tags save failed for artist {} \"{}\": {err}",
+                            row.id, row.name
+                        ));
+                    }
+                }
+            }
+            Ok(_) => {
+                stats.not_found += 1;
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "MusicBrainz artist tags failed for artist {} \"{}\" mbid={}: {err}",
+                    row.id, row.name, mbid
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+async fn backfill_musicbrainz_release_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    client: &crate::jobs::musicbrainz::MusicBrainzClient,
+    overwrite: bool,
+    stats: &mut MusicBrainzTagStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, LastfmReleaseTagRow>(
+        r#"SELECT r.id,
+                  r.title::text AS title,
+                  (
+                    SELECT a.name::text
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__artist a ON a.id = ra.artist_id
+                     WHERE ra.release_id = r.id
+                     ORDER BY ra.position
+                     LIMIT 1
+                  ) AS artist_name,
+                  (
+                    SELECT t.title::text
+                      FROM furumusic__track t
+                     WHERE t.release_id = r.id
+                       AND t.is_hidden = false
+                     ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id
+                     LIMIT 1
+                  ) AS track_title
+           FROM furumusic__release r
+           WHERE r.is_hidden = false
+           ORDER BY r.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    log.info(&format!(
+        "MusicBrainz release tag pass: checking {} release(s)",
+        rows.len()
+    ));
+    let total = rows.len();
+    for (index, row) in rows.into_iter().enumerate() {
+        if should_log_lastfm_item(index + 1, total, 25) {
+            log.info(&format!(
+                "MusicBrainz release tags {}/{}: release {} \"{}\"",
+                index + 1,
+                total,
+                row.id,
+                row.title
+            ));
+        }
+        if should_skip_source_entity(&ctx.pool, "release", row.id, "musicbrainz", overwrite).await?
+        {
+            stats.skipped_existing += 1;
+            continue;
+        }
+        let Some(artist) = row
+            .artist_name
+            .as_deref()
+            .filter(|value| !value.trim().is_empty())
+        else {
+            stats.not_found += 1;
+            continue;
+        };
+        stats.considered += 1;
+
+        let mbid = match crate::jobs::musicbrainz::load_or_search_release_mbid(
+            &ctx.pool,
+            client,
+            row.id,
+            artist,
+            &row.title,
+            row.track_title.as_deref(),
+        )
+        .await
+        {
+            Ok((release_mbid, _release_group_mbid)) => release_mbid,
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "MusicBrainz release search failed for release {} \"{}\" / \"{}\": {err}",
+                    row.id, artist, row.title
+                ));
+                None
+            }
+        };
+
+        let Some(mbid) = mbid else {
+            stats.not_found += 1;
+            continue;
+        };
+        match client.lookup_release_tags(&mbid).await {
+            Ok(result) if !result.tags.is_empty() => {
+                if let Some(group_mbid) = result.release_group_mbid.as_deref() {
+                    crate::jobs::musicbrainz::save_external_id(
+                        &ctx.pool,
+                        "release",
+                        row.id,
+                        "release_group",
+                        group_mbid,
+                        1.0,
+                    )
+                    .await?;
+                }
+                let tags = musicbrainz_tags_to_candidates(&result.tags);
+                match replace_entity_tags(&ctx.pool, "release", row.id, &tags, "musicbrainz", false)
+                    .await
+                {
+                    Ok(saved) => {
+                        stats.tags_saved += saved;
+                        stats.updated_entities += 1;
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "MusicBrainz release tags save failed for release {} \"{}\" / \"{}\": {err}",
+                            row.id, artist, row.title
+                        ));
+                    }
+                }
+            }
+            Ok(_) => {
+                stats.not_found += 1;
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "MusicBrainz release tags failed for release {} \"{}\" mbid={}: {err}",
+                    row.id, row.title, mbid
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
 async fn backfill_lastfm_artist_tags(
     ctx: &JobContext,
     log: &mut JobLog,
@@ -358,7 +653,7 @@ async fn backfill_lastfm_artist_tags(
     api_key: &str,
     overwrite: bool,
     stats: &mut LastfmTagStats,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<LastfmTagPassResult> {
     let rows = sqlx::query_as::<_, LastfmArtistTagRow>(
         r#"SELECT DISTINCT a.id, a.name::text AS name
            FROM furumusic__artist a
@@ -376,31 +671,65 @@ async fn backfill_lastfm_artist_tags(
     ));
     let total = rows.len();
     for (index, row) in rows.into_iter().enumerate() {
-        if should_skip_lastfm_entity(&ctx.pool, "artist", row.id, overwrite).await? {
-            stats.skipped_existing += 1;
-            if should_log_lastfm_progress(index + 1, total, 25) {
-                log.info(&format!(
-                    "Last.fm artist tags progress: {}/{}",
-                    index + 1,
-                    total
-                ));
+        if should_log_lastfm_item(index + 1, total, 25) {
+            log.info(&format!(
+                "Last.fm artist tags {}/{}: artist {} \"{}\"",
+                index + 1,
+                total,
+                row.id,
+                row.name
+            ));
+        }
+        match should_skip_lastfm_entity(&ctx.pool, "artist", row.id, overwrite).await {
+            Ok(true) => {
+                stats.skipped_existing += 1;
+                if should_log_lastfm_progress(index + 1, total, 25) {
+                    log.info(&format!(
+                        "Last.fm artist tags progress: {}/{}",
+                        index + 1,
+                        total
+                    ));
+                }
+                continue;
+            }
+            Ok(false) => {}
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm artist tags skip check failed for artist {} \"{}\": {err}",
+                    row.id, row.name
+                ));
+                continue;
             }
-            continue;
         }
         stats.considered += 1;
         match fetch_lastfm_artist_tags(client, api_key, &row.name).await {
             Ok(tags) if !tags.is_empty() => {
-                let saved =
-                    replace_entity_tags(&ctx.pool, "artist", row.id, &tags, "lastfm", false)
-                        .await?;
-                stats.tags_saved += saved;
-                stats.updated_entities += 1;
+                match replace_entity_tags(&ctx.pool, "artist", row.id, &tags, "lastfm", false).await
+                {
+                    Ok(saved) => {
+                        stats.tags_saved += saved;
+                        stats.updated_entities += 1;
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "Last.fm artist tags save failed for artist {} \"{}\": {err}",
+                            row.id, row.name
+                        ));
+                    }
+                }
             }
             Ok(_) => {
                 stats.not_found += 1;
             }
-            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
-                return Err(err);
+            Err(err) if is_lastfm_rate_limit_error(&err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm rate limit reached while fetching artist tags for artist {} \"{}\"; stopping Last.fm tag backfill for this run",
+                    row.id, row.name
+                ));
+                return Ok(LastfmTagPassResult::RateLimited);
             }
             Err(err) => {
                 stats.failed += 1;
@@ -419,7 +748,7 @@ async fn backfill_lastfm_artist_tags(
         }
         tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
     }
-    Ok(())
+    Ok(LastfmTagPassResult::Completed)
 }
 
 async fn backfill_lastfm_release_tags(
@@ -429,7 +758,7 @@ async fn backfill_lastfm_release_tags(
     api_key: &str,
     overwrite: bool,
     stats: &mut LastfmTagStats,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<LastfmTagPassResult> {
     let rows = sqlx::query_as::<_, LastfmReleaseTagRow>(
         r#"SELECT r.id,
                   r.title::text AS title,
@@ -440,7 +769,15 @@ async fn backfill_lastfm_release_tags(
                      WHERE ra.release_id = r.id
                      ORDER BY ra.position
                      LIMIT 1
-                  ) AS artist_name
+                  ) AS artist_name,
+                  (
+                    SELECT t.title::text
+                      FROM furumusic__track t
+                     WHERE t.release_id = r.id
+                       AND t.is_hidden = false
+                     ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id
+                     LIMIT 1
+                  ) AS track_title
            FROM furumusic__release r
            WHERE r.is_hidden = false
            ORDER BY r.id"#,
@@ -454,18 +791,41 @@ async fn backfill_lastfm_release_tags(
     ));
     let total = rows.len();
     for (index, row) in rows.into_iter().enumerate() {
-        if should_skip_lastfm_entity(&ctx.pool, "release", row.id, overwrite).await? {
-            stats.skipped_existing += 1;
-            if should_log_lastfm_progress(index + 1, total, 25) {
-                log.info(&format!(
-                    "Last.fm release tags progress: {}/{}",
-                    index + 1,
-                    total
-                ));
-            }
-            continue;
+        if should_log_lastfm_item(index + 1, total, 25) {
+            log.info(&format!(
+                "Last.fm release tags {}/{}: release {} \"{}\"",
+                index + 1,
+                total,
+                row.id,
+                row.title
+            ));
         }
-        let Some(artist) = row.artist_name.as_deref().filter(|value| !value.trim().is_empty())
+        match should_skip_lastfm_entity(&ctx.pool, "release", row.id, overwrite).await {
+            Ok(true) => {
+                stats.skipped_existing += 1;
+                if should_log_lastfm_progress(index + 1, total, 25) {
+                    log.info(&format!(
+                        "Last.fm release tags progress: {}/{}",
+                        index + 1,
+                        total
+                    ));
+                }
+                continue;
+            }
+            Ok(false) => {}
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm release tags skip check failed for release {} \"{}\": {err}",
+                    row.id, row.title
+                ));
+                continue;
+            }
+        }
+        let Some(artist) = row
+            .artist_name
+            .as_deref()
+            .filter(|value| !value.trim().is_empty())
         else {
             stats.not_found += 1;
             if should_log_lastfm_progress(index + 1, total, 25) {
@@ -480,17 +840,32 @@ async fn backfill_lastfm_release_tags(
         stats.considered += 1;
         match fetch_lastfm_album_tags(client, api_key, artist, &row.title).await {
             Ok(tags) if !tags.is_empty() => {
-                let saved =
-                    replace_entity_tags(&ctx.pool, "release", row.id, &tags, "lastfm", false)
-                        .await?;
-                stats.tags_saved += saved;
-                stats.updated_entities += 1;
+                match replace_entity_tags(&ctx.pool, "release", row.id, &tags, "lastfm", false)
+                    .await
+                {
+                    Ok(saved) => {
+                        stats.tags_saved += saved;
+                        stats.updated_entities += 1;
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "Last.fm release tags save failed for release {} \"{}\" / \"{}\": {err}",
+                            row.id, artist, row.title
+                        ));
+                    }
+                }
             }
             Ok(_) => {
                 stats.not_found += 1;
             }
-            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
-                return Err(err);
+            Err(err) if is_lastfm_rate_limit_error(&err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm rate limit reached while fetching release tags for release {} \"{}\" / \"{}\"; stopping Last.fm tag backfill for this run",
+                    row.id, artist, row.title
+                ));
+                return Ok(LastfmTagPassResult::RateLimited);
             }
             Err(err) => {
                 stats.failed += 1;
@@ -509,7 +884,7 @@ async fn backfill_lastfm_release_tags(
         }
         tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
     }
-    Ok(())
+    Ok(LastfmTagPassResult::Completed)
 }
 
 async fn backfill_lastfm_track_tags(
@@ -519,7 +894,7 @@ async fn backfill_lastfm_track_tags(
     api_key: &str,
     overwrite: bool,
     stats: &mut LastfmTagStats,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<LastfmTagPassResult> {
     let rows = sqlx::query_as::<_, LastfmTrackTagRow>(
         r#"SELECT t.id,
                   t.title::text AS title,
@@ -544,18 +919,41 @@ async fn backfill_lastfm_track_tags(
     ));
     let total = rows.len();
     for (index, row) in rows.into_iter().enumerate() {
-        if should_skip_lastfm_entity(&ctx.pool, "track", row.id, overwrite).await? {
-            stats.skipped_existing += 1;
-            if should_log_lastfm_progress(index + 1, total, 50) {
-                log.info(&format!(
-                    "Last.fm track tags progress: {}/{}",
-                    index + 1,
-                    total
-                ));
-            }
-            continue;
+        if should_log_lastfm_item(index + 1, total, 50) {
+            log.info(&format!(
+                "Last.fm track tags {}/{}: track {} \"{}\"",
+                index + 1,
+                total,
+                row.id,
+                row.title
+            ));
         }
-        let Some(artist) = row.artist_name.as_deref().filter(|value| !value.trim().is_empty())
+        match should_skip_lastfm_entity(&ctx.pool, "track", row.id, overwrite).await {
+            Ok(true) => {
+                stats.skipped_existing += 1;
+                if should_log_lastfm_progress(index + 1, total, 50) {
+                    log.info(&format!(
+                        "Last.fm track tags progress: {}/{}",
+                        index + 1,
+                        total
+                    ));
+                }
+                continue;
+            }
+            Ok(false) => {}
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm track tags skip check failed for track {} \"{}\": {err}",
+                    row.id, row.title
+                ));
+                continue;
+            }
+        }
+        let Some(artist) = row
+            .artist_name
+            .as_deref()
+            .filter(|value| !value.trim().is_empty())
         else {
             stats.not_found += 1;
             if should_log_lastfm_progress(index + 1, total, 50) {
@@ -570,16 +968,30 @@ async fn backfill_lastfm_track_tags(
         stats.considered += 1;
         match fetch_lastfm_track_tags(client, api_key, artist, &row.title).await {
             Ok(tags) if !tags.is_empty() => {
-                let saved =
-                    replace_entity_tags(&ctx.pool, "track", row.id, &tags, "lastfm", true).await?;
-                stats.tags_saved += saved;
-                stats.updated_entities += 1;
+                match replace_entity_tags(&ctx.pool, "track", row.id, &tags, "lastfm", true).await {
+                    Ok(saved) => {
+                        stats.tags_saved += saved;
+                        stats.updated_entities += 1;
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        log.warn(&format!(
+                            "Last.fm track tags save failed for track {} \"{}\" / \"{}\": {err}",
+                            row.id, artist, row.title
+                        ));
+                    }
+                }
             }
             Ok(_) => {
                 stats.not_found += 1;
             }
-            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
-                return Err(err);
+            Err(err) if is_lastfm_rate_limit_error(&err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm rate limit reached while fetching track tags for track {} \"{}\" / \"{}\"; stopping Last.fm tag backfill for this run",
+                    row.id, artist, row.title
+                ));
+                return Ok(LastfmTagPassResult::RateLimited);
             }
             Err(err) => {
                 stats.failed += 1;
@@ -598,18 +1010,36 @@ async fn backfill_lastfm_track_tags(
         }
         tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
     }
-    Ok(())
+    Ok(LastfmTagPassResult::Completed)
 }
 
 fn should_log_lastfm_progress(done: usize, total: usize, every: usize) -> bool {
     total > 0 && (done == total || done % every == 0)
 }
 
+fn should_log_lastfm_item(done: usize, total: usize, every: usize) -> bool {
+    total > 0 && (done == 1 || done == total || done % every == 0)
+}
+
+fn is_lastfm_rate_limit_error(err: &anyhow::Error) -> bool {
+    err.to_string().contains("Last.fm rate limit exceeded")
+}
+
 async fn should_skip_lastfm_entity(
     pool: &sqlx::PgPool,
     entity_kind: &str,
     entity_id: i64,
     overwrite: bool,
+) -> anyhow::Result<bool> {
+    should_skip_source_entity(pool, entity_kind, entity_id, "lastfm", overwrite).await
+}
+
+async fn should_skip_source_entity(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    source: &str,
+    overwrite: bool,
 ) -> anyhow::Result<bool> {
     if overwrite {
         return Ok(false);
@@ -617,16 +1047,28 @@ async fn should_skip_lastfm_entity(
     let exists: Option<i64> = sqlx::query_scalar(
         r#"SELECT 1
            FROM furumusic__entity_genre_tag
-           WHERE entity_kind = $1 AND entity_id = $2 AND source = 'lastfm'
+           WHERE entity_kind = $1 AND entity_id = $2 AND source = $3
            LIMIT 1"#,
     )
     .bind(entity_kind)
     .bind(entity_id)
+    .bind(source)
     .fetch_optional(pool)
     .await?;
     Ok(exists.is_some())
 }
 
+fn musicbrainz_tags_to_candidates(
+    tags: &[crate::jobs::musicbrainz::MusicBrainzTag],
+) -> Vec<TagCandidate> {
+    tags.iter()
+        .map(|tag| TagCandidate {
+            name: tag.name.clone(),
+            weight: tag.weight,
+        })
+        .collect()
+}
+
 async fn fetch_lastfm_artist_tags(
     client: &reqwest::Client,
     api_key: &str,
@@ -723,7 +1165,11 @@ async fn fetch_lastfm_top_tags(
         Value::Object(_) => tag_from_value(tag_value).into_iter().collect::<Vec<_>>(),
         _ => Vec::new(),
     };
-    tags.sort_by(|a, b| b.weight.total_cmp(&a.weight).then_with(|| a.name.cmp(&b.name)));
+    tags.sort_by(|a, b| {
+        b.weight
+            .total_cmp(&a.weight)
+            .then_with(|| a.name.cmp(&b.name))
+    });
     tags.truncate(LASTFM_TAG_LIMIT);
     Ok(tags)
 }
@@ -896,9 +1342,9 @@ fn tags_from_text(value: &str) -> Vec<TagCandidate> {
     for raw in normalized_separators.split([';', ',']) {
         if let Some(name) = clean_tag_name(raw) {
             if !is_ignored_tag(&normalize_tag_name(&name))
-                && !tags
-                    .iter()
-                    .any(|tag: &TagCandidate| normalize_tag_name(&tag.name) == normalize_tag_name(&name))
+                && !tags.iter().any(|tag: &TagCandidate| {
+                    normalize_tag_name(&tag.name) == normalize_tag_name(&name)
+                })
             {
                 tags.push(TagCandidate { name, weight: 1.0 });
             }

src/jobs/mod.rs

@@ -4,6 +4,7 @@ pub mod inbox_process;
 pub mod lastfm_popularity;
 pub mod lastfm_scrobble;
 pub mod metadata_backfill;
+pub mod musicbrainz;
 
 use std::path::{Component, Path, PathBuf};
 

src/jobs/musicbrainz.rs

@@ -0,0 +1,587 @@
+use std::time::{Duration, Instant};
+
+use reqwest::{Client, StatusCode};
+use serde::Deserialize;
+use tokio::sync::Mutex;
+
+const MUSICBRAINZ_BASE_URL: &str = "https://musicbrainz.org/ws/2";
+const COVER_ART_ARCHIVE_BASE_URL: &str = "https://coverartarchive.org";
+const MUSICBRAINZ_REQUEST_DELAY: Duration = Duration::from_millis(1100);
+const MUSICBRAINZ_TAG_LIMIT: usize = 12;
+
+#[derive(Debug, Clone)]
+pub struct MusicBrainzTag {
+    pub name: String,
+    pub weight: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct MusicBrainzArtistMatch {
+    pub mbid: String,
+    pub score: i32,
+}
+
+#[derive(Debug, Clone)]
+pub struct MusicBrainzReleaseMatch {
+    pub mbid: String,
+    pub release_group_mbid: Option<String>,
+    pub score: i32,
+}
+
+#[derive(Debug, Clone)]
+pub struct MusicBrainzReleaseTags {
+    pub release_group_mbid: Option<String>,
+    pub tags: Vec<MusicBrainzTag>,
+}
+
+pub struct MusicBrainzClient {
+    client: Client,
+    last_musicbrainz_request: Mutex<Option<Instant>>,
+}
+
+pub async fn load_external_id(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    id_kind: &str,
+) -> anyhow::Result<Option<String>> {
+    let value = sqlx::query_scalar::<_, String>(
+        r#"SELECT external_id::text
+           FROM furumusic__external_metadata_id
+           WHERE entity_kind = $1
+             AND entity_id = $2
+             AND source = 'musicbrainz'
+             AND id_kind = $3
+           LIMIT 1"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .bind(id_kind)
+    .fetch_optional(pool)
+    .await?;
+    Ok(value)
+}
+
+pub async fn save_external_id(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    id_kind: &str,
+    external_id: &str,
+    confidence: f64,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"INSERT INTO furumusic__external_metadata_id
+              (entity_kind, entity_id, source, id_kind, external_id, confidence, updated_at)
+           VALUES ($1, $2, 'musicbrainz', $3, $4, $5, $6)
+           ON CONFLICT (entity_kind, entity_id, source, id_kind) DO UPDATE SET
+              external_id = EXCLUDED.external_id,
+              confidence = EXCLUDED.confidence,
+              updated_at = EXCLUDED.updated_at"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .bind(id_kind)
+    .bind(external_id)
+    .bind(confidence)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+pub async fn load_or_search_release_mbid(
+    pool: &sqlx::PgPool,
+    client: &MusicBrainzClient,
+    release_id: i64,
+    artist_name: &str,
+    release_title: &str,
+    representative_track_title: Option<&str>,
+) -> anyhow::Result<(Option<String>, Option<String>)> {
+    let release_mbid = load_external_id(pool, "release", release_id, "release").await?;
+    let release_group_mbid = load_external_id(pool, "release", release_id, "release_group").await?;
+    if release_mbid.is_some() || release_group_mbid.is_some() {
+        return Ok((release_mbid, release_group_mbid));
+    }
+
+    let found = match client.search_release(artist_name, release_title).await? {
+        Some(found) => Some(found),
+        None => {
+            if let Some(track_title) =
+                representative_track_title.filter(|value| !value.trim().is_empty())
+            {
+                client
+                    .search_release_by_recording(artist_name, track_title)
+                    .await?
+            } else {
+                None
+            }
+        }
+    };
+
+    let Some(found) = found else {
+        return Ok((None, None));
+    };
+    save_external_id(
+        pool,
+        "release",
+        release_id,
+        "release",
+        &found.mbid,
+        found.score as f64 / 100.0,
+    )
+    .await?;
+    if let Some(group_mbid) = found.release_group_mbid.as_deref() {
+        save_external_id(
+            pool,
+            "release",
+            release_id,
+            "release_group",
+            group_mbid,
+            found.score as f64 / 100.0,
+        )
+        .await?;
+    }
+    Ok((Some(found.mbid), found.release_group_mbid))
+}
+
+impl MusicBrainzClient {
+    pub fn new(user_agent_prefix: &str) -> anyhow::Result<Self> {
+        let client = Client::builder()
+            .user_agent(format!(
+                "{}/{} (musicbrainz.org/doc/MusicBrainz_API)",
+                user_agent_prefix,
+                env!("CARGO_PKG_VERSION")
+            ))
+            .timeout(Duration::from_secs(20))
+            .build()?;
+        Ok(Self {
+            client,
+            last_musicbrainz_request: Mutex::new(None),
+        })
+    }
+
+    pub fn http_client(&self) -> &Client {
+        &self.client
+    }
+
+    pub async fn search_artist(
+        &self,
+        name: &str,
+    ) -> anyhow::Result<Option<MusicBrainzArtistMatch>> {
+        let query = format!("artist:\"{}\"", escape_search_value(name));
+        let response: Option<ArtistSearchResponse> = self
+            .get_musicbrainz_json(
+                "artist",
+                &[("query", query.as_str()), ("fmt", "json"), ("limit", "5")],
+            )
+            .await?;
+        let Some(response) = response else {
+            return Ok(None);
+        };
+        Ok(response
+            .artists
+            .into_iter()
+            .filter(|artist| artist.id.trim().len() == 36)
+            .max_by_key(|artist| artist.score.unwrap_or(0))
+            .and_then(|artist| {
+                let score = artist.score.unwrap_or(0);
+                (score >= 70).then_some(MusicBrainzArtistMatch {
+                    mbid: artist.id,
+                    score,
+                })
+            }))
+    }
+
+    pub async fn search_release(
+        &self,
+        artist: &str,
+        title: &str,
+    ) -> anyhow::Result<Option<MusicBrainzReleaseMatch>> {
+        let query = format!(
+            "release:\"{}\" AND artist:\"{}\"",
+            escape_search_value(title),
+            escape_search_value(artist)
+        );
+        let response: Option<ReleaseSearchResponse> = self
+            .get_musicbrainz_json(
+                "release",
+                &[("query", query.as_str()), ("fmt", "json"), ("limit", "5")],
+            )
+            .await?;
+        let Some(response) = response else {
+            return Ok(None);
+        };
+        Ok(response
+            .releases
+            .into_iter()
+            .filter(|release| release.id.trim().len() == 36)
+            .max_by_key(|release| release.score.unwrap_or(0))
+            .and_then(|release| {
+                let score = release.score.unwrap_or(0);
+                (score >= 70).then_some(MusicBrainzReleaseMatch {
+                    mbid: release.id,
+                    release_group_mbid: release.release_group.map(|group| group.id),
+                    score,
+                })
+            }))
+    }
+
+    pub async fn search_release_by_recording(
+        &self,
+        artist: &str,
+        track_title: &str,
+    ) -> anyhow::Result<Option<MusicBrainzReleaseMatch>> {
+        let query = format!(
+            "recording:\"{}\" AND artist:\"{}\"",
+            escape_search_value(track_title),
+            escape_search_value(artist)
+        );
+        let response: Option<RecordingSearchResponse> = self
+            .get_musicbrainz_json(
+                "recording",
+                &[("query", query.as_str()), ("fmt", "json"), ("limit", "5")],
+            )
+            .await?;
+        let Some(response) = response else {
+            return Ok(None);
+        };
+
+        Ok(response
+            .recordings
+            .into_iter()
+            .flat_map(|recording| {
+                let recording_score = recording.score.unwrap_or(0);
+                recording
+                    .releases
+                    .into_iter()
+                    .filter(move |release| release.id.trim().len() == 36)
+                    .map(move |release| (recording_score, release))
+            })
+            .max_by_key(|(score, _)| *score)
+            .and_then(|(score, release)| {
+                (score >= 70).then_some(MusicBrainzReleaseMatch {
+                    mbid: release.id,
+                    release_group_mbid: release.release_group.map(|group| group.id),
+                    score,
+                })
+            }))
+    }
+
+    pub async fn lookup_artist_tags(&self, mbid: &str) -> anyhow::Result<Vec<MusicBrainzTag>> {
+        let response: Option<TaggedEntityResponse> = self
+            .get_musicbrainz_json(
+                &format!("artist/{mbid}"),
+                &[("inc", "tags+genres"), ("fmt", "json")],
+            )
+            .await?;
+        Ok(response.map(tags_from_entity).unwrap_or_default())
+    }
+
+    pub async fn lookup_release_tags(&self, mbid: &str) -> anyhow::Result<MusicBrainzReleaseTags> {
+        let response: Option<ReleaseLookupResponse> = self
+            .get_musicbrainz_json(
+                &format!("release/{mbid}"),
+                &[("inc", "tags+genres+release-groups"), ("fmt", "json")],
+            )
+            .await?;
+        let Some(response) = response else {
+            return Ok(MusicBrainzReleaseTags {
+                release_group_mbid: None,
+                tags: Vec::new(),
+            });
+        };
+
+        let mut tags = tags_from_parts(response.tags, response.genres);
+        let release_group_mbid = response
+            .release_group
+            .as_ref()
+            .map(|group| group.id.clone());
+        if let Some(group_mbid) = release_group_mbid.as_deref() {
+            let group_response: Option<TaggedEntityResponse> = self
+                .get_musicbrainz_json(
+                    &format!("release-group/{group_mbid}"),
+                    &[("inc", "tags+genres"), ("fmt", "json")],
+                )
+                .await?;
+            merge_tags(
+                &mut tags,
+                group_response.map(tags_from_entity).unwrap_or_default(),
+            );
+        }
+        tags.sort_by(|a, b| {
+            b.weight
+                .total_cmp(&a.weight)
+                .then_with(|| a.name.cmp(&b.name))
+        });
+        tags.truncate(MUSICBRAINZ_TAG_LIMIT);
+
+        Ok(MusicBrainzReleaseTags {
+            release_group_mbid,
+            tags,
+        })
+    }
+
+    pub async fn fetch_cover_art_front_url(
+        &self,
+        release_mbid: Option<&str>,
+        release_group_mbid: Option<&str>,
+    ) -> anyhow::Result<Option<String>> {
+        if let Some(mbid) = release_mbid {
+            if let Some(url) = self.cover_art_front_url("release", mbid).await? {
+                return Ok(Some(url));
+            }
+        }
+        if let Some(mbid) = release_group_mbid {
+            if let Some(url) = self.cover_art_front_url("release-group", mbid).await? {
+                return Ok(Some(url));
+            }
+        }
+        Ok(None)
+    }
+
+    async fn get_musicbrainz_json<T>(
+        &self,
+        path: &str,
+        query: &[(&str, &str)],
+    ) -> anyhow::Result<Option<T>>
+    where
+        T: for<'de> Deserialize<'de>,
+    {
+        self.wait_for_musicbrainz_slot().await;
+        let url = format!("{MUSICBRAINZ_BASE_URL}/{}", path.trim_start_matches('/'));
+        let response = self.client.get(url).query(query).send().await?;
+        if response.status() == StatusCode::NOT_FOUND {
+            return Ok(None);
+        }
+        if response.status() == StatusCode::TOO_MANY_REQUESTS
+            || response.status() == StatusCode::SERVICE_UNAVAILABLE
+        {
+            anyhow::bail!(
+                "MusicBrainz rate limit or service unavailable: {}",
+                response.status()
+            );
+        }
+        let response = response.error_for_status()?;
+        Ok(Some(response.json::<T>().await?))
+    }
+
+    async fn cover_art_front_url(&self, kind: &str, mbid: &str) -> anyhow::Result<Option<String>> {
+        let url = format!("{COVER_ART_ARCHIVE_BASE_URL}/{kind}/{mbid}");
+        let response = self.client.get(url).send().await?;
+        if response.status() == StatusCode::NOT_FOUND {
+            return Ok(None);
+        }
+        if response.status() == StatusCode::TOO_MANY_REQUESTS
+            || response.status() == StatusCode::SERVICE_UNAVAILABLE
+        {
+            anyhow::bail!("Cover Art Archive unavailable: {}", response.status());
+        }
+        let response = response.error_for_status()?;
+        let body = response.json::<CoverArtArchiveResponse>().await?;
+        Ok(best_cover_art_url(body.images))
+    }
+
+    async fn wait_for_musicbrainz_slot(&self) {
+        let mut last = self.last_musicbrainz_request.lock().await;
+        if let Some(previous) = *last {
+            let elapsed = previous.elapsed();
+            if elapsed < MUSICBRAINZ_REQUEST_DELAY {
+                tokio::time::sleep(MUSICBRAINZ_REQUEST_DELAY - elapsed).await;
+            }
+        }
+        *last = Some(Instant::now());
+    }
+}
+
+fn now_iso() -> String {
+    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
+}
+
+#[derive(Debug, Deserialize)]
+struct ArtistSearchResponse {
+    #[serde(default)]
+    artists: Vec<ArtistSearchItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ArtistSearchItem {
+    id: String,
+    score: Option<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ReleaseSearchResponse {
+    #[serde(default)]
+    releases: Vec<ReleaseSearchItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ReleaseSearchItem {
+    id: String,
+    score: Option<i32>,
+    #[serde(rename = "release-group")]
+    release_group: Option<MusicBrainzIdRef>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RecordingSearchResponse {
+    #[serde(default)]
+    recordings: Vec<RecordingSearchItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RecordingSearchItem {
+    score: Option<i32>,
+    #[serde(default)]
+    releases: Vec<RecordingReleaseItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RecordingReleaseItem {
+    id: String,
+    #[serde(rename = "release-group")]
+    release_group: Option<MusicBrainzIdRef>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ReleaseLookupResponse {
+    #[serde(default)]
+    tags: Vec<MusicBrainzTagItem>,
+    #[serde(default)]
+    genres: Vec<MusicBrainzTagItem>,
+    #[serde(rename = "release-group")]
+    release_group: Option<MusicBrainzIdRef>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TaggedEntityResponse {
+    #[serde(default)]
+    tags: Vec<MusicBrainzTagItem>,
+    #[serde(default)]
+    genres: Vec<MusicBrainzTagItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct MusicBrainzIdRef {
+    id: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct MusicBrainzTagItem {
+    name: String,
+    count: Option<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CoverArtArchiveResponse {
+    #[serde(default)]
+    images: Vec<CoverArtArchiveImage>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CoverArtArchiveImage {
+    image: Option<String>,
+    front: Option<bool>,
+    approved: Option<bool>,
+    #[serde(default)]
+    types: Vec<String>,
+    thumbnails: Option<CoverArtArchiveThumbnails>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CoverArtArchiveThumbnails {
+    #[serde(rename = "1200")]
+    size_1200: Option<String>,
+    #[serde(rename = "500")]
+    size_500: Option<String>,
+    large: Option<String>,
+}
+
+fn escape_search_value(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+fn tags_from_entity(entity: TaggedEntityResponse) -> Vec<MusicBrainzTag> {
+    tags_from_parts(entity.tags, entity.genres)
+}
+
+fn tags_from_parts(
+    tags: Vec<MusicBrainzTagItem>,
+    genres: Vec<MusicBrainzTagItem>,
+) -> Vec<MusicBrainzTag> {
+    let mut result = Vec::new();
+    merge_items(&mut result, genres, 2.0);
+    merge_items(&mut result, tags, 1.0);
+    result.sort_by(|a, b| {
+        b.weight
+            .total_cmp(&a.weight)
+            .then_with(|| a.name.cmp(&b.name))
+    });
+    result.truncate(MUSICBRAINZ_TAG_LIMIT);
+    result
+}
+
+fn merge_items(result: &mut Vec<MusicBrainzTag>, items: Vec<MusicBrainzTagItem>, multiplier: f64) {
+    for item in items {
+        let name = item.name.trim();
+        if name.is_empty() {
+            continue;
+        }
+        let weight = item.count.unwrap_or(1).max(1) as f64 * multiplier;
+        if let Some(existing) = result
+            .iter_mut()
+            .find(|tag| tag.name.eq_ignore_ascii_case(name))
+        {
+            existing.weight = existing.weight.max(weight);
+        } else {
+            result.push(MusicBrainzTag {
+                name: name.to_string(),
+                weight,
+            });
+        }
+    }
+}
+
+fn merge_tags(result: &mut Vec<MusicBrainzTag>, extra: Vec<MusicBrainzTag>) {
+    for tag in extra {
+        if let Some(existing) = result
+            .iter_mut()
+            .find(|candidate| candidate.name.eq_ignore_ascii_case(&tag.name))
+        {
+            existing.weight = existing.weight.max(tag.weight);
+        } else {
+            result.push(tag);
+        }
+    }
+}
+
+fn best_cover_art_url(mut images: Vec<CoverArtArchiveImage>) -> Option<String> {
+    images.sort_by_key(|image| {
+        let front = image.front.unwrap_or(false)
+            || image
+                .types
+                .iter()
+                .any(|value| value.eq_ignore_ascii_case("front"));
+        let approved = image.approved.unwrap_or(false);
+        (u8::from(front), u8::from(approved))
+    });
+    images
+        .into_iter()
+        .rev()
+        .find_map(|image| {
+            image
+                .thumbnails
+                .as_ref()
+                .and_then(|thumbs| {
+                    thumbs
+                        .size_1200
+                        .as_deref()
+                        .or(thumbs.size_500.as_deref())
+                        .or(thumbs.large.as_deref())
+                })
+                .map(str::to_string)
+                .or(image.image)
+        })
+        .filter(|url| !url.trim().is_empty())
+}

src/main.rs

@@ -7,6 +7,7 @@ mod i18n;
 mod jobs;
 mod lastfm;
 mod media_paths;
+mod metrics;
 mod music;
 mod oidc;
 mod player;
@@ -139,12 +140,41 @@ async fn logout_handler(session: Session) -> cot::Result<cot::response::Response
     Ok(auth::redirect("/login"))
 }
 
+async fn metrics_handler(
+    config: Arc<AppConfig>,
+    pool: Arc<tokio::sync::OnceCell<sqlx::PgPool>>,
+) -> cot::Result<cot::http::Response<Body>> {
+    if config.database_url.is_empty() {
+        return Ok(cot::http::Response::builder()
+            .status(cot::http::StatusCode::SERVICE_UNAVAILABLE)
+            .header(cot::http::header::CONTENT_TYPE, "text/plain; version=0.0.4")
+            .body(Body::fixed("furumusic_metrics_unavailable 1\n"))
+            .expect("valid response"));
+    }
+    let pg_pool = pool
+        .get_or_init(|| async {
+            sqlx::postgres::PgPoolOptions::new()
+                .max_connections(2)
+                .connect(&config.database_url)
+                .await
+                .expect("metrics pool")
+        })
+        .await;
+    let body = metrics::render(pg_pool, &config).await;
+    Ok(cot::http::Response::builder()
+        .status(cot::http::StatusCode::OK)
+        .header(cot::http::header::CONTENT_TYPE, "text/plain; version=0.0.4")
+        .body(Body::fixed(body))
+        .expect("valid response"))
+}
+
 // ---------------------------------------------------------------------------
 // App
 // ---------------------------------------------------------------------------
 
 struct FuruApp {
     config: Arc<AppConfig>,
+    pool: Arc<tokio::sync::OnceCell<sqlx::PgPool>>,
 }
 
 impl App for FuruApp {
@@ -171,6 +201,19 @@ impl App for FuruApp {
                 },
                 "index",
             ),
+            Route::with_handler_and_name(
+                "/metrics",
+                get({
+                    let config = Arc::clone(&self.config);
+                    let pool = Arc::clone(&self.pool);
+                    move || {
+                        let config = Arc::clone(&config);
+                        let pool = Arc::clone(&pool);
+                        async move { metrics_handler(config, pool).await }
+                    }
+                }),
+                "metrics",
+            ),
             Route::with_handler_and_name(
                 "/login",
                 get({
@@ -200,6 +243,11 @@ impl App for FuruApp {
                             let data = match result {
                                 FormResult::Ok(data) => data,
                                 FormResult::ValidationError(_) => {
+                                    metrics::record_auth_attempt(
+                                        "password",
+                                        "failure",
+                                        "validation_error",
+                                    );
                                     let msg = i18n.t.login_invalid.to_owned();
                                     return login_page_handler(i18n, &config, db, msg)
                                         .await?
@@ -216,6 +264,10 @@ impl App for FuruApp {
                                         PasswordVerificationResult::Ok
                                         | PasswordVerificationResult::OkObsolete(_) => {
                                             auth::login(&session, user.id_val()).await?;
+                                            metrics::record_auth_attempt(
+                                                "password", "success", "ok",
+                                            );
+                                            metrics::record_session_created("password");
                                             return Ok(auth::redirect("/"));
                                         }
                                         PasswordVerificationResult::Invalid => {}
@@ -223,6 +275,11 @@ impl App for FuruApp {
                                 }
                             }
 
+                            metrics::record_auth_attempt(
+                                "password",
+                                "failure",
+                                "bad_credentials",
+                            );
                             let msg = i18n.t.login_invalid.to_owned();
                             login_page_handler(i18n, &config, db, msg)
                                 .await?
@@ -332,6 +389,7 @@ impl Project for FuruProject {
         context: &cot::project::MiddlewareContext,
     ) -> cot::project::RootHandler {
         handler
+            .middleware(metrics::MetricsLayer)
             .middleware(StaticFilesMiddleware::from_context(context))
             .middleware(SessionMiddleware::from_context(context))
             .build()
@@ -361,6 +419,7 @@ impl Project for FuruProject {
         apps.register_with_views(
             FuruApp {
                 config: Arc::clone(&self.app_config),
+                pool: Arc::new(tokio::sync::OnceCell::new()),
             },
             "",
         );

src/metrics.rs

@@ -0,0 +1,851 @@
+use std::collections::{BTreeMap, HashMap};
+use std::future::Future;
+use std::path::Path;
+use std::pin::Pin;
+use std::sync::{LazyLock, Mutex};
+use std::task::{Context, Poll};
+use std::time::{Duration, Instant};
+
+use cot::http::header::CONTENT_LENGTH;
+use cot::http::Method;
+use cot::request::Request;
+use cot::response::Response;
+use cot::Error;
+use sqlx::PgPool;
+use tower::{Layer, Service};
+
+use crate::config::AppConfig;
+
+const HTTP_BUCKETS: &[f64] = &[
+    0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0,
+];
+const JOB_BUCKETS: &[f64] = &[0.1, 0.5, 1.0, 2.5, 5.0, 10.0, 30.0, 60.0, 300.0, 600.0];
+const FILE_BUCKETS: &[f64] = &[
+    0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 15.0, 60.0,
+];
+
+static REGISTRY: LazyLock<Registry> = LazyLock::new(Registry::default);
+static ACTIVE_USERS: LazyLock<Mutex<HashMap<i64, Instant>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
+
+#[derive(Default)]
+struct Registry {
+    counters: Mutex<BTreeMap<MetricKey, f64>>,
+    gauges: Mutex<BTreeMap<MetricKey, f64>>,
+    histograms: Mutex<BTreeMap<MetricKey, HistogramState>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct MetricKey {
+    name: &'static str,
+    labels: Vec<(&'static str, String)>,
+}
+
+#[derive(Debug, Clone)]
+struct HistogramState {
+    buckets: Vec<f64>,
+    counts: Vec<u64>,
+    sum: f64,
+    count: u64,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct MetricsLayer;
+
+#[derive(Debug, Clone)]
+pub struct MetricsService<S> {
+    inner: S,
+}
+
+impl<S> Layer<S> for MetricsLayer {
+    type Service = MetricsService<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        MetricsService { inner }
+    }
+}
+
+impl<S> Service<Request> for MetricsService<S>
+where
+    S: Service<Request, Response = Response, Error = Error> + Send + 'static,
+    S::Future: Send + 'static,
+{
+    type Response = Response;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, request: Request) -> Self::Future {
+        let method = request.method().clone();
+        let route = normalize_route(request.uri().path());
+        let request_bytes = request
+            .headers()
+            .get(CONTENT_LENGTH)
+            .and_then(|value| value.to_str().ok())
+            .and_then(|value| value.parse::<f64>().ok())
+            .unwrap_or(0.0);
+        let labels = http_labels(&method, &route, "in_flight");
+        REGISTRY.inc_gauge("furumusic_http_in_flight_requests", labels, 1.0);
+        REGISTRY.inc_counter(
+            "furumusic_http_request_body_bytes_total",
+            vec![
+                ("method", method.as_str().to_owned()),
+                ("route", route.clone()),
+            ],
+            request_bytes,
+        );
+
+        let start = Instant::now();
+        let fut = self.inner.call(request);
+        Box::pin(async move {
+            let result = fut.await;
+            let elapsed = start.elapsed().as_secs_f64();
+            REGISTRY.inc_gauge(
+                "furumusic_http_in_flight_requests",
+                http_labels(&method, &route, "in_flight"),
+                -1.0,
+            );
+
+            match result {
+                Ok(response) => {
+                    let status = response.status().as_u16().to_string();
+                    let labels = http_labels(&method, &route, &status);
+                    REGISTRY.inc_counter("furumusic_http_requests_total", labels.clone(), 1.0);
+                    REGISTRY.observe_histogram(
+                        "furumusic_http_request_duration_seconds",
+                        labels,
+                        elapsed,
+                        HTTP_BUCKETS,
+                    );
+                    if let Some(length) = response
+                        .headers()
+                        .get(CONTENT_LENGTH)
+                        .and_then(|value| value.to_str().ok())
+                        .and_then(|value| value.parse::<f64>().ok())
+                    {
+                        REGISTRY.inc_counter(
+                            "furumusic_http_response_body_bytes_total",
+                            vec![
+                                ("method", method.as_str().to_owned()),
+                                ("route", route.clone()),
+                                ("status", status),
+                            ],
+                            length,
+                        );
+                    }
+                    Ok(response)
+                }
+                Err(error) => {
+                    let labels = http_labels(&method, &route, "500");
+                    REGISTRY.inc_counter("furumusic_http_requests_total", labels.clone(), 1.0);
+                    REGISTRY.observe_histogram(
+                        "furumusic_http_request_duration_seconds",
+                        labels,
+                        elapsed,
+                        HTTP_BUCKETS,
+                    );
+                    Err(error)
+                }
+            }
+        })
+    }
+}
+
+pub fn record_active_user(user_id: i64) {
+    let mut users = ACTIVE_USERS.lock().expect("active user lock");
+    users.insert(user_id, Instant::now());
+}
+
+pub fn active_user_last_seen_ms() -> HashMap<i64, i64> {
+    let users = ACTIVE_USERS.lock().expect("active user lock");
+    users
+        .iter()
+        .map(|(user_id, last_seen)| (*user_id, last_seen.elapsed().as_millis() as i64))
+        .collect()
+}
+
+pub fn record_auth_attempt(method: &'static str, outcome: &'static str, reason: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_auth_login_attempts_total",
+        vec![
+            ("method", method.to_owned()),
+            ("outcome", outcome.to_owned()),
+            ("reason", reason.to_owned()),
+        ],
+        1.0,
+    );
+}
+
+pub fn record_session_created(method: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_auth_sessions_created_total",
+        vec![("method", method.to_owned())],
+        1.0,
+    );
+}
+
+pub fn record_authorization_denied(kind: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_auth_denied_total",
+        vec![("kind", kind.to_owned())],
+        1.0,
+    );
+}
+
+pub fn record_play_history(duration_listened: Option<i32>, completed: bool) {
+    REGISTRY.inc_counter(
+        "furumusic_listens_total",
+        vec![(
+            "completed",
+            if completed { "true" } else { "false" }.to_owned(),
+        )],
+        1.0,
+    );
+    if let Some(seconds) = duration_listened {
+        REGISTRY.inc_counter(
+            "furumusic_listened_seconds_total",
+            Vec::new(),
+            seconds.max(0) as f64,
+        );
+    }
+}
+
+pub fn record_stream_request(range: bool, bytes: u64) {
+    REGISTRY.inc_counter(
+        "furumusic_stream_requests_total",
+        vec![("range", if range { "true" } else { "false" }.to_owned())],
+        1.0,
+    );
+    REGISTRY.inc_counter("furumusic_stream_bytes_total", Vec::new(), bytes as f64);
+}
+
+pub fn record_agent_discover_run(outcome: &'static str, duration: Duration) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_discover_runs_total",
+        vec![("outcome", outcome.to_owned())],
+        1.0,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_discover_duration_seconds",
+        vec![("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        JOB_BUCKETS,
+    );
+}
+
+pub fn record_agent_discover_files(seen: u64, queued: u64, skipped_hash: u64, skipped_existing: u64) {
+    REGISTRY.inc_counter("furumusic_agent_discover_files_seen_total", Vec::new(), seen as f64);
+    REGISTRY.inc_counter(
+        "furumusic_agent_discover_files_queued_total",
+        Vec::new(),
+        queued as f64,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_agent_discover_files_skipped_total",
+        vec![("reason", "hash_known".to_owned())],
+        skipped_hash as f64,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_agent_discover_files_skipped_total",
+        vec![("reason", "already_queued".to_owned())],
+        skipped_existing as f64,
+    );
+}
+
+pub fn record_agent_file_hash(duration: Duration, bytes: i64, outcome: &'static str) {
+    REGISTRY.observe_histogram(
+        "furumusic_agent_discover_hash_duration_seconds",
+        vec![("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        FILE_BUCKETS,
+    );
+    if bytes > 0 {
+        REGISTRY.inc_counter(
+            "furumusic_agent_discover_file_bytes_total",
+            vec![("outcome", outcome.to_owned())],
+            bytes as f64,
+        );
+    }
+}
+
+pub fn record_agent_metadata(duration: Duration, outcome: &'static str) {
+    REGISTRY.observe_histogram(
+        "furumusic_agent_discover_metadata_duration_seconds",
+        vec![("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        FILE_BUCKETS,
+    );
+}
+
+pub fn record_agent_folder_batch(outcome: &'static str, size: usize, duration: Duration) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_folder_batches_total",
+        vec![("outcome", outcome.to_owned())],
+        1.0,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_folder_batch_duration_seconds",
+        vec![("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        JOB_BUCKETS,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_folder_batch_size",
+        vec![("outcome", outcome.to_owned())],
+        size as f64,
+        &[1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0],
+    );
+}
+
+pub fn record_agent_file_processed(outcome: &'static str, decision: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_files_processed_total",
+        vec![
+            ("outcome", outcome.to_owned()),
+            ("decision", decision.to_owned()),
+        ],
+        1.0,
+    );
+}
+
+pub fn record_agent_failed(stage: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_failed_total",
+        vec![("stage", stage.to_owned())],
+        1.0,
+    );
+}
+
+pub fn observe_agent_confidence(confidence: f64) {
+    REGISTRY.observe_histogram(
+        "furumusic_agent_confidence",
+        Vec::new(),
+        confidence,
+        &[0.1, 0.2, 0.4, 0.6, 0.75, 0.85, 0.95, 1.0],
+    );
+}
+
+pub fn record_agent_llm(
+    model: &str,
+    outcome: &'static str,
+    duration: Duration,
+    prompt_tokens: u64,
+    completion_tokens: u64,
+    batch_size: usize,
+    estimated_tokens: Option<u64>,
+) {
+    let model = normalize_model_label(model);
+    REGISTRY.inc_counter(
+        "furumusic_agent_llm_requests_total",
+        vec![
+            ("model", model.clone()),
+            ("outcome", outcome.to_owned()),
+        ],
+        1.0,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_llm_duration_seconds",
+        vec![
+            ("model", model.clone()),
+            ("outcome", outcome.to_owned()),
+        ],
+        duration.as_secs_f64(),
+        JOB_BUCKETS,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_agent_llm_tokens_total",
+        vec![("model", model.clone()), ("type", "prompt".to_owned())],
+        prompt_tokens as f64,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_agent_llm_tokens_total",
+        vec![
+            ("model", model.clone()),
+            ("type", "completion".to_owned()),
+        ],
+        completion_tokens as f64,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_llm_batch_size",
+        vec![("model", model.clone())],
+        batch_size as f64,
+        &[1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0],
+    );
+    if let Some(estimated) = estimated_tokens {
+        REGISTRY.observe_histogram(
+            "furumusic_agent_llm_context_estimated_tokens",
+            vec![("model", model)],
+            estimated as f64,
+            &[512.0, 1024.0, 2048.0, 4096.0, 8192.0, 16384.0, 32768.0],
+        );
+    }
+}
+
+pub fn record_agent_llm_split(reason: &'static str) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_llm_batch_splits_total",
+        vec![("reason", reason.to_owned())],
+        1.0,
+    );
+}
+
+pub fn record_agent_llm_parse_failure(model: &str) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_llm_parse_failures_total",
+        vec![("model", normalize_model_label(model))],
+        1.0,
+    );
+}
+
+pub fn record_agent_rag(kind: &'static str, outcome: &'static str, duration: Duration, results: usize) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_rag_queries_total",
+        vec![("kind", kind.to_owned()), ("outcome", outcome.to_owned())],
+        1.0,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_rag_duration_seconds",
+        vec![("kind", kind.to_owned()), ("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        FILE_BUCKETS,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_rag_results",
+        vec![("kind", kind.to_owned())],
+        results as f64,
+        &[0.0, 1.0, 2.0, 5.0, 10.0],
+    );
+}
+
+pub fn record_agent_cover_lookup(source: &'static str, outcome: &'static str, bytes: usize) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_cover_lookup_total",
+        vec![("source", source.to_owned()), ("outcome", outcome.to_owned())],
+        1.0,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_agent_cover_bytes_total",
+        vec![("source", source.to_owned())],
+        bytes as f64,
+    );
+}
+
+pub fn record_agent_cover_variant(variant: &'static str, outcome: &'static str, duration: Duration) {
+    REGISTRY.inc_counter(
+        "furumusic_agent_cover_variant_generation_total",
+        vec![
+            ("variant", variant.to_owned()),
+            ("outcome", outcome.to_owned()),
+        ],
+        1.0,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_agent_cover_variant_duration_seconds",
+        vec![
+            ("variant", variant.to_owned()),
+            ("outcome", outcome.to_owned()),
+        ],
+        duration.as_secs_f64(),
+        FILE_BUCKETS,
+    );
+}
+
+pub fn record_scheduler_job(job: &str, trigger: &str, outcome: &'static str, duration_ms: i64) {
+    let labels = vec![
+        ("job", job.to_owned()),
+        ("trigger", trigger.to_owned()),
+        ("outcome", outcome.to_owned()),
+    ];
+    REGISTRY.inc_counter("furumusic_scheduler_job_runs_total", labels.clone(), 1.0);
+    REGISTRY.observe_histogram(
+        "furumusic_scheduler_job_duration_seconds",
+        labels,
+        (duration_ms.max(0) as f64) / 1000.0,
+        JOB_BUCKETS,
+    );
+}
+
+pub fn record_torrent_download(outcome: &'static str, selected_bytes: u64, duration: Duration) {
+    REGISTRY.inc_counter(
+        "furumusic_torrent_downloads_total",
+        vec![("outcome", outcome.to_owned())],
+        1.0,
+    );
+    REGISTRY.inc_counter(
+        "furumusic_torrent_selected_bytes_total",
+        vec![("outcome", outcome.to_owned())],
+        selected_bytes as f64,
+    );
+    REGISTRY.observe_histogram(
+        "furumusic_torrent_download_duration_seconds",
+        vec![("outcome", outcome.to_owned())],
+        duration.as_secs_f64(),
+        JOB_BUCKETS,
+    );
+}
+
+pub async fn render(pool: &PgPool, config: &AppConfig) -> String {
+    let mut out = String::new();
+    emit_static_gauge(&mut out, "furumusic_build_info", &[("version", env!("CARGO_PKG_VERSION"))], 1.0);
+    render_active_users(&mut out);
+    render_storage(&mut out, config);
+    render_db_metrics(&mut out, pool).await;
+    out.push_str(&REGISTRY.render());
+    out
+}
+
+fn render_active_users(out: &mut String) {
+    let mut users = ACTIVE_USERS.lock().expect("active user lock");
+    let now = Instant::now();
+    users.retain(|_, seen| now.duration_since(*seen) <= Duration::from_secs(3600));
+    for (window, seconds) in [("5m", 300), ("15m", 900), ("1h", 3600)] {
+        let count = users
+            .values()
+            .filter(|seen| now.duration_since(**seen) <= Duration::from_secs(seconds))
+            .count();
+        emit_static_gauge(
+            out,
+            "furumusic_active_users",
+            &[("window", window)],
+            count as f64,
+        );
+    }
+}
+
+fn render_storage(out: &mut String, config: &AppConfig) {
+    for (kind, path) in [
+        ("inbox", config.agent_inbox_dir.as_str()),
+        ("library", config.agent_storage_dir.as_str()),
+    ] {
+        if let Some(usage) = disk_usage(Path::new(path.trim())) {
+            emit_static_gauge(
+                out,
+                "furumusic_storage_free_bytes",
+                &[("path_kind", kind)],
+                usage.free_bytes as f64,
+            );
+            emit_static_gauge(
+                out,
+                "furumusic_storage_total_bytes",
+                &[("path_kind", kind)],
+                usage.total_bytes as f64,
+            );
+        }
+    }
+}
+
+async fn render_db_metrics(out: &mut String, pool: &PgPool) {
+    render_group_counts(out, pool, "furumusic_users_total", "SELECT role::text AS label, COUNT(*) AS count FROM furumusic__user GROUP BY role", "role").await;
+    render_single_count(out, pool, "furumusic_library_tracks_total", "SELECT COUNT(*) FROM furumusic__track").await;
+    render_single_count(out, pool, "furumusic_library_releases_total", "SELECT COUNT(*) FROM furumusic__release").await;
+    render_single_count(out, pool, "furumusic_library_artists_total", "SELECT COUNT(*) FROM furumusic__artist").await;
+    render_single_count(out, pool, "furumusic_library_playlists_total", "SELECT COUNT(*) FROM furumusic__playlist").await;
+    render_group_counts(out, pool, "furumusic_media_files_total", "SELECT file_type::text AS label, COUNT(*) AS count FROM furumusic__media_file GROUP BY file_type", "type").await;
+    render_group_sums(out, pool, "furumusic_media_file_bytes_total", "SELECT file_type::text AS label, COALESCE(SUM(file_size_bytes), 0)::bigint AS value FROM furumusic__media_file GROUP BY file_type", "type").await;
+    render_group_counts(out, pool, "furumusic_agent_reviews_total", "SELECT status::text AS label, COUNT(*) AS count FROM furumusic__pending_review GROUP BY status", "status").await;
+    render_group_counts(out, pool, "furumusic_agent_queue_depth", "SELECT status::text AS label, COUNT(*) AS count FROM furumusic__pending_review GROUP BY status", "status").await;
+    render_group_counts(out, pool, "furumusic_scheduler_job_running", "SELECT job_name::text AS label, COUNT(*) AS count FROM furumusic__job_run WHERE status = 'running' GROUP BY job_name", "job").await;
+    render_group_sums(out, pool, "furumusic_scheduler_job_enabled", "SELECT name::text AS label, (CASE WHEN enabled THEN 1 ELSE 0 END)::bigint AS value FROM furumusic__scheduled_job", "job").await;
+    render_group_counts(out, pool, "furumusic_torrent_sessions_total", "SELECT status::text AS label, COUNT(*) AS count FROM furumusic__torrent_session GROUP BY status", "status").await;
+    render_single_count(out, pool, "furumusic_play_history_total", "SELECT COUNT(*) FROM furumusic__play_history").await;
+}
+
+async fn render_single_count(out: &mut String, pool: &PgPool, metric: &'static str, sql: &str) {
+    if let Ok(value) = sqlx::query_scalar::<_, i64>(sql).fetch_one(pool).await {
+        emit_static_gauge(out, metric, &[], value as f64);
+    }
+}
+
+async fn render_group_counts(
+    out: &mut String,
+    pool: &PgPool,
+    metric: &'static str,
+    sql: &str,
+    label_name: &'static str,
+) {
+    if let Ok(rows) = sqlx::query_as::<_, (String, i64)>(sql).fetch_all(pool).await {
+        for (label, count) in rows {
+            emit_static_gauge(out, metric, &[(label_name, label.as_str())], count as f64);
+        }
+    }
+}
+
+async fn render_group_sums(
+    out: &mut String,
+    pool: &PgPool,
+    metric: &'static str,
+    sql: &str,
+    label_name: &'static str,
+) {
+    if let Ok(rows) = sqlx::query_as::<_, (String, i64)>(sql).fetch_all(pool).await {
+        for (label, value) in rows {
+            emit_static_gauge(out, metric, &[(label_name, label.as_str())], value as f64);
+        }
+    }
+}
+
+impl Registry {
+    fn inc_counter(&self, name: &'static str, labels: Vec<(&'static str, String)>, value: f64) {
+        if value <= 0.0 {
+            return;
+        }
+        let mut counters = self.counters.lock().expect("counter lock");
+        *counters.entry(MetricKey::new(name, labels)).or_default() += value;
+    }
+
+    fn inc_gauge(&self, name: &'static str, labels: Vec<(&'static str, String)>, value: f64) {
+        let mut gauges = self.gauges.lock().expect("gauge lock");
+        *gauges.entry(MetricKey::new(name, labels)).or_default() += value;
+    }
+
+    fn observe_histogram(
+        &self,
+        name: &'static str,
+        labels: Vec<(&'static str, String)>,
+        value: f64,
+        buckets: &[f64],
+    ) {
+        let mut histograms = self.histograms.lock().expect("histogram lock");
+        let state = histograms
+            .entry(MetricKey::new(name, labels))
+            .or_insert_with(|| HistogramState {
+                buckets: buckets.to_vec(),
+                counts: vec![0; buckets.len()],
+                sum: 0.0,
+                count: 0,
+            });
+        for (index, bucket) in state.buckets.iter().enumerate() {
+            if value <= *bucket {
+                state.counts[index] += 1;
+            }
+        }
+        state.sum += value;
+        state.count += 1;
+    }
+
+    fn render(&self) -> String {
+        let mut out = String::new();
+        for (key, value) in self.counters.lock().expect("counter lock").iter() {
+            emit_type(&mut out, key.name, "counter");
+            emit_metric(&mut out, key.name, &key.labels, *value);
+        }
+        for (key, value) in self.gauges.lock().expect("gauge lock").iter() {
+            emit_type(&mut out, key.name, "gauge");
+            emit_metric(&mut out, key.name, &key.labels, (*value).max(0.0));
+        }
+        for (key, state) in self.histograms.lock().expect("histogram lock").iter() {
+            emit_type(&mut out, key.name, "histogram");
+            for (bucket, count) in state.buckets.iter().zip(state.counts.iter()) {
+                let mut labels = key.labels.clone();
+                labels.push(("le", bucket.to_string()));
+                emit_metric(&mut out, &format!("{}_bucket", key.name), &labels, *count as f64);
+            }
+            let mut inf_labels = key.labels.clone();
+            inf_labels.push(("le", "+Inf".to_owned()));
+            emit_metric(
+                &mut out,
+                &format!("{}_bucket", key.name),
+                &inf_labels,
+                state.count as f64,
+            );
+            emit_metric(
+                &mut out,
+                &format!("{}_sum", key.name),
+                &key.labels,
+                state.sum,
+            );
+            emit_metric(
+                &mut out,
+                &format!("{}_count", key.name),
+                &key.labels,
+                state.count as f64,
+            );
+        }
+        out
+    }
+}
+
+impl MetricKey {
+    fn new(name: &'static str, mut labels: Vec<(&'static str, String)>) -> Self {
+        labels.sort_by(|a, b| a.0.cmp(b.0));
+        Self { name, labels }
+    }
+}
+
+fn http_labels(method: &Method, route: &str, status: &str) -> Vec<(&'static str, String)> {
+    vec![
+        ("method", method.as_str().to_owned()),
+        ("route", route.to_owned()),
+        ("status", status.to_owned()),
+    ]
+}
+
+fn normalize_route(path: &str) -> String {
+    let mut route = String::with_capacity(path.len());
+    for segment in path.split('/') {
+        if segment.is_empty() {
+            continue;
+        }
+        route.push('/');
+        if segment.parse::<i64>().is_ok() || looks_like_uuid(segment) {
+            route.push_str("{id}");
+        } else {
+            route.push_str(segment);
+        }
+    }
+    if route.is_empty() {
+        "/".to_owned()
+    } else {
+        route
+    }
+}
+
+fn looks_like_uuid(value: &str) -> bool {
+    value.len() == 36
+        && value
+            .chars()
+            .all(|ch| ch.is_ascii_hexdigit() || ch == '-')
+}
+
+fn normalize_model_label(value: &str) -> String {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        "unknown".to_owned()
+    } else {
+        trimmed.chars().take(80).collect()
+    }
+}
+
+fn emit_static_gauge(out: &mut String, name: &str, labels: &[(&str, &str)], value: f64) {
+    emit_type(out, name, "gauge");
+    let labels = labels
+        .iter()
+        .map(|(key, value)| (*key, (*value).to_owned()))
+        .collect::<Vec<_>>();
+    emit_metric(out, name, &labels, value);
+}
+
+fn emit_type(out: &mut String, name: &str, metric_type: &str) {
+    let _ = (out, name, metric_type);
+}
+
+fn emit_metric(out: &mut String, name: &str, labels: &[(&str, String)], value: f64) {
+    out.push_str(name);
+    if !labels.is_empty() {
+        out.push('{');
+        for (index, (key, value)) in labels.iter().enumerate() {
+            if index > 0 {
+                out.push(',');
+            }
+            out.push_str(key);
+            out.push_str("=\"");
+            escape_label(out, value);
+            out.push('"');
+        }
+        out.push('}');
+    }
+    out.push(' ');
+    out.push_str(&format!("{value:.6}"));
+    out.push('\n');
+}
+
+fn escape_label(out: &mut String, value: &str) {
+    for ch in value.chars() {
+        match ch {
+            '\\' => out.push_str("\\\\"),
+            '"' => out.push_str("\\\""),
+            '\n' => out.push_str("\\n"),
+            _ => out.push(ch),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct DiskUsage {
+    free_bytes: u64,
+    total_bytes: u64,
+}
+
+#[cfg(windows)]
+fn disk_usage(path: &Path) -> Option<DiskUsage> {
+    use std::os::windows::ffi::OsStrExt;
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn GetDiskFreeSpaceExW(
+            lpDirectoryName: *const u16,
+            lpFreeBytesAvailableToCaller: *mut u64,
+            lpTotalNumberOfBytes: *mut u64,
+            lpTotalNumberOfFreeBytes: *mut u64,
+        ) -> i32;
+    }
+
+    let mut wide: Vec<u16> = path.as_os_str().encode_wide().collect();
+    wide.push(0);
+    let mut free_available = 0_u64;
+    let mut total = 0_u64;
+    let mut total_free = 0_u64;
+    let ok = unsafe {
+        GetDiskFreeSpaceExW(
+            wide.as_ptr(),
+            &mut free_available,
+            &mut total,
+            &mut total_free,
+        )
+    };
+    (ok != 0).then_some(DiskUsage {
+        free_bytes: free_available,
+        total_bytes: total,
+    })
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn disk_usage(path: &Path) -> Option<DiskUsage> {
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+
+    #[repr(C)]
+    struct Statvfs {
+        f_bsize: std::ffi::c_ulong,
+        f_frsize: std::ffi::c_ulong,
+        f_blocks: std::ffi::c_ulong,
+        f_bfree: std::ffi::c_ulong,
+        f_bavail: std::ffi::c_ulong,
+        f_files: std::ffi::c_ulong,
+        f_ffree: std::ffi::c_ulong,
+        f_favail: std::ffi::c_ulong,
+        f_fsid: std::ffi::c_ulong,
+        f_flag: std::ffi::c_ulong,
+        f_namemax: std::ffi::c_ulong,
+        __f_spare: [std::ffi::c_int; 6],
+    }
+
+    unsafe extern "C" {
+        fn statvfs(path: *const std::ffi::c_char, buf: *mut Statvfs) -> std::ffi::c_int;
+    }
+
+    let c_path = CString::new(path.as_os_str().as_bytes()).ok()?;
+    let mut stat = std::mem::MaybeUninit::<Statvfs>::uninit();
+    let ok = unsafe { statvfs(c_path.as_ptr(), stat.as_mut_ptr()) };
+    if ok != 0 {
+        return None;
+    }
+    let stat = unsafe { stat.assume_init() };
+    let fragment_size = if stat.f_frsize > 0 {
+        stat.f_frsize as u64
+    } else {
+        stat.f_bsize as u64
+    };
+    Some(DiskUsage {
+        free_bytes: stat.f_bavail as u64 * fragment_size,
+        total_bytes: stat.f_blocks as u64 * fragment_size,
+    })
+}
+
+#[cfg(not(any(windows, target_os = "linux", target_os = "android")))]
+fn disk_usage(_path: &Path) -> Option<DiskUsage> {
+    None
+}

src/music/mod.rs

@@ -1865,6 +1865,51 @@ pub mod db_migrations {
             &[Operation::custom(create_entity_genre_tags).build()];
     }
 
+    // -- M0036: External metadata identifiers --------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_external_metadata_ids(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__external_metadata_id (
+                    id BIGSERIAL PRIMARY KEY,
+                    entity_kind VARCHAR(32) NOT NULL,
+                    entity_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    id_kind VARCHAR(64) NOT NULL,
+                    external_id VARCHAR(255) NOT NULL,
+                    confidence DOUBLE PRECISION NOT NULL DEFAULT 1,
+                    updated_at VARCHAR(32) NOT NULL,
+                    UNIQUE(entity_kind, entity_id, source, id_kind)
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_external_metadata_id_lookup
+                   ON furumusic__external_metadata_id (source, id_kind, external_id)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0036CreateExternalMetadataIds;
+
+    impl migrations::Migration for M0036CreateExternalMetadataIds {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0036_create_external_metadata_ids";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0035_create_entity_genre_tags",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_external_metadata_ids).build()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1891,5 +1936,6 @@ pub mod db_migrations {
         &M0033CreateLastfmScrobbling,
         &M0034CreateArtworkLookupState,
         &M0035CreateEntityGenreTags,
+        &M0036CreateExternalMetadataIds,
     ];
 }

src/oidc.rs

@@ -172,6 +172,7 @@ pub async fn oidc_start_handler(
         || config.oidc_client_secret.is_empty()
     {
         tracing::warn!("OIDC start requested but SSO is not configured");
+        crate::metrics::record_auth_attempt("oidc", "failure", "not_configured");
         return redirect_login_with_error(i18n.t.login_sso_disabled);
     }
 
@@ -180,6 +181,7 @@ pub async fn oidc_start_handler(
         Ok(c) => c,
         Err(e) => {
             tracing::error!("OIDC provider error: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "provider_error");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -276,19 +278,23 @@ pub async fn oidc_callback_handler(
     // Validate CSRF state.
     let Some(saved_csrf) = saved_csrf else {
         tracing::warn!("OIDC callback: no CSRF state in session");
+        crate::metrics::record_auth_attempt("oidc", "failure", "missing_state");
         return redirect_login_with_error(i18n.t.login_oidc_error);
     };
     if query.state != saved_csrf {
         tracing::warn!("OIDC callback: CSRF state mismatch");
+        crate::metrics::record_auth_attempt("oidc", "failure", "csrf");
         return redirect_login_with_error(i18n.t.login_oidc_error);
     }
 
     let Some(nonce_str) = saved_nonce else {
         tracing::warn!("OIDC callback: no nonce in session");
+        crate::metrics::record_auth_attempt("oidc", "failure", "missing_nonce");
         return redirect_login_with_error(i18n.t.login_oidc_error);
     };
     let Some(pkce_str) = saved_pkce else {
         tracing::warn!("OIDC callback: no PKCE verifier in session");
+        crate::metrics::record_auth_attempt("oidc", "failure", "missing_pkce");
         return redirect_login_with_error(i18n.t.login_oidc_error);
     };
 
@@ -300,6 +306,7 @@ pub async fn oidc_callback_handler(
         Ok(c) => c,
         Err(e) => {
             tracing::error!("OIDC provider error during callback: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "provider_error");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -318,6 +325,7 @@ pub async fn oidc_callback_handler(
         Ok(req) => req,
         Err(e) => {
             tracing::error!("OIDC token endpoint not configured: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "token_config");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -330,6 +338,7 @@ pub async fn oidc_callback_handler(
         Ok(t) => t,
         Err(e) => {
             tracing::error!("OIDC token exchange failed: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "token_exchange");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -340,6 +349,7 @@ pub async fn oidc_callback_handler(
         Some(t) => t,
         None => {
             tracing::error!("OIDC response missing ID token");
+            crate::metrics::record_auth_attempt("oidc", "failure", "missing_id_token");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -348,6 +358,7 @@ pub async fn oidc_callback_handler(
         Ok(c) => c,
         Err(e) => {
             tracing::error!("OIDC ID token verification failed: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "id_token_verify");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
@@ -395,6 +406,7 @@ pub async fn oidc_callback_handler(
             config.oidc_user_groups,
             config.oidc_admin_groups,
         );
+        crate::metrics::record_auth_attempt("oidc", "failure", "not_in_group");
         return redirect_login_with_error(i18n.t.login_access_denied);
     }
 
@@ -413,12 +425,15 @@ pub async fn oidc_callback_handler(
         Ok(u) => u,
         Err(e) => {
             tracing::error!("OIDC user provisioning failed: {e}");
+            crate::metrics::record_auth_attempt("oidc", "failure", "provisioning");
             return redirect_login_with_error(i18n.t.login_oidc_error);
         }
     };
 
     // Log the user in.
     auth::login(&session, user.id_val()).await?;
+    crate::metrics::record_auth_attempt("oidc", "success", "ok");
+    crate::metrics::record_session_created("oidc");
 
     // Clear OIDC session keys.
     let _: Option<String> = session

src/player/dto.rs

@@ -16,6 +16,7 @@ pub(super) struct Paginated<T: Serialize> {
     pub(super) total: i64,
     pub(super) page: i32,
     pub(super) per_page: i32,
+    pub(super) has_more: bool,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]

src/player/mod.rs

@@ -2360,7 +2360,7 @@ async fn load_user_upload_queue(
            ORDER BY
              CASE status WHEN 'processing' THEN 0 ELSE 1 END,
              created_at DESC
-           LIMIT 20"#,
+           LIMIT 100"#,
     )
     .bind(uploaded_by_pattern)
     .fetch_all(pool)
@@ -2774,20 +2774,86 @@ async fn artists_handler(
     pool: &sqlx::PgPool,
     query: cot::request::extractors::UrlQuery<PaginationQuery>,
 ) -> cot::Result<cot::response::Response> {
-    let Some(_user) = auth::get_session_user(&session, &db).await else {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
         return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
     };
 
     let page = query.0.page.unwrap_or(1).max(1);
     let per_page = query.0.limit.unwrap_or(60).clamp(1, 200);
     let offset = (page - 1) as i64 * per_page as i64;
+    let mine = query.0.mine.unwrap_or(false);
+
+    if mine {
+        let total_row = sqlx::query_as::<_, CountRow>(
+            r#"SELECT COUNT(DISTINCT a.id) AS count
+               FROM furumusic__artist a
+               JOIN furumusic__track_artist ta ON ta.artist_id = a.id
+               JOIN furumusic__track t ON t.id = ta.track_id AND t.is_hidden = false
+               JOIN furumusic__release r ON r.id = t.release_id AND r.is_hidden = false
+               JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
+              WHERE a.is_hidden = false
+                AND mf.uploaded_by_user_id = $1"#,
+        )
+        .bind(user.id)
+        .fetch_one(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+        let rows = sqlx::query_as::<_, ArtistRow>(
+            r#"SELECT a.id, a.name::text as name, a.image_file_id,
+                      COUNT(DISTINCT r.id) FILTER (WHERE primary_release.artist_id IS NOT NULL) AS release_count,
+                      COUNT(DISTINCT t.id) AS track_count
+               FROM furumusic__artist a
+               JOIN furumusic__track_artist ta ON ta.artist_id = a.id
+               JOIN furumusic__track t ON t.id = ta.track_id AND t.is_hidden = false
+               JOIN furumusic__release r ON r.id = t.release_id AND r.is_hidden = false
+               JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
+               LEFT JOIN furumusic__release_artist primary_release
+                 ON primary_release.release_id = r.id
+                AND primary_release.artist_id = a.id
+                AND primary_release.position = 0
+              WHERE a.is_hidden = false
+                AND mf.uploaded_by_user_id = $1
+              GROUP BY a.id, a.name, a.name_sort, a.image_file_id
+              ORDER BY (COUNT(DISTINCT r.id) FILTER (WHERE primary_release.artist_id IS NOT NULL) > 0) DESC,
+                       release_count DESC,
+                       track_count DESC,
+                       a.name_sort
+              LIMIT $2 OFFSET $3"#,
+        )
+        .bind(user.id)
+        .bind(per_page as i64)
+        .bind(offset)
+        .fetch_all(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+        let items: Vec<ArtistCard> = rows
+            .into_iter()
+            .map(|r| ArtistCard {
+                id: r.id,
+                name: r.name,
+                image_url: cover_variant_url(r.image_file_id, "medium"),
+                release_count: r.release_count,
+                track_count: r.track_count,
+            })
+            .collect();
+        let has_more = offset + (items.len() as i64) < total_row.count;
+
+        return Json(Paginated {
+            items,
+            total: total_row.count,
+            page,
+            per_page,
+            has_more,
+        })
+        .into_response();
+    }
 
     let total_row = sqlx::query_as::<_, CountRow>(
-        r#"SELECT COUNT(DISTINCT a.id) AS count
+        r#"SELECT COUNT(*) AS count
            FROM furumusic__artist a
-           JOIN furumusic__release_artist ra ON ra.artist_id = a.id
-           JOIN furumusic__release r ON r.id = ra.release_id
-           WHERE a.is_hidden = false AND r.is_hidden = false AND ra.position = 0"#,
+           WHERE a.is_hidden = false"#,
     )
     .fetch_one(pool)
     .await
@@ -2795,21 +2861,33 @@ async fn artists_handler(
 
     let rows = sqlx::query_as::<_, ArtistRow>(
         r#"SELECT a.id, a.name::text as name, a.image_file_id,
-                  s.release_count,
-                  s.track_count
+                  COALESCE(s.release_count, 0) AS release_count,
+                  COALESCE(s.track_count, 0) AS track_count
            FROM furumusic__artist a
-           JOIN (
-               SELECT ra.artist_id,
-                      COUNT(DISTINCT r.id) AS release_count,
-                      COUNT(t.id) AS track_count
-               FROM furumusic__release_artist ra
-               JOIN furumusic__release r ON r.id = ra.release_id AND r.is_hidden = false
-               LEFT JOIN furumusic__track t ON t.release_id = r.id AND t.is_hidden = false
-               WHERE ra.position = 0
-               GROUP BY ra.artist_id
+           LEFT JOIN (
+               SELECT appearance.artist_id,
+                      COUNT(DISTINCT appearance.release_id) FILTER (WHERE appearance.is_primary_release_artist) AS release_count,
+                      COUNT(DISTINCT appearance.track_id) AS track_count
+                 FROM (
+                        SELECT ta.artist_id,
+                               t.id AS track_id,
+                               r.id AS release_id,
+                               primary_release.artist_id IS NOT NULL AS is_primary_release_artist
+                          FROM furumusic__track_artist ta
+                          JOIN furumusic__track t ON t.id = ta.track_id AND t.is_hidden = false
+                          JOIN furumusic__release r ON r.id = t.release_id AND r.is_hidden = false
+                          LEFT JOIN furumusic__release_artist primary_release
+                            ON primary_release.release_id = r.id
+                           AND primary_release.artist_id = ta.artist_id
+                           AND primary_release.position = 0
+                      ) appearance
+                GROUP BY appearance.artist_id
            ) s ON s.artist_id = a.id
            WHERE a.is_hidden = false
-           ORDER BY s.release_count DESC, s.track_count DESC, a.name_sort
+           ORDER BY (COALESCE(s.release_count, 0) > 0) DESC,
+                    COALESCE(s.release_count, 0) DESC,
+                    COALESCE(s.track_count, 0) DESC,
+                    a.name_sort
            LIMIT $1 OFFSET $2"#,
     )
     .bind(per_page as i64)
@@ -2828,12 +2906,14 @@ async fn artists_handler(
             track_count: r.track_count,
         })
         .collect();
+    let has_more = offset + (items.len() as i64) < total_row.count;
 
     Json(Paginated {
         items,
         total: total_row.count,
         page,
         per_page,
+        has_more,
     })
     .into_response()
 }
@@ -3421,10 +3501,7 @@ async fn build_track_items(
         .collect())
 }
 
-async fn load_track_items_by_ids(
-    pool: &sqlx::PgPool,
-    ids: &[i64],
-) -> cot::Result<Vec<TrackItem>> {
+async fn load_track_items_by_ids(pool: &sqlx::PgPool, ids: &[i64]) -> cot::Result<Vec<TrackItem>> {
     if ids.is_empty() {
         return Ok(Vec::new());
     }
@@ -3571,6 +3648,7 @@ async fn stream_handler(
             let chunk_size = end - start + 1;
 
             let data = read_file_range(&full_path, start, chunk_size).await?;
+            crate::metrics::record_stream_request(true, chunk_size);
 
             let response = cot::http::Response::builder()
                 .status(StatusCode::PARTIAL_CONTENT)
@@ -3589,6 +3667,7 @@ async fn stream_handler(
     let data = tokio::fs::read(&full_path)
         .await
         .map_err(|e| cot::Error::internal(e.to_string()))?;
+    crate::metrics::record_stream_request(false, file_size);
 
     let response = cot::http::Response::builder()
         .status(StatusCode::OK)
@@ -4012,7 +4091,10 @@ async fn devices_command_handler(
 }
 
 fn stamp_jam_queue_tracks(payload: &mut serde_json::Value, user_id: i64, user_name: &str) {
-    let Some(tracks) = payload.get_mut("tracks").and_then(serde_json::Value::as_array_mut) else {
+    let Some(tracks) = payload
+        .get_mut("tracks")
+        .and_then(serde_json::Value::as_array_mut)
+    else {
         return;
     };
     for track in tracks {
@@ -4491,6 +4573,7 @@ async fn history_handler(
     .execute(pool)
     .await
     .map_err(|e| cot::Error::internal(e.to_string()))?;
+    crate::metrics::record_play_history(entry.duration_listened, entry.completed);
 
     if let Some(listened_seconds) = entry.duration_listened {
         let (config, _) = AppConfig::load_with_db(&db).await;
@@ -5730,7 +5813,8 @@ async fn build_track_radio_ids(
 
     let artist_ids = track_primary_artist_ids(pool, track_id).await?;
     let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
-    let fallback_ids = fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
+    let fallback_ids =
+        fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
     append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
 
     Ok(Some(ids))
@@ -5786,7 +5870,8 @@ async fn build_release_radio_ids(
 
     let artist_ids = release_primary_artist_ids(pool, release_id).await?;
     let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
-    let fallback_ids = fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
+    let fallback_ids =
+        fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
     append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
 
     Ok(Some(ids))
@@ -6689,22 +6774,24 @@ impl App for PlayerApp {
                 {
                     let pool = Arc::clone(&pool);
                     let pool_config = Arc::clone(&pool_config);
-                    get(move |session: Session, db: Database, path: Path<PathRadioSeed>| {
-                        let pool = Arc::clone(&pool);
-                        let pool_config = Arc::clone(&pool_config);
-                        async move {
-                            let pg_pool = pool
-                                .get_or_init(|| async {
-                                    sqlx::postgres::PgPoolOptions::new()
-                                        .max_connections(5)
-                                        .connect(&pool_config.database_url)
-                                        .await
-                                        .expect("player pool")
-                                })
-                                .await;
-                            radio_handler(session, db, pg_pool, path).await
-                        }
-                    })
+                    get(
+                        move |session: Session, db: Database, path: Path<PathRadioSeed>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            async move {
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("player pool")
+                                    })
+                                    .await;
+                                radio_handler(session, db, pg_pool, path).await
+                            }
+                        },
+                    )
                 },
                 "player_radio",
             ),

src/player/queries.rs

@@ -49,6 +49,7 @@ pub(super) struct RemoveTrackRequest {
 pub(super) struct PaginationQuery {
     pub(super) page: Option<i32>,
     pub(super) limit: Option<i32>,
+    pub(super) mine: Option<bool>,
 }
 
 #[derive(Debug, Deserialize)]

src/scheduler/mod.rs

@@ -200,6 +200,12 @@ impl JobRun {
         duration_ms: i64,
         log: &str,
     ) -> cot::db::Result<()> {
+        crate::metrics::record_scheduler_job(
+            self.job_name.as_str(),
+            self.trigger.as_str(),
+            "completed",
+            duration_ms,
+        );
         self.status = LimitedString::new("completed").unwrap();
         self.finished_at = Some(now_iso().to_string());
         self.duration_ms = Some(duration_ms);
@@ -214,6 +220,12 @@ impl JobRun {
         log: &str,
         error: &str,
     ) -> cot::db::Result<()> {
+        crate::metrics::record_scheduler_job(
+            self.job_name.as_str(),
+            self.trigger.as_str(),
+            "failed",
+            duration_ms,
+        );
         self.status = LimitedString::new("failed").unwrap();
         self.finished_at = Some(now_iso().to_string());
         self.duration_ms = Some(duration_ms);

src/torrents.rs

@@ -777,7 +777,7 @@ impl TorrentService {
 
         self.ensure_memory_job(pool, uploader_user_id, id).await?;
 
-        let (torrent_bytes, output_dir) = {
+        let (torrent_bytes, output_dir, selected_size) = {
             let mut jobs = self.jobs.lock().await;
             let job = jobs.get_mut(id).context("torrent job not found")?;
             if job.user_id != uploader_user_id {
@@ -800,7 +800,11 @@ impl TorrentService {
             job.error = None;
             job.completed_at = None;
             job.updated_at = now_string();
-            (job.torrent_bytes.clone(), job.output_dir.clone())
+            (
+                job.torrent_bytes.clone(),
+                job.output_dir.clone(),
+                job.selected_size(),
+            )
         };
 
         tokio::fs::create_dir_all(&output_dir).await?;
@@ -846,6 +850,7 @@ impl TorrentService {
         let service = Arc::clone(self);
         let pool = pool.clone();
         let id = id.to_string();
+        let download_start = std::time::Instant::now();
         tokio::spawn(async move {
             if let Err(err) = handle.wait_until_completed().await {
                 if service.is_paused(&id).await {
@@ -853,6 +858,11 @@ impl TorrentService {
                 }
                 service.stop_torrent(&handle).await;
                 service.fail_job(&pool, &id, err.to_string()).await;
+                crate::metrics::record_torrent_download(
+                    "failed",
+                    selected_size,
+                    download_start.elapsed(),
+                );
                 return;
             }
             service.stop_torrent(&handle).await;
@@ -861,6 +871,17 @@ impl TorrentService {
                 .await
             {
                 service.fail_job(&pool, &id, err.to_string()).await;
+                crate::metrics::record_torrent_download(
+                    "failed",
+                    selected_size,
+                    download_start.elapsed(),
+                );
+            } else {
+                crate::metrics::record_torrent_download(
+                    "completed",
+                    selected_size,
+                    download_start.elapsed(),
+                );
             }
         });
 

templates/admin/v2.html

@@ -185,7 +185,7 @@ button {
 
 .stats-strip {
     display: grid;
-    grid-template-columns: repeat(7, minmax(104px, 1fr));
+    grid-template-columns: repeat(auto-fit, minmax(132px, 1fr));
     gap: 8px;
     margin-bottom: 14px;
 }
@@ -201,12 +201,18 @@ button {
 .stat-value {
     font-size: 18px;
     font-weight: 800;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 
 .stat-label {
     margin-top: 2px;
     color: var(--text-subdued);
     font-size: 11px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 
 .panel {
@@ -301,7 +307,8 @@ button {
 }
 
 .btn:disabled,
-.icon-btn:disabled {
+.icon-btn:disabled,
+.seg-btn:disabled {
     opacity: 0.45;
     cursor: not-allowed;
 }
@@ -410,6 +417,15 @@ tbody tr:hover {
 .col-tags { width: 250px; }
 .col-time { width: 132px; }
 
+.users-table-wrap {
+    max-height: calc(100vh - 300px);
+}
+
+.users-table .user-status-column { width: 116px; }
+.users-table .user-role-column { width: 110px; }
+.users-table .user-active-column { width: 112px; }
+.users-table .user-seen-column { width: 170px; }
+
 .check {
     width: 16px;
     height: 16px;
@@ -1268,6 +1284,137 @@ tbody tr:hover {
     padding: 14px;
     overflow: auto;
 }
+
+.user-modal {
+    width: min(860px, calc(100vw - 80px));
+}
+
+.user-modal-tabs {
+    margin-bottom: 14px;
+}
+
+.user-summary-grid,
+.user-profile-facts {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 8px;
+    margin-bottom: 14px;
+}
+
+.user-summary-card,
+.user-profile-facts > div {
+    min-width: 0;
+    padding: 10px 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
+.user-summary-card span,
+.user-profile-facts span {
+    display: block;
+    color: var(--text-subdued);
+    font-size: 11px;
+    margin-bottom: 4px;
+}
+
+.user-summary-card strong,
+.user-profile-facts strong {
+    display: block;
+    overflow: hidden;
+    color: var(--text-primary);
+    font-size: 13px;
+    font-weight: 800;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.user-stats-grid {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.user-activity-list {
+    display: grid;
+    gap: 8px;
+}
+
+.user-activity-row {
+    min-width: 0;
+    padding: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+    display: grid;
+    grid-template-columns: 52px minmax(0, 1fr) auto;
+    align-items: center;
+    gap: 10px;
+}
+
+.user-activity-cover {
+    width: 52px;
+    height: 52px;
+    border-radius: 4px;
+    background: var(--bg-elevated);
+    overflow: hidden;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-subdued);
+}
+
+.user-activity-cover img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.user-activity-cover svg {
+    width: 24px;
+    height: 24px;
+}
+
+.user-activity-main {
+    min-width: 0;
+}
+
+.user-activity-title,
+.user-activity-meta,
+.user-activity-sub {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.user-activity-title {
+    color: var(--text-primary);
+    font-size: 13px;
+    font-weight: 800;
+}
+
+.user-activity-meta {
+    margin-top: 3px;
+    color: var(--text-secondary);
+    font-size: 12px;
+}
+
+.user-activity-sub {
+    margin-top: 3px;
+    color: var(--text-subdued);
+    font-size: 11px;
+}
+
+.user-activity-time {
+    min-width: 118px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    text-align: right;
+}
+
+.user-activity-time strong {
+    display: block;
+    color: var(--text-primary);
+    font-size: 12px;
+}
 </style>
 {% endblock head_extra %}
 
@@ -1287,7 +1434,7 @@ tbody tr:hover {
             <button class="nav-btn" :class="{active: activeView === 'reviews'}" @click="openReviews()">
                 <i data-lucide="inbox"></i>
                 <span>Review Queue</span>
-                <span class="nav-count" x-text="reviews.total || 0"></span>
+                <span class="nav-count" x-text="reviewTotalAll()"></span>
             </button>
             <button class="nav-btn" :class="{active: activeView === 'jobs'}" @click="openJobs()">
                 <i data-lucide="calendar-clock"></i>
@@ -1303,6 +1450,11 @@ tbody tr:hover {
                 <i data-lucide="wrench"></i>
                 <span>Future Tools</span>
             </button>
+            <button class="nav-btn" :class="{active: activeView === 'users'}" @click="openUsers()">
+                <i data-lucide="users"></i>
+                <span>Users</span>
+                <span class="nav-count" x-text="users.online_count ? users.online_count + ' online' : ''"></span>
+            </button>
             <button class="nav-btn" :class="{active: activeView === 'settings'}" @click="openSettings()">
                 <i data-lucide="settings"></i>
                 <span>Settings</span>
@@ -1355,8 +1507,8 @@ tbody tr:hover {
         <div class="content" x-show="activeView === 'reviews'">
             <section class="stats-strip">
                 <template x-for="cell in statCells()" :key="cell.label">
-                    <div class="stat-cell">
-                        <div class="stat-value" x-text="fmt(cell.value)"></div>
+                    <div class="stat-cell" :title="cell.title || ''">
+                        <div class="stat-value" x-text="cell.display || fmt(cell.value)"></div>
                         <div class="stat-label" x-text="cell.label"></div>
                     </div>
                 </template>
@@ -1374,7 +1526,7 @@ tbody tr:hover {
                                 <template x-for="status in reviewStatuses" :key="status.value">
                                     <button class="seg-btn" :class="{active: reviewFilter.status === status.value}" @click="setReviewStatus(status.value)">
                                         <span x-text="status.label"></span>
-                                        <span class="muted" x-text="status.value ? statusCount(status.value) : reviews.total"></span>
+                                        <span class="muted" x-text="status.value ? statusCount(status.value) : reviewTotalAll()"></span>
                                     </button>
                                 </template>
                             </div>
@@ -1563,12 +1715,19 @@ tbody tr:hover {
                                 <label><input type="checkbox" x-model="metadataBackfillOptions.duration_seconds" /> duration_seconds</label>
                                 <label><input type="checkbox" x-model="metadataBackfillOptions.local_genres" /> local genres from files</label>
                                 <label><input type="checkbox" x-model="metadataBackfillOptions.lastfm_tags" /> Last.fm tags</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.musicbrainz_tags" /> MusicBrainz tags</label>
                             </div>
                             <div class="mode-row">
                                 <label><input type="radio" value="fill_missing" x-model="metadataBackfillOptions.mode" /> Fill missing only</label>
                                 <label><input type="radio" value="overwrite" x-model="metadataBackfillOptions.mode" /> Overwrite existing values</label>
                             </div>
                         </div>
+                        <div class="metadata-backfill-options" x-show="isArtworkBackfillJob(activeJob)">
+                            <div class="mode-row">
+                                <label><input type="radio" value="missing" x-model="artworkBackfillOptions.mode" /> Missing images only</label>
+                                <label><input type="radio" value="overwrite" x-model="artworkBackfillOptions.mode" /> Search all and replace existing</label>
+                            </div>
+                        </div>
                         <div class="job-param-note" x-show="activeJob && !jobHasParameterForm(activeJob)">
                             This task has no manual parameters.
                         </div>
@@ -1723,6 +1882,79 @@ tbody tr:hover {
             </div>
         </div>
 
+        <div class="content" x-show="activeView === 'users'">
+            <section class="stats-strip">
+                <div class="stat-cell">
+                    <div class="stat-value" x-text="fmt(users.total || 0)"></div>
+                    <div class="stat-label">Users</div>
+                </div>
+                <div class="stat-cell">
+                    <div class="stat-value" x-text="fmt(users.online_count || 0)"></div>
+                    <div class="stat-label">Online now</div>
+                </div>
+            </section>
+            <section class="panel">
+                <div class="panel-head">
+                    <div class="panel-title">
+                        <strong>Users</strong>
+                        <span x-text="usersSubtitle()"></span>
+                    </div>
+                    <div class="toolbar">
+                        <input class="search" placeholder="Search users" x-model="userSearch" @input.debounce.350ms="loadUsers()" />
+                        <button class="btn" @click="loadUsers(false)">
+                            <i data-lucide="refresh-cw"></i>
+                            Refresh
+                        </button>
+                    </div>
+                </div>
+                <div class="table-wrap users-table-wrap">
+                    <table class="users-table">
+                        <thead>
+                            <tr>
+                                <th class="user-status-column">Status</th>
+                                <th>User</th>
+                                <th class="user-role-column">Role</th>
+                                <th class="user-active-column">Account</th>
+                                <th class="user-seen-column">Last activity</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <template x-for="user in users.items" :key="user.id">
+                                <tr @click="openUser(user)">
+                                    <td>
+                                        <span class="badge" :class="userStatusClass(user)" x-text="userStatusLabel(user)"></span>
+                                    </td>
+                                    <td>
+                                        <div class="primary-line" x-text="user.display_name || user.username"></div>
+                                        <div class="secondary-line" x-text="user.email ? user.username + ' · ' + user.email : user.username"></div>
+                                    </td>
+                                    <td><span x-text="user.role"></span></td>
+                                    <td>
+                                        <span class="badge" :class="user.is_active ? 'ok' : 'disabled'" x-text="user.is_active ? 'active' : 'disabled'"></span>
+                                    </td>
+                                    <td><span x-text="userLastSeenLabel(user)"></span></td>
+                                </tr>
+                            </template>
+                        </tbody>
+                    </table>
+                    <div class="empty" x-show="!usersLoading && users.items.length === 0">No users in this filter</div>
+                </div>
+                <div class="action-strip">
+                    <span class="selection-summary" x-text="usersRangeText()"></span>
+                    <div class="toolbar">
+                        <select class="search" style="width:92px" x-model.number="users.limit" @change="users.offset = 0; loadUsers(false)">
+                            <option value="25">25</option>
+                            <option value="40">40</option>
+                            <option value="80">80</option>
+                            <option value="120">120</option>
+                        </select>
+                        <button class="btn" @click="pageUsers(-1)" :disabled="users.offset === 0">Previous</button>
+                        <button class="btn" @click="pageUsers(1)" :disabled="users.offset + users.limit >= users.total">Next</button>
+                    </div>
+                </div>
+            </section>
+        </div>
+
         <div class="content" x-show="activeView === 'tools'">
             <section class="panel">
                 <div class="panel-head">
@@ -2004,6 +2236,90 @@ tbody tr:hover {
         </div>
     </main>
 
+    <div class="modal-backdrop" x-show="userModalOpen && activeUserDetail" x-transition @click.self="userModalOpen = false">
+        <section class="modal user-modal">
+            <div class="modal-head">
+                <div class="panel-title">
+                    <strong x-text="activeUserDetail ? (activeUserDetail.user.display_name || activeUserDetail.user.username) : 'User'"></strong>
+                    <span x-text="activeUserDetail ? userStatusLabel(activeUserDetail.user) + ' · ' + activeUserDetail.user.role : ''"></span>
+                </div>
+                <button class="icon-btn" @click="userModalOpen = false">
+                    <i data-lucide="x"></i>
+                </button>
+            </div>
+            <div class="modal-body" x-show="activeUserDetail">
+                <div class="segmented user-modal-tabs">
+                    <button class="seg-btn" :class="{active: userModalTab === 'overview'}" @click="userModalTab = 'overview'">Overview</button>
+                    <button class="seg-btn" :class="{active: userModalTab === 'activity'}" @click="userModalTab = 'activity'">Activity</button>
+                    <button class="seg-btn" :class="{active: userModalTab === 'library'}" @click="userModalTab = 'library'" disabled>Library</button>
+                </div>
+                <div x-show="userModalTab === 'overview'">
+                    <section class="user-summary-grid">
+                        <div class="user-summary-card">
+                            <span>Status</span>
+                            <strong x-text="userStatusLabel(activeUserDetail.user)"></strong>
+                        </div>
+                        <div class="user-summary-card">
+                            <span>Last activity</span>
+                            <strong x-text="userLastSeenLabel(activeUserDetail.user)"></strong>
+                        </div>
+                        <div class="user-summary-card">
+                            <span>Account</span>
+                            <strong x-text="activeUserDetail.user.is_active ? 'active' : 'disabled'"></strong>
+                        </div>
+                        <div class="user-summary-card">
+                            <span>Last.fm</span>
+                            <strong x-text="activeUserDetail.stats.lastfm_connected ? 'connected' : 'not connected'"></strong>
+                        </div>
+                    </section>
+                    <section class="stats-strip user-stats-grid">
+                        <template x-for="cell in userStatCards()" :key="cell.label">
+                            <div class="stat-cell">
+                                <div class="stat-value" x-text="cell.display"></div>
+                                <div class="stat-label" x-text="cell.label"></div>
+                            </div>
+                        </template>
+                    </section>
+                    <div class="field">
+                        <label>Profile</label>
+                        <div class="user-profile-facts">
+                            <div><span>Username</span><strong x-text="activeUserDetail.user.username"></strong></div>
+                            <div><span>Email</span><strong x-text="activeUserDetail.user.email || 'not set'"></strong></div>
+                            <div><span>Display name</span><strong x-text="activeUserDetail.user.display_name || 'not set'"></strong></div>
+                            <div><span>Role</span><strong x-text="activeUserDetail.user.role"></strong></div>
+                        </div>
+                    </div>
+                </div>
+                <div x-show="userModalTab === 'activity'">
+                    <div class="user-activity-list">
+                        <template x-for="play in (activeUserDetail?.recent_plays || [])" :key="play.history_id">
+                            <div class="user-activity-row">
+                                <div class="user-activity-cover">
+                                    <template x-if="play.cover_url">
+                                        <img :src="play.cover_url" :alt="play.release_title || play.title" loading="lazy">
+                                    </template>
+                                    <template x-if="!play.cover_url">
+                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
+                                    </template>
+                                </div>
+                                <div class="user-activity-main">
+                                    <div class="user-activity-title" x-text="play.title"></div>
+                                    <div class="user-activity-meta" x-text="play.artists"></div>
+                                    <div class="user-activity-sub" x-text="userPlayMeta(play)"></div>
+                                </div>
+                                <div class="user-activity-time">
+                                    <strong x-text="userPlayListened(play)"></strong>
+                                    <span x-text="shortDate(play.played_at)"></span>
+                                </div>
+                            </div>
+                        </template>
+                        <div class="empty" x-show="activeUserDetail && (!activeUserDetail.recent_plays || activeUserDetail.recent_plays.length === 0)">No play history for this user yet</div>
+                    </div>
+                </div>
+            </div>
+        </section>
+    </div>
+
     <div class="modal-backdrop" x-show="reviewModalOpen && activeReview" x-transition @click.self="reviewModalOpen = false">
         <section class="modal">
             <div class="modal-head">
@@ -2298,8 +2614,15 @@ function adminV2() {
         libraryLoading: false,
         toastMessage: '',
         stats: {},
+        runtime: { agent: {}, storage: [], node: {} },
         libraryOverview: {},
-        reviews: { items: [], total: 0, limit: 80, offset: 0, status_counts: [] },
+        reviews: { items: [], total: 0, total_all: 0, limit: 80, offset: 0, status_counts: [] },
+        users: { items: [], total: 0, limit: 40, offset: 0, online_count: 0 },
+        usersLoading: false,
+        userSearch: '',
+        userModalOpen: false,
+        userModalTab: 'overview',
+        activeUserDetail: null,
         reviewFilter: { status: null, search: '' },
         selectedReviewIds: {},
         reviewSelectionScope: 'ids',
@@ -2340,8 +2663,12 @@ function adminV2() {
             duration_seconds: true,
             local_genres: true,
             lastfm_tags: true,
+            musicbrainz_tags: true,
             mode: 'fill_missing'
         },
+        artworkBackfillOptions: {
+            mode: 'missing'
+        },
         libraryKind: 'artists',
         librarySearch: '',
         library: { items: [], total: 0, limit: 40, offset: 0 },
@@ -2419,6 +2746,7 @@ function adminV2() {
             try {
                 const data = await this.request(`${this.apiBase}/dashboard`);
                 this.stats = data.stats || {};
+                this.runtime = data.runtime || this.runtime;
                 this.libraryOverview = data.library || {};
                 this.reviews = data.reviews || this.reviews;
                 this.jobs = data.jobs || [];
@@ -2442,6 +2770,8 @@ function adminV2() {
                     this.activeJobName ? this.loadRunsForJob(this.activeJobName, false) : Promise.resolve(),
                     this.refreshActiveRunDetail()
                 ]);
+            } else if (this.activeView === 'users') {
+                await Promise.allSettled([this.loadUsers(false)]);
             } else {
                 await Promise.allSettled([this.loadJobs(false), this.loadReviews(false)]);
             }
@@ -2474,6 +2804,8 @@ function adminV2() {
                 this.libraryKind = nextKind;
             } else if (view === 'settings') {
                 this.activeView = 'settings';
+            } else if (view === 'users') {
+                this.activeView = 'users';
             } else if (view === 'tools') {
                 this.activeView = 'tools';
             } else {
@@ -2505,6 +2837,9 @@ function adminV2() {
                 if (!this.settingsProbe.status || this.settingsProbe.status === 'idle') {
                     await this.loadSettingsProbe(false);
                 }
+            } else if (this.activeView === 'users') {
+                if (updateRoute) this.setRoute('#users');
+                await this.loadUsers(false);
             } else if (this.activeView === 'tools' && updateRoute) {
                 this.setRoute('#tools');
             }
@@ -2547,6 +2882,12 @@ function adminV2() {
             this.setRoute('#tools');
         },
 
+        openUsers() {
+            this.activeView = 'users';
+            this.setRoute('#users');
+            this.loadUsers();
+        },
+
         async loadReviews(resetOffset = true) {
             if (resetOffset) this.reviews.offset = 0;
             const params = new URLSearchParams();
@@ -2595,6 +2936,38 @@ function adminV2() {
             }
         },
 
+        async loadUsers(resetOffset = true) {
+            if (this.activeView !== 'users' && resetOffset) return;
+            if (resetOffset) this.users.offset = 0;
+            this.usersLoading = true;
+            const params = new URLSearchParams();
+            params.set('limit', this.users.limit || 40);
+            params.set('offset', this.users.offset || 0);
+            if (this.userSearch) params.set('search', this.userSearch);
+            try {
+                this.users = await this.request(`${this.apiBase}/users?${params.toString()}`);
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.usersLoading = false;
+                this.icons();
+            }
+        },
+
+        async openUser(user) {
+            if (!user) return;
+            this.userModalTab = 'overview';
+            this.activeUserDetail = { user, stats: {}, recent_plays: [] };
+            this.userModalOpen = true;
+            try {
+                this.activeUserDetail = await this.request(`${this.apiBase}/users/${user.id}`);
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.icons();
+            }
+        },
+
         async loadSettings(showErrors = true) {
             try {
                 this.settings = await this.request(`${this.apiBase}/settings`);
@@ -2818,6 +3191,11 @@ function adminV2() {
                         method: 'POST',
                         body: JSON.stringify(this.metadataBackfillPayload())
                     })
+                    : this.isArtworkBackfillJob(job)
+                    ? await this.request(`${this.apiBase}/jobs/artwork_backfill/run-options`, {
+                        method: 'POST',
+                        body: JSON.stringify(this.artworkBackfillPayload())
+                    })
                     : await this.request(`${this.apiBase}/jobs/${encodeURIComponent(job.name)}/run`, { method: 'POST' });
                 this.showToast(`Run #${result.run_id} started`);
                 this.activeJobName = job.name;
@@ -2837,8 +3215,12 @@ function adminV2() {
             return job && job.name === 'metadata_backfill';
         },
 
+        isArtworkBackfillJob(job) {
+            return job && job.name === 'artwork_backfill';
+        },
+
         jobHasParameterForm(job) {
-            return this.isMetadataBackfillJob(job);
+            return this.isMetadataBackfillJob(job) || this.isArtworkBackfillJob(job);
         },
 
         metadataBackfillPayload() {
@@ -2850,10 +3232,18 @@ function adminV2() {
                 duration_seconds: Boolean(options.duration_seconds),
                 local_genres: Boolean(options.local_genres),
                 lastfm_tags: Boolean(options.lastfm_tags),
+                musicbrainz_tags: Boolean(options.musicbrainz_tags),
                 overwrite: options.mode === 'overwrite'
             };
         },
 
+        artworkBackfillPayload() {
+            const options = this.artworkBackfillOptions || {};
+            return {
+                overwrite_existing: options.mode === 'overwrite'
+            };
+        },
+
         async toggleJob(job) {
             try {
                 const result = await this.request(`${this.apiBase}/jobs/${encodeURIComponent(job.name)}/toggle`, { method: 'POST' });
@@ -3405,23 +3795,70 @@ function adminV2() {
             this.loadLibrary(false);
         },
 
+        pageUsers(delta) {
+            const next = Math.max(0, (this.users.offset || 0) + delta * (this.users.limit || 40));
+            if (next === this.users.offset) return;
+            this.users.offset = next;
+            this.loadUsers(false);
+        },
+
         statCells() {
+            const agent = (this.runtime && this.runtime.agent) || {};
+            const storage = (this.runtime && this.runtime.storage) || [];
+            const node = (this.runtime && this.runtime.node) || {};
+            const inbox = storage.find(item => item.label === 'Inbox') || {};
+            const library = storage.find(item => item.label === 'Library') || {};
             return [
                 { label: 'Tracks', value: this.stats.tracks || 0 },
                 { label: 'Releases', value: this.stats.releases || 0 },
                 { label: 'Artists', value: this.stats.artists || 0 },
                 { label: 'Playlists', value: this.stats.playlists || 0 },
-                { label: 'Hidden tracks', value: this.stats.hidden_tracks || 0 },
-                { label: 'Hidden releases', value: this.stats.hidden_releases || 0 },
-                { label: 'Hidden artists', value: this.stats.hidden_artists || 0 }
+                {
+                    label: agent.model ? `AI agent · ${agent.model}` : 'AI agent',
+                    display: agent.status || 'unknown',
+                    title: `enabled: ${agent.enabled ? 'yes' : 'no'} · llm: ${agent.llm_configured ? 'configured' : 'missing'} · concurrency: ${agent.concurrency || 0}`
+                },
+                this.storageStatCell(inbox, 'Inbox disk'),
+                this.storageStatCell(library, 'Library disk'),
+                {
+                    label: `${node.hostname || 'node'} · pid ${node.pid || '?'}`,
+                    display: `${node.cpu_count || '?'} CPU`,
+                    title: `${node.os || 'unknown'} / ${node.arch || 'unknown'}`
+                }
             ];
         },
 
+        storageStatCell(item, fallbackLabel) {
+            const free = item && item.free_bytes != null ? item.free_bytes : null;
+            const total = item && item.total_bytes != null ? item.total_bytes : null;
+            const suffix = item && item.exists === false ? ' · missing' : '';
+            return {
+                label: `${item.label || fallbackLabel}${suffix}`,
+                display: free != null ? `${this.formatBytes(free)} free` : 'n/a',
+                title: `${item.path || 'not configured'}${total != null ? ` · ${this.formatBytes(total)} total` : ''}`
+            };
+        },
+
+        formatBytes(bytes) {
+            const value = Number(bytes || 0);
+            if (!Number.isFinite(value) || value <= 0) return '0 B';
+            const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+            let size = value;
+            let unit = 0;
+            while (size >= 1024 && unit < units.length - 1) {
+                size /= 1024;
+                unit += 1;
+            }
+            const digits = size >= 10 || unit === 0 ? 0 : 1;
+            return `${size.toFixed(digits)} ${units[unit]}`;
+        },
+
         pageTitle() {
             if (this.activeView === 'library') return 'Library Workbench';
             if (this.activeView === 'jobs') return 'Tasks';
             if (this.activeView === 'tools') return 'Future Tools';
             if (this.activeView === 'settings') return 'Settings';
+            if (this.activeView === 'users') return 'Users';
             return 'Review Queue';
         },
 
@@ -3430,11 +3867,16 @@ function adminV2() {
             if (this.activeView === 'jobs') return 'Scheduler state, recent runs, and manual controls in one place';
             if (this.activeView === 'tools') return 'Reserved space for merge, split, enrichment, and destructive workflows';
             if (this.activeView === 'settings') return 'Application configuration and external API credentials';
+            if (this.activeView === 'users') return 'Account status, live presence, and per-user listening statistics';
             return 'Full-screen review triage with filter-aware bulk actions';
         },
 
         reviewPanelSubtitle() {
-            return `${this.fmt(this.reviews.total || 0)} rows · ${this.reviewFilter.status || 'all statuses'}`;
+            const total = this.reviews.total || 0;
+            const totalAll = this.reviewTotalAll();
+            const status = this.reviewFilter.status || 'all statuses';
+            if (this.reviewFilter.status) return `${this.fmt(total)} ${status} · ${this.fmt(totalAll)} total`;
+            return `${this.fmt(totalAll)} rows · ${status}`;
         },
 
         jobPanelSubtitle() {
@@ -3446,6 +3888,75 @@ function adminV2() {
             return `${this.libraryKind} · ${this.fmt(this.library.total || 0)} rows`;
         },
 
+        usersSubtitle() {
+            return `${this.fmt(this.users.total || 0)} users · ${this.fmt(this.users.online_count || 0)} online`;
+        },
+
+        userStatusClass(user) {
+            return user?.is_online ? 'ok' : 'disabled';
+        },
+
+        userStatusLabel(user) {
+            return user?.is_online ? 'online' : 'offline';
+        },
+
+        userLastSeenLabel(user) {
+            if (!user || user.last_seen_ms == null) return 'never in this session';
+            if (user.is_online) return 'online now';
+            return this.durationApprox(user.last_seen_ms / 1000) + ' ago';
+        },
+
+        usersRangeText() {
+            const total = this.users.total || 0;
+            if (!total) return 'No users';
+            const start = (this.users.offset || 0) + 1;
+            const end = Math.min(total, (this.users.offset || 0) + (this.users.limit || 40));
+            return `${start}-${end} of ${this.fmt(total)}`;
+        },
+
+        userStatCards() {
+            const stats = this.activeUserDetail?.stats || {};
+            return [
+                { label: 'Plays', display: this.fmt(stats.plays || 0) },
+                { label: 'Completed plays', display: this.fmt(stats.completed_plays || 0) },
+                { label: 'Listened time', display: this.durationApprox(stats.listened_seconds || 0) },
+                { label: 'Liked tracks', display: this.fmt(stats.liked_tracks || 0) },
+                { label: 'Followed artists', display: this.fmt(stats.followed_artists || 0) },
+                { label: 'Own playlists', display: this.fmt(stats.own_playlists || 0) },
+                { label: 'Saved playlists', display: this.fmt(stats.saved_playlists || 0) },
+                { label: 'Uploaded tracks', display: this.fmt(stats.uploaded_tracks || 0) },
+                { label: 'Torrent sessions', display: this.fmt(stats.torrent_sessions || 0) }
+            ];
+        },
+
+        userPlayListened(play) {
+            const listened = play?.duration_listened;
+            const duration = play?.track_duration_seconds;
+            const listenedText = listened == null ? 'unknown' : this.durationApprox(listened);
+            const durationText = duration ? this.durationApprox(duration) : null;
+            return durationText ? `${listenedText} / ${durationText}` : listenedText;
+        },
+
+        userPlayMeta(play) {
+            const parts = [];
+            if (play.release_title) {
+                parts.push(play.release_year ? `${play.release_title} (${play.release_year})` : play.release_title);
+            }
+            if (play.audio_format) parts.push(String(play.audio_format).toUpperCase());
+            if (play.audio_bitrate) parts.push(`${play.audio_bitrate} kbps`);
+            if (play.uploader_name) parts.push(`uploaded by ${play.uploader_name}`);
+            parts.push(play.completed ? 'completed' : 'partial');
+            return parts.join(' · ');
+        },
+
+        durationApprox(seconds) {
+            const value = Math.max(0, Number(seconds || 0));
+            if (value < 60) return `${Math.floor(value)}s`;
+            if (value < 3600) return `${Math.floor(value / 60)}m`;
+            if (value < 86400) return `${Math.floor(value / 3600)}h ${Math.floor((value % 3600) / 60)}m`;
+            return `${Math.floor(value / 86400)}d ${Math.floor((value % 86400) / 3600)}h`;
+        },
+
         librarySelectionSummary() {
             const count = this.selectedLibraryCount();
             if (!count) return 'Nothing selected';
@@ -3476,6 +3987,12 @@ function adminV2() {
             return row ? row.count : 0;
         },
 
+        reviewTotalAll() {
+            const explicit = Number(this.reviews.total_all || 0);
+            if (explicit > 0 || Object.prototype.hasOwnProperty.call(this.reviews || {}, 'total_all')) return explicit;
+            return (this.reviews.status_counts || []).reduce((sum, row) => sum + Number(row.count || 0), 0);
+        },
+
         formatConfidence(value) {
             return typeof value === 'number' ? `${Math.round(value * 100)}%` : '-';
         },

templates/player/modals.html

@@ -122,11 +122,11 @@
                 <div class="torrent-tabs">
                     <button class="torrent-tab-btn"
                             :class="{ active: $store.torrents.activeTab === 'import' }"
-                            @click="$store.torrents.showImportTab()">Import</button>
+                            @click="$store.torrents.showImportTab()">{{ t.player_import }}</button>
                     <button class="torrent-tab-btn"
                             :class="{ active: $store.torrents.activeTab === 'uploads' }"
                             @click="$store.torrents.showUploadsTab()">
-                        <span>My uploads</span>
+                        <span>{{ t.player_my_uploads }}</span>
                         <span class="torrent-tab-count"
                               x-show="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal > 0"
                               x-text="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal"></span>
@@ -347,7 +347,7 @@
                     <section class="upload-manager-panel">
                         <div class="upload-manager-head">
                             <div>
-                                <h4>My uploaded tracks</h4>
+                                <h4>{{ t.player_my_uploaded_tracks }}</h4>
                                 <p x-text="$store.torrents.uploadSummary()"></p>
                             </div>
                             <button class="modal-btn modal-btn-ghost"
@@ -357,22 +357,22 @@
 
                         <template x-if="$store.torrents.uploadLoaded && $store.torrents.uploadTracks.length === 0 && $store.torrents.uploadPending.length === 0 && $store.torrents.uploadQueued.length === 0">
                             <div class="empty-state torrent-workspace-empty">
-                                <p>No uploaded tracks yet</p>
+                                <p>{{ t.player_no_uploaded_tracks }}</p>
                             </div>
                         </template>
 
                         <div class="upload-manager-grid">
                             <aside class="upload-review-column">
                                 <div class="upload-panel-card">
-                                    <div class="upload-panel-title">Needs approval</div>
-                                    <p class="upload-panel-subtitle" x-text="$store.torrents.uploadPendingTotal + ' pending or failed'"></p>
+                                    <div class="upload-panel-title">{{ t.player_needs_approval }}</div>
+                                    <p class="upload-panel-subtitle" x-text="$store.torrents.uploadPendingTotal + ' {{ t.player_pending_or_failed }}'"></p>
                                     <template x-if="$store.torrents.uploadPending.length === 0">
-                                        <div class="upload-mini-empty">No tracks need approval</div>
+                                        <div class="upload-mini-empty">{{ t.player_no_tracks_need_approval }}</div>
                                     </template>
                                     <div class="upload-review-list">
                                         <template x-for="item in $store.torrents.uploadPending" :key="item.id">
                                             <button class="upload-review-row" :class="{ active: $store.torrents.uploadReviewEditId === item.id, failed: item.status === 'failed' }" @click="$store.torrents.editUploadReview(item)">
-                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="$store.torrents.uploadStatusLabel(item.status)"></span>
                                                 <span class="upload-review-name" x-text="item.filename"></span>
                                                 <span class="upload-review-error" x-show="item.error_message" x-text="item.error_message"></span>
                                             </button>
@@ -381,67 +381,94 @@
                                 </div>
                                 <template x-if="$store.torrents.uploadQueuedTotal > 0">
                                     <div class="upload-panel-card upload-queue-panel">
-                                        <div class="upload-panel-title">Queued / processing</div>
+                                        <div class="upload-panel-title upload-panel-title-row">
+                                            <span>{{ t.player_queued_processing }}</span>
+                                            <div class="upload-queue-nav" x-show="$store.torrents.uploadQueued.length > $store.torrents.uploadQueuePageSize">
+                                                <span class="upload-queue-range" x-text="$store.torrents.uploadQueueRangeText()"></span>
+                                                <button type="button"
+                                                        class="upload-queue-nav-btn"
+                                                        @click="$store.torrents.uploadQueuePrev()"
+                                                        :disabled="!$store.torrents.uploadQueueCanPrev()"
+                                                        title="{{ t.player_previous }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4"><polyline points="15 18 9 12 15 6"/></svg>
+                                                </button>
+                                                <button type="button"
+                                                        class="upload-queue-nav-btn"
+                                                        @click="$store.torrents.uploadQueueNext()"
+                                                        :disabled="!$store.torrents.uploadQueueCanNext()"
+                                                        title="{{ t.player_next }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4"><polyline points="9 18 15 12 9 6"/></svg>
+                                                </button>
+                                            </div>
+                                        </div>
                                         <template x-for="item in $store.torrents.compactQueuedUploads()" :key="item.id">
-                                            <div class="upload-queue-row">
-                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
+                                            <div class="upload-queue-row" :title="$store.torrents.uploadQueueTooltip(item)">
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="$store.torrents.uploadStatusLabel(item.status)"></span>
                                                 <span class="upload-queue-name" x-text="item.filename"></span>
                                             </div>
                                         </template>
-                                        <div class="upload-mini-empty" x-show="$store.torrents.uploadQueuedTotal > $store.torrents.uploadQueued.length" x-text="'Showing ' + $store.torrents.uploadQueued.length + ' of ' + $store.torrents.uploadQueuedTotal"></div>
+                                        <div class="upload-mini-empty" x-show="$store.torrents.uploadQueuedTotal > $store.torrents.uploadQueued.length" x-text="$store.torrents.uploadQueueOverflowText()"></div>
                                     </div>
                                 </template>
                             </aside>
                             <section class="upload-library-column">
                                 <div class="upload-bulk-bar" x-show="$store.torrents.uploadSelectedCount() > 0">
-                                    <div class="upload-bulk-title" x-text="$store.torrents.uploadSelectedCount() + ' selected'"></div>
-                                    <input type="text" placeholder="Artists" x-model="$store.torrents.uploadBulkDraft.artists">
-                                    <input type="text" placeholder="Featured" x-model="$store.torrents.uploadBulkDraft.featured_artists">
-                                    <input type="text" placeholder="Album" x-model="$store.torrents.uploadBulkDraft.release_title">
-                                    <input type="number" placeholder="Year" x-model="$store.torrents.uploadBulkDraft.release_year">
+                                    <div class="upload-bulk-title" x-text="$store.torrents.uploadSelectedCount() + ' {{ t.player_selected }}'"></div>
+                                    <input type="text" placeholder="{{ t.player_artists }}" x-model="$store.torrents.uploadBulkDraft.artists">
+                                    <input type="text" placeholder="{{ t.player_featured }}" x-model="$store.torrents.uploadBulkDraft.featured_artists">
+                                    <input type="text" placeholder="{{ t.player_album }}" x-model="$store.torrents.uploadBulkDraft.release_title">
+                                    <input type="number" placeholder="{{ t.player_year }}" x-model="$store.torrents.uploadBulkDraft.release_year">
                                     <select x-model="$store.torrents.uploadBulkDraft.release_type">
-                                        <option value="">Type unchanged</option><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
+                                        <option value="">{{ t.player_type_unchanged }}</option><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option>
                                     </select>
                                     <select x-model="$store.torrents.uploadBulkDraft.hidden">
-                                        <option value="">Visibility unchanged</option><option value="false">Visible</option><option value="true">Hidden</option>
+                                        <option value="">{{ t.player_visibility_unchanged }}</option><option value="false">{{ t.player_visible }}</option><option value="true">{{ t.player_hidden }}</option>
                                     </select>
-                                    <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadBulkEdit()" :disabled="$store.torrents.uploadBulkSaving">Apply</button>
-                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearUploadSelection()">Clear</button>
+                                    <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadBulkEdit()" :disabled="$store.torrents.uploadBulkSaving">{{ t.player_apply }}</button>
+                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearUploadSelection()">{{ t.player_clear }}</button>
                                 </div>
                                 <div class="upload-release-tree">
-                                    <template x-for="release in $store.torrents.uploadReleases" :key="release.id">
-                                        <div class="upload-release-node" :class="{ hidden: release.is_hidden }">
-                                            <div class="upload-release-row">
-                                                <button class="torrent-tree-check" :class="$store.torrents.uploadReleaseSelectionState(release)" @click="$store.torrents.toggleUploadReleaseSelection(release)">
-                                                    <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'checked'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
-                                                    <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'partial'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><line x1="5" y1="12" x2="19" y2="12"/></svg></template>
-                                                </button>
-                                                <button class="torrent-tree-toggle" :class="{ expanded: $store.torrents.uploadReleaseExpanded(release.id) }" @click="$store.torrents.toggleUploadRelease(release.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg></button>
-                                                <div class="upload-release-main">
-                                                    <div class="upload-release-title"><span x-text="release.title"></span><span class="upload-hidden-pill" x-show="release.is_hidden">hidden</span></div>
-                                                    <div class="upload-track-meta"><span x-text="$store.torrents.uploadReleaseArtistsText(release)"></span><span>-</span><span x-text="release.year || 'no year'"></span><span>-</span><span x-text="release.tracks.length + ' tracks'"></span></div>
-                                                </div>
-                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUploadRelease(release)">Edit release</button>
+                                    <template x-for="group in $store.torrents.uploadArtistGroups()" :key="group.key">
+                                        <section class="upload-artist-group">
+                                            <div class="upload-artist-row">
+                                                <div class="upload-artist-name" x-text="group.name"></div>
+                                                <div class="upload-artist-meta" x-text="group.releases.length + ' {{ t.player_releases_count }} - ' + group.trackCount + ' {{ t.player_tracks_count }}'"></div>
                                             </div>
-                                            <div class="upload-track-children" x-show="$store.torrents.uploadReleaseExpanded(release.id)">
-                                                <template x-for="item in release.tracks" :key="item.track.id">
-                                                    <div class="upload-tree-track" :class="{ hidden: item.is_hidden, selected: $store.torrents.selectedUploadTracks.has(item.track.id) }">
-                                                        <button class="torrent-tree-check" :class="{ checked: $store.torrents.selectedUploadTracks.has(item.track.id) }" @click="$store.torrents.toggleUploadTrackSelection(item.track.id)">
-                                                            <template x-if="$store.torrents.selectedUploadTracks.has(item.track.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                            <template x-for="release in group.releases" :key="release.id">
+                                                <div class="upload-release-node" :class="{ hidden: release.is_hidden }">
+                                                    <div class="upload-release-row">
+                                                        <button class="torrent-tree-check" :class="$store.torrents.uploadReleaseSelectionState(release)" @click="$store.torrents.toggleUploadReleaseSelection(release)">
+                                                            <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'checked'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                            <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'partial'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><line x1="5" y1="12" x2="19" y2="12"/></svg></template>
                                                         </button>
-                                                        <div class="upload-track-main">
-                                                            <div class="upload-track-title"><span x-text="item.track.track_number ? item.track.track_number + '. ' + item.track.title : item.track.title"></span><span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span></div>
-                                                            <div class="upload-track-meta"><span x-text="$store.torrents.uploadArtistsText(item)"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)">feat.</span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="$store.torrents.uploadFeaturedArtistsText(item)"></span></div>
-                                                        </div>
-                                                        <div class="upload-track-actions">
-                                                            <button class="track-action-btn queue-insert-btn queue-next-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
-                                                            <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
-                                                            <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
+                                                        <button class="torrent-tree-toggle" :class="{ expanded: $store.torrents.uploadReleaseExpanded(release.id) }" @click="$store.torrents.toggleUploadRelease(release.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg></button>
+                                                        <div class="upload-release-main">
+                                                            <div class="upload-release-title"><span x-text="release.title"></span><span class="upload-hidden-pill" x-show="release.is_hidden">{{ t.player_hidden }}</span></div>
+                                                            <div class="upload-track-meta"><span x-text="$store.torrents.uploadReleaseArtistsText(release)"></span><span>-</span><span x-text="release.year || T.noYear"></span><span>-</span><span x-text="release.tracks.length + ' {{ t.player_tracks_count }}'"></span></div>
                                                         </div>
+                                                        <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUploadRelease(release)">{{ t.player_edit_release }}</button>
                                                     </div>
-                                                </template>
-                                            </div>
-                                        </div>
+                                                    <div class="upload-track-children" x-show="$store.torrents.uploadReleaseExpanded(release.id)">
+                                                        <template x-for="item in release.tracks" :key="item.track.id">
+                                                            <div class="upload-tree-track" :class="{ hidden: item.is_hidden, selected: $store.torrents.selectedUploadTracks.has(item.track.id) }">
+                                                                <button class="torrent-tree-check" :class="{ checked: $store.torrents.selectedUploadTracks.has(item.track.id) }" @click="$store.torrents.toggleUploadTrackSelection(item.track.id)">
+                                                                    <template x-if="$store.torrents.selectedUploadTracks.has(item.track.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                                </button>
+                                                                <div class="upload-track-main">
+                                                                    <div class="upload-track-title"><span x-text="item.track.track_number ? item.track.track_number + '. ' + item.track.title : item.track.title"></span><span class="upload-hidden-pill" x-show="item.is_hidden">{{ t.player_hidden }}</span></div>
+                                                                    <div class="upload-track-meta"><span x-text="$store.torrents.uploadArtistsText(item)"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="T.featuredShort"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="$store.torrents.uploadFeaturedArtistsText(item)"></span></div>
+                                                                </div>
+                                                                <div class="upload-track-actions">
+                                                                    <button class="track-action-btn queue-insert-btn queue-next-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                                    <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">{{ t.player_edit }}</button>
+                                                                </div>
+                                                            </div>
+                                                        </template>
+                                                    </div>
+                                                </div>
+                                            </template>
+                                        </section>
                                     </template>
                                 </div>
                             </section>
@@ -455,7 +482,7 @@
                                             <div class="upload-panel-title" x-text="$store.torrents.uploadEditorKicker()"></div>
                                             <h4 x-text="$store.torrents.uploadEditorTitle()"></h4>
                                         </div>
-                                        <button class="track-action-btn" @click="$store.torrents.closeUploadEditor()" title="Close">
+                                        <button class="track-action-btn" @click="$store.torrents.closeUploadEditor()" title="{{ t.player_close }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
                                                 <path d="M18 6L6 18M6 6l12 12"/>
                                             </svg>
@@ -464,53 +491,53 @@
 
                                     <template x-if="$store.torrents.uploadReviewDraft">
                                         <div class="upload-editor-form">
-                                            <label class="upload-field upload-field-half"><span>Title</span><input type="text" x-model="$store.torrents.uploadReviewDraft.title"></label>
-                                            <label class="upload-field upload-field-half"><span>Artist</span><input type="text" x-model="$store.torrents.uploadReviewDraft.artist"></label>
-                                            <label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadReviewDraft.album"></label>
-                                            <label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadReviewDraft.featured_artists" placeholder="Artist, Artist"></label>
-                                            <label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadReviewDraft.year"></label>
-                                            <label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadReviewDraft.track_number"></label>
-                                            <label class="upload-field upload-field-compact"><span>Genre</span><input type="text" x-model="$store.torrents.uploadReviewDraft.genre"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_title }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_artist }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.artist"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.album"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_featured }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.featured_artists" placeholder="{{ t.player_artists_placeholder }}"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadReviewDraft.year"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_track_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadReviewDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_genre }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.genre"></label>
                                             <label class="upload-field upload-field-compact">
-                                                <span>Type</span>
+                                                <span>{{ t.player_type }}</span>
                                                 <select x-model="$store.torrents.uploadReviewDraft.release_type">
-                                                    <option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
+                                                    <option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option>
                                                 </select>
                                             </label>
-                                            <label class="upload-field upload-field-wide"><span>Notes</span><textarea rows="4" x-model="$store.torrents.uploadReviewDraft.notes"></textarea></label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_notes }}</span><textarea rows="4" x-model="$store.torrents.uploadReviewDraft.notes"></textarea></label>
                                             <div class="upload-editor-actions">
-                                                <button class="modal-btn modal-btn-danger" @click="$store.torrents.deleteUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Delete review</button>
-                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.approveUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Approve</button>
+                                                <button class="modal-btn modal-btn-danger" @click="$store.torrents.deleteUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">{{ t.player_delete_review }}</button>
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.approveUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">{{ t.player_approve }}</button>
                                             </div>
                                         </div>
                                     </template>
 
                                     <template x-if="$store.torrents.uploadReleaseDraft">
                                         <div class="upload-editor-form">
-                                            <label class="upload-field upload-field-wide"><span>Album</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.title"></label>
-                                            <label class="upload-field upload-field-wide"><span>Album artists</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.artists"></label>
-                                            <label class="upload-field upload-field-half"><span>Year</span><input type="number" x-model="$store.torrents.uploadReleaseDraft.year"></label>
-                                            <label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadReleaseDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
-                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadReleaseDraft.is_hidden"><span>Hidden</span></label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.title"></label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_album_artists }}</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadReleaseDraft.year"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_type }}</span><select x-model="$store.torrents.uploadReleaseDraft.release_type"><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option></select></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadReleaseDraft.is_hidden"><span>{{ t.player_hidden }}</span></label>
                                             <div class="upload-editor-actions">
-                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadReleaseEdit()" :disabled="$store.torrents.uploadReleaseSavingId === $store.torrents.uploadReleaseEditId">Save release</button>
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadReleaseEdit()" :disabled="$store.torrents.uploadReleaseSavingId === $store.torrents.uploadReleaseEditId">{{ t.player_save_release }}</button>
                                             </div>
                                         </div>
                                     </template>
 
                                     <template x-if="$store.torrents.uploadDraft">
                                         <div class="upload-editor-form">
-                                            <label class="upload-field upload-field-wide"><span>Title</span><input type="text" x-model="$store.torrents.uploadDraft.title"></label>
-                                            <label class="upload-field upload-field-half"><span>Artists</span><input type="text" x-model="$store.torrents.uploadDraft.artists"></label>
-                                            <label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadDraft.featured_artists"></label>
-                                            <label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadDraft.release_title"></label>
-                                            <label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
-                                            <label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadDraft.release_year"></label>
-                                            <label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number"></label>
-                                            <label class="upload-field upload-field-compact"><span>Disc #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number"></label>
-                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden"><span>Hidden</span></label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_title }}</span><input type="text" x-model="$store.torrents.uploadDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_artists }}</span><input type="text" x-model="$store.torrents.uploadDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_featured }}</span><input type="text" x-model="$store.torrents.uploadDraft.featured_artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadDraft.release_title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_type }}</span><select x-model="$store.torrents.uploadDraft.release_type"><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option></select></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadDraft.release_year"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_track_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_disc_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number"></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden"><span>{{ t.player_hidden }}</span></label>
                                             <div class="upload-editor-actions">
-                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadEdit()" :disabled="$store.torrents.uploadSavingId === $store.torrents.uploadEditId">Save track</button>
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadEdit()" :disabled="$store.torrents.uploadSavingId === $store.torrents.uploadEditId">{{ t.player_save_track }}</button>
                                             </div>
                                         </div>
                                     </template>
@@ -526,7 +553,7 @@
                                             <div class="upload-track-main">
                                                 <div class="upload-track-title">
                                                     <span x-text="item.track.title"></span>
-                                                    <span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span>
+                                                    <span class="upload-hidden-pill" x-show="item.is_hidden">{{ t.player_hidden }}</span>
                                                 </div>
                                                 <div class="upload-track-meta">
                                                     <span x-text="$store.torrents.uploadArtistsText(item)"></span>
@@ -543,7 +570,7 @@
                                                 <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                                 </button>
-                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">{{ t.player_edit }}</button>
                                             </div>
                                         </div>
                                     </template>
@@ -551,52 +578,52 @@
                                     <template x-if="$store.torrents.uploadEditId === item.track.id">
                                         <div class="upload-edit-form">
                                             <label>
-                                                <span>Title</span>
+                                                <span>{{ t.player_title }}</span>
                                                 <input type="text" x-model="$store.torrents.uploadDraft.title">
                                             </label>
                                             <label>
-                                                <span>Artists</span>
-                                                <input type="text" x-model="$store.torrents.uploadDraft.artists" placeholder="Artist, Featured Artist">
+                                                <span>{{ t.player_artists }}</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.artists" placeholder="{{ t.player_artist_featured_placeholder }}">
                                             </label>
                                             <label>
-                                                <span>Release</span>
+                                                <span>{{ t.player_release }}</span>
                                                 <input type="text" x-model="$store.torrents.uploadDraft.release_title">
                                             </label>
                                             <label>
-                                                <span>Type</span>
+                                                <span>{{ t.player_type }}</span>
                                                 <select x-model="$store.torrents.uploadDraft.release_type">
-                                                    <option value="album">Album</option>
-                                                    <option value="single">Single</option>
-                                                    <option value="ep">EP</option>
-                                                    <option value="compilation">Compilation</option>
-                                                    <option value="mixtape">Mixtape</option>
-                                                    <option value="live">Live</option>
-                                                    <option value="soundtrack">Soundtrack</option>
-                                                    <option value="remix">Remix</option>
-                                                    <option value="demo">Demo</option>
+                                                    <option value="album">{{ t.player_release_type_album }}</option>
+                                                    <option value="single">{{ t.player_release_type_single }}</option>
+                                                    <option value="ep">{{ t.player_release_type_ep }}</option>
+                                                    <option value="compilation">{{ t.player_release_type_compilation }}</option>
+                                                    <option value="mixtape">{{ t.player_release_type_mixtape }}</option>
+                                                    <option value="live">{{ t.player_release_type_live }}</option>
+                                                    <option value="soundtrack">{{ t.player_release_type_soundtrack }}</option>
+                                                    <option value="remix">{{ t.player_release_type_remix }}</option>
+                                                    <option value="demo">{{ t.player_release_type_demo }}</option>
                                                 </select>
                                             </label>
                                             <label>
-                                                <span>Year</span>
+                                                <span>{{ t.player_year }}</span>
                                                 <input type="number" x-model="$store.torrents.uploadDraft.release_year">
                                             </label>
                                             <label>
-                                                <span>Track #</span>
+                                                <span>{{ t.player_track_number }}</span>
                                                 <input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number">
                                             </label>
                                             <label>
-                                                <span>Disc #</span>
+                                                <span>{{ t.player_disc_number }}</span>
                                                 <input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number">
                                             </label>
                                             <label class="upload-hidden-toggle">
                                                 <input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden">
-                                                <span>Hidden</span>
+                                                <span>{{ t.player_hidden }}</span>
                                             </label>
                                             <div class="upload-edit-actions">
                                                 <button class="modal-btn modal-btn-primary"
                                                         @click="$store.torrents.saveUploadEdit()"
-                                                        :disabled="$store.torrents.uploadSavingId === item.track.id">Save</button>
-                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.cancelUploadEdit()">Cancel</button>
+                                                        :disabled="$store.torrents.uploadSavingId === item.track.id">{{ t.player_save }}</button>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.cancelUploadEdit()">{{ t.player_cancel }}</button>
                                             </div>
                                         </div>
                                     </template>

templates/player/scripts.html

@@ -46,7 +46,38 @@ const T = {
     radioFailed: "{{ t.player_radio_failed }}",
     connectionLost: "{{ t.player_connection_lost }}",
     connectionLostDetail: "{{ t.player_connection_lost_detail }}",
+    activeDevice: "{{ t.player_active_device }}",
     trackWord: "{{ t.player_tracks_count }}",
+    releaseWord: "{{ t.player_releases_count }}",
+    ofWord: "{{ t.player_of }}",
+    needsApproval: "{{ t.player_needs_approval }}",
+    showing: "{{ t.player_showing }}",
+    statusLabelText: "{{ t.player_status }}",
+    fileLabel: "{{ t.player_file }}",
+    createdLabel: "{{ t.player_created }}",
+    updatedLabel: "{{ t.player_updated }}",
+    errorLabel: "{{ t.player_error }}",
+    pending: "{{ t.player_pending }}",
+    featuredShort: "{{ t.player_featured_short }}",
+    noYear: "{{ t.player_no_year }}",
+    loadUploadsFailed: "{{ t.player_failed_load_uploaded_tracks }}",
+    releaseMetadata: "{{ t.player_release_metadata }}",
+    trackMetadata: "{{ t.player_track_metadata }}",
+    metadata: "{{ t.player_metadata }}",
+    approveMetadata: "{{ t.player_approve_metadata }}",
+    editRelease: "{{ t.player_edit_release }}",
+    editTrack: "{{ t.player_edit_track }}",
+    editMetadata: "{{ t.player_edit_metadata }}",
+    failedSaveTrack: "{{ t.player_failed_save_track }}",
+    trackMetadataSaved: "{{ t.player_track_metadata_saved }}",
+    failedSaveRelease: "{{ t.player_failed_save_release }}",
+    releaseMetadataSaved: "{{ t.player_release_metadata_saved }}",
+    failedDeleteReview: "{{ t.player_failed_delete_review }}",
+    reviewDeleted: "{{ t.player_review_deleted }}",
+    failedApproveReview: "{{ t.player_failed_approve_review }}",
+    trackApprovedImported: "{{ t.player_track_approved_imported }}",
+    failedUpdateSelectedTracks: "{{ t.player_failed_update_selected_tracks }}",
+    selectedTracksUpdated: "{{ t.player_selected_tracks_updated }}",
     clientIdle: "{{ t.player_client_idle }}",
     active: "{{ t.player_active }}",
     aiIdle: "{{ t.player_ai_idle }}",
@@ -168,18 +199,6 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('mobile', {
         libraryOpen: false,
         playerExpanded: false,
-        playerDragging: false,
-        playerDragOffset: 0,
-        playerCloseOffset: 0,
-        _playerDragStartY: 0,
-        _playerDragStartX: 0,
-        _playerDragTracking: false,
-        _playerDragMode: null,
-        _playerDragPointerId: null,
-        _playerDragElement: null,
-        _playerDragMove: null,
-        _playerDragEnd: null,
-        _playerSuppressClickUntil: 0,
         toggleLibrary() {
             this.libraryOpen = !this.libraryOpen;
             if (this.libraryOpen) Alpine.store('user').menuOpen = false;
@@ -188,119 +207,30 @@ document.addEventListener('alpine:init', () => {
             this.libraryOpen = false;
         },
         isMobilePlayer() {
-            return window.matchMedia && window.matchMedia('(max-width: 720px)').matches;
+            if (!window.matchMedia) return false;
+            return window.matchMedia('(max-width: 900px)').matches
+                || window.matchMedia('(pointer: coarse) and (max-width: 1024px)').matches;
         },
         openPlayerFullscreen() {
             if (!this.isMobilePlayer() || !Alpine.store('player').currentTrack) return;
             this.playerExpanded = true;
-            this.playerDragging = false;
-            this.playerDragOffset = 0;
-            this.playerCloseOffset = 0;
             Alpine.store('queue').visible = false;
             Alpine.store('devices').open = false;
+            this.resetPlayerFullscreenScroll();
         },
         closePlayerFullscreen() {
             this.playerExpanded = false;
-            this.playerDragging = false;
-            this.playerDragOffset = 0;
-            this.playerCloseOffset = 0;
+            Alpine.store('queue').visible = false;
+            Alpine.store('devices').open = false;
         },
-        playerDragStyle() {
-            return `--mobile-player-drag:${this.playerDragOffset}px; --mobile-player-close-drag:${this.playerCloseOffset}px;`;
-        },
-        handlePlayerClick(event) {
-            if (Date.now() <= this._playerSuppressClickUntil) {
-                event.preventDefault();
-                event.stopPropagation();
-                this._playerSuppressClickUntil = 0;
-            }
-        },
-        startPlayerDrag(event, force = false) {
-            if (!this.isMobilePlayer() || !Alpine.store('player').currentTrack) return;
-            if (event.button && event.button !== 0) return;
-            const target = event.target;
-            const isDragBlocked = target.closest('input, select, textarea, .volume-slider, .device-popover, .mobile-expanded-queue');
-            if (!force) {
-                if (this.playerExpanded) {
-                    const isCloseHandle = target.closest('.player-now-playing');
-                    const scroller = event.currentTarget?.classList?.contains('player-bar') ? event.currentTarget : null;
-                    if (!isCloseHandle || isDragBlocked || (scroller && scroller.scrollTop > 4)) return;
-                } else if (isDragBlocked) {
-                    return;
+        resetPlayerFullscreenScroll() {
+            requestAnimationFrame(() => {
+                const full = document.querySelector('.player-bar .mobile-full-player');
+                if (full) {
+                    full.scrollTop = 0;
+                    full.scrollLeft = 0;
                 }
-            }
-            if (this._playerDragTracking) this.endPlayerDrag({ type: 'pointercancel' });
-            this.playerDragging = false;
-            this._playerDragTracking = true;
-            this._playerDragMode = this.playerExpanded ? 'close' : 'open';
-            this._playerDragStartY = event.clientY;
-            this._playerDragStartX = event.clientX;
-            this._playerDragPointerId = event.pointerId;
-            this._playerDragElement = event.currentTarget;
-            this.playerDragOffset = 0;
-            this.playerCloseOffset = 0;
-            this._playerDragMove = e => this.movePlayerDrag(e);
-            this._playerDragEnd = e => this.endPlayerDrag(e);
-            window.addEventListener('pointermove', this._playerDragMove, { passive: false });
-            window.addEventListener('pointerup', this._playerDragEnd, { passive: false });
-            window.addEventListener('pointercancel', this._playerDragEnd, { passive: false });
-        },
-        movePlayerDrag(event) {
-            if (!this._playerDragTracking) return;
-            const delta = this._playerDragStartY - event.clientY;
-            const absDelta = Math.abs(delta);
-            if (!this.playerDragging) {
-                const horizontalDelta = Math.abs(event.clientX - this._playerDragStartX);
-                const wantsOpen = this._playerDragMode === 'open' && delta > 0;
-                const wantsClose = this._playerDragMode === 'close' && delta < 0;
-                if (absDelta < 8 || absDelta < horizontalDelta * 1.15 || (!wantsOpen && !wantsClose)) return;
-                this.playerDragging = true;
-                try {
-                    this._playerDragElement?.setPointerCapture?.(this._playerDragPointerId);
-                } catch (_) {}
-            }
-            event.preventDefault();
-            if (this._playerDragMode === 'close') {
-                this.playerCloseOffset = Math.max(0, Math.min(window.innerHeight, -delta));
-            } else {
-                const max = Math.max(0, window.innerHeight - 132);
-                this.playerDragOffset = Math.max(0, Math.min(max, delta));
-            }
-        },
-        endPlayerDrag(event) {
-            const openThreshold = Math.min(180, Math.max(90, window.innerHeight * 0.18));
-            const closeThreshold = Math.min(110, Math.max(64, window.innerHeight * 0.1));
-            const wasCancelled = event?.type === 'pointercancel';
-            const wasDragging = this.playerDragging;
-            if (wasDragging) this._playerSuppressClickUntil = Date.now() + 450;
-            if (this._playerDragMode === 'close') {
-                if (!wasCancelled && this.playerCloseOffset > closeThreshold) this.closePlayerFullscreen();
-                else {
-                    this.playerCloseOffset = 0;
-                    this.playerDragging = false;
-                }
-            } else if (this._playerDragMode === 'open' && !wasCancelled && this.playerDragOffset > openThreshold) {
-                this.openPlayerFullscreen();
-            } else {
-                this.playerDragOffset = 0;
-                this.playerDragging = false;
-            }
-            try {
-                if (this._playerDragPointerId !== null && this._playerDragElement?.hasPointerCapture?.(this._playerDragPointerId)) {
-                    this._playerDragElement.releasePointerCapture(this._playerDragPointerId);
-                }
-            } catch (_) {}
-            if (this._playerDragMove) window.removeEventListener('pointermove', this._playerDragMove);
-            if (this._playerDragEnd) {
-                window.removeEventListener('pointerup', this._playerDragEnd);
-                window.removeEventListener('pointercancel', this._playerDragEnd);
-            }
-            this._playerDragTracking = false;
-            this._playerDragMode = null;
-            this._playerDragPointerId = null;
-            this._playerDragElement = null;
-            this._playerDragMove = null;
-            this._playerDragEnd = null;
+            });
         },
     });
 
@@ -1247,6 +1177,10 @@ document.addEventListener('alpine:init', () => {
         jamUsers: [],
         jamSelectedUsers: [],
         jamSearching: false,
+        remoteHintVisible: false,
+        remoteHintDeviceName: '',
+        _remoteHintShown: false,
+        _remoteHintTimer: null,
         _pollTimer: null,
         _jamSearchTimer: null,
         _stateRefreshTick: 0,
@@ -1336,6 +1270,34 @@ document.addEventListener('alpine:init', () => {
             if (wasActive && !this.isActive()) {
                 Alpine.store('player')?._pauseLocal();
             }
+            this._maybeShowRemoteHint();
+        },
+
+        remoteActiveDevice() {
+            if (!this.activeDeviceId || this.activeDeviceId === this.id) return null;
+            return this.devices.find(device => device.id === this.activeDeviceId) || null;
+        },
+
+        _maybeShowRemoteHint() {
+            if (this._remoteHintShown || this.remoteHintVisible || this.open) return;
+            const active = this.remoteActiveDevice();
+            if (!active) return;
+            this.remoteHintDeviceName = active.name || 'Devices';
+            this.remoteHintVisible = true;
+            this._remoteHintShown = true;
+            clearTimeout(this._remoteHintTimer);
+            this._remoteHintTimer = setTimeout(() => this.dismissRemoteHint(), 60000);
+        },
+
+        dismissRemoteHint() {
+            this.remoteHintVisible = false;
+            this._remoteHintShown = true;
+            clearTimeout(this._remoteHintTimer);
+            this._remoteHintTimer = null;
+        },
+
+        remoteHintText() {
+            return `${T.activeDevice}: ${this.remoteHintDeviceName || this.activeLabel()}`;
         },
 
         selectedJam() {
@@ -1401,6 +1363,7 @@ document.addEventListener('alpine:init', () => {
         },
 
         toggle() {
+            this.dismissRemoteHint();
             this.open = !this.open;
             if (this.open) this.poll();
         },
@@ -1884,11 +1847,13 @@ document.addEventListener('alpine:init', () => {
     // -----------------------------------------------------------------------
     Alpine.store('library', {
         view: 'artists',
+        artistFilter: 'all',
         artists: [],
         artistsPage: 0,
         artistsTotal: 0,
         loading: false,
         _allLoaded: false,
+        _artistsLoadToken: 0,
         currentArtist: null,
         currentRelease: null,
         currentPlaylist: null,
@@ -1903,7 +1868,6 @@ document.addEventListener('alpine:init', () => {
         _hashNav: false, // guard against circular hash updates
 
         init() {
-            this.loadArtists(1);
             this._setupScroll();
 
             // Listen for browser back/forward
@@ -1940,7 +1904,10 @@ document.addEventListener('alpine:init', () => {
             const params = match[3] || '';
 
             if (view === 'artists' && !id) {
-                if (this.view !== 'artists') this.goArtists(options);
+                if (this.view !== 'artists' || this.artistsPage === 0) this.goArtists(options);
+                else if (options.restoreScroll) this._restoreScrollPosition(hash);
+            } else if (view === 'uploads' && !id) {
+                if (this.view !== 'my_uploads' || this.artistsPage === 0) this.goMyUploads(options);
                 else if (options.restoreScroll) this._restoreScrollPosition(hash);
             } else if (view === 'artist' && id) {
                 this.openArtist(id, options);
@@ -2006,8 +1973,22 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        _resetArtistList(filter) {
+            this.artistFilter = filter;
+            this.artists = [];
+            this.artistsPage = 0;
+            this.artistsTotal = 0;
+            this._allLoaded = false;
+            this.loading = false;
+            this._artistsLoadToken += 1;
+        },
+
         goArtists(options = {}) {
             this._beginNavigation('#artists', options);
+            if (this.artistFilter !== 'all' || this.artistsPage === 0) {
+                this._resetArtistList('all');
+                this.loadArtists(1);
+            }
             this.view = 'artists';
             this.currentArtist = null;
             this.currentRelease = null;
@@ -2019,25 +2000,63 @@ document.addEventListener('alpine:init', () => {
             this._afterNavigation(options);
         },
 
+        goMyUploads(options = {}) {
+            this._beginNavigation('#uploads', options);
+            if (this.artistFilter !== 'uploads' || this.artistsPage === 0) {
+                this._resetArtistList('uploads');
+                this.loadArtists(1);
+            }
+            this.view = 'my_uploads';
+            this.currentArtist = null;
+            this.currentRelease = null;
+            this.currentPlaylist = null;
+            this.searchQuery = '';
+            this.searchResults = null;
+            this._previousView = 'my_uploads';
+            this.$nextTick(() => { this._setupScroll(); });
+            this._afterNavigation(options);
+        },
+
         async loadArtists(page) {
             if (this.loading || this._allLoaded) return;
             this.loading = true;
+            const filter = this.artistFilter;
+            const token = this._artistsLoadToken + 1;
+            this._artistsLoadToken = token;
             try {
-                const res = await fetch(`/api/player/artists?page=${page}&limit=60`);
+                const mine = filter === 'uploads' ? '&mine=true' : '';
+                const res = await fetch(`/api/player/artists?page=${page}&limit=80${mine}`);
                 if (!res.ok) throw new Error('failed');
                 const data = await res.json();
+                if (token !== this._artistsLoadToken || filter !== this.artistFilter) return;
+                const incoming = Array.isArray(data.items) ? data.items : [];
                 if (page === 1) {
-                    this.artists = data.items;
+                    this.artists = incoming;
                 } else {
-                    this.artists = [...this.artists, ...data.items];
+                    const existing = new Set(this.artists.map(artist => artist.id));
+                    this.artists = [...this.artists, ...incoming.filter(artist => !existing.has(artist.id))];
                 }
                 this.artistsPage = data.page;
                 this.artistsTotal = data.total;
-                if (this.artists.length >= data.total) {
+                if (data.has_more === false || this.artists.length >= data.total) {
                     this._allLoaded = true;
                 }
             } catch {}
-            this.loading = false;
+            if (token === this._artistsLoadToken) {
+                this.loading = false;
+                this.$nextTick(() => { this._fillArtistViewport(); });
+            }
+        },
+
+        isFeaturedOnlyArtist(artist) {
+            return Number(artist?.release_count || 0) <= 0 && Number(artist?.track_count || 0) > 0;
+        },
+
+        shouldShowFeaturedSeparator(index) {
+            if (!(this.view === 'artists' || this.view === 'my_uploads') || index <= 0) return false;
+            const current = this.artists[index];
+            const previous = this.artists[index - 1];
+            return this.isFeaturedOnlyArtist(current) && !this.isFeaturedOnlyArtist(previous);
         },
 
         async openArtist(id, options = {}) {
@@ -2374,8 +2393,8 @@ document.addEventListener('alpine:init', () => {
             this.searchLoading = false;
             if (this.view === 'search') {
                 this.view = this._previousView || 'artists';
-                this._setHash('#artists');
-                if (this.view === 'artists') {
+                this._setHash(this.view === 'my_uploads' ? '#uploads' : '#artists');
+                if (this.view === 'artists' || this.view === 'my_uploads') {
                     this.$nextTick(() => { this._setupScroll(); });
                 }
             }
@@ -2395,11 +2414,21 @@ document.addEventListener('alpine:init', () => {
                     if (entries[0].isIntersecting && !this.loading && !this._allLoaded) {
                         this.loadArtists(this.artistsPage + 1);
                     }
-                }, { root: document.getElementById('center-scroll'), threshold: 0.1 });
+                }, { root: document.getElementById('center-scroll'), rootMargin: '900px 0px', threshold: 0.01 });
                 this._observer.observe(sentinel);
+                this._fillArtistViewport();
             });
         },
 
+        _fillArtistViewport() {
+            if (!(this.view === 'artists' || this.view === 'my_uploads') || this.loading || this._allLoaded) return;
+            const el = this._scrollElement();
+            if (!el) return;
+            if (el.scrollHeight <= el.clientHeight + 900) {
+                this.loadArtists(this.artistsPage + 1);
+            }
+        },
+
         $nextTick(fn) {
             setTimeout(fn, 50);
         },
@@ -2576,6 +2605,8 @@ document.addEventListener('alpine:init', () => {
         uploadQueued: [],
         uploadPendingTotal: 0,
         uploadQueuedTotal: 0,
+        uploadQueueOffset: 0,
+        uploadQueuePageSize: 6,
         uploadLoaded: false,
         uploadLoading: false,
         uploadEditId: null,
@@ -2846,7 +2877,7 @@ document.addEventListener('alpine:init', () => {
             try {
                 const res = await fetch('/api/player/uploads/tracks');
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to load uploaded tracks');
+                if (!res.ok) throw new Error(data.error || T.loadUploadsFailed);
                 this.applyUploadPage(data);
                 this.uploadLoaded = true;
                 if (this.uploadEditId && !this.uploadTracks.some(item => item.track.id === this.uploadEditId)) {
@@ -2870,9 +2901,9 @@ document.addEventListener('alpine:init', () => {
         uploadSummary() {
             const trackCount = this.uploadTracks.length;
             const releaseCount = this.uploadReleases.length;
-            const parts = [trackCount + ' tracks', releaseCount + ' releases'];
-            if (this.uploadPendingTotal > 0) parts.push(this.uploadPendingTotal + ' need approval');
-            if (this.uploadQueuedTotal > 0) parts.push(this.uploadQueuedTotal + ' queued');
+            const parts = [trackCount + ' ' + T.trackWord, releaseCount + ' ' + T.releaseWord];
+            if (this.uploadPendingTotal > 0) parts.push(this.uploadPendingTotal + ' ' + T.needsApproval);
+            if (this.uploadQueuedTotal > 0) parts.push(this.uploadQueuedTotal + ' ' + T.queued);
             return parts.join(' / ');
         },
 
@@ -2880,7 +2911,7 @@ document.addEventListener('alpine:init', () => {
             const track = item?.track || item;
             const names = [
                 ...((track?.artists || []).map(artist => artist.name)),
-                ...((track?.featured_artists || []).map(artist => 'ft. ' + artist.name)),
+                ...((track?.featured_artists || []).map(artist => T.featuredShort + ' ' + artist.name)),
             ];
             return names.join(', ') || T.unknown;
         },
@@ -2890,13 +2921,99 @@ document.addEventListener('alpine:init', () => {
             return names.join(', ') || T.unknown;
         },
 
+        uploadArtistGroups() {
+            const collator = new Intl.Collator(undefined, { sensitivity: 'base', numeric: true });
+            const groups = new Map();
+            for (const release of this.uploadReleases) {
+                const artists = Array.isArray(release?.artists) ? release.artists : [];
+                const artistKey = artists
+                    .map(artist => artist?.id != null ? 'id:' + artist.id : 'name:' + String(artist?.name || '').trim().toLowerCase())
+                    .filter(Boolean)
+                    .join('|') || 'unknown';
+                if (!groups.has(artistKey)) {
+                    groups.set(artistKey, {
+                        key: artistKey,
+                        name: this.uploadReleaseArtistsText(release),
+                        releases: [],
+                        trackCount: 0,
+                    });
+                }
+                const group = groups.get(artistKey);
+                group.releases.push(release);
+                group.trackCount += Array.isArray(release?.tracks) ? release.tracks.length : 0;
+            }
+            return [...groups.values()]
+                .map(group => ({
+                    ...group,
+                    releases: group.releases.slice().sort((a, b) => {
+                        const aDate = String(a?.tracks?.[0]?.uploaded_at || '');
+                        const bDate = String(b?.tracks?.[0]?.uploaded_at || '');
+                        return bDate.localeCompare(aDate) || collator.compare(a?.title || '', b?.title || '');
+                    }),
+                }))
+                .sort((a, b) => collator.compare(a.name, b.name));
+        },
+
         uploadFeaturedArtistsText(item) {
             const track = item?.track || item;
             return (track?.featured_artists || []).map(artist => artist.name).join(', ');
         },
 
         compactQueuedUploads() {
-            return this.uploadQueued.slice(0, 6);
+            const maxOffset = Math.max(0, this.uploadQueued.length - this.uploadQueuePageSize);
+            this.uploadQueueOffset = Math.max(0, Math.min(this.uploadQueueOffset, maxOffset));
+            return this.uploadQueued.slice(this.uploadQueueOffset, this.uploadQueueOffset + this.uploadQueuePageSize);
+        },
+
+        uploadQueueCanPrev() {
+            return this.uploadQueueOffset > 0;
+        },
+
+        uploadQueueCanNext() {
+            return this.uploadQueueOffset + this.uploadQueuePageSize < this.uploadQueued.length;
+        },
+
+        uploadQueuePrev() {
+            this.uploadQueueOffset = Math.max(0, this.uploadQueueOffset - this.uploadQueuePageSize);
+        },
+
+        uploadQueueNext() {
+            const maxOffset = Math.max(0, this.uploadQueued.length - this.uploadQueuePageSize);
+            this.uploadQueueOffset = Math.min(maxOffset, this.uploadQueueOffset + this.uploadQueuePageSize);
+        },
+
+        uploadQueueRangeText() {
+            if (this.uploadQueued.length === 0) return '';
+            const start = this.uploadQueueOffset + 1;
+            const end = Math.min(this.uploadQueueOffset + this.uploadQueuePageSize, this.uploadQueued.length);
+            const total = Math.max(this.uploadQueuedTotal || 0, this.uploadQueued.length);
+            return start + '-' + end + ' / ' + total;
+        },
+
+        uploadQueueOverflowText() {
+            const total = Math.max(this.uploadQueuedTotal || 0, this.uploadQueued.length);
+            return T.showing + ' ' + this.uploadQueued.length + ' ' + T.ofWord + ' ' + total;
+        },
+
+        uploadQueueTooltip(item) {
+            if (!item) return '';
+            const lines = [];
+            if (item.filename) lines.push(T.fileLabel + ': ' + item.filename);
+            if (item.status) lines.push(T.statusLabelText + ': ' + item.status);
+            if (item.created_at) lines.push(T.createdLabel + ': ' + item.created_at);
+            if (item.updated_at) lines.push(T.updatedLabel + ': ' + item.updated_at);
+            if (item.error_message) lines.push(T.errorLabel + ': ' + item.error_message);
+            return lines.join('\n');
+        },
+
+        uploadStatusLabel(status) {
+            const labels = {
+                pending: T.pending,
+                queued: T.queued,
+                processing: T.processing,
+                failed: T.failed,
+            };
+            return labels[String(status || '').toLowerCase()] || status || T.unknown;
         },
 
         uploadHasEditorOpen() {
@@ -2904,17 +3021,17 @@ document.addEventListener('alpine:init', () => {
         },
 
         uploadEditorKicker() {
-            if (this.uploadReviewDraft) return 'Needs approval';
-            if (this.uploadReleaseDraft) return 'Release metadata';
-            if (this.uploadDraft) return 'Track metadata';
-            return 'Metadata';
+            if (this.uploadReviewDraft) return T.needsApproval;
+            if (this.uploadReleaseDraft) return T.releaseMetadata;
+            if (this.uploadDraft) return T.trackMetadata;
+            return T.metadata;
         },
 
         uploadEditorTitle() {
-            if (this.uploadReviewDraft) return 'Approve metadata';
-            if (this.uploadReleaseDraft) return this.uploadReleaseDraft.title || 'Edit release';
-            if (this.uploadDraft) return this.uploadDraft.title || 'Edit track';
-            return 'Edit metadata';
+            if (this.uploadReviewDraft) return T.approveMetadata;
+            if (this.uploadReleaseDraft) return this.uploadReleaseDraft.title || T.editRelease;
+            if (this.uploadDraft) return this.uploadDraft.title || T.editTrack;
+            return T.editMetadata;
         },
 
         closeUploadEditor() {
@@ -3028,11 +3145,11 @@ document.addEventListener('alpine:init', () => {
                     }),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to save track');
+                if (!res.ok) throw new Error(data.error || T.failedSaveTrack);
                 this.uploadTracks = this.uploadTracks.map(item => item.track.id === id ? data : item);
                 this.cancelUploadEdit();
                 this.loadUploads({ silent: true, preserveEditor: false });
-                this._setMessage('Track metadata saved');
+                this._setMessage(T.trackMetadataSaved);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -3078,10 +3195,10 @@ document.addEventListener('alpine:init', () => {
                     }),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to save release');
+                if (!res.ok) throw new Error(data.error || T.failedSaveRelease);
                 this.applyUploadPage(data);
                 this.cancelUploadReleaseEdit();
-                this._setMessage('Release metadata saved');
+                this._setMessage(T.releaseMetadataSaved);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -3137,10 +3254,10 @@ document.addEventListener('alpine:init', () => {
                     method: 'DELETE',
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to delete review');
+                if (!res.ok) throw new Error(data.error || T.failedDeleteReview);
                 this.applyUploadPage(data);
                 this.cancelUploadReviewEdit();
-                this._setMessage('Review deleted');
+                this._setMessage(T.reviewDeleted);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -3159,10 +3276,10 @@ document.addEventListener('alpine:init', () => {
                     body: JSON.stringify(this.uploadReviewPayload()),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to approve review');
+                if (!res.ok) throw new Error(data.error || T.failedApproveReview);
                 this.applyUploadPage(data);
                 this.cancelUploadReviewEdit();
-                this._setMessage('Track approved and imported');
+                this._setMessage(T.trackApprovedImported);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -3193,10 +3310,10 @@ document.addEventListener('alpine:init', () => {
                     }),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to update selected tracks');
+                if (!res.ok) throw new Error(data.error || T.failedUpdateSelectedTracks);
                 this.applyUploadPage(data);
                 this.clearUploadSelection();
-                this._setMessage('Selected tracks updated');
+                this._setMessage(T.selectedTracksUpdated);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -3211,6 +3328,8 @@ document.addEventListener('alpine:init', () => {
             this.uploadQueued = Array.isArray(data.queued) ? data.queued : [];
             this.uploadPendingTotal = Number(data.pending_total || this.uploadPending.length || 0);
             this.uploadQueuedTotal = Number(data.queued_total || this.uploadQueued.length || 0);
+            const maxQueueOffset = Math.max(0, this.uploadQueued.length - this.uploadQueuePageSize);
+            this.uploadQueueOffset = Math.max(0, Math.min(this.uploadQueueOffset, maxQueueOffset));
             this.pruneUploadSelection();
         },
 

templates/player/shell.html

@@ -60,7 +60,13 @@
                      :class="{ active: $store.library.view === 'artists' }"
                      @click="$store.library.goArtists()">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
-                    {{ t.player_artists }}
+                    {{ t.player_global_library }}
+                </div>
+                <div class="sidebar-nav-item"
+                     :class="{ active: $store.library.view === 'my_uploads' }"
+                     @click="$store.library.goMyUploads()">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
+                    {{ t.player_my_uploads }}
                 </div>
             </div>
             <div class="sidebar-section">
@@ -168,7 +174,13 @@
                                  :class="{ active: $store.library.view === 'artists' }"
                                  @click="$store.library.goArtists(); $store.mobile.closeLibrary()">
                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
-                                {{ t.player_artists }}
+                                {{ t.player_global_library }}
+                            </div>
+                            <div class="sidebar-nav-item"
+                                 :class="{ active: $store.library.view === 'my_uploads' }"
+                                 @click="$store.library.goMyUploads(); $store.mobile.closeLibrary()">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
+                                {{ t.player_my_uploads }}
                             </div>
                         </div>
 
@@ -507,39 +519,59 @@
             </template>
 
             <!-- Artists Grid -->
-            <template x-if="$store.library.view === 'artists'">
+            <template x-if="$store.library.view === 'artists' || $store.library.view === 'my_uploads'">
                 <div>
-                    <h1 class="section-title">{{ t.player_artists }}</h1>
+                    <h1 class="section-title" x-text="$store.library.view === 'my_uploads' ? '{{ t.player_my_uploads }}' : '{{ t.player_global_library }}'"></h1>
                     <div class="card-grid">
-                        <template x-for="artist in $store.library.artists" :key="artist.id">
-                            <div class="card" @click="$store.library.openArtist(artist.id)">
-                                <div class="card-img">
-                                    <template x-if="artist.image_url">
-                                        <img :src="artist.image_url" :alt="artist.name" loading="lazy">
-                                    </template>
-                                    <template x-if="!artist.image_url">
-                                        <span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg></span>
-                                    </template>
-                                    <button class="artist-follow-card-btn"
-                                            :class="{ followed: $store.follows.has(artist.id) }"
-                                            @click.stop="$store.follows.toggle(artist.id)"
-                                            :title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
-                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                                            <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
-                                            <circle cx="9" cy="7" r="4"/>
-                                            <path x-show="!$store.follows.has(artist.id)" d="M19 8v6M16 11h6"/>
-                                            <path x-show="$store.follows.has(artist.id)" d="M16 11l2 2 4-5"/>
-                                        </svg>
-                                    </button>
+                        <template x-for="(artist, idx) in $store.library.artists" :key="artist.id">
+                            <div class="artist-grid-entry">
+                                <div class="artist-section-divider"
+                                     x-show="$store.library.shouldShowFeaturedSeparator(idx)"
+                                     x-cloak>
+                                    <span>{{ t.player_featured_only_artists }}</span>
+                                </div>
+                                <div class="card" @click="$store.library.openArtist(artist.id)">
+                                    <div class="card-img">
+                                        <template x-if="artist.image_url">
+                                            <img :src="artist.image_url" :alt="artist.name" loading="lazy">
+                                        </template>
+                                        <template x-if="!artist.image_url">
+                                            <span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg></span>
+                                        </template>
+                                        <button class="artist-follow-card-btn"
+                                                :class="{ followed: $store.follows.has(artist.id) }"
+                                                @click.stop="$store.follows.toggle(artist.id)"
+                                                :title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                                <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
+                                                <circle cx="9" cy="7" r="4"/>
+                                                <path x-show="!$store.follows.has(artist.id)" d="M19 8v6M16 11h6"/>
+                                                <path x-show="$store.follows.has(artist.id)" d="M16 11l2 2 4-5"/>
+                                            </svg>
+                                        </button>
+                                    </div>
+                                    <div class="card-title" x-text="artist.name"></div>
+                                    <div class="card-subtitle" x-text="artist.release_count + ' {{ t.player_releases_count }} · ' + artist.track_count + ' {{ t.player_tracks_count }}'"></div>
                                 </div>
-                                <div class="card-title" x-text="artist.name"></div>
-                                <div class="card-subtitle" x-text="artist.release_count + ' {{ t.player_releases_count }} · ' + artist.track_count + ' {{ t.player_tracks_count }}'"></div>
                             </div>
                         </template>
                     </div>
-                    <template x-if="$store.library.loading">
+                    <template x-if="!$store.library.loading && $store.library.artists.length === 0">
+                        <div class="empty-state">
+                            <p x-text="$store.library.view === 'my_uploads' ? '{{ t.player_no_uploaded_tracks }}' : '{{ t.artists_empty }}'"></p>
+                        </div>
+                    </template>
+                    <template x-if="$store.library.loading && $store.library.artists.length === 0">
                         <div class="loading-spinner"><div class="spinner"></div></div>
                     </template>
+                    <div class="scroll-load-indicator"
+                         x-show="$store.library.loading && $store.library.artists.length > 0"
+                         x-cloak
+                         role="status"
+                         aria-live="polite">
+                        <div class="scroll-load-spinner"></div>
+                        <span>{{ t.player_loading_more }}</span>
+                    </div>
                     <div id="artist-sentinel" style="height:1px"></div>
                 </div>
             </template>
@@ -548,7 +580,8 @@
             <template x-if="$store.library.view === 'artist_detail' && $store.library.currentArtist">
                 <div>
                     <div class="breadcrumb">
-                        <a @click="$store.library.goArtists()">{{ t.player_artists }}</a>
+                        <a @click="$store.library.artistFilter === 'uploads' ? $store.library.goMyUploads() : $store.library.goArtists()"
+                           x-text="$store.library.artistFilter === 'uploads' ? '{{ t.player_my_uploads }}' : '{{ t.player_global_library }}'"></a>
                         <span>/</span>
                         <span x-text="$store.library.currentArtist.name"></span>
                     </div>
@@ -639,23 +672,37 @@
                                 <span style="text-align:right">{{ t.player_duration }}</span>
                             </div>
                             <template x-for="(track, idx) in $store.library.currentArtist.featured_tracks" :key="track.id">
-                                <div class="track-row"
+                                <div class="track-row artist-appearance-row"
                                      :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
                                      @dblclick="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)">
                                     <span class="track-num" x-text="idx + 1"></span>
                                     <div class="track-info">
-                                        <div class="track-title">
-                                            <span x-text="track.title"></span>
-                                            <span style="color:var(--text-subdued)"> · </span>
-                                            <a class="artist-link" @click.stop="$store.library.openRelease(track.release_id)" x-text="track.release_title"></a>
-                                        </div>
-                                        <div class="track-artists-inline">
-                                            <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
-                                                <span>
-                                                    <template x-if="artistIdx > 0"><span>, </span></template>
-                                                    <a class="artist-link" @click.stop="$store.library.openArtist(artist.id)" x-text="artist.label"></a>
-                                                </span>
+                                        <button class="artist-appearance-cover"
+                                                type="button"
+                                                @click.stop="$store.library.openRelease(track.release_id)"
+                                                :title="track.release_title"
+                                                aria-label="{{ t.player_release }}">
+                                            <template x-if="track.cover_url">
+                                                <img :src="track.cover_url" :alt="track.release_title" loading="lazy">
                                             </template>
+                                            <template x-if="!track.cover_url">
+                                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
+                                            </template>
+                                        </button>
+                                        <div class="artist-appearance-copy">
+                                            <div class="track-title">
+                                                <span x-text="track.title"></span>
+                                                <span style="color:var(--text-subdued)"> · </span>
+                                                <a class="artist-link" @click.stop="$store.library.openRelease(track.release_id)" x-text="track.release_title"></a>
+                                            </div>
+                                            <div class="track-artists-inline">
+                                                <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
+                                                    <span>
+                                                        <template x-if="artistIdx > 0"><span>, </span></template>
+                                                        <a class="artist-link" @click.stop="$store.library.openArtist(artist.id)" x-text="artist.label"></a>
+                                                    </span>
+                                                </template>
+                                            </div>
                                         </div>
                                     </div>
                                     <span></span>
@@ -694,7 +741,8 @@
             <template x-if="$store.library.view === 'release_detail' && $store.library.currentRelease">
                 <div>
                     <div class="breadcrumb">
-                        <a @click="$store.library.goArtists()">{{ t.player_artists }}</a>
+                        <a @click="$store.library.artistFilter === 'uploads' ? $store.library.goMyUploads() : $store.library.goArtists()"
+                           x-text="$store.library.artistFilter === 'uploads' ? '{{ t.player_my_uploads }}' : '{{ t.player_global_library }}'"></a>
                         <span>/</span>
                         <template x-if="$store.library.currentRelease.artists.length > 0">
                             <a @click="$store.library.openArtist($store.library.currentRelease.artists[0].id)" x-text="$store.library.currentRelease.artists[0].name"></a>
@@ -958,16 +1006,14 @@
 
     <!-- Player Bar -->
     <div class="player-bar"
-         :class="{ 'mobile-expanded': $store.mobile.playerExpanded, 'mobile-dragging': $store.mobile.playerDragging }"
-         :style="$store.mobile.playerDragStyle()"
-         @click.capture="$store.mobile.handlePlayerClick($event)"
-         @pointerdown="$store.mobile.startPlayerDrag($event)">
-        <button class="mobile-player-collapse-btn" type="button" @click.stop="$store.mobile.closePlayerFullscreen()" title="{{ t.player_close }}" aria-label="{{ t.player_close }}">
-            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
-                <path d="M6 9l6 6 6-6"/>
-            </svg>
-        </button>
-        <div class="player-now-playing">
+         :class="{ 'mobile-expanded': $store.mobile.playerExpanded }">
+        <div class="mobile-full-player">
+            <button class="mobile-player-collapse-btn" type="button" @click.stop="$store.mobile.closePlayerFullscreen()" title="{{ t.player_close }}" aria-label="{{ t.player_close }}">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                    <path d="M6 9l6 6 6-6"/>
+                </svg>
+            </button>
+            <div class="player-now-playing">
             <template x-if="$store.player.currentTrack">
                 <div style="display:flex;align-items:center;gap:12px;overflow:hidden">
                     <div class="player-cover"
@@ -1007,9 +1053,9 @@
                     </div>
                 </div>
             </template>
-        </div>
+            </div>
 
-        <div class="player-controls">
+            <div class="player-controls">
             <div class="player-buttons">
                 <button class="player-btn" :class="{ active: $store.player.shuffle }" @click="$store.player.toggleShuffle()" title="{{ t.player_shuffle }}">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 3 21 3 21 8"/><line x1="4" y1="20" x2="21" y2="3"/><polyline points="21 16 21 21 16 21"/><line x1="15" y1="15" x2="21" y2="21"/><line x1="4" y1="4" x2="9" y2="9"/></svg>
@@ -1049,9 +1095,9 @@
                 <span class="player-time" x-text="formatTime($store.player.duration)"></span>
             </div>
             <div class="player-version-chip">v{{ t.app_version() }}</div>
-        </div>
+            </div>
 
-        <div class="player-right">
+            <div class="player-right">
             <div class="volume-control">
                 <button class="volume-btn" @click="$store.player.toggleMute()">
                     <template x-if="$store.player.volume === 0">
@@ -1076,6 +1122,16 @@
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>
             </button>
             <div class="device-picker" @click.outside="$store.devices.open = false">
+                <template x-if="$store.devices.remoteHintVisible">
+                    <button class="remote-playback-hint"
+                            type="button"
+                            @click="$store.devices.dismissRemoteHint()"
+                            x-transition
+                            x-cloak>
+                        <span class="remote-playback-hint-text" x-text="$store.devices.remoteHintText()"></span>
+                        <span class="remote-playback-hint-progress"></span>
+                    </button>
+                </template>
                 <button class="queue-toggle-btn device-toggle-btn"
                         :class="{ active: $store.devices.isActive() }"
                         @click="$store.devices.toggle()"
@@ -1199,8 +1255,8 @@
                     </div>
                 </div>
             </div>
-        </div>
-        <div class="mobile-expanded-queue">
+            </div>
+            <div class="mobile-expanded-queue">
             <div class="mobile-expanded-queue-title">{{ t.player_queue }}</div>
             <template x-if="$store.queue.upcoming().length === 0">
                 <div class="mobile-expanded-queue-empty">{{ t.player_queue_empty }}</div>
@@ -1233,5 +1289,6 @@
                     <span class="mobile-expanded-queue-time" x-text="formatTime(track.duration_seconds)"></span>
                 </button>
             </template>
+            </div>
         </div>
     </div>

templates/player/styles.html

@@ -513,6 +513,31 @@ button.user-stat:hover {
     gap: 20px;
 }
 
+.artist-grid-entry {
+    display: contents;
+}
+
+.artist-section-divider {
+    grid-column: 1 / -1;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-height: 28px;
+    margin: 2px 0 -2px;
+    color: var(--text-subdued);
+    font-size: 12px;
+    font-weight: 700;
+    text-transform: uppercase;
+}
+
+.artist-section-divider::before,
+.artist-section-divider::after {
+    content: "";
+    flex: 1;
+    height: 1px;
+    background: var(--border-color);
+}
+
 .card {
     background: var(--bg-secondary);
     border-radius: 8px;
@@ -735,6 +760,47 @@ button.user-stat:hover {
     margin-top: 2px;
 }
 
+.artist-appearance-row .track-info {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.artist-appearance-cover {
+    width: 42px;
+    height: 42px;
+    border: 0;
+    border-radius: 4px;
+    background: var(--bg-elevated);
+    color: var(--text-subdued);
+    cursor: pointer;
+    flex: 0 0 42px;
+    overflow: hidden;
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.artist-appearance-cover img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.artist-appearance-cover svg {
+    width: 22px;
+    height: 22px;
+}
+
+.artist-appearance-cover:hover {
+    filter: brightness(1.14);
+}
+
+.artist-appearance-copy {
+    min-width: 0;
+}
+
 .track-album { font-size: 13px; color: var(--text-subdued); }
 .track-duration { font-size: 13px; color: var(--text-subdued); text-align: right; pointer-events: none; }
 
@@ -1370,19 +1436,35 @@ button.user-stat:hover {
 
 .volume-slider {
     width: 104px;
-    height: 4px;
-    background: var(--bg-active);
-    border-radius: 2px;
+    height: 28px;
+    background: transparent;
+    border-radius: 6px;
     cursor: pointer;
     position: relative;
     touch-action: none;
+    display: flex;
+    align-items: center;
+}
+
+.volume-slider::before {
+    content: "";
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: 50%;
+    height: 4px;
+    border-radius: 2px;
+    background: var(--bg-active);
+    transform: translateY(-50%);
 }
 
 .volume-slider-fill {
-    height: 100%;
+    height: 4px;
     background: var(--text-primary);
     border-radius: 2px;
     position: relative;
+    z-index: 1;
+    pointer-events: none;
 }
 
 .volume-slider:hover .volume-slider-fill { background: var(--accent); }
@@ -1452,6 +1534,51 @@ button.user-stat:hover {
     justify-content: center;
 }
 
+.remote-playback-hint {
+    position: absolute;
+    right: 0;
+    bottom: 38px;
+    width: max-content;
+    max-width: min(280px, calc(100vw - 24px));
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-elevated);
+    color: var(--text-primary);
+    box-shadow: 0 14px 34px rgba(0,0,0,0.46);
+    cursor: pointer;
+    font: inherit;
+    overflow: hidden;
+    padding: 10px 12px 12px;
+    text-align: left;
+    z-index: 44;
+}
+
+.remote-playback-hint-text {
+    display: block;
+    max-width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 13px;
+    line-height: 1.35;
+}
+
+.remote-playback-hint-progress {
+    position: absolute;
+    left: 0;
+    bottom: 0;
+    width: 100%;
+    height: 2px;
+    background: var(--accent);
+    transform-origin: left center;
+    animation: remote-playback-hint-progress 60s linear forwards;
+}
+
+@keyframes remote-playback-hint-progress {
+    from { transform: scaleX(1); }
+    to { transform: scaleX(0); }
+}
+
 .device-popover {
     position: absolute;
     right: 0;
@@ -1712,6 +1839,26 @@ button.user-stat:hover {
     animation: spin 0.8s linear infinite;
 }
 
+.scroll-load-indicator {
+    min-height: 56px;
+    margin: 18px 0 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 10px;
+    color: var(--text-secondary);
+    font-size: 13px;
+}
+
+.scroll-load-spinner {
+    width: 18px;
+    height: 18px;
+    border: 2px solid var(--bg-active);
+    border-top-color: var(--accent);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
 @keyframes spin { to { transform: rotate(360deg); } }
 
 /* Empty state */
@@ -3239,7 +3386,40 @@ button.user-stat:hover {
 
 .upload-release-tree {
     display: grid;
-    gap: 8px;
+    gap: 12px;
+}
+
+.upload-artist-group {
+    display: grid;
+    gap: 7px;
+    min-width: 0;
+}
+
+.upload-artist-row {
+    display: flex;
+    align-items: baseline;
+    justify-content: space-between;
+    gap: 10px;
+    min-width: 0;
+    padding: 2px 2px 0;
+}
+
+.upload-artist-name {
+    min-width: 0;
+    overflow: hidden;
+    color: var(--text-primary);
+    font-size: 13px;
+    font-weight: 950;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.upload-artist-meta {
+    flex: 0 0 auto;
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 750;
+    white-space: nowrap;
 }
 
 .upload-release-node {
@@ -3333,6 +3513,60 @@ button.user-stat:hover {
     text-transform: uppercase;
 }
 
+.upload-panel-title-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    flex-wrap: wrap;
+    margin-bottom: 8px;
+}
+
+.upload-queue-nav {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    margin-left: auto;
+}
+
+.upload-queue-range {
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 850;
+    text-transform: none;
+    white-space: nowrap;
+}
+
+.upload-queue-nav-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 24px;
+    height: 24px;
+    padding: 0;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-secondary);
+    color: var(--text-secondary);
+    cursor: pointer;
+}
+
+.upload-queue-nav-btn:hover:not(:disabled) {
+    border-color: var(--text-subdued);
+    background: var(--bg-elevated);
+    color: var(--text-primary);
+}
+
+.upload-queue-nav-btn:disabled {
+    cursor: default;
+    opacity: 0.42;
+}
+
+.upload-queue-nav-btn svg {
+    width: 14px;
+    height: 14px;
+}
+
 .upload-queue-row {
     display: grid;
     grid-template-columns: auto minmax(0, 1fr);
@@ -3644,6 +3878,10 @@ button.user-stat:hover {
     display: none;
 }
 
+.mobile-full-player {
+    display: contents;
+}
+
 .playlist-action-btn {
     background: none;
     border: none;
@@ -3696,7 +3934,7 @@ button.user-stat:hover {
     .release-meta .release-title { font-size: 32px; }
 }
 
-@media (max-width: 900px) {
+@media (max-width: 900px), (pointer: coarse) and (max-width: 1024px) {
     :root {
         --player-height: 168px;
         --player-bar-space: calc(var(--player-height) + var(--safe-bottom));
@@ -3879,7 +4117,7 @@ button.user-stat:hover {
         gap: 4px 10px;
         align-items: center;
         padding: 34px 12px calc(9px + var(--safe-bottom));
-        touch-action: none;
+        touch-action: auto;
         user-select: none;
     }
 
@@ -4073,13 +4311,19 @@ button.user-stat:hover {
     }
 
     .volume-slider {
-        display: block;
+        display: flex;
         width: 100%;
-        height: 9px;
-        border-radius: 999px;
+        height: 34px;
+        border-radius: 6px;
     }
 
     .volume-slider-fill {
+        height: 7px;
+        border-radius: 999px;
+    }
+
+    .volume-slider::before {
+        height: 7px;
         border-radius: 999px;
     }
 
@@ -4115,20 +4359,32 @@ button.user-stat:hover {
         height: 21px;
     }
 
-    .player-bar.mobile-dragging:not(.mobile-expanded) {
+    .player-bar.mobile-expanded {
         position: fixed;
         left: 0;
         right: 0;
-        bottom: 0;
-        height: calc(var(--player-bar-space) + var(--mobile-player-drag, 0px));
-        z-index: 70;
-        border-radius: 18px 18px 0 0;
-        box-shadow: 0 -18px 54px rgba(0,0,0,0.5);
+        top: 0;
+        bottom: auto;
+        height: 100dvh;
+        display: block;
+        padding: 0;
+        border-top: 0;
+        border-radius: 0;
+        background: var(--bg-primary);
+        box-shadow: none;
+        overflow: hidden;
+        overscroll-behavior: contain;
+        z-index: 80;
+        touch-action: auto;
+        user-select: auto;
+        transform: translateZ(0);
     }
 
-    .player-bar.mobile-expanded {
-        position: fixed;
-        inset: 0;
+    .player-bar.mobile-expanded .mobile-full-player {
+        position: absolute;
+        left: 0;
+        right: 0;
+        bottom: 0;
         height: 100dvh;
         display: flex;
         flex-direction: column;
@@ -4136,26 +4392,14 @@ button.user-stat:hover {
         gap: 16px;
         align-items: center;
         padding: calc(18px + env(safe-area-inset-top)) 18px calc(16px + var(--safe-bottom));
-        border-top: 0;
-        border-radius: 0;
-        background: var(--bg-primary);
-        box-shadow: none;
         overflow-y: auto;
         overscroll-behavior: contain;
-        z-index: 80;
-        transform: translateY(var(--mobile-player-close-drag, 0px));
-        transition: transform 0.18s ease, height 0.18s ease;
-        touch-action: pan-y;
-        user-select: auto;
+        z-index: 3;
     }
 
-    .player-bar.mobile-dragging {
-        transition: none;
-    }
-
-    .player-bar.mobile-expanded .mobile-player-collapse-btn {
+    .player-bar.mobile-expanded .mobile-full-player .mobile-player-collapse-btn {
         display: flex;
-        position: absolute;
+        position: fixed;
         top: calc(12px + env(safe-area-inset-top));
         right: 12px;
         width: 42px;
@@ -4174,7 +4418,7 @@ button.user-stat:hover {
         height: 22px;
     }
 
-    .player-bar.mobile-expanded .player-now-playing {
+    .player-bar.mobile-expanded .mobile-full-player .player-now-playing {
         justify-content: center;
         align-self: stretch;
         width: 100%;
@@ -4182,11 +4426,11 @@ button.user-stat:hover {
         flex: 0 0 auto;
         overflow: visible;
         padding-top: 38px;
-        touch-action: none;
-        cursor: grab;
+        touch-action: auto;
+        cursor: default;
     }
 
-    .player-bar.mobile-expanded .player-now-playing > div {
+    .player-bar.mobile-expanded .mobile-full-player .player-now-playing > div {
         width: 100%;
         flex-direction: column;
         justify-content: center;
@@ -4195,60 +4439,56 @@ button.user-stat:hover {
         text-align: center;
     }
 
-    .player-bar.mobile-expanded.mobile-dragging .player-now-playing {
-        cursor: grabbing;
-    }
-
-    .player-bar.mobile-expanded .player-cover {
+    .player-bar.mobile-expanded .mobile-full-player .player-cover {
         width: min(76vw, 38dvh, 360px);
         height: auto;
         aspect-ratio: 1;
         border-radius: 14px;
         box-shadow: 0 22px 62px rgba(0,0,0,0.48);
-        touch-action: none;
+        touch-action: manipulation;
     }
 
-    .player-bar.mobile-expanded .player-cover svg {
+    .player-bar.mobile-expanded .mobile-full-player .player-cover svg {
         width: 96px;
         height: 96px;
     }
 
-    .player-bar.mobile-expanded .player-track-info {
+    .player-bar.mobile-expanded .mobile-full-player .player-track-info {
         width: min(100%, 520px);
         overflow: visible;
     }
 
-    .player-bar.mobile-expanded .player-track-title-row {
+    .player-bar.mobile-expanded .mobile-full-player .player-track-title-row {
         justify-content: center;
     }
 
-    .player-bar.mobile-expanded .player-track-title {
+    .player-bar.mobile-expanded .mobile-full-player .player-track-title {
         font-size: 22px;
         font-weight: 800;
         white-space: normal;
         text-align: center;
     }
 
-    .player-bar.mobile-expanded .player-track-artist {
+    .player-bar.mobile-expanded .mobile-full-player .player-track-artist {
         margin-top: 5px;
         font-size: 14px;
         white-space: normal;
         text-align: center;
     }
 
-    .player-bar.mobile-expanded .player-current-like {
+    .player-bar.mobile-expanded .mobile-full-player .player-current-like {
         display: flex;
         width: 38px;
         height: 38px;
     }
 
-    .player-bar.mobile-expanded .player-track-release {
+    .player-bar.mobile-expanded .mobile-full-player .player-track-release {
         margin-top: 4px;
         font-size: 13px;
         white-space: normal;
     }
 
-    .player-bar.mobile-expanded .player-controls {
+    .player-bar.mobile-expanded .mobile-full-player .player-controls {
         display: flex;
         width: 100%;
         flex: 0 0 auto;
@@ -4257,32 +4497,32 @@ button.user-stat:hover {
         gap: 14px;
     }
 
-    .player-bar.mobile-expanded .player-version-chip {
+    .player-bar.mobile-expanded .mobile-full-player .player-version-chip {
         display: none;
     }
 
-    .player-bar.mobile-expanded .player-buttons {
+    .player-bar.mobile-expanded .mobile-full-player .player-buttons {
         justify-self: center;
         gap: 18px;
         order: 2;
     }
 
-    .player-bar.mobile-expanded .player-btn {
+    .player-bar.mobile-expanded .mobile-full-player .player-btn {
         min-width: 56px;
         min-height: 56px;
     }
 
-    .player-bar.mobile-expanded .player-btn svg {
+    .player-bar.mobile-expanded .mobile-full-player .player-btn svg {
         width: 28px;
         height: 28px;
     }
 
-    .player-bar.mobile-expanded .player-btn-play {
+    .player-bar.mobile-expanded .mobile-full-player .player-btn-play {
         width: 72px;
         height: 72px;
     }
 
-    .player-bar.mobile-expanded .player-timeline {
+    .player-bar.mobile-expanded .mobile-full-player .player-timeline {
         width: 100%;
         max-width: none;
         justify-self: center;
@@ -4291,16 +4531,16 @@ button.user-stat:hover {
         order: 1;
     }
 
-    .player-bar.mobile-expanded .progress-bar {
+    .player-bar.mobile-expanded .mobile-full-player .progress-bar {
         height: 7px;
         border-radius: 999px;
     }
 
-    .player-bar.mobile-expanded .progress-bar-thumb {
+    .player-bar.mobile-expanded .mobile-full-player .progress-bar-thumb {
         opacity: 1;
     }
 
-    .player-bar.mobile-expanded .player-right {
+    .player-bar.mobile-expanded .mobile-full-player .player-right {
         position: static;
         grid-area: actions;
         justify-self: center;
@@ -4313,28 +4553,28 @@ button.user-stat:hover {
         background: transparent;
     }
 
-    .player-bar.mobile-expanded .volume-control {
+    .player-bar.mobile-expanded .mobile-full-player .volume-control {
         grid-template-columns: 44px minmax(0, 1fr);
         gap: 8px;
     }
 
-    .player-bar.mobile-expanded .volume-btn,
-    .player-bar.mobile-expanded .queue-toggle-btn {
+    .player-bar.mobile-expanded .mobile-full-player .volume-btn,
+    .player-bar.mobile-expanded .mobile-full-player .queue-toggle-btn {
         min-width: 48px;
         min-height: 48px;
         padding: 10px;
     }
 
-    .player-bar.mobile-expanded .volume-btn {
+    .player-bar.mobile-expanded .mobile-full-player .volume-btn {
         min-width: 44px;
     }
 
-    .player-bar.mobile-expanded .volume-slider {
-        display: block;
-        height: 7px;
+    .player-bar.mobile-expanded .mobile-full-player .volume-slider {
+        display: flex;
+        height: 44px;
     }
 
-    .player-bar.mobile-expanded .device-popover {
+    .player-bar.mobile-expanded .mobile-full-player .device-popover {
         position: fixed;
         top: auto;
         bottom: calc(90px + var(--safe-bottom));
@@ -4345,7 +4585,15 @@ button.user-stat:hover {
         max-height: 42dvh;
     }
 
-    .player-bar.mobile-expanded .mobile-expanded-queue {
+    .player-bar.mobile-expanded .mobile-full-player .remote-playback-hint {
+        position: fixed;
+        top: auto;
+        bottom: calc(90px + var(--safe-bottom));
+        right: 18px;
+        max-width: calc(100vw - 36px);
+    }
+
+    .player-bar.mobile-expanded .mobile-full-player .mobile-expanded-queue {
         display: block;
         width: 100%;
         max-height: none;
@@ -4966,7 +5214,7 @@ button.user-stat:hover {
     }
 
     .volume-slider {
-        display: block;
+        display: flex;
         width: 100%;
     }
 
@@ -4991,26 +5239,26 @@ button.user-stat:hover {
         height: 24px;
     }
 
-    .player-bar.mobile-expanded {
+    .player-bar.mobile-expanded .mobile-full-player {
         gap: 14px;
         padding-left: 14px;
         padding-right: 14px;
     }
 
-    .player-bar.mobile-expanded .player-cover {
+    .player-bar.mobile-expanded .mobile-full-player .player-cover {
         width: min(82vw, 36dvh, 340px);
     }
 
-    .player-bar.mobile-expanded .player-buttons {
+    .player-bar.mobile-expanded .mobile-full-player .player-buttons {
         gap: 12px;
     }
 
-    .player-bar.mobile-expanded .player-btn {
+    .player-bar.mobile-expanded .mobile-full-player .player-btn {
         min-width: 52px;
         min-height: 52px;
     }
 
-    .player-bar.mobile-expanded .player-btn-play {
+    .player-bar.mobile-expanded .mobile-full-player .player-btn-play {
         width: 68px;
         height: 68px;
     }