PLAYER: fixe i8n

Cargo.lock

@@ -501,6 +501,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -599,6 +605,12 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e769b5c8c8283982a987c6e948e540254f1058d5a74b8794914d4ef5fc2a24"
 
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
 [[package]]
 name = "colorchoice"
 version = "1.0.5"
@@ -1304,6 +1316,15 @@ version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
 [[package]]
 name = "ff"
 version = "0.13.1"
@@ -1397,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.1.10"
+version = "0.2.12"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1407,7 +1428,9 @@ dependencies = [
  "croner",
  "encoding_rs",
  "id3",
+ "image",
  "librqbit",
+ "md-5",
  "openidconnect",
  "reqwest",
  "schemars 0.9.0",
@@ -1418,6 +1441,7 @@ dependencies = [
  "symphonia",
  "tokio",
  "tokio-cron-scheduler",
+ "tower",
  "tracing",
  "tracing-subscriber",
  "uuid",
@@ -1588,6 +1612,16 @@ dependencies = [
  "wasip3",
 ]
 
+[[package]]
+name = "gif"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
 [[package]]
 name = "gimli"
 version = "0.32.3"
@@ -2026,6 +2060,34 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "gif",
+ "image-webp",
+ "moxcms",
+ "num-traits",
+ "png",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
+dependencies = [
+ "byteorder-lite",
+ "quick-error",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@@ -2522,6 +2584,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "multer"
 version = "3.1.0"
@@ -3000,6 +3072,19 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.1",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.13.1"
@@ -3067,6 +3152,12 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
 [[package]]
 name = "quanta"
 version = "0.12.6"
@@ -3082,6 +3173,12 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
 [[package]]
 name = "quick-xml"
 version = "0.37.5"
@@ -5142,6 +5239,12 @@ dependencies = [
  "rustls-pki-types",
 ]
 
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
 [[package]]
 name = "whoami"
 version = "1.6.1"
@@ -5690,3 +5793,18 @@ name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.1.10"
+version = "0.2.13"
 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"
@@ -20,6 +21,8 @@ symphonia = { version = "0.5", default-features = false, features = ["mp3","aac"
 id3 = "1"
 encoding_rs = "0.8"
 sha2 = "0.10"
+md-5 = "0.10"
+image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp", "gif", "bmp"] }
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres"] }
 anyhow = "1.0"
 tokio-cron-scheduler = "0.15"

src/admin/mod.rs

@@ -20,8 +20,8 @@ use crate::i18n::I18n;
 use crate::scheduler::{JobRegistry, SchedulerHandle};
 use crate::user::User;
 use views::{
-    ArtistForm, CronForm, MetadataBackfillForm, OidcSettingsForm, ReleaseForm, ReviewsBulkForm,
-    SetImageBody, SetupForm, UploadImageBody, UserForm,
+    ArtistForm, CronForm, MetadataBackfillForm, OidcSettingsForm, ReleaseForm, ReviewApproveForm,
+    ReviewsBulkForm, SetImageBody, SetupForm, UploadImageBody, UserForm,
 };
 
 #[derive(Debug, Deserialize)]
@@ -227,6 +227,35 @@ impl App for AdminApp {
                 },
                 "admin_v2_reviews_bulk",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/reviews/{id}/approve",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              path: Path<PathId>,
+                              json: Json<v2::ReviewEditDto>| {
+                            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::approve_review(session, db, pg_pool, path.0.id, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_review_approve",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/jobs",
                 {
@@ -253,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({
@@ -264,6 +319,27 @@ impl App for AdminApp {
                 }),
                 "admin_v2_job_run",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/settings",
+                get(move |session: Session, db: Database| async move {
+                    v2::settings(session, db).await
+                })
+                .post(
+                    move |session: Session,
+                          db: Database,
+                          json: Json<v2::UpdateSettingsRequest>| async move {
+                        v2::update_settings(session, db, json).await
+                    },
+                ),
+                "admin_v2_settings",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/settings/probe",
+                get(move |session: Session, db: Database| async move {
+                    v2::settings_probe(session, db).await
+                }),
+                "admin_v2_settings_probe",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/jobs/{name}/toggle",
                 cot::router::method::post({
@@ -378,6 +454,88 @@ impl App for AdminApp {
                 },
                 "admin_v2_library_item",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/detail",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session,
+                              db: Database,
+                              query: UrlQuery<v2::LibraryItemDetailQuery>| {
+                        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::library_item_detail(session, db, pg_pool, query.0).await
+                        }
+                    })
+                },
+                "admin_v2_library_item_detail",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/image",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              json: Json<v2::SetLibraryImageRequest>| {
+                            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::set_library_item_image(session, db, pg_pool, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_library_item_image",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/upload-image",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              json: Json<v2::UploadLibraryImageRequest>| {
+                            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::upload_library_item_image(session, db, pg_pool, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_library_item_upload_image",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/library/bulk",
                 {
@@ -1027,7 +1185,8 @@ impl App for AdminApp {
                     let config = Arc::clone(&self.config);
                     let pool = Arc::clone(&pool);
                     let pool_config = Arc::clone(&pool_config);
-                    move |session: Session, db: Database, path: Path<PathId>| {
+                    move |session: Session, db: Database, path: Path<PathId>,
+                          form: RequestForm<ReviewApproveForm>| {
                         let config = Arc::clone(&config);
                         let pool = Arc::clone(&pool);
                         let pool_config = Arc::clone(&pool_config);
@@ -1043,7 +1202,7 @@ impl App for AdminApp {
                                     .await
                                     .expect("admin pool")
                             }).await;
-                            views::review_approve(admin, &config, &db, pg_pool, path.0.id).await
+                            views::review_approve(admin, &config, &db, pg_pool, path.0.id, form).await
                         }
                     }
                 }),

src/admin/views.rs

@@ -184,6 +184,16 @@ fn config_display_entries(config: &AppConfig, sources: &ConfigSources) -> Vec<Co
             config.agent_concurrency.to_string(),
             defaults.agent_concurrency.to_string()
         ),
+        entry!(
+            lastfm_api_key,
+            config.lastfm_api_key.clone(),
+            defaults.lastfm_api_key.clone()
+        ),
+        entry!(
+            lastfm_shared_secret,
+            config.lastfm_shared_secret.clone(),
+            defaults.lastfm_shared_secret.clone()
+        ),
     ]
 }
 
@@ -258,6 +268,10 @@ struct SettingsTemplate {
     agent_context_limit_source: &'static str,
     agent_concurrency: String,
     agent_concurrency_source: &'static str,
+    lastfm_api_key: String,
+    lastfm_api_key_source: &'static str,
+    lastfm_shared_secret: String,
+    lastfm_shared_secret_source: &'static str,
 }
 
 pub async fn settings_handler(
@@ -310,6 +324,10 @@ pub async fn settings_handler(
         agent_context_limit_source: sources.agent_context_limit.code(),
         agent_concurrency: config.agent_concurrency.to_string(),
         agent_concurrency_source: sources.agent_concurrency.code(),
+        lastfm_api_key: config.lastfm_api_key.clone(),
+        lastfm_api_key_source: sources.lastfm_api_key.code(),
+        lastfm_shared_secret: config.lastfm_shared_secret.clone(),
+        lastfm_shared_secret_source: sources.lastfm_shared_secret.code(),
     };
     Ok(Html::new(template.render()?))
 }
@@ -334,6 +352,8 @@ pub struct OidcSettingsForm {
     agent_confidence_threshold: Option<String>,
     agent_context_limit: Option<String>,
     agent_concurrency: Option<String>,
+    lastfm_api_key: Option<String>,
+    lastfm_shared_secret: Option<String>,
 }
 
 pub async fn settings_submit(
@@ -380,7 +400,9 @@ pub async fn settings_submit(
             let agent_confidence_threshold = data.agent_confidence_threshold.unwrap_or_default();
             let agent_context_limit = data.agent_context_limit.unwrap_or_default();
             let agent_concurrency = data.agent_concurrency.unwrap_or_default();
-            let fields: [(&str, &str); 18] = [
+            let lastfm_api_key = data.lastfm_api_key.unwrap_or_default();
+            let lastfm_shared_secret = data.lastfm_shared_secret.unwrap_or_default();
+            let fields: [(&str, &str); 20] = [
                 ("auth_password_enabled", pw_enabled),
                 ("auth_sso_enabled", sso_enabled),
                 ("oidc_button_text", &oidc_button_text),
@@ -399,6 +421,8 @@ pub async fn settings_submit(
                 ("agent_confidence_threshold", &agent_confidence_threshold),
                 ("agent_context_limit", &agent_context_limit),
                 ("agent_concurrency", &agent_concurrency),
+                ("lastfm_api_key", &lastfm_api_key),
+                ("lastfm_shared_secret", &lastfm_shared_secret),
             ];
             for (key, value) in fields {
                 let mut entry = ConfigEntry::new(key.to_owned(), value.to_owned());
@@ -799,7 +823,7 @@ pub async fn artists_edit(
             .await
             .ok()
             .flatten()
-            .map(|mf| format!("/api/player/cover/{}", mf.id_val())),
+            .map(|mf| format!("/api/player/cover/{}/large", mf.id_val())),
         None => None,
     };
 
@@ -879,7 +903,7 @@ pub async fn artists_available_covers(
                 covers.push(AvailableCover {
                     media_file_id: cover_fid,
                     release_title: release.title_str().to_owned(),
-                    cover_url: format!("/api/player/cover/{cover_fid}"),
+                    cover_url: format!("/api/player/cover/{cover_fid}/medium"),
                 });
             }
         }
@@ -1378,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>,
 }
 
@@ -1444,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"),
     };
 
@@ -1794,12 +1822,104 @@ struct ReviewDetailTemplate {
     user_name: String,
     user_role: String,
     review: PendingReview,
+    edit: ReviewEditFields,
+    release_types: &'static [(&'static str, &'static str, &'static str)],
+    lang_code: &'static str,
     context_pretty: String,
     result_pretty: String,
     error_message: String,
     stats: Option<scheduler::ProcessingStats>,
 }
 
+#[derive(Debug, Default)]
+struct ReviewEditFields {
+    title: String,
+    artist: String,
+    album: String,
+    year: String,
+    track_number: String,
+    genre: String,
+    featured_artists: String,
+    release_type: String,
+    notes: String,
+}
+
+#[derive(Debug, Form)]
+pub struct ReviewApproveForm {
+    title: String,
+    artist: String,
+    album: String,
+    year: String,
+    track_number: String,
+    genre: String,
+    featured_artists: String,
+    release_type: String,
+    notes: String,
+}
+
+fn optional_trimmed(value: &str) -> Option<String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_owned())
+    }
+}
+
+fn parse_optional_i32(value: &str) -> Option<i32> {
+    value.trim().parse::<i32>().ok()
+}
+
+fn parse_featured_artists(value: &str) -> Vec<String> {
+    value
+        .split(',')
+        .map(str::trim)
+        .filter(|part| !part.is_empty())
+        .map(str::to_owned)
+        .collect()
+}
+
+fn edit_fields_from_normalized(
+    normalized: &crate::agent::dto::NormalizedFields,
+) -> ReviewEditFields {
+    ReviewEditFields {
+        title: normalized.title.clone().unwrap_or_default(),
+        artist: normalized.artist.clone().unwrap_or_default(),
+        album: normalized.album.clone().unwrap_or_default(),
+        year: normalized.year.map(|v| v.to_string()).unwrap_or_default(),
+        track_number: normalized
+            .track_number
+            .map(|v| v.to_string())
+            .unwrap_or_default(),
+        genre: normalized.genre.clone().unwrap_or_default(),
+        featured_artists: normalized.featured_artists.join(", "),
+        release_type: normalized
+            .release_type
+            .clone()
+            .unwrap_or_else(|| "album".to_owned()),
+        notes: normalized.notes.clone().unwrap_or_default(),
+    }
+}
+
+fn normalized_from_result_json(result_json: &str) -> crate::agent::dto::NormalizedFields {
+    serde_json::from_str(result_json).unwrap_or_default()
+}
+
+fn normalized_from_review_form(form: &ReviewApproveForm) -> crate::agent::dto::NormalizedFields {
+    crate::agent::dto::NormalizedFields {
+        title: optional_trimmed(&form.title),
+        artist: optional_trimmed(&form.artist),
+        album: optional_trimmed(&form.album),
+        year: parse_optional_i32(&form.year),
+        track_number: parse_optional_i32(&form.track_number),
+        genre: optional_trimmed(&form.genre),
+        featured_artists: parse_featured_artists(&form.featured_artists),
+        release_type: optional_trimmed(&form.release_type).or_else(|| Some("album".to_owned())),
+        confidence: Some(1.0),
+        notes: optional_trimmed(&form.notes),
+    }
+}
+
 pub async fn review_detail(
     admin: AuthenticatedUser,
     i18n: I18n,
@@ -1830,12 +1950,17 @@ pub async fn review_detail(
     let stats = scheduler::ProcessingStats::get_by_review_id(db, review_id)
         .await
         .unwrap_or(None);
+    let normalized = normalized_from_result_json(review.result_json_str());
+    let edit = edit_fields_from_normalized(&normalized);
 
     let template = ReviewDetailTemplate {
         t: i18n.t,
         user_name: admin.name,
         user_role: admin.role.code().to_owned(),
         review,
+        edit,
+        release_types: RELEASE_TYPES,
+        lang_code: i18n.t.lang.code(),
         context_pretty,
         result_pretty,
         error_message,
@@ -1850,24 +1975,29 @@ pub async fn review_approve(
     db: &Database,
     pool: &sqlx::PgPool,
     review_id: i64,
+    form: RequestForm<ReviewApproveForm>,
 ) -> cot::Result<cot::http::Response<Body>> {
     let mut review = PendingReview::get_by_id(db, review_id)
         .await
         .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
         .ok_or_else(|| cot::Error::internal("review not found"))?;
 
-    let result_str = review.result_json_str().to_owned();
+    let RequestForm(form_result) = form;
+    let normalized = match form_result {
+        FormResult::Ok(data) => normalized_from_review_form(&data),
+        FormResult::ValidationError(_) => {
+            return Ok(auth::redirect(&format!("/admin/reviews/{review_id}")));
+        }
+    };
+    let result_str = serde_json::to_string(&normalized)
+        .map_err(|e| cot::Error::internal(format!("failed to serialize review fields: {e}")))?;
+    review
+        .set_result_json(db, result_str)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?;
     let context_str = review.context_json_str().to_owned();
     let input_path = review.input_path_str().to_owned();
 
-    if result_str.is_empty() {
-        let _ = review.set_rejected(db).await;
-        return Ok(auth::redirect(&format!("/admin/reviews/{review_id}")));
-    }
-
-    let normalized: crate::agent::dto::NormalizedFields = serde_json::from_str(&result_str)
-        .map_err(|e| cot::Error::internal(format!("invalid result_json: {e}")))?;
-
     let context: serde_json::Value = serde_json::from_str(&context_str).unwrap_or_default();
 
     // Load live config from DB so admin-set values are used

src/agent/cover_art.rs

@@ -3,6 +3,7 @@
 //! Sources (in priority order):
 //! 1. Standalone image files in the album folder (cover.jpg, folder.jpg, etc.)
 //! 2. Embedded cover art in audio file metadata (ID3 APIC, Vorbis METADATA_BLOCK_PICTURE, etc.)
+//! 3. Remote metadata providers used by background backfill jobs.
 //!
 //! The first usable image found is saved as a MediaFile with file_type="cover_art"
 //! and linked to the Release via cover_file_id.
@@ -26,6 +27,8 @@ pub enum CoverSource {
     FolderFile(PathBuf),
     /// Embedded in an audio file's metadata.
     Embedded(PathBuf),
+    /// Downloaded from a remote metadata provider.
+    Remote(String),
 }
 
 /// Well-known cover art filenames, in priority order.
@@ -125,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;
+            }
         }
     }
 
@@ -140,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
 }
 
@@ -320,24 +333,62 @@ pub async fn save_cover_to_storage(
     let hash = hash_image(&cover.data);
 
     // Check if we already have this exact image in the DB
-    let existing: Option<(i64,)> = sqlx::query_as(
-        "SELECT id FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
+    let existing: Option<(i64, String)> = sqlx::query_as(
+        "SELECT id, file_path FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
     )
     .bind(&hash)
     .fetch_optional(pool)
     .await?;
 
-    if let Some((id,)) = existing {
-        return Ok(id);
+    if let Some((id, file_path)) = existing {
+        let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path);
+        let is_inside_storage = crate::media_paths::path_for_root(storage_dir, &path).is_some();
+        if !is_inside_storage {
+            tracing::warn!(
+                media_file_id = id,
+                path = %path.display(),
+                "Ignoring duplicate cover hash whose stored file is outside agent_storage_dir"
+            );
+        } else if !path.exists() {
+            if let Some(parent) = path.parent() {
+                tokio::fs::create_dir_all(parent).await?;
+            }
+            match tokio::fs::write(&path, &cover.data).await {
+                Ok(()) => {
+                    tracing::info!(
+                        media_file_id = id,
+                        path = %path.display(),
+                        "Restored missing cover file for existing MediaFile"
+                    );
+                }
+                Err(err) => {
+                    tracing::warn!(
+                        media_file_id = id,
+                        path = %path.display(),
+                        error = %err,
+                        "Failed to restore missing cover file for existing MediaFile; creating a new cover file"
+                    );
+                }
+            }
+        }
+        if is_inside_storage && path.exists() {
+            if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&path).await {
+                tracing::warn!(media_file_id = id, error = %err, "Failed to generate cover variants");
+            }
+            return Ok(id);
+        }
     }
 
     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);
 
-    let dest_dir = Path::new(storage_dir).join(&artist_dir).join(&album_dir);
+    let dest_dir = crate::media_paths::resolve_config_path_buf(storage_dir)
+        .join(&artist_dir)
+        .join(&album_dir);
     tokio::fs::create_dir_all(&dest_dir).await?;
 
     let dest_path = dest_dir.join(&filename);
@@ -345,7 +396,13 @@ pub async fn save_cover_to_storage(
     // Write image data
     tokio::fs::write(&dest_path, &cover.data).await?;
 
-    let relative_path = dest_path.to_string_lossy().to_string();
+    let relative_path = crate::media_paths::media_file_path_for_storage(storage_dir, &dest_path)
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "cover destination is outside agent_storage_dir: {}",
+                dest_path.display()
+            )
+        })?;
     let file_size = cover.data.len() as i64;
 
     let media_file = crate::music::MediaFile::create(
@@ -374,6 +431,14 @@ pub async fn save_cover_to_storage(
         "Saved cover art"
     );
 
+    if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&dest_path).await {
+        tracing::warn!(
+            media_file_id = media_file.id_val(),
+            error = %err,
+            "Failed to generate cover variants"
+        );
+    }
+
     Ok(media_file.id_val())
 }
 

src/agent/cover_variants.rs

@@ -0,0 +1,118 @@
+use std::path::{Path, PathBuf};
+
+use image::codecs::jpeg::JpegEncoder;
+use image::imageops::FilterType;
+
+#[derive(Debug, Clone, Copy)]
+pub struct CoverVariant {
+    pub name: &'static str,
+    pub max_edge: u32,
+    pub quality: u8,
+}
+
+pub const COVER_VARIANTS: &[CoverVariant] = &[
+    CoverVariant {
+        name: "small",
+        max_edge: 96,
+        quality: 80,
+    },
+    CoverVariant {
+        name: "medium",
+        max_edge: 256,
+        quality: 82,
+    },
+    CoverVariant {
+        name: "large",
+        max_edge: 512,
+        quality: 85,
+    },
+];
+
+pub fn variant_by_name(name: &str) -> Option<CoverVariant> {
+    COVER_VARIANTS
+        .iter()
+        .copied()
+        .find(|variant| variant.name == name)
+}
+
+pub fn variant_path(original_path: &Path, variant: CoverVariant) -> PathBuf {
+    let stem = original_path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .filter(|value| !value.is_empty())
+        .unwrap_or("cover");
+    let filename = format!("{stem}.{}.jpg", variant.name);
+    original_path.with_file_name(filename)
+}
+
+pub fn missing_variants(original_path: &Path) -> Vec<CoverVariant> {
+    COVER_VARIANTS
+        .iter()
+        .copied()
+        .filter(|variant| !variant_path(original_path, *variant).exists())
+        .collect()
+}
+
+pub async fn ensure_cover_variants(original_path: &Path) -> anyhow::Result<usize> {
+    let missing = missing_variants(original_path);
+    if missing.is_empty() {
+        return Ok(0);
+    }
+
+    let original_path = original_path.to_path_buf();
+    tokio::task::spawn_blocking(move || generate_missing_variants_sync(&original_path, &missing))
+        .await
+        .map_err(|err| anyhow::anyhow!("cover variant task failed: {err}"))?
+}
+
+fn generate_missing_variants_sync(
+    original_path: &Path,
+    variants: &[CoverVariant],
+) -> anyhow::Result<usize> {
+    let data = std::fs::read(original_path)?;
+    let image = image::load_from_memory(&data)?;
+
+    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;
+        }
+
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+
+        let resized = image
+            .resize(variant.max_edge, variant.max_edge, FilterType::Lanczos3)
+            .to_rgb8();
+        let mut output = Vec::new();
+        let mut encoder = JpegEncoder::new_with_quality(&mut output, variant.quality);
+        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;
+    }
+
+    Ok(created)
+}

