PLAYER: added simple rating

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.12"
+version = "0.1.17"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1407,6 +1428,7 @@ dependencies = [
  "croner",
  "encoding_rs",
  "id3",
+ "image",
  "librqbit",
  "openidconnect",
  "reqwest",
@@ -1588,6 +1610,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 +2058,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 +2582,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 +3070,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 +3150,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 +3171,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 +5237,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 +5791,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.13"
+version = "0.1.18"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -20,6 +20,7 @@ symphonia = { version = "0.5", default-features = false, features = ["mp3","aac"
 id3 = "1"
 encoding_rs = "0.8"
 sha2 = "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

@@ -264,6 +264,27 @@ impl App for AdminApp {
                 }),
                 "admin_v2_job_run",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/settings",
+                get(move |session: Session, db: Database| async move {
+                    v2::settings(session, db).await
+                })
+                .post(
+                    move |session: Session,
+                          db: Database,
+                          json: Json<v2::UpdateSettingsRequest>| async move {
+                        v2::update_settings(session, db, json).await
+                    },
+                ),
+                "admin_v2_settings",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/settings/probe",
+                get(move |session: Session, db: Database| async move {
+                    v2::settings_probe(session, db).await
+                }),
+                "admin_v2_settings_probe",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/jobs/{name}/toggle",
                 cot::router::method::post({

src/admin/v2.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use cot::db::Database;
+use cot::db::{Database, Model};
 use cot::html::Html;
 use cot::http::StatusCode;
 use cot::http::header::CONTENT_TYPE;
@@ -13,7 +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, ConfigSources};
 use crate::i18n::{I18n, Translations};
 use crate::scheduler::{JobRegistry, ScheduledJob};
 
@@ -214,6 +216,95 @@ struct MutationResponse {
     affected: u64,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminSettingsDto {
+    values: AdminSettingsValues,
+    sources: AdminSettingsSources,
+    lastfm_api_key_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,
+    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,
+    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,
+    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)]
 struct LibraryOverviewDto {
     artists: i64,
@@ -458,6 +549,163 @@ pub async fn jobs(
     Json(jobs).into_response()
 }
 
+pub async fn settings(session: Session, db: Database) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let (config, sources) = AppConfig::load_with_db(&db).await;
+    Json(settings_dto(config, sources)).into_response()
+}
+
+pub async fn update_settings(
+    session: Session,
+    db: Database,
+    Json(body): Json<UpdateSettingsRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    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()),
+        ("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(),
+        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,
+            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(),
+            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,

src/admin/views.rs

@@ -799,7 +799,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 +879,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"),
                 });
             }
         }

src/agent/cover_art.rs

@@ -328,6 +328,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 +391,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

@@ -133,6 +133,7 @@ pub struct ConfigSources {
     pub agent_confidence_threshold: ConfigSource,
     pub agent_context_limit: ConfigSource,
     pub agent_concurrency: ConfigSource,
+    pub lastfm_api_key: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -158,6 +159,7 @@ impl Default for ConfigSources {
             agent_confidence_threshold: ConfigSource::Default,
             agent_context_limit: ConfigSource::Default,
             agent_concurrency: ConfigSource::Default,
+            lastfm_api_key: ConfigSource::Default,
         }
     }
 }
@@ -262,6 +264,8 @@ pub struct AppConfig {
     pub agent_context_limit: u64,
     /// Number of files to process in parallel via the LLM.
     pub agent_concurrency: u64,
+    /// Last.fm API key for weekly popularity enrichment.
+    pub lastfm_api_key: String,
 }
 
 impl Default for AppConfig {
@@ -287,6 +291,7 @@ impl Default for AppConfig {
             agent_confidence_threshold: 0.85,
             agent_context_limit: 8192,
             agent_concurrency: 2,
+            lastfm_api_key: String::new(),
         }
     }
 }
@@ -313,6 +318,7 @@ impl_env_overrides!(
     agent_confidence_threshold,
     agent_context_limit,
     agent_concurrency,
+    lastfm_api_key,
 );
 
 impl AppConfig {
@@ -396,6 +402,7 @@ impl AppConfig {
         apply_db_field!(agent_confidence_threshold);
         apply_db_field!(agent_context_limit);
         apply_db_field!(agent_concurrency);
+        apply_db_field!(lastfm_api_key);
     }
 }
 

src/i18n/phrases.rs

@@ -321,6 +321,11 @@ translations! {
     player_audio:            "Audio"                           , "Аудио";
     player_size:             "Size"                            , "Размер";
     player_uploader:         "Uploader"                        , "Загрузил";
+    player_lastfm_rating:    "Last.fm popularity"              , "Популярность Last.fm";
+    player_lastfm_listeners: "Last.fm listeners"               , "Слушатели Last.fm";
+    player_lastfm_playcount: "Last.fm plays"                   , "Прослушивания Last.fm";
+    player_lastfm_updated:   "Last.fm updated"                 , "Last.fm обновлён";
+    player_lastfm_not_loaded: "not loaded yet"                 , "ещё не загружено";
     player_play:             "Play"                            , "Играть";
     player_like:             "Like"                            , "Лайк";
     player_add_to_queue:     "Add to queue"                    , "Добавить в очередь";
@@ -357,17 +362,19 @@ translations! {
     player_saved_torrents:   "Saved torrents"                  , "Сохранённые торренты";
     player_refresh:          "Refresh"                         , "Обновить";
     player_no_saved_torrents: "No saved torrents"              , "Сохранённых торрентов нет";
-    player_add_torrent:      "Add torrent"                     , "Добавить торрент";
-    player_choose_saved_or_add_torrent: "Choose a saved torrent or add a new one." , "Выберите сохранённый торрент или добавьте новый.";
+    player_upload:           "Upload"                          , "Загрузить";
+    player_choose_saved_or_add_torrent: "Choose a saved item or upload new files." , "Выберите сохранённый элемент или загрузите новые файлы.";
+    player_local_files:      "Local audio files"               , "Локальные аудиофайлы";
     player_torrent_file:     "Torrent file"                    , "Torrent-файл";
     player_magnet_link:      "Magnet link"                     , "Magnet-ссылка";
-    player_preview_content:  "Preview content"                 , "Предпросмотр";
+    player_upload_content:   "Upload"                          , "Загрузить";
     player_download_selected: "Download selected"              , "Скачать выбранное";
     player_pause_download:   "Pause download"                  , "Поставить на паузу";
     player_expand_all:       "Expand all"                      , "Развернуть всё";
     player_collapse:         "Collapse"                        , "Свернуть";
     player_selected:         "selected"                        , "выбрано";
     player_preview:          "Preview"                         , "Предпросмотр";
+    player_resolving:        "Resolving metadata"              , "Получаю метаданные";
     player_downloading:      "Downloading"                     , "Скачивается";
     player_moving:           "Moving"                          , "Перемещается";
     player_completed:        "Completed"                       , "Готово";
@@ -389,7 +396,10 @@ translations! {
     player_no_plays_yet:     "No plays yet"                    , "Прослушиваний пока нет";
     player_page:             "Page"                            , "Страница";
     player_of:               "of"                              , "из";
-    player_choose_torrent:   "Choose a .torrent file or paste a magnet link." , "Выберите .torrent файл или вставьте magnet-ссылку.";
+    player_choose_torrent:   "Choose local files, paste a magnet link, or choose a .torrent file." , "Выберите локальные файлы, вставьте magnet-ссылку или выберите .torrent файл.";
+    player_uploading_files:  "Uploading files..."              , "Загружаю файлы...";
+    player_upload_complete:  "Upload complete. Files are queued for processing." , "Загрузка завершена. Файлы поставлены в обработку.";
+    player_upload_failed:    "Upload failed"                   , "Загрузка не удалась";
     player_reading_torrent:  "Reading torrent file..."         , "Читаю torrent-файл...";
     player_resolving_magnet: "Resolving magnet metadata. This can take a while..." , "Получаю метаданные magnet-ссылки. Это может занять время...";
     player_preview_failed:   "Preview failed"                  , "Предпросмотр не удался";

src/jobs/cover_variant_backfill.rs

@@ -0,0 +1,96 @@
+use std::path::{Path, PathBuf};
+
+use crate::agent::cover_variants;
+use crate::scheduler::{Job, JobContext, JobLog};
+
+pub struct CoverVariantBackfillJob;
+
+#[async_trait::async_trait]
+impl Job for CoverVariantBackfillJob {
+    fn name(&self) -> &'static str {
+        "cover_variant_backfill"
+    }
+
+    fn description(&self) -> &'static str {
+        "Generate missing resized cover image variants"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Once a day after cover extraction and artist image assignment.
+        "0 45 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 variant backfill");
+            return Ok(());
+        }
+
+        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("No cover art media files found");
+            return Ok(());
+        }
+
+        log.info(&format!(
+            "Found {} cover art media file(s), checking variants...",
+            rows.len()
+        ));
+
+        let mut created = 0usize;
+        let mut unchanged = 0usize;
+        let mut missing_original = 0usize;
+        let mut failed = 0usize;
+
+        for (media_file_id, file_path) in rows {
+            let path = resolve_media_path(storage_dir, &file_path);
+            if !path.exists() {
+                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) => unchanged += 1,
+                Ok(count) => {
+                    created += count;
+                    log.info(&format!(
+                        "Media file {media_file_id}: created {count} variant(s)"
+                    ));
+                }
+                Err(err) => {
+                    failed += 1;
+                    log.warn(&format!(
+                        "Media file {media_file_id}: failed to create variants: {err}"
+                    ));
+                }
+            }
+        }
+
+        log.info(&format!(
+            "Cover variant backfill complete: {created} variant(s) created, \
+             {unchanged} original(s) already complete, {missing_original} missing original(s), \
+             {failed} failed original(s)"
+        ));
+
+        Ok(())
+    }
+}
+
+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)
+    }
+}

src/jobs/lastfm_popularity.rs

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

src/jobs/mod.rs

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

src/main.rs

@@ -52,7 +52,9 @@ fn build_registry() -> Arc<JobRegistry> {
     registry.register(jobs::cover_backfill::CoverBackfillJob);
     registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
     registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
+    registry.register(jobs::cover_variant_backfill::CoverVariantBackfillJob);
     registry.register(jobs::metadata_backfill::MetadataBackfillJob);
+    registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
     Arc::new(registry)
 }
 

src/music/mod.rs

@@ -1637,6 +1637,61 @@ pub mod db_migrations {
             &[Operation::custom(create_torrent_session).build()];
     }
 
+    // -- M0032: Last.fm track popularity ------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_lastfm_track_popularity(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_listeners BIGINT")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_playcount BIGINT")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_rating DOUBLE PRECISION")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN lastfm_updated_at VARCHAR(32)")
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__track_popularity_history (
+                    id BIGSERIAL PRIMARY KEY,
+                    track_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    listeners BIGINT NOT NULL,
+                    playcount BIGINT NOT NULL,
+                    rating DOUBLE PRECISION NOT NULL,
+                    fetched_at VARCHAR(32) NOT NULL
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_track_popularity_history_track
+                   ON furumusic__track_popularity_history (track_id, fetched_at DESC)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0032CreateLastfmTrackPopularity;
+
+    impl migrations::Migration for M0032CreateLastfmTrackPopularity {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0032_create_lastfm_track_popularity";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0031_create_torrent_session",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_lastfm_track_popularity).build()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1659,5 +1714,6 @@ pub mod db_migrations {
         &M0029AddPlaybackVolume,
         &M0030AddMediaFileUploader,
         &M0031CreateTorrentSession,
+        &M0032CreateLastfmTrackPopularity,
     ];
 }

src/oidc.rs

@@ -389,11 +389,7 @@ pub async fn oidc_callback_handler(
         config.oidc_user_groups,
     );
 
