CORE: reworked artwork_backfill.rs task

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.14"
+version = "0.1.21"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1407,7 +1428,9 @@ dependencies = [
  "croner",
  "encoding_rs",
  "id3",
+ "image",
  "librqbit",
+ "md-5",
  "openidconnect",
  "reqwest",
  "schemars 0.9.0",
@@ -1588,6 +1611,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 +2059,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 +2583,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 +3071,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 +3151,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 +3172,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 +5238,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 +5792,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.15"
+version = "0.1.22"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -20,6 +20,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",
                 {
@@ -278,6 +307,13 @@ impl App for AdminApp {
                 ),
                 "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({
@@ -392,6 +428,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",
                 {
@@ -1041,7 +1159,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);
@@ -1057,7 +1176,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/v2.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use cot::db::{Database, Model};
 use cot::html::Html;
@@ -13,8 +13,9 @@ use serde::{Deserialize, Serialize};
 use sqlx::{PgPool, Postgres, QueryBuilder};
 
 use super::BUILD_INFO;
+use crate::agent;
 use crate::auth::{self, AuthenticatedUser, Role};
-use crate::config::{AppConfig, ConfigEntry};
+use crate::config::{AppConfig, ConfigEntry, ConfigSources};
 use crate::i18n::{I18n, Translations};
 use crate::scheduler::{JobRegistry, ScheduledJob};
 
@@ -66,6 +67,31 @@ pub(super) struct UpdateLibraryItemRequest {
     id: i64,
     title: String,
     hidden: bool,
+    release_type: Option<String>,
+    year: Option<String>,
+    artist_ids: Option<Vec<i64>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct LibraryItemDetailQuery {
+    kind: String,
+    id: i64,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct SetLibraryImageRequest {
+    kind: String,
+    id: i64,
+    media_file_id: Option<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct UploadLibraryImageRequest {
+    kind: String,
+    id: i64,
+    data: String,
+    filename: String,
+    mime_type: String,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
@@ -155,10 +181,24 @@ struct ReviewDto {
     token_count: Option<i64>,
     tags: Vec<TagDto>,
     error_message: Option<String>,
+    normalized: ReviewEditDto,
     created_at: String,
     updated_at: String,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub(super) struct ReviewEditDto {
+    title: String,
+    artist: String,
+    album: String,
+    year: String,
+    track_number: String,
+    genre: String,
+    featured_artists: String,
+    release_type: String,
+    notes: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct JobDto {
     name: String,
@@ -217,13 +257,96 @@ struct MutationResponse {
 
 #[derive(Debug, Serialize, JsonSchema)]
 struct AdminSettingsDto {
-    lastfm_api_key: String,
+    values: AdminSettingsValues,
+    sources: AdminSettingsSources,
     lastfm_api_key_configured: bool,
+    lastfm_shared_secret_configured: bool,
+    lastfm_scrobbling_configured: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+struct AdminSettingsValues {
+    auth_password_enabled: bool,
+    auth_sso_enabled: bool,
+    oidc_button_text: String,
+    oidc_issuer: String,
+    oidc_client_id: String,
+    oidc_client_secret: String,
+    oidc_admin_groups: String,
+    oidc_user_groups: String,
+    swagger_enabled: bool,
+    lastfm_api_key: String,
+    lastfm_shared_secret: String,
+    agent_enabled: bool,
+    agent_inbox_dir: String,
+    agent_storage_dir: String,
+    agent_llm_url: String,
+    agent_llm_model: String,
+    agent_llm_auth: String,
+    agent_confidence_threshold: String,
+    agent_context_limit: String,
+    agent_concurrency: String,
+}
+
+#[derive(Debug, Clone, Serialize, JsonSchema)]
+struct AdminSettingsSources {
+    auth_password_enabled: &'static str,
+    auth_sso_enabled: &'static str,
+    oidc_button_text: &'static str,
+    oidc_issuer: &'static str,
+    oidc_client_id: &'static str,
+    oidc_client_secret: &'static str,
+    oidc_admin_groups: &'static str,
+    oidc_user_groups: &'static str,
+    swagger_enabled: &'static str,
+    lastfm_api_key: &'static str,
+    lastfm_shared_secret: &'static str,
+    agent_enabled: &'static str,
+    agent_inbox_dir: &'static str,
+    agent_storage_dir: &'static str,
+    agent_llm_url: &'static str,
+    agent_llm_model: &'static str,
+    agent_llm_auth: &'static str,
+    agent_confidence_threshold: &'static str,
+    agent_context_limit: &'static str,
+    agent_concurrency: &'static str,
 }
 
 #[derive(Debug, Deserialize)]
 pub(super) struct UpdateSettingsRequest {
+    auth_password_enabled: bool,
+    auth_sso_enabled: bool,
+    oidc_button_text: String,
+    oidc_issuer: String,
+    oidc_client_id: String,
+    oidc_client_secret: String,
+    oidc_admin_groups: String,
+    oidc_user_groups: String,
+    swagger_enabled: bool,
     lastfm_api_key: String,
+    lastfm_shared_secret: String,
+    agent_enabled: bool,
+    agent_inbox_dir: String,
+    agent_storage_dir: String,
+    agent_llm_url: String,
+    agent_llm_model: String,
+    agent_llm_auth: String,
+    agent_confidence_threshold: String,
+    agent_context_limit: String,
+    agent_concurrency: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AgentProbeDto {
+    status: String,
+    ok: bool,
+    model_intro: String,
+    model_name: String,
+    prompt_tokens: Option<u32>,
+    completion_tokens: Option<u32>,
+    tokens_per_sec: Option<f64>,
+    latency_ms: u64,
+    error: String,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]
@@ -255,6 +378,32 @@ struct LibraryItemDto {
     updated_at: Option<String>,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct LibraryItemDetailDto {
+    item: LibraryItemDto,
+    title: String,
+    hidden: bool,
+    release_type: Option<String>,
+    year: Option<i32>,
+    current_image_url: Option<String>,
+    selected_artist_ids: Vec<i64>,
+    artists: Vec<ArtistOptionDto>,
+    available_covers: Vec<AvailableCoverDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ArtistOptionDto {
+    id: i64,
+    name: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AvailableCoverDto {
+    media_file_id: i64,
+    release_title: String,
+    cover_url: String,
+}
+
 #[derive(Debug, sqlx::FromRow)]
 struct IdRow {
     id: i64,
@@ -454,6 +603,65 @@ pub async fn bulk_reviews(
     Json(BulkReviewsResponse { ok: true, affected }).into_response()
 }
 
+pub async fn approve_review(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    review_id: i64,
+    Json(body): Json<ReviewEditDto>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let mut review = crate::scheduler::PendingReview::get_by_id(&db, review_id)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+        .ok_or_else(|| cot::Error::internal("review not found"))?;
+    let normalized = normalized_from_review_edit(&body);
+    let result_json = serde_json::to_string(&normalized)
+        .map_err(|e| cot::Error::internal(format!("failed to serialize review fields: {e}")))?;
+    review
+        .set_result_json(&db, result_json)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let context: serde_json::Value =
+        serde_json::from_str(review.context_json_str()).unwrap_or_default();
+    let input_path = review.input_path_str().to_owned();
+    let (live_config, _) = AppConfig::load_with_db(&db).await;
+    let stats = crate::scheduler::ProcessingStats::get_by_review_id(&db, review_id)
+        .await
+        .unwrap_or(None);
+    let model_name = stats.as_ref().map(|s| s.model_name.to_string());
+
+    match crate::jobs::inbox_process::finalize_approved(
+        &db,
+        pool,
+        &live_config,
+        &input_path,
+        &normalized,
+        &context,
+        &live_config.agent_storage_dir,
+        model_name.as_deref(),
+    )
+    .await
+    {
+        Ok(()) => {
+            let _ = review.set_approved(&db).await;
+            Json(serde_json::json!({ "ok": true })).into_response()
+        }
+        Err(error) => {
+            tracing::error!(?error, "review approval failed");
+            let _ = review.set_rejected(&db).await;
+            Ok(json_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "review approval failed",
+            ))
+        }
+    }
+}
+
 pub async fn jobs(
     session: Session,
     db: Database,
@@ -474,12 +682,8 @@ pub async fn settings(session: Session, db: Database) -> cot::Result<cot::respon
     if let Err(response) = require_admin_json(&session, &db).await {
         return Ok(response);
     }
-    let (config, _) = AppConfig::load_with_db(&db).await;
-    Json(AdminSettingsDto {
-        lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
-        lastfm_api_key: config.lastfm_api_key,
-    })
-    .into_response()
+    let (config, sources) = AppConfig::load_with_db(&db).await;
+    Json(settings_dto(config, sources)).into_response()
 }
 
 pub async fn update_settings(
@@ -490,17 +694,156 @@ pub async fn update_settings(
     if let Err(response) = require_admin_json(&session, &db).await {
         return Ok(response);
     }
-    let mut entry = ConfigEntry::new(
-        "lastfm_api_key".to_string(),
-        body.lastfm_api_key.trim().to_string(),
-    );
+    let fields = [
+        (
+            "auth_password_enabled",
+            body.auth_password_enabled.to_string(),
+        ),
+        ("auth_sso_enabled", body.auth_sso_enabled.to_string()),
+        ("oidc_button_text", body.oidc_button_text.trim().to_string()),
+        ("oidc_issuer", body.oidc_issuer.trim().to_string()),
+        ("oidc_client_id", body.oidc_client_id.trim().to_string()),
+        (
+            "oidc_client_secret",
+            body.oidc_client_secret.trim().to_string(),
+        ),
+        (
+            "oidc_admin_groups",
+            body.oidc_admin_groups.trim().to_string(),
+        ),
+        ("oidc_user_groups", body.oidc_user_groups.trim().to_string()),
+        ("swagger_enabled", body.swagger_enabled.to_string()),
+        ("lastfm_api_key", body.lastfm_api_key.trim().to_string()),
+        (
+            "lastfm_shared_secret",
+            body.lastfm_shared_secret.trim().to_string(),
+        ),
+        ("agent_enabled", body.agent_enabled.to_string()),
+        ("agent_inbox_dir", body.agent_inbox_dir.trim().to_string()),
+        (
+            "agent_storage_dir",
+            body.agent_storage_dir.trim().to_string(),
+        ),
+        ("agent_llm_url", body.agent_llm_url.trim().to_string()),
+        ("agent_llm_model", body.agent_llm_model.trim().to_string()),
+        ("agent_llm_auth", body.agent_llm_auth.trim().to_string()),
+        (
+            "agent_confidence_threshold",
+            body.agent_confidence_threshold.trim().to_string(),
+        ),
+        (
+            "agent_context_limit",
+            body.agent_context_limit.trim().to_string(),
+        ),
+        (
+            "agent_concurrency",
+            body.agent_concurrency.trim().to_string(),
+        ),
+    ];
+    for (key, value) in fields {
+        let mut entry = ConfigEntry::new(key.to_string(), value);
         entry
             .save(&db)
             .await
             .map_err(|e| cot::Error::internal(e.to_string()))?;
+    }
     Json(serde_json::json!({ "ok": true })).into_response()
 }
 
+pub async fn settings_probe(
+    session: Session,
+    db: Database,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let probe = if config.agent_enabled && !config.agent_llm_url.is_empty() {
+        agent::probe_llm(
+            &config.agent_llm_url,
+            &config.agent_llm_model,
+            &config.agent_llm_auth,
+        )
+        .await
+    } else {
+        agent::AgentProbeResult::default()
+    };
+    let status = if !config.agent_enabled {
+        "disabled"
+    } else if config.agent_llm_url.is_empty() {
+        "not_configured"
+    } else if probe.ok {
+        "ok"
+    } else {
+        "error"
+    };
+    Json(AgentProbeDto {
+        status: status.to_string(),
+        ok: probe.ok,
+        model_intro: probe.model_intro,
+        model_name: probe.model_name,
+        prompt_tokens: probe.prompt_tokens,
+        completion_tokens: probe.completion_tokens,
+        tokens_per_sec: probe.tokens_per_sec,
+        latency_ms: probe.latency_ms,
+        error: probe.error,
+    })
+    .into_response()
+}
+
+fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
+    AdminSettingsDto {
+        lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
+        lastfm_shared_secret_configured: !config.lastfm_shared_secret.trim().is_empty(),
+        lastfm_scrobbling_configured: !config.lastfm_api_key.trim().is_empty()
+            && !config.lastfm_shared_secret.trim().is_empty(),
+        values: AdminSettingsValues {
+            auth_password_enabled: config.auth_password_enabled,
+            auth_sso_enabled: config.auth_sso_enabled,
+            oidc_button_text: config.oidc_button_text,
+            oidc_issuer: config.oidc_issuer,
+            oidc_client_id: config.oidc_client_id,
+            oidc_client_secret: config.oidc_client_secret,
+            oidc_admin_groups: config.oidc_admin_groups,
+            oidc_user_groups: config.oidc_user_groups,
+            swagger_enabled: config.swagger_enabled,
+            lastfm_api_key: config.lastfm_api_key,
+            lastfm_shared_secret: config.lastfm_shared_secret,
+            agent_enabled: config.agent_enabled,
+            agent_inbox_dir: config.agent_inbox_dir,
+            agent_storage_dir: config.agent_storage_dir,
+            agent_llm_url: config.agent_llm_url,
+            agent_llm_model: config.agent_llm_model,
+            agent_llm_auth: config.agent_llm_auth,
+            agent_confidence_threshold: config.agent_confidence_threshold.to_string(),
+            agent_context_limit: config.agent_context_limit.to_string(),
+            agent_concurrency: config.agent_concurrency.to_string(),
+        },
+        sources: AdminSettingsSources {
+            auth_password_enabled: sources.auth_password_enabled.code(),
+            auth_sso_enabled: sources.auth_sso_enabled.code(),
+            oidc_button_text: sources.oidc_button_text.code(),
+            oidc_issuer: sources.oidc_issuer.code(),
+            oidc_client_id: sources.oidc_client_id.code(),
+            oidc_client_secret: sources.oidc_client_secret.code(),
+            oidc_admin_groups: sources.oidc_admin_groups.code(),
+            oidc_user_groups: sources.oidc_user_groups.code(),
+            swagger_enabled: sources.swagger_enabled.code(),
+            lastfm_api_key: sources.lastfm_api_key.code(),
+            lastfm_shared_secret: sources.lastfm_shared_secret.code(),
+            agent_enabled: sources.agent_enabled.code(),
+            agent_inbox_dir: sources.agent_inbox_dir.code(),
+            agent_storage_dir: sources.agent_storage_dir.code(),
+            agent_llm_url: sources.agent_llm_url.code(),
+            agent_llm_model: sources.agent_llm_model.code(),
+            agent_llm_auth: sources.agent_llm_auth.code(),
+            agent_confidence_threshold: sources.agent_confidence_threshold.code(),
+            agent_context_limit: sources.agent_context_limit.code(),
+            agent_concurrency: sources.agent_concurrency.code(),
+        },
+    }
+}
+
 pub async fn run_job(
     session: Session,
     db: Database,
@@ -625,6 +968,28 @@ pub async fn library(
     Json(page).into_response()
 }
 
+pub async fn library_item_detail(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    query: LibraryItemDetailQuery,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(query.kind.as_str()));
+    let Some(item) = fetch_library_item(pool, &kind, query.id)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    };
+    let detail = load_library_item_detail(pool, &kind, item)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(detail).into_response()
+}
+
 pub async fn update_library_item(
     session: Session,
     db: Database,
@@ -658,13 +1023,27 @@ pub async fn update_library_item(
             .await
         }
         "releases" => {
+            let release_type = body
+                .release_type
+                .as_deref()
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .unwrap_or("album");
+            let year = body
+                .year
+                .as_deref()
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .and_then(|value| value.parse::<i32>().ok());
             sqlx::query(
                 "UPDATE furumusic__release \
-                 SET title = $1, title_sort = $2, is_hidden = $3, updated_at = $4 \
-                 WHERE id = $5",
+                 SET title = $1, title_sort = $2, release_type = $3, year = $4, is_hidden = $5, updated_at = $6 \
+                 WHERE id = $7",
             )
             .bind(title)
             .bind(normalize_name(title))
+            .bind(release_type)
+            .bind(year)
             .bind(body.hidden)
             .bind(&now)
             .bind(body.id)
@@ -692,6 +1071,28 @@ pub async fn update_library_item(
     if affected == 0 {
         return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
     }
+    if kind == "releases" {
+        if let Some(mut artist_ids) = body.artist_ids {
+            let mut seen_artist_ids = HashSet::new();
+            artist_ids.retain(|id| *id > 0 && seen_artist_ids.insert(*id));
+            sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
+                .bind(body.id)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
+            for (position, artist_id) in artist_ids.iter().enumerate() {
+                sqlx::query(
+                    "INSERT INTO furumusic__release_artist (release_id, artist_id, position) VALUES ($1, $2, $3)",
+                )
+                .bind(body.id)
+                .bind(*artist_id)
+                .bind(position as i32)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
+            }
+        }
+    }
 
     let Some(item) = fetch_library_item(pool, &kind, body.id)
         .await
@@ -703,6 +1104,128 @@ pub async fn update_library_item(
     Json(item).into_response()
 }
 
+pub async fn set_library_item_image(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<SetLibraryImageRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(body.kind.as_str()));
+    if kind != "artists" && kind != "releases" {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
+    }
+    if let Some(fid) = body.media_file_id {
+        let exists: Option<i64> = sqlx::query_scalar(
+            "SELECT id FROM furumusic__media_file WHERE id = $1 AND file_type = 'cover_art'",
+        )
+        .bind(fid)
+        .fetch_optional(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        if exists.is_none() {
+            return Ok(json_error(StatusCode::NOT_FOUND, "image not found"));
+        }
+    }
+    let now = now_string();
+    let result = if kind == "releases" {
+        sqlx::query(
+            "UPDATE furumusic__release SET cover_file_id = $1, updated_at = $2 WHERE id = $3",
+        )
+        .bind(body.media_file_id)
+        .bind(&now)
+        .bind(body.id)
+        .execute(pool)
+        .await
+    } else {
+        sqlx::query(
+            "UPDATE furumusic__artist SET image_file_id = $1, updated_at = $2 WHERE id = $3",
+        )
+        .bind(body.media_file_id)
+        .bind(&now)
+        .bind(body.id)
+        .execute(pool)
+        .await
+    }
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    if result.rows_affected() == 0 {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    }
+    Json(serde_json::json!({ "ok": true })).into_response()
+}
+
+pub async fn upload_library_item_image(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<UploadLibraryImageRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(body.kind.as_str()));
+    if kind != "artists" && kind != "releases" {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
+    }
+    let storage_dir = AppConfig::load_with_db(&db).await.0.agent_storage_dir;
+    if storage_dir.trim().is_empty() {
+        return Err(cot::Error::internal("agent_storage_dir is not configured"));
+    }
+    use base64::Engine;
+    let image_data = base64::engine::general_purpose::STANDARD
+        .decode(body.data.trim())
+        .map_err(|e| cot::Error::internal(format!("invalid base64: {e}")))?;
+    if image_data.is_empty() {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "image is empty"));
+    }
+    let title: Option<String> = if kind == "releases" {
+        sqlx::query_scalar("SELECT title::text FROM furumusic__release WHERE id = $1")
+    } else {
+        sqlx::query_scalar("SELECT name::text FROM furumusic__artist WHERE id = $1")
+    }
+    .bind(body.id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(title) = title else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    };
+    let cover = crate::agent::cover_art::CoverImage {
+        data: image_data,
+        mime_type: body.mime_type,
+        source: crate::agent::cover_art::CoverSource::FolderFile(std::path::PathBuf::from(
+            body.filename,
+        )),
+    };
+    let media_file_id = crate::agent::cover_art::save_cover_to_storage(
+        &db,
+        pool,
+        &storage_dir,
+        &title,
+        if kind == "artists" {
+            "__artist_image__"
+        } else {
+            "__release_cover__"
+        },
+        &cover,
+    )
+    .await
+    .map_err(|e| cot::Error::internal(format!("failed to save image: {e}")))?;
+    set_library_item_image(
+        session,
+        db,
+        pool,
+        Json(SetLibraryImageRequest {
+            kind,
+            id: body.id,
+            media_file_id: Some(media_file_id),
+        }),
+    )
+    .await
+}
+
 pub async fn bulk_library(
     session: Session,
     db: Database,
@@ -1004,6 +1527,11 @@ fn review_dto(
         .as_deref()
         .and_then(|json| serde_json::from_str::<serde_json::Value>(json).ok())
         .and_then(|value| value.get("confidence").and_then(|v| v.as_f64()));
+    let normalized = row
+        .result_json
+        .as_deref()
+        .map(review_edit_dto_from_json)
+        .unwrap_or_default();
 
     ReviewDto {
         id: row.id,
@@ -1019,11 +1547,72 @@ fn review_dto(
         token_count: stat.map(|s| s.prompt_tokens + s.completion_tokens),
         tags,
         error_message: row.error_message,
+        normalized,
         created_at: row.created_at,
         updated_at: row.updated_at,
     }
 }
 
+fn review_edit_dto_from_json(result_json: &str) -> ReviewEditDto {
+    let Ok(normalized) = serde_json::from_str::<crate::agent::dto::NormalizedFields>(result_json)
+    else {
+        return ReviewEditDto::default();
+    };
+    ReviewEditDto {
+        title: normalized.title.unwrap_or_default(),
+        artist: normalized.artist.unwrap_or_default(),
+        album: normalized.album.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.unwrap_or_default(),
+        featured_artists: normalized.featured_artists.join(", "),
+        release_type: normalized
+            .release_type
+            .unwrap_or_else(|| "album".to_owned()),
+        notes: normalized.notes.unwrap_or_default(),
+    }
+}
+
+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 normalized_from_review_edit(edit: &ReviewEditDto) -> crate::agent::dto::NormalizedFields {
+    crate::agent::dto::NormalizedFields {
+        title: optional_trimmed(&edit.title),
+        artist: optional_trimmed(&edit.artist),
+        album: optional_trimmed(&edit.album),
+        year: parse_optional_i32(&edit.year),
+        track_number: parse_optional_i32(&edit.track_number),
+        genre: optional_trimmed(&edit.genre),
+        featured_artists: parse_featured_artists(&edit.featured_artists),
+        release_type: optional_trimmed(&edit.release_type).or_else(|| Some("album".to_owned())),
+        confidence: Some(1.0),
+        notes: optional_trimmed(&edit.notes),
+    }
+}
+
 fn media_tags(row: &ReviewMediaRow) -> Vec<TagDto> {
     let mut tags = Vec::new();
     if let Some(format) = row.audio_format.as_deref().filter(|s| !s.trim().is_empty()) {
@@ -1275,6 +1864,103 @@ async fn fetch_library_item(
     Ok(row.map(|row| library_item_dto(kind, row)))
 }
 
+async fn load_library_item_detail(
+    pool: &PgPool,
+    kind: &str,
+    item: LibraryItemDto,
+) -> anyhow::Result<LibraryItemDetailDto> {
+    let mut detail = LibraryItemDetailDto {
+        title: item.title.clone(),
+        hidden: item.is_hidden.unwrap_or(false),
+        release_type: None,
+        year: None,
+        current_image_url: None,
+        selected_artist_ids: Vec::new(),
+        artists: Vec::new(),
+        available_covers: Vec::new(),
+        item,
+    };
+
+    match kind {
+        "artists" => {
+            let image_file_id: Option<i64> =
+                sqlx::query_scalar("SELECT image_file_id FROM furumusic__artist WHERE id = $1")
+                    .bind(detail.item.id)
+                    .fetch_optional(pool)
+                    .await?
+                    .flatten();
+            detail.current_image_url =
+                image_file_id.map(|id| format!("/api/player/cover/{id}/large"));
+            detail.available_covers = artist_available_covers(pool, detail.item.id).await?;
+        }
+        "releases" => {
+            let row: Option<(Option<String>, Option<i32>, Option<i64>)> = sqlx::query_as(
+                "SELECT release_type::text, year, cover_file_id FROM furumusic__release WHERE id = $1",
+            )
+            .bind(detail.item.id)
+            .fetch_optional(pool)
+            .await?;
+            if let Some((release_type, year, cover_file_id)) = row {
+                detail.release_type = release_type;
+                detail.year = year;
+                detail.current_image_url =
+                    cover_file_id.map(|id| format!("/api/player/cover/{id}/large"));
+            }
+            detail.selected_artist_ids = sqlx::query_as::<_, IdRow>(
+                "SELECT artist_id AS id FROM furumusic__release_artist WHERE release_id = $1 ORDER BY position, artist_id",
+            )
+            .bind(detail.item.id)
+            .fetch_all(pool)
+            .await?
+            .into_iter()
+            .map(|row| row.id)
+            .collect();
+            detail.artists = load_artist_options(pool).await?;
+        }
+        _ => {}
+    }
+
+    Ok(detail)
+}
+
+async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDto>> {
+    let rows = sqlx::query_as::<_, (i64, String)>(
+        "SELECT id, name::text FROM furumusic__artist ORDER BY name ASC",
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(id, name)| ArtistOptionDto { id, name })
+        .collect())
+}
+
+async fn artist_available_covers(
+    pool: &PgPool,
+    artist_id: i64,
+) -> anyhow::Result<Vec<AvailableCoverDto>> {
+    let rows = sqlx::query_as::<_, (i64, String)>(
+        "SELECT DISTINCT r.cover_file_id AS media_file_id, r.title::text AS release_title \
+         FROM furumusic__release r \
+         LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+         LEFT JOIN furumusic__track t ON t.release_id = r.id \
+         LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+         WHERE r.cover_file_id IS NOT NULL AND (ra.artist_id = $1 OR ta.artist_id = $1) \
+         ORDER BY r.title::text ASC",
+    )
+    .bind(artist_id)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(media_file_id, release_title)| AvailableCoverDto {
+            media_file_id,
+            release_title,
+            cover_url: format!("/api/player/cover/{media_file_id}/medium"),
+        })
+        .collect())
+}
+
 async fn library_ids_by_filter(
     pool: &PgPool,
     kind: &str,

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"),
                 });
             }
         }
@@ -1794,12 +1818,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 +1946,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,23 +1971,28 @@ 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 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;
+    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 normalized: crate::agent::dto::NormalizedFields = serde_json::from_str(&result_str)
-        .map_err(|e| cot::Error::internal(format!("invalid result_json: {e}")))?;
+    };
+    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();
 
     let context: serde_json::Value = serde_json::from_str(&context_str).unwrap_or_default();
 

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.
@@ -328,6 +331,23 @@ pub async fn save_cover_to_storage(
     .await?;
 
     if let Some((id,)) = existing {
+        if let Some((file_path,)) = sqlx::query_as::<_, (String,)>(
+            "SELECT file_path FROM furumusic__media_file WHERE id = $1",
+        )
+        .bind(id)
+        .fetch_optional(pool)
+        .await?
+        {
+            let path = PathBuf::from(&file_path);
+            let path = if path.is_absolute() {
+                path
+            } else {
+                Path::new(storage_dir).join(path)
+            };
+            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);
     }
 
@@ -374,6 +394,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,102 @@
+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 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);
+        encoder.encode(
+            &resized,
+            resized.width(),
+            resized.height(),
+            image::ExtendedColorType::Rgb8,
+        )?;
+        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/config.rs

@@ -134,6 +134,7 @@ pub struct ConfigSources {
     pub agent_context_limit: ConfigSource,
     pub agent_concurrency: ConfigSource,
     pub lastfm_api_key: ConfigSource,
+    pub lastfm_shared_secret: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -160,6 +161,7 @@ impl Default for ConfigSources {
             agent_context_limit: ConfigSource::Default,
             agent_concurrency: ConfigSource::Default,
             lastfm_api_key: ConfigSource::Default,
+            lastfm_shared_secret: ConfigSource::Default,
         }
     }
 }
@@ -266,6 +268,8 @@ pub struct AppConfig {
     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 {
@@ -292,6 +296,7 @@ impl Default for AppConfig {
             agent_context_limit: 8192,
             agent_concurrency: 2,
             lastfm_api_key: String::new(),
+            lastfm_shared_secret: String::new(),
         }
     }
 }
@@ -319,6 +324,7 @@ impl_env_overrides!(
     agent_context_limit,
     agent_concurrency,
     lastfm_api_key,
+    lastfm_shared_secret,
 );
 
 impl AppConfig {
@@ -403,6 +409,7 @@ impl AppConfig {
         apply_db_field!(agent_context_limit);
         apply_db_field!(agent_concurrency);
         apply_db_field!(lastfm_api_key);
+        apply_db_field!(lastfm_shared_secret);
     }
 }
 

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. Попробуйте ещё раз.";
@@ -268,6 +272,7 @@ translations! {
     // Player UI
     player_library:          "Library"                         , "Библиотека";
     player_artists:          "Artists"                         , "Артисты";
+    player_release:          "Release"                         , "Релиз";
     player_releases:         "Releases"                        , "Релизы";
     player_tracks:           "Tracks"                          , "Треки";
     player_title:            "Title"                           , "Название";
@@ -326,6 +331,14 @@ translations! {
     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_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_like:             "Like"                            , "Лайк";
     player_add_to_queue:     "Add to 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/artwork_backfill.rs

@@ -0,0 +1,963 @@
+use std::path::{Path, PathBuf};
+
+use reqwest::Client;
+use serde::Deserialize;
+
+use crate::agent::cover_art::{self, CoverImage, CoverSource};
+use crate::agent::cover_variants;
+use crate::scheduler::{Job, JobContext, JobLog};
+
+pub struct ArtworkBackfillJob;
+
+const LASTFM_REQUEST_DELAY: std::time::Duration = std::time::Duration::from_millis(1200);
+const MAX_LASTFM_RELEASE_LOOKUPS: i64 = 200;
+const MAX_LASTFM_ARTIST_LOOKUPS: i64 = 200;
+
+#[derive(Debug, sqlx::FromRow)]
+struct ReleaseCandidate {
+    id: i64,
+    title: String,
+    artist_name: Option<String>,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct ArtistCandidate {
+    id: i64,
+    name: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmAlbumResponse {
+    album: Option<LastfmImageContainer>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmArtistResponse {
+    artist: Option<LastfmImageContainer>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTopAlbumsResponse {
+    topalbums: Option<LastfmTopAlbums>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTopAlbums {
+    album: Option<OneOrMany<LastfmImageContainer>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum OneOrMany<T> {
+    One(T),
+    Many(Vec<T>),
+}
+
+impl<T> OneOrMany<T> {
+    fn into_vec(self) -> Vec<T> {
+        match self {
+            Self::One(value) => vec![value],
+            Self::Many(values) => values,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmImageContainer {
+    image: Option<Vec<LastfmImage>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmImage {
+    #[serde(rename = "#text")]
+    url: String,
+    size: String,
+}
+
+#[derive(Default)]
+struct ArtworkStats {
+    release_local_assigned: u64,
+    release_lastfm_assigned: u64,
+    release_lastfm_not_found: u64,
+    release_skipped_no_audio: u64,
+    artist_lastfm_assigned: u64,
+    artist_lastfm_not_found: u64,
+    variants_created: usize,
+    variants_unchanged: usize,
+    variants_missing_original: usize,
+    failed: u64,
+}
+
+#[async_trait::async_trait]
+impl Job for ArtworkBackfillJob {
+    fn name(&self) -> &'static str {
+        "artwork_backfill"
+    }
+
+    fn description(&self) -> &'static str {
+        "Backfill and repair release, track, and artist artwork"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Nightly, after inbox processing has had a chance to import new files.
+        "0 30 3 * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        let storage_dir = ctx.config.agent_storage_dir.trim();
+        if storage_dir.is_empty() {
+            log.warn("agent_storage_dir is not configured, skipping artwork backfill");
+            return Ok(());
+        }
+
+        let client = Client::builder()
+            .user_agent(format!(
+                "furumusic-artwork-backfill/{}",
+                env!("CARGO_PKG_VERSION")
+            ))
+            .timeout(std::time::Duration::from_secs(20))
+            .build()?;
+        let mut stats = ArtworkStats::default();
+
+        backfill_release_local(ctx, log, storage_dir, &mut stats).await?;
+
+        let api_key = ctx.config.lastfm_api_key.trim();
+        if api_key.is_empty() {
+            log.warn("lastfm_api_key is not configured; skipping Last.fm artwork fallback");
+        } else {
+            backfill_release_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?;
+            backfill_artist_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?;
+        }
+
+        repair_cover_variants(ctx, log, storage_dir, &mut stats).await?;
+
+        log.info(&format!(
+            "Artwork backfill complete: release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}",
+            stats.release_local_assigned,
+            stats.release_lastfm_assigned,
+            stats.release_lastfm_not_found,
+            stats.release_skipped_no_audio,
+            stats.artist_lastfm_assigned,
+            stats.artist_lastfm_not_found,
+            stats.variants_created,
+            stats.variants_unchanged,
+            stats.variants_missing_original,
+            stats.failed
+        ));
+        Ok(())
+    }
+}
+
+async fn backfill_release_local(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let releases = sqlx::query_as::<_, ReleaseCandidate>(
+        r#"SELECT r.id,
+                  r.title::text AS title,
+                  (
+                    SELECT a.name::text
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__artist a ON a.id = ra.artist_id
+                     WHERE ra.release_id = r.id
+                     ORDER BY ra.position
+                     LIMIT 1
+                  ) AS artist_name
+             FROM furumusic__release r
+            WHERE r.cover_file_id IS NULL
+              AND r.is_hidden = false
+            ORDER BY r.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if releases.is_empty() {
+        log.info("Release local artwork pass: all visible releases already have covers");
+        return Ok(());
+    }
+    log.info(&format!(
+        "Release local artwork pass: checking {} release(s) without covers",
+        releases.len()
+    ));
+
+    for (index, release) in releases.iter().enumerate() {
+        log.info(&format!(
+            "Release local artwork {}/{}: release {} \"{}\"",
+            index + 1,
+            releases.len(),
+            release.id,
+            release.title
+        ));
+
+        let audio_paths: Vec<String> = sqlx::query_scalar(
+            r#"SELECT mf.file_path::text
+                 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'
+                ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, t.id"#,
+        )
+        .bind(release.id)
+        .fetch_all(&ctx.pool)
+        .await
+        .unwrap_or_default();
+
+        if audio_paths.is_empty() {
+            stats.release_skipped_no_audio += 1;
+            log.warn(&format!(
+                "Release {} \"{}\": no audio files found for local cover extraction",
+                release.id, release.title
+            ));
+            continue;
+        }
+
+        let audio_files: Vec<PathBuf> = audio_paths
+            .iter()
+            .map(|path| resolve_media_path(storage_dir, path))
+            .collect();
+        let Some(folder) = audio_files.first().and_then(|path| path.parent()) else {
+            stats.failed += 1;
+            log.warn(&format!(
+                "Release {} \"{}\": could not determine audio folder",
+                release.id, release.title
+            ));
+            continue;
+        };
+
+        let Some(cover) = cover_art::find_best_cover(folder, &audio_files).await else {
+            continue;
+        };
+
+        let source_desc = cover_source_description(&cover.source);
+        let artist_name = release.artist_name.as_deref().unwrap_or("Unknown Artist");
+        match cover_art::save_cover_to_storage(
+            &ctx.db,
+            &ctx.pool,
+            storage_dir,
+            artist_name,
+            &release.title,
+            &cover,
+        )
+        .await
+        {
+            Ok(cover_file_id) => {
+                cover_art::assign_cover_to_release(&ctx.pool, release.id, cover_file_id).await?;
+                stats.release_local_assigned += 1;
+                log.info(&format!(
+                    "Release {} \"{}\": assigned local cover from {source_desc}",
+                    release.id, release.title
+                ));
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Release {} \"{}\": failed to save local cover: {err}",
+                    release.id, release.title
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn backfill_release_lastfm(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    api_key: &str,
+    client: &Client,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let failed_cutoff = cutoff_iso(1);
+    let not_found_cutoff = cutoff_iso(30);
+    let releases = sqlx::query_as::<_, ReleaseCandidate>(
+        r#"SELECT r.id,
+                  r.title::text AS title,
+                  COALESCE(
+                    (
+                      SELECT a.name::text
+                        FROM furumusic__release_artist ra
+                        JOIN furumusic__artist a ON a.id = ra.artist_id
+                       WHERE ra.release_id = r.id
+                       ORDER BY ra.position
+                       LIMIT 1
+                    ),
+                    (
+                      SELECT a.name::text
+                        FROM furumusic__track t
+                        JOIN furumusic__track_artist ta ON ta.track_id = t.id
+                        JOIN furumusic__artist a ON a.id = ta.artist_id
+                       WHERE t.release_id = r.id AND ta.role <> 'featuring'
+                       ORDER BY t.disc_number NULLS LAST, t.track_number NULLS LAST, ta.position
+                       LIMIT 1
+                    )
+                  ) AS artist_name
+             FROM furumusic__release r
+             LEFT JOIN furumusic__artwork_lookup_state s
+               ON s.entity_kind = 'release'
+              AND s.entity_id = r.id
+              AND s.source = 'lastfm'
+            WHERE r.cover_file_id IS NULL
+              AND r.is_hidden = false
+              AND (
+                    s.entity_id IS NULL
+                 OR s.status = 'failed' AND s.last_attempt_at < $1
+                 OR s.status = 'not_found' AND (s.attempt_count < 3 OR s.last_attempt_at < $2)
+                 OR s.status = 'found' AND s.last_attempt_at < $1
+              )
+            ORDER BY s.last_attempt_at NULLS FIRST, r.id
+            LIMIT $3"#,
+    )
+    .bind(&failed_cutoff)
+    .bind(&not_found_cutoff)
+    .bind(MAX_LASTFM_RELEASE_LOOKUPS)
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if releases.is_empty() {
+        log.info("Release Last.fm artwork pass: no eligible releases need lookup");
+        return Ok(());
+    }
+    log.info(&format!(
+        "Release Last.fm artwork pass: looking up {} release(s)",
+        releases.len()
+    ));
+
+    for (index, release) in releases.iter().enumerate() {
+        let Some(artist_name) = release
+            .artist_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+        else {
+            stats.release_lastfm_not_found += 1;
+            record_lookup_state(
+                &ctx.pool,
+                "release",
+                release.id,
+                "not_found",
+                Some("release has no primary artist for Last.fm lookup"),
+                None,
+            )
+            .await?;
+            log.warn(&format!(
+                "Release {} \"{}\": no primary artist for Last.fm lookup",
+                release.id, release.title
+            ));
+            continue;
+        };
+
+        log.info(&format!(
+            "Release Last.fm artwork {}/{}: release {} \"{}\" by \"{}\"",
+            index + 1,
+            releases.len(),
+            release.id,
+            release.title,
+            artist_name
+        ));
+
+        match fetch_lastfm_album_image(client, api_key, artist_name, &release.title).await {
+            Ok(Some(image_url)) => match download_remote_cover(client, &image_url).await {
+                Ok(cover) => match cover_art::save_cover_to_storage(
+                    &ctx.db,
+                    &ctx.pool,
+                    storage_dir,
+                    artist_name,
+                    &release.title,
+                    &cover,
+                )
+                .await
+                {
+                    Ok(cover_file_id) => {
+                        cover_art::assign_cover_to_release(&ctx.pool, release.id, cover_file_id)
+                            .await?;
+                        record_lookup_state(
+                            &ctx.pool,
+                            "release",
+                            release.id,
+                            "found",
+                            None,
+                            Some(&image_url),
+                        )
+                        .await?;
+                        stats.release_lastfm_assigned += 1;
+                        log.info(&format!(
+                            "Release {} \"{}\": assigned Last.fm cover",
+                            release.id, release.title
+                        ));
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        record_lookup_state(
+                            &ctx.pool,
+                            "release",
+                            release.id,
+                            "failed",
+                            Some(&err.to_string()),
+                            Some(&image_url),
+                        )
+                        .await?;
+                        log.warn(&format!(
+                            "Release {} \"{}\": failed to save Last.fm cover: {err}",
+                            release.id, release.title
+                        ));
+                    }
+                },
+                Err(err) => {
+                    stats.failed += 1;
+                    record_lookup_state(
+                        &ctx.pool,
+                        "release",
+                        release.id,
+                        "failed",
+                        Some(&err.to_string()),
+                        Some(&image_url),
+                    )
+                    .await?;
+                    log.warn(&format!(
+                        "Release {} \"{}\": failed to download Last.fm cover: {err}",
+                        release.id, release.title
+                    ));
+                }
+            },
+            Ok(None) => {
+                stats.release_lastfm_not_found += 1;
+                record_lookup_state(&ctx.pool, "release", release.id, "not_found", None, None)
+                    .await?;
+                log.info(&format!(
+                    "Release {} \"{}\": Last.fm did not return artwork",
+                    release.id, release.title
+                ));
+            }
+            Err(err) if err.to_string().contains("rate limit") => {
+                stats.failed += 1;
+                record_lookup_state(
+                    &ctx.pool,
+                    "release",
+                    release.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.error(
+                    "Last.fm rate limit exceeded during release artwork lookup; stopping this pass",
+                );
+                break;
+            }
+            Err(err) => {
+                stats.failed += 1;
+                record_lookup_state(
+                    &ctx.pool,
+                    "release",
+                    release.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.warn(&format!(
+                    "Release {} \"{}\": Last.fm artwork lookup failed: {err}",
+                    release.id, release.title
+                ));
+            }
+        }
+
+        tokio::time::sleep(LASTFM_REQUEST_DELAY).await;
+    }
+
+    Ok(())
+}
+
+async fn backfill_artist_lastfm(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    api_key: &str,
+    client: &Client,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let failed_cutoff = cutoff_iso(1);
+    let not_found_cutoff = cutoff_iso(30);
+    let artists = sqlx::query_as::<_, ArtistCandidate>(
+        r#"SELECT a.id, a.name::text AS name
+             FROM furumusic__artist a
+             LEFT JOIN furumusic__artwork_lookup_state s
+               ON s.entity_kind = 'artist'
+              AND s.entity_id = a.id
+              AND s.source = 'lastfm'
+            WHERE a.image_file_id IS NULL
+              AND a.is_hidden = false
+              AND (
+                    s.entity_id IS NULL
+                 OR s.status = 'failed' AND s.last_attempt_at < $1
+                 OR s.status = 'not_found' AND (s.attempt_count < 3 OR s.last_attempt_at < $2)
+                 OR s.status = 'found' AND s.last_attempt_at < $1
+              )
+            ORDER BY s.last_attempt_at NULLS FIRST, a.id
+            LIMIT $3"#,
+    )
+    .bind(&failed_cutoff)
+    .bind(&not_found_cutoff)
+    .bind(MAX_LASTFM_ARTIST_LOOKUPS)
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if artists.is_empty() {
+        log.info("Artist Last.fm artwork pass: no eligible artists need lookup");
+        return Ok(());
+    }
+    log.info(&format!(
+        "Artist Last.fm artwork pass: looking up {} artist(s)",
+        artists.len()
+    ));
+
+    for (index, artist) in artists.iter().enumerate() {
+        log.info(&format!(
+            "Artist Last.fm artwork {}/{}: artist {} \"{}\"",
+            index + 1,
+            artists.len(),
+            artist.id,
+            artist.name
+        ));
+
+        match fetch_lastfm_artist_image(client, api_key, &artist.name).await {
+            Ok(Some(image_url)) => match download_remote_cover(client, &image_url).await {
+                Ok(cover) => match cover_art::save_cover_to_storage(
+                    &ctx.db,
+                    &ctx.pool,
+                    storage_dir,
+                    &artist.name,
+                    "__artist_image__",
+                    &cover,
+                )
+                .await
+                {
+                    Ok(image_file_id) => {
+                        sqlx::query(
+                            r#"UPDATE furumusic__artist
+                                      SET image_file_id = $1,
+                                          updated_at = $3
+                                    WHERE id = $2
+                                      AND image_file_id IS NULL"#,
+                        )
+                        .bind(image_file_id)
+                        .bind(artist.id)
+                        .bind(now_iso())
+                        .execute(&ctx.pool)
+                        .await?;
+                        record_lookup_state(
+                            &ctx.pool,
+                            "artist",
+                            artist.id,
+                            "found",
+                            None,
+                            Some(&image_url),
+                        )
+                        .await?;
+                        stats.artist_lastfm_assigned += 1;
+                        log.info(&format!(
+                            "Artist {} \"{}\": assigned Last.fm image",
+                            artist.id, artist.name
+                        ));
+                    }
+                    Err(err) => {
+                        stats.failed += 1;
+                        record_lookup_state(
+                            &ctx.pool,
+                            "artist",
+                            artist.id,
+                            "failed",
+                            Some(&err.to_string()),
+                            Some(&image_url),
+                        )
+                        .await?;
+                        log.warn(&format!(
+                            "Artist {} \"{}\": failed to save Last.fm image: {err}",
+                            artist.id, artist.name
+                        ));
+                    }
+                },
+                Err(err) => {
+                    stats.failed += 1;
+                    record_lookup_state(
+                        &ctx.pool,
+                        "artist",
+                        artist.id,
+                        "failed",
+                        Some(&err.to_string()),
+                        Some(&image_url),
+                    )
+                    .await?;
+                    log.warn(&format!(
+                        "Artist {} \"{}\": failed to download Last.fm image: {err}",
+                        artist.id, artist.name
+                    ));
+                }
+            },
+            Ok(None) => {
+                stats.artist_lastfm_not_found += 1;
+                record_lookup_state(&ctx.pool, "artist", artist.id, "not_found", None, None)
+                    .await?;
+                log.info(&format!(
+                    "Artist {} \"{}\": Last.fm did not return artwork",
+                    artist.id, artist.name
+                ));
+            }
+            Err(err) if err.to_string().contains("rate limit") => {
+                stats.failed += 1;
+                record_lookup_state(
+                    &ctx.pool,
+                    "artist",
+                    artist.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.error(
+                    "Last.fm rate limit exceeded during artist artwork lookup; stopping this pass",
+                );
+                break;
+            }
+            Err(err) => {
+                stats.failed += 1;
+                record_lookup_state(
+                    &ctx.pool,
+                    "artist",
+                    artist.id,
+                    "failed",
+                    Some(&err.to_string()),
+                    None,
+                )
+                .await?;
+                log.warn(&format!(
+                    "Artist {} \"{}\": Last.fm artwork lookup failed: {err}",
+                    artist.id, artist.name
+                ));
+            }
+        }
+
+        tokio::time::sleep(LASTFM_REQUEST_DELAY).await;
+    }
+
+    Ok(())
+}
+
+async fn repair_cover_variants(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let rows: Vec<(i64, String)> = sqlx::query_as(
+        "SELECT id, file_path FROM furumusic__media_file WHERE file_type = 'cover_art' ORDER BY id",
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if rows.is_empty() {
+        log.info("Cover variant pass: no cover art media files found");
+        return Ok(());
+    }
+    log.info(&format!(
+        "Cover variant pass: checking {} cover art media file(s)",
+        rows.len()
+    ));
+
+    for (media_file_id, file_path) in rows {
+        let path = resolve_media_path(storage_dir, &file_path);
+        if !path.exists() {
+            stats.variants_missing_original += 1;
+            log.warn(&format!(
+                "Media file {media_file_id}: original cover not found at {}",
+                path.display()
+            ));
+            continue;
+        }
+
+        match cover_variants::ensure_cover_variants(&path).await {
+            Ok(0) => stats.variants_unchanged += 1,
+            Ok(count) => {
+                stats.variants_created += count;
+                log.info(&format!(
+                    "Media file {media_file_id}: created {count} variant(s)"
+                ));
+            }
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Media file {media_file_id}: failed to create variants: {err}"
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn fetch_lastfm_album_image(
+    client: &Client,
+    api_key: &str,
+    artist: &str,
+    album: &str,
+) -> anyhow::Result<Option<String>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(&[
+            ("method", "album.getInfo"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("album", album),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ])
+        .send()
+        .await?;
+    let body = response.text().await?;
+    let parsed: LastfmAlbumResponse = serde_json::from_str(&body)?;
+    if let Some(code) = parsed.error {
+        if code == 6 || code == 7 {
+            return Ok(None);
+        }
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            parsed.message.unwrap_or_default()
+        );
+    }
+    Ok(parsed
+        .album
+        .and_then(|album| choose_best_image(album.image)))
+}
+
+async fn fetch_lastfm_artist_image(
+    client: &Client,
+    api_key: &str,
+    artist: &str,
+) -> anyhow::Result<Option<String>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(&[
+            ("method", "artist.getInfo"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("autocorrect", "1"),
+            ("format", "json"),
+        ])
+        .send()
+        .await?;
+    let body = response.text().await?;
+    let parsed: LastfmArtistResponse = serde_json::from_str(&body)?;
+    if let Some(code) = parsed.error {
+        if code == 6 || code == 7 {
+            return Ok(None);
+        }
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            parsed.message.unwrap_or_default()
+        );
+    }
+    if let Some(url) = parsed
+        .artist
+        .and_then(|artist| choose_best_image(artist.image))
+    {
+        return Ok(Some(url));
+    }
+
+    fetch_lastfm_artist_top_album_image(client, api_key, artist).await
+}
+
+async fn fetch_lastfm_artist_top_album_image(
+    client: &Client,
+    api_key: &str,
+    artist: &str,
+) -> anyhow::Result<Option<String>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(&[
+            ("method", "artist.getTopAlbums"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("autocorrect", "1"),
+            ("limit", "10"),
+            ("format", "json"),
+        ])
+        .send()
+        .await?;
+    let body = response.text().await?;
+    let parsed: LastfmTopAlbumsResponse = serde_json::from_str(&body)?;
+    if let Some(code) = parsed.error {
+        if code == 6 || code == 7 {
+            return Ok(None);
+        }
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            parsed.message.unwrap_or_default()
+        );
+    }
+
+    let albums = parsed
+        .topalbums
+        .and_then(|topalbums| topalbums.album)
+        .map(OneOrMany::into_vec)
+        .unwrap_or_default();
+    Ok(albums
+        .into_iter()
+        .filter_map(|album| choose_best_image(album.image))
+        .next())
+}
+
+fn choose_best_image(images: Option<Vec<LastfmImage>>) -> Option<String> {
+    let mut images = images.unwrap_or_default();
+    images.sort_by_key(|image| image_size_rank(&image.size));
+    images
+        .into_iter()
+        .rev()
+        .map(|image| image.url.trim().to_string())
+        .find(|url| is_usable_lastfm_image(url))
+}
+
+fn image_size_rank(size: &str) -> u8 {
+    match size {
+        "mega" => 5,
+        "extralarge" => 4,
+        "large" => 3,
+        "medium" => 2,
+        "small" => 1,
+        _ => 0,
+    }
+}
+
+fn is_usable_lastfm_image(url: &str) -> bool {
+    let value = url.trim();
+    !value.is_empty()
+        && !value.contains("2a96cbd8b46e442fc41c2b86b821562f")
+        && !value.contains("default_")
+}
+
+async fn download_remote_cover(client: &Client, url: &str) -> anyhow::Result<CoverImage> {
+    let response = client.get(url).send().await?;
+    if !response.status().is_success() {
+        anyhow::bail!("image download failed with HTTP {}", response.status());
+    }
+    let header_mime = response
+        .headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .and_then(normalize_image_mime);
+    let data = response.bytes().await?.to_vec();
+    if data.is_empty() {
+        anyhow::bail!("downloaded image is empty");
+    }
+    let mime_type = header_mime
+        .or_else(|| guess_image_mime(&data))
+        .ok_or_else(|| anyhow::anyhow!("downloaded file is not a supported image"))?;
+    Ok(CoverImage {
+        data,
+        mime_type,
+        source: CoverSource::Remote(url.to_string()),
+    })
+}
+
+fn normalize_image_mime(value: &str) -> Option<String> {
+    let mime = value.split(';').next()?.trim().to_ascii_lowercase();
+    match mime.as_str() {
+        "image/jpeg" | "image/jpg" => Some("image/jpeg".to_string()),
+        "image/png" => Some("image/png".to_string()),
+        "image/webp" => Some("image/webp".to_string()),
+        "image/gif" => Some("image/gif".to_string()),
+        "image/bmp" => Some("image/bmp".to_string()),
+        _ => None,
+    }
+}
+
+fn guess_image_mime(data: &[u8]) -> Option<String> {
+    if data.starts_with(&[0xFF, 0xD8, 0xFF]) {
+        Some("image/jpeg".to_string())
+    } else if data.starts_with(&[0x89, 0x50, 0x4E, 0x47]) {
+        Some("image/png".to_string())
+    } else if data.starts_with(b"RIFF") && data.len() > 12 && &data[8..12] == b"WEBP" {
+        Some("image/webp".to_string())
+    } else if data.starts_with(b"GIF8") {
+        Some("image/gif".to_string())
+    } else if data.starts_with(&[0x42, 0x4D]) {
+        Some("image/bmp".to_string())
+    } else {
+        None
+    }
+}
+
+async fn record_lookup_state(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+    status: &str,
+    error: Option<&str>,
+    source_url: Option<&str>,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"INSERT INTO furumusic__artwork_lookup_state
+              (entity_kind, entity_id, source, status, attempt_count, last_attempt_at, last_error, source_url)
+           VALUES ($1, $2, 'lastfm', $3, 1, $4, $5, $6)
+           ON CONFLICT (entity_kind, entity_id, source) DO UPDATE SET
+              status = EXCLUDED.status,
+              attempt_count = furumusic__artwork_lookup_state.attempt_count + 1,
+              last_attempt_at = EXCLUDED.last_attempt_at,
+              last_error = EXCLUDED.last_error,
+              source_url = EXCLUDED.source_url"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .bind(status)
+    .bind(now_iso())
+    .bind(error)
+    .bind(source_url)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+fn cover_source_description(source: &CoverSource) -> String {
+    match source {
+        CoverSource::FolderFile(path) => format!("folder: {}", path.display()),
+        CoverSource::Embedded(path) => format!("embedded: {}", path.display()),
+        CoverSource::Remote(url) => format!("remote: {url}"),
+    }
+}
+
+fn resolve_media_path(storage_dir: &str, file_path: &str) -> PathBuf {
+    let path = PathBuf::from(file_path);
+    if path.is_absolute() {
+        path
+    } else {
+        Path::new(storage_dir).join(path)
+    }
+}
+
+fn cutoff_iso(days: i64) -> String {
+    (chrono::Utc::now() - chrono::Duration::days(days))
+        .format("%Y-%m-%dT%H:%M:%SZ")
+        .to_string()
+}
+
+fn now_iso() -> String {
+    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
+}

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_process.rs

@@ -887,6 +887,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_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,9 +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,7 @@ mod auth;
 mod config;
 mod i18n;
 mod jobs;
+mod lastfm;
 mod music;
 mod oidc;
 mod player;
@@ -49,11 +50,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)
 }
 

src/music/mod.rs

@@ -1692,6 +1692,129 @@ pub mod db_migrations {
             &[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()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1715,5 +1838,7 @@ pub mod db_migrations {
         &M0030AddMediaFileUploader,
         &M0031CreateTorrentSession,
         &M0032CreateLastfmTrackPopularity,
+        &M0033CreateLastfmScrobbling,
+        &M0034CreateArtworkLookupState,
     ];
 }

src/player/dto.rs

@@ -55,6 +55,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,
@@ -170,6 +172,35 @@ pub(super) struct UserProfile {
     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,

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,
 }
@@ -70,3 +71,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

@@ -37,6 +37,8 @@ pub(super) struct TrackRow {
     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>,
@@ -107,6 +109,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>,
@@ -170,6 +174,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>,

src/scheduler/mod.rs

@@ -460,6 +460,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 +1357,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 && job_name != "lastfm_popularity" {
+    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;
     }

templates/admin/review_detail.html

@@ -25,28 +25,76 @@
 </div>
 {% endif %}
 
-<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>
+<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;">
     <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

@@ -11,7 +11,32 @@
                         </svg>
                     </button>
                 </div>
-                <pre class="info-modal-body" x-text="$store.info.modal.body"></pre>
+                <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>

templates/player/scripts.html

@@ -3,11 +3,15 @@
 const T = {
     info: "{{ t.player_info }}",
     noDetails: "{{ t.player_no_details }}",
+    trackInfoTitle: "{{ t.player_track_info }}",
+    releaseInfoTitle: "{{ t.player_release_info }}",
     loadingHistory: "{{ t.player_loading_history }}",
     failedLoadHistory: "{{ t.player_failed_load_history }}",
     totalPlays: "{{ t.player_total_plays }}",
     unknown: "{{ t.player_unknown }}",
     unknownSize: "{{ t.player_unknown_size }}",
+    title: "{{ t.player_title }}",
+    release: "{{ t.player_release }}",
     unknownRelease: "{{ t.player_unknown_release }}",
     unknownTrack: "{{ t.player_unknown_track }}",
     unknownAudio: "{{ t.player_unknown_audio }}",
@@ -26,6 +30,14 @@ const T = {
     lastfmPlaycount: "{{ t.player_lastfm_playcount }}",
     lastfmUpdated: "{{ t.player_lastfm_updated }}",
     lastfmNotLoaded: "{{ t.player_lastfm_not_loaded }}",
+    lastfmProfile: "{{ t.player_lastfm_profile }}",
+    lastfmConnect: "{{ t.player_lastfm_connect }}",
+    lastfmConnected: "{{ t.player_lastfm_connected }}",
+    lastfmReconnect: "{{ t.player_lastfm_reconnect }}",
+    lastfmNotConfigured: "{{ t.player_lastfm_not_configured }}",
+    lastfmDisconnectConfirm: "{{ t.player_lastfm_disconnect_confirm }}",
+    lastfmConnectFailed: "{{ t.player_lastfm_connect_failed }}",
+    lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
     trackWord: "{{ t.player_tracks_count }}",
     clientIdle: "{{ t.player_client_idle }}",
     active: "{{ t.player_active }}",
@@ -97,6 +109,11 @@ function formatTime(seconds) {
     return m + ':' + (sec < 10 ? '0' : '') + sec;
 }
 
+function coverVariantUrl(url, variant) {
+    if (!url) return url;
+    return url.replace(/\/(small|medium|large)$/, '/' + variant);
+}
+
 document.addEventListener('alpine:init', () => {
     // -----------------------------------------------------------------------
     // Audio element
@@ -118,14 +135,33 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('info', {
         modal: null,
         open(title, body) {
+            if (Array.isArray(body)) {
+                this.openRows(title, body);
+                return;
+            }
             this.modal = {
                 title: title || T.info,
                 body: body || T.noDetails,
+                rows: null,
+            };
+        },
+        openRows(title, rows) {
+            this.modal = {
+                title: title || T.info,
+                body: '',
+                rows: (rows || []).filter(row => row && ((row.value !== undefined && row.value !== null && row.value !== '') || (row.links && row.links.length))),
             };
         },
         close() {
             this.modal = null;
         },
+        navigate(link) {
+            if (!link || !link.id) return;
+            this.close();
+            const library = Alpine.store('library');
+            if (link.type === 'release') library.openRelease(link.id);
+            if (link.type === 'artist') library.openArtist(link.id);
+        },
     });
 
     // -----------------------------------------------------------------------
@@ -134,9 +170,12 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('user', {
         profile: null,
         menuOpen: false,
+        lastfm: { configured: false, connected: false, username: null, reauth_required: false, last_error: null },
+        lastfmBusy: false,
 
         init() {
             this.load();
+            this.loadLastfm();
         },
 
         async load() {
@@ -149,6 +188,56 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        async loadLastfm() {
+            try {
+                const res = await fetch('/api/player/lastfm/status');
+                if (!res.ok) throw new Error('failed');
+                this.lastfm = await res.json();
+                const player = Alpine.store('player');
+                if (player?.isPlaying) player._sendNowPlaying();
+            } catch {
+                this.lastfm = { configured: false, connected: false, username: null, reauth_required: false, last_error: null };
+            }
+        },
+
+        lastfmLabel() {
+            if (!this.lastfm?.configured) return T.lastfmNotConfigured;
+            if (this.lastfm?.connected && this.lastfm?.reauth_required) return T.lastfmReconnect;
+            if (this.lastfm?.connected) {
+                const user = this.lastfm.username || T.unknown;
+                return T.lastfmConnected.replace('{user}', user);
+            }
+            return T.lastfmConnect;
+        },
+
+        lastfmClass() {
+            if (!this.lastfm?.configured) return 'not-configured';
+            if (this.lastfm?.connected && this.lastfm?.reauth_required) return 'needs-auth';
+            if (this.lastfm?.connected) return 'connected';
+            return 'available';
+        },
+
+        async handleLastfm() {
+            if (this.lastfmBusy) return;
+            if (!this.lastfm?.configured) return;
+            if (!this.lastfm?.connected || this.lastfm?.reauth_required) {
+                window.location.href = '/api/player/lastfm/connect';
+                return;
+            }
+            const user = this.lastfm.username || T.unknown;
+            if (!window.confirm(T.lastfmDisconnectConfirm.replace('{user}', user))) return;
+            this.lastfmBusy = true;
+            try {
+                const res = await fetch('/api/player/lastfm/disconnect', { method: 'POST' });
+                if (!res.ok) throw new Error(T.lastfmDisconnectFailed);
+                await this.loadLastfm();
+            } catch {
+                alert(T.lastfmDisconnectFailed);
+            } finally {
+                this.lastfmBusy = false;
+            }
+        },
+
         initials() {
             const name = this.profile?.name || '';
             return name.trim().charAt(0) || '?';
@@ -266,6 +355,10 @@ document.addEventListener('alpine:init', () => {
         progress: 0,
         _saveTimer: null,
         _historyRecorded: false,
+        _nowPlayingSent: false,
+        _playbackStartedAt: null,
+        _listenedSeconds: 0,
+        _lastAudioTime: 0,
 
         init() {
             audio.volume = this.volume;
@@ -274,15 +367,25 @@ document.addEventListener('alpine:init', () => {
                 this.currentTime = audio.currentTime;
                 this.duration = audio.duration || 0;
                 this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0;
+                this._trackListenedDelta();
             });
 
             audio.addEventListener('ended', () => {
+                this._trackListenedDelta();
                 this._recordHistory(true);
                 this.next();
             });
 
-            audio.addEventListener('play', () => { this.isPlaying = true; });
-            audio.addEventListener('pause', () => { this.isPlaying = false; });
+            audio.addEventListener('play', () => {
+                this.isPlaying = true;
+                if (!this._playbackStartedAt) this._playbackStartedAt = Math.floor(Date.now() / 1000);
+                this._lastAudioTime = audio.currentTime || 0;
+                this._sendNowPlaying();
+            });
+            audio.addEventListener('pause', () => {
+                this.isPlaying = false;
+                this._lastAudioTime = audio.currentTime || 0;
+            });
 
             audio.addEventListener('loadedmetadata', () => {
                 this.duration = audio.duration || 0;
@@ -305,6 +408,7 @@ document.addEventListener('alpine:init', () => {
         play(track) {
             this.currentTrack = track;
             this._historyRecorded = false;
+            this._resetPlaybackTracking();
             audio.src = track.stream_url;
             audio.play().catch(() => {});
             this._updateMediaSession();
@@ -321,11 +425,13 @@ document.addEventListener('alpine:init', () => {
 
         seek(time) {
             audio.currentTime = time;
+            this._lastAudioTime = audio.currentTime || 0;
         },
 
         seekRelative(delta) {
             if (!this.currentTrack) return;
             audio.currentTime = Math.max(0, Math.min(audio.duration || 0, audio.currentTime + delta));
+            this._lastAudioTime = audio.currentTime || 0;
         },
 
         seekFromClick(event) {
@@ -440,7 +546,7 @@ document.addEventListener('alpine:init', () => {
             navigator.mediaSession.metadata = new MediaMetadata({
                 title: t.title,
                 artist: t.artists.map(a => a.name).join(', '),
-                artwork: t.cover_url ? [{ src: t.cover_url, sizes: '512x512', type: 'image/jpeg' }] : [],
+                artwork: t.cover_url ? [{ src: coverVariantUrl(t.cover_url, 'large'), sizes: '512x512', type: 'image/jpeg' }] : [],
             });
             navigator.mediaSession.setActionHandler('play', () => this.resume());
             navigator.mediaSession.setActionHandler('pause', () => this.pause());
@@ -513,6 +619,7 @@ document.addEventListener('alpine:init', () => {
                                 if (currentTrack) {
                                     this.currentTrack = currentTrack;
                                     this._historyRecorded = false;
+                                    this._resetPlaybackTracking();
                                     audio.src = currentTrack.stream_url;
                                     // Seek to saved position once metadata is loaded
                                     const seekMs = state.position_ms || 0;
@@ -535,16 +642,82 @@ document.addEventListener('alpine:init', () => {
         _recordHistory(completed) {
             if (this._historyRecorded || !this.currentTrack) return;
             this._historyRecorded = true;
+            const listenedSeconds = this._historyListenedSeconds(completed);
             fetch('/api/player/history', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
                     track_id: this.currentTrack.id,
-                    duration_listened: Math.floor(this.currentTime),
+                    started_at: this._playbackStartedAt,
+                    duration_listened: listenedSeconds,
                     completed: completed,
                 }),
             }).catch(() => {});
         },
+
+        _resetPlaybackTracking() {
+            this._nowPlayingSent = false;
+            this._playbackStartedAt = null;
+            this._listenedSeconds = 0;
+            this._lastAudioTime = 0;
+        },
+
+        _trackListenedDelta() {
+            if (!this.currentTrack) return;
+            const current = audio.currentTime || 0;
+            if (!this.isPlaying) {
+                this._lastAudioTime = current;
+                return;
+            }
+            const previous = Number.isFinite(this._lastAudioTime) ? this._lastAudioTime : current;
+            const delta = current - previous;
+            if (delta > 0 && delta < 5) {
+                this._listenedSeconds += delta;
+            }
+            this._lastAudioTime = current;
+        },
+
+        _trackDuration() {
+            const candidates = [
+                this.currentTrack?.duration_seconds,
+                this.duration,
+                audio.duration,
+            ];
+            for (const value of candidates) {
+                const duration = Number(value || 0);
+                if (Number.isFinite(duration) && duration > 0) return duration;
+            }
+            return 0;
+        },
+
+        _scrobbleThreshold(duration) {
+            return Math.min(duration / 2, 240);
+        },
+
+        _historyListenedSeconds(completed) {
+            const duration = this._trackDuration();
+            const listened = Number(this._listenedSeconds || 0);
+            const finalGrace = completed ? 1 : 0;
+            const precise = Math.floor(listened + finalGrace);
+            if (precise > 0) return precise;
+            const current = Number(audio.currentTime || this.currentTime || 0);
+            if (duration > 0 && Number.isFinite(current)) {
+                return Math.floor(Math.min(current, duration));
+            }
+            return Math.floor(current || 0);
+        },
+
+        _sendNowPlaying() {
+            if (this._nowPlayingSent || !this.currentTrack) return;
+            const lastfm = Alpine.store('user')?.lastfm;
+            if (!lastfm?.configured || !lastfm?.connected || lastfm?.reauth_required) return;
+            this._nowPlayingSent = true;
+            fetch('/api/player/lastfm/now-playing', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ track_id: this.currentTrack.id }),
+            }).catch(() => {});
+        },
     });
 
     // -----------------------------------------------------------------------
@@ -634,6 +807,8 @@ document.addEventListener('alpine:init', () => {
         searchResults: null,
         searchLoading: false,
         _previousView: 'artists',
+        _activeHash: location.hash || '#artists',
+        _scrollPositions: {},
 
         _hashNav: false, // guard against circular hash updates
 
@@ -643,26 +818,31 @@ document.addEventListener('alpine:init', () => {
 
             // Listen for browser back/forward
             window.addEventListener('hashchange', () => {
-                this._navigateFromHash();
+                if (this._hashNav) return;
+                const nextHash = location.hash || '#artists';
+                this._saveScrollPosition(this._activeHash);
+                this._activeHash = nextHash;
+                this._navigateFromHash({ fromHash: true, restoreScroll: true });
             });
 
             // Navigate to initial hash (if any)
-            this._navigateFromHash();
+            this._navigateFromHash({ fromHash: true, restoreScroll: true });
         },
 
         _setHash(hash) {
             this._hashNav = true;
+            this._activeHash = hash;
             location.hash = hash;
             // Reset guard after a tick
             setTimeout(() => { this._hashNav = false; }, 0);
         },
 
-        _navigateFromHash() {
+        _navigateFromHash(options = {}) {
             if (this._hashNav) return;
             const hash = location.hash || '#artists';
             const match = hash.match(/^#(\w+)(?:\/([-]?\d+))?(?:\?(.*))?$/);
             if (!match) {
-                this.goArtists();
+                this.goArtists(options);
                 return;
             }
             const view = match[1];
@@ -670,26 +850,74 @@ document.addEventListener('alpine:init', () => {
             const params = match[3] || '';
 
             if (view === 'artists' && !id) {
-                if (this.view !== 'artists') this.goArtists();
+                if (this.view !== 'artists') this.goArtists(options);
+                else if (options.restoreScroll) this._restoreScrollPosition(hash);
             } else if (view === 'artist' && id) {
-                this.openArtist(id);
+                this.openArtist(id, options);
             } else if (view === 'release' && id) {
-                this.openRelease(id);
+                this.openRelease(id, options);
             } else if (view === 'playlist' && id) {
-                this.openPlaylist(id);
+                this.openPlaylist(id, options);
             } else if (view === 'search') {
                 const qMatch = params.match(/q=([^&]*)/);
                 if (qMatch) {
                     const q = decodeURIComponent(qMatch[1]);
                     this.searchQuery = q;
-                    this.search(q);
+                    this.search(q, options);
                 }
             } else {
-                this.goArtists();
+                this.goArtists(options);
             }
         },
 
-        goArtists() {
+        _scrollElement() {
+            return document.getElementById('center-scroll');
+        },
+
+        _saveScrollPosition(hash = this._activeHash) {
+            const el = this._scrollElement();
+            if (!el || !hash) return;
+            this._scrollPositions[hash] = el.scrollTop;
+        },
+
+        _scrollToTop() {
+            const el = this._scrollElement();
+            if (el) el.scrollTop = 0;
+        },
+
+        _restoreScrollPosition(hash = this._activeHash) {
+            const top = this._scrollPositions[hash];
+            if (top == null) return;
+            const restore = () => {
+                const el = this._scrollElement();
+                if (el) el.scrollTop = top;
+            };
+            this.$nextTick(() => {
+                restore();
+                requestAnimationFrame(restore);
+                setTimeout(restore, 150);
+            });
+        },
+
+        _afterNavigation(options = {}) {
+            if (options.restoreScroll) {
+                this._restoreScrollPosition(this._activeHash);
+            } else {
+                this.$nextTick(() => { this._scrollToTop(); });
+            }
+        },
+
+        _beginNavigation(hash, options = {}) {
+            if (!options.fromHash) {
+                this._saveScrollPosition(this._activeHash);
+                this._setHash(hash);
+            } else {
+                this._activeHash = hash;
+            }
+        },
+
+        goArtists(options = {}) {
+            this._beginNavigation('#artists', options);
             this.view = 'artists';
             this.currentArtist = null;
             this.currentRelease = null;
@@ -697,8 +925,8 @@ document.addEventListener('alpine:init', () => {
             this.searchQuery = '';
             this.searchResults = null;
             this._previousView = 'artists';
-            this._setHash('#artists');
             this.$nextTick(() => { this._setupScroll(); });
+            this._afterNavigation(options);
         },
 
         async loadArtists(page) {
@@ -722,17 +950,18 @@ document.addEventListener('alpine:init', () => {
             this.loading = false;
         },
 
-        async openArtist(id) {
+        async openArtist(id, options = {}) {
+            this._beginNavigation('#artist/' + id, options);
             this.searchQuery = '';
             this.searchResults = null;
             this.view = 'artist_detail';
             this.currentArtist = null;
-            this._setHash('#artist/' + id);
             try {
                 const res = await fetch(`/api/player/artists/${id}`);
                 if (!res.ok) throw new Error('failed');
                 this.currentArtist = await res.json();
             } catch {}
+            this._afterNavigation(options);
         },
 
         artistReleaseGroups() {
@@ -792,6 +1021,47 @@ document.addEventListener('alpine:init', () => {
             return (idx === 0 ? size.toFixed(0) : size.toFixed(1)) + ' ' + units[idx];
         },
 
+        trackPopularityValue(track) {
+            const value = Number(track?.lastfm_rating);
+            return Number.isFinite(value) && value > 0 ? value : null;
+        },
+
+        hasPopularity(track) {
+            return this.trackPopularityValue(track) != null;
+        },
+
+        popularityLabel(track) {
+            const value = this.trackPopularityValue(track);
+            if (value == null) return 'i';
+            if (value >= 10000) return Math.round(value / 1000) + 'k';
+            if (value >= 1000) return (value / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
+            return Math.round(value).toString();
+        },
+
+        popularityStyle(track) {
+            const value = this.trackPopularityValue(track);
+            if (value == null) return '';
+            const t = Math.max(0, Math.min(1, Math.log1p(value) / Math.log1p(180)));
+            const hue = 210 - (190 * t);
+            const saturation = 42 + (46 * t);
+            const lightness = 30 + (16 * t);
+            const bg = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${lightness.toFixed(0)}%, 0.28)`;
+            const hoverBg = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${Math.min(54, lightness + 6).toFixed(0)}%, 0.36)`;
+            const border = `hsla(${hue.toFixed(0)}, ${saturation.toFixed(0)}%, ${Math.min(66, lightness + 16).toFixed(0)}%, 0.52)`;
+            const fg = `hsl(${hue.toFixed(0)}, ${Math.min(96, saturation + 8).toFixed(0)}%, ${Math.min(86, lightness + 34).toFixed(0)}%)`;
+            return `--popularity-bg:${bg};--popularity-hover-bg:${hoverBg};--popularity-border:${border};--popularity-fg:${fg}`;
+        },
+
+        trackInfoTitle(track) {
+            const value = this.trackPopularityValue(track);
+            if (value == null) return this.trackInfo(track);
+            return `${T.lastfmRating}: ${Math.round(value)}\n${this.trackInfo(track)}`;
+        },
+
+        openTrackInfo(track) {
+            Alpine.store('info').openRows(T.trackInfoTitle, this.trackInfoRows(track));
+        },
+
         uploadersInfo(uploaders) {
             const rows = uploaders || [];
             if (!rows.length) return 'UFO';
@@ -812,6 +1082,31 @@ document.addEventListener('alpine:init', () => {
             return lines.join('\n');
         },
 
+        openReleaseInfo(release) {
+            Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release));
+        },
+
+        infoLinks(items, type) {
+            const seen = new Set();
+            return (items || [])
+                .filter(item => item && item.id && !seen.has(Number(item.id)) && seen.add(Number(item.id)))
+                .map(item => ({ type, id: item.id, label: item.label || item.name || item.title || String(item.id) }));
+        },
+
+        releaseInfoRows(release) {
+            if (!release) return [];
+            const rows = [
+                { label: T.release, value: release.title || T.unknownRelease },
+                { label: T.type, value: release.release_type || T.unknown },
+                { label: T.year, value: release.year || T.unknown },
+                { label: T.tracks, value: release.track_count || release.tracks?.length || 0 },
+                { label: T.uploaders, value: this.uploadersInfo(release.uploaders || []) },
+            ];
+            const artistLinks = this.infoLinks(release.artists || [], 'artist');
+            if (artistLinks.length) rows.splice(1, 0, { label: T.artists, links: artistLinks });
+            return rows;
+        },
+
         trackInfo(track) {
             if (!track) return '';
             const artists = this.trackArtistLinks(track).map(artist => artist.label).join(', ') || T.unknown;
@@ -832,7 +1127,7 @@ document.addEventListener('alpine:init', () => {
             ];
             if (track.lastfm_rating != null || track.lastfm_listeners != null || track.lastfm_playcount != null) {
                 const rating = Number(track.lastfm_rating || 0);
-                lines.push(`${T.lastfmRating}: ${Number.isFinite(rating) ? rating.toFixed(2) : T.unknown}`);
+                lines.push(`${T.lastfmRating}: ${Number.isFinite(rating) ? Math.round(rating) : T.unknown}`);
                 lines.push(`${T.lastfmListeners}: ${new Intl.NumberFormat().format(track.lastfm_listeners || 0)}`);
                 lines.push(`${T.lastfmPlaycount}: ${new Intl.NumberFormat().format(track.lastfm_playcount || 0)}`);
                 if (track.lastfm_updated_at) lines.push(`${T.lastfmUpdated}: ${track.lastfm_updated_at}`);
@@ -842,28 +1137,64 @@ document.addEventListener('alpine:init', () => {
             return lines.join('\n');
         },
 
-        async openRelease(id) {
+        trackInfoRows(track) {
+            if (!track) return [];
+            const artistLinks = this.infoLinks(this.trackArtistLinks(track), 'artist');
+            const releaseLinks = track.release_id
+                ? [{ type: 'release', id: track.release_id, label: track.release_title || T.unknownRelease }]
+                : [];
+            const audio = [
+                track.audio_format || null,
+                track.audio_bitrate ? `${track.audio_bitrate} kbps` : null,
+                track.audio_sample_rate ? `${track.audio_sample_rate} Hz` : null,
+                track.audio_bit_depth ? `${track.audio_bit_depth}-bit` : null,
+            ].filter(Boolean).join(' · ') || T.unknownAudio;
+            const rows = [
+                { label: T.title, value: track.title || T.unknownTrack },
+                { label: T.release, links: releaseLinks },
+                { label: T.artists, links: artistLinks },
+                { label: T.releaseYear, value: track.release_year || T.unknown },
+                { label: T.duration, value: formatTime(track.duration_seconds) },
+                { label: T.audio, value: audio },
+                { label: T.size, value: this.bytes(track.file_size_bytes) },
+                { label: T.uploader, value: track.uploader_name || 'UFO' },
+            ];
+            if (track.lastfm_rating != null || track.lastfm_listeners != null || track.lastfm_playcount != null) {
+                const rating = Number(track.lastfm_rating || 0);
+                rows.push({ label: T.lastfmRating, value: Number.isFinite(rating) ? Math.round(rating) : T.unknown });
+                rows.push({ label: T.lastfmListeners, value: new Intl.NumberFormat().format(track.lastfm_listeners || 0) });
+                rows.push({ label: T.lastfmPlaycount, value: new Intl.NumberFormat().format(track.lastfm_playcount || 0) });
+                if (track.lastfm_updated_at) rows.push({ label: T.lastfmUpdated, value: track.lastfm_updated_at });
+            } else {
+                rows.push({ label: T.lastfmRating, value: T.lastfmNotLoaded });
+            }
+            return rows;
+        },
+
+        async openRelease(id, options = {}) {
+            this._beginNavigation('#release/' + id, options);
             this.searchQuery = '';
             this.searchResults = null;
             this.view = 'release_detail';
             this.currentRelease = null;
-            this._setHash('#release/' + id);
             try {
                 const res = await fetch(`/api/player/releases/${id}`);
                 if (!res.ok) throw new Error('failed');
                 this.currentRelease = await res.json();
             } catch {}
+            this._afterNavigation(options);
         },
 
-        async openPlaylist(id) {
+        async openPlaylist(id, options = {}) {
+            this._beginNavigation('#playlist/' + id, options);
             this.view = 'playlist_detail';
             this.currentPlaylist = null;
-            this._setHash('#playlist/' + id);
             try {
                 const res = await fetch(`/api/player/playlists/${id}`);
                 if (!res.ok) throw new Error('failed');
                 this.currentPlaylist = await res.json();
             } catch {}
+            this._afterNavigation(options);
         },
 
         async playRelease(releaseId) {
@@ -899,17 +1230,17 @@ document.addEventListener('alpine:init', () => {
             } catch {}
         },
 
-        async search(query) {
+        async search(query, options = {}) {
             const q = (query || '').trim();
             if (!q) {
                 this.clearSearch();
                 return;
             }
+            this._beginNavigation('#search?q=' + encodeURIComponent(q), options);
             if (this.view !== 'search') {
                 this._previousView = this.view;
             }
             this.view = 'search';
-            this._setHash('#search?q=' + encodeURIComponent(q));
             this.searchLoading = true;
             try {
                 const res = await fetch(`/api/player/search?q=${encodeURIComponent(q)}&limit=10`);
@@ -919,6 +1250,7 @@ document.addEventListener('alpine:init', () => {
                 this.searchResults = { artists: [], releases: [], tracks: [] };
             }
             this.searchLoading = false;
+            this._afterNavigation(options);
         },
 
         clearSearch() {

templates/player/shell.html

@@ -38,6 +38,13 @@
                         <span class="user-stat-label">{{ t.player_listened }}</span>
                     </div>
                 </div>
+                <button class="lastfm-profile-action"
+                        :class="$store.user.lastfmClass()"
+                        :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
+                        @click="$store.user.handleLastfm()">
+                    <span class="lastfm-dot"></span>
+                    <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                </button>
             </div>
             <div class="sidebar-header">
                 <h2>{{ t.player_library }}</h2>
@@ -324,6 +331,13 @@
                             <span class="user-stat-label">{{ t.player_listened }}</span>
                         </div>
                     </div>
+                    <button class="lastfm-profile-action"
+                            :class="$store.user.lastfmClass()"
+                            :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
+                            @click="$store.user.handleLastfm()">
+                        <span class="lastfm-dot"></span>
+                        <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                    </button>
                     <button class="modal-btn modal-btn-primary mobile-account-logout"
                             @click="$store.user.logout()">
                         {{ t.player_log_out }}
@@ -391,7 +405,7 @@
                                                     <template x-if="!release.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 class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                                    <button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
                                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                                     </button>
                                                 </div>
@@ -434,8 +448,14 @@
                                             </div>
                                             <span></span>
                                             <div class="track-actions">
-                                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                                                <button class="track-action-btn info-btn popularity-info-btn"
+                                                        :class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
+                                                        :style="$store.library.popularityStyle(track)"
+                                                        @click.stop="$store.library.openTrackInfo(track)"
+                                                        :title="$store.library.trackInfoTitle(track)"
+                                                        aria-label="{{ t.player_track_info }}">
+                                                    <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
+                                                    <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                                 </button>
                                                 <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="{{ t.player_play }}">
                                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
@@ -556,7 +576,7 @@
                                             <template x-if="!release.cover_url">
                                                 <span class="placeholder-icon"><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></span>
                                             </template>
-                                            <button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                            <button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
                                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                             </button>
                                             <button class="card-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="{{ t.player_add_to_queue }}">
@@ -608,8 +628,14 @@
                                     </div>
                                     <span></span>
                                     <div class="track-actions">
-                                        <button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                                        <button class="track-action-btn info-btn popularity-info-btn"
+                                                :class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
+                                                :style="$store.library.popularityStyle(track)"
+                                                @click.stop="$store.library.openTrackInfo(track)"
+                                                :title="$store.library.trackInfoTitle(track)"
+                                                aria-label="{{ t.player_track_info }}">
+                                            <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
+                                            <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                         </button>
                                         <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="{{ t.player_play }}">
                                             <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
@@ -678,7 +704,7 @@
                             <div class="release-year" x-text="$store.library.currentRelease.year || ''"></div>
                             <div class="release-actions">
                                 <button class="release-action-btn secondary"
-                                        @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo($store.library.currentRelease))"
+                                        @click.stop="$store.library.openReleaseInfo($store.library.currentRelease)"
                                         :title="$store.library.releaseInfo($store.library.currentRelease)"
                                         aria-label="{{ t.player_release_info }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
@@ -725,8 +751,14 @@
                             </div>
                             <span></span>
                             <div class="track-actions">
-                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                                <button class="track-action-btn info-btn popularity-info-btn"
+                                        :class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
+                                        :style="$store.library.popularityStyle(track)"
+                                        @click.stop="$store.library.openTrackInfo(track)"
+                                        :title="$store.library.trackInfoTitle(track)"
+                                        aria-label="{{ t.player_track_info }}">
+                                    <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
+                                    <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
                                 <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="{{ t.player_play }}">
                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
@@ -795,8 +827,14 @@
                             </div>
                             <span></span>
                             <div class="track-actions">
-                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                                <button class="track-action-btn info-btn popularity-info-btn"
+                                        :class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
+                                        :style="$store.library.popularityStyle(track)"
+                                        @click.stop="$store.library.openTrackInfo(track)"
+                                        :title="$store.library.trackInfoTitle(track)"
+                                        aria-label="{{ t.player_track_info }}">
+                                    <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
+                                    <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
                                 <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="{{ t.player_play }}">
                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
@@ -871,8 +909,14 @@
                             </div>
                         </div>
                         <div class="queue-track-actions">
-                            <button class="queue-track-remove info-btn" @click.stop="$store.info.open('{{ t.player_track_info }}', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="{{ t.player_track_info }}">
-                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="14" height="14"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                            <button class="queue-track-remove info-btn popularity-info-btn"
+                                    :class="{ 'has-popularity': $store.library.hasPopularity(track), 'no-popularity': !$store.library.hasPopularity(track) }"
+                                    :style="$store.library.popularityStyle(track)"
+                                    @click.stop="$store.library.openTrackInfo(track)"
+                                    :title="$store.library.trackInfoTitle(track)"
+                                    aria-label="{{ t.player_track_info }}">
+                                <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
+                                <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                             </button>
                             <button class="queue-track-remove" @click.stop="$store.queue.remove(idx)" title="{{ t.player_remove }}">
                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
@@ -898,7 +942,16 @@
                         </template>
                     </div>
                     <div class="player-track-info">
+                        <div class="player-track-title-row">
                             <div class="player-track-title" x-text="$store.player.currentTrack.title"></div>
+                            <button class="like-btn player-current-like"
+                                    :class="{ liked: $store.likes.has($store.player.currentTrack.id) }"
+                                    @click.stop="$store.likes.toggle($store.player.currentTrack.id)"
+                                    title="{{ t.player_like }}"
+                                    aria-label="{{ t.player_like }}">
+                                <svg viewBox="0 0 24 24" :fill="$store.likes.has($store.player.currentTrack.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>
+                        </div>
                         <div class="player-track-artist">
                             <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks($store.player.currentTrack)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
                                 <span>

templates/player/styles.html

@@ -165,6 +165,68 @@ button.user-stat:hover {
     color: var(--text-subdued);
 }
 
+.lastfm-profile-action {
+    width: 100%;
+    min-height: 34px;
+    margin-top: 8px;
+    padding: 7px 9px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    text-align: left;
+    transition: background 0.15s, border-color 0.15s, color 0.15s;
+}
+
+.lastfm-profile-action:not(:disabled):hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+}
+
+.lastfm-profile-action:disabled {
+    cursor: default;
+    opacity: 0.72;
+}
+
+.lastfm-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-subdued);
+    flex-shrink: 0;
+}
+
+.lastfm-profile-action.connected {
+    border-color: rgba(29, 185, 84, 0.32);
+    color: var(--text-primary);
+}
+
+.lastfm-profile-action.connected .lastfm-dot {
+    background: #1db954;
+}
+
+.lastfm-profile-action.available .lastfm-dot,
+.lastfm-profile-action.needs-auth .lastfm-dot {
+    background: var(--accent);
+}
+
+.lastfm-profile-action.needs-auth {
+    border-color: rgba(255, 184, 77, 0.4);
+}
+
+.lastfm-profile-text {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 11px;
+    font-weight: 650;
+}
+
 .sidebar-header {
     padding: 16px;
     display: flex;
@@ -661,11 +723,20 @@ button.user-stat:hover {
     display: flex;
     align-items: center;
     gap: 2px;
-    opacity: 0;
+    opacity: 1;
     transition: opacity 0.15s;
 }
 
-.track-row:hover .track-actions { opacity: 1; }
+.track-actions > :not(.popularity-info-btn) {
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.15s;
+}
+
+.track-row:hover .track-actions > * {
+    opacity: 1;
+    pointer-events: auto;
+}
 
 .track-action-btn {
     background: none;
@@ -692,6 +763,43 @@ button.user-stat:hover {
     color: var(--text-primary);
 }
 
+.popularity-info-btn {
+    min-width: 26px;
+    height: 20px;
+    padding: 0 3px;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    font-size: 11px;
+    font-weight: 800;
+    line-height: 1;
+    letter-spacing: 0;
+    font-variant-numeric: tabular-nums;
+}
+
+.popularity-info-btn.has-popularity {
+    color: var(--popularity-fg, var(--text-primary));
+    background: transparent;
+}
+
+.popularity-info-btn.has-popularity:hover {
+    color: var(--popularity-fg, var(--text-primary));
+    background: transparent;
+}
+
+.popularity-info-btn.no-popularity {
+    min-width: 18px;
+    width: 18px;
+    padding: 0;
+}
+
+.popularity-info-btn .info-letter {
+    font-size: 12px;
+    font-weight: 800;
+    font-style: normal;
+    line-height: 1;
+}
+
 .card-info-btn {
     position: absolute;
     top: 8px;
@@ -926,12 +1034,21 @@ button.user-stat:hover {
     display: flex;
     align-items: center;
     gap: 2px;
-    opacity: 0;
+    opacity: 1;
     transition: opacity 0.15s;
     flex-shrink: 0;
 }
 
-.queue-track:hover .queue-track-actions { opacity: 1; }
+.queue-track-actions > :not(.popularity-info-btn) {
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.15s;
+}
+
+.queue-track:hover .queue-track-actions > * {
+    opacity: 1;
+    pointer-events: auto;
+}
 
 .queue-track-remove {
     background: none;
@@ -948,6 +1065,20 @@ button.user-stat:hover {
 
 .queue-track-remove:hover { color: var(--text-primary); background: var(--bg-hover); }
 
+.queue-track-remove.popularity-info-btn {
+    min-width: 26px;
+    width: auto;
+    height: 20px;
+    padding: 0 3px;
+    border-radius: 0;
+}
+
+.queue-track-remove.popularity-info-btn.no-popularity {
+    min-width: 18px;
+    width: 18px;
+    padding: 0;
+}
+
 /* Drag handle */
 .queue-drag-handle {
     cursor: grab;
@@ -1010,12 +1141,28 @@ button.user-stat:hover {
     overflow: hidden;
     min-width: 0;
 }
+
+.player-track-title-row {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    min-width: 0;
+}
+
 .player-track-title {
     font-size: 13px;
     font-weight: 500;
     white-space: nowrap;
     overflow: hidden;
     text-overflow: ellipsis;
+    min-width: 0;
+}
+
+.player-current-like {
+    width: 24px;
+    height: 24px;
+    padding: 4px;
+    flex: 0 0 auto;
 }
 
 .player-track-artist {
@@ -1694,7 +1841,7 @@ button.user-stat:hover {
 .modal-playlist-item svg { width: 16px; height: 16px; flex-shrink: 0; }
 
 .info-modal {
-    max-width: min(520px, calc(100vw - 24px));
+    max-width: min(620px, calc(100vw - 24px));
 }
 
 .info-modal-head {
@@ -1716,14 +1863,72 @@ button.user-stat:hover {
     border-radius: 8px;
     background: var(--bg-primary);
     color: var(--text-secondary);
-    font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
     font-size: 13px;
     line-height: 1.55;
-    white-space: pre-wrap;
     overflow: auto;
     max-height: min(58dvh, 520px);
 }
 
+.info-modal-plain {
+    margin: 0;
+    font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
+    white-space: pre-wrap;
+}
+
+.info-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.info-table th,
+.info-table td {
+    padding: 9px 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.07);
+    vertical-align: top;
+}
+
+.info-table tr:last-child th,
+.info-table tr:last-child td {
+    border-bottom: 0;
+}
+
+.info-table th {
+    width: 34%;
+    padding-right: 18px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 700;
+    text-align: left;
+    text-transform: uppercase;
+}
+
+.info-table td {
+    color: var(--text-primary);
+}
+
+.info-link-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+}
+
+.info-link {
+    border: 1px solid rgba(29, 185, 84, 0.36);
+    border-radius: 999px;
+    background: rgba(29, 185, 84, 0.1);
+    color: var(--text-primary);
+    cursor: pointer;
+    padding: 3px 8px;
+    font: inherit;
+    line-height: 1.3;
+}
+
+.info-link:hover {
+    border-color: rgba(29, 185, 84, 0.7);
+    background: rgba(29, 185, 84, 0.18);
+    color: var(--accent);
+}
+
 .modal-btn {
     padding: 8px 16px;
     border-radius: 20px;
@@ -2807,6 +3012,24 @@ button.user-stat:hover {
         padding: 6px;
     }
 
+    .popularity-info-btn {
+        min-width: 28px;
+        height: 22px;
+        padding: 0 3px;
+    }
+
+    .popularity-info-btn.no-popularity {
+        min-width: 20px;
+        width: 20px;
+        padding: 0;
+    }
+
+    .track-actions > *,
+    .queue-track-actions > * {
+        opacity: 1;
+        pointer-events: auto;
+    }
+
     .track-action-btn svg,
     .like-btn svg {
         width: 17px;
@@ -2834,6 +3057,22 @@ button.user-stat:hover {
         max-width: 400px;
     }
 
+    .info-table th,
+    .info-table td {
+        display: block;
+        width: 100%;
+        padding-right: 0;
+    }
+
+    .info-table th {
+        padding-bottom: 2px;
+        border-bottom: 0;
+    }
+
+    .info-table td {
+        padding-top: 0;
+    }
+
     .torrent-modal {
         width: 100vw;
         max-width: none;