src/agent/mod.rs

@@ -1,4 +1,5 @@
 pub mod cover_art;
+pub mod cover_variants;
 pub mod dto;
 pub mod metadata;
 pub mod mover;

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/config.rs

@@ -133,6 +133,8 @@ pub struct ConfigSources {
     pub agent_confidence_threshold: ConfigSource,
     pub agent_context_limit: ConfigSource,
     pub agent_concurrency: ConfigSource,
+    pub lastfm_api_key: ConfigSource,
+    pub lastfm_shared_secret: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -158,6 +160,8 @@ impl Default for ConfigSources {
             agent_confidence_threshold: ConfigSource::Default,
             agent_context_limit: ConfigSource::Default,
             agent_concurrency: ConfigSource::Default,
+            lastfm_api_key: ConfigSource::Default,
+            lastfm_shared_secret: ConfigSource::Default,
         }
     }
 }
@@ -262,6 +266,10 @@ pub struct AppConfig {
     pub agent_context_limit: u64,
     /// Number of files to process in parallel via the LLM.
     pub agent_concurrency: u64,
+    /// Last.fm API key for weekly popularity enrichment.
+    pub lastfm_api_key: String,
+    /// Last.fm shared secret for authenticated scrobbling calls.
+    pub lastfm_shared_secret: String,
 }
 
 impl Default for AppConfig {
@@ -287,6 +295,8 @@ impl Default for AppConfig {
             agent_confidence_threshold: 0.85,
             agent_context_limit: 8192,
             agent_concurrency: 2,
+            lastfm_api_key: String::new(),
+            lastfm_shared_secret: String::new(),
         }
     }
 }
@@ -313,14 +323,22 @@ impl_env_overrides!(
     agent_confidence_threshold,
     agent_context_limit,
     agent_concurrency,
+    lastfm_api_key,
+    lastfm_shared_secret,
 );
 
 impl AppConfig {
+    fn normalize_host_paths(&mut self) {
+        self.agent_inbox_dir = crate::media_paths::resolve_config_path(&self.agent_inbox_dir);
+        self.agent_storage_dir = crate::media_paths::resolve_config_path(&self.agent_storage_dir);
+    }
+
     /// Build config: start from defaults, then overlay env vars.
     /// Used at startup before the DB is available (to get `database_url`).
     pub fn load() -> Self {
         let mut cfg = Self::default();
         cfg.apply_env_overrides();
+        cfg.normalize_host_paths();
         cfg
     }
 
@@ -331,6 +349,7 @@ impl AppConfig {
         let mut sources = ConfigSources::default();
         cfg.apply_db_overrides(db, &mut sources).await;
         cfg.apply_env_overrides_tracked(&mut sources);
+        cfg.normalize_host_paths();
         (cfg, sources)
     }
 
@@ -389,12 +408,21 @@ impl AppConfig {
         apply_db_field!(agent_confidence_threshold);
         apply_db_field!(agent_context_limit);
         apply_db_field!(agent_concurrency);
+        apply_db_field!(lastfm_api_key);
+        apply_db_field!(lastfm_shared_secret);
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::{Mutex, MutexGuard};
+
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    fn lock_env() -> MutexGuard<'static, ()> {
+        ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner())
+    }
 
     #[test]
     fn defaults_are_sane() {
@@ -403,7 +431,29 @@ mod tests {
         assert_eq!(cfg.log_level, "info");
     }
 
-    // SAFETY: tests run with --test-threads=1 so no concurrent env access.
+    #[test]
+    fn resolves_relative_media_paths_from_working_dir() {
+        let expected = std::env::current_dir()
+            .unwrap()
+            .join("media")
+            .join("uploads")
+            .to_string_lossy()
+            .to_string();
+        assert_eq!(
+            crate::media_paths::resolve_config_path("media/uploads"),
+            expected
+        );
+    }
+
+    #[test]
+    fn keeps_absolute_windows_media_paths() {
+        assert_eq!(
+            crate::media_paths::resolve_config_path(r"C:\Users\ab\repos\furumusic\media\uploads"),
+            "C:/Users/ab/repos/furumusic/media/uploads"
+        );
+    }
+
+    // SAFETY: environment-mutating tests take ENV_LOCK before changing vars.
     unsafe fn set(k: &str, v: &str) {
         unsafe { std::env::set_var(k, v) };
     }
@@ -413,6 +463,7 @@ mod tests {
 
     #[test]
     fn env_override_string_field() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_OIDC_ISSUER", "https://example.com");
         }
@@ -425,6 +476,7 @@ mod tests {
 
     #[test]
     fn env_override_bool_field() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_AUTH_SSO_ENABLED", "true");
         }
@@ -437,6 +489,7 @@ mod tests {
 
     #[test]
     fn source_tracking_env() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_OIDC_ISSUER", "https://tracked.example.com");
         }

src/i18n/phrases.rs

@@ -95,6 +95,10 @@ translations! {
     settings_api:             "API"                           , "API";
     settings_swagger:         "Swagger UI"                    , "Swagger UI";
     settings_swagger_help:    "Serves interactive API docs at /swagger/ (requires restart)" , "Интерактивная документация API на /swagger/ (требуется перезапуск)";
+    settings_lastfm_api_key:  "Last.fm API key"               , "API ключ Last.fm";
+    settings_lastfm_api_key_help: "Used for Last.fm popularity and account connection" , "Используется для популярности Last.fm и подключения аккаунта";
+    settings_lastfm_shared_secret: "Last.fm shared secret"    , "Shared secret Last.fm";
+    settings_lastfm_shared_secret_help: "Required for signed Last.fm scrobbling requests" , "Нужен для подписанных запросов скробблинга Last.fm";
 
     // OIDC login errors
     login_oidc_error:         "SSO login failed. Please try again." , "Ошибка входа через SSO. Попробуйте ещё раз.";
@@ -264,4 +268,244 @@ translations! {
     settings_agent_completion_tokens: "Completion tokens"       , "Токенов на ответ";
     settings_agent_tokens_per_sec: "Tokens/sec"                 , "Токенов/сек";
     settings_agent_status_loading: "Checking connection"         , "Проверка подключения";
+
+    // Player UI
+    player_library:          "Library"                         , "Библиотека";
+    player_artists:          "Artists"                         , "Артисты";
+    player_release:          "Release"                         , "Релиз";
+    player_releases:         "Releases"                        , "Релизы";
+    player_tracks:           "Tracks"                          , "Треки";
+    player_title:            "Title"                           , "Название";
+    player_duration:         "Duration"                        , "Длительность";
+    player_following:        "Following"                       , "Подписки";
+    player_follow:           "Follow"                          , "Подписаться";
+    player_followed:         "Following"                       , "Вы подписаны";
+    player_unfollow_artist:  "Unfollow artist"                 , "Отписаться от артиста";
+    player_follow_artist:    "Follow artist"                   , "Подписаться на артиста";
+    player_no_followed_artists: "No followed artists"           , "Нет подписок на артистов";
+    player_playlists:        "Playlists"                       , "Плейлисты";
+    player_published_playlists: "Published Playlists"           , "Опубликованные плейлисты";
+    player_public:           "Public"                          , "Публичный";
+    player_published:        "Published"                       , "Опубликован";
+    player_by:               "by"                              , "от";
+    player_tracks_count:     "tracks"                          , "треков";
+    player_files_count:      "files"                           , "файлов";
+    player_releases_count:   "releases"                        , "релизов";
+    player_plays_count:      "plays"                           , "прослушиваний";
+    player_likes_count:      "likes"                           , "лайков";
+    player_likes_playlist:   "Likes"                           , "Лайки";
+    player_listened:         "listened"                        , "прослушано";
+    player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
+    player_connection_lost: "Server connection lost"             , "Нет соединения с сервером";
+    player_connection_lost_detail: "Player cannot reach the server. Retrying..." , "Плеер не может связаться с сервером. Повторяю...";
+    player_no_results:       "No results found"                , "Ничего не найдено";
+    player_new_playlist:     "New Playlist"                    , "Новый плейлист";
+    player_rename_playlist:  "Rename Playlist"                 , "Переименовать плейлист";
+    player_playlist_name:    "Playlist name"                   , "Название плейлиста";
+    player_add_to_playlist:  "Add to Playlist"                 , "Добавить в плейлист";
+    player_cancel:           "Cancel"                          , "Отмена";
+    player_create:           "Create"                          , "Создать";
+    player_save:             "Save"                            , "Сохранить";
+    player_delete:           "Delete"                          , "Удалить";
+    player_delete_playlist_confirm: "Delete this playlist?"     , "Удалить этот плейлист?";
+    player_rename:           "Rename"                          , "Переименовать";
+    player_close:            "Close"                           , "Закрыть";
+    player_log_out:          "Log out"                         , "Выйти";
+    player_admin_panel:      "Admin Panel"                     , "Админка";
+    player_info:             "Info"                            , "Информация";
+    player_no_details:       "No details available."           , "Нет подробностей.";
+    player_release_info:     "Release info"                    , "Информация о релизе";
+    player_track_info:       "Track info"                      , "Информация о треке";
+    player_type:             "Type"                            , "Тип";
+    player_year:             "Year"                            , "Год";
+    player_uploaders:        "Uploaders"                       , "Загрузили";
+    player_unknown:          "unknown"                         , "неизвестно";
+    player_unknown_size:     "unknown size"                    , "размер неизвестен";
+    player_unknown_release:  "Unknown release"                 , "Неизвестный релиз";
+    player_unknown_track:    "Unknown track"                   , "Неизвестный трек";
+    player_unknown_audio:    "unknown audio details"           , "детали аудио неизвестны";
+    player_release_year:     "Release year"                    , "Год релиза";
+    player_audio:            "Audio"                           , "Аудио";
+    player_size:             "Size"                            , "Размер";
+    player_uploader:         "Uploader"                        , "Загрузил";
+    player_lastfm_rating:    "Last.fm popularity"              , "Популярность Last.fm";
+    player_lastfm_listeners: "Last.fm listeners"               , "Слушатели Last.fm";
+    player_lastfm_playcount: "Last.fm plays"                   , "Прослушивания Last.fm";
+    player_lastfm_updated:   "Last.fm updated"                 , "Last.fm обновлён";
+    player_lastfm_not_loaded: "not loaded yet"                 , "ещё не загружено";
+    player_lastfm_profile:   "Last.fm"                         , "Last.fm";
+    player_lastfm_connect:   "Connect Last.fm"                 , "Подключить Last.fm";
+    player_lastfm_connected: "Connected as {user}"             , "Подключён: {user}";
+    player_lastfm_reconnect: "Reconnect Last.fm"               , "Переподключить Last.fm";
+    player_lastfm_not_configured: "Last.fm is not configured"  , "Last.fm не настроен";
+    player_lastfm_status_connect: "connect account"            , "подключить аккаунт";
+    player_lastfm_status_connected: "connected"                , "подключён";
+    player_lastfm_status_reconnect: "reconnect account"        , "переподключить аккаунт";
+    player_lastfm_status_not_configured: "not configured"      , "не настроен";
+    player_lastfm_disconnect_confirm: "Disconnect Last.fm account {user}?" , "Отвязать аккаунт Last.fm {user}?";
+    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"             , "Добавить в конец очереди";
+    player_play_next:        "Play next"                       , "Играть следующим";
+    player_queue:            "Queue"                           , "Очередь";
+    player_next:             "Next"                            , "Далее";
+    player_previous:         "Previous"                        , "Назад";
+    player_clear:            "Clear"                           , "Очистить";
+    player_remove:           "Remove"                          , "Удалить";
+    player_queue_empty:      "Queue is empty"                  , "Очередь пуста";
+    player_shuffle:          "Shuffle"                         , "Перемешать";
+    player_repeat:           "Repeat"                          , "Повтор";
+    player_volume:           "Volume"                          , "Громкость";
+    player_appears_on:       "Appears on"                      , "Участвует в";
+    player_albums:           "Albums"                          , "Альбомы";
+    player_eps:              "EPs"                             , "EP";
+    player_singles:          "Singles"                         , "Синглы";
+    player_compilations:     "Compilations"                    , "Сборники";
+    player_mixtapes:         "Mixtapes"                        , "Микстейпы";
+    player_live_releases:    "Live releases"                   , "Концертные релизы";
+    player_soundtracks:      "Soundtracks"                     , "Саундтреки";
+
+    // Player torrent/history UI
+    player_torrent_manager:  "Torrent manager"                 , "Торрент-менеджер";
+    player_import_torrent:   "Import torrent"                  , "Импортировать торрент";
+    player_client_idle:      "Client idle"                     , "Клиент простаивает";
+    player_active:           "active"                          , "активно";
+    player_ai_idle:          "AI idle"                         , "ИИ простаивает";
+    player_ai_prefix:        "AI"                              , "ИИ";
+    player_processing:       "processing"                      , "обрабатывается";
+    player_queued:           "queued"                          , "в очереди";
+    player_saved:            "saved"                           , "сохранено";
+    player_saved_torrents:   "Saved torrents"                  , "Сохранённые торренты";
+    player_refresh:          "Refresh"                         , "Обновить";
+    player_no_saved_torrents: "No saved torrents"              , "Сохранённых торрентов нет";
+    player_import:           "Import"                          , "Импорт";
+    player_upload:           "Upload"                          , "Загрузить";
+    player_my_uploads:       "My uploads"                      , "Мои загрузки";
+    player_my_uploaded_tracks: "My uploaded tracks"             , "Мои загруженные треки";
+    player_no_uploaded_tracks: "No uploaded tracks yet"         , "Загруженных треков пока нет";
+    player_needs_approval:   "Needs approval"                  , "Нужно подтверждение";
+    player_pending_or_failed: "pending or failed"               , "ожидают или с ошибкой";
+    player_no_tracks_need_approval: "No tracks need approval"   , "Нет треков для подтверждения";
+    player_queued_processing: "Queued / processing"             , "В очереди / обработке";
+    player_showing:          "Showing"                         , "Показано";
+    player_status:           "Status"                          , "Статус";
+    player_file:             "File"                            , "Файл";
+    player_created:          "Created"                         , "Создано";
+    player_updated:          "Updated"                         , "Обновлено";
+    player_error:            "Error"                           , "Ошибка";
+    player_pending:          "Pending"                         , "Ожидает";
+    player_artist:           "Artist"                          , "Артист";
+    player_album:            "Album"                           , "Альбом";
+    player_album_artists:    "Album artists"                   , "Артисты альбома";
+    player_featured:         "Featured"                        , "При участии";
+    player_featured_short:   "feat."                           , "уч.";
+    player_track_number:     "Track #"                         , "Трек #";
+    player_disc_number:      "Disc #"                          , "Диск #";
+    player_genre:            "Genre"                           , "Жанр";
+    player_notes:            "Notes"                           , "Заметки";
+    player_type_unchanged:   "Type unchanged"                  , "Тип без изменений";
+    player_visibility_unchanged: "Visibility unchanged"         , "Видимость без изменений";
+    player_visible:          "Visible"                         , "Видимый";
+    player_hidden:           "Hidden"                          , "Скрыт";
+    player_no_year:          "no year"                         , "год неизвестен";
+    player_apply:            "Apply"                           , "Применить";
+    player_edit:             "Edit"                            , "Редактировать";
+    player_edit_release:     "Edit release"                    , "Редактировать релиз";
+    player_edit_track:       "Edit track"                      , "Редактировать трек";
+    player_edit_metadata:    "Edit metadata"                   , "Редактировать метаданные";
+    player_metadata:         "Metadata"                        , "Метаданные";
+    player_release_metadata: "Release metadata"                , "Метаданные релиза";
+    player_track_metadata:   "Track metadata"                  , "Метаданные трека";
+    player_approve_metadata: "Approve metadata"                , "Подтвердить метаданные";
+    player_delete_review:    "Delete review"                   , "Удалить проверку";
+    player_approve:          "Approve"                         , "Подтвердить";
+    player_save_track:       "Save track"                      , "Сохранить трек";
+    player_save_release:     "Save release"                    , "Сохранить релиз";
+    player_artists_placeholder: "Artist, Artist"               , "Артист, артист";
+    player_artist_featured_placeholder: "Artist, Featured Artist" , "Артист, приглашённый артист";
+    player_release_type_album: "Album"                         , "Альбом";
+    player_release_type_single: "Single"                       , "Сингл";
+    player_release_type_ep:  "EP"                              , "EP";
+    player_release_type_compilation: "Compilation"             , "Сборник";
+    player_release_type_mixtape: "Mixtape"                     , "Микстейп";
+    player_release_type_live: "Live"                           , "Концерт";
+    player_release_type_soundtrack: "Soundtrack"               , "Саундтрек";
+    player_release_type_remix: "Remix"                         , "Ремикс";
+    player_release_type_demo: "Demo"                           , "Демо";
+    player_failed_load_uploaded_tracks: "Failed to load uploaded tracks" , "Не удалось загрузить загруженные треки";
+    player_failed_save_track: "Failed to save track"           , "Не удалось сохранить трек";
+    player_track_metadata_saved: "Track metadata saved"         , "Метаданные трека сохранены";
+    player_failed_save_release: "Failed to save release"       , "Не удалось сохранить релиз";
+    player_release_metadata_saved: "Release metadata saved"     , "Метаданные релиза сохранены";
+    player_failed_delete_review: "Failed to delete review"     , "Не удалось удалить проверку";
+    player_review_deleted:   "Review deleted"                  , "Проверка удалена";
+    player_failed_approve_review: "Failed to approve review"   , "Не удалось подтвердить проверку";
+    player_track_approved_imported: "Track approved and imported" , "Трек подтверждён и импортирован";
+    player_failed_update_selected_tracks: "Failed to update selected tracks" , "Не удалось обновить выбранные треки";
+    player_selected_tracks_updated: "Selected tracks updated"   , "Выбранные треки обновлены";
+    player_choose_saved_or_add_torrent: "Choose a saved item or upload new files." , "Выберите сохранённый элемент или загрузите новые файлы.";
+    player_local_files:      "Local audio files"               , "Локальные аудиофайлы";
+    player_torrent_file:     "Torrent file"                    , "Torrent-файл";
+    player_magnet_link:      "Magnet link"                     , "Magnet-ссылка";
+    player_upload_content:   "Upload"                          , "Загрузить";
+    player_download_selected: "Download selected"              , "Скачать выбранное";
+    player_pause_download:   "Pause download"                  , "Поставить на паузу";
+    player_expand_all:       "Expand all"                      , "Развернуть всё";
+    player_collapse:         "Collapse"                        , "Свернуть";
+    player_selected:         "selected"                        , "выбрано";
+    player_preview:          "Preview"                         , "Предпросмотр";
+    player_resolving:        "Resolving metadata"              , "Получаю метаданные";
+    player_downloading:      "Downloading"                     , "Скачивается";
+    player_moving:           "Moving"                          , "Перемещается";
+    player_completed:        "Completed"                       , "Готово";
+    player_failed:           "Failed"                          , "Ошибка";
+    player_paused:           "Paused"                          , "Пауза";
+    player_no_torrent_selected: "No torrent selected"          , "Торрент не выбран";
+    player_downloaded:        "Downloaded"                     , "Загружено";
+    player_speed:             "Speed"                          , "Скорость";
+    player_down:             "down"                            , "вниз";
+    player_up:               "up"                              , "вверх";
+    player_peers:            "peers"                           , "пиры";
+    player_live:             "live"                            , "активных";
+    player_seen:             "seen"                            , "видели";
+    player_eta:              "eta"                             , "осталось";
+    player_loading_history:  "Loading history..."              , "Загрузка истории...";
+    player_failed_load_history: "Failed to load history"        , "Не удалось загрузить историю";
+    player_total_plays:      "total plays"                     , "прослушиваний всего";
+    player_play_history:     "Play history"                    , "История прослушиваний";
+    player_no_plays_yet:     "No plays yet"                    , "Прослушиваний пока нет";
+    player_page:             "Page"                            , "Страница";
+    player_of:               "of"                              , "из";
+    player_choose_torrent:   "Choose local files, paste a magnet link, or choose a .torrent file." , "Выберите локальные файлы, вставьте magnet-ссылку или выберите .torrent файл.";
+    player_uploading_files:  "Uploading files..."              , "Загружаю файлы...";
+    player_upload_complete:  "Upload complete. Files are queued for processing." , "Загрузка завершена. Файлы поставлены в обработку.";
+    player_upload_failed:    "Upload failed"                   , "Загрузка не удалась";
+    player_reading_torrent:  "Reading torrent file..."         , "Читаю torrent-файл...";
+    player_resolving_magnet: "Resolving magnet metadata. This can take a while..." , "Получаю метаданные magnet-ссылки. Это может занять время...";
+    player_preview_failed:   "Preview failed"                  , "Предпросмотр не удался";
+    player_all_files_selected: "All files are selected by default. Clear or adjust the tree before download." , "Все файлы выбраны по умолчанию. Перед скачиванием можно очистить или изменить выбор.";
+    player_opening_saved_torrent: "Opening saved torrent..."   , "Открываю сохранённый торрент...";
+    player_saved_torrent_opened: "Saved torrent opened. Adjust files or resume download." , "Сохранённый торрент открыт. Можно изменить файлы или продолжить скачивание.";
+    player_remove_torrent_confirm: "Remove this torrent from the client list? Downloaded files will stay on disk." , "Удалить этот торрент из списка клиента? Скачанные файлы останутся на диске.";
+    player_torrent_removed:  "Torrent removed from the client list." , "Торрент удалён из списка клиента.";
+    player_select_one_file:  "Select at least one file."       , "Выберите хотя бы один файл.";
+    player_starting_download: "Starting download..."           , "Запускаю скачивание...";
+    player_download_started: "Download started. Files will move to inbox when complete." , "Скачивание началось. После завершения файлы будут перенесены во входящие.";
+    player_pausing_download: "Pausing download..."             , "Ставлю скачивание на паузу...";
+    player_download_paused:  "Download paused. Start again when you are ready." , "Скачивание на паузе. Можно продолжить позже.";
+    player_status_failed:    "Status failed"                   , "Не удалось получить статус";
+    player_start_failed:     "Start failed"                    , "Не удалось запустить";
+    player_pause_failed:     "Pause failed"                    , "Не удалось поставить на паузу";
+    player_load_torrents_failed: "Could not load torrents"     , "Не удалось загрузить торренты";
+    player_open_torrent_failed: "Could not open torrent"       , "Не удалось открыть торрент";
+    player_delete_torrent_failed: "Could not delete torrent"   , "Не удалось удалить торрент";
+    player_load_ai_queue_failed: "Could not load AI queue"     , "Не удалось загрузить очередь ИИ";
 }

src/jobs/artist_image_backfill.rs

@@ -1,60 +0,0 @@
-use crate::scheduler::{Job, JobContext, JobLog};
-
-/// Periodic job that auto-assigns artist images from their release covers.
-///
-/// For every artist that has no `image_file_id`, picks the cover of the most
-/// recent release (by year) that has one. Runs after the cover backfill job
-/// so freshly-extracted covers are available.
-pub struct ArtistImageBackfillJob;
-
-#[async_trait::async_trait]
-impl Job for ArtistImageBackfillJob {
-    fn name(&self) -> &'static str {
-        "artist_image_backfill"
-    }
-
-    fn description(&self) -> &'static str {
-        "Auto-assign artist images from release covers"
-    }
-
-    fn default_cron(&self) -> &'static str {
-        // 03:15 daily — after cover_backfill at 03:00
-        "0 15 3 * * *"
-    }
-
-    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
-        let result = sqlx::query(
-            "UPDATE furumusic__artist a \
-             SET image_file_id = ( \
-                 SELECT r.cover_file_id \
-                 FROM furumusic__release_artist ra \
-                 JOIN furumusic__release r ON r.id = ra.release_id \
-                 WHERE ra.artist_id = a.id \
-                   AND r.cover_file_id IS NOT NULL \
-                 ORDER BY r.year DESC NULLS LAST \
-                 LIMIT 1 \
-             ), \
-             updated_at = $1 \
-             WHERE a.image_file_id IS NULL \
-               AND EXISTS ( \
-                   SELECT 1 FROM furumusic__release_artist ra2 \
-                   JOIN furumusic__release r2 ON r2.id = ra2.release_id \
-                   WHERE ra2.artist_id = a.id AND r2.cover_file_id IS NOT NULL \
-               )",
-        )
-        .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
-        .execute(&ctx.pool)
-        .await?;
-
-        let count = result.rows_affected();
-        if count > 0 {
-            log.info(&format!(
-                "Assigned images to {count} artists from release covers"
-            ));
-        } else {
-            log.info("All artists already have images (or no covers available)");
-        }
-
-        Ok(())
-    }
-}