-    if !is_allowed_by_groups(
-        &groups,
-        &config.oidc_user_groups,
-        &config.oidc_admin_groups,
-    ) {
+    if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
         tracing::warn!(
             "OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
             config.oidc_user_groups,

src/player/dto.rs

@@ -64,6 +64,10 @@ pub(super) struct TrackItem {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]
@@ -84,6 +88,10 @@ pub(super) struct ArtistAppearanceTrack {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]

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

@@ -2,7 +2,9 @@ use std::sync::Arc;
 
 use cot::db::Database;
 use cot::http::StatusCode;
-use cot::http::header::{ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE};
+use cot::http::header::{
+    ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, HeaderName, RANGE,
+};
 use cot::json::Json;
 use cot::request::extractors::Path;
 use cot::response::IntoResponse;
@@ -23,7 +25,7 @@ mod queries;
 mod rows;
 
 use dto::*;
-use helpers::{cover_url, load_release_uploaders, track_cover_url};
+use helpers::{cover_variant_url, load_release_uploaders, track_cover_variant_url};
 use queries::*;
 use rows::*;
 
@@ -40,6 +42,13 @@ fn json_error(status: StatusCode, message: &str) -> cot::response::Response {
         .expect("valid response")
 }
 
+#[derive(serde::Serialize)]
+struct LocalUploadResponse {
+    ok: bool,
+    filename: String,
+    size: u64,
+}
+
 // ---------------------------------------------------------------------------
 // SPA shell
 // ---------------------------------------------------------------------------
@@ -194,7 +203,7 @@ async fn artists_handler(
         .map(|r| ArtistCard {
             id: r.id,
             name: r.name,
-            image_url: cover_url(r.image_file_id),
+            image_url: cover_variant_url(r.image_file_id, "medium"),
             release_count: r.release_count,
             track_count: r.track_count,
         })
@@ -270,7 +279,7 @@ async fn artist_detail_handler(
             title: r.title,
             release_type: r.release_type,
             year: r.year,
-            cover_url: cover_url(r.cover_file_id),
+            cover_url: cover_variant_url(r.cover_file_id, "medium"),
             track_count: r.track_count,
             uploaders: release_uploaders.remove(&r.id).unwrap_or_default(),
         })
@@ -304,7 +313,11 @@ async fn artist_detail_handler(
                   mf.audio_bitrate,
                   mf.audio_sample_rate,
                   mf.audio_bit_depth,
-                  mf.file_size_bytes
+                  mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
            FROM furumusic__track_artist ta
            JOIN furumusic__track t ON t.id = ta.track_id
            JOIN furumusic__release r ON r.id = t.release_id
@@ -373,7 +386,11 @@ async fn artist_detail_handler(
                 duration_seconds: t.duration_seconds,
                 artists: featured_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: featured_feat_artists.remove(&tid).unwrap_or_default(),
-                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                cover_url: track_cover_variant_url(
+                    t.cover_file_id,
+                    t.release_cover_file_id,
+                    "medium",
+                ),
                 stream_url: format!("/api/player/stream/{tid}"),
                 uploader_name: t.uploader_name,
                 audio_format: t.audio_format,
@@ -381,6 +398,10 @@ async fn artist_detail_handler(
                 audio_sample_rate: t.audio_sample_rate,
                 audio_bit_depth: t.audio_bit_depth,
                 file_size_bytes: t.file_size_bytes,
+                lastfm_listeners: t.lastfm_listeners,
+                lastfm_playcount: t.lastfm_playcount,
+                lastfm_rating: t.lastfm_rating,
+                lastfm_updated_at: t.lastfm_updated_at,
             }
         })
         .collect();
@@ -388,7 +409,7 @@ async fn artist_detail_handler(
     Json(ArtistDetail {
         id: artist.id,
         name: artist.name,
-        image_url: cover_url(image_file_id),
+        image_url: cover_variant_url(image_file_id, "large"),
         total_track_count,
         total_play_count,
         releases: release_cards,
@@ -450,7 +471,11 @@ async fn release_detail_handler(
                   mf.audio_bitrate,
                   mf.audio_sample_rate,
                   mf.audio_bit_depth,
-                  mf.file_size_bytes
+                  mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
            FROM furumusic__track t
            JOIN furumusic__release r ON r.id = t.release_id
            LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
@@ -518,7 +543,11 @@ async fn release_detail_handler(
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
                 release_year: t.release_year,
-                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                cover_url: track_cover_variant_url(
+                    t.cover_file_id,
+                    t.release_cover_file_id,
+                    "medium",
+                ),
                 stream_url: format!("/api/player/stream/{tid}"),
                 uploader_name: t.uploader_name,
                 audio_format: t.audio_format,
@@ -526,6 +555,10 @@ async fn release_detail_handler(
                 audio_sample_rate: t.audio_sample_rate,
                 audio_bit_depth: t.audio_bit_depth,
                 file_size_bytes: t.file_size_bytes,
+                lastfm_listeners: t.lastfm_listeners,
+                lastfm_playcount: t.lastfm_playcount,
+                lastfm_rating: t.lastfm_rating,
+                lastfm_updated_at: t.lastfm_updated_at,
             }
         })
         .collect();
@@ -540,7 +573,7 @@ async fn release_detail_handler(
         title: release.title,
         release_type: release.release_type,
         year: release.year,
-        cover_url: cover_url(release.cover_file_id),
+        cover_url: cover_variant_url(release.cover_file_id, "large"),
         artists: release_artists
             .into_iter()
             .map(|a| ArtistRef {
@@ -680,7 +713,11 @@ async fn playlist_detail_handler(
                   mf.audio_bitrate,
                   mf.audio_sample_rate,
                   mf.audio_bit_depth,
-                  mf.file_size_bytes
+                  mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
            FROM furumusic__playlist_track pt
            JOIN furumusic__track t ON t.id = pt.track_id
            JOIN furumusic__release r ON r.id = t.release_id
@@ -768,7 +805,11 @@ async fn build_track_items(
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
                 release_year: t.release_year,
-                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                cover_url: track_cover_variant_url(
+                    t.cover_file_id,
+                    t.release_cover_file_id,
+                    "medium",
+                ),
                 stream_url: format!("/api/player/stream/{tid}"),
                 uploader_name: t.uploader_name,
                 audio_format: t.audio_format,
@@ -776,6 +817,10 @@ async fn build_track_items(
                 audio_sample_rate: t.audio_sample_rate,
                 audio_bit_depth: t.audio_bit_depth,
                 file_size_bytes: t.file_size_bytes,
+                lastfm_listeners: t.lastfm_listeners,
+                lastfm_playcount: t.lastfm_playcount,
+                lastfm_rating: t.lastfm_rating,
+                lastfm_updated_at: t.lastfm_updated_at,
             }
         })
         .collect())
@@ -910,6 +955,140 @@ async fn stream_handler(
     Ok(response)
 }
 
+async fn local_upload_handler(
+    session: Session,
+    db: Database,
+    config: AppConfig,
+    scheduler_handle: Arc<tokio::sync::OnceCell<Arc<SchedulerHandle>>>,
+    request: cot::request::Request,
+) -> cot::Result<cot::http::Response<Body>> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+
+    let inbox_dir = config.agent_inbox_dir.trim();
+    if inbox_dir.is_empty() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "agent_inbox_dir is not configured",
+        ));
+    }
+    let inbox_root = std::path::PathBuf::from(inbox_dir);
+    if !inbox_root.is_absolute() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "agent_inbox_dir must be an absolute path",
+        ));
+    }
+
+    let filename_header = HeaderName::from_static("x-furumusic-filename");
+    let original_name = request
+        .headers()
+        .get(filename_header)
+        .and_then(|value| value.to_str().ok())
+        .map(percent_decode_header)
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| "upload.mp3".to_string());
+    let filename = sanitize_upload_filename(&original_name);
+
+    let bytes = request
+        .into_body()
+        .into_bytes()
+        .await
+        .map_err(|err| cot::Error::internal(err.to_string()))?;
+    if bytes.is_empty() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "uploaded file is empty",
+        ));
+    }
+
+    let upload_dir = inbox_root
+        .join("user_uploads")
+        .join(user.id.to_string())
+        .join(format!("local-{}", uuid::Uuid::new_v4()));
+    tokio::fs::create_dir_all(&upload_dir)
+        .await
+        .map_err(|err| cot::Error::internal(err.to_string()))?;
+    let destination = upload_dir.join(&filename);
+    tokio::fs::write(&destination, &bytes)
+        .await
+        .map_err(|err| cot::Error::internal(err.to_string()))?;
+
+    if let Some(handle) = scheduler_handle.get() {
+        let handle = Arc::clone(handle);
+        tokio::spawn(async move {
+            if let Err(err) = handle.trigger_job_now("inbox_discover").await {
+                tracing::warn!("failed to trigger inbox_discover after local upload: {err}");
+            }
+        });
+    }
+
+    Json(LocalUploadResponse {
+        ok: true,
+        filename,
+        size: bytes.len() as u64,
+    })
+    .into_response()
+}
+
+fn sanitize_upload_filename(value: &str) -> String {
+    let name = std::path::Path::new(value)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("upload.mp3");
+    let sanitized: String = name
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            c if c.is_control() => '_',
+            c => c,
+        })
+        .collect();
+    let trimmed = sanitized.trim().trim_matches('.').trim();
+    if trimmed.is_empty() {
+        "upload.mp3".to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn percent_decode_header(value: &str) -> String {
+    let bytes = value.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut index = 0;
+    while index < bytes.len() {
+        match bytes[index] {
+            b'%' if index + 2 < bytes.len() => {
+                let hi = hex_value(bytes[index + 1]);
+                let lo = hex_value(bytes[index + 2]);
+                if let (Some(hi), Some(lo)) = (hi, lo) {
+                    out.push((hi << 4) | lo);
+                    index += 3;
+                } else {
+                    out.push(bytes[index]);
+                    index += 1;
+                }
+            }
+            byte => {
+                out.push(byte);
+                index += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).to_string()
+}
+
+fn hex_value(byte: u8) -> Option<u8> {
+    match byte {
+        b'0'..=b'9' => Some(byte - b'0'),
+        b'a'..=b'f' => Some(byte - b'a' + 10),
+        b'A'..=b'F' => Some(byte - b'A' + 10),
+        _ => None,
+    }
+}
+
 fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
     let bytes_prefix = "bytes=";
     if !header.starts_with(bytes_prefix) {
@@ -971,13 +1150,40 @@ async fn cover_handler(
     pool: &sqlx::PgPool,
     config: &AppConfig,
     path: Path<PathMediaFileId>,
+) -> cot::Result<cot::http::Response<Body>> {
+    cover_response(session, db, pool, config, path.0.media_file_id, None).await
+}
+
+async fn cover_variant_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    config: &AppConfig,
+    path: Path<PathMediaFileVariant>,
+) -> cot::Result<cot::http::Response<Body>> {
+    cover_response(
+        session,
+        db,
+        pool,
+        config,
+        path.0.media_file_id,
+        Some(path.0.variant.as_str()),
+    )
+    .await
+}
+
+async fn cover_response(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    config: &AppConfig,
+    media_file_id: i64,
+    variant_name: Option<&str>,
 ) -> cot::Result<cot::http::Response<Body>> {
     let Some(_user) = auth::get_session_user(&session, &db).await else {
         return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
     };
 
-    let media_file_id = path.0.media_file_id;
-
     let media = sqlx::query_as::<_, MediaFileRow>(
         "SELECT file_path, mime_type::text as mime_type, file_size_bytes FROM furumusic__media_file WHERE id = $1",
     )
@@ -996,13 +1202,25 @@ async fn cover_handler(
         return Ok(json_error(StatusCode::NOT_FOUND, "file not found on disk"));
     }
 
-    let data = tokio::fs::read(&full_path)
+    let (response_path, content_type) = variant_name
+        .and_then(crate::agent::cover_variants::variant_by_name)
+        .map(|variant| {
+            let variant_path = crate::agent::cover_variants::variant_path(&full_path, variant);
+            if variant_path.exists() {
+                (variant_path, "image/jpeg")
+            } else {
+                (full_path.clone(), media.mime_type.as_str())
+            }
+        })
+        .unwrap_or_else(|| (full_path.clone(), media.mime_type.as_str()));
+
+    let data = tokio::fs::read(&response_path)
         .await
         .map_err(|e| cot::Error::internal(e.to_string()))?;
 
     let response = cot::http::Response::builder()
         .status(StatusCode::OK)
-        .header(CONTENT_TYPE, media.mime_type.as_str())
+        .header(CONTENT_TYPE, content_type)
         .header(CONTENT_LENGTH, data.len().to_string())
         .header("Cache-Control", "public, max-age=86400")
         .body(Body::fixed(data))
@@ -1264,7 +1482,11 @@ async fn search_handler(
                       mf.audio_bitrate,
                       mf.audio_sample_rate,
                       mf.audio_bit_depth,
-                      mf.file_size_bytes
+                      mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
                FROM furumusic__track t
                JOIN furumusic__release rel ON rel.id = t.release_id
                LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
@@ -1329,7 +1551,7 @@ async fn search_handler(
         let t = sqlx::query_as::<_, SearchTrackRow>(
             r#"SELECT id, title, track_number, disc_number, duration_seconds, cover_file_id,
                       release_cover_file_id, release_year, uploader_name, audio_format, audio_bitrate,
-                      audio_sample_rate, audio_bit_depth, file_size_bytes FROM (
+                      audio_sample_rate, audio_bit_depth, file_size_bytes, lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at FROM (
                 SELECT t.id, t.title::text AS title, t.track_number, t.disc_number,
                        t.duration_seconds, t.cover_file_id,
                        rel.cover_file_id AS release_cover_file_id,
@@ -1340,20 +1562,27 @@ async fn search_handler(
                        mf.audio_sample_rate,
                        mf.audio_bit_depth,
                        mf.file_size_bytes,
+                       t.lastfm_listeners,
+                       t.lastfm_playcount,
+                       t.lastfm_rating,
+                       t.lastfm_updated_at,
                        MAX(sim) AS similarity
                 FROM (
                     SELECT id, title, title_sort, track_number, disc_number, duration_seconds, cover_file_id, release_id, audio_file_id,
+                           lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at,
                            similarity(title_sort, $1) AS sim
                     FROM furumusic__track WHERE is_hidden = false AND title_sort % $1
                     UNION ALL
                     SELECT id, title, title_sort, track_number, disc_number, duration_seconds, cover_file_id, release_id, audio_file_id,
+                           lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at,
                            0.01::real AS sim
                     FROM furumusic__track WHERE is_hidden = false AND title_sort ILIKE '%' || $1 || '%'
                 ) t
                 JOIN furumusic__release rel ON rel.id = t.release_id
                 LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
                 GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id, rel.year,
-                         mf.uploader_name, mf.audio_format, mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, mf.file_size_bytes
+                         mf.uploader_name, mf.audio_format, mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, mf.file_size_bytes,
+                         t.lastfm_listeners, t.lastfm_playcount, t.lastfm_rating, t.lastfm_updated_at
                 ORDER BY similarity DESC
                 LIMIT $2
             ) sub"#,
@@ -1412,7 +1641,7 @@ async fn search_handler(
         .map(|r| ArtistCard {
             id: r.id,
             name: r.name,
-            image_url: cover_url(r.image_file_id),
+            image_url: cover_variant_url(r.image_file_id, "medium"),
             release_count: r.release_count,
             track_count: r.track_count,
         })
@@ -1430,7 +1659,7 @@ async fn search_handler(
             title: r.title,
             release_type: r.release_type,
             year: r.year,
-            cover_url: cover_url(r.cover_file_id),
+            cover_url: cover_variant_url(r.cover_file_id, "medium"),
             track_count: r.track_count,
             uploaders: release_uploaders.remove(&r.id).unwrap_or_default(),
         })
@@ -1449,7 +1678,11 @@ async fn search_handler(
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
                 release_year: t.release_year,
-                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                cover_url: track_cover_variant_url(
+                    t.cover_file_id,
+                    t.release_cover_file_id,
+                    "medium",
+                ),
                 stream_url: format!("/api/player/stream/{tid}"),
                 uploader_name: t.uploader_name,
                 audio_format: t.audio_format,
@@ -1457,6 +1690,10 @@ async fn search_handler(
                 audio_sample_rate: t.audio_sample_rate,
                 audio_bit_depth: t.audio_bit_depth,
                 file_size_bytes: t.file_size_bytes,
+                lastfm_listeners: t.lastfm_listeners,
+                lastfm_playcount: t.lastfm_playcount,
+                lastfm_rating: t.lastfm_rating,
+                lastfm_updated_at: t.lastfm_updated_at,
             }
         })
         .collect();
@@ -1915,7 +2152,7 @@ async fn followed_artists_handler(
         .map(|r| ArtistCard {
             id: r.id,
             name: r.name,
-            image_url: cover_url(r.image_file_id),
+            image_url: cover_variant_url(r.image_file_id, "small"),
             release_count: r.release_count,
             track_count: r.track_count,
         })
@@ -2021,7 +2258,11 @@ async fn tracks_by_ids_handler(
                   mf.audio_bitrate,
                   mf.audio_sample_rate,
                   mf.audio_bit_depth,
-                  mf.file_size_bytes
+                  mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
            FROM furumusic__track t
            JOIN furumusic__release r ON r.id = t.release_id
            LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
@@ -2088,7 +2329,11 @@ async fn tracks_by_ids_handler(
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
                 release_year: t.release_year,
-                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                cover_url: track_cover_variant_url(
+                    t.cover_file_id,
+                    t.release_cover_file_id,
+                    "medium",
+                ),
                 stream_url: format!("/api/player/stream/{tid}"),
                 uploader_name: t.uploader_name,
                 audio_format: t.audio_format,
@@ -2096,6 +2341,10 @@ async fn tracks_by_ids_handler(
                 audio_sample_rate: t.audio_sample_rate,
                 audio_bit_depth: t.audio_bit_depth,
                 file_size_bytes: t.file_size_bytes,
+                lastfm_listeners: t.lastfm_listeners,
+                lastfm_playcount: t.lastfm_playcount,
+                lastfm_rating: t.lastfm_rating,
+                lastfm_updated_at: t.lastfm_updated_at,
             },
         );
     }
@@ -2268,9 +2517,7 @@ impl App for PlayerApp {
                                     .await;
                                 let service = torrent_service
                                     .get_or_init(|| async {
-                                        Arc::new(TorrentService::new(Arc::clone(
-                                            &scheduler_handle,
-                                        )))
+                                        Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
                                     })
                                     .await;
                                 match service.details(pg_pool, user.id, &path.0.id).await {
@@ -2282,40 +2529,44 @@ impl App for PlayerApp {
                             }
                         }
                     })
-                    .delete(move |session: Session, db: Database, path: Path<PathStringId>| {
-                        let pool = Arc::clone(&pool);
-                        let pool_config = Arc::clone(&pool_config);
-                        let torrent_service = Arc::clone(&torrent_service);
-                        let scheduler_handle = Arc::clone(&scheduler_handle);
-                        async move {
-                            let Some(user) = auth::get_session_user(&session, &db).await else {
-                                return Ok(json_error(
-                                    StatusCode::UNAUTHORIZED,
-                                    "not authenticated",
-                                ));
-                            };
-                            let pg_pool = pool
-                                .get_or_init(|| async {
-                                    sqlx::postgres::PgPoolOptions::new()
-                                        .max_connections(5)
-                                        .connect(&pool_config.database_url)
-                                        .await
-                                        .expect("player pool")
-                                })
-                                .await;
-                            let service = torrent_service
-                                .get_or_init(|| async {
-                                    Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
-                                })
-                                .await;
-                            match service.remove(pg_pool, user.id, &path.0.id).await {
-                                Ok(()) => Json(serde_json::json!({ "ok": true })).into_response(),
-                                Err(err) => {
-                                    Ok(json_error(StatusCode::NOT_FOUND, &err.to_string()))
+                    .delete(
+                        move |session: Session, db: Database, path: Path<PathStringId>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            let torrent_service = Arc::clone(&torrent_service);
+                            let scheduler_handle = Arc::clone(&scheduler_handle);
+                            async move {
+                                let Some(user) = auth::get_session_user(&session, &db).await else {
+                                    return Ok(json_error(
+                                        StatusCode::UNAUTHORIZED,
+                                        "not authenticated",
+                                    ));
+                                };
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("player pool")
+                                    })
+                                    .await;
+                                let service = torrent_service
+                                    .get_or_init(|| async {
+                                        Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
+                                    })
+                                    .await;
+                                match service.remove(pg_pool, user.id, &path.0.id).await {
+                                    Ok(()) => {
+                                        Json(serde_json::json!({ "ok": true })).into_response()
+                                    }
+                                    Err(err) => {
+                                        Ok(json_error(StatusCode::NOT_FOUND, &err.to_string()))
+                                    }
                                 }
                             }
-                        }
-                    })
+                        },
+                    )
                 },
                 "player_torrent_detail",
             ),
@@ -2365,6 +2616,29 @@ impl App for PlayerApp {
                 },
                 "player_torrent_preview",
             ),
+            Route::with_handler_and_name(
+                "/uploads/local",
+                {
+                    let scheduler_handle = Arc::clone(&self.scheduler_handle);
+                    post(
+                        move |session: Session, db: Database, request: cot::request::Request| {
+                            let scheduler_handle = Arc::clone(&scheduler_handle);
+                            async move {
+                                let (live_config, _) = AppConfig::load_with_db(&db).await;
+                                local_upload_handler(
+                                    session,
+                                    db,
+                                    live_config,
+                                    scheduler_handle,
+                                    request,
+                                )
+                                .await
+                            }
+                        },
+                    )
+                },
+                "player_local_upload",
+            ),
             Route::with_handler_and_name(
                 "/torrents/{id}/start",
                 {
@@ -2431,40 +2705,42 @@ impl App for PlayerApp {
                     let pool_config = Arc::clone(&pool_config);
                     let torrent_service = Arc::clone(&torrent_service);
                     let scheduler_handle = Arc::clone(&self.scheduler_handle);
-                    post(move |session: Session, db: Database, path: Path<PathStringId>| {
-                        let pool = Arc::clone(&pool);
-                        let pool_config = Arc::clone(&pool_config);
-                        let torrent_service = Arc::clone(&torrent_service);
-                        let scheduler_handle = Arc::clone(&scheduler_handle);
-                        async move {
-                            let Some(user) = auth::get_session_user(&session, &db).await else {
-                                return Ok(json_error(
-                                    StatusCode::UNAUTHORIZED,
-                                    "not authenticated",
-                                ));
-                            };
-                            let pg_pool = pool
-                                .get_or_init(|| async {
-                                    sqlx::postgres::PgPoolOptions::new()
-                                        .max_connections(5)
-                                        .connect(&pool_config.database_url)
-                                        .await
-                                        .expect("player pool")
-                                })
-                                .await;
-                            let service = torrent_service
-                                .get_or_init(|| async {
-                                    Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
-                                })
-                                .await;
-                            match service.pause(pg_pool, user.id, &path.0.id).await {
-                                Ok(job) => Json(job).into_response(),
-                                Err(err) => {
-                                    Ok(json_error(StatusCode::BAD_REQUEST, &err.to_string()))
+                    post(
+                        move |session: Session, db: Database, path: Path<PathStringId>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            let torrent_service = Arc::clone(&torrent_service);
+                            let scheduler_handle = Arc::clone(&scheduler_handle);
+                            async move {
+                                let Some(user) = auth::get_session_user(&session, &db).await else {
+                                    return Ok(json_error(
+                                        StatusCode::UNAUTHORIZED,
+                                        "not authenticated",
+                                    ));
+                                };
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("player pool")
+                                    })
+                                    .await;
+                                let service = torrent_service
+                                    .get_or_init(|| async {
+                                        Arc::new(TorrentService::new(Arc::clone(&scheduler_handle)))
+                                    })
+                                    .await;
+                                match service.pause(pg_pool, user.id, &path.0.id).await {
+                                    Ok(job) => Json(job).into_response(),
+                                    Err(err) => {
+                                        Ok(json_error(StatusCode::BAD_REQUEST, &err.to_string()))
+                                    }
                                 }
                             }
-                        }
-                    })
+                        },
+                    )
                 },
                 "player_torrent_pause",
             ),
@@ -2913,6 +3189,34 @@ impl App for PlayerApp {
                 "player_stream",
             ),
             // -- Cover art --
+            Route::with_handler_and_name(
+                "/cover/{media_file_id}/{variant}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    let config = Arc::clone(&self.config);
+                    get(
+                        move |session: Session, db: Database, path: Path<PathMediaFileVariant>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            let config = Arc::clone(&config);
+                            async move {
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("player pool")
+                                    })
+                                    .await;
+                                cover_variant_handler(session, db, pg_pool, &config, path).await
+                            }
+                        },
+                    )
+                },
+                "player_cover_variant",
+            ),
             Route::with_handler_and_name(
                 "/cover/{media_file_id}",
                 {

src/player/queries.rs

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

@@ -44,6 +44,10 @@ pub(super) struct TrackRow {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]
@@ -110,6 +114,10 @@ pub(super) struct PlaylistTrackRow {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]
@@ -128,6 +136,10 @@ pub(super) struct AppearanceTrackRow {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]
@@ -165,6 +177,10 @@ pub(super) struct SearchTrackRow {
     pub(super) audio_sample_rate: Option<i32>,
     pub(super) audio_bit_depth: Option<i32>,
     pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]

src/scheduler/mod.rs

@@ -1347,7 +1347,7 @@ async fn run_scheduled_job(
 
     // Check agent_enabled (re-read from DB every run)
     let (live_config, _) = AppConfig::load_with_db(db).await;
-    if !live_config.agent_enabled {
+    if !live_config.agent_enabled && job_name != "lastfm_popularity" {
         tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
         return;
     }

src/torrents.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
@@ -98,6 +98,7 @@ pub struct TorrentStartRequest {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum TorrentJobStatus {
+    Resolving,
     Preview,
     Downloading,
     Moving,
@@ -110,6 +111,7 @@ impl TorrentJobStatus {
     fn as_str(self) -> &'static str {
         match self {
             Self::Preview => "preview",
+            Self::Resolving => "resolving",
             Self::Downloading => "downloading",
             Self::Moving => "moving",
             Self::Complete => "complete",
@@ -121,6 +123,7 @@ impl TorrentJobStatus {
     fn from_str(value: &str) -> Self {
         match value {
             "downloading" => Self::Downloading,
+            "resolving" => Self::Resolving,
             "moving" => Self::Moving,
             "complete" => Self::Complete,
             "failed" => Self::Failed,
@@ -351,7 +354,7 @@ impl TorrentJob {
                 100.0
             } else {
                 progress_percent(downloaded_bytes, total_bytes)
-                .unwrap_or(self.progress_percent)
+                    .unwrap_or(self.progress_percent)
                     .clamp(0.0, 100.0)
             },
             download_speed_mbps: live.map(|l| l.download_speed.mbps),
@@ -372,6 +375,7 @@ pub struct TorrentService {
     temp_root: PathBuf,
     session: OnceCell<Arc<Session>>,
     jobs: Mutex<HashMap<String, TorrentJob>>,
+    resolving_jobs: Mutex<HashSet<String>>,
     scheduler_handle: Arc<OnceCell<Arc<SchedulerHandle>>>,
 }
 
@@ -381,6 +385,7 @@ impl TorrentService {
             temp_root: std::env::temp_dir().join("furumusic").join("torrents"),
             session: OnceCell::new(),
             jobs: Mutex::new(HashMap::new()),
+            resolving_jobs: Mutex::new(HashSet::new()),
             scheduler_handle,
         }
     }
@@ -404,7 +409,11 @@ impl TorrentService {
             .cloned()
     }
 
-    pub async fn list(&self, pool: &PgPool, user_id: i64) -> anyhow::Result<Vec<TorrentJobDto>> {
+    pub async fn list(
+        self: &Arc<Self>,
+        pool: &PgPool,
+        user_id: i64,
+    ) -> anyhow::Result<Vec<TorrentJobDto>> {
         let rows = sqlx::query_as::<_, TorrentSessionRow>(
             r#"SELECT id, user_id, name, info_hash, source_kind, source_label, torrent_bytes,
                       files_json, selected_files_json, status, total_size, selected_size,
@@ -412,7 +421,7 @@ impl TorrentService {
                       created_at, updated_at, completed_at
                  FROM furumusic__torrent_session
                 WHERE user_id = $1
-                ORDER BY updated_at DESC, created_at DESC
+                ORDER BY created_at DESC, id DESC
                 LIMIT $2"#,
         )
         .bind(user_id)
@@ -427,6 +436,21 @@ impl TorrentService {
                 .collect::<HashMap<_, _>>()
         };
 
+        for row in rows.iter().filter(|row| row.status == "resolving") {
+            if row.source_kind == "magnet" {
+                if let Some(magnet) = row.source_label.clone() {
+                    self.spawn_resolve_pending_magnet(
+                        pool.clone(),
+                        user_id,
+                        row.id.clone(),
+                        magnet,
+                        row.created_at.clone(),
+                    )
+                    .await;
+                }
+            }
+        }
+
         Ok(rows
             .iter()
             .map(|row| row.dto(handles.get(&row.id)))
@@ -455,7 +479,7 @@ impl TorrentService {
     }
 
     pub async fn preview(
-        &self,
+        self: &Arc<Self>,
         pool: &PgPool,
         user_id: i64,
         request: TorrentPreviewRequest,
@@ -473,42 +497,50 @@ impl TorrentService {
             .filter(|s| !s.is_empty())
             .map(str::to_owned);
 
-        let add = match request.kind {
-            TorrentPreviewKind::Magnet => {
-                let magnet = request
-                    .magnet
-                    .as_deref()
-                    .map(str::trim)
-                    .filter(|s| !s.is_empty())
-                    .context("magnet link is empty")?;
-                AddTorrent::from_url(magnet.to_string())
-            }
-            TorrentPreviewKind::TorrentFile => {
-                let encoded = request
-                    .torrent_base64
-                    .as_deref()
-                    .filter(|s| !s.is_empty())
-                    .context("torrent file is empty")?;
-                let bytes = base64::engine::general_purpose::STANDARD
-                    .decode(encoded)
-                    .context("invalid torrent file encoding")?;
-                AddTorrent::from_bytes(bytes)
-            }
-        };
+        if matches!(request.kind, TorrentPreviewKind::Magnet) {
+            let magnet = request
+                .magnet
+                .as_deref()
+                .map(str::trim)
+                .filter(|s| !s.is_empty())
+                .context("magnet link is empty")?
+                .to_string();
+            let info_hash = extract_magnet_info_hash(&magnet).context("invalid magnet link")?;
+            let name = magnet_display_name(&magnet)
+                .or(source_label)
+                .unwrap_or_else(|| info_hash.clone());
+            let now = now_string();
+            insert_pending_magnet(pool, &id, user_id, &name, &info_hash, &magnet, &now).await?;
+            self.spawn_resolve_pending_magnet(pool.clone(), user_id, id.clone(), magnet, now)
+                .await;
 
-        let response = tokio::time::timeout(
-            METADATA_TIMEOUT,
-            session.add_torrent(
-                add,
+            let row = load_row(pool, user_id, &id).await?;
+            return Ok(TorrentSessionDto {
+                job: row.dto(None),
+                preview: row.preview()?,
+                selected_files: row.selected_files(),
+            });
+        }
+
+        let encoded = request
+            .torrent_base64
+            .as_deref()
+            .filter(|s| !s.is_empty())
+            .context("torrent file is empty")?;
+        let bytes = base64::engine::general_purpose::STANDARD
+            .decode(encoded)
+            .context("invalid torrent file encoding")?;
+
+        let response = session
+            .add_torrent(
+                AddTorrent::from_bytes(bytes),
                 Some(AddTorrentOptions {
                     list_only: true,
                     output_folder: Some(output_dir.to_string_lossy().to_string()),
                     ..Default::default()
                 }),
-            ),
-        )
-        .await
-        .context("timed out while resolving torrent metadata")??;
+            )
+            .await?;
 
         let AddTorrentResponse::ListOnly(list) = response else {
             bail!("torrent was unexpectedly added instead of previewed");
@@ -572,6 +604,114 @@ impl TorrentService {
         Ok(dto)
     }
 
+    async fn spawn_resolve_pending_magnet(
+        self: &Arc<Self>,
+        pool: PgPool,
+        user_id: i64,
+        id: String,
+        magnet: String,
+        created_at: String,
+    ) {
+        {
+            let mut resolving = self.resolving_jobs.lock().await;
+            if !resolving.insert(id.clone()) {
+                return;
+            }
+        }
+
+        let service = Arc::clone(self);
+        tokio::spawn(async move {
+            let result = service
+                .resolve_pending_magnet(&pool, user_id, &id, &magnet, &created_at)
+                .await;
+            if let Err(err) = result {
+                update_resolving_error(&pool, &id, &err.to_string()).await;
+            }
+            service.resolving_jobs.lock().await.remove(&id);
+        });
+    }
+
+    async fn resolve_pending_magnet(
+        &self,
+        pool: &PgPool,
+        user_id: i64,
+        id: &str,
+        magnet: &str,
+        created_at: &str,
+    ) -> anyhow::Result<()> {
+        let session = self.session().await?;
+        let output_dir = self.temp_root.join(id).join("download");
+        tokio::fs::create_dir_all(&output_dir).await?;
+        let response = tokio::time::timeout(
+            METADATA_TIMEOUT,
+            session.add_torrent(
+                AddTorrent::from_url(magnet.to_string()),
+                Some(AddTorrentOptions {
+                    list_only: true,
+                    output_folder: Some(output_dir.to_string_lossy().to_string()),
+                    ..Default::default()
+                }),
+            ),
+        )
+        .await
+        .context("timed out while resolving torrent metadata")??;
+
+        let AddTorrentResponse::ListOnly(list) = response else {
+            bail!("torrent was unexpectedly added instead of previewed");
+        };
+
+        let name = list
+            .info
+            .name
+            .as_ref()
+            .map(|b| String::from_utf8_lossy(b.as_ref()).to_string())
+            .filter(|s| !s.is_empty())
+            .or_else(|| magnet_display_name(magnet))
+            .unwrap_or_else(|| list.info_hash.as_string());
+
+        let mut files = Vec::new();
+        for (index, details) in list.info.iter_file_details()?.enumerate() {
+            let name = details
+                .filename
+                .to_string()
+                .unwrap_or_else(|_| "<invalid filename>".to_string());
+            files.push(TorrentFileDto {
+                index,
+                name,
+                components: details.filename.to_vec().unwrap_or_default(),
+                length: details.len,
+                selected: true,
+            });
+        }
+
+        let selected_files = files.iter().map(|f| f.index).collect::<Vec<_>>();
+        let job = TorrentJob {
+            id: id.to_string(),
+            user_id,
+            name,
+            info_hash: list.info_hash.as_string(),
+            source_kind: "magnet".to_string(),
+            source_label: Some(magnet.to_string()),
+            torrent_bytes: list.torrent_bytes.to_vec(),
+            files,
+            status: TorrentJobStatus::Preview,
+            output_dir,
+            selected_files,
+            handle: None,
+            downloaded_bytes: 0,
+            uploaded_bytes: 0,
+            progress_percent: 0.0,
+            error: None,
+            created_at: created_at.to_string(),
+            updated_at: now_string(),
+            completed_at: None,
+        };
+
+        update_resolved_job(pool, &job).await?;
+        self.jobs.lock().await.insert(id.to_string(), job);
+        Ok(())
+    }
+
     pub async fn status(
         &self,
         pool: &PgPool,
@@ -606,13 +746,12 @@ impl TorrentService {
             self.stop_torrent(&handle).await;
         }
 
-        let result = sqlx::query(
-            "DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2",
-        )
-        .bind(id)
-        .bind(user_id)
-        .execute(pool)
-        .await?;
+        let result =
+            sqlx::query("DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2")
+                .bind(id)
+                .bind(user_id)
+                .execute(pool)
+                .await?;
 
         if result.rows_affected() == 0 {
             bail!("torrent session not found");
@@ -644,7 +783,12 @@ impl TorrentService {
             if job.user_id != uploader_user_id {
                 bail!("torrent job not found");
             }
-            if job.handle.is_some() && matches!(job.status, TorrentJobStatus::Downloading | TorrentJobStatus::Moving) {
+            if job.handle.is_some()
+                && matches!(
+                    job.status,
+                    TorrentJobStatus::Downloading | TorrentJobStatus::Moving
+                )
+            {
                 bail!("torrent job is already running");
             }
             validate_selection(&job.files, &selected_files)?;
@@ -949,6 +1093,89 @@ async fn insert_job(pool: &PgPool, job: &TorrentJob) -> anyhow::Result<()> {
     Ok(())
 }
 
+async fn insert_pending_magnet(
+    pool: &PgPool,
+    id: &str,
+    user_id: i64,
+    name: &str,
+    info_hash: &str,
+    magnet: &str,
+    now: &str,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"INSERT INTO furumusic__torrent_session
+              (id, user_id, name, info_hash, source_kind, source_label, torrent_bytes,
+               files_json, selected_files_json, status, total_size, selected_size,
+               downloaded_bytes, uploaded_bytes, progress_percent, error,
+               created_at, updated_at, completed_at)
+           VALUES ($1, $2, $3, $4, 'magnet', $5, $6,
+                   '[]', '[]', 'resolving', 0, 0,
+                   0, 0, 0, NULL,
+                   $7, $8, NULL)"#,
+    )
+    .bind(id)
+    .bind(user_id)
+    .bind(name)
+    .bind(info_hash)
+    .bind(magnet)
+    .bind(Vec::<u8>::new())
+    .bind(now)
+    .bind(now)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn update_resolved_job(pool: &PgPool, job: &TorrentJob) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__torrent_session
+              SET name = $2,
+                  info_hash = $3,
+                  torrent_bytes = $4,
+                  files_json = $5,
+                  selected_files_json = $6,
+                  status = 'preview',
+                  total_size = $7,
+                  selected_size = $8,
+                  downloaded_bytes = 0,
+                  uploaded_bytes = 0,
+                  progress_percent = 0,
+                  error = NULL,
+                  updated_at = $9,
+                  completed_at = NULL
+            WHERE id = $1"#,
+    )
+    .bind(&job.id)
+    .bind(&job.name)
+    .bind(&job.info_hash)
+    .bind(&job.torrent_bytes)
+    .bind(serde_json::to_string(&job.files)?)
+    .bind(serde_json::to_string(&job.selected_files)?)
+    .bind(u64_to_i64(job.total_size()))
+    .bind(u64_to_i64(job.selected_size()))
+    .bind(&job.updated_at)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn update_resolving_error(pool: &PgPool, id: &str, error: &str) {
+    if let Err(err) = sqlx::query(
+        r#"UPDATE furumusic__torrent_session
+              SET error = $2,
+                  updated_at = $3
+            WHERE id = $1 AND status = 'resolving'"#,
+    )
+    .bind(id)
+    .bind(error)
+    .bind(now_string())
+    .execute(pool)
+    .await
+    {
+        tracing::warn!("failed to persist torrent metadata resolving error: {err}");
+    }
+}
+
 async fn mark_job_started(
     pool: &PgPool,
     id: &str,
@@ -1056,6 +1283,65 @@ fn i64_to_u64(value: i64) -> u64 {
     value.max(0) as u64
 }
 
+fn extract_magnet_info_hash(magnet: &str) -> Option<String> {
+    if !magnet.starts_with("magnet:?") {
+        return None;
+    }
+    magnet
+        .split(['?', '&'])
+        .find_map(|part| part.strip_prefix("xt=urn:btih:"))
+        .map(|hash| percent_decode(hash).to_ascii_lowercase())
+        .filter(|hash| !hash.is_empty())
+}
+
+fn magnet_display_name(magnet: &str) -> Option<String> {
+    magnet
+        .split(['?', '&'])
+        .find_map(|part| part.strip_prefix("dn="))
+        .map(percent_decode)
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn percent_decode(value: &str) -> String {
+    let bytes = value.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut index = 0;
+    while index < bytes.len() {
+        match bytes[index] {
+            b'+' => {
+                out.push(b' ');
+                index += 1;
+            }
+            b'%' if index + 2 < bytes.len() => {
+                let hi = hex_value(bytes[index + 1]);
+                let lo = hex_value(bytes[index + 2]);
+                if let (Some(hi), Some(lo)) = (hi, lo) {
+                    out.push((hi << 4) | lo);
+                    index += 3;
+                } else {
+                    out.push(bytes[index]);
+                    index += 1;
+                }
+            }
+            byte => {
+                out.push(byte);
+                index += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).to_string()
+}
+
+fn hex_value(byte: u8) -> Option<u8> {
+    match byte {
+        b'0'..=b'9' => Some(byte - b'0'),
+        b'a'..=b'f' => Some(byte - b'a' + 10),
+        b'A'..=b'F' => Some(byte - b'A' + 10),
+        _ => None,
+    }
+}
+
 fn sanitize_path_component(value: &str) -> String {
     let sanitized: String = value
         .chars()

templates/admin/v2.html

@@ -667,6 +667,161 @@ tbody tr:hover {
     display: block;
 }
 
+.settings-page {
+    max-width: none;
+}
+
+.settings-layout {
+    display: grid;
+    grid-template-columns: minmax(620px, 1fr) minmax(360px, 440px);
+    gap: 14px;
+    align-items: start;
+}
+
+.settings-column {
+    display: grid;
+    gap: 14px;
+    align-content: start;
+}
+
+.settings-side .settings-grid {
+    grid-template-columns: minmax(0, 1fr);
+}
+
+.settings-actions {
+    grid-column: 1 / -1;
+}
+
+.settings-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 10px;
+    padding: 14px;
+}
+
+.settings-card {
+    padding: 14px;
+}
+
+.setting-field {
+    min-width: 0;
+}
+
+.setting-field label,
+.setting-toggle label {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    margin-bottom: 6px;
+    color: var(--text-secondary);
+    font-size: 11px;
+    font-weight: 800;
+    text-transform: uppercase;
+}
+
+.setting-field input {
+    width: 100%;
+    height: 34px;
+    padding: 0 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    outline: none;
+}
+
+.setting-field input:focus {
+    border-color: var(--accent);
+}
+
+.setting-toggle {
+    min-height: 74px;
+    padding: 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
+.setting-toggle-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+}
+
+.setting-toggle-row span {
+    color: var(--text-primary);
+    font-size: 13px;
+    font-weight: 800;
+}
+
+.setting-toggle input {
+    width: 18px;
+    height: 18px;
+    accent-color: var(--accent);
+}
+
+.setting-help {
+    margin-top: 6px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    line-height: 1.4;
+}
+
+.source-pill {
+    flex: 0 0 auto;
+    display: inline-flex;
+    align-items: center;
+    height: 18px;
+    padding: 0 6px;
+    border-radius: 999px;
+    background: rgba(255, 255, 255, 0.08);
+    color: var(--text-subdued);
+    font-size: 10px;
+    font-weight: 850;
+    text-transform: lowercase;
+}
+
+.source-pill.env { background: rgba(90, 167, 255, 0.16); color: #9ccbff; }
+.source-pill.database { background: rgba(29, 185, 84, 0.16); color: #8ef0b2; }
+.source-pill.default { background: rgba(255, 255, 255, 0.08); color: var(--text-subdued); }
+
+.settings-wide {
+    grid-column: 1 / -1;
+}
+
+.settings-note {
+    padding: 14px;
+    color: var(--text-secondary);
+    font-size: 12px;
+    line-height: 1.55;
+}
+
+.probe-body {
+    padding: 14px;
+}
+
+.probe-intro {
+    margin: 0 0 12px;
+    color: var(--text-primary);
+    font-size: 13px;
+    line-height: 1.45;
+}
+
+.probe-table {
+    display: grid;
+    gap: 7px;
+    color: var(--text-secondary);
+    font-size: 12px;
+}
+
+.probe-row {
+    display: flex;
+    justify-content: space-between;
+    gap: 10px;
+}
+
 .library-row {
     display: grid;
     grid-template-columns: 38px minmax(0, 1fr) 300px 130px;
@@ -799,40 +954,45 @@ tbody tr:hover {
 
         <div class="nav-group">
             <div class="nav-label">Operations</div>
-            <button class="nav-btn" :class="{active: activeView === 'reviews'}" @click="activeView = 'reviews'">
+            <button class="nav-btn" :class="{active: activeView === 'reviews'}" @click="openReviews()">
                 <i data-lucide="inbox"></i>
                 <span>Review Queue</span>
                 <span class="nav-count" x-text="reviews.total || 0"></span>
             </button>
-            <button class="nav-btn" :class="{active: activeView === 'jobs'}" @click="activeView = 'jobs'; loadJobs()">
+            <button class="nav-btn" :class="{active: activeView === 'jobs'}" @click="openJobs()">
                 <i data-lucide="calendar-clock"></i>
                 <span>Tasks</span>
                 <span class="nav-count" x-text="jobs.length || 0"></span>
             </button>
-            <button class="nav-btn" :class="{active: activeView === 'library'}" @click="activeView = 'library'; loadLibrary()">
+            <button class="nav-btn" :class="{active: activeView === 'library'}" @click="openLibrary(libraryKind)">
                 <i data-lucide="library"></i>
                 <span>Library Workbench</span>
                 <span class="nav-count" x-text="fmt(stats.tracks || 0)"></span>
             </button>
-            <button class="nav-btn" :class="{active: activeView === 'tools'}" @click="activeView = 'tools'">
+            <button class="nav-btn" :class="{active: activeView === 'tools'}" @click="openTools()">
                 <i data-lucide="wrench"></i>
                 <span>Future Tools</span>
             </button>
+            <button class="nav-btn" :class="{active: activeView === 'settings'}" @click="openSettings()">
+                <i data-lucide="settings"></i>
+                <span>Settings</span>
+                <span class="nav-count" x-text="settings.lastfm_api_key_configured ? 'ok' : ''"></span>
+            </button>
         </div>
 
         <div class="nav-group">
             <div class="nav-label">Entities</div>
-            <button class="nav-btn" @click="activeView = 'library'; libraryKind = 'artists'; loadLibrary()">
+            <button class="nav-btn" @click="openLibrary('artists')">
                 <i data-lucide="mic-2"></i>
                 <span>Artists</span>
                 <span class="nav-count" x-text="fmt(libraryOverview.artists || 0)"></span>
             </button>
-            <button class="nav-btn" @click="activeView = 'library'; libraryKind = 'releases'; loadLibrary()">
+            <button class="nav-btn" @click="openLibrary('releases')">
                 <i data-lucide="disc-3"></i>
                 <span>Releases</span>
                 <span class="nav-count" x-text="fmt(libraryOverview.releases || 0)"></span>
             </button>
-            <button class="nav-btn" @click="activeView = 'library'; libraryKind = 'playlists'; loadLibrary()">
+            <button class="nav-btn" @click="openLibrary('playlists')">
                 <i data-lucide="list-music"></i>
                 <span>Playlists</span>
                 <span class="nav-count" x-text="fmt(libraryOverview.playlists || 0)"></span>
@@ -1130,9 +1290,9 @@ tbody tr:hover {
                         </div>
                         <div class="toolbar">
                             <div class="segmented">
-                                <button class="seg-btn" :class="{active: libraryKind === 'artists'}" @click="libraryKind = 'artists'; loadLibrary()">Artists</button>
-                                <button class="seg-btn" :class="{active: libraryKind === 'releases'}" @click="libraryKind = 'releases'; loadLibrary()">Releases</button>
-                                <button class="seg-btn" :class="{active: libraryKind === 'playlists'}" @click="libraryKind = 'playlists'; loadLibrary()">Playlists</button>
+                                <button class="seg-btn" :class="{active: libraryKind === 'artists'}" @click="openLibrary('artists')">Artists</button>
+                                <button class="seg-btn" :class="{active: libraryKind === 'releases'}" @click="openLibrary('releases')">Releases</button>
+                                <button class="seg-btn" :class="{active: libraryKind === 'playlists'}" @click="openLibrary('playlists')">Playlists</button>
                             </div>
                             <input class="search" placeholder="Search library" x-model="librarySearch" @input.debounce.350ms="loadLibrary()" />
                         </div>
@@ -1236,6 +1396,253 @@ tbody tr:hover {
                 </div>
             </section>
         </div>
+
+        <div class="content" x-show="activeView === 'settings'">
+            <div class="settings-page">
+                <form class="settings-layout" @submit.prevent="saveSettings()">
+                    <div class="settings-column">
+                        <section class="panel">
+                            <div class="panel-head">
+                                <div class="panel-title">
+                                    <strong>OIDC</strong>
+                                    <span>Identity provider and group mapping</span>
+                                </div>
+                            </div>
+                            <div class="settings-grid">
+                                <div class="setting-field settings-wide">
+                                    <label>Callback URL</label>
+                                    <input readonly :value="callbackUrl()" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>SSO button text</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_button_text')" x-text="settingSource('oidc_button_text')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.oidc_button_text" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Issuer URL</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_issuer')" x-text="settingSource('oidc_issuer')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.oidc_issuer" placeholder="https://accounts.google.com" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Client ID</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_client_id')" x-text="settingSource('oidc_client_id')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.oidc_client_id" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Client secret</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_client_secret')" x-text="settingSource('oidc_client_secret')"></span>
+                                    </label>
+                                    <input type="password" x-model="settingsDraft.oidc_client_secret" autocomplete="off" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Admin groups</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_admin_groups')" x-text="settingSource('oidc_admin_groups')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.oidc_admin_groups" placeholder="/admin,/furumusic-admins" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>User groups</span>
+                                        <span class="source-pill" :class="sourceClass('oidc_user_groups')" x-text="settingSource('oidc_user_groups')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.oidc_user_groups" />
+                                </div>
+                            </div>
+                        </section>
+
+                        <section class="panel">
+                            <div class="panel-head">
+                                <div class="panel-title">
+                                    <strong>Agent</strong>
+                                    <span>AI processing directories, LLM endpoint, and execution limits</span>
+                                </div>
+                            </div>
+                            <div class="settings-grid">
+                                <div class="setting-toggle">
+                                    <label>
+                                        <span>Agent enabled</span>
+                                        <span class="source-pill" :class="sourceClass('agent_enabled')" x-text="settingSource('agent_enabled')"></span>
+                                    </label>
+                                    <div class="setting-toggle-row">
+                                        <span x-text="settingsDraft.agent_enabled ? 'Enabled' : 'Disabled'"></span>
+                                        <input type="checkbox" x-model="settingsDraft.agent_enabled" />
+                                    </div>
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Concurrency</span>
+                                        <span class="source-pill" :class="sourceClass('agent_concurrency')" x-text="settingSource('agent_concurrency')"></span>
+                                    </label>
+                                    <input type="number" min="1" max="32" x-model="settingsDraft.agent_concurrency" />
+                                </div>
+                                <div class="setting-field settings-wide">
+                                    <label>
+                                        <span>Inbox directory</span>
+                                        <span class="source-pill" :class="sourceClass('agent_inbox_dir')" x-text="settingSource('agent_inbox_dir')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_inbox_dir" />
+                                </div>
+                                <div class="setting-field settings-wide">
+                                    <label>
+                                        <span>Storage directory</span>
+                                        <span class="source-pill" :class="sourceClass('agent_storage_dir')" x-text="settingSource('agent_storage_dir')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_storage_dir" />
+                                </div>
+                                <div class="setting-field settings-wide">
+                                    <label>
+                                        <span>LLM API URL</span>
+                                        <span class="source-pill" :class="sourceClass('agent_llm_url')" x-text="settingSource('agent_llm_url')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_llm_url" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>LLM model</span>
+                                        <span class="source-pill" :class="sourceClass('agent_llm_model')" x-text="settingSource('agent_llm_model')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_llm_model" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>LLM auth header</span>
+                                        <span class="source-pill" :class="sourceClass('agent_llm_auth')" x-text="settingSource('agent_llm_auth')"></span>
+                                    </label>
+                                    <input type="password" x-model="settingsDraft.agent_llm_auth" autocomplete="off" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Confidence threshold</span>
+                                        <span class="source-pill" :class="sourceClass('agent_confidence_threshold')" x-text="settingSource('agent_confidence_threshold')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_confidence_threshold" />
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Context limit</span>
+                                        <span class="source-pill" :class="sourceClass('agent_context_limit')" x-text="settingSource('agent_context_limit')"></span>
+                                    </label>
+                                    <input x-model="settingsDraft.agent_context_limit" />
+                                </div>
+                            </div>
+                        </section>
+                    </div>
+
+                    <div class="settings-column settings-side">
+                        <section class="panel">
+                            <div class="panel-head">
+                                <div class="panel-title">
+                                    <strong>Authentication</strong>
+                                    <span>Password and SSO access switches</span>
+                                </div>
+                            </div>
+                            <div class="settings-grid">
+                                <div class="setting-toggle">
+                                    <label>
+                                        <span>Password login</span>
+                                        <span class="source-pill" :class="sourceClass('auth_password_enabled')" x-text="settingSource('auth_password_enabled')"></span>
+                                    </label>
+                                    <div class="setting-toggle-row">
+                                        <span x-text="settingsDraft.auth_password_enabled ? 'Enabled' : 'Disabled'"></span>
+                                        <input type="checkbox" x-model="settingsDraft.auth_password_enabled" />
+                                    </div>
+                                </div>
+                                <div class="setting-toggle">
+                                    <label>
+                                        <span>SSO login</span>
+                                        <span class="source-pill" :class="sourceClass('auth_sso_enabled')" x-text="settingSource('auth_sso_enabled')"></span>
+                                    </label>
+                                    <div class="setting-toggle-row">
+                                        <span x-text="settingsDraft.auth_sso_enabled ? 'Enabled' : 'Disabled'"></span>
+                                        <input type="checkbox" x-model="settingsDraft.auth_sso_enabled" />
+                                    </div>
+                                </div>
+                            </div>
+                        </section>
+
+                        <section class="panel">
+                            <div class="panel-head">
+                                <div class="panel-title">
+                                    <strong>API</strong>
+                                    <span>Developer and enrichment integrations</span>
+                                </div>
+                                <span class="badge" :class="settings.lastfm_api_key_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_api_key_configured ? 'Last.fm configured' : 'Last.fm missing'"></span>
+                            </div>
+                            <div class="settings-grid">
+                                <div class="setting-toggle">
+                                    <label>
+                                        <span>Swagger UI</span>
+                                        <span class="source-pill" :class="sourceClass('swagger_enabled')" x-text="settingSource('swagger_enabled')"></span>
+                                    </label>
+                                    <div class="setting-toggle-row">
+                                        <span x-text="settingsDraft.swagger_enabled ? 'Enabled' : 'Disabled'"></span>
+                                        <input type="checkbox" x-model="settingsDraft.swagger_enabled" />
+                                    </div>
+                                    <div class="setting-help">Interactive API docs at /swagger/ after restart.</div>
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>Last.fm API key</span>
+                                        <span class="source-pill" :class="sourceClass('lastfm_api_key')" x-text="settingSource('lastfm_api_key')"></span>
+                                    </label>
+                                    <input type="password" x-model="settingsDraft.lastfm_api_key" autocomplete="off" />
+                                    <div class="setting-help">Used by the weekly Last.fm popularity task.</div>
+                                </div>
+                            </div>
+                        </section>
+
+                        <section class="panel">
+                            <div class="panel-head">
+                                <div class="panel-title">
+                                    <strong>Agent Status</strong>
+                                    <span x-text="settingsProbeSubtitle()"></span>
+                                </div>
+                                <span class="badge" :class="settingsProbeBadge()" x-text="settingsProbe.status || 'idle'"></span>
+                            </div>
+                            <div class="probe-body">
+                                <p class="probe-intro" x-show="settingsProbe.model_intro" x-text="settingsProbe.model_intro"></p>
+                                <p class="probe-intro muted" x-show="!settingsProbe.model_intro" x-text="settingsProbeText()"></p>
+                                <div class="probe-table" x-show="settingsProbe.ok">
+                                    <div class="probe-row"><span>Model</span><strong x-text="settingsProbe.model_name || 'unknown'"></strong></div>
+                                    <div class="probe-row"><span>Latency</span><strong x-text="settingsProbe.latency_ms + ' ms'"></strong></div>
+                                    <div class="probe-row"><span>Prompt tokens</span><strong x-text="settingsProbe.prompt_tokens ?? '-'"></strong></div>
+                                    <div class="probe-row"><span>Completion tokens</span><strong x-text="settingsProbe.completion_tokens ?? '-'"></strong></div>
+                                    <div class="probe-row"><span>Tokens/sec</span><strong x-text="settingsProbe.tokens_per_sec != null ? settingsProbe.tokens_per_sec.toFixed(1) : '-'"></strong></div>
+                                </div>
+                                <div class="toolbar" style="margin-top:14px">
+                                    <button class="btn" type="button" @click="loadSettingsProbe()" :disabled="settingsProbeLoading">
+                                        <i data-lucide="activity"></i>
+                                        Test agent
+                                    </button>
+                                </div>
+                            </div>
+                        </section>
+                    </div>
+
+                    <div class="action-strip settings-actions">
+                        <span class="selection-summary">Settings are stored as database overrides unless an environment variable wins.</span>
+                        <div class="toolbar">
+                            <button class="btn" type="button" @click="loadSettings()">
+                                <i data-lucide="refresh-cw"></i>
+                                Reload
+                            </button>
+                            <button class="btn primary" type="submit" :disabled="settingsSaving">
+                                <i :data-lucide="settingsSaving ? 'loader-circle' : 'save'"></i>
+                                <span x-text="settingsSaving ? 'Saving...' : 'Save settings'"></span>
+                            </button>
+                        </div>
+                    </div>
+                </form>
+            </div>
+        </div>
     </main>
 
     <div class="modal-backdrop" x-show="reviewModalOpen && activeReview" x-transition @click.self="reviewModalOpen = false">
@@ -1366,10 +1773,43 @@ function adminV2() {
         activeLibraryItem: null,
         editorOpen: false,
         editorDraft: { title: '', hidden: 'false' },
+        settings: { values: {}, sources: {}, lastfm_api_key_configured: false },
+        settingsDraft: {
+            auth_password_enabled: false,
+            auth_sso_enabled: false,
+            oidc_button_text: '',
+            oidc_issuer: '',
+            oidc_client_id: '',
+            oidc_client_secret: '',
+            oidc_admin_groups: '',
+            oidc_user_groups: '',
+            swagger_enabled: false,
+            lastfm_api_key: '',
+            agent_enabled: false,
+            agent_inbox_dir: '',
+            agent_storage_dir: '',
+            agent_llm_url: '',
+            agent_llm_model: '',
+            agent_llm_auth: '',
+            agent_confidence_threshold: '',
+            agent_context_limit: '',
+            agent_concurrency: ''
+        },
+        settingsProbe: { status: 'idle', ok: false },
+        settingsProbeLoading: false,
+        settingsSaving: false,
+        routeReady: false,
         poller: null,
 
         async init() {
+            this.applyRouteFromHash();
             await this.refreshAll();
+            this.routeReady = true;
+            this.activateCurrentView(false);
+            window.addEventListener('hashchange', () => {
+                this.applyRouteFromHash();
+                this.activateCurrentView(false);
+            });
             this.poller = setInterval(() => this.poll(), 6000);
             this.icons();
         },
@@ -1399,6 +1839,7 @@ function adminV2() {
                 this.jobs = data.jobs || [];
                 this.recentRuns = data.recent_runs || [];
                 if (!this.activeJobName && this.jobs.length) this.activeJobName = this.jobs[0].name;
+                await this.loadSettings(false);
                 await this.loadLibrary(false);
             } catch (error) {
                 this.showToast(error.message);
@@ -1413,6 +1854,84 @@ function adminV2() {
             await Promise.allSettled([this.loadJobs(false), this.loadReviews(false)]);
         },
 
+        applyRouteFromHash() {
+            const raw = (window.location.hash || '#reviews').replace(/^#\/?/, '');
+            const parts = raw.split('/').filter(Boolean);
+            const view = parts[0] || 'reviews';
+            if (view === 'reviews') {
+                this.activeView = 'reviews';
+                this.reviewFilter.status = parts[1] || null;
+            } else if (view === 'jobs') {
+                this.activeView = 'jobs';
+                if (parts[1]) this.activeJobName = decodeURIComponent(parts[1]);
+            } else if (view === 'library') {
+                this.activeView = 'library';
+                this.libraryKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
+            } else if (view === 'settings') {
+                this.activeView = 'settings';
+            } else if (view === 'tools') {
+                this.activeView = 'tools';
+            } else {
+                this.activeView = 'reviews';
+            }
+        },
+
+        setRoute(path) {
+            if (!path.startsWith('#')) path = '#' + path;
+            if (window.location.hash !== path) {
+                window.history.pushState(null, '', path);
+            }
+        },
+
+        async activateCurrentView(updateRoute = true) {
+            if (this.activeView === 'reviews') {
+                if (updateRoute) this.setRoute(this.reviewFilter.status ? `#reviews/${this.reviewFilter.status}` : '#reviews');
+                await this.loadReviews(false);
+            } else if (this.activeView === 'jobs') {
+                if (updateRoute) this.setRoute(this.activeJobName ? `#jobs/${encodeURIComponent(this.activeJobName)}` : '#jobs');
+                await this.loadJobs();
+                if (this.activeJobName) await this.loadRunsForJob(this.activeJobName);
+            } else if (this.activeView === 'library') {
+                if (updateRoute) this.setRoute(`#library/${this.libraryKind}`);
+                await this.loadLibrary(false);
+            } else if (this.activeView === 'settings') {
+                if (updateRoute) this.setRoute('#settings');
+                await this.loadSettings();
+                if (!this.settingsProbe.status || this.settingsProbe.status === 'idle') {
+                    await this.loadSettingsProbe(false);
+                }
+            } else if (this.activeView === 'tools' && updateRoute) {
+                this.setRoute('#tools');
+            }
+        },
+
+        openReviews(status = null) {
+            this.activeView = 'reviews';
+            this.reviewFilter.status = status;
+            this.setRoute(status ? `#reviews/${status}` : '#reviews');
+            this.loadReviews();
+        },
+
+        openJobs(name = this.activeJobName) {
+            this.activeView = 'jobs';
+            if (name) this.activeJobName = name;
+            this.setRoute(this.activeJobName ? `#jobs/${encodeURIComponent(this.activeJobName)}` : '#jobs');
+            this.loadJobs();
+            if (this.activeJobName) this.loadRunsForJob(this.activeJobName);
+        },
+
+        openLibrary(kind = this.libraryKind) {
+            this.activeView = 'library';
+            this.libraryKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
+            this.setRoute(`#library/${this.libraryKind}`);
+            this.loadLibrary();
+        },
+
+        openTools() {
+            this.activeView = 'tools';
+            this.setRoute('#tools');
+        },
+
         async loadReviews(resetOffset = true) {
             if (resetOffset) this.reviews.offset = 0;
             const params = new URLSearchParams();
@@ -1462,9 +1981,93 @@ function adminV2() {
             }
         },
 
+        async loadSettings(showErrors = true) {
+            try {
+                this.settings = await this.request(`${this.apiBase}/settings`);
+                this.settingsDraft = Object.assign({}, this.settingsDraft, this.settings.values || {});
+            } catch (error) {
+                if (showErrors) this.showToast(error.message);
+            } finally {
+                this.icons();
+            }
+        },
+
+        async saveSettings() {
+            if (this.settingsSaving) return;
+            this.settingsSaving = true;
+            try {
+                await this.request(`${this.apiBase}/settings`, {
+                    method: 'POST',
+                    body: JSON.stringify(this.settingsDraft)
+                });
+                await this.loadSettings(false);
+                this.showToast('Settings saved');
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.settingsSaving = false;
+                this.icons();
+            }
+        },
+
+        async openSettings() {
+            this.activeView = 'settings';
+            this.setRoute('#settings');
+            await this.loadSettings();
+            if (!this.settingsProbe.status || this.settingsProbe.status === 'idle') {
+                await this.loadSettingsProbe(false);
+            }
+        },
+
+        async loadSettingsProbe(showErrors = true) {
+            this.settingsProbeLoading = true;
+            try {
+                this.settingsProbe = await this.request(`${this.apiBase}/settings/probe`);
+            } catch (error) {
+                this.settingsProbe = { status: 'error', ok: false, error: error.message };
+                if (showErrors) this.showToast(error.message);
+            } finally {
+                this.settingsProbeLoading = false;
+                this.icons();
+            }
+        },
+
+        settingSource(key) {
+            return (this.settings.sources || {})[key] || 'default';
+        },
+
+        sourceClass(key) {
+            return this.settingSource(key);
+        },
+
+        callbackUrl() {
+            return `${window.location.origin}/auth/oidc/callback`;
+        },
+
+        settingsProbeBadge() {
+            if (this.settingsProbeLoading) return 'running';
+            if (this.settingsProbe.status === 'ok') return 'ok';
+            if (this.settingsProbe.status === 'error') return 'failed';
+            return 'disabled';
+        },
+
+        settingsProbeSubtitle() {
+            if (this.settingsProbeLoading) return 'Checking LLM connection';
+            if (this.settingsProbe.status === 'ok') return 'LLM connection OK';
+            if (this.settingsProbe.status === 'error') return 'LLM connection error';
+            if (this.settingsProbe.status === 'disabled') return 'Agent is disabled';
+            if (this.settingsProbe.status === 'not_configured') return 'LLM URL is not configured';
+            return 'Connection probe';
+        },
+
+        settingsProbeText() {
+            if (this.settingsProbeLoading) return 'Checking connection...';
+            if (this.settingsProbe.error) return this.settingsProbe.error;
+            return this.settingsProbeSubtitle();
+        },
+
         setReviewStatus(status) {
-            this.reviewFilter.status = status;
-            this.loadReviews();
+            this.openReviews(status);
         },
 
         openReview(row) {
@@ -1590,6 +2193,7 @@ function adminV2() {
 
         async selectJob(name) {
             this.activeJobName = name;
+            this.setRoute(`#jobs/${encodeURIComponent(name)}`);
             this.activeReview = null;
             this.activeRunDetail = null;
             await this.loadRunsForJob(name);
@@ -1770,6 +2374,7 @@ function adminV2() {
             if (this.activeView === 'library') return 'Library Workbench';
             if (this.activeView === 'jobs') return 'Tasks';
             if (this.activeView === 'tools') return 'Future Tools';
+            if (this.activeView === 'settings') return 'Settings';
             return 'Review Queue';
         },
 
@@ -1777,6 +2382,7 @@ function adminV2() {
             if (this.activeView === 'library') return 'Fast entity control surface for artists, releases, and playlists';
             if (this.activeView === 'jobs') return 'Scheduler state, recent runs, and manual controls in one place';
             if (this.activeView === 'tools') return 'Reserved space for merge, split, enrichment, and destructive workflows';
+            if (this.activeView === 'settings') return 'Application configuration and external API credentials';
             return 'Full-screen review triage with filter-aware bulk actions';
         },
 

templates/player/modals.html

@@ -64,6 +64,15 @@
                            :class="{ error: $store.torrents.error }"
                            x-text="$store.torrents.message"></p>
                     </div>
+                    <button class="torrent-modal-close"
+                            @click="$store.torrents.close()"
+                            title="{{ t.player_close }}"
+                            aria-label="{{ t.player_close }}">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
                     <div class="torrent-client-status">
                         <span class="torrent-status-pill"
                               :class="{ active: $store.torrents.activeCount() > 0 }"
@@ -109,8 +118,6 @@
                                                  :style="'width:' + $store.torrents.progressValue(job) + '%'"></div>
                                         </div>
                                     </div>
-                                    <button class="torrent-session-remove"
-                                            @click.stop="$store.torrents.removeSession(job.id)">{{ t.player_delete }}</button>
                                 </div>
                             </template>
                             <button type="button"
@@ -119,7 +126,7 @@
                                     @click="$store.torrents.addNew()"
                                     :disabled="$store.torrents.loading">
                                 <span class="torrent-session-add-icon">+</span>
-                                <span>{{ t.player_add_torrent }}</span>
+                                <span>{{ t.player_upload }}</span>
                             </button>
                         </div>
                     </aside>
@@ -135,9 +142,10 @@
                             <div class="torrent-import-panel">
                                 <div class="torrent-modal-grid">
                                     <div>
-                                        <label for="torrent-file-input">{{ t.player_torrent_file }}</label>
-                                        <input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
-                                               @change="$store.torrents.file = $event.target.files[0] || null">
+                                        <label for="local-file-input">{{ t.player_local_files }}</label>
+                                        <input id="local-file-input" type="file" multiple accept="audio/*,.mp3,.flac,.wav,.m4a,.ogg,.opus,.aac"
+                                               @change="$store.torrents.setLocalFiles($event.target.files)">
+                                        <div class="torrent-upload-summary" x-text="$store.torrents.localUploadSummary()"></div>
                                     </div>
                                     <div>
                                         <label for="torrent-magnet-input">{{ t.player_magnet_link }}</label>
@@ -145,10 +153,26 @@
                                                x-model="$store.torrents.magnet"
                                                placeholder="magnet:?xt=urn:btih:...">
                                     </div>
+                                    <div>
+                                        <label for="torrent-file-input">{{ t.player_torrent_file }}</label>
+                                        <input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
+                                               @change="$store.torrents.file = $event.target.files[0] || null">
+                                    </div>
+                                </div>
+                                <div class="torrent-upload-progress"
+                                    x-show="$store.torrents.uploadProgress > 0 || ($store.torrents.localFiles.length > 0 && $store.torrents.loading)">
+                                    <div class="torrent-progress-head">
+                                        <span x-text="$store.torrents.uploadProgress >= 100 ? T.uploadComplete : T.uploadingFiles"></span>
+                                        <span x-text="$store.torrents.uploadProgressText"></span>
+                                    </div>
+                                    <div class="torrent-progress-track">
+                                        <div class="torrent-progress-bar"
+                                             :style="'width:' + $store.torrents.uploadProgress + '%'"></div>
+                                    </div>
                                 </div>
                                 <div class="torrent-actions">
                                     <button class="modal-btn modal-btn-primary" @click="$store.torrents.preview()" :disabled="$store.torrents.loading">
-                                        {{ t.player_preview_content }}
+                                        {{ t.player_upload_content }}
                                     </button>
                                 </div>
                             </div>
@@ -201,12 +225,19 @@
                                 <div class="torrent-preview-meta"
                                      x-text="$store.torrents.previewData.files.length + ' {{ t.player_files_count }} - ' + $store.torrents.bytes($store.torrents.previewData.total_size)"></div>
                             </div>
-                            <button class="modal-btn"
-                                    :class="$store.torrents.actionButtonClass()"
-                                    @click="$store.torrents.toggleDownloadAction()"
-                                    :disabled="$store.torrents.actionButtonDisabled()">
-                                <span x-text="$store.torrents.actionButtonText()"></span>
-                            </button>
+                            <div class="torrent-preview-actions">
+                                <button class="modal-btn"
+                                        :class="$store.torrents.actionButtonClass()"
+                                        @click="$store.torrents.toggleDownloadAction()"
+                                        :disabled="$store.torrents.actionButtonDisabled()">
+                                    <span x-text="$store.torrents.actionButtonText()"></span>
+                                </button>
+                                <button class="modal-btn modal-btn-danger"
+                                        @click="$store.torrents.removeSession($store.torrents.previewData.id)"
+                                        :disabled="$store.torrents.loading">
+                                    {{ t.player_delete }}
+                                </button>
+                            </div>
                         </div>
                         <div class="torrent-tree-toolbar">
                             <div class="torrent-selected-summary"

templates/player/scripts.html

@@ -3,6 +3,7 @@
 const T = {
     info: "{{ t.player_info }}",
     noDetails: "{{ t.player_no_details }}",
+    trackInfoTitle: "{{ t.player_track_info }}",
     loadingHistory: "{{ t.player_loading_history }}",
     failedLoadHistory: "{{ t.player_failed_load_history }}",
     totalPlays: "{{ t.player_total_plays }}",
@@ -21,6 +22,11 @@ const T = {
     audio: "{{ t.player_audio }}",
     size: "{{ t.player_size }}",
     uploader: "{{ t.player_uploader }}",
+    lastfmRating: "{{ t.player_lastfm_rating }}",
+    lastfmListeners: "{{ t.player_lastfm_listeners }}",
+    lastfmPlaycount: "{{ t.player_lastfm_playcount }}",
+    lastfmUpdated: "{{ t.player_lastfm_updated }}",
+    lastfmNotLoaded: "{{ t.player_lastfm_not_loaded }}",
     trackWord: "{{ t.player_tracks_count }}",
     clientIdle: "{{ t.player_client_idle }}",
     active: "{{ t.player_active }}",
@@ -30,7 +36,11 @@ const T = {
     queued: "{{ t.player_queued }}",
     saved: "{{ t.player_saved }}",
     chooseSavedOrAddTorrent: "{{ t.player_choose_saved_or_add_torrent }}",
+    uploadFailed: "{{ t.player_upload_failed }}",
+    uploadComplete: "{{ t.player_upload_complete }}",
+    uploadingFiles: "{{ t.player_uploading_files }}",
     preview: "{{ t.player_preview }}",
+    resolving: "{{ t.player_resolving }}",
     downloading: "{{ t.player_downloading }}",
     moving: "{{ t.player_moving }}",
     completed: "{{ t.player_completed }}",
@@ -88,6 +98,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
@@ -431,7 +446,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());
@@ -625,6 +640,8 @@ document.addEventListener('alpine:init', () => {
         searchResults: null,
         searchLoading: false,
         _previousView: 'artists',
+        _activeHash: location.hash || '#artists',
+        _scrollPositions: {},
 
         _hashNav: false, // guard against circular hash updates
 
@@ -634,26 +651,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];
@@ -661,26 +683,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;
@@ -688,8 +758,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) {
@@ -713,17 +783,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() {
@@ -783,6 +854,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').open(T.trackInfoTitle, this.trackInfo(track));
+        },
+
         uploadersInfo(uploaders) {
             const rows = uploaders || [];
             if (!rows.length) return 'UFO';
@@ -821,31 +933,42 @@ document.addEventListener('alpine:init', () => {
                 `${T.size}: ${this.bytes(track.file_size_bytes)}`,
                 `${T.uploader}: ${track.uploader_name || 'UFO'}`,
             ];
+            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) ? 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}`);
+            } else {
+                lines.push(`${T.lastfmRating}: ${T.lastfmNotLoaded}`);
+            }
             return lines.join('\n');
         },
 
-        async openRelease(id) {
+        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) {
@@ -881,17 +1004,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`);
@@ -901,6 +1024,7 @@ document.addEventListener('alpine:init', () => {
                 this.searchResults = { artists: [], releases: [], tracks: [] };
             }
             this.searchLoading = false;
+            this._afterNavigation(options);
         },
 
         clearSearch() {
@@ -1083,6 +1207,7 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('torrents', {
         modal: false,
         file: null,
+        localFiles: [],
         magnet: '',
         sessions: [],
         loadingSessions: false,
@@ -1101,6 +1226,8 @@ document.addEventListener('alpine:init', () => {
         queuedTasks: 0,
         processingTasks: 0,
         loadingAgentStatus: false,
+        uploadProgress: 0,
+        uploadProgressText: '',
 
         open() {
             this.modal = true;
@@ -1132,7 +1259,10 @@ document.addEventListener('alpine:init', () => {
             this._stopPoll();
             this.workspaceMode = 'new';
             this.file = null;
+            this.localFiles = [];
             this.magnet = '';
+            this.uploadProgress = 0;
+            this.uploadProgressText = '';
             this.currentJob = null;
             this.previewData = null;
             this.treeRoot = null;
@@ -1208,6 +1338,7 @@ document.addEventListener('alpine:init', () => {
         statusLabel(job) {
             const labels = {
                 preview: T.preview,
+                resolving: T.resolving,
                 downloading: T.downloading,
                 moving: T.moving,
                 completed: T.completed,
@@ -1283,12 +1414,18 @@ document.addEventListener('alpine:init', () => {
         },
 
         actionButtonText() {
+            if (this.normalizedStatus(this.currentJob) === 'resolving') return T.resolving;
             if (this.isCurrentCompletedLocked()) return T.completed;
             return this.isCurrentDownloading() ? T.pauseDownload : T.downloadSelected;
         },
 
         actionButtonDisabled() {
-            return this.loading || this.isCurrentCompletedLocked();
+            return this.loading
+                || this.isCurrentCompletedLocked()
+                || this.normalizedStatus(this.currentJob) === 'resolving'
+                || !this.previewData
+                || !Array.isArray(this.previewData.files)
+                || this.previewData.files.length === 0;
         },
 
         toggleDownloadAction() {
@@ -1336,7 +1473,7 @@ document.addEventListener('alpine:init', () => {
         _rememberJob(job) {
             if (!job || !job.id) return;
             const rest = this.sessions.filter(item => item.id !== job.id);
-            this.sessions = [job, ...rest].sort((a, b) => String(b.updated_at || '').localeCompare(String(a.updated_at || '')));
+            this.sessions = [job, ...rest].sort((a, b) => String(b.created_at || '').localeCompare(String(a.created_at || '')));
             if (this.currentJob && this.currentJob.id === job.id) this.currentJob = job;
         },
 
@@ -1359,7 +1496,10 @@ document.addEventListener('alpine:init', () => {
             const job = data.job || null;
             this.workspaceMode = 'session';
             this.file = null;
+            this.localFiles = [];
             this.magnet = '';
+            this.uploadProgress = 0;
+            this.uploadProgressText = '';
             this.previewData = preview;
             this.currentJob = job;
             const selected = Array.isArray(data.selected_files) && data.selected_files.length
@@ -1378,6 +1518,7 @@ document.addEventListener('alpine:init', () => {
                 if (!res.ok) throw new Error(data.error || T.loadTorrentsFailed);
                 this.sessions = Array.isArray(data) ? data : [];
                 this._syncCurrentJobFromSessions();
+                await this._refreshResolvedSelection();
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -1385,6 +1526,19 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        async _refreshResolvedSelection() {
+            if (!this.currentJob || !this.previewData || (this.previewData.files || []).length > 0) return;
+            const selected = this.sessions.find(job => job.id === this.currentJob.id);
+            if (!selected || this.normalizedStatus(selected) === 'resolving') return;
+            try {
+                const res = await fetch(`/api/player/torrents/session/${selected.id}`);
+                const data = await res.json();
+                if (!res.ok) return;
+                this._applySession(data);
+                this._setMessage(T.allFilesSelected);
+            } catch {}
+        },
+
         async openSession(id) {
             if (!id || this.loading) return;
             this._stopPoll();
@@ -1442,8 +1596,76 @@ document.addEventListener('alpine:init', () => {
             });
         },
 
+        setLocalFiles(files) {
+            this.localFiles = Array.from(files || []);
+        },
+
+        localUploadBytes() {
+            return this.localFiles.reduce((sum, file) => sum + Number(file.size || 0), 0);
+        },
+
+        localUploadSummary() {
+            const count = this.localFiles.length;
+            if (count === 0) return '';
+            return count + ' ' + T.selected + ' - ' + this.bytes(this.localUploadBytes());
+        },
+
+        uploadLocalFile(file, loadedBefore, totalBytes) {
+            return new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open('POST', '/api/player/uploads/local');
+                xhr.setRequestHeader('Content-Type', file.type || 'application/octet-stream');
+                xhr.setRequestHeader('X-Furumusic-Filename', encodeURIComponent(file.name || 'upload.mp3'));
+                xhr.upload.onprogress = event => {
+                    if (!event.lengthComputable || totalBytes <= 0) return;
+                    const loaded = loadedBefore + event.loaded;
+                    this.uploadProgress = Math.max(0, Math.min(100, loaded / totalBytes * 100));
+                    this.uploadProgressText = this.uploadProgress.toFixed(1) + '%';
+                };
+                xhr.onload = () => {
+                    let data = {};
+                    try { data = JSON.parse(xhr.responseText || '{}'); } catch {}
+                    if (xhr.status >= 200 && xhr.status < 300) resolve(data);
+                    else reject(new Error(data.error || T.uploadFailed));
+                };
+                xhr.onerror = () => reject(new Error(T.uploadFailed));
+                xhr.send(file);
+            });
+        },
+
+        async uploadLocalFiles() {
+            if (this.loading || this.localFiles.length === 0) return;
+            this.loading = true;
+            this.uploadProgress = 0;
+            this.uploadProgressText = '0.0%';
+            this._setMessage(T.uploadingFiles);
+            const totalBytes = this.localUploadBytes();
+            let loadedBefore = 0;
+            try {
+                for (const file of this.localFiles) {
+                    await this.uploadLocalFile(file, loadedBefore, totalBytes);
+                    loadedBefore += Number(file.size || 0);
+                    this.uploadProgress = totalBytes > 0 ? Math.min(100, loadedBefore / totalBytes * 100) : 100;
+                    this.uploadProgressText = this.uploadProgress.toFixed(1) + '%';
+                }
+                this.localFiles = [];
+                this.uploadProgress = 100;
+                this.uploadProgressText = '100.0%';
+                this._setMessage(T.uploadComplete);
+                await this.loadAgentStatus();
+            } catch (err) {
+                this._setMessage(err.message || String(err), true);
+            } finally {
+                this.loading = false;
+            }
+        },
+
         async preview() {
             if (this.loading) return;
+            if (this.localFiles.length > 0) {
+                await this.uploadLocalFiles();
+                return;
+            }
             const magnet = this.magnet.trim();
             if (!this.file && !magnet) {
                 this._setMessage(T.chooseTorrent, true);
@@ -1472,7 +1694,7 @@ document.addEventListener('alpine:init', () => {
                 if (!res.ok) throw new Error(data.error || T.previewFailed);
 
                 this._applySession(data);
-                this._setMessage(T.allFilesSelected);
+                this._setMessage((data.preview?.files || []).length ? T.allFilesSelected : T.resolving);
                 await this.loadSessions();
             } catch (err) {
                 this._setMessage(err.message || String(err), true);

templates/player/shell.html

@@ -434,8 +434,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>
@@ -608,8 +614,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>
@@ -725,8 +737,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 +813,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 +895,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>

templates/player/styles.html

@@ -661,11 +661,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 +701,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 +972,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 +1003,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;
@@ -1741,6 +1810,11 @@ button.user-stat:hover {
     color: #111;
 }
 .modal-btn-ghost { background: transparent; color: var(--text-secondary); }
+.modal-btn-danger {
+    background: rgba(229,96,96,0.16);
+    color: #ffb9b9;
+    border: 1px solid rgba(229,96,96,0.32);
+}
 
 .modal-footer {
     display: flex;
@@ -1749,9 +1823,10 @@ button.user-stat:hover {
 }
 
 .torrent-modal {
-    width: min(860px, calc(100vw - 32px));
-    max-width: 860px;
-    max-height: min(88dvh, 760px);
+    width: min(1180px, calc(100vw - 48px));
+    max-width: 1180px;
+    height: min(820px, calc(100dvh - 64px));
+    max-height: calc(100dvh - 64px);
     overflow: hidden;
 }
 
@@ -1761,6 +1836,8 @@ button.user-stat:hover {
     justify-content: space-between;
     gap: 14px;
     margin-bottom: 12px;
+    flex: 0 0 auto;
+    position: relative;
 }
 
 .torrent-modal-head h3 {
@@ -1792,6 +1869,25 @@ button.user-stat:hover {
     white-space: nowrap;
 }
 
+.torrent-modal-close {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    flex: 0 0 auto;
+    width: 34px;
+    height: 34px;
+    border: 1px solid var(--border-color);
+    border-radius: 999px;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    cursor: pointer;
+}
+
+.torrent-modal-close svg {
+    width: 18px;
+    height: 18px;
+}
+
 .torrent-status-pill.active {
     border-color: rgba(29,185,84,0.42);
     color: #9ff0b9;
@@ -1816,9 +1912,10 @@ button.user-stat:hover {
 
 .torrent-manager-layout {
     display: grid;
-    grid-template-columns: minmax(210px, 260px) minmax(0, 1fr);
+    grid-template-columns: minmax(260px, 320px) minmax(0, 1fr);
     gap: 14px;
     min-height: 0;
+    flex: 1 1 auto;
 }
 
 .torrent-manager-sidebar,
@@ -1851,13 +1948,14 @@ button.user-stat:hover {
 
 .torrent-session-list {
     overflow-y: auto;
-    min-height: 150px;
-    max-height: min(52vh, 470px);
+    min-height: 0;
+    max-height: none;
+    flex: 1 1 auto;
 }
 
 .torrent-session-row {
     display: grid;
-    grid-template-columns: minmax(0, 1fr) auto;
+    grid-template-columns: minmax(0, 1fr);
     gap: 8px;
     padding: 10px 12px;
     border-bottom: 1px solid var(--border-color);
@@ -1935,19 +2033,28 @@ button.user-stat:hover {
 }
 
 .torrent-status-badge.status-preview {
-    background: rgba(122,162,255,0.14);
-    color: #a8c0ff;
+    background: rgba(122,162,255,0.16);
+    color: #adc3ff;
 }
 
-.torrent-status-badge.status-downloading,
-.torrent-status-badge.status-moving {
+.torrent-status-badge.status-resolving {
+    background: rgba(182,141,255,0.16);
+    color: #d0b6ff;
+}
+
+.torrent-status-badge.status-downloading {
     background: rgba(29,185,84,0.16);
     color: #9ff0b9;
 }
 
+.torrent-status-badge.status-moving {
+    background: rgba(75,198,240,0.16);
+    color: #a8e8ff;
+}
+
 .torrent-status-badge.status-completed {
-    background: rgba(105,214,161,0.2);
-    color: #b8ffd2;
+    background: rgba(110,211,123,0.16);
+    color: #b8f7be;
 }
 
 .torrent-status-badge.status-paused {
@@ -1985,23 +2092,6 @@ button.user-stat:hover {
     transition: width 0.25s ease;
 }
 
-.torrent-session-remove {
-    align-self: flex-start;
-    border: 1px solid rgba(229,96,96,0.24);
-    background: rgba(229,96,96,0.12);
-    color: #ffb9b9;
-    border-radius: 5px;
-    padding: 4px 7px;
-    font-size: 11px;
-    font-weight: 800;
-    cursor: pointer;
-}
-
-.torrent-session-remove:hover {
-    background: rgba(229,96,96,0.2);
-    color: #ffd7d7;
-}
-
 .torrent-progress-card {
     margin-top: 10px;
     padding: 10px 12px;
@@ -2143,6 +2233,21 @@ button.user-stat:hover {
     min-height: 150px;
 }
 
+.torrent-upload-summary {
+    min-height: 16px;
+    margin-top: 5px;
+    color: var(--text-subdued);
+    font-size: 11px;
+}
+
+.torrent-upload-progress {
+    margin-top: 10px;
+    padding: 10px 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
 .torrent-modal label {
     display: block;
     margin-bottom: 6px;
@@ -2187,6 +2292,13 @@ button.user-stat:hover {
     margin-top: 16px;
 }
 
+.torrent-preview-actions {
+    display: flex;
+    flex-wrap: wrap;
+    justify-content: flex-end;
+    gap: 8px;
+}
+
 .torrent-preview-title {
     min-width: 0;
     font-size: 14px;
@@ -2243,7 +2355,7 @@ button.user-stat:hover {
     margin-top: 10px;
     overflow-y: auto;
     min-height: 140px;
-    max-height: min(46vh, 420px);
+    max-height: none;
     border: 1px solid var(--border-color);
     border-radius: 8px;
     background: var(--bg-primary);
@@ -2442,7 +2554,7 @@ button.user-stat:hover {
     }
 
     .torrent-modal {
-        width: calc(100vw - 24px);
+        width: min(1180px, calc(100vw - 32px));
     }
 
     .card-grid {
@@ -2764,6 +2876,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;
@@ -2786,34 +2916,49 @@ button.user-stat:hover {
     }
 
     .info-modal,
-    .torrent-modal,
     .history-modal {
         width: min(400px, calc(100vw - 24px));
         max-width: 400px;
     }
 
     .torrent-modal {
-        max-height: min(82dvh, 640px);
-        padding: 20px;
+        width: 100vw;
+        max-width: none;
+        height: 100dvh;
+        max-height: none;
+        border-radius: 0;
+        padding: calc(14px + env(safe-area-inset-top)) 14px calc(14px + env(safe-area-inset-bottom));
+        overflow: hidden;
     }
 
     .torrent-modal-head {
-        flex-direction: column;
+        display: grid;
+        grid-template-columns: minmax(0, 1fr) auto;
         gap: 8px;
+        align-items: start;
     }
 
     .torrent-client-status {
+        grid-column: 1 / -1;
         justify-content: flex-start;
     }
 
+    .torrent-modal-close {
+        display: inline-flex;
+    }
+
     .torrent-manager-layout {
         grid-template-columns: 1fr;
         gap: 10px;
     }
 
     .torrent-session-list {
-        max-height: 148px;
-        min-height: 96px;
+        max-height: none;
+        min-height: 0;
+    }
+
+    .torrent-manager-sidebar {
+        flex: 0 0 178px;
     }
 
     .torrent-progress-head {
@@ -2867,8 +3012,8 @@ button.user-stat:hover {
     }
 
     .torrent-file-tree {
-        min-height: 120px;
-        max-height: min(32dvh, 260px);
+        min-height: 0;
+        max-height: none;
     }
 
     .torrent-tree-row {