CORE: added prom metrics on /metrics

Cargo.lock

@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.2.2"
+version = "0.2.11"
 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.3"
+version = "0.2.12"
 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

@@ -282,6 +282,32 @@ impl App for AdminApp {
                 },
                 "admin_v2_jobs",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/jobs/metadata_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::MetadataBackfillRunRequest>| {
+                        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_metadata_backfill(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "admin_v2_metadata_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;
@@ -9,7 +10,7 @@ use cot::response::IntoResponse;
 use cot::session::Session;
 use cot::{Body, Template};
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use sqlx::{PgPool, Postgres, QueryBuilder};
 
 use super::BUILD_INFO;
@@ -17,7 +18,7 @@ use crate::agent;
 use crate::auth::{self, AuthenticatedUser, Role};
 use crate::config::{AppConfig, ConfigEntry, ConfigSources};
 use crate::i18n::{I18n, Translations};
-use crate::scheduler::{JobRegistry, ScheduledJob};
+use crate::scheduler::{self, JobRegistry, JobRun, ScheduledJob};
 
 #[derive(Debug, Template)]
 #[template(path = "admin/v2.html")]
@@ -61,6 +62,24 @@ pub(super) struct BulkLibraryRequest {
     filter: Option<LibraryFilter>,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct MetadataBackfillRunRequest {
+    #[serde(default = "default_true")]
+    audio_bitrate: bool,
+    #[serde(default = "default_true")]
+    audio_sample_rate: bool,
+    #[serde(default = "default_true")]
+    audio_bit_depth: bool,
+    #[serde(default = "default_true")]
+    duration_seconds: bool,
+    #[serde(default = "default_true")]
+    local_genres: bool,
+    #[serde(default = "default_true")]
+    lastfm_tags: bool,
+    #[serde(default)]
+    overwrite: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct UpdateLibraryItemRequest {
     kind: String,
@@ -68,7 +87,13 @@ pub(super) struct UpdateLibraryItemRequest {
     title: String,
     hidden: bool,
     release_type: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
     year: Option<String>,
+    release_id: Option<i64>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
+    track_number: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
+    disc_number: Option<String>,
     artist_ids: Option<Vec<i64>>,
 }
 
@@ -126,6 +151,7 @@ struct AdminDashboardDto {
     user: AdminUserDto,
     build: BuildDto,
     stats: OverviewStatsDto,
+    runtime: RuntimeOverviewDto,
     reviews: ReviewPageDto,
     jobs: Vec<JobDto>,
     recent_runs: Vec<JobRunDto>,
@@ -143,6 +169,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,
@@ -155,6 +215,14 @@ struct TagDto {
     kind: String,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct MetadataTagDto {
+    name: String,
+    source: String,
+    weight: f64,
+    updated_at: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct ReviewPageDto {
     items: Vec<ReviewDto>,
@@ -385,10 +453,15 @@ struct LibraryItemDetailDto {
     hidden: bool,
     release_type: Option<String>,
     year: Option<i32>,
+    release_id: Option<i64>,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
     current_image_url: Option<String>,
     selected_artist_ids: Vec<i64>,
     artists: Vec<ArtistOptionDto>,
+    releases: Vec<ReleaseOptionDto>,
     available_covers: Vec<AvailableCoverDto>,
+    metadata_tags: Vec<MetadataTagDto>,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]
@@ -397,6 +470,13 @@ struct ArtistOptionDto {
     name: String,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct ReleaseOptionDto {
+    id: i64,
+    title: String,
+    subtitle: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct AvailableCoverDto {
     media_file_id: i64,
@@ -521,6 +601,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),
@@ -538,6 +620,7 @@ pub async fn dashboard(
         },
         build: build_dto(),
         stats,
+        runtime,
         reviews,
         jobs,
         recent_runs,
@@ -872,6 +955,70 @@ pub async fn run_job(
     }
 }
 
+pub async fn run_metadata_backfill(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<MetadataBackfillRunRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let options = crate::jobs::metadata_backfill::MetadataBackfillOptions {
+        audio_bitrate: body.audio_bitrate,
+        audio_sample_rate: body.audio_sample_rate,
+        audio_bit_depth: body.audio_bit_depth,
+        duration_seconds: body.duration_seconds,
+        local_genres: body.local_genres,
+        lastfm_tags: body.lastfm_tags,
+        overwrite: body.overwrite,
+    };
+    if !options.any_field() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "select at least one metadata field",
+        ));
+    }
+
+    let mut run = JobRun::create_running(&db, "metadata_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::metadata_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
+                    .set_failed(&db_for_task, duration_ms, &log.output(), &err.to_string())
+                    .await;
+            }
+        }
+    });
+
+    Json(JobRunStartedDto { ok: true, run_id }).into_response()
+}
+
 pub async fn toggle_job(
     session: Session,
     db: Database,
@@ -1050,6 +1197,40 @@ pub async fn update_library_item(
             .execute(pool)
             .await
         }
+        "tracks" => {
+            let release_id = body.release_id.unwrap_or(0);
+            if release_id <= 0 {
+                return Ok(json_error(StatusCode::BAD_REQUEST, "release is required"));
+            }
+            let release_exists: Option<i64> =
+                sqlx::query_scalar("SELECT id FROM furumusic__release WHERE id = $1")
+                    .bind(release_id)
+                    .fetch_optional(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+            if release_exists.is_none() {
+                return Ok(json_error(StatusCode::NOT_FOUND, "release not found"));
+            }
+            let year = parse_optional_admin_i32(body.year.as_deref(), 0, 3000);
+            let track_number = parse_optional_admin_i32(body.track_number.as_deref(), 1, 9999);
+            let disc_number = parse_optional_admin_i32(body.disc_number.as_deref(), 1, 999);
+            sqlx::query(
+                "UPDATE furumusic__track \
+                 SET title = $1, title_sort = $2, release_id = $3, track_number = $4, disc_number = $5, year = $6, is_hidden = $7, updated_at = $8 \
+                 WHERE id = $9",
+            )
+            .bind(title)
+            .bind(normalize_name(title))
+            .bind(release_id)
+            .bind(track_number)
+            .bind(disc_number)
+            .bind(year)
+            .bind(body.hidden)
+            .bind(&now)
+            .bind(body.id)
+            .execute(pool)
+            .await
+        }
         "playlists" => {
             sqlx::query(
                 "UPDATE furumusic__playlist \
@@ -1071,10 +1252,11 @@ pub async fn update_library_item(
     if affected == 0 {
         return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
     }
-    if kind == "releases" {
+    if kind == "releases" || kind == "tracks" {
         if let Some(mut artist_ids) = body.artist_ids {
             let mut seen_artist_ids = HashSet::new();
             artist_ids.retain(|id| *id > 0 && seen_artist_ids.insert(*id));
+            if kind == "releases" {
                 sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
                     .bind(body.id)
                     .execute(pool)
@@ -1091,6 +1273,26 @@ pub async fn update_library_item(
                     .await
                     .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()))?;
+                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)",
+                    )
+                    .bind(body.id)
+                    .bind(*artist_id)
+                    .bind(position as i32)
+                    .execute(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                }
+            }
         }
     }
 
@@ -1352,6 +1554,158 @@ async fn load_overview_stats(pool: &PgPool) -> anyhow::Result<OverviewStatsDto>
     })
 }
 
+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 {
@@ -1781,6 +2135,7 @@ async fn load_library_page(pool: &PgPool, query: LibraryQuery) -> anyhow::Result
     let total = count_library(pool, &kind, search_pattern.clone()).await?;
     let rows = match kind.as_str() {
         "releases" => load_release_items(pool, search_pattern.clone(), limit, offset).await?,
+        "tracks" => load_track_items(pool, search_pattern.clone(), limit, offset).await?,
         "playlists" => load_playlist_items(pool, search_pattern.clone(), limit, offset).await?,
         _ => load_artist_items(pool, search_pattern.clone(), limit, offset).await?,
     };
@@ -1808,7 +2163,7 @@ async fn fetch_library_item(
         "releases" => {
             sqlx::query_as::<_, LibraryItemRow>(
                 "SELECT r.id, r.title::text AS title, \
-                        CONCAT(r.release_type::text, COALESCE(' · ' || r.year::text, '')) AS subtitle, \
+                        (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
                         r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
                         COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
                         COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
@@ -1816,6 +2171,7 @@ async fn fetch_library_item(
                  FROM furumusic__release r \
                  LEFT JOIN furumusic__track t ON t.release_id = r.id \
                  LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+                 LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
                  LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
                  WHERE r.id = $1 \
                  GROUP BY r.id",
@@ -1841,6 +2197,26 @@ async fn fetch_library_item(
             .fetch_optional(pool)
             .await?
         }
+        "tracks" => {
+            sqlx::query_as::<_, LibraryItemRow>(
+                "SELECT t.id, t.title::text AS title, \
+                        CONCAT(r.title::text, COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
+                        t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
+                        COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
+                        COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
+                        t.updated_at::text AS updated_at \
+                 FROM furumusic__track t \
+                 JOIN furumusic__release r ON r.id = t.release_id \
+                 LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+                 LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
+                 LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
+                 WHERE t.id = $1 \
+                 GROUP BY t.id, r.title",
+            )
+            .bind(id)
+            .fetch_optional(pool)
+            .await?
+        }
         _ => {
             sqlx::query_as::<_, LibraryItemRow>(
                 "SELECT a.id, a.name::text AS title, NULL::text AS subtitle, a.is_hidden, \
@@ -1874,10 +2250,15 @@ async fn load_library_item_detail(
         hidden: item.is_hidden.unwrap_or(false),
         release_type: None,
         year: None,
+        release_id: None,
+        track_number: None,
+        disc_number: None,
         current_image_url: None,
         selected_artist_ids: Vec::new(),
         artists: Vec::new(),
+        releases: Vec::new(),
         available_covers: Vec::new(),
+        metadata_tags: load_metadata_tags(pool, kind, item.id).await?,
         item,
     };
 
@@ -1917,12 +2298,128 @@ async fn load_library_item_detail(
             .collect();
             detail.artists = load_artist_options(pool).await?;
         }
+        "tracks" => {
+            let row: Option<(i64, Option<i32>, Option<i32>, Option<i32>)> = sqlx::query_as(
+                "SELECT release_id, track_number, disc_number, year FROM furumusic__track WHERE id = $1",
+            )
+            .bind(detail.item.id)
+            .fetch_optional(pool)
+            .await?;
+            if let Some((release_id, track_number, disc_number, year)) = row {
+                detail.release_id = Some(release_id);
+                detail.track_number = track_number;
+                detail.disc_number = disc_number;
+                detail.year = year;
+            }
+            detail.selected_artist_ids = sqlx::query_as::<_, IdRow>(
+                "SELECT artist_id AS id FROM furumusic__track_artist WHERE track_id = $1 AND role = 'main' ORDER BY position, artist_id",
+            )
+            .bind(detail.item.id)
+            .fetch_all(pool)
+            .await?
+            .into_iter()
+            .map(|row| row.id)
+            .collect();
+            detail.artists = load_artist_options(pool).await?;
+            detail.releases = load_release_options(pool).await?;
+        }
         _ => {}
     }
 
     Ok(detail)
 }
 
+async fn load_metadata_tags(
+    pool: &PgPool,
+    kind: &str,
+    id: i64,
+) -> anyhow::Result<Vec<MetadataTagDto>> {
+    let entity_kind = match kind {
+        "artists" => "artist",
+        "releases" => "release",
+        "tracks" => "track",
+        _ => return Ok(Vec::new()),
+    };
+    let rows = sqlx::query_as::<_, (String, String, f64, String)>(
+        r#"SELECT name, source, weight, updated_at
+           FROM (
+               SELECT g.name::text AS name,
+                      egt.source::text AS source,
+                      egt.weight,
+                      egt.updated_at::text AS updated_at
+                 FROM furumusic__entity_genre_tag egt
+                 JOIN furumusic__genre g ON g.id = egt.genre_id
+                WHERE egt.entity_kind = $1 AND egt.entity_id = $2
+               UNION ALL
+               SELECT g.name::text AS name,
+                      'track_genre'::text AS source,
+                      1.0::double precision AS weight,
+                      ''::text AS updated_at
+                 FROM furumusic__track_genre tg
+                 JOIN furumusic__genre g ON g.id = tg.genre_id
+                WHERE $1 = 'track'
+                  AND tg.track_id = $2
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__entity_genre_tag egt
+                       WHERE egt.entity_kind = 'track'
+                         AND egt.entity_id = tg.track_id
+                         AND egt.genre_id = tg.genre_id
+                  )
+               UNION ALL
+               SELECT g.name::text AS name,
+                      ('release_' || egt.source)::text AS source,
+                      egt.weight,
+                      egt.updated_at::text AS updated_at
+                 FROM furumusic__track t
+                 JOIN furumusic__entity_genre_tag egt
+                   ON egt.entity_kind = 'release'
+                  AND egt.entity_id = t.release_id
+                 JOIN furumusic__genre g ON g.id = egt.genre_id
+                WHERE $1 = 'track'
+                  AND t.id = $2
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__entity_genre_tag direct_egt
+                       WHERE direct_egt.entity_kind = 'track'
+                         AND direct_egt.entity_id = t.id
+                         AND direct_egt.genre_id = egt.genre_id
+                  )
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__track_genre tg
+                       WHERE tg.track_id = t.id
+                         AND tg.genre_id = egt.genre_id
+                  )
+           ) tags
+           ORDER BY CASE source
+                        WHEN 'lastfm' THEN 0
+                        WHEN 'release_lastfm' THEN 1
+                        WHEN 'review' THEN 2
+                        WHEN 'release_review' THEN 3
+                        WHEN 'file' THEN 4
+                        WHEN 'release_file' THEN 5
+                        WHEN 'track_genre' THEN 6
+                        ELSE 7
+                    END,
+                    weight DESC,
+                    name ASC"#,
+    )
+    .bind(entity_kind)
+    .bind(id)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(name, source, weight, updated_at)| MetadataTagDto {
+            name,
+            source,
+            weight,
+            updated_at,
+        })
+        .collect())
+}
+
 async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDto>> {
     let rows = sqlx::query_as::<_, (i64, String)>(
         "SELECT id, name::text FROM furumusic__artist ORDER BY name ASC",
@@ -1935,6 +2432,28 @@ async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDt
         .collect())
 }
 
+async fn load_release_options(pool: &PgPool) -> anyhow::Result<Vec<ReleaseOptionDto>> {
+    let rows = sqlx::query_as::<_, (i64, String, Option<String>)>(
+        "SELECT r.id, r.title::text AS title, \
+                (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle \
+         FROM furumusic__release r \
+         LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+         LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
+         GROUP BY r.id \
+         ORDER BY r.title_sort ASC, r.year NULLS LAST, r.id ASC",
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(id, title, subtitle)| ReleaseOptionDto {
+            id,
+            title,
+            subtitle: subtitle.unwrap_or_default(),
+        })
+        .collect())
+}
+
 async fn artist_available_covers(
     pool: &PgPool,
     artist_id: i64,
@@ -1974,6 +2493,13 @@ async fn library_ids_by_filter(
              LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
              LEFT JOIN furumusic__artist a ON a.id = ra.artist_id WHERE 1=1",
         ),
+        "tracks" => QueryBuilder::<Postgres>::new(
+            "SELECT DISTINCT t.id \
+             FROM furumusic__track t \
+             JOIN furumusic__release r ON r.id = t.release_id \
+             LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+             LEFT JOIN furumusic__artist a ON a.id = ta.artist_id WHERE 1=1",
+        ),
         "playlists" => QueryBuilder::<Postgres>::new(
             "SELECT DISTINCT p.id \
              FROM furumusic__playlist p \
@@ -2030,6 +2556,14 @@ async fn set_library_visibility(
             .bind(ids)
             .execute(pool)
             .await,
+            "tracks" => sqlx::query(
+                "UPDATE furumusic__track SET is_hidden = $1, updated_at = $2 WHERE id = ANY($3)",
+            )
+            .bind(hidden)
+            .bind(&now)
+            .bind(ids)
+            .execute(pool)
+            .await,
             _ => sqlx::query(
                 "UPDATE furumusic__artist SET is_hidden = $1, updated_at = $2 WHERE id = ANY($3)",
             )
@@ -2046,6 +2580,7 @@ async fn set_library_visibility(
 async fn delete_library_items(pool: &PgPool, kind: &str, ids: &[i64]) -> cot::Result<u64> {
     match kind {
         "releases" => delete_releases(pool, ids).await,
+        "tracks" => delete_tracks(pool, ids).await,
         "playlists" => delete_playlists(pool, ids).await,
         _ => delete_artists(pool, ids).await,
     }
@@ -2132,6 +2667,40 @@ async fn delete_releases(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
     Ok(result.rows_affected())
 }
 
+async fn delete_tracks(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
+    sqlx::query("DELETE FROM furumusic__playlist_track WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__user_liked_track WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__play_history WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__track_genre WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__track_artist WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let result = sqlx::query("DELETE FROM furumusic__track WHERE id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Ok(result.rows_affected())
+}
+
 async fn delete_playlists(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
     sqlx::query("DELETE FROM furumusic__playlist_track WHERE playlist_id = ANY($1)")
         .bind(ids)
@@ -2163,6 +2732,13 @@ async fn count_library(
              LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
              LEFT JOIN furumusic__artist a ON a.id = ra.artist_id WHERE 1=1",
         ),
+        "tracks" => QueryBuilder::<Postgres>::new(
+            "SELECT COUNT(DISTINCT t.id) AS count \
+             FROM furumusic__track t \
+             JOIN furumusic__release r ON r.id = t.release_id \
+             LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+             LEFT JOIN furumusic__artist a ON a.id = ta.artist_id WHERE 1=1",
+        ),
         "playlists" => QueryBuilder::<Postgres>::new(
             "SELECT COUNT(DISTINCT p.id) AS count \
              FROM furumusic__playlist p \
@@ -2203,6 +2779,15 @@ fn push_library_search_filter(
             qb.push_bind(pattern);
             qb.push(")");
         }
+        "tracks" => {
+            qb.push(" AND (t.title ILIKE ");
+            qb.push_bind(pattern.clone());
+            qb.push(" OR r.title ILIKE ");
+            qb.push_bind(pattern.clone());
+            qb.push(" OR a.name ILIKE ");
+            qb.push_bind(pattern);
+            qb.push(")");
+        }
         _ => {
             qb.push(" AND a.name ILIKE ");
             qb.push_bind(pattern);
@@ -2250,7 +2835,7 @@ async fn load_release_items(
 ) -> anyhow::Result<Vec<LibraryItemRow>> {
     let mut qb = QueryBuilder::<Postgres>::new(
         "SELECT r.id, r.title::text AS title, \
-                CONCAT(r.release_type::text, COALESCE(' · ' || r.year::text, '')) AS subtitle, \
+                (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
                 r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
                 COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
                 COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
@@ -2279,6 +2864,46 @@ async fn load_release_items(
         .await?)
 }
 
+async fn load_track_items(
+    pool: &PgPool,
+    search_pattern: Option<String>,
+    limit: i64,
+    offset: i64,
+) -> anyhow::Result<Vec<LibraryItemRow>> {
+    let mut qb = QueryBuilder::<Postgres>::new(
+        "SELECT t.id, t.title::text AS title, \
+                CONCAT(r.title::text, COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
+                t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
+                COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
+                COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
+                t.updated_at::text AS updated_at \
+         FROM furumusic__track t \
+         JOIN furumusic__release r ON r.id = t.release_id \
+         LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+         LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
+         LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
+         LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
+         WHERE 1=1",
+    );
+    if let Some(pattern) = search_pattern {
+        qb.push(" AND (t.title ILIKE ");
+        qb.push_bind(pattern.clone());
+        qb.push(" OR r.title ILIKE ");
+        qb.push_bind(pattern.clone());
+        qb.push(" OR a.name ILIKE ");
+        qb.push_bind(pattern);
+        qb.push(")");
+    }
+    qb.push(" GROUP BY t.id, r.title ORDER BY r.title ASC, t.disc_number NULLS FIRST, t.track_number NULLS FIRST, t.title ASC LIMIT ");
+    qb.push_bind(limit);
+    qb.push(" OFFSET ");
+    qb.push_bind(offset);
+    Ok(qb
+        .build_query_as::<LibraryItemRow>()
+        .fetch_all(pool)
+        .await?)
+}
+
 async fn load_playlist_items(
     pool: &PgPool,
     search_pattern: Option<String>,
@@ -2324,6 +2949,11 @@ fn library_item_dto(kind: &str, row: LibraryItemRow) -> LibraryItemDto {
             tag(format!("{} artists", row.secondary_count), "relation"),
             tag(format!("{} plays", row.tertiary_count), "plays"),
         ],
+        "tracks" => vec![
+            tag(format!("{} artists", row.primary_count), "relation"),
+            tag(format!("{} plays", row.secondary_count), "plays"),
+            tag(format!("{} playlists", row.tertiary_count), "count"),
+        ],
         "playlists" => vec![
             tag(format!("{} tracks", row.primary_count), "count"),
             tag(
@@ -2401,6 +3031,10 @@ fn tag(label: impl Into<String>, kind: impl Into<String>) -> TagDto {
     }
 }
 
+fn default_true() -> bool {
+    true
+}
+
 fn optional_job_time(value: &str) -> Option<String> {
     if value.is_empty() {
         None
@@ -2410,9 +3044,12 @@ fn optional_job_time(value: &str) -> Option<String> {
 }
 
 fn normalize_library_kind(kind: Option<&str>) -> String {
-    match kind {
-        Some("releases") => "releases",
-        Some("playlists") => "playlists",
+    let kind = kind.unwrap_or_default().trim().to_ascii_lowercase();
+    match kind.as_str() {
+        "release" | "releases" => "releases",
+        "track" | "tracks" => "tracks",
+        "playlist" | "playlists" => "playlists",
+        "artist" | "artists" => "artists",
         _ => "artists",
     }
     .to_owned()
@@ -2437,6 +3074,34 @@ fn normalize_name(value: &str) -> String {
     value.trim().to_lowercase()
 }
 
+fn parse_optional_admin_i32(value: Option<&str>, min: i32, max: i32) -> Option<i32> {
+    let value = value?.trim();
+    if value.is_empty() {
+        return None;
+    }
+    value
+        .parse::<i32>()
+        .ok()
+        .map(|parsed| parsed.clamp(min, max))
+}
+
+fn deserialize_optional_stringish<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let Some(value) = Option::<serde_json::Value>::deserialize(deserializer)? else {
+        return Ok(None);
+    };
+    match value {
+        serde_json::Value::Null => Ok(None),
+        serde_json::Value::String(value) => Ok(Some(value)),
+        serde_json::Value::Number(value) => Ok(Some(value.to_string())),
+        other => Err(serde::de::Error::custom(format!(
+            "expected string, number, or null, got {other}"
+        ))),
+    }
+}
+
 fn now_string() -> String {
     chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
 }

src/admin/views.rs

@@ -1402,6 +1402,8 @@ pub struct MetadataBackfillForm {
     audio_sample_rate: Option<String>,
     audio_bit_depth: Option<String>,
     duration_seconds: Option<String>,
+    local_genres: Option<String>,
+    lastfm_tags: Option<String>,
     mode: Option<String>,
 }
 
@@ -1468,6 +1470,8 @@ pub async fn metadata_backfill_run(
         audio_sample_rate: data.audio_sample_rate.is_some(),
         audio_bit_depth: data.audio_bit_depth.is_some(),
         duration_seconds: data.duration_seconds.is_some(),
+        local_genres: data.local_genres.is_some(),
+        lastfm_tags: data.lastfm_tags.is_some(),
         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
 }
 
@@ -370,7 +380,8 @@ pub async fn save_cover_to_storage(
     }
 
     let ext = extension_for_mime(&cover.mime_type);
-    let filename = format!("cover.{ext}");
+    let hash_prefix: String = hash.chars().take(12).collect();
+    let filename = format!("cover-{hash_prefix}.{ext}");
 
     let artist_dir = sanitize_dir_name(artist_name);
     let album_dir = sanitize_dir_name(release_title);

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

@@ -346,6 +346,11 @@ translations! {
     player_lastfm_connect_failed: "Could not open Last.fm connection" , "Не удалось открыть подключение Last.fm";
     player_lastfm_disconnect_failed: "Could not disconnect Last.fm" , "Не удалось отвязать Last.fm";
     player_play:             "Play"                            , "Играть";
+    player_listen:           "Listen"                          , "Слушать";
+    player_listen_artist:    "Listen to artist"                , "Слушать артиста";
+    player_start_radio:      "Start radio"                     , "Запустить радио";
+    player_radio_failed:     "Could not start radio"           , "Не удалось запустить радио";
+    player_played_at:        "Played"                          , "Прослушано";
     player_like:             "Like"                            , "Лайк";
     player_add_to_queue:     "Add to queue"                    , "Добавить в очередь";
     player_add_to_end_queue: "Add to end of queue"             , "Добавить в конец очереди";

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

@@ -307,12 +307,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 +326,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 +335,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 +426,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 +434,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 +444,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 +465,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 +475,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 +573,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 +641,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 +685,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 +704,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 +716,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)
@@ -878,6 +914,26 @@ pub async fn finalize_approved(
         .await;
     }
 
+    let approved_genre = normalized
+        .genre
+        .as_deref()
+        .or_else(|| context.get("raw_genre").and_then(|v| v.as_str()))
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    if let Some(genre) = approved_genre {
+        if let Err(err) =
+            crate::jobs::metadata_backfill::save_approved_track_genres(pool, track.id_val(), genre)
+                .await
+        {
+            tracing::warn!(
+                track_id = track.id_val(),
+                genre,
+                error = %err,
+                "failed to save approved track genre metadata"
+            );
+        }
+    }
+
     // Cover art: if the release has no cover yet, try to find one
     if release.cover_file_id.is_none() {
         let source_folder = Path::new(input_path_str).parent().unwrap_or(Path::new("."));

src/jobs/metadata_backfill.rs

@@ -1,11 +1,20 @@
+use std::time::Duration;
+
+use serde_json::Value;
+
 use crate::scheduler::{Job, JobContext, JobLog};
 
+const LASTFM_TAG_REQUEST_DELAY: Duration = Duration::from_millis(1200);
+const LASTFM_TAG_LIMIT: usize = 12;
+
 #[derive(Debug, Clone, Copy)]
 pub struct MetadataBackfillOptions {
     pub audio_bitrate: bool,
     pub audio_sample_rate: bool,
     pub audio_bit_depth: bool,
     pub duration_seconds: bool,
+    pub local_genres: bool,
+    pub lastfm_tags: bool,
     pub overwrite: bool,
 }
 
@@ -15,6 +24,16 @@ impl MetadataBackfillOptions {
             || self.audio_sample_rate
             || self.audio_bit_depth
             || self.duration_seconds
+            || self.local_genres
+            || self.lastfm_tags
+    }
+
+    fn needs_file_scan(self) -> bool {
+        self.audio_bitrate
+            || self.audio_sample_rate
+            || self.audio_bit_depth
+            || self.duration_seconds
+            || self.local_genres
     }
 }
 
@@ -29,6 +48,42 @@ struct BackfillRow {
     duration_seconds: Option<f64>,
 }
 
+#[derive(sqlx::FromRow)]
+struct LastfmArtistTagRow {
+    id: i64,
+    name: String,
+}
+
+#[derive(sqlx::FromRow)]
+struct LastfmReleaseTagRow {
+    id: i64,
+    title: String,
+    artist_name: Option<String>,
+}
+
+#[derive(sqlx::FromRow)]
+struct LastfmTrackTagRow {
+    id: i64,
+    title: String,
+    artist_name: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+struct TagCandidate {
+    name: String,
+    weight: f64,
+}
+
+#[derive(Debug, Default)]
+struct LastfmTagStats {
+    considered: u64,
+    updated_entities: u64,
+    tags_saved: u64,
+    skipped_existing: u64,
+    not_found: u64,
+    failed: u64,
+}
+
 pub struct MetadataBackfillJob;
 
 #[async_trait::async_trait]
@@ -38,7 +93,7 @@ impl Job for MetadataBackfillJob {
     }
 
     fn description(&self) -> &'static str {
-        "Backfill technical audio metadata from existing files"
+        "Backfill technical audio metadata, local genres, and Last.fm tags"
     }
 
     fn default_cron(&self) -> &'static str {
@@ -54,6 +109,8 @@ impl Job for MetadataBackfillJob {
                 audio_sample_rate: true,
                 audio_bit_depth: true,
                 duration_seconds: true,
+                local_genres: true,
+                lastfm_tags: true,
                 overwrite: false,
             },
         )
@@ -71,6 +128,27 @@ pub async fn run_with_options(
         return Ok(());
     }
 
+    let mut scanned = 0u64;
+    let mut media_updated = 0u64;
+    let mut track_updated = 0u64;
+    let mut local_tags_updated = 0u64;
+    let mut unchanged = 0u64;
+    let mut missing = 0u64;
+    let mut failed = 0u64;
+
+    log.info(&format!(
+        "Metadata backfill options: file_scan={}, local_genres={}, lastfm_tags={}, mode={}",
+        options.needs_file_scan(),
+        options.local_genres,
+        options.lastfm_tags,
+        if options.overwrite {
+            "overwrite"
+        } else {
+            "fill_missing"
+        }
+    ));
+
+    if options.needs_file_scan() {
         let rows = sqlx::query_as::<_, BackfillRow>(
             "SELECT mf.id AS media_file_id, mf.file_path, \
                     mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, \
@@ -84,7 +162,7 @@ pub async fn run_with_options(
         .await?;
 
         log.info(&format!(
-        "Metadata backfill started: {} audio file(s), mode={}",
+            "Metadata file backfill started: {} audio file(s), mode={}",
             rows.len(),
             if options.overwrite {
                 "overwrite"
@@ -93,13 +171,6 @@ pub async fn run_with_options(
             }
         ));
 
-    let mut scanned = 0u64;
-    let mut media_updated = 0u64;
-    let mut track_updated = 0u64;
-    let mut unchanged = 0u64;
-    let mut missing = 0u64;
-    let mut failed = 0u64;
-
         for row in rows {
             scanned += 1;
             let path = crate::media_paths::resolve_media_file_path(
@@ -142,7 +213,8 @@ pub async fn run_with_options(
                     changed_media = next_bitrate != row.audio_bitrate || changed_media;
                 }
             }
-        if options.audio_sample_rate && should_update(row.audio_sample_rate, options.overwrite) {
+            if options.audio_sample_rate && should_update(row.audio_sample_rate, options.overwrite)
+            {
                 if let Some(value) = raw_meta.audio_sample_rate {
                     next_sample_rate = Some(value);
                     changed_media = next_sample_rate != row.audio_sample_rate || changed_media;
@@ -170,6 +242,24 @@ 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?;
+                    if saved > 0 {
+                        local_tags_updated += saved;
+                        changed_tags = true;
+                    }
+                }
+            }
+
             if changed_media {
                 sqlx::query(
                     "UPDATE furumusic__media_file \
@@ -196,23 +286,657 @@ pub async fn run_with_options(
                 }
             }
 
-        if !changed_media && !changed_track {
+            if !changed_media && !changed_track && !changed_tags {
                 unchanged += 1;
             }
 
             if scanned % 100 == 0 {
                 log.info(&format!(
-                "Progress: {scanned} scanned, {media_updated} media updated, {track_updated} tracks updated, {unchanged} unchanged, {missing} missing, {failed} failed"
+                    "Progress: {scanned} scanned, {media_updated} media updated, {track_updated} tracks updated, {local_tags_updated} local tags saved, {unchanged} unchanged, {missing} missing, {failed} failed"
                 ));
             }
         }
+    }
+
+    let lastfm_stats = if options.lastfm_tags {
+        log.info("Metadata file backfill finished; starting Last.fm tag backfill");
+        backfill_lastfm_tags(ctx, log, options.overwrite).await?
+    } else {
+        log.info("Last.fm tag backfill disabled for this run");
+        LastfmTagStats::default()
+    };
 
     log.info(&format!(
-        "Metadata backfill complete: {scanned} scanned, {media_updated} media updated, {track_updated} tracks updated, {unchanged} unchanged, {missing} missing, {failed} 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={}",
+        lastfm_stats.considered,
+        lastfm_stats.updated_entities,
+        lastfm_stats.tags_saved,
+        lastfm_stats.skipped_existing,
+        lastfm_stats.not_found,
+        lastfm_stats.failed,
     ));
     Ok(())
 }
 
+pub async fn save_approved_track_genres(
+    pool: &sqlx::PgPool,
+    track_id: i64,
+    genre_text: &str,
+) -> anyhow::Result<u64> {
+    save_track_tag_text(pool, track_id, genre_text, "review", false).await
+}
+
+async fn backfill_lastfm_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    overwrite: bool,
+) -> anyhow::Result<LastfmTagStats> {
+    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 tag backfill");
+        return Ok(LastfmTagStats::default());
+    }
+
+    log.info("Last.fm tag backfill started");
+
+    let client = reqwest::Client::builder()
+        .user_agent("furumusic-metadata-backfill/0.1")
+        .timeout(Duration::from_secs(15))
+        .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?;
+    Ok(stats)
+}
+
+async fn backfill_lastfm_artist_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    client: &reqwest::Client,
+    api_key: &str,
+    overwrite: bool,
+    stats: &mut LastfmTagStats,
+) -> 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!(
+        "Last.fm artist tag pass: checking {} artist(s)",
+        rows.len()
+    ));
+    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
+                ));
+            }
+            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;
+            }
+            Ok(_) => {
+                stats.not_found += 1;
+            }
+            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
+                return Err(err);
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm artist tags failed for artist {} \"{}\": {err}",
+                    row.id, row.name
+                ));
+            }
+        }
+        if should_log_lastfm_progress(index + 1, total, 25) {
+            log.info(&format!(
+                "Last.fm artist tags progress: {}/{}",
+                index + 1,
+                total
+            ));
+        }
+        tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
+    }
+    Ok(())
+}
+
+async fn backfill_lastfm_release_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    client: &reqwest::Client,
+    api_key: &str,
+    overwrite: bool,
+    stats: &mut LastfmTagStats,
+) -> 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
+           FROM furumusic__release r
+           WHERE r.is_hidden = false
+           ORDER BY r.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    log.info(&format!(
+        "Last.fm release tag pass: checking {} release(s)",
+        rows.len()
+    ));
+    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;
+        }
+        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) {
+                log.info(&format!(
+                    "Last.fm release tags progress: {}/{}",
+                    index + 1,
+                    total
+                ));
+            }
+            continue;
+        };
+        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;
+            }
+            Ok(_) => {
+                stats.not_found += 1;
+            }
+            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
+                return Err(err);
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm release tags failed for release {} \"{}\" / \"{}\": {err}",
+                    row.id, artist, row.title
+                ));
+            }
+        }
+        if should_log_lastfm_progress(index + 1, total, 25) {
+            log.info(&format!(
+                "Last.fm release tags progress: {}/{}",
+                index + 1,
+                total
+            ));
+        }
+        tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
+    }
+    Ok(())
+}
+
+async fn backfill_lastfm_track_tags(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    client: &reqwest::Client,
+    api_key: &str,
+    overwrite: bool,
+    stats: &mut LastfmTagStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, LastfmTrackTagRow>(
+        r#"SELECT t.id,
+                  t.title::text AS title,
+                  (
+                    SELECT a.name::text
+                      FROM furumusic__track_artist ta
+                      JOIN furumusic__artist a ON a.id = ta.artist_id
+                     WHERE ta.track_id = t.id AND ta.role <> 'featuring'
+                     ORDER BY ta.position
+                     LIMIT 1
+                  ) AS artist_name
+           FROM furumusic__track t
+           WHERE t.is_hidden = false
+           ORDER BY t.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    log.info(&format!(
+        "Last.fm track tag pass: checking {} track(s)",
+        rows.len()
+    ));
+    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;
+        }
+        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) {
+                log.info(&format!(
+                    "Last.fm track tags progress: {}/{}",
+                    index + 1,
+                    total
+                ));
+            }
+            continue;
+        };
+        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;
+            }
+            Ok(_) => {
+                stats.not_found += 1;
+            }
+            Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
+                return Err(err);
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Last.fm track tags failed for track {} \"{}\" / \"{}\": {err}",
+                    row.id, artist, row.title
+                ));
+            }
+        }
+        if should_log_lastfm_progress(index + 1, total, 50) {
+            log.info(&format!(
+                "Last.fm track tags progress: {}/{}",
+                index + 1,
+                total
+            ));
+        }
+        tokio::time::sleep(LASTFM_TAG_REQUEST_DELAY).await;
+    }
+    Ok(())
+}
+
+fn should_log_lastfm_progress(done: usize, total: usize, every: usize) -> bool {
+    total > 0 && (done == total || done % every == 0)
+}
+
+async fn should_skip_lastfm_entity(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    overwrite: bool,
+) -> anyhow::Result<bool> {
+    if overwrite {
+        return Ok(false);
+    }
+    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'
+           LIMIT 1"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .fetch_optional(pool)
+    .await?;
+    Ok(exists.is_some())
+}
+
+async fn fetch_lastfm_artist_tags(
+    client: &reqwest::Client,
+    api_key: &str,
+    artist: &str,
+) -> anyhow::Result<Vec<TagCandidate>> {
+    fetch_lastfm_top_tags(
+        client,
+        &[
+            ("method", "artist.getTopTags"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ],
+    )
+    .await
+}
+
+async fn fetch_lastfm_album_tags(
+    client: &reqwest::Client,
+    api_key: &str,
+    artist: &str,
+    album: &str,
+) -> anyhow::Result<Vec<TagCandidate>> {
+    fetch_lastfm_top_tags(
+        client,
+        &[
+            ("method", "album.getTopTags"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("album", album),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ],
+    )
+    .await
+}
+
+async fn fetch_lastfm_track_tags(
+    client: &reqwest::Client,
+    api_key: &str,
+    artist: &str,
+    track: &str,
+) -> anyhow::Result<Vec<TagCandidate>> {
+    fetch_lastfm_top_tags(
+        client,
+        &[
+            ("method", "track.getTopTags"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("track", track),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ],
+    )
+    .await
+}
+
+async fn fetch_lastfm_top_tags(
+    client: &reqwest::Client,
+    query: &[(&str, &str)],
+) -> anyhow::Result<Vec<TagCandidate>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(query)
+        .send()
+        .await?;
+
+    if response.status() == reqwest::StatusCode::NOT_FOUND {
+        return Ok(Vec::new());
+    }
+    let response = response.error_for_status()?;
+    let body: Value = response.json().await?;
+    if let Some(code) = body.get("error").and_then(|value| value.as_i64()) {
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        if code == 6 || code == 7 {
+            return Ok(Vec::new());
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            body.get("message")
+                .and_then(|value| value.as_str())
+                .unwrap_or("unknown error")
+        );
+    }
+
+    let Some(tag_value) = body.get("toptags").and_then(|value| value.get("tag")) else {
+        return Ok(Vec::new());
+    };
+    let mut tags = match tag_value {
+        Value::Array(values) => values.iter().filter_map(tag_from_value).collect::<Vec<_>>(),
+        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.truncate(LASTFM_TAG_LIMIT);
+    Ok(tags)
+}
+
+fn tag_from_value(value: &Value) -> Option<TagCandidate> {
+    let name = value.get("name")?.as_str()?.trim();
+    let name = clean_tag_name(name)?;
+    let weight = value
+        .get("count")
+        .and_then(lastfm_count_to_f64)
+        .unwrap_or(1.0)
+        .max(1.0);
+    Some(TagCandidate { name, weight })
+}
+
+fn lastfm_count_to_f64(value: &Value) -> Option<f64> {
+    value
+        .as_f64()
+        .or_else(|| value.as_str().and_then(|text| text.parse::<f64>().ok()))
+}
+
+async fn save_track_tag_text(
+    pool: &sqlx::PgPool,
+    track_id: i64,
+    tag_text: &str,
+    source: &str,
+    replace_source: bool,
+) -> anyhow::Result<u64> {
+    let tags = tags_from_text(tag_text);
+    save_entity_tags(pool, "track", track_id, &tags, source, replace_source, true).await
+}
+
+async fn replace_entity_tags(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    tags: &[TagCandidate],
+    source: &str,
+    mirror_track_genre: bool,
+) -> anyhow::Result<u64> {
+    save_entity_tags(
+        pool,
+        entity_kind,
+        entity_id,
+        tags,
+        source,
+        true,
+        mirror_track_genre,
+    )
+    .await
+}
+
+async fn save_entity_tags(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    tags: &[TagCandidate],
+    source: &str,
+    replace_source: bool,
+    mirror_track_genre: bool,
+) -> anyhow::Result<u64> {
+    if tags.is_empty() {
+        return Ok(0);
+    }
+    if replace_source {
+        sqlx::query(
+            r#"DELETE FROM furumusic__entity_genre_tag
+               WHERE entity_kind = $1 AND entity_id = $2 AND source = $3"#,
+        )
+        .bind(entity_kind)
+        .bind(entity_id)
+        .bind(source)
+        .execute(pool)
+        .await?;
+
+        if mirror_track_genre && entity_kind == "track" {
+            sqlx::query(
+                r#"DELETE FROM furumusic__track_genre tg
+                   WHERE tg.track_id = $1
+                     AND NOT EXISTS (
+                         SELECT 1
+                           FROM furumusic__entity_genre_tag egt
+                          WHERE egt.entity_kind = 'track'
+                            AND egt.entity_id = tg.track_id
+                            AND egt.genre_id = tg.genre_id
+                     )"#,
+            )
+            .bind(entity_id)
+            .execute(pool)
+            .await?;
+        }
+    }
+
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    let mut saved = 0u64;
+    for tag in tags {
+        let Some(genre_id) = ensure_genre(pool, &tag.name).await? else {
+            continue;
+        };
+        let result = sqlx::query(
+            r#"INSERT INTO furumusic__entity_genre_tag
+                  (entity_kind, entity_id, genre_id, source, weight, updated_at)
+               VALUES ($1, $2, $3, $4, $5, $6)
+               ON CONFLICT (entity_kind, entity_id, genre_id, source) DO NOTHING"#,
+        )
+        .bind(entity_kind)
+        .bind(entity_id)
+        .bind(genre_id)
+        .bind(source)
+        .bind(tag.weight)
+        .bind(&now)
+        .execute(pool)
+        .await?;
+        saved += result.rows_affected();
+
+        if mirror_track_genre && entity_kind == "track" {
+            let result = sqlx::query(
+                r#"INSERT INTO furumusic__track_genre (track_id, genre_id)
+                   VALUES ($1, $2)
+                   ON CONFLICT (track_id, genre_id) DO NOTHING"#,
+            )
+            .bind(entity_id)
+            .bind(genre_id)
+            .execute(pool)
+            .await?;
+            saved += result.rows_affected();
+        }
+    }
+    Ok(saved)
+}
+
+async fn ensure_genre(pool: &sqlx::PgPool, name: &str) -> anyhow::Result<Option<i64>> {
+    let Some(name) = clean_tag_name(name) else {
+        return Ok(None);
+    };
+    let normalized = normalize_tag_name(&name);
+    if normalized.is_empty() || is_ignored_tag(&normalized) {
+        return Ok(None);
+    }
+
+    let existing: Option<i64> = sqlx::query_scalar(
+        r#"SELECT id FROM furumusic__genre
+           WHERE name_normalized = $1
+           ORDER BY id
+           LIMIT 1"#,
+    )
+    .bind(&normalized)
+    .fetch_optional(pool)
+    .await?;
+    if existing.is_some() {
+        return Ok(existing);
+    }
+
+    let id = sqlx::query_scalar::<_, i64>(
+        r#"INSERT INTO furumusic__genre (name, name_normalized)
+           VALUES ($1, $2)
+           ON CONFLICT (name) DO UPDATE SET name = EXCLUDED.name
+           RETURNING id"#,
+    )
+    .bind(&name)
+    .bind(&normalized)
+    .fetch_one(pool)
+    .await?;
+    Ok(Some(id))
+}
+
+fn tags_from_text(value: &str) -> Vec<TagCandidate> {
+    let normalized_separators = value.replace(" / ", ";").replace('|', ";");
+    let mut tags = Vec::new();
+    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.push(TagCandidate { name, weight: 1.0 });
+            }
+        }
+    }
+    tags
+}
+
+fn clean_tag_name(value: &str) -> Option<String> {
+    let cleaned = value.trim().trim_matches('"').trim_matches('\'').trim();
+    if cleaned.is_empty() {
+        return None;
+    }
+    let cleaned = cleaned.chars().take(100).collect::<String>();
+    let cleaned = cleaned.split_whitespace().collect::<Vec<_>>().join(" ");
+    if cleaned.is_empty() {
+        None
+    } else {
+        Some(cleaned)
+    }
+}
+
+fn normalize_tag_name(value: &str) -> String {
+    value
+        .trim()
+        .to_lowercase()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn is_ignored_tag(normalized: &str) -> bool {
+    matches!(
+        normalized,
+        "" | "unknown" | "undefined" | "none" | "n/a" | "na" | "other" | "misc" | "various"
+    )
+}
+
 fn should_update<T>(current: Option<T>, overwrite: bool) -> bool {
     overwrite || current.is_none()
 }

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,843 @@
+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 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

@@ -1815,6 +1815,56 @@ pub mod db_migrations {
             &[Operation::custom(create_artwork_lookup_state).build()];
     }
 
+    // -- M0035: Weighted metadata tags for tracks, releases, and artists ----
+
+    #[cot::db::migrations::migration_op]
+    async fn create_entity_genre_tags(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__entity_genre_tag (
+                    id BIGSERIAL PRIMARY KEY,
+                    entity_kind VARCHAR(32) NOT NULL,
+                    entity_id BIGINT NOT NULL,
+                    genre_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    weight DOUBLE PRECISION NOT NULL DEFAULT 1,
+                    updated_at VARCHAR(32) NOT NULL,
+                    UNIQUE(entity_kind, entity_id, genre_id, source)
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_entity_genre_tag_entity
+                   ON furumusic__entity_genre_tag (entity_kind, entity_id, source)",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_entity_genre_tag_genre
+                   ON furumusic__entity_genre_tag (genre_id, entity_kind)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0035CreateEntityGenreTags;
+
+    impl migrations::Migration for M0035CreateEntityGenreTags {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0035_create_entity_genre_tags";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0034_create_artwork_lookup_state",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_entity_genre_tags).build()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1840,5 +1890,6 @@ pub mod db_migrations {
         &M0032CreateLastfmTrackPopularity,
         &M0033CreateLastfmScrobbling,
         &M0034CreateArtworkLookupState,
+        &M0035CreateEntityGenreTags,
     ];
 }

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

@@ -36,17 +36,18 @@ pub(super) struct ArtistDetail {
     pub(super) image_url: Option<String>,
     pub(super) total_track_count: i64,
     pub(super) total_play_count: i64,
+    pub(super) top_tracks: Vec<TrackItem>,
     pub(super) releases: Vec<ReleaseCard>,
     pub(super) featured_tracks: Vec<ArtistAppearanceTrack>,
 }
 
-#[derive(Debug, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub(super) struct ArtistRef {
     pub(super) id: i64,
     pub(super) name: String,
 }
 
-#[derive(Debug, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub(super) struct TrackItem {
     pub(super) id: i64,
     pub(super) title: String,
@@ -141,6 +142,7 @@ pub(super) struct PlaybackStateDto {
 pub(super) struct DeviceHeartbeatRequest {
     pub(super) device_id: String,
     pub(super) user_agent: Option<String>,
+    pub(super) current_jam_id: Option<String>,
     pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
 }
 
@@ -153,6 +155,7 @@ pub(super) struct DeviceSelectRequest {
 #[derive(Debug, Deserialize, JsonSchema)]
 pub(super) struct DeviceCommandRequest {
     pub(super) target_device_id: Option<String>,
+    pub(super) jam_id: Option<String>,
     pub(super) command: String,
     #[serde(default)]
     pub(super) payload: serde_json::Value,
@@ -168,6 +171,66 @@ pub(super) struct PlayerDeviceDto {
     pub(super) last_seen_ms: i64,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamDto {
+    pub(super) id: String,
+    pub(super) name: String,
+    pub(super) host_user_id: i64,
+    pub(super) host_name: String,
+    pub(super) is_owner: bool,
+    pub(super) is_member: bool,
+    pub(super) is_pending: bool,
+    pub(super) is_active: bool,
+    pub(super) member_count: i64,
+    pub(super) host_last_seen_ms: i64,
+    pub(super) host_device_online: bool,
+    pub(super) members: Vec<PlayerJamMemberDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamMemberDto {
+    pub(super) user_id: i64,
+    pub(super) name: String,
+    pub(super) is_joined: bool,
+    pub(super) is_current_user: bool,
+    pub(super) last_seen_ms: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamCreateRequest {
+    pub(super) device_id: String,
+    #[serde(default)]
+    pub(super) invitee_user_ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamInviteRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+    #[serde(default)]
+    pub(super) invitee_user_ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamJoinRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamLeaveRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamUserDto {
+    pub(super) id: i64,
+    pub(super) username: String,
+    pub(super) display_name: Option<String>,
+    pub(super) email: Option<String>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlayerDeviceCommandDto {
     pub(super) id: String,
@@ -196,6 +259,8 @@ pub(super) struct PlayerDevicesResponse {
     pub(super) device_id: String,
     pub(super) active_device_id: Option<String>,
     pub(super) devices: Vec<PlayerDeviceDto>,
+    pub(super) jams: Vec<PlayerJamDto>,
+    pub(super) current_jam_id: Option<String>,
     pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
 }
 
@@ -204,6 +269,8 @@ pub(super) struct PlayerDevicePollResponse {
     pub(super) device_id: String,
     pub(super) active_device_id: Option<String>,
     pub(super) devices: Vec<PlayerDeviceDto>,
+    pub(super) jams: Vec<PlayerJamDto>,
+    pub(super) current_jam_id: Option<String>,
     pub(super) commands: Vec<PlayerDeviceCommandDto>,
     pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
 }
@@ -238,6 +305,7 @@ pub(super) struct UserStats {
 
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct UserProfile {
+    pub(super) id: i64,
     pub(super) name: String,
     pub(super) role: String,
     pub(super) stats: UserStats,
@@ -278,12 +346,125 @@ pub(super) struct AgentQueueStatus {
     pub(super) processing_count: i64,
 }
 
+#[derive(Debug, Clone, Serialize, JsonSchema)]
+pub(super) struct UserUploadTrack {
+    pub(super) track: TrackItem,
+    pub(super) media_file_id: i64,
+    pub(super) is_hidden: bool,
+    pub(super) release_is_hidden: bool,
+    pub(super) release_type: String,
+    pub(super) year: Option<i32>,
+    pub(super) uploaded_at: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadRelease {
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) release_type: String,
+    pub(super) year: Option<i32>,
+    pub(super) is_hidden: bool,
+    pub(super) artists: Vec<ArtistRef>,
+    pub(super) tracks: Vec<UserUploadTrack>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadReviewFields {
+    pub(super) title: String,
+    pub(super) artist: String,
+    pub(super) album: String,
+    pub(super) year: String,
+    pub(super) track_number: String,
+    pub(super) genre: String,
+    pub(super) featured_artists: Vec<String>,
+    pub(super) release_type: String,
+    pub(super) notes: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadReviewItem {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) filename: String,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+    pub(super) fields: UserUploadReviewFields,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadQueueItem {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) filename: String,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadsPage {
+    pub(super) tracks: Vec<UserUploadTrack>,
+    pub(super) releases: Vec<UserUploadRelease>,
+    pub(super) pending: Vec<UserUploadReviewItem>,
+    pub(super) queued: Vec<UserUploadQueueItem>,
+    pub(super) pending_total: i64,
+    pub(super) queued_total: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadTrackUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) featured_artist_names: Option<Vec<String>>,
+    pub(super) release_title: Option<String>,
+    pub(super) release_type: Option<String>,
+    pub(super) release_year: Option<String>,
+    pub(super) track_number: Option<String>,
+    pub(super) disc_number: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadReleaseUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) release_type: Option<String>,
+    pub(super) year: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadBulkTrackUpdateRequest {
+    pub(super) track_ids: Vec<i64>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) featured_artist_names: Option<Vec<String>>,
+    pub(super) release_title: Option<String>,
+    pub(super) release_type: Option<String>,
+    pub(super) release_year: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadReviewUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist: Option<String>,
+    pub(super) album: Option<String>,
+    pub(super) year: Option<String>,
+    pub(super) track_number: Option<String>,
+    pub(super) genre: Option<String>,
+    pub(super) featured_artists: Option<Vec<String>>,
+    pub(super) release_type: Option<String>,
+    pub(super) notes: Option<String>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlayHistoryItem {
     pub(super) id: i64,
     pub(super) track_id: i64,
     pub(super) track_title: String,
     pub(super) release_title: Option<String>,
+    pub(super) track: TrackItem,
     pub(super) played_at: String,
     pub(super) duration_listened: Option<i32>,
     pub(super) completed: bool,

src/player/queries.rs

@@ -19,6 +19,11 @@ pub(super) struct TracksByIdsRequest {
     pub(super) ids: Vec<i64>,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct UserUploadsQuery {
+    pub(super) limit: Option<i32>,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct CreatePlaylistRequest {
     pub(super) title: String,
@@ -56,12 +61,24 @@ pub(super) struct PathStringId {
     pub(super) id: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct PathRadioSeed {
+    pub(super) kind: String,
+    pub(super) id: i64,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct SearchQuery {
     pub(super) q: String,
     pub(super) limit: Option<i32>,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct JamUserSearchQuery {
+    pub(super) q: Option<String>,
+    pub(super) limit: Option<i32>,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct PathTrackId {
     pub(super) track_id: i64,

src/player/rows.rs

@@ -12,6 +12,14 @@ pub(super) struct CountRow {
     pub(super) count: i64,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct PlayerJamUserRow {
+    pub(super) id: i64,
+    pub(super) username: String,
+    pub(super) display_name: Option<String>,
+    pub(super) email: Option<String>,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct ReleaseRow {
     pub(super) id: i64,
@@ -28,30 +36,6 @@ pub(super) struct ArtistBriefRow {
     pub(super) name: String,
 }
 
-#[derive(sqlx::FromRow)]
-pub(super) struct TrackRow {
-    pub(super) id: i64,
-    pub(super) title: String,
-    pub(super) track_number: Option<i32>,
-    pub(super) disc_number: Option<i32>,
-    pub(super) duration_seconds: f64,
-    pub(super) cover_file_id: Option<i64>,
-    pub(super) release_cover_file_id: Option<i64>,
-    pub(super) release_id: i64,
-    pub(super) release_title: String,
-    pub(super) release_year: Option<i32>,
-    pub(super) uploader_name: String,
-    pub(super) audio_format: Option<String>,
-    pub(super) audio_bitrate: Option<i32>,
-    pub(super) audio_sample_rate: Option<i32>,
-    pub(super) audio_bit_depth: Option<i32>,
-    pub(super) file_size_bytes: Option<i64>,
-    pub(super) lastfm_listeners: Option<i64>,
-    pub(super) lastfm_playcount: Option<i64>,
-    pub(super) lastfm_rating: Option<f64>,
-    pub(super) lastfm_updated_at: Option<String>,
-}
-
 #[derive(sqlx::FromRow)]
 pub(super) struct TrackArtistRow {
     pub(super) track_id: i64,
@@ -60,6 +44,13 @@ pub(super) struct TrackArtistRow {
     pub(super) role: String,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct ReleaseArtistRefRow {
+    pub(super) release_id: i64,
+    pub(super) artist_id: i64,
+    pub(super) artist_name: String,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct MediaFileRow {
     pub(super) file_path: String,
@@ -124,6 +115,70 @@ pub(super) struct PlaylistTrackRow {
     pub(super) lastfm_updated_at: Option<String>,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct UploadedTrackRow {
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) duration_seconds: f64,
+    pub(super) cover_file_id: Option<i64>,
+    pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
+    pub(super) release_type: String,
+    pub(super) release_year: Option<i32>,
+    pub(super) release_is_hidden: bool,
+    pub(super) uploader_name: String,
+    pub(super) audio_format: Option<String>,
+    pub(super) audio_bitrate: Option<i32>,
+    pub(super) audio_sample_rate: Option<i32>,
+    pub(super) audio_bit_depth: Option<i32>,
+    pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
+    pub(super) media_file_id: i64,
+    pub(super) is_hidden: bool,
+    pub(super) year: Option<i32>,
+    pub(super) uploaded_at: String,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UserUploadQueueRow {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) input_path: Option<String>,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UserUploadReviewRow {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) input_path: Option<String>,
+    pub(super) result_json: Option<String>,
+    pub(super) context_json: Option<String>,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UploadTrackEditRow {
+    pub(super) release_id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) is_hidden: bool,
+    pub(super) release_title: String,
+    pub(super) release_type: String,
+    pub(super) release_year: Option<i32>,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct AppearanceTrackRow {
     pub(super) id: i64,
@@ -197,14 +252,31 @@ pub(super) struct ReleaseUploaderRow {
 }
 
 #[derive(sqlx::FromRow)]
-pub(super) struct PlayHistoryRow {
-    pub(super) id: i64,
-    pub(super) track_id: i64,
-    pub(super) track_title: String,
-    pub(super) release_title: Option<String>,
+pub(super) struct PlayHistoryTrackRow {
+    pub(super) history_id: i64,
     pub(super) played_at: String,
     pub(super) duration_listened: Option<i32>,
     pub(super) completed: bool,
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) duration_seconds: f64,
+    pub(super) cover_file_id: Option<i64>,
+    pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
+    pub(super) release_year: Option<i32>,
+    pub(super) uploader_name: String,
+    pub(super) audio_format: Option<String>,
+    pub(super) audio_bitrate: Option<i32>,
+    pub(super) audio_sample_rate: Option<i32>,
+    pub(super) audio_bit_depth: Option<i32>,
+    pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]

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/job_detail.html

@@ -46,6 +46,12 @@
         <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
             <input type="checkbox" name="duration_seconds" checked> duration_seconds
         </label>
+        <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
+            <input type="checkbox" name="local_genres" checked> local genres from files
+        </label>
+        <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
+            <input type="checkbox" name="lastfm_tags" checked> Last.fm tags
+        </label>
     </fieldset>
     <div style="display:flex; gap:1rem; align-items:center; margin-bottom:.9rem;">
         <label style="display:inline-flex; gap:.35rem; align-items:center;">

templates/player/modals.html

@@ -11,6 +11,13 @@
                         </svg>
                     </button>
                 </div>
+                <div class="info-actions" x-show="$store.info.modal.actions && $store.info.modal.actions.length">
+                    <template x-for="(action, idx) in $store.info.modal.actions" :key="action.label + '-' + idx">
+                        <button class="info-action-btn" type="button" @click.stop.prevent="$store.info.runAction(idx)" :disabled="action.busy === true">
+                            <span x-text="action.busy ? '{{ t.player_resolving }}' : action.label"></span>
+                        </button>
+                    </template>
+                </div>
                 <div class="info-modal-body">
                     <template x-if="$store.info.modal.rows && $store.info.modal.rows.length">
                         <table class="info-table">
@@ -112,6 +119,21 @@
                     </div>
                 </div>
 
+                <div class="torrent-tabs">
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'import' }"
+                            @click="$store.torrents.showImportTab()">Import</button>
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'uploads' }"
+                            @click="$store.torrents.showUploadsTab()">
+                        <span>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>
+                    </button>
+                </div>
+
+                <template x-if="$store.torrents.activeTab === 'import'">
                 <div class="torrent-manager-layout">
                     <aside class="torrent-manager-sidebar">
                         <div class="torrent-manager-title">
@@ -319,6 +341,270 @@
                 </template>
                     </section>
                 </div>
+                </template>
+
+                <template x-if="$store.torrents.activeTab === 'uploads'">
+                    <section class="upload-manager-panel">
+                        <div class="upload-manager-head">
+                            <div>
+                                <h4>My uploaded tracks</h4>
+                                <p x-text="$store.torrents.uploadSummary()"></p>
+                            </div>
+                            <button class="modal-btn modal-btn-ghost"
+                                    @click="$store.torrents.loadUploads()"
+                                    :disabled="$store.torrents.uploadHasEditorOpen()">{{ t.player_refresh }}</button>
+                        </div>
+
+                        <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>
+                            </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>
+                                    <template x-if="$store.torrents.uploadPending.length === 0">
+                                        <div class="upload-mini-empty">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="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>
+                                        </template>
+                                    </div>
+                                </div>
+                                <template x-if="$store.torrents.uploadQueuedTotal > 0">
+                                    <div class="upload-panel-card upload-queue-panel">
+                                        <div class="upload-panel-title">Queued / processing</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>
+                                                <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>
+                                </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">
+                                    <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>
+                                    </select>
+                                    <select x-model="$store.torrents.uploadBulkDraft.hidden">
+                                        <option value="">Visibility unchanged</option><option value="false">Visible</option><option value="true">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>
+                                </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>
+                                            </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">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>
+                                                        </div>
+                                                    </div>
+                                                </template>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </div>
+                            </section>
+                        </div>
+
+                        <template x-if="$store.torrents.uploadHasEditorOpen()">
+                            <div class="upload-editor-backdrop" @click.self="$store.torrents.closeUploadEditor()">
+                                <aside class="upload-editor-drawer">
+                                    <div class="upload-editor-head">
+                                        <div>
+                                            <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">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                                <path d="M18 6L6 18M6 6l12 12"/>
+                                            </svg>
+                                        </button>
+                                    </div>
+
+                                    <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-compact">
+                                                <span>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>
+                                                </select>
+                                            </label>
+                                            <label class="upload-field upload-field-wide"><span>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>
+                                            </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>
+                                            <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>
+                                            </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>
+                                            <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>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </aside>
+                            </div>
+                        </template>
+
+                        <div class="upload-track-list" x-show="false">
+                            <template x-for="item in $store.torrents.uploadTracks" :key="item.track.id">
+                                <div class="upload-track-card" :class="{ hidden: item.is_hidden }">
+                                    <template x-if="$store.torrents.uploadEditId !== item.track.id">
+                                        <div class="upload-track-display">
+                                            <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>
+                                                </div>
+                                                <div class="upload-track-meta">
+                                                    <span x-text="$store.torrents.uploadArtistsText(item)"></span>
+                                                    <span>·</span>
+                                                    <span x-text="item.track.release_title"></span>
+                                                    <span x-show="item.track.track_number">·</span>
+                                                    <span x-show="item.track.track_number" x-text="'#' + item.track.track_number"></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>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadEditId === item.track.id">
+                                        <div class="upload-edit-form">
+                                            <label>
+                                                <span>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">
+                                            </label>
+                                            <label>
+                                                <span>Release</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.release_title">
+                                            </label>
+                                            <label>
+                                                <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>
+                                                <span>Year</span>
+                                                <input type="number" x-model="$store.torrents.uploadDraft.release_year">
+                                            </label>
+                                            <label>
+                                                <span>Track #</span>
+                                                <input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number">
+                                            </label>
+                                            <label>
+                                                <span>Disc #</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>
+                                            </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>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </div>
+                            </template>
+                        </div>
+                    </section>
+                </template>
             </div>
         </div>
     </template>
@@ -327,25 +613,93 @@
     <template x-if="$store.history.modal">
         <div class="modal-overlay" @click.self="$store.history.close()">
             <div class="modal-box history-modal">
+                <div class="history-head">
+                    <div>
                         <h3>{{ t.player_play_history }}</h3>
                         <p class="torrent-message" :class="{ error: $store.history.error }"
                            x-text="$store.history.message"></p>
+                    </div>
+                    <button class="mobile-list-action" @click="$store.history.close()" title="{{ t.player_close }}">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
+                </div>
                 <div class="history-list">
                     <template x-if="!$store.history.loading && $store.history.items.length === 0">
                         <div class="empty-state" style="padding:32px 16px">
                             <p>{{ t.player_no_plays_yet }}</p>
                         </div>
                     </template>
-                    <template x-for="item in $store.history.items" :key="item.id">
-                        <div class="history-row">
-                            <div style="min-width:0">
-                                <div class="history-title" x-text="item.track_title"></div>
-                                <div class="history-release" x-text="item.release_title || '{{ t.player_unknown_release }}'"></div>
+                    <template x-if="$store.history.items.length > 0">
+                        <div class="history-table-head">
+                            <span></span>
+                            <span>{{ t.player_title }}</span>
+                            <span>{{ t.player_played_at }}</span>
+                            <span></span>
+                            <span style="text-align:right">{{ t.player_listened }}</span>
+                        </div>
+                    </template>
+                    <template x-for="(item, idx) in $store.history.items" :key="item.id">
+                        <div class="history-row track-row"
+                             :class="{ playing: $store.player.currentTrack && item.track && $store.player.currentTrack.id === item.track.id }"
+                             @dblclick="$store.history.playFrom(idx)">
+                            <button class="history-cover"
+                                    @click.stop="$store.history.playFrom(idx)"
+                                    :title="item.track?.title || item.track_title">
+                                <template x-if="item.track && item.track.cover_url">
+                                    <img :src="item.track.cover_url" :alt="item.track.title" loading="lazy">
+                                </template>
+                                <template x-if="!item.track || !item.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="track-info">
+                                <div class="track-title" x-text="item.track?.title || item.track_title"></div>
+                                <div class="track-artists-inline">
+                                    <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(item.track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
+                                        <span>
+                                            <template x-if="artistIdx > 0"><span>, </span></template>
+                                            <a class="artist-link" @click.stop="$store.history.close(); $store.library.openArtist(artist.id)" x-text="artist.label"></a>
+                                        </span>
+                                    </template>
+                                    <template x-if="!item.track || !$store.library.trackArtistLinks(item.track).length">
+                                        <span x-text="item.release_title || '{{ t.player_unknown_release }}'"></span>
+                                    </template>
+                                </div>
+                                <div class="history-release-line">
+                                    <a class="artist-link"
+                                       x-show="item.track && item.track.release_id"
+                                       @click.stop="$store.history.close(); $store.library.openRelease(item.track.release_id)"
+                                       x-text="item.track?.release_title || item.release_title || '{{ t.player_unknown_release }}'"></a>
+                                </div>
                             </div>
-                            <div>
                             <div class="history-date" x-text="$store.history.date(item.played_at)"></div>
-                                <div class="history-duration" x-text="$store.history.duration(item.duration_listened)"></div>
+                            <div class="track-actions">
+                                <button class="track-action-btn info-btn popularity-info-btn"
+                                        :class="{ 'has-popularity': $store.library.hasPopularity(item.track), 'no-popularity': !$store.library.hasPopularity(item.track) }"
+                                        :style="$store.library.popularityStyle(item.track)"
+                                        @click.stop="$store.library.openTrackInfo(item.track)"
+                                        :title="$store.library.trackInfoTitle(item.track)"
+                                        aria-label="{{ t.player_track_info }}">
+                                    <span x-show="$store.library.hasPopularity(item.track)" x-text="$store.library.popularityLabel(item.track)"></span>
+                                    <span x-show="!$store.library.hasPopularity(item.track)" class="info-letter">i</span>
+                                </button>
+                                <button class="like-btn" :class="{ liked: $store.likes.has(item.track_id) }" @click.stop="$store.likes.toggle(item.track_id)" title="{{ t.player_like }}">
+                                    <svg viewBox="0 0 24 24" :fill="$store.likes.has(item.track_id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
+                                </button>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$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.stop="$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="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([item.track_id])" title="{{ t.player_add_to_playlist }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
+                                </button>
                             </div>
+                            <span class="history-duration" x-text="$store.history.duration(item.duration_listened)"></span>
                         </div>
                     </template>
                 </div>

templates/player/shell.html

@@ -483,19 +483,16 @@
                                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                                 </button>
-                                                <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="{{ t.player_play }}">
-                                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                                </button>
                                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([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" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([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="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                                 </button>
                                             </div>
@@ -573,8 +570,17 @@
                                 <span>•</span>
                                 <span x-text="$store.library.currentArtist.total_play_count + ' {{ t.player_plays_count }}'"></span>
                             </div>
-                            <div class="release-actions">
-                                <button class="release-action-btn secondary"
+                            <div class="release-actions artist-actions">
+                                <button class="release-action-btn primary artist-listen-action"
+                                        :disabled="!($store.library.currentArtist.top_tracks && $store.library.currentArtist.top_tracks.length)"
+                                        @click="$store.library.playArtistTopTracks()"
+                                        title="{{ t.player_listen_artist }}">
+                                    <svg viewBox="0 0 24 24" fill="currentColor" stroke="none">
+                                        <path d="M8 5v14l11-7z"/>
+                                    </svg>
+                                    <span>{{ t.player_listen }}</span>
+                                </button>
+                                <button class="release-action-btn secondary artist-follow-action"
                                         :class="{ followed: $store.follows.has($store.library.currentArtist.id) }"
                                         @click="$store.follows.toggle($store.library.currentArtist.id)"
                                         :title="$store.follows.has($store.library.currentArtist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
@@ -663,19 +669,16 @@
                                             <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                             <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                         </button>
-                                        <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="{{ t.player_play }}">
-                                            <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                        </button>
                                         <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                             <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                        <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([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" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                        <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([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="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                        <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                         </button>
                                     </div>
@@ -762,7 +765,7 @@
                     <template x-for="(track, idx) in $store.library.currentRelease.tracks" :key="track.id">
                         <div class="track-row"
                              :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
-                             @dblclick="$store.queue.playRelease($store.library.currentRelease.tracks, idx)">
+                             @dblclick="$store.queue.playRelease([track], 0)">
                             <span class="track-num" x-text="track.track_number || (idx + 1)"></span>
                             <div class="track-info">
                                 <div class="track-title" x-text="track.title"></div>
@@ -786,19 +789,16 @@
                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="{{ t.player_play }}">
-                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                </button>
                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([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" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([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="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -862,19 +862,16 @@
                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="{{ t.player_play }}">
-                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                </button>
                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([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" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([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="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -904,7 +901,9 @@
                 </template>
                 <template x-for="(track, idx) in $store.queue.tracks" :key="idx + '-' + track.id">
                     <div class="queue-track"
-                         :class="{ active: idx === $store.queue.currentIndex, dragging: $store.queue._dragIdx === idx }"
+                         :data-queue-index="idx"
+                         :class="{ active: idx === $store.queue.currentIndex, dragging: $store.queue._dragIdx === idx, 'foreign-jam-track': $store.queue.isForeignJamTrack(track) }"
+                         :style="$store.queue.isForeignJamTrack(track) ? $store.queue.contributorStyle(track) : ''"
                          @click="$store.queue.playFromIndex(idx)"
                          draggable="true"
                          @dragstart="$store.queue._dragIdx = idx; $event.dataTransfer.effectAllowed = 'move'"
@@ -912,7 +911,10 @@
                          @dragover.prevent="$event.dataTransfer.dropEffect = 'move'; $event.currentTarget.classList.add('drag-over')"
                          @dragleave="$event.currentTarget.classList.remove('drag-over')"
                          @drop.prevent="$event.currentTarget.classList.remove('drag-over'); if ($store.queue._dragIdx !== null) { $store.queue.moveTrack($store.queue._dragIdx, idx); $store.queue._dragIdx = null; }">
-                        <div class="queue-drag-handle" @mousedown.stop>
+                        <div class="queue-drag-handle"
+                             @mousedown.stop
+                             @click.stop
+                             @pointerdown.stop="$store.queue.startPointerReorder($event, idx)">
                             <svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9" cy="6" r="1.5"/><circle cx="15" cy="6" r="1.5"/><circle cx="9" cy="12" r="1.5"/><circle cx="15" cy="12" r="1.5"/><circle cx="9" cy="18" r="1.5"/><circle cx="15" cy="18" r="1.5"/></svg>
                         </div>
                         <div class="queue-track-cover">
@@ -955,11 +957,19 @@
     </div>
 
     <!-- Player Bar -->
-    <div class="player-bar">
+    <div class="player-bar"
+         :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">
+                    <div class="player-cover"
+                         @click.stop="$store.mobile.openPlayerFullscreen()">
                         <template x-if="$store.player.currentTrack.cover_url">
                             <img :src="$store.player.currentTrack.cover_url" :alt="$store.player.currentTrack.title">
                         </template>
@@ -989,6 +999,9 @@
                                 <span class="player-release-year" x-text="' · ' + $store.player.currentTrack.release_year"></span>
                             </template>
                         </div>
+                        <div class="player-track-release" x-show="$store.player.currentTrack.release_title">
+                            <a class="artist-link" @click.stop="$store.player.currentTrack.release_id && $store.library.openRelease($store.player.currentTrack.release_id)" x-text="$store.player.currentTrack.release_title"></a>
+                        </div>
                     </div>
                 </div>
             </template>
@@ -1029,6 +1042,8 @@
                         <div class="progress-bar-thumb"></div>
                     </div>
                 </div>
+                <div class="player-progress-strip-times"
+                     x-text="'-' + formatTime(Math.max(0, $store.player.duration - $store.player.currentTime)) + ' / ' + formatTime($store.player.duration)"></div>
                 <span class="player-time" x-text="formatTime($store.player.duration)"></span>
             </div>
             <div class="player-version-chip">v{{ t.app_version() }}</div>
@@ -1050,7 +1065,7 @@
                 <div class="volume-slider"
                      @pointerdown.prevent="$store.player.startVolumeDrag($event)"
                      aria-label="{{ t.player_volume }}">
-                    <div class="volume-slider-fill" :style="'width:' + ($store.player.volume * 100) + '%'">
+                    <div class="volume-slider-fill" :style="'width:' + $store.player.volumeSliderPercent() + '%'">
                         <div class="volume-slider-thumb"></div>
                     </div>
                 </div>
@@ -1069,11 +1084,18 @@
                         <path d="M8 20h8"/>
                         <path d="M12 16v4"/>
                     </svg>
+                    <span class="jam-member-squares"
+                          x-show="$store.devices.activeJamMembers().length > 0"
+                          x-cloak>
+                        <template x-for="member in $store.devices.activeJamMembers().slice(0, 8)" :key="'device-jam-member-' + member.user_id">
+                            <span class="jam-member-square" :style="$store.devices.userColorStyle(member.user_id, member.name)"></span>
+                        </template>
+                    </span>
                 </button>
                 <div class="device-popover" x-show="$store.devices.open" x-transition x-cloak>
                     <template x-for="device in $store.devices.devices" :key="device.id">
                         <button class="device-row"
-                                :class="{ active: device.is_active }"
+                                :class="{ active: device.is_active, 'current-device': device.is_current }"
                                 @click="$store.devices.select(device.id)">
                             <span class="device-row-icon">
                                 <template x-if="device.kind === 'phone'">
@@ -1101,7 +1123,114 @@
                             </span>
                         </button>
                     </template>
+                    <template x-if="$store.devices.jams.length > 0">
+                        <div class="device-section-label jam-section-label">Jams</div>
+                    </template>
+                    <template x-for="jam in $store.devices.jams" :key="jam.id">
+                        <button class="device-row jam-row"
+                                :class="{ active: jam.is_active, pending: jam.is_pending }"
+                                @click="$store.devices.handleJamRowClick(jam)">
+                            <span class="device-row-icon">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                    <circle cx="8" cy="8" r="3"/>
+                                    <circle cx="16" cy="8" r="3"/>
+                                    <path d="M4 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
+                                    <path d="M12 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
+                                </svg>
+                            </span>
+                            <span class="device-row-main">
+                                <span class="device-row-name" x-text="jam.name"></span>
+                                <span class="device-row-current"
+                                      x-text="!jam.host_device_online ? 'Host offline' : (jam.is_pending ? 'Invite pending' : (jam.is_owner ? 'Your Jam' : 'Shared queue'))"></span>
+                            </span>
+                            <span class="device-row-check" x-show="jam.is_active">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                    <polyline points="20 6 9 17 4 12"/>
+                                </svg>
+                            </span>
+                        </button>
+                    </template>
+                    <button class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
+                        <span class="device-row-icon">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M12 5v14"/>
+                                <path d="M5 12h14"/>
+                            </svg>
+                        </span>
+                        <span class="device-row-main">
+                            <span class="device-row-name">Start Jam</span>
+                            <span class="device-row-current">Invite listeners</span>
+                        </span>
+                    </button>
+                    <div class="jam-create-panel" x-show="$store.devices.jamPanelOpen" x-transition x-cloak>
+                        <div class="jam-panel-title" x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite listeners' : 'Start Jam'"></div>
+                        <div class="jam-selected-users" x-show="$store.devices.jamSelectedUsers.length > 0">
+                            <template x-for="user in $store.devices.jamSelectedUsers" :key="user.id">
+                                <button class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
+                                    <span x-text="user.display_name || user.username"></span>
+                                    <span aria-hidden="true">×</span>
+                                </button>
+                            </template>
+                        </div>
+                        <input class="jam-user-search"
+                               type="search"
+                               placeholder="Search users"
+                               x-model="$store.devices.jamQuery"
+                               @input="$store.devices.queueJamSearch()">
+                        <div class="jam-search-results" x-show="$store.devices.jamUsers.length > 0">
+                            <template x-for="user in $store.devices.jamUsers" :key="user.id">
+                                <button class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
+                                    <span x-text="user.display_name || user.username"></span>
+                                    <small x-text="user.email || user.username"></small>
+                                </button>
+                            </template>
+                        </div>
+                        <div class="jam-panel-actions">
+                            <button class="jam-create-btn"
+                                    :disabled="$store.devices.jamSelectedUsers.length === 0 && $store.devices.jamPanelMode === 'manage'"
+                                    @click="$store.devices.submitJamPanel()"
+                                    x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite' : 'Create Jam'"></button>
+                            <button class="jam-leave-btn"
+                                    x-show="$store.devices.jamPanelMode === 'manage'"
+                                    @click="$store.devices.leaveJam($store.devices.jamPanelJamId)">Leave</button>
                         </div>
                     </div>
                 </div>
             </div>
+            </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>
+            </template>
+            <template x-for="(track, idx) in $store.queue.upcoming()" :key="'mobile-expanded-queue-' + track.id + '-' + idx">
+                <button class="mobile-expanded-queue-row"
+                        :class="{ 'foreign-jam-track': $store.queue.isForeignJamTrack(track) }"
+                        :style="$store.queue.isForeignJamTrack(track) ? $store.queue.contributorStyle(track) : ''"
+                        type="button"
+                        @click="$store.queue.playFromIndex($store.queue.currentIndex + idx + 1)">
+                    <div class="mobile-expanded-queue-cover">
+                        <template x-if="track.cover_url">
+                            <img :src="track.cover_url" :alt="track.title" loading="lazy">
+                        </template>
+                        <template x-if="!track.cover_url">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                        </template>
+                    </div>
+                    <div class="mobile-expanded-queue-info">
+                        <div class="mobile-expanded-queue-name" x-text="track.title"></div>
+                        <div class="mobile-expanded-queue-artist">
+                            <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>
+                                    <span x-text="artist.label"></span>
+                                </span>
+                            </template>
+                        </div>
+                    </div>
+                    <span class="mobile-expanded-queue-time" x-text="formatTime(track.duration_seconds)"></span>
+                </button>
+            </template>
+            </div>
+        </div>
+    </div>