src/jobs/artist_track_image_backfill.rs

@@ -1,69 +0,0 @@
-use crate::scheduler::{Job, JobContext, JobLog};
-
-/// Fallback job that assigns artist images from track cover art.
-///
-/// The primary `artist_image_backfill` job uses release covers.  This job
-/// runs afterwards and covers the case where the release itself has no
-/// cover but individual tracks do (e.g. when cover art is embedded in the
-/// audio file and extracted per-track rather than per-release).
-///
-/// For every artist that *still* has no `image_file_id` after the release-
-/// based backfill, picks the `cover_file_id` of the most recent track
-/// (by year, then track id) that has one.
-pub struct ArtistTrackImageBackfillJob;
-
-#[async_trait::async_trait]
-impl Job for ArtistTrackImageBackfillJob {
-    fn name(&self) -> &'static str {
-        "artist_track_image_backfill"
-    }
-
-    fn description(&self) -> &'static str {
-        "Auto-assign artist images from track covers (fallback)"
-    }
-
-    fn default_cron(&self) -> &'static str {
-        // 03:30 daily — after artist_image_backfill at 03:15
-        "0 30 3 * * *"
-    }
-
-    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
-        let result = sqlx::query(
-            "UPDATE furumusic__artist a \
-             SET image_file_id = ( \
-                 SELECT t.cover_file_id \
-                 FROM furumusic__track_artist ta \
-                 JOIN furumusic__track t ON t.id = ta.track_id \
-                 WHERE ta.artist_id = a.id \
-                   AND t.cover_file_id IS NOT NULL \
-                   AND t.is_hidden = false \
-                 ORDER BY t.year DESC NULLS LAST, t.id DESC \
-                 LIMIT 1 \
-             ), \
-             updated_at = $1 \
-             WHERE a.image_file_id IS NULL \
-               AND a.is_hidden = false \
-               AND EXISTS ( \
-                   SELECT 1 FROM furumusic__track_artist ta2 \
-                   JOIN furumusic__track t2 ON t2.id = ta2.track_id \
-                   WHERE ta2.artist_id = a.id \
-                     AND t2.cover_file_id IS NOT NULL \
-                     AND t2.is_hidden = false \
-               )",
-        )
-        .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
-        .execute(&ctx.pool)
-        .await?;
-
-        let count = result.rows_affected();
-        if count > 0 {
-            log.info(&format!(
-                "Assigned images to {count} artists from track covers"
-            ));
-        } else {
-            log.info("All artists already have images (or no track covers available)");
-        }
-
-        Ok(())
-    }
-}

src/jobs/cover_backfill.rs

@@ -1,167 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::agent::cover_art;
-use crate::scheduler::{Job, JobContext, JobLog};
-
-/// One-shot / periodic job that finds releases without cover art and attempts
-/// to extract or discover covers from their audio files in storage.
-pub struct CoverBackfillJob;
-
-#[async_trait::async_trait]
-impl Job for CoverBackfillJob {
-    fn name(&self) -> &'static str {
-        "cover_backfill"
-    }
-
-    fn description(&self) -> &'static str {
-        "Backfill cover art for releases missing covers"
-    }
-
-    fn default_cron(&self) -> &'static str {
-        // Once a day at 03:00
-        "0 0 3 * * *"
-    }
-
-    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
-        let storage_dir = &ctx.config.agent_storage_dir;
-        if storage_dir.is_empty() {
-            log.warn("agent_storage_dir is not configured, skipping cover backfill");
-            return Ok(());
-        }
-
-        // Find all releases without a cover
-        let rows: Vec<(i64, String)> = sqlx::query_as(
-            "SELECT r.id, r.title \
-             FROM furumusic__release r \
-             WHERE r.cover_file_id IS NULL \
-             ORDER BY r.id",
-        )
-        .fetch_all(&ctx.pool)
-        .await?;
-
-        if rows.is_empty() {
-            log.info("All releases already have cover art, nothing to backfill");
-            return Ok(());
-        }
-
-        log.info(&format!(
-            "Found {} releases without cover art, starting backfill...",
-            rows.len()
-        ));
-
-        let mut assigned = 0u32;
-        let mut failed = 0u32;
-        let mut skipped_no_audio = 0u32;
-        let mut skipped_no_cover = 0u32;
-        let total = rows.len();
-
-        for (i, (release_id, release_title)) in rows.iter().enumerate() {
-            log.info(&format!(
-                "[{}/{}] Processing release {release_id} \"{release_title}\"...",
-                i + 1,
-                total,
-            ));
-
-            // Find audio files belonging to this release via tracks → media_file
-            let audio_paths: Vec<(String,)> = sqlx::query_as(
-                "SELECT mf.file_path \
-                 FROM furumusic__track t \
-                 JOIN furumusic__media_file mf ON mf.id = t.audio_file_id \
-                 WHERE t.release_id = $1 AND mf.file_type = 'audio'",
-            )
-            .bind(release_id)
-            .fetch_all(&ctx.pool)
-            .await
-            .unwrap_or_default();
-
-            if audio_paths.is_empty() {
-                log.warn(&format!(
-                    "Release {release_id} \"{release_title}\": no audio files found, skipping"
-                ));
-                skipped_no_audio += 1;
-                continue;
-            }
-
-            // Determine the folder from the first audio file's path
-            let first_path = Path::new(&audio_paths[0].0);
-            let folder = first_path.parent().unwrap_or(Path::new("."));
-
-            // Collect all audio file paths as PathBuf
-            let audio_files: Vec<PathBuf> =
-                audio_paths.iter().map(|(p,)| PathBuf::from(p)).collect();
-
-            // Try to find cover art
-            let cover = match cover_art::find_best_cover(folder, &audio_files).await {
-                Some(c) => c,
-                None => {
-                    log.info(&format!(
-                        "Release {release_id} \"{release_title}\": no cover image found in {} audio files, skipping",
-                        audio_files.len(),
-                    ));
-                    skipped_no_cover += 1;
-                    continue;
-                }
-            };
-
-            let source_desc = match &cover.source {
-                cover_art::CoverSource::FolderFile(p) => format!("folder: {}", p.display()),
-                cover_art::CoverSource::Embedded(p) => format!("embedded: {}", p.display()),
-            };
-
-            // Look up artist name for storage path
-            let artist_name: String = sqlx::query_scalar(
-                "SELECT a.name FROM furumusic__artist a \
-                 JOIN furumusic__release_artist ra ON ra.artist_id = a.id \
-                 WHERE ra.release_id = $1 \
-                 ORDER BY ra.position LIMIT 1",
-            )
-            .bind(release_id)
-            .fetch_optional(&ctx.pool)
-            .await
-            .ok()
-            .flatten()
-            .unwrap_or_else(|| "Unknown Artist".to_string());
-
-            match cover_art::save_cover_to_storage(
-                &ctx.db,
-                &ctx.pool,
-                storage_dir,
-                &artist_name,
-                release_title,
-                &cover,
-            )
-            .await
-            {
-                Ok(cover_file_id) => {
-                    if let Err(e) =
-                        cover_art::assign_cover_to_release(&ctx.pool, *release_id, cover_file_id)
-                            .await
-                    {
-                        log.warn(&format!(
-                            "Release {release_id} \"{release_title}\": saved cover but failed to assign: {e}"
-                        ));
-                        failed += 1;
-                    } else {
-                        log.info(&format!(
-                            "Release {release_id} \"{release_title}\": assigned cover from {source_desc}"
-                        ));
-                        assigned += 1;
-                    }
-                }
-                Err(e) => {
-                    log.warn(&format!(
-                        "Release {release_id} \"{release_title}\": failed to save cover: {e}"
-                    ));
-                    failed += 1;
-                }
-            }
-        }
-
-        log.info(&format!(
-            "Cover backfill complete: {assigned} assigned, {failed} failed, \
-             {skipped_no_audio} skipped (no audio), {skipped_no_cover} skipped (no cover found)"
-        ));
-
-        Ok(())
-    }
-}

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;
 
@@ -75,7 +90,9 @@ impl Job for InboxDiscoverJob {
 
         for (_folder, files) in &groups {
             for file_path in files {
-                let input_path_str = file_path.to_string_lossy().to_string();
+                let input_path_str =
+                    crate::media_paths::path_for_root(&config.agent_inbox_dir, file_path)
+                        .unwrap_or_else(|| file_path.to_string_lossy().to_string());
 
                 // Skip if a PendingReview already exists for this path
                 match PendingReview::exists_for_path(&ctx.db, &input_path_str).await {
@@ -95,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)?;
@@ -105,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;
                         }
@@ -123,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()
@@ -187,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
@@ -217,6 +250,7 @@ impl Job for InboxDiscoverJob {
             }
         }
 
+        metrics_guard.outcome = run_outcome;
         Ok(())
     }
 }

src/jobs/inbox_process.rs

@@ -225,14 +225,13 @@ fn group_reviews_by_folder(
     reviews: &[PendingReview],
     inbox_dir: &str,
 ) -> Vec<(String, Vec<PendingReview>)> {
-    let inbox = Path::new(inbox_dir);
     let mut map: HashMap<String, Vec<PendingReview>> = HashMap::new();
 
     for r in reviews {
-        let path = Path::new(r.input_path_str());
-        let folder = path.parent().unwrap_or(path);
-        let rel = folder.strip_prefix(inbox).unwrap_or(folder);
-        let key = rel.to_string_lossy().to_string();
+        let path = crate::media_paths::resolve_path_from_root(inbox_dir, r.input_path_str());
+        let folder = path.parent().unwrap_or(path.as_path());
+        let key = crate::media_paths::path_for_root(inbox_dir, folder)
+            .unwrap_or_else(|| folder.to_string_lossy().to_string());
         map.entry(key).or_default().push(r.clone());
     }
 
@@ -287,8 +286,9 @@ async fn process_folder_batch(
     let mut failed_reviews: Vec<PendingReview> = Vec::new();
 
     for mut review in reviews {
-        let input_path_str = review.input_path_str().to_owned();
-        let file_path = Path::new(&input_path_str);
+        let stored_input_path = review.input_path_str().to_owned();
+        let file_path =
+            crate::media_paths::resolve_path_from_root(&config.agent_inbox_dir, &stored_input_path);
         let filename = file_path
             .file_name()
             .and_then(|n| n.to_str())
@@ -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;
@@ -336,7 +346,7 @@ async fn process_folder_batch(
             };
 
         // Parse path hints
-        let relative = file_path.strip_prefix(inbox_path).unwrap_or(file_path);
+        let relative = file_path.strip_prefix(inbox_path).unwrap_or(&file_path);
         let uploader = crate::jobs::uploader_from_relative_path(pool, relative).await;
         let hinted_relative = crate::jobs::strip_user_upload_prefix(relative);
         let hints = crate::agent::path_hints::parse(&hinted_relative);
@@ -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}\""))
+            }
         }
     }
 
@@ -471,8 +497,11 @@ async fn process_folder_batch(
 
     // Build folder context from the first file's folder
     let folder_ctx = {
-        let first_path = Path::new(prepared[0].review.input_path_str());
-        let folder = first_path.parent().unwrap_or(first_path);
+        let first_path = crate::media_paths::resolve_path_from_root(
+            &config.agent_inbox_dir,
+            prepared[0].review.input_path_str(),
+        );
+        let folder = first_path.parent().unwrap_or(first_path.as_path());
         let mut folder_files: Vec<String> = std::fs::read_dir(folder)
             .ok()
             .map(|rd| {
@@ -544,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;
@@ -609,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()
@@ -631,7 +664,11 @@ async fn process_folder_batch(
         p.review.result_json = Some(result_json);
         let _ = p.review.save(db).await;
 
-        let input_path_str = p.review.input_path_str().to_owned();
+        let input_path = crate::media_paths::resolve_path_from_root(
+            &config.agent_inbox_dir,
+            p.review.input_path_str(),
+        );
+        let input_path_str = input_path.to_string_lossy().to_string();
 
         if confidence >= config.agent_confidence_threshold {
             match finalize_approved(
@@ -648,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;
@@ -664,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,
@@ -675,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)
@@ -787,10 +830,10 @@ pub async fn finalize_approved(
         format!("{}.{}", sanitize_filename(track_title), ext)
     };
 
-    let storage_dir = Path::new(storage_dir_str);
+    let storage_dir = crate::media_paths::resolve_config_path_buf(storage_dir_str);
     let storage_path = if source_path.exists() {
         match mover::move_to_storage(
-            storage_dir,
+            &storage_dir,
             artist_name,
             release_title,
             &dest_filename,
@@ -798,16 +841,29 @@ pub async fn finalize_approved(
         )
         .await?
         {
-            mover::MoveOutcome::Moved(p) => p.to_string_lossy().to_string(),
-            mover::MoveOutcome::Merged(p) => p.to_string_lossy().to_string(),
+            mover::MoveOutcome::Moved(p) | mover::MoveOutcome::Merged(p) => {
+                crate::media_paths::media_file_path_for_storage(storage_dir_str, &p).ok_or_else(
+                    || {
+                        anyhow::anyhow!(
+                            "storage destination is outside agent_storage_dir: {}",
+                            p.display()
+                        )
+                    },
+                )?
+            }
         }
     } else {
-        storage_dir
+        let expected_path = storage_dir
             .join(sanitize_filename(artist_name))
             .join(sanitize_filename(release_title))
-            .join(&dest_filename)
-            .to_string_lossy()
-            .to_string()
+            .join(&dest_filename);
+        crate::media_paths::media_file_path_for_storage(storage_dir_str, &expected_path)
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "storage destination is outside agent_storage_dir: {}",
+                    expected_path.display()
+                )
+            })?
     };
 
     let media_file = MediaFile::create(
@@ -858,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("."));
@@ -887,6 +963,9 @@ pub async fn finalize_approved(
                     crate::agent::cover_art::CoverSource::Embedded(p) => {
                         format!("embedded in: {}", p.display())
                     }
+                    crate::agent::cover_art::CoverSource::Remote(url) => {
+                        format!("remote: {url}")
+                    }
                 };
                 match crate::agent::cover_art::save_cover_to_storage(
                     db,

src/jobs/lastfm_popularity.rs

@@ -0,0 +1,249 @@
+use serde::Deserialize;
+
+use crate::scheduler::{Job, JobContext, JobLog};
+
+pub struct LastfmPopularityJob;
+
+const LASTFM_REQUEST_DELAY: std::time::Duration = std::time::Duration::from_millis(1200);
+
+#[derive(Debug, sqlx::FromRow)]
+struct TrackLookupRow {
+    id: i64,
+    title: String,
+    artist_name: Option<String>,
+    lastfm_updated_at: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTrackInfoResponse {
+    track: Option<LastfmTrack>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTrack {
+    listeners: Option<String>,
+    playcount: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl Job for LastfmPopularityJob {
+    fn name(&self) -> &'static str {
+        "lastfm_popularity"
+    }
+
+    fn description(&self) -> &'static str {
+        "Update Last.fm playcount/listener popularity for library tracks"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Sundays at 04:15
+        "0 15 4 * * Sun"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        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 popularity update");
+            return Ok(());
+        }
+
+        let tracks = sqlx::query_as::<_, TrackLookupRow>(
+            r#"SELECT t.id,
+                      t.title::text AS title,
+                      t.lastfm_updated_at::text AS lastfm_updated_at,
+                      (
+                        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.lastfm_updated_at IS NOT NULL, t.lastfm_updated_at ASC, t.id ASC"#,
+        )
+        .fetch_all(&ctx.pool)
+        .await?;
+
+        if tracks.is_empty() {
+            log.info("No visible tracks found for Last.fm popularity update");
+            return Ok(());
+        }
+
+        log.info(&format!(
+            "Starting Last.fm popularity update for {} visible tracks; oldest or missing ratings are processed first; request delay is {} ms; rating formula is ln(playcount + 1) * ln(listeners + 1)",
+            tracks.len(),
+            LASTFM_REQUEST_DELAY.as_millis()
+        ));
+
+        let client = reqwest::Client::builder()
+            .user_agent("furumusic-lastfm-popularity/0.1")
+            .timeout(std::time::Duration::from_secs(15))
+            .build()?;
+        let mut updated = 0u64;
+        let mut skipped = 0u64;
+        let mut failed = 0u64;
+
+        for (index, track) in tracks.iter().enumerate() {
+            let Some(artist) = track
+                .artist_name
+                .as_deref()
+                .map(str::trim)
+                .filter(|v| !v.is_empty())
+            else {
+                skipped += 1;
+                log.warn(&format!(
+                    "Skipping track {} \"{}\": no primary artist",
+                    track.id, track.title
+                ));
+                continue;
+            };
+
+            log.info(&format!(
+                "Last.fm lookup {}/{}: track {} \"{}\" by \"{}\" (previous update: {})",
+                index + 1,
+                tracks.len(),
+                track.id,
+                track.title,
+                artist,
+                track.lastfm_updated_at.as_deref().unwrap_or("never")
+            ));
+            let result = fetch_track_info(&client, api_key, artist, &track.title).await;
+            match result {
+                Ok(Some((listeners, playcount))) => {
+                    let rating = popularity_rating(listeners, playcount);
+                    let fetched_at = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+                    sqlx::query(
+                        r#"UPDATE furumusic__track
+                              SET lastfm_listeners = $2,
+                                  lastfm_playcount = $3,
+                                  lastfm_rating = $4,
+                                  lastfm_updated_at = $5
+                            WHERE id = $1"#,
+                    )
+                    .bind(track.id)
+                    .bind(listeners)
+                    .bind(playcount)
+                    .bind(rating)
+                    .bind(&fetched_at)
+                    .execute(&ctx.pool)
+                    .await?;
+                    sqlx::query(
+                        r#"INSERT INTO furumusic__track_popularity_history
+                              (track_id, source, listeners, playcount, rating, fetched_at)
+                           VALUES ($1, 'lastfm', $2, $3, $4, $5)"#,
+                    )
+                    .bind(track.id)
+                    .bind(listeners)
+                    .bind(playcount)
+                    .bind(rating)
+                    .bind(&fetched_at)
+                    .execute(&ctx.pool)
+                    .await?;
+                    updated += 1;
+                    log.info(&format!(
+                        "Updated track {} \"{}\" by \"{}\": listeners={listeners}, playcount={playcount}, rating={rating:.4}",
+                        track.id, track.title, artist
+                    ));
+                }
+                Ok(None) => {
+                    skipped += 1;
+                    log.warn(&format!(
+                        "Last.fm has no usable match for track {} \"{}\" by \"{}\"",
+                        track.id, track.title, artist
+                    ));
+                }
+                Err(err) if err.to_string().contains("Last.fm rate limit exceeded") => {
+                    failed += 1;
+                    log.error("Last.fm rate limit exceeded; stopping this run early");
+                    break;
+                }
+                Err(err) => {
+                    failed += 1;
+                    log.warn(&format!(
+                        "Last.fm lookup failed for track {} \"{}\" / \"{}\": {err}",
+                        track.id, artist, track.title
+                    ));
+                }
+            }
+
+            if (index + 1) % 50 == 0 {
+                log.info(&format!(
+                    "Last.fm progress: {}/{} tracks, {updated} updated, {skipped} skipped, {failed} failed",
+                    index + 1,
+                    tracks.len()
+                ));
+            }
+            tokio::time::sleep(LASTFM_REQUEST_DELAY).await;
+        }
+
+        log.info(&format!(
+            "Last.fm popularity update finished: {updated} updated, {skipped} skipped, {failed} failed, {} considered",
+            tracks.len()
+        ));
+        Ok(())
+    }
+}
+
+async fn fetch_track_info(
+    client: &reqwest::Client,
+    api_key: &str,
+    artist: &str,
+    track: &str,
+) -> anyhow::Result<Option<(i64, i64)>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(&[
+            ("method", "track.getInfo"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("track", track),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ])
+        .send()
+        .await?;
+
+    if response.status() == reqwest::StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+    let response = response.error_for_status()?;
+    let body: LastfmTrackInfoResponse = response.json().await?;
+    if let Some(code) = body.error {
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        if code == 6 || code == 7 {
+            return Ok(None);
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            body.message.unwrap_or_else(|| "unknown error".to_string())
+        );
+    }
+    let Some(info) = body.track else {
+        return Ok(None);
+    };
+    let listeners = info
+        .listeners
+        .as_deref()
+        .unwrap_or("0")
+        .parse::<i64>()
+        .unwrap_or(0);
+    let playcount = info
+        .playcount
+        .as_deref()
+        .unwrap_or("0")
+        .parse::<i64>()
+        .unwrap_or(0);
+    Ok(Some((listeners.max(0), playcount.max(0))))
+}
+
+fn popularity_rating(listeners: i64, playcount: i64) -> f64 {
+    let listeners = listeners.max(0) as f64;
+    let playcount = playcount.max(0) as f64;
+    playcount.ln_1p() * listeners.ln_1p()
+}

src/jobs/lastfm_scrobble.rs

@@ -0,0 +1,34 @@
+use crate::lastfm;
+use crate::scheduler::{Job, JobContext, JobLog};
+
+pub struct LastfmScrobbleJob;
+
+#[async_trait::async_trait]
+impl Job for LastfmScrobbleJob {
+    fn name(&self) -> &'static str {
+        "lastfm_scrobble"
+    }
+
+    fn description(&self) -> &'static str {
+        "Send queued Last.fm scrobbles for connected users"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Every minute.
+        "0 * * * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        if !lastfm::is_configured(&ctx.config) {
+            log.warn("Last.fm API key/shared secret are not configured; skipping scrobble outbox");
+            return Ok(());
+        }
+
+        let summary = lastfm::process_pending_scrobbles(&ctx.pool, &ctx.config, None, 50).await?;
+        log.info(&format!(
+            "Last.fm scrobble outbox processed: considered={}, sent={}, failed={}, blocked={}, skipped={}",
+            summary.considered, summary.sent, summary.failed, summary.blocked, summary.skipped
+        ));
+        Ok(())
+    }
+}

src/jobs/mod.rs

@@ -1,8 +1,8 @@
-pub mod artist_image_backfill;
-pub mod artist_track_image_backfill;
-pub mod cover_backfill;
+pub mod artwork_backfill;
 pub mod inbox_discover;
 pub mod inbox_process;
+pub mod lastfm_popularity;
+pub mod lastfm_scrobble;
 pub mod metadata_backfill;
 
 use std::path::{Component, Path, PathBuf};

src/lastfm.rs

@@ -0,0 +1,619 @@
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+use anyhow::Context;
+use md5::{Digest, Md5};
+use reqwest::Client;
+use serde::Deserialize;
+use sqlx::PgPool;
+
+use crate::config::AppConfig;
+
+const LASTFM_API_URL: &str = "https://ws.audioscrobbler.com/2.0/";
+const MAX_BATCH_SIZE: i64 = 50;
+const MAX_ATTEMPTS: i32 = 8;
+
+#[derive(Debug, Clone)]
+pub struct LastfmCredentials {
+    api_key: String,
+    shared_secret: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmSession {
+    pub username: String,
+    pub session_key: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmTrackPayload {
+    pub artist: String,
+    pub track: String,
+    pub album: Option<String>,
+    pub album_artist: Option<String>,
+    pub track_number: Option<i32>,
+    pub duration_seconds: Option<i32>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmScrobblePayload {
+    pub track: LastfmTrackPayload,
+    pub timestamp: i64,
+}
+
+#[derive(Debug)]
+pub struct LastfmApiError {
+    pub code: Option<i32>,
+    pub message: String,
+}
+
+impl std::fmt::Display for LastfmApiError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.code {
+            Some(code) => write!(f, "Last.fm API error {code}: {}", self.message),
+            None => write!(f, "Last.fm API error: {}", self.message),
+        }
+    }
+}
+
+impl std::error::Error for LastfmApiError {}
+
+impl LastfmApiError {
+    fn new(code: Option<i32>, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+
+    pub fn is_invalid_session(&self) -> bool {
+        self.code == Some(9)
+    }
+
+    pub fn is_retryable(&self) -> bool {
+        matches!(self.code, Some(11 | 16 | 29) | None)
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ScrobbleProcessSummary {
+    pub considered: u64,
+    pub sent: u64,
+    pub failed: u64,
+    pub blocked: u64,
+    pub skipped: u64,
+}
+
+pub fn is_configured(config: &AppConfig) -> bool {
+    !config.lastfm_api_key.trim().is_empty() && !config.lastfm_shared_secret.trim().is_empty()
+}
+
+impl LastfmCredentials {
+    pub fn from_config(config: &AppConfig) -> Option<Self> {
+        let api_key = config.lastfm_api_key.trim();
+        let shared_secret = config.lastfm_shared_secret.trim();
+        if api_key.is_empty() || shared_secret.is_empty() {
+            return None;
+        }
+        Some(Self {
+            api_key: api_key.to_owned(),
+            shared_secret: shared_secret.to_owned(),
+        })
+    }
+
+    pub fn api_key(&self) -> &str {
+        &self.api_key
+    }
+}
+
+pub struct LastfmClient {
+    client: Client,
+    credentials: LastfmCredentials,
+}
+
+impl LastfmClient {
+    pub fn new(credentials: LastfmCredentials) -> anyhow::Result<Self> {
+        let client = Client::builder()
+            .user_agent(format!(
+                "furumusic-lastfm-scrobbler/{}",
+                env!("CARGO_PKG_VERSION")
+            ))
+            .timeout(Duration::from_secs(15))
+            .build()
+            .context("failed to build Last.fm HTTP client")?;
+        Ok(Self {
+            client,
+            credentials,
+        })
+    }
+
+    pub async fn get_session(&self, token: &str) -> Result<LastfmSession, LastfmApiError> {
+        let params = self.signed_params(
+            "auth.getSession",
+            None,
+            vec![("token".to_string(), token.to_string())],
+        );
+        let body = self.post(params).await?;
+        let response: AuthSessionResponse = serde_json::from_str(&body)
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        if let Some(code) = response.error {
+            return Err(LastfmApiError::new(
+                Some(code),
+                response
+                    .message
+                    .unwrap_or_else(|| "authentication failed".to_string()),
+            ));
+        }
+        let Some(session) = response.session else {
+            return Err(LastfmApiError::new(
+                None,
+                "Last.fm auth response did not include a session",
+            ));
+        };
+        Ok(LastfmSession {
+            username: session.name,
+            session_key: session.key,
+        })
+    }
+
+    pub async fn update_now_playing(
+        &self,
+        session_key: &str,
+        track: &LastfmTrackPayload,
+    ) -> Result<(), LastfmApiError> {
+        let mut extra = vec![
+            ("artist".to_string(), track.artist.clone()),
+            ("track".to_string(), track.track.clone()),
+        ];
+        push_optional(&mut extra, "album", track.album.as_deref());
+        push_optional(&mut extra, "albumArtist", track.album_artist.as_deref());
+        push_optional_i32(&mut extra, "trackNumber", track.track_number);
+        push_optional_i32(&mut extra, "duration", track.duration_seconds);
+
+        let params = self.signed_params("track.updateNowPlaying", Some(session_key), extra);
+        let body = self.post(params).await?;
+        check_lastfm_error(&body)
+    }
+
+    pub async fn scrobble_batch(
+        &self,
+        session_key: &str,
+        scrobbles: &[LastfmScrobblePayload],
+    ) -> Result<(), LastfmApiError> {
+        let mut extra = Vec::new();
+        for (index, scrobble) in scrobbles.iter().take(MAX_BATCH_SIZE as usize).enumerate() {
+            let suffix = format!("[{index}]");
+            extra.push((format!("artist{suffix}"), scrobble.track.artist.clone()));
+            extra.push((format!("track{suffix}"), scrobble.track.track.clone()));
+            extra.push((format!("timestamp{suffix}"), scrobble.timestamp.to_string()));
+            push_optional(
+                &mut extra,
+                &format!("album{suffix}"),
+                scrobble.track.album.as_deref(),
+            );
+            push_optional(
+                &mut extra,
+                &format!("albumArtist{suffix}"),
+                scrobble.track.album_artist.as_deref(),
+            );
+            push_optional_i32(
+                &mut extra,
+                &format!("trackNumber{suffix}"),
+                scrobble.track.track_number,
+            );
+            push_optional_i32(
+                &mut extra,
+                &format!("duration{suffix}"),
+                scrobble.track.duration_seconds,
+            );
+        }
+
+        let params = self.signed_params("track.scrobble", Some(session_key), extra);
+        let body = self.post(params).await?;
+        check_lastfm_error(&body)
+    }
+
+    fn signed_params(
+        &self,
+        method: &str,
+        session_key: Option<&str>,
+        extra: Vec<(String, String)>,
+    ) -> Vec<(String, String)> {
+        let mut params = BTreeMap::new();
+        params.insert("api_key".to_string(), self.credentials.api_key.clone());
+        params.insert("method".to_string(), method.to_string());
+        if let Some(session_key) = session_key {
+            params.insert("sk".to_string(), session_key.to_string());
+        }
+        for (key, value) in extra {
+            params.insert(key, value);
+        }
+
+        let mut signature_input = String::new();
+        for (key, value) in &params {
+            signature_input.push_str(key);
+            signature_input.push_str(value);
+        }
+        signature_input.push_str(&self.credentials.shared_secret);
+        let digest = Md5::digest(signature_input.as_bytes());
+        let api_sig = format!("{digest:x}");
+
+        let mut out = params.into_iter().collect::<Vec<_>>();
+        out.push(("api_sig".to_string(), api_sig));
+        out.push(("format".to_string(), "json".to_string()));
+        out
+    }
+
+    async fn post(&self, params: Vec<(String, String)>) -> Result<String, LastfmApiError> {
+        let response = self
+            .client
+            .post(LASTFM_API_URL)
+            .form(&params)
+            .send()
+            .await
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        let status = response.status();
+        let body = response
+            .text()
+            .await
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        if !status.is_success() {
+            if let Some(err) = parse_error(&body) {
+                return Err(err);
+            }
+            return Err(LastfmApiError::new(None, format!("HTTP {status}: {body}")));
+        }
+        Ok(body)
+    }
+}
+
+pub async fn process_pending_scrobbles(
+    pool: &PgPool,
+    config: &AppConfig,
+    user_id: Option<i64>,
+    limit_per_user: i64,
+) -> anyhow::Result<ScrobbleProcessSummary> {
+    let Some(credentials) = LastfmCredentials::from_config(config) else {
+        return Ok(ScrobbleProcessSummary::default());
+    };
+    let client = LastfmClient::new(credentials)?;
+    let user_ids = pending_user_ids(pool, user_id).await?;
+    let mut summary = ScrobbleProcessSummary::default();
+
+    for uid in user_ids {
+        let rows = fetch_pending_scrobbles(pool, uid, limit_per_user.min(MAX_BATCH_SIZE)).await?;
+        if rows.is_empty() {
+            continue;
+        }
+        summary.considered += rows.len() as u64;
+
+        let mut ids = Vec::new();
+        let mut attempt_rows = Vec::new();
+        let mut payloads = Vec::new();
+        for row in &rows {
+            match row.payload() {
+                Some(payload) => {
+                    ids.push(row.id);
+                    attempt_rows.push((row.id, row.attempt_count));
+                    payloads.push(payload);
+                }
+                None => {
+                    mark_row_failed(pool, row.id, "track has no primary Last.fm artist").await?;
+                    summary.skipped += 1;
+                }
+            }
+        }
+        if ids.is_empty() {
+            continue;
+        }
+
+        match client.scrobble_batch(&rows[0].session_key, &payloads).await {
+            Ok(()) => {
+                mark_rows_sent(pool, &ids).await?;
+                clear_account_error(pool, uid).await?;
+                summary.sent += ids.len() as u64;
+            }
+            Err(err) if err.is_invalid_session() => {
+                mark_account_reauth_required(pool, uid, &err.to_string()).await?;
+                mark_rows_blocked(pool, &ids, &err.to_string()).await?;
+                summary.blocked += ids.len() as u64;
+            }
+            Err(err) => {
+                mark_rows_retry_or_failed(pool, &attempt_rows, &err).await?;
+                summary.failed += ids.len() as u64;
+                if err.code == Some(29) {
+                    break;
+                }
+            }
+        }
+    }
+
+    Ok(summary)
+}
+
+#[derive(Debug, Deserialize)]
+struct AuthSessionResponse {
+    session: Option<AuthSession>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AuthSession {
+    name: String,
+    key: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ErrorEnvelope {
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct PendingScrobbleRow {
+    id: i64,
+    started_at: i64,
+    duration_seconds: i32,
+    attempt_count: i32,
+    session_key: String,
+    title: String,
+    artist_name: Option<String>,
+    album_title: Option<String>,
+    album_artist_name: Option<String>,
+    track_number: Option<i32>,
+}
+
+impl PendingScrobbleRow {
+    fn payload(&self) -> Option<LastfmScrobblePayload> {
+        let artist = self
+            .artist_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())?
+            .to_string();
+        Some(LastfmScrobblePayload {
+            track: LastfmTrackPayload {
+                artist,
+                track: self.title.clone(),
+                album: non_empty(self.album_title.as_deref()),
+                album_artist: non_empty(self.album_artist_name.as_deref()),
+                track_number: self.track_number,
+                duration_seconds: Some(self.duration_seconds),
+            },
+            timestamp: self.started_at,
+        })
+    }
+}
+
+fn non_empty(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
+fn push_optional(params: &mut Vec<(String, String)>, key: &str, value: Option<&str>) {
+    if let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) {
+        params.push((key.to_string(), value.to_string()));
+    }
+}
+
+fn push_optional_i32(params: &mut Vec<(String, String)>, key: &str, value: Option<i32>) {
+    if let Some(value) = value {
+        params.push((key.to_string(), value.to_string()));
+    }
+}
+
+fn check_lastfm_error(body: &str) -> Result<(), LastfmApiError> {
+    if let Some(err) = parse_error(body) {
+        return Err(err);
+    }
+    Ok(())
+}
+
+fn parse_error(body: &str) -> Option<LastfmApiError> {
+    let envelope: ErrorEnvelope = serde_json::from_str(body).ok()?;
+    envelope
+        .error
+        .map(|code| LastfmApiError::new(Some(code), envelope.message.unwrap_or_default()))
+}
+
+async fn pending_user_ids(pool: &PgPool, user_id: Option<i64>) -> anyhow::Result<Vec<i64>> {
+    if let Some(user_id) = user_id {
+        return Ok(vec![user_id]);
+    }
+    let rows = sqlx::query_scalar::<_, i64>(
+        r#"SELECT DISTINCT o.user_id
+             FROM furumusic__lastfm_scrobble_outbox o
+             JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
+            WHERE o.status IN ('pending', 'retry')
+              AND a.reauth_required = false
+            ORDER BY o.user_id"#,
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows)
+}
+
+async fn fetch_pending_scrobbles(
+    pool: &PgPool,
+    user_id: i64,
+    limit: i64,
+) -> anyhow::Result<Vec<PendingScrobbleRow>> {
+    let rows = sqlx::query_as::<_, PendingScrobbleRow>(
+        r#"SELECT o.id,
+                  o.started_at,
+                  o.duration_seconds,
+                  o.attempt_count,
+                  a.session_key::text AS session_key,
+                  t.title::text AS title,
+                  r.title::text AS album_title,
+                  t.track_number,
+                  (
+                    SELECT ar.name::text
+                      FROM furumusic__track_artist ta
+                      JOIN furumusic__artist ar ON ar.id = ta.artist_id
+                     WHERE ta.track_id = t.id AND ta.role <> 'featuring'
+                     ORDER BY ta.position
+                     LIMIT 1
+                  ) AS artist_name,
+                  (
+                    SELECT ar.name::text
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__artist ar ON ar.id = ra.artist_id
+                     WHERE ra.release_id = r.id
+                     ORDER BY ra.position
+                     LIMIT 1
+                  ) AS album_artist_name
+             FROM furumusic__lastfm_scrobble_outbox o
+             JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
+             JOIN furumusic__track t ON t.id = o.track_id
+             LEFT JOIN furumusic__release r ON r.id = t.release_id
+            WHERE o.user_id = $1
+              AND o.status IN ('pending', 'retry')
+              AND a.reauth_required = false
+            ORDER BY o.created_at, o.id
+            LIMIT $2"#,
+    )
+    .bind(user_id)
+    .bind(limit)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows)
+}
+
+async fn clear_account_error(pool: &PgPool, user_id: i64) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_account
+              SET last_error = NULL,
+                  reauth_required = false,
+                  updated_at = $2
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_account_reauth_required(
+    pool: &PgPool,
+    user_id: i64,
+    error: &str,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_account
+              SET reauth_required = true,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_sent(pool: &PgPool, ids: &[i64]) -> anyhow::Result<()> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+    let now = now_iso();
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'sent',
+                  updated_at = $2,
+                  scrobbled_at = $2,
+                  last_error = NULL
+            WHERE id = ANY($1)"#,
+    )
+    .bind(ids)
+    .bind(now)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_row_failed(pool: &PgPool, id: i64, error: &str) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'failed',
+                  attempt_count = attempt_count + 1,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE id = $1"#,
+    )
+    .bind(id)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_blocked(pool: &PgPool, ids: &[i64], error: &str) -> anyhow::Result<()> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'blocked',
+                  attempt_count = attempt_count + 1,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE id = ANY($1)"#,
+    )
+    .bind(ids)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_retry_or_failed(
+    pool: &PgPool,
+    rows: &[(i64, i32)],
+    error: &LastfmApiError,
+) -> anyhow::Result<()> {
+    if rows.is_empty() {
+        return Ok(());
+    }
+    let ids: Vec<i64> = rows.iter().map(|(id, _)| *id).collect();
+    let next_status = if error.is_retryable()
+        && rows
+            .iter()
+            .any(|(_, attempt_count)| attempt_count + 1 < MAX_ATTEMPTS)
+    {
+        "retry"
+    } else {
+        "failed"
+    };
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = CASE
+                    WHEN attempt_count + 1 >= $2 THEN 'failed'
+                    ELSE $3
+                  END,
+                  attempt_count = attempt_count + 1,
+                  last_error = $4,
+                  updated_at = $5
+            WHERE id = ANY($1)"#,
+    )
+    .bind(&ids)
+    .bind(MAX_ATTEMPTS)
+    .bind(next_status)
+    .bind(error.to_string())
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+fn now_iso() -> String {
+    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
+}

src/main.rs

@@ -5,6 +5,9 @@ mod auth;
 mod config;
 mod i18n;
 mod jobs;
+mod lastfm;
+mod media_paths;
+mod metrics;
 mod music;
 mod oidc;
 mod player;
@@ -49,10 +52,10 @@ fn build_registry() -> Arc<JobRegistry> {
     registry.register(jobs::inbox_discover::InboxDiscoverJob);
     registry.register(jobs::inbox_process::InboxProcessJob);
     registry.register(jobs::inbox_process::FileProcessJob);
-    registry.register(jobs::cover_backfill::CoverBackfillJob);
-    registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
-    registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
+    registry.register(jobs::artwork_backfill::ArtworkBackfillJob);
     registry.register(jobs::metadata_backfill::MetadataBackfillJob);
+    registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
+    registry.register(jobs::lastfm_scrobble::LastfmScrobbleJob);
     Arc::new(registry)
 }
 
@@ -137,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 {
@@ -169,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({
@@ -198,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?
@@ -214,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 => {}
@@ -221,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?
@@ -330,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()
@@ -359,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/media_paths.rs

@@ -0,0 +1,256 @@
+use std::path::{Component, Path, PathBuf};
+
+pub fn resolve_config_path(value: &str) -> String {
+    let path = resolve_config_path_buf(value);
+    if path.as_os_str().is_empty() {
+        String::new()
+    } else {
+        path.to_string_lossy().to_string()
+    }
+}
+
+pub fn resolve_config_path_buf(value: &str) -> PathBuf {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return PathBuf::new();
+    }
+
+    let normalized = normalize_slashes(trimmed);
+    if is_absolute_path(&normalized) {
+        PathBuf::from(normalized)
+    } else {
+        app_root().join(slash_path(&normalized))
+    }
+}
+
+pub fn resolve_media_file_path(storage_dir: &str, file_path: &str) -> PathBuf {
+    resolve_path_from_root(storage_dir, file_path)
+}
+
+pub fn media_file_path_for_storage(storage_dir: &str, path: &Path) -> Option<String> {
+    path_for_root(storage_dir, path)
+}
+
+pub fn resolve_path_from_root(root_dir: &str, stored_path: &str) -> PathBuf {
+    let normalized = normalize_slashes(stored_path.trim());
+    if is_absolute_path(&normalized) {
+        PathBuf::from(normalized)
+    } else {
+        resolve_config_path_buf(root_dir).join(slash_path(&normalized))
+    }
+}
+
+pub fn path_for_root(root_dir: &str, path: &Path) -> Option<String> {
+    let root = resolve_config_path_buf(root_dir);
+    let normalized = normalize_slashes(&path.to_string_lossy());
+    if is_absolute_path(&normalized) {
+        return strip_root_prefix(&root, &normalized);
+    }
+
+    relative_path_string(path)
+}
+
+pub async fn normalize_media_file_paths(
+    pool: &sqlx::PgPool,
+    storage_dir: &str,
+) -> anyhow::Result<u64> {
+    normalize_table_paths(pool, "furumusic__media_file", "file_path", storage_dir).await
+}
+
+pub async fn normalize_pending_review_paths(
+    pool: &sqlx::PgPool,
+    inbox_dir: &str,
+) -> anyhow::Result<u64> {
+    normalize_table_paths(pool, "furumusic__pending_review", "input_path", inbox_dir).await
+}
+
+async fn normalize_table_paths(
+    pool: &sqlx::PgPool,
+    table: &str,
+    column: &str,
+    root_dir: &str,
+) -> anyhow::Result<u64> {
+    let sql = format!("SELECT id, {column} FROM {table} WHERE {column} IS NOT NULL ORDER BY id");
+    let rows: Vec<(i64, String)> = sqlx::query_as(&sql).fetch_all(pool).await?;
+
+    let mut updated = 0;
+    for (id, stored_path) in rows {
+        let Some(normalized) = normalize_stored_path(root_dir, &stored_path) else {
+            continue;
+        };
+        if normalized == stored_path {
+            continue;
+        }
+
+        let sql = format!("UPDATE {table} SET {column} = $1 WHERE id = $2");
+        sqlx::query(&sql)
+            .bind(&normalized)
+            .bind(id)
+            .execute(pool)
+            .await?;
+        updated += 1;
+    }
+
+    Ok(updated)
+}
+
+fn normalize_stored_path(root_dir: &str, stored_path: &str) -> Option<String> {
+    let normalized = normalize_slashes(stored_path);
+    if normalized.is_empty() {
+        return None;
+    }
+
+    if is_absolute_path(&normalized) {
+        strip_root_prefix(&resolve_config_path_buf(root_dir), &normalized)
+    } else {
+        normalize_relative_path(&normalized)
+    }
+}
+
+fn app_root() -> PathBuf {
+    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}
+
+fn normalize_slashes(value: &str) -> String {
+    value.trim().replace('\\', "/")
+}
+
+fn is_absolute_path(value: &str) -> bool {
+    value.starts_with('/') || Path::new(value).is_absolute() || looks_like_windows_absolute(value)
+}
+
+fn looks_like_windows_absolute(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    bytes.len() >= 3 && bytes[1] == b':' && bytes[2] == b'/' && bytes[0].is_ascii_alphabetic()
+}
+
+fn slash_path(value: &str) -> PathBuf {
+    value
+        .split('/')
+        .filter(|part| !part.is_empty() && *part != ".")
+        .fold(PathBuf::new(), |mut path, part| {
+            path.push(part);
+            path
+        })
+}
+
+fn normalize_relative_path(value: &str) -> Option<String> {
+    let parts: Vec<&str> = value
+        .split('/')
+        .filter(|part| !part.is_empty() && *part != ".")
+        .collect();
+    if parts.is_empty() || parts.iter().any(|part| *part == "..") {
+        return None;
+    }
+    Some(parts.join("/"))
+}
+
+fn strip_root_prefix(root: &Path, normalized_path: &str) -> Option<String> {
+    let root_string = normalize_slashes(&root.to_string_lossy());
+    let root_trimmed = root_string.trim_end_matches('/');
+    let path_trimmed = normalized_path.trim();
+
+    let root_cmp = comparable_path(root_trimmed);
+    let path_cmp = comparable_path(path_trimmed);
+    if path_cmp == root_cmp {
+        return None;
+    }
+
+    let prefix = format!("{root_cmp}/");
+    if path_cmp.starts_with(&prefix) {
+        let tail = &path_trimmed[root_trimmed.len() + 1..];
+        return normalize_relative_path(tail);
+    }
+
+    None
+}
+
+fn comparable_path(value: &str) -> String {
+    let normalized = normalize_slashes(value).trim_end_matches('/').to_owned();
+    if cfg!(windows) || looks_like_windows_absolute(&normalized) {
+        normalized.to_ascii_lowercase()
+    } else {
+        normalized
+    }
+}
+
+fn relative_path_string(path: &Path) -> Option<String> {
+    let mut parts = Vec::new();
+    for component in path.components() {
+        match component {
+            Component::Normal(value) => parts.push(value.to_string_lossy().to_string()),
+            Component::CurDir => {}
+            _ => return None,
+        }
+    }
+    if parts.is_empty() {
+        None
+    } else {
+        Some(parts.join("/"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolves_relative_config_path_from_app_root() {
+        let expected = app_root().join("media").join("library");
+        assert_eq!(resolve_config_path_buf("media/library"), expected);
+    }
+
+    #[test]
+    fn keeps_absolute_config_path() {
+        assert_eq!(resolve_config_path_buf("/media"), PathBuf::from("/media"));
+    }
+
+    #[test]
+    fn resolves_relative_media_file_under_storage_root() {
+        assert_eq!(
+            resolve_media_file_path("/media", "Buckethead/Pike/cover.jpg"),
+            PathBuf::from("/media")
+                .join("Buckethead")
+                .join("Pike")
+                .join("cover.jpg")
+        );
+    }
+
+    #[test]
+    fn keeps_absolute_media_file_path() {
+        assert_eq!(
+            resolve_media_file_path("/media", "/media/Buckethead/Pike/cover.jpg"),
+            PathBuf::from("/media/Buckethead/Pike/cover.jpg")
+        );
+    }
+
+    #[test]
+    fn stores_path_relative_to_storage_root() {
+        let storage = app_root().join("media").join("library");
+        let path = storage.join("Artist").join("Album").join("track.flac");
+        assert_eq!(
+            media_file_path_for_storage(&storage.to_string_lossy(), &path).as_deref(),
+            Some("Artist/Album/track.flac")
+        );
+    }
+
+    #[test]
+    fn stores_windows_path_relative_to_windows_storage_root() {
+        assert_eq!(
+            path_for_root(
+                r"C:\Users\ab\repos\furumusic\library",
+                Path::new(r"C:\Users\ab\repos\furumusic\library\Artist\Album\track.mp3"),
+            )
+            .as_deref(),
+            Some("Artist/Album/track.mp3")
+        );
+    }
+
+    #[test]
+    fn normalizes_relative_backslashes() {
+        assert_eq!(
+            normalize_stored_path("/media", r"Artist\Album\track.mp3").as_deref(),
+            Some("Artist/Album/track.mp3")
+        );
+    }
+}

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

@@ -1578,6 +1578,293 @@ pub mod db_migrations {
             &[Operation::custom(add_media_file_uploader).build()];
     }
 
+    // -- M0031: persistent torrent import sessions ---------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_torrent_session(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__torrent_session (
+                    id VARCHAR(36) PRIMARY KEY,
+                    user_id BIGINT NOT NULL,
+                    name TEXT NOT NULL,
+                    info_hash VARCHAR(80) NOT NULL,
+                    source_kind VARCHAR(32) NOT NULL,
+                    source_label TEXT,
+                    torrent_bytes BYTEA NOT NULL,
+                    files_json TEXT NOT NULL,
+                    selected_files_json TEXT NOT NULL DEFAULT '[]',
+                    status VARCHAR(32) NOT NULL,
+                    total_size BIGINT NOT NULL DEFAULT 0,
+                    selected_size BIGINT NOT NULL DEFAULT 0,
+                    downloaded_bytes BIGINT NOT NULL DEFAULT 0,
+                    uploaded_bytes BIGINT NOT NULL DEFAULT 0,
+                    progress_percent DOUBLE PRECISION NOT NULL DEFAULT 0,
+                    error TEXT,
+                    created_at VARCHAR(32) NOT NULL,
+                    updated_at VARCHAR(32) NOT NULL,
+                    completed_at VARCHAR(32)
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_torrent_session_user_updated
+                   ON furumusic__torrent_session (user_id, updated_at DESC)",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_torrent_session_user_status
+                   ON furumusic__torrent_session (user_id, status)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0031CreateTorrentSession;
+
+    impl migrations::Migration for M0031CreateTorrentSession {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0031_create_torrent_session";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0030_add_media_file_uploader",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_torrent_session).build()];
+    }
+
+    // -- M0032: Last.fm track popularity ------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_lastfm_track_popularity(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_listeners BIGINT")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_playcount BIGINT")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_rating DOUBLE PRECISION")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_updated_at VARCHAR(32)")
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__track_popularity_history (
+                    id BIGSERIAL PRIMARY KEY,
+                    track_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    listeners BIGINT NOT NULL,
+                    playcount BIGINT NOT NULL,
+                    rating DOUBLE PRECISION NOT NULL,
+                    fetched_at VARCHAR(32) NOT NULL
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_track_popularity_history_track
+                   ON furumusic__track_popularity_history (track_id, fetched_at DESC)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0032CreateLastfmTrackPopularity;
+
+    impl migrations::Migration for M0032CreateLastfmTrackPopularity {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0032_create_lastfm_track_popularity";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0031_create_torrent_session",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_lastfm_track_popularity).build()];
+    }
+
+    // -- M0033: Last.fm scrobbling -----------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_lastfm_scrobbling(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_account (
+                    user_id BIGINT PRIMARY KEY,
+                    lastfm_username VARCHAR(255) NOT NULL,
+                    session_key TEXT NOT NULL,
+                    connected_at VARCHAR(32) NOT NULL,
+                    updated_at VARCHAR(32) NOT NULL,
+                    last_error TEXT,
+                    reauth_required BOOLEAN NOT NULL DEFAULT FALSE
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_auth_state (
+                    state VARCHAR(64) PRIMARY KEY,
+                    user_id BIGINT NOT NULL,
+                    created_at VARCHAR(32) NOT NULL
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_scrobble_outbox (
+                    id BIGSERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL,
+                    track_id BIGINT NOT NULL,
+                    started_at BIGINT NOT NULL,
+                    listened_seconds INTEGER NOT NULL,
+                    duration_seconds INTEGER NOT NULL,
+                    status VARCHAR(32) NOT NULL,
+                    attempt_count INTEGER NOT NULL DEFAULT 0,
+                    last_error TEXT,
+                    created_at VARCHAR(32) NOT NULL,
+                    updated_at VARCHAR(32) NOT NULL,
+                    scrobbled_at VARCHAR(32),
+                    dedupe_key VARCHAR(128) NOT NULL UNIQUE
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_status
+                   ON furumusic__lastfm_scrobble_outbox (status, created_at, id)",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_user
+                   ON furumusic__lastfm_scrobble_outbox (user_id, status, created_at)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0033CreateLastfmScrobbling;
+
+    impl migrations::Migration for M0033CreateLastfmScrobbling {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0033_create_lastfm_scrobbling";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0032_create_lastfm_track_popularity",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_lastfm_scrobbling).build()];
+    }
+
+    // -- M0034: Artwork lookup state --------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_artwork_lookup_state(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__artwork_lookup_state (
+                    id BIGSERIAL PRIMARY KEY,
+                    entity_kind VARCHAR(32) NOT NULL,
+                    entity_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    status VARCHAR(32) NOT NULL,
+                    attempt_count INTEGER NOT NULL DEFAULT 0,
+                    last_attempt_at VARCHAR(32) NOT NULL,
+                    last_error TEXT,
+                    source_url TEXT,
+                    UNIQUE(entity_kind, entity_id, source)
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_artwork_lookup_state_retry
+                   ON furumusic__artwork_lookup_state (entity_kind, source, status, last_attempt_at)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0034CreateArtworkLookupState;
+
+    impl migrations::Migration for M0034CreateArtworkLookupState {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0034_create_artwork_lookup_state";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0033_create_lastfm_scrobbling",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[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,
@@ -1599,5 +1886,10 @@ pub mod db_migrations {
         &M0028AddModelNameColumns,
         &M0029AddPlaybackVolume,
         &M0030AddMediaFileUploader,
+        &M0031CreateTorrentSession,
+        &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);
         }
     };
@@ -389,16 +400,13 @@ pub async fn oidc_callback_handler(
         config.oidc_user_groups,
     );
 
-    if !is_allowed_by_groups(
-        &groups,
-        &config.oidc_user_groups,
-        &config.oidc_admin_groups,
-    ) {
+    if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
         tracing::warn!(
             "OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
             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);
     }
 
@@ -417,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,
@@ -55,6 +56,8 @@ pub(super) struct TrackItem {
     pub(super) duration_seconds: f64,
     pub(super) artists: Vec<ArtistRef>,
     pub(super) featured_artists: Vec<ArtistRef>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
     pub(super) release_year: Option<i32>,
     pub(super) cover_url: Option<String>,
     pub(super) stream_url: String,
@@ -64,6 +67,10 @@ pub(super) struct TrackItem {
     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(Debug, Serialize, JsonSchema)]
@@ -84,6 +91,10 @@ pub(super) struct ArtistAppearanceTrack {
     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(Debug, Serialize, JsonSchema)]
@@ -127,6 +138,143 @@ pub(super) struct PlaybackStateDto {
     pub(super) volume: f64,
 }
 
+#[derive(Debug, Deserialize, JsonSchema)]
+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>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct DeviceSelectRequest {
+    pub(super) device_id: String,
+    pub(super) current_device_id: Option<String>,
+}
+
+#[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,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerDeviceDto {
+    pub(super) id: String,
+    pub(super) name: String,
+    pub(super) kind: String,
+    pub(super) is_current: bool,
+    pub(super) is_active: bool,
+    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,
+    pub(super) command: String,
+    pub(super) payload: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub(super) struct PlayerDevicePlaybackStateDto {
+    pub(super) track: Option<serde_json::Value>,
+    #[serde(default)]
+    pub(super) tracks: Vec<serde_json::Value>,
+    pub(super) index: i32,
+    pub(super) position_seconds: f64,
+    pub(super) duration_seconds: f64,
+    pub(super) paused: bool,
+    pub(super) shuffle: bool,
+    pub(super) repeat_mode: String,
+    pub(super) volume: f64,
+    #[serde(default)]
+    pub(super) updated_at_ms: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+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>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+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>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlaylistDetail {
     pub(super) id: i64,
@@ -157,17 +305,166 @@ 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,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct LastfmStatus {
+    pub(super) configured: bool,
+    pub(super) connected: bool,
+    pub(super) username: Option<String>,
+    pub(super) reauth_required: bool,
+    pub(super) last_error: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct LastfmActionResponse {
+    pub(super) ok: bool,
+    pub(super) queued: bool,
+    pub(super) sent: bool,
+    pub(super) message: Option<String>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct LastfmNowPlayingRequest {
+    pub(super) track_id: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct LastfmScrobbleRequest {
+    pub(super) track_id: i64,
+    pub(super) started_at: Option<i64>,
+    pub(super) listened_seconds: i32,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct AgentQueueStatus {
+    pub(super) queued_count: i64,
+    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/helpers.rs

@@ -1,15 +1,16 @@
 use crate::player::dto::UploaderSummary;
 use crate::player::rows::ReleaseUploaderRow;
 
-pub(super) fn cover_url(file_id: Option<i64>) -> Option<String> {
-    file_id.map(|id| format!("/api/player/cover/{id}"))
+pub(super) fn cover_variant_url(file_id: Option<i64>, variant: &str) -> Option<String> {
+    file_id.map(|id| format!("/api/player/cover/{id}/{variant}"))
 }
 
-pub(super) fn track_cover_url(
+pub(super) fn track_cover_variant_url(
     track_cover: Option<i64>,
     release_cover: Option<i64>,
+    variant: &str,
 ) -> Option<String> {
-    cover_url(track_cover.or(release_cover))
+    cover_variant_url(track_cover.or(release_cover), variant)
 }
 
 pub(super) async fn load_release_uploaders(

src/player/queries.rs

@@ -3,6 +3,7 @@ use serde::Deserialize;
 #[derive(Debug, Deserialize)]
 pub(super) struct HistoryEntry {
     pub(super) track_id: i64,
+    pub(super) started_at: Option<i64>,
     pub(super) duration_listened: Option<i32>,
     pub(super) completed: bool,
 }
@@ -18,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,
@@ -55,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,
@@ -70,3 +88,9 @@ pub(super) struct PathTrackId {
 pub(super) struct PathMediaFileId {
     pub(super) media_file_id: i64,
 }
+
+#[derive(Debug, Deserialize)]
+pub(super) struct PathMediaFileVariant {
+    pub(super) media_file_id: i64,
+    pub(super) variant: String,
+}

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,24 +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_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>,
-}
-
 #[derive(sqlx::FromRow)]
 pub(super) struct TrackArtistRow {
     pub(super) track_id: i64,
@@ -54,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,
@@ -103,6 +100,8 @@ pub(super) struct PlaylistTrackRow {
     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>,
@@ -110,6 +109,74 @@ pub(super) struct PlaylistTrackRow {
     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 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)]
@@ -128,6 +195,10 @@ pub(super) struct AppearanceTrackRow {
     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)]
@@ -158,6 +229,8 @@ pub(super) struct SearchTrackRow {
     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>,
@@ -165,6 +238,10 @@ pub(super) struct SearchTrackRow {
     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)]
@@ -175,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);
@@ -460,6 +472,16 @@ impl PendingReview {
         self.save(db).await
     }
 
+    pub async fn set_result_json(
+        &mut self,
+        db: &Database,
+        result_json: String,
+    ) -> cot::db::Result<()> {
+        self.result_json = Some(result_json);
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
     pub async fn set_failed(&mut self, db: &Database, error: &str) -> cot::db::Result<()> {
         self.status = LimitedString::new("failed").unwrap();
         self.error_message = Some(error.to_owned());
@@ -1347,7 +1369,11 @@ async fn run_scheduled_job(
 
     // Check agent_enabled (re-read from DB every run)
     let (live_config, _) = AppConfig::load_with_db(db).await;
-    if !live_config.agent_enabled {
+    if !live_config.agent_enabled
+        && job_name != "lastfm_popularity"
+        && job_name != "lastfm_scrobble"
+        && job_name != "artwork_backfill"
+    {
         tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
         return;
     }
@@ -1457,6 +1483,31 @@ pub async fn start_scheduler(
         Err(e) => tracing::error!("Failed to recover stale reviews: {e}"),
     }
 
+    let (live_config, _) = AppConfig::load_with_db(&db).await;
+    if !live_config.agent_storage_dir.trim().is_empty() {
+        match crate::media_paths::normalize_media_file_paths(&pool, &live_config.agent_storage_dir)
+            .await
+        {
+            Ok(0) => {}
+            Ok(n) => tracing::info!("Normalized {n} media file path(s) to relative storage paths"),
+            Err(e) => tracing::warn!("Failed to normalize media file paths: {e:#}"),
+        }
+    }
+    if !live_config.agent_inbox_dir.trim().is_empty() {
+        match crate::media_paths::normalize_pending_review_paths(
+            &pool,
+            &live_config.agent_inbox_dir,
+        )
+        .await
+        {
+            Ok(0) => {}
+            Ok(n) => {
+                tracing::info!("Normalized {n} pending review path(s) to relative inbox paths")
+            }
+            Err(e) => tracing::warn!("Failed to normalize pending review paths: {e:#}"),
+        }
+    }
+
     // Upsert ScheduledJob rows
     for job in registry.all_jobs() {
         ScheduledJob::upsert(&db, job.name(), job.description(), job.default_cron())

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/admin/review_detail.html

@@ -25,28 +25,76 @@
 </div>
 {% endif %}
 
+{% if review.status_str() == "pending" %}
+<h2>{{ t.reviews_result }}</h2>
+<form method="post" action="/admin/reviews/{{ review.id_val() }}/approve" style="margin: 1rem 0;">
+    <table>
+        <tr>
+            <td><label for="artist">Artist</label></td>
+            <td><input name="artist" id="artist" value="{{ edit.artist }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="album">Album</label></td>
+            <td><input name="album" id="album" value="{{ edit.album }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="title">Title</label></td>
+            <td><input name="title" id="title" value="{{ edit.title }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="year">Year</label></td>
+            <td><input name="year" id="year" type="number" min="0" max="3000" value="{{ edit.year }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="track_number">Track</label></td>
+            <td><input name="track_number" id="track_number" type="number" min="0" value="{{ edit.track_number }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="genre">Genre</label></td>
+            <td><input name="genre" id="genre" value="{{ edit.genre }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="featured_artists">Featured artists</label></td>
+            <td><input name="featured_artists" id="featured_artists" value="{{ edit.featured_artists }}" style="width:100%"></td>
+        </tr>
+        <tr>
+            <td><label for="release_type">{{ t.releases_type }}</label></td>
+            <td>
+                <select name="release_type" id="release_type" style="width:100%; padding:.4rem;">
+                    {% for rt in release_types %}
+                    <option value="{{ rt.0 }}"{% if edit.release_type == rt.0 %} selected{% endif %}>{% if lang_code == "ru" %}{{ rt.2 }}{% else %}{{ rt.1 }}{% endif %} ({{ rt.0 }})</option>
+                    {% endfor %}
+                </select>
+            </td>
+        </tr>
+        <tr>
+            <td><label for="notes">Notes</label></td>
+            <td><textarea name="notes" id="notes" style="width:100%; min-height:4rem;">{{ edit.notes }}</textarea></td>
+        </tr>
+    </table>
+    <button type="submit" style="margin-top:1rem; padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_approve }}</button>
+</form>
 <div style="margin: 1rem 0; display: flex; gap: .5rem;">
-    {% if review.status_str() == "pending" %}
-    <form method="post" action="/admin/reviews/{{ review.id_val() }}/approve" style="display:inline;">
-        <button type="submit" style="padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_approve }}</button>
-    </form>
     <form method="post" action="/admin/reviews/{{ review.id_val() }}/reject" style="display:inline;">
         <button type="submit" style="padding:.4rem 1rem; background:#dc3545; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_reject }}</button>
     </form>
-    {% endif %}
+</div>
+{% else %}
+<div style="margin: 1rem 0; display: flex; gap: .5rem;">
     {% if review.status_str() == "failed" || review.status_str() == "processing" %}
     <form method="post" action="/admin/reviews/{{ review.id_val() }}/requeue" style="display:inline;" onsubmit="return confirm('{{ t.reviews_requeue_confirm }}');">
         <button type="submit" style="padding:.4rem 1rem; background:#17a2b8; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_requeue }}</button>
     </form>
     {% endif %}
 </div>
+{% endif %}
 
 {% if !context_pretty.is_empty() %}
 <h2>{{ t.reviews_context }}</h2>
 <pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ context_pretty }}</pre>
 {% endif %}
 
-{% if !result_pretty.is_empty() %}
+{% if !result_pretty.is_empty() && review.status_str() != "pending" %}
 <h2>{{ t.reviews_result }}</h2>
 <pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ result_pretty }}</pre>
 {% endif %}

templates/admin/settings.html

@@ -85,6 +85,16 @@
     <td><input type="checkbox" name="swagger_enabled" id="swagger_enabled" value="on"{% if swagger_enabled %} checked{% endif %}></td>
     <td><span class="badge badge-{{ swagger_enabled_source }}">{{ swagger_enabled_source }}</span></td>
   </tr>
+  <tr>
+    <td><label for="lastfm_api_key">{{ t.settings_lastfm_api_key }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_api_key_help }}</span></td>
+    <td><input type="password" name="lastfm_api_key" id="lastfm_api_key" value="{{ lastfm_api_key }}"></td>
+    <td><span class="badge badge-{{ lastfm_api_key_source }}">{{ lastfm_api_key_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="lastfm_shared_secret">{{ t.settings_lastfm_shared_secret }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_shared_secret_help }}</span></td>
+    <td><input type="password" name="lastfm_shared_secret" id="lastfm_shared_secret" value="{{ lastfm_shared_secret }}"></td>
+    <td><span class="badge badge-{{ lastfm_shared_secret_source }}">{{ lastfm_shared_secret_source }}</span></td>
+  </tr>
 </table>
 
 <h2>{{ t.settings_agent }}</h2>

templates/player/modals.html

@@ -0,0 +1,750 @@
+    <!-- Info Modal -->
+    <template x-if="$store.info.modal">
+        <div class="modal-overlay" @click.self="$store.info.close()">
+            <div class="modal-box info-modal">
+                <div class="info-modal-head">
+                    <h3 x-text="$store.info.modal.title"></h3>
+                    <button class="mobile-list-action" @click="$store.info.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="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">
+                            <tbody>
+                                <template x-for="(row, idx) in $store.info.modal.rows" :key="row.label + '-' + idx">
+                                    <tr>
+                                        <th x-text="row.label"></th>
+                                        <td>
+                                            <template x-if="row.links && row.links.length">
+                                                <div class="info-link-list">
+                                                    <template x-for="link in row.links" :key="link.type + '-' + link.id + '-' + link.label">
+                                                        <button class="info-link" type="button" @click="$store.info.navigate(link)" x-text="link.label"></button>
+                                                    </template>
+                                                </div>
+                                            </template>
+                                            <template x-if="!row.links || !row.links.length">
+                                                <span x-text="row.value"></span>
+                                            </template>
+                                        </td>
+                                    </tr>
+                                </template>
+                            </tbody>
+                        </table>
+                    </template>
+                    <pre class="info-modal-plain" x-show="!$store.info.modal.rows || !$store.info.modal.rows.length" x-text="$store.info.modal.body"></pre>
+                </div>
+            </div>
+        </div>
+    </template>
+
+    <!-- Create / Rename Playlist Modal -->
+    <template x-if="$store.playlists.modal">
+        <div class="modal-overlay" @click.self="$store.playlists.modal = null">
+            <div class="modal-box">
+                <h3 x-text="$store.playlists.modal.mode === 'create' ? '{{ t.player_new_playlist }}' : '{{ t.player_rename_playlist }}'"></h3>
+                <input type="text" x-model="$store.playlists.modal.title" placeholder="{{ t.player_playlist_name }}"
+                       @keydown.enter="$store.playlists.submitModal()" x-init="$nextTick(() => $el.focus())">
+                <div class="modal-footer">
+                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.modal = null">{{ t.player_cancel }}</button>
+                    <button class="modal-btn modal-btn-primary" @click="$store.playlists.submitModal()"
+                            x-text="$store.playlists.modal.mode === 'create' ? '{{ t.player_create }}' : '{{ t.player_save }}'"></button>
+                </div>
+            </div>
+        </div>
+    </template>
+
+    <!-- Add to Playlist Modal -->
+    <template x-if="$store.playlists.picker">
+        <div class="modal-overlay" @click.self="$store.playlists.picker = null">
+            <div class="modal-box">
+                <h3>{{ t.player_add_to_playlist }}</h3>
+                <div class="modal-playlist-list">
+                    <template x-for="pl in $store.playlists.list.filter(p => p.kind === 'user' && p.is_own)" :key="pl.id">
+                        <div class="modal-playlist-item" @click="$store.playlists.addToPicked(pl.id)">
+                            <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>
+                            <span x-text="pl.title"></span>
+                        </div>
+                    </template>
+                </div>
+                <div class="modal-footer">
+                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.picker = null">{{ t.player_cancel }}</button>
+                    <button class="modal-btn modal-btn-primary" @click="$store.playlists.picker = null; $store.playlists.showCreate()">{{ t.player_new_playlist }}</button>
+                </div>
+            </div>
+        </div>
+    </template>
+
+    <!-- Torrent Import Modal -->
+    <template x-if="$store.torrents.modal">
+        <div class="modal-overlay" @click.self="$store.torrents.close()">
+            <div class="modal-box torrent-modal">
+                <div class="torrent-modal-head">
+                    <div>
+                        <h3>{{ t.player_torrent_manager }}</h3>
+                        <p class="torrent-message" style="margin:4px 0 0"
+                           :class="{ error: $store.torrents.error }"
+                           x-text="$store.torrents.message"></p>
+                    </div>
+                    <button class="torrent-modal-close"
+                            @click="$store.torrents.close()"
+                            title="{{ t.player_close }}"
+                            aria-label="{{ t.player_close }}">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
+                    <div class="torrent-client-status">
+                        <span class="torrent-status-pill"
+                              :class="{ active: $store.torrents.activeCount() > 0 }"
+                              x-text="$store.torrents.clientSummary()"></span>
+                        <span class="torrent-status-pill torrent-agent-pill"
+                              :class="{ active: $store.torrents.agentBusy() }">
+                            <span class="torrent-agent-dot"></span>
+                            <span x-text="$store.torrents.agentSummary()"></span>
+                        </span>
+                        <span class="torrent-status-pill"
+                              x-text="$store.torrents.sessions.length + ' ' + T.saved"></span>
+                    </div>
+                </div>
+
+                <div class="torrent-tabs">
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'import' }"
+                            @click="$store.torrents.showImportTab()">{{ t.player_import }}</button>
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'uploads' }"
+                            @click="$store.torrents.showUploadsTab()">
+                        <span>{{ t.player_my_uploads }}</span>
+                        <span class="torrent-tab-count"
+                              x-show="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal > 0"
+                              x-text="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal"></span>
+                    </button>
+                </div>
+
+                <template x-if="$store.torrents.activeTab === 'import'">
+                <div class="torrent-manager-layout">
+                    <aside class="torrent-manager-sidebar">
+                        <div class="torrent-manager-title">
+                            <span>{{ t.player_saved_torrents }}</span>
+                            <button class="modal-btn modal-btn-ghost" style="padding:4px 8px"
+                                    @click="$store.torrents.loadSessions()"
+                                    :disabled="$store.torrents.loading">{{ t.player_refresh }}</button>
+                        </div>
+                        <div class="torrent-session-list">
+                            <template x-if="!$store.torrents.loadingSessions && $store.torrents.sessions.length === 0">
+                                <div class="empty-state" style="padding:28px 12px">
+                                    <p>{{ t.player_no_saved_torrents }}</p>
+                                </div>
+                            </template>
+                            <template x-for="job in $store.torrents.sessions" :key="job.id">
+                                <div class="torrent-session-row"
+                                     :class="{ active: $store.torrents.workspaceMode === 'session' && $store.torrents.previewData && $store.torrents.previewData.id === job.id }"
+                                     @click="$store.torrents.openSession(job.id)">
+                                    <div class="torrent-session-main">
+                                        <div class="torrent-session-topline">
+                                            <div class="torrent-session-name" x-text="job.name"></div>
+                                            <span class="torrent-status-badge"
+                                                  :class="$store.torrents.statusBadgeClass(job)"
+                                                  x-text="$store.torrents.statusLabel(job)"></span>
+                                        </div>
+                                        <div class="torrent-session-meta" x-text="$store.torrents.sessionMeta(job)"></div>
+                                        <div class="torrent-session-progress">
+                                            <div class="torrent-session-progress-bar"
+                                                 :style="'width:' + $store.torrents.progressValue(job) + '%'"></div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </template>
+                            <button type="button"
+                                    class="torrent-session-row torrent-session-add"
+                                    :class="{ active: $store.torrents.isImporting() }"
+                                    @click="$store.torrents.addNew()"
+                                    :disabled="$store.torrents.loading">
+                                <span class="torrent-session-add-icon">+</span>
+                                <span>{{ t.player_upload }}</span>
+                            </button>
+                        </div>
+                    </aside>
+
+                    <section class="torrent-workspace">
+                        <template x-if="$store.torrents.workspaceMode === 'empty'">
+                            <div class="empty-state torrent-workspace-empty">
+                                <p x-text="T.chooseSavedOrAddTorrent"></p>
+                            </div>
+                        </template>
+
+                        <template x-if="$store.torrents.isImporting()">
+                            <div class="torrent-import-panel">
+                                <div class="torrent-modal-grid">
+                                    <div>
+                                        <label for="local-file-input">{{ t.player_local_files }}</label>
+                                        <input id="local-file-input" type="file" multiple accept="audio/*,.mp3,.flac,.wav,.m4a,.ogg,.opus,.aac"
+                                               @change="$store.torrents.setLocalFiles($event.target.files)">
+                                        <div class="torrent-upload-summary" x-text="$store.torrents.localUploadSummary()"></div>
+                                    </div>
+                                    <div>
+                                        <label for="torrent-magnet-input">{{ t.player_magnet_link }}</label>
+                                        <input id="torrent-magnet-input" type="text"
+                                               x-model="$store.torrents.magnet"
+                                               placeholder="magnet:?xt=urn:btih:...">
+                                    </div>
+                                    <div>
+                                        <label for="torrent-file-input">{{ t.player_torrent_file }}</label>
+                                        <input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
+                                               @change="$store.torrents.file = $event.target.files[0] || null">
+                                    </div>
+                                </div>
+                                <div class="torrent-upload-progress"
+                                    x-show="$store.torrents.uploadProgress > 0 || ($store.torrents.localFiles.length > 0 && $store.torrents.loading)">
+                                    <div class="torrent-progress-head">
+                                        <span x-text="$store.torrents.uploadProgress >= 100 ? T.uploadComplete : T.uploadingFiles"></span>
+                                        <span x-text="$store.torrents.uploadProgressText"></span>
+                                    </div>
+                                    <div class="torrent-progress-track">
+                                        <div class="torrent-progress-bar"
+                                             :style="'width:' + $store.torrents.uploadProgress + '%'"></div>
+                                    </div>
+                                </div>
+                                <div class="torrent-actions">
+                                    <button class="modal-btn modal-btn-primary" @click="$store.torrents.preview()" :disabled="$store.torrents.loading">
+                                        {{ t.player_upload_content }}
+                                    </button>
+                                </div>
+                            </div>
+                        </template>
+
+                        <template x-if="$store.torrents.currentJob">
+                            <div class="torrent-progress-card">
+                                <div class="torrent-progress-head">
+                                    <span x-text="$store.torrents.statusText($store.torrents.currentJob)"></span>
+                                    <span x-text="$store.torrents.progressValue($store.torrents.currentJob).toFixed(1) + '%'"></span>
+                                </div>
+                                <div class="torrent-progress-track">
+                                    <div class="torrent-progress-bar"
+                                         :style="'width:' + $store.torrents.progressValue($store.torrents.currentJob) + '%'"></div>
+                                </div>
+                                <div class="torrent-progress-details"
+                                     :class="{ completed: $store.torrents.isCompleted($store.torrents.currentJob) }">
+                                    <span class="torrent-progress-metric">
+                                        <span class="torrent-progress-label"
+                                              x-text="$store.torrents.isCompleted($store.torrents.currentJob) ? T.size : T.downloaded"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.progressDetailText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.speed"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.speedText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.peers"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.peerText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob) && $store.torrents.etaText($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.eta"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.etaText($store.torrents.currentJob)"></span>
+                                    </span>
+                                </div>
+                            </div>
+                        </template>
+                <template x-if="$store.torrents.previewData">
+                    <div class="torrent-preview-panel">
+                        <div class="torrent-preview-head">
+                            <div style="min-width:0">
+                                <div class="torrent-preview-title" x-text="$store.torrents.previewData.name"></div>
+                                <div class="torrent-preview-meta"
+                                     x-text="$store.torrents.previewData.files.length + ' {{ t.player_files_count }} - ' + $store.torrents.bytes($store.torrents.previewData.total_size)"></div>
+                            </div>
+                            <div class="torrent-preview-actions">
+                                <button class="modal-btn"
+                                        :class="$store.torrents.actionButtonClass()"
+                                        @click="$store.torrents.toggleDownloadAction()"
+                                        :disabled="$store.torrents.actionButtonDisabled()">
+                                    <span x-text="$store.torrents.actionButtonText()"></span>
+                                </button>
+                                <button class="modal-btn modal-btn-danger"
+                                        @click="$store.torrents.removeSession($store.torrents.previewData.id)"
+                                        :disabled="$store.torrents.loading">
+                                    {{ t.player_delete }}
+                                </button>
+                            </div>
+                        </div>
+                        <div class="torrent-tree-toolbar">
+                            <div class="torrent-selected-summary"
+                                 x-text="$store.torrents.selected.size + ' {{ t.player_selected }} - ' + $store.torrents.bytes($store.torrents.selectedBytes())"></div>
+                            <div class="torrent-actions" style="margin-top:0">
+                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(true)">{{ t.player_expand_all }}</button>
+                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(false)">{{ t.player_collapse }}</button>
+                            </div>
+                        </div>
+                        <div class="torrent-file-tree">
+                            <template x-for="node in $store.torrents.visibleNodes()" :key="node.key">
+                                <div class="torrent-tree-row" :style="'--indent:' + $store.torrents.rowIndent(node) + 'px'">
+                                    <button class="torrent-tree-toggle"
+                                            :class="{ expanded: $store.torrents.expanded.has(node.key) }"
+                                            @click="$store.torrents.toggleExpand(node)"
+                                            :style="node.type === 'folder' ? '' : 'visibility:hidden'">
+                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                            <polyline points="9 18 15 12 9 6"/>
+                                        </svg>
+                                    </button>
+                                    <button class="torrent-tree-check"
+                                            :class="$store.torrents.nodeCheckClass(node)"
+                                            @click="$store.torrents.toggleNode(node)">
+                                        <template x-if="$store.torrents.nodeState(node) === '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.nodeState(node) === 'partial'">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3">
+                                                <line x1="5" y1="12" x2="19" y2="12"/>
+                                            </svg>
+                                        </template>
+                                    </button>
+                                    <div class="torrent-tree-label" :title="node.name">
+                                        <template x-if="node.type === 'folder'">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                                <path d="M3 7a2 2 0 012-2h5l2 2h7a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2z"/>
+                                            </svg>
+                                        </template>
+                                        <template x-if="node.type === 'file'">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                                <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/>
+                                                <polyline points="14 2 14 8 20 8"/>
+                                            </svg>
+                                        </template>
+                                        <span class="torrent-file-name" x-text="node.name"></span>
+                                    </div>
+                                    <span class="torrent-file-size" x-text="$store.torrents.bytes(node.size)"></span>
+                                </div>
+                            </template>
+                        </div>
+                    </div>
+                </template>
+                    </section>
+                </div>
+                </template>
+
+                <template x-if="$store.torrents.activeTab === 'uploads'">
+                    <section class="upload-manager-panel">
+                        <div class="upload-manager-head">
+                            <div>
+                                <h4>{{ t.player_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>{{ t.player_no_uploaded_tracks }}</p>
+                            </div>
+                        </template>
+
+                        <div class="upload-manager-grid">
+                            <aside class="upload-review-column">
+                                <div class="upload-panel-card">
+                                    <div class="upload-panel-title">{{ t.player_needs_approval }}</div>
+                                    <p class="upload-panel-subtitle" x-text="$store.torrents.uploadPendingTotal + ' {{ t.player_pending_or_failed }}'"></p>
+                                    <template x-if="$store.torrents.uploadPending.length === 0">
+                                        <div class="upload-mini-empty">{{ t.player_no_tracks_need_approval }}</div>
+                                    </template>
+                                    <div class="upload-review-list">
+                                        <template x-for="item in $store.torrents.uploadPending" :key="item.id">
+                                            <button class="upload-review-row" :class="{ active: $store.torrents.uploadReviewEditId === item.id, failed: item.status === 'failed' }" @click="$store.torrents.editUploadReview(item)">
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="$store.torrents.uploadStatusLabel(item.status)"></span>
+                                                <span class="upload-review-name" x-text="item.filename"></span>
+                                                <span class="upload-review-error" x-show="item.error_message" x-text="item.error_message"></span>
+                                            </button>
+                                        </template>
+                                    </div>
+                                </div>
+                                <template x-if="$store.torrents.uploadQueuedTotal > 0">
+                                    <div class="upload-panel-card upload-queue-panel">
+                                        <div class="upload-panel-title upload-panel-title-row">
+                                            <span>{{ t.player_queued_processing }}</span>
+                                            <div class="upload-queue-nav" x-show="$store.torrents.uploadQueued.length > $store.torrents.uploadQueuePageSize">
+                                                <span class="upload-queue-range" x-text="$store.torrents.uploadQueueRangeText()"></span>
+                                                <button type="button"
+                                                        class="upload-queue-nav-btn"
+                                                        @click="$store.torrents.uploadQueuePrev()"
+                                                        :disabled="!$store.torrents.uploadQueueCanPrev()"
+                                                        title="{{ t.player_previous }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4"><polyline points="15 18 9 12 15 6"/></svg>
+                                                </button>
+                                                <button type="button"
+                                                        class="upload-queue-nav-btn"
+                                                        @click="$store.torrents.uploadQueueNext()"
+                                                        :disabled="!$store.torrents.uploadQueueCanNext()"
+                                                        title="{{ t.player_next }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4"><polyline points="9 18 15 12 9 6"/></svg>
+                                                </button>
+                                            </div>
+                                        </div>
+                                        <template x-for="item in $store.torrents.compactQueuedUploads()" :key="item.id">
+                                            <div class="upload-queue-row" :title="$store.torrents.uploadQueueTooltip(item)">
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="$store.torrents.uploadStatusLabel(item.status)"></span>
+                                                <span class="upload-queue-name" x-text="item.filename"></span>
+                                            </div>
+                                        </template>
+                                        <div class="upload-mini-empty" x-show="$store.torrents.uploadQueuedTotal > $store.torrents.uploadQueued.length" x-text="$store.torrents.uploadQueueOverflowText()"></div>
+                                    </div>
+                                </template>
+                            </aside>
+                            <section class="upload-library-column">
+                                <div class="upload-bulk-bar" x-show="$store.torrents.uploadSelectedCount() > 0">
+                                    <div class="upload-bulk-title" x-text="$store.torrents.uploadSelectedCount() + ' {{ t.player_selected }}'"></div>
+                                    <input type="text" placeholder="{{ t.player_artists }}" x-model="$store.torrents.uploadBulkDraft.artists">
+                                    <input type="text" placeholder="{{ t.player_featured }}" x-model="$store.torrents.uploadBulkDraft.featured_artists">
+                                    <input type="text" placeholder="{{ t.player_album }}" x-model="$store.torrents.uploadBulkDraft.release_title">
+                                    <input type="number" placeholder="{{ t.player_year }}" x-model="$store.torrents.uploadBulkDraft.release_year">
+                                    <select x-model="$store.torrents.uploadBulkDraft.release_type">
+                                        <option value="">{{ t.player_type_unchanged }}</option><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option>
+                                    </select>
+                                    <select x-model="$store.torrents.uploadBulkDraft.hidden">
+                                        <option value="">{{ t.player_visibility_unchanged }}</option><option value="false">{{ t.player_visible }}</option><option value="true">{{ t.player_hidden }}</option>
+                                    </select>
+                                    <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadBulkEdit()" :disabled="$store.torrents.uploadBulkSaving">{{ t.player_apply }}</button>
+                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearUploadSelection()">{{ t.player_clear }}</button>
+                                </div>
+                                <div class="upload-release-tree">
+                                    <template x-for="group in $store.torrents.uploadArtistGroups()" :key="group.key">
+                                        <section class="upload-artist-group">
+                                            <div class="upload-artist-row">
+                                                <div class="upload-artist-name" x-text="group.name"></div>
+                                                <div class="upload-artist-meta" x-text="group.releases.length + ' {{ t.player_releases_count }} - ' + group.trackCount + ' {{ t.player_tracks_count }}'"></div>
+                                            </div>
+                                            <template x-for="release in group.releases" :key="release.id">
+                                                <div class="upload-release-node" :class="{ hidden: release.is_hidden }">
+                                                    <div class="upload-release-row">
+                                                        <button class="torrent-tree-check" :class="$store.torrents.uploadReleaseSelectionState(release)" @click="$store.torrents.toggleUploadReleaseSelection(release)">
+                                                            <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'checked'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                            <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'partial'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><line x1="5" y1="12" x2="19" y2="12"/></svg></template>
+                                                        </button>
+                                                        <button class="torrent-tree-toggle" :class="{ expanded: $store.torrents.uploadReleaseExpanded(release.id) }" @click="$store.torrents.toggleUploadRelease(release.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg></button>
+                                                        <div class="upload-release-main">
+                                                            <div class="upload-release-title"><span x-text="release.title"></span><span class="upload-hidden-pill" x-show="release.is_hidden">{{ t.player_hidden }}</span></div>
+                                                            <div class="upload-track-meta"><span x-text="$store.torrents.uploadReleaseArtistsText(release)"></span><span>-</span><span x-text="release.year || T.noYear"></span><span>-</span><span x-text="release.tracks.length + ' {{ t.player_tracks_count }}'"></span></div>
+                                                        </div>
+                                                        <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUploadRelease(release)">{{ t.player_edit_release }}</button>
+                                                    </div>
+                                                    <div class="upload-track-children" x-show="$store.torrents.uploadReleaseExpanded(release.id)">
+                                                        <template x-for="item in release.tracks" :key="item.track.id">
+                                                            <div class="upload-tree-track" :class="{ hidden: item.is_hidden, selected: $store.torrents.selectedUploadTracks.has(item.track.id) }">
+                                                                <button class="torrent-tree-check" :class="{ checked: $store.torrents.selectedUploadTracks.has(item.track.id) }" @click="$store.torrents.toggleUploadTrackSelection(item.track.id)">
+                                                                    <template x-if="$store.torrents.selectedUploadTracks.has(item.track.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                                </button>
+                                                                <div class="upload-track-main">
+                                                                    <div class="upload-track-title"><span x-text="item.track.track_number ? item.track.track_number + '. ' + item.track.title : item.track.title"></span><span class="upload-hidden-pill" x-show="item.is_hidden">{{ t.player_hidden }}</span></div>
+                                                                    <div class="upload-track-meta"><span x-text="$store.torrents.uploadArtistsText(item)"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="T.featuredShort"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="$store.torrents.uploadFeaturedArtistsText(item)"></span></div>
+                                                                </div>
+                                                                <div class="upload-track-actions">
+                                                                    <button class="track-action-btn queue-insert-btn queue-next-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                                    <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">{{ t.player_edit }}</button>
+                                                                </div>
+                                                            </div>
+                                                        </template>
+                                                    </div>
+                                                </div>
+                                            </template>
+                                        </section>
+                                    </template>
+                                </div>
+                            </section>
+                        </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="{{ t.player_close }}">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                                <path d="M18 6L6 18M6 6l12 12"/>
+                                            </svg>
+                                        </button>
+                                    </div>
+
+                                    <template x-if="$store.torrents.uploadReviewDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_title }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_artist }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.artist"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.album"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_featured }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.featured_artists" placeholder="{{ t.player_artists_placeholder }}"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadReviewDraft.year"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_track_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadReviewDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_genre }}</span><input type="text" x-model="$store.torrents.uploadReviewDraft.genre"></label>
+                                            <label class="upload-field upload-field-compact">
+                                                <span>{{ t.player_type }}</span>
+                                                <select x-model="$store.torrents.uploadReviewDraft.release_type">
+                                                    <option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option>
+                                                </select>
+                                            </label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_notes }}</span><textarea rows="4" x-model="$store.torrents.uploadReviewDraft.notes"></textarea></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-danger" @click="$store.torrents.deleteUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">{{ t.player_delete_review }}</button>
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.approveUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">{{ t.player_approve }}</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadReleaseDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.title"></label>
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_album_artists }}</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadReleaseDraft.year"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_type }}</span><select x-model="$store.torrents.uploadReleaseDraft.release_type"><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option></select></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadReleaseDraft.is_hidden"><span>{{ t.player_hidden }}</span></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadReleaseEdit()" :disabled="$store.torrents.uploadReleaseSavingId === $store.torrents.uploadReleaseEditId">{{ t.player_save_release }}</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-wide"><span>{{ t.player_title }}</span><input type="text" x-model="$store.torrents.uploadDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_artists }}</span><input type="text" x-model="$store.torrents.uploadDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_featured }}</span><input type="text" x-model="$store.torrents.uploadDraft.featured_artists"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_album }}</span><input type="text" x-model="$store.torrents.uploadDraft.release_title"></label>
+                                            <label class="upload-field upload-field-half"><span>{{ t.player_type }}</span><select x-model="$store.torrents.uploadDraft.release_type"><option value="album">{{ t.player_release_type_album }}</option><option value="single">{{ t.player_release_type_single }}</option><option value="ep">{{ t.player_release_type_ep }}</option><option value="compilation">{{ t.player_release_type_compilation }}</option><option value="mixtape">{{ t.player_release_type_mixtape }}</option><option value="live">{{ t.player_release_type_live }}</option><option value="soundtrack">{{ t.player_release_type_soundtrack }}</option><option value="remix">{{ t.player_release_type_remix }}</option><option value="demo">{{ t.player_release_type_demo }}</option></select></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_year }}</span><input type="number" x-model="$store.torrents.uploadDraft.release_year"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_track_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>{{ t.player_disc_number }}</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number"></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden"><span>{{ t.player_hidden }}</span></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadEdit()" :disabled="$store.torrents.uploadSavingId === $store.torrents.uploadEditId">{{ t.player_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">{{ t.player_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)">{{ t.player_edit }}</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadEditId === item.track.id">
+                                        <div class="upload-edit-form">
+                                            <label>
+                                                <span>{{ t.player_title }}</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.title">
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_artists }}</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.artists" placeholder="{{ t.player_artist_featured_placeholder }}">
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_release }}</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.release_title">
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_type }}</span>
+                                                <select x-model="$store.torrents.uploadDraft.release_type">
+                                                    <option value="album">{{ t.player_release_type_album }}</option>
+                                                    <option value="single">{{ t.player_release_type_single }}</option>
+                                                    <option value="ep">{{ t.player_release_type_ep }}</option>
+                                                    <option value="compilation">{{ t.player_release_type_compilation }}</option>
+                                                    <option value="mixtape">{{ t.player_release_type_mixtape }}</option>
+                                                    <option value="live">{{ t.player_release_type_live }}</option>
+                                                    <option value="soundtrack">{{ t.player_release_type_soundtrack }}</option>
+                                                    <option value="remix">{{ t.player_release_type_remix }}</option>
+                                                    <option value="demo">{{ t.player_release_type_demo }}</option>
+                                                </select>
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_year }}</span>
+                                                <input type="number" x-model="$store.torrents.uploadDraft.release_year">
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_track_number }}</span>
+                                                <input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number">
+                                            </label>
+                                            <label>
+                                                <span>{{ t.player_disc_number }}</span>
+                                                <input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number">
+                                            </label>
+                                            <label class="upload-hidden-toggle">
+                                                <input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden">
+                                                <span>{{ t.player_hidden }}</span>
+                                            </label>
+                                            <div class="upload-edit-actions">
+                                                <button class="modal-btn modal-btn-primary"
+                                                        @click="$store.torrents.saveUploadEdit()"
+                                                        :disabled="$store.torrents.uploadSavingId === item.track.id">{{ t.player_save }}</button>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.cancelUploadEdit()">{{ t.player_cancel }}</button>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </div>
+                            </template>
+                        </div>
+                    </section>
+                </template>
+            </div>
+        </div>
+    </template>
+
+    <!-- Play History Modal -->
+    <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-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 class="history-date" x-text="$store.history.date(item.played_at)"></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>
+                <div class="history-pager">
+                    <button class="modal-btn modal-btn-ghost"
+                            @click="$store.history.load($store.history.page - 1)"
+                            :disabled="$store.history.loading || $store.history.page <= 1">
+                        {{ t.player_previous }}
+                    </button>
+                    <span class="history-release"
+                          x-text="'{{ t.player_page }} ' + $store.history.page + ' {{ t.player_of }} ' + $store.history.totalPages()"></span>
+                    <button class="modal-btn modal-btn-primary"
+                            @click="$store.history.load($store.history.page + 1)"
+                            :disabled="$store.history.loading || $store.history.page >= $store.history.totalPages()">
+                        {{ t.player_next }}
+                    </button>
+                </div>
+            </div>
+        </div>
+    </template>
+</div>