Added lastfm statistics

Cargo.lock

@@ -1397,7 +1397,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.1.10"
+version = "0.1.14"
 dependencies = [
  "anyhow",
  "async-trait",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.1.11"
+version = "0.1.15"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 

src/admin/mod.rs

@@ -264,6 +264,20 @@ 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/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;
@@ -14,6 +14,7 @@ use sqlx::{PgPool, Postgres, QueryBuilder};
 
 use super::BUILD_INFO;
 use crate::auth::{self, AuthenticatedUser, Role};
+use crate::config::{AppConfig, ConfigEntry};
 use crate::i18n::{I18n, Translations};
 use crate::scheduler::{JobRegistry, ScheduledJob};
 
@@ -214,6 +215,17 @@ struct MutationResponse {
     affected: u64,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct AdminSettingsDto {
+    lastfm_api_key: String,
+    lastfm_api_key_configured: bool,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct UpdateSettingsRequest {
+    lastfm_api_key: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct LibraryOverviewDto {
     artists: i64,
@@ -458,6 +470,37 @@ 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, _) = AppConfig::load_with_db(&db).await;
+    Json(AdminSettingsDto {
+        lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
+        lastfm_api_key: config.lastfm_api_key,
+    })
+    .into_response()
+}
+
+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 mut entry = ConfigEntry::new(
+        "lastfm_api_key".to_string(),
+        body.lastfm_api_key.trim().to_string(),
+    );
+    entry
+        .save(&db)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(serde_json::json!({ "ok": true })).into_response()
+}
+
 pub async fn run_job(
     session: Session,
     db: Database,

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,14 +318,21 @@ impl_env_overrides!(
     agent_confidence_threshold,
     agent_context_limit,
     agent_concurrency,
+    lastfm_api_key,
 );
 
 impl AppConfig {
+    fn normalize_host_paths(&mut self) {
+        self.agent_inbox_dir = normalize_host_path(&self.agent_inbox_dir);
+        self.agent_storage_dir = normalize_host_path(&self.agent_storage_dir);
+    }
+
     /// Build config: start from defaults, then overlay env vars.
     /// Used at startup before the DB is available (to get `database_url`).
     pub fn load() -> Self {
         let mut cfg = Self::default();
         cfg.apply_env_overrides();
+        cfg.normalize_host_paths();
         cfg
     }
 
@@ -331,6 +343,7 @@ impl AppConfig {
         let mut sources = ConfigSources::default();
         cfg.apply_db_overrides(db, &mut sources).await;
         cfg.apply_env_overrides_tracked(&mut sources);
+        cfg.normalize_host_paths();
         (cfg, sources)
     }
 
@@ -389,9 +402,48 @@ 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);
     }
 }
 
+fn normalize_host_path(value: &str) -> String {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return String::new();
+    }
+
+    normalize_windows_user_path(trimmed).unwrap_or_else(|| trimmed.to_owned())
+}
+
+#[cfg(not(windows))]
+fn normalize_windows_user_path(value: &str) -> Option<String> {
+    let normalized = value.replace('\\', "/");
+    let mut parts = normalized.split('/').filter(|part| !part.is_empty());
+    let drive = parts.next()?;
+    if drive.len() != 2 || !drive.ends_with(':') {
+        return None;
+    }
+    if !parts.next()?.eq_ignore_ascii_case("Users") {
+        return None;
+    }
+    let user = parts.next()?;
+    if user.is_empty() {
+        return None;
+    }
+
+    let mut out = format!("/Users/{user}");
+    for part in parts {
+        out.push('/');
+        out.push_str(part);
+    }
+    Some(out)
+}
+
+#[cfg(windows)]
+fn normalize_windows_user_path(_value: &str) -> Option<String> {
+    None
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -403,6 +455,24 @@ mod tests {
         assert_eq!(cfg.log_level, "info");
     }
 
+    #[cfg(not(windows))]
+    #[test]
+    fn normalizes_windows_user_path_on_unix() {
+        assert_eq!(
+            normalize_host_path(r"C:\Users\ab\repos\furumusic\media\uploads"),
+            "/Users/ab/repos/furumusic/media/uploads"
+        );
+    }
+
+    #[cfg(not(windows))]
+    #[test]
+    fn leaves_unix_path_unchanged() {
+        assert_eq!(
+            normalize_host_path("/Users/ab/repos/furumusic/media/uploads"),
+            "/Users/ab/repos/furumusic/media/uploads"
+        );
+    }
+
     // SAFETY: tests run with --test-threads=1 so no concurrent env access.
     unsafe fn set(k: &str, v: &str) {
         unsafe { std::env::set_var(k, v) };

src/i18n/phrases.rs

@@ -264,4 +264,160 @@ translations! {
     settings_agent_completion_tokens: "Completion tokens"       , "Токенов на ответ";
     settings_agent_tokens_per_sec: "Tokens/sec"                 , "Токенов/сек";
     settings_agent_status_loading: "Checking connection"         , "Проверка подключения";
+
+    // Player UI
+    player_library:          "Library"                         , "Библиотека";
+    player_artists:          "Artists"                         , "Артисты";
+    player_releases:         "Releases"                        , "Релизы";
+    player_tracks:           "Tracks"                          , "Треки";
+    player_title:            "Title"                           , "Название";
+    player_duration:         "Duration"                        , "Длительность";
+    player_following:        "Following"                       , "Подписки";
+    player_follow:           "Follow"                          , "Подписаться";
+    player_followed:         "Following"                       , "Вы подписаны";
+    player_unfollow_artist:  "Unfollow artist"                 , "Отписаться от артиста";
+    player_follow_artist:    "Follow artist"                   , "Подписаться на артиста";
+    player_no_followed_artists: "No followed artists"           , "Нет подписок на артистов";
+    player_playlists:        "Playlists"                       , "Плейлисты";
+    player_published_playlists: "Published Playlists"           , "Опубликованные плейлисты";
+    player_public:           "Public"                          , "Публичный";
+    player_published:        "Published"                       , "Опубликован";
+    player_by:               "by"                              , "от";
+    player_tracks_count:     "tracks"                          , "треков";
+    player_files_count:      "files"                           , "файлов";
+    player_releases_count:   "releases"                        , "релизов";
+    player_plays_count:      "plays"                           , "прослушиваний";
+    player_likes_count:      "likes"                           , "лайков";
+    player_likes_playlist:   "Likes"                           , "Лайки";
+    player_listened:         "listened"                        , "прослушано";
+    player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
+    player_no_results:       "No results found"                , "Ничего не найдено";
+    player_new_playlist:     "New Playlist"                    , "Новый плейлист";
+    player_rename_playlist:  "Rename Playlist"                 , "Переименовать плейлист";
+    player_playlist_name:    "Playlist name"                   , "Название плейлиста";
+    player_add_to_playlist:  "Add to Playlist"                 , "Добавить в плейлист";
+    player_cancel:           "Cancel"                          , "Отмена";
+    player_create:           "Create"                          , "Создать";
+    player_save:             "Save"                            , "Сохранить";
+    player_delete:           "Delete"                          , "Удалить";
+    player_delete_playlist_confirm: "Delete this playlist?"     , "Удалить этот плейлист?";
+    player_rename:           "Rename"                          , "Переименовать";
+    player_close:            "Close"                           , "Закрыть";
+    player_log_out:          "Log out"                         , "Выйти";
+    player_admin_panel:      "Admin Panel"                     , "Админка";
+    player_info:             "Info"                            , "Информация";
+    player_no_details:       "No details available."           , "Нет подробностей.";
+    player_release_info:     "Release info"                    , "Информация о релизе";
+    player_track_info:       "Track info"                      , "Информация о треке";
+    player_type:             "Type"                            , "Тип";
+    player_year:             "Year"                            , "Год";
+    player_uploaders:        "Uploaders"                       , "Загрузили";
+    player_unknown:          "unknown"                         , "неизвестно";
+    player_unknown_size:     "unknown size"                    , "размер неизвестен";
+    player_unknown_release:  "Unknown release"                 , "Неизвестный релиз";
+    player_unknown_track:    "Unknown track"                   , "Неизвестный трек";
+    player_unknown_audio:    "unknown audio details"           , "детали аудио неизвестны";
+    player_release_year:     "Release year"                    , "Год релиза";
+    player_audio:            "Audio"                           , "Аудио";
+    player_size:             "Size"                            , "Размер";
+    player_uploader:         "Uploader"                        , "Загрузил";
+    player_lastfm_rating:    "Last.fm popularity"              , "Популярность Last.fm";
+    player_lastfm_listeners: "Last.fm listeners"               , "Слушатели Last.fm";
+    player_lastfm_playcount: "Last.fm plays"                   , "Прослушивания Last.fm";
+    player_lastfm_updated:   "Last.fm updated"                 , "Last.fm обновлён";
+    player_lastfm_not_loaded: "not loaded yet"                 , "ещё не загружено";
+    player_play:             "Play"                            , "Играть";
+    player_like:             "Like"                            , "Лайк";
+    player_add_to_queue:     "Add to queue"                    , "Добавить в очередь";
+    player_add_to_end_queue: "Add to end of queue"             , "Добавить в конец очереди";
+    player_play_next:        "Play next"                       , "Играть следующим";
+    player_queue:            "Queue"                           , "Очередь";
+    player_next:             "Next"                            , "Далее";
+    player_previous:         "Previous"                        , "Назад";
+    player_clear:            "Clear"                           , "Очистить";
+    player_remove:           "Remove"                          , "Удалить";
+    player_queue_empty:      "Queue is empty"                  , "Очередь пуста";
+    player_shuffle:          "Shuffle"                         , "Перемешать";
+    player_repeat:           "Repeat"                          , "Повтор";
+    player_volume:           "Volume"                          , "Громкость";
+    player_appears_on:       "Appears on"                      , "Участвует в";
+    player_albums:           "Albums"                          , "Альбомы";
+    player_eps:              "EPs"                             , "EP";
+    player_singles:          "Singles"                         , "Синглы";
+    player_compilations:     "Compilations"                    , "Сборники";
+    player_mixtapes:         "Mixtapes"                        , "Микстейпы";
+    player_live_releases:    "Live releases"                   , "Концертные релизы";
+    player_soundtracks:      "Soundtracks"                     , "Саундтреки";
+
+    // Player torrent/history UI
+    player_torrent_manager:  "Torrent manager"                 , "Торрент-менеджер";
+    player_import_torrent:   "Import torrent"                  , "Импортировать торрент";
+    player_client_idle:      "Client idle"                     , "Клиент простаивает";
+    player_active:           "active"                          , "активно";
+    player_ai_idle:          "AI idle"                         , "ИИ простаивает";
+    player_ai_prefix:        "AI"                              , "ИИ";
+    player_processing:       "processing"                      , "обрабатывается";
+    player_queued:           "queued"                          , "в очереди";
+    player_saved:            "saved"                           , "сохранено";
+    player_saved_torrents:   "Saved torrents"                  , "Сохранённые торренты";
+    player_refresh:          "Refresh"                         , "Обновить";
+    player_no_saved_torrents: "No saved torrents"              , "Сохранённых торрентов нет";
+    player_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_upload_content:   "Upload"                          , "Загрузить";
+    player_download_selected: "Download selected"              , "Скачать выбранное";
+    player_pause_download:   "Pause download"                  , "Поставить на паузу";
+    player_expand_all:       "Expand all"                      , "Развернуть всё";
+    player_collapse:         "Collapse"                        , "Свернуть";
+    player_selected:         "selected"                        , "выбрано";
+    player_preview:          "Preview"                         , "Предпросмотр";
+    player_resolving:        "Resolving metadata"              , "Получаю метаданные";
+    player_downloading:      "Downloading"                     , "Скачивается";
+    player_moving:           "Moving"                          , "Перемещается";
+    player_completed:        "Completed"                       , "Готово";
+    player_failed:           "Failed"                          , "Ошибка";
+    player_paused:           "Paused"                          , "Пауза";
+    player_no_torrent_selected: "No torrent selected"          , "Торрент не выбран";
+    player_downloaded:        "Downloaded"                     , "Загружено";
+    player_speed:             "Speed"                          , "Скорость";
+    player_down:             "down"                            , "вниз";
+    player_up:               "up"                              , "вверх";
+    player_peers:            "peers"                           , "пиры";
+    player_live:             "live"                            , "активных";
+    player_seen:             "seen"                            , "видели";
+    player_eta:              "eta"                             , "осталось";
+    player_loading_history:  "Loading history..."              , "Загрузка истории...";
+    player_failed_load_history: "Failed to load history"        , "Не удалось загрузить историю";
+    player_total_plays:      "total plays"                     , "прослушиваний всего";
+    player_play_history:     "Play history"                    , "История прослушиваний";
+    player_no_plays_yet:     "No plays yet"                    , "Прослушиваний пока нет";
+    player_page:             "Page"                            , "Страница";
+    player_of:               "of"                              , "из";
+    player_choose_torrent:   "Choose local files, paste a magnet link, or choose a .torrent file." , "Выберите локальные файлы, вставьте magnet-ссылку или выберите .torrent файл.";
+    player_uploading_files:  "Uploading files..."              , "Загружаю файлы...";
+    player_upload_complete:  "Upload complete. Files are queued for processing." , "Загрузка завершена. Файлы поставлены в обработку.";
+    player_upload_failed:    "Upload failed"                   , "Загрузка не удалась";
+    player_reading_torrent:  "Reading torrent file..."         , "Читаю torrent-файл...";
+    player_resolving_magnet: "Resolving magnet metadata. This can take a while..." , "Получаю метаданные magnet-ссылки. Это может занять время...";
+    player_preview_failed:   "Preview failed"                  , "Предпросмотр не удался";
+    player_all_files_selected: "All files are selected by default. Clear or adjust the tree before download." , "Все файлы выбраны по умолчанию. Перед скачиванием можно очистить или изменить выбор.";
+    player_opening_saved_torrent: "Opening saved torrent..."   , "Открываю сохранённый торрент...";
+    player_saved_torrent_opened: "Saved torrent opened. Adjust files or resume download." , "Сохранённый торрент открыт. Можно изменить файлы или продолжить скачивание.";
+    player_remove_torrent_confirm: "Remove this torrent from the client list? Downloaded files will stay on disk." , "Удалить этот торрент из списка клиента? Скачанные файлы останутся на диске.";
+    player_torrent_removed:  "Torrent removed from the client list." , "Торрент удалён из списка клиента.";
+    player_select_one_file:  "Select at least one file."       , "Выберите хотя бы один файл.";
+    player_starting_download: "Starting download..."           , "Запускаю скачивание...";
+    player_download_started: "Download started. Files will move to inbox when complete." , "Скачивание началось. После завершения файлы будут перенесены во входящие.";
+    player_pausing_download: "Pausing download..."             , "Ставлю скачивание на паузу...";
+    player_download_paused:  "Download paused. Start again when you are ready." , "Скачивание на паузе. Можно продолжить позже.";
+    player_status_failed:    "Status failed"                   , "Не удалось получить статус";
+    player_start_failed:     "Start failed"                    , "Не удалось запустить";
+    player_pause_failed:     "Pause failed"                    , "Не удалось поставить на паузу";
+    player_load_torrents_failed: "Could not load torrents"     , "Не удалось загрузить торренты";
+    player_open_torrent_failed: "Could not open torrent"       , "Не удалось открыть торрент";
+    player_delete_torrent_failed: "Could not delete torrent"   , "Не удалось удалить торрент";
+    player_load_ai_queue_failed: "Could not load AI queue"     , "Не удалось загрузить очередь ИИ";
 }

src/jobs/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

@@ -3,6 +3,7 @@ pub mod artist_track_image_backfill;
 pub mod cover_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

@@ -53,6 +53,7 @@ fn build_registry() -> Arc<JobRegistry> {
     registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
     registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
     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)]
@@ -162,6 +170,12 @@ pub(super) struct UserProfile {
     pub(super) stats: UserStats,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct AgentQueueStatus {
+    pub(super) queued_count: i64,
+    pub(super) processing_count: i64,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlayHistoryItem {
     pub(super) id: i64,

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;
@@ -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
 // ---------------------------------------------------------------------------
@@ -105,6 +114,36 @@ async fn me_handler(
     .into_response()
 }
 
+// ---------------------------------------------------------------------------
+// GET /api/player/agent-queue
+// ---------------------------------------------------------------------------
+
+async fn agent_queue_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+) -> cot::Result<cot::response::Response> {
+    let Some(_user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+
+    let (queued_count, processing_count): (i64, i64) = sqlx::query_as(
+        r#"SELECT
+              COUNT(*) FILTER (WHERE status = 'queued') AS queued_count,
+              COUNT(*) FILTER (WHERE status = 'processing') AS processing_count
+           FROM furumusic__pending_review"#,
+    )
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(AgentQueueStatus {
+        queued_count,
+        processing_count,
+    })
+    .into_response()
+}
+
 // ---------------------------------------------------------------------------
 // GET /api/player/artists?page=N&limit=N
 // ---------------------------------------------------------------------------
@@ -274,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
@@ -351,6 +394,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();
@@ -420,7 +467,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
@@ -496,6 +547,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();
@@ -650,7 +705,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
@@ -746,6 +805,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())
@@ -880,6 +943,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) {
@@ -1234,7 +1431,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
@@ -1299,7 +1500,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,
@@ -1310,20 +1511,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"#,
@@ -1427,6 +1635,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();
@@ -1991,7 +2203,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
@@ -2066,6 +2282,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,
             },
         );
     }
@@ -2134,6 +2354,30 @@ impl App for PlayerApp {
                 },
                 "player_me",
             ),
+            Route::with_handler_and_name(
+                "/agent-queue",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            agent_queue_handler(session, db, pg_pool).await
+                        }
+                    })
+                },
+                "player_agent_queue",
+            ),
             // -- Torrent import widget --
             Route::with_handler_and_name(
                 "/torrents",
@@ -2214,9 +2458,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 {
@@ -2228,7 +2470,8 @@ impl App for PlayerApp {
                             }
                         }
                     })
-                    .delete(move |session: Session, db: Database, path: Path<PathStringId>| {
+                    .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);
@@ -2255,13 +2498,16 @@ impl App for PlayerApp {
                                     })
                                     .await;
                                 match service.remove(pg_pool, user.id, &path.0.id).await {
-                                Ok(()) => Json(serde_json::json!({ "ok": true })).into_response(),
+                                    Ok(()) => {
+                                        Json(serde_json::json!({ "ok": true })).into_response()
+                                    }
                                     Err(err) => {
                                         Ok(json_error(StatusCode::NOT_FOUND, &err.to_string()))
                                     }
                                 }
                             }
-                    })
+                        },
+                    )
                 },
                 "player_torrent_detail",
             ),
@@ -2311,6 +2557,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",
                 {
@@ -2370,6 +2639,52 @@ impl App for PlayerApp {
                 },
                 "player_torrent_start",
             ),
+            Route::with_handler_and_name(
+                "/torrents/{id}/pause",
+                {
+                    let pool = Arc::clone(&pool);
+                    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()))
+                                    }
+                                }
+                            }
+                        },
+                    )
+                },
+                "player_torrent_pause",
+            ),
             Route::with_handler_and_name(
                 "/torrents/{id}/status",
                 {

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,
@@ -194,10 +197,14 @@ impl TorrentSessionRow {
             self.status.as_str()
         };
         let stats = handle.map(|h| h.stats());
-        let downloaded_bytes = stats
+        let mut downloaded_bytes = stats
             .as_ref()
             .map(|s| s.progress_bytes)
             .unwrap_or_else(|| i64_to_u64(self.downloaded_bytes));
+        let selected_size = i64_to_u64(self.selected_size);
+        if status == "complete" {
+            downloaded_bytes = selected_size;
+        }
         let uploaded_bytes = stats
             .as_ref()
             .map(|s| s.uploaded_bytes)
@@ -210,6 +217,11 @@ impl TorrentSessionRow {
         let progress_percent = progress_percent(downloaded_bytes, total_bytes)
             .unwrap_or(self.progress_percent)
             .clamp(0.0, 100.0);
+        let progress_percent = if status == "complete" {
+            100.0
+        } else {
+            progress_percent
+        };
         let live = stats.as_ref().and_then(|s| s.live.as_ref());
         let peer_stats = live.map(|l| &l.snapshot.peer_stats);
 
@@ -220,7 +232,7 @@ impl TorrentSessionRow {
             status: status.to_string(),
             client_state: stats.as_ref().map(|s| s.state.to_string()),
             total_size: i64_to_u64(self.total_size),
-            selected_size: i64_to_u64(self.selected_size),
+            selected_size,
             downloaded_bytes,
             uploaded_bytes,
             progress_percent,
@@ -308,10 +320,14 @@ impl TorrentJob {
 
     fn dto(&self) -> TorrentJobDto {
         let stats = self.handle.as_ref().map(|h| h.stats());
-        let downloaded_bytes = stats
+        let mut downloaded_bytes = stats
             .as_ref()
             .map(|s| s.progress_bytes)
             .unwrap_or(self.downloaded_bytes);
+        let selected_size = self.selected_size();
+        if self.status == TorrentJobStatus::Complete {
+            downloaded_bytes = selected_size;
+        }
         let uploaded_bytes = stats
             .as_ref()
             .map(|s| s.uploaded_bytes)
@@ -331,12 +347,16 @@ impl TorrentJob {
             status: self.status.as_str().to_string(),
             client_state: stats.as_ref().map(|s| s.state.to_string()),
             total_size: self.total_size(),
-            selected_size: self.selected_size(),
+            selected_size,
             downloaded_bytes,
             uploaded_bytes,
-            progress_percent: progress_percent(downloaded_bytes, total_bytes)
+            progress_percent: if self.status == TorrentJobStatus::Complete {
+                100.0
+            } else {
+                progress_percent(downloaded_bytes, total_bytes)
                     .unwrap_or(self.progress_percent)
-                .clamp(0.0, 100.0),
+                    .clamp(0.0, 100.0)
+            },
             download_speed_mbps: live.map(|l| l.download_speed.mbps),
             upload_speed_mbps: live.map(|l| l.upload_speed.mbps),
             peers_live: peer_stats.map(|p| p.live),
@@ -355,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>>>,
 }
 
@@ -364,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,
         }
     }
@@ -387,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,
@@ -395,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)
@@ -410,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)))
@@ -438,7 +479,7 @@ impl TorrentService {
     }
 
     pub async fn preview(
-        &self,
+        self: &Arc<Self>,
         pool: &PgPool,
         user_id: i64,
         request: TorrentPreviewRequest,
@@ -456,17 +497,31 @@ impl TorrentService {
             .filter(|s| !s.is_empty())
             .map(str::to_owned);
 
-        let add = match request.kind {
-            TorrentPreviewKind::Magnet => {
+        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")?;
-                AddTorrent::from_url(magnet.to_string())
+                .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 row = load_row(pool, user_id, &id).await?;
+            return Ok(TorrentSessionDto {
+                job: row.dto(None),
+                preview: row.preview()?,
+                selected_files: row.selected_files(),
+            });
         }
-            TorrentPreviewKind::TorrentFile => {
+
         let encoded = request
             .torrent_base64
             .as_deref()
@@ -475,23 +530,17 @@ impl TorrentService {
         let bytes = base64::engine::general_purpose::STANDARD
             .decode(encoded)
             .context("invalid torrent file encoding")?;
-                AddTorrent::from_bytes(bytes)
-            }
-        };
 
-        let response = tokio::time::timeout(
-            METADATA_TIMEOUT,
-            session.add_torrent(
-                add,
+        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");
@@ -555,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,
@@ -589,9 +746,8 @@ impl TorrentService {
             self.stop_torrent(&handle).await;
         }
 
-        let result = sqlx::query(
-            "DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2",
-        )
+        let result =
+            sqlx::query("DELETE FROM furumusic__torrent_session WHERE id = $1 AND user_id = $2")
                 .bind(id)
                 .bind(user_id)
                 .execute(pool)
@@ -627,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)?;
@@ -687,6 +848,9 @@ impl TorrentService {
         let id = id.to_string();
         tokio::spawn(async move {
             if let Err(err) = handle.wait_until_completed().await {
+                if service.is_paused(&id).await {
+                    return;
+                }
                 service.stop_torrent(&handle).await;
                 service.fail_job(&pool, &id, err.to_string()).await;
                 return;
@@ -703,6 +867,34 @@ impl TorrentService {
         Ok(dto)
     }
 
+    pub async fn pause(
+        &self,
+        pool: &PgPool,
+        user_id: i64,
+        id: &str,
+    ) -> anyhow::Result<TorrentJobDto> {
+        self.ensure_memory_job(pool, user_id, id).await?;
+
+        let (dto, handle) = {
+            let mut jobs = self.jobs.lock().await;
+            let job = jobs.get_mut(id).context("torrent job not found")?;
+            if job.user_id != user_id {
+                bail!("torrent job not found");
+            }
+            job.refresh_progress();
+            job.status = TorrentJobStatus::Paused;
+            job.updated_at = now_string();
+            let handle = job.handle.take();
+            (job.dto(), handle)
+        };
+
+        persist_progress(pool, &dto).await?;
+        if let Some(handle) = handle {
+            self.stop_torrent(&handle).await;
+        }
+        Ok(dto)
+    }
+
     async fn memory_details(&self, user_id: i64, id: &str) -> Option<TorrentSessionDto> {
         let jobs = self.jobs.lock().await;
         let job = jobs.get(id)?;
@@ -733,6 +925,13 @@ impl TorrentService {
         Ok(job.dto())
     }
 
+    async fn is_paused(&self, id: &str) -> bool {
+        let jobs = self.jobs.lock().await;
+        jobs.get(id)
+            .map(|job| job.status == TorrentJobStatus::Paused)
+            .unwrap_or(false)
+    }
+
     async fn fail_job(&self, pool: &PgPool, id: &str, error: String) {
         let dto = {
             let mut jobs = self.jobs.lock().await;
@@ -824,6 +1023,8 @@ impl TorrentService {
             let job = jobs.get_mut(id).context("torrent job not found")?;
             job.refresh_progress();
             job.status = TorrentJobStatus::Complete;
+            job.downloaded_bytes = job.selected_size();
+            job.progress_percent = 100.0;
             job.completed_at = Some(now_string());
             job.updated_at = now_string();
             let dto = job.dto();
@@ -892,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,
@@ -999,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,24 @@ tbody tr:hover {
     display: block;
 }
 
+.settings-page {
+    display: grid;
+    grid-template-columns: minmax(560px, 760px) minmax(260px, 1fr);
+    gap: 14px;
+    align-items: start;
+}
+
+.settings-card {
+    padding: 14px;
+}
+
+.settings-note {
+    padding: 14px;
+    color: var(--text-secondary);
+    font-size: 12px;
+    line-height: 1.55;
+}
+
 .library-row {
     display: grid;
     grid-template-columns: 38px minmax(0, 1fr) 300px 130px;
@@ -818,6 +836,11 @@ tbody tr:hover {
                 <i data-lucide="wrench"></i>
                 <span>Future Tools</span>
             </button>
+            <button class="nav-btn" :class="{active: activeView === 'settings'}" @click="activeView = 'settings'; loadSettings()">
+                <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">
@@ -1236,6 +1259,48 @@ tbody tr:hover {
                 </div>
             </section>
         </div>
+
+        <div class="content" x-show="activeView === 'settings'">
+            <div class="settings-page">
+                <section class="panel">
+                    <div class="panel-head">
+                        <div class="panel-title">
+                            <strong>External APIs</strong>
+                            <span>Keys used by scheduled enrichment jobs</span>
+                        </div>
+                        <span class="badge" :class="settings.lastfm_api_key_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_api_key_configured ? 'configured' : 'not configured'"></span>
+                    </div>
+                    <form class="settings-card" @submit.prevent="saveSettings()">
+                        <div class="field">
+                            <label>Last.fm API key</label>
+                            <input type="password" x-model="settingsDraft.lastfm_api_key" autocomplete="off" placeholder="Paste Last.fm API key" />
+                        </div>
+                        <div class="toolbar">
+                            <button class="btn primary" type="submit">
+                                <i data-lucide="save"></i>
+                                Save
+                            </button>
+                            <button class="btn" type="button" @click="loadSettings()">
+                                <i data-lucide="refresh-cw"></i>
+                                Reload
+                            </button>
+                        </div>
+                    </form>
+                </section>
+
+                <section class="panel">
+                    <div class="panel-head">
+                        <div class="panel-title">
+                            <strong>Last.fm Popularity</strong>
+                            <span>Weekly track rating refresh</span>
+                        </div>
+                    </div>
+                    <div class="settings-note">
+                        The scheduler uses Last.fm track.getInfo for each track, stores listeners, playcount, current rating, and a history row. The job processes tracks with missing or oldest ratings first and waits between requests to avoid Last.fm API limits.
+                    </div>
+                </section>
+            </div>
+        </div>
     </main>
 
     <div class="modal-backdrop" x-show="reviewModalOpen && activeReview" x-transition @click.self="reviewModalOpen = false">
@@ -1366,6 +1431,8 @@ function adminV2() {
         activeLibraryItem: null,
         editorOpen: false,
         editorDraft: { title: '', hidden: 'false' },
+        settings: { lastfm_api_key: '', lastfm_api_key_configured: false },
+        settingsDraft: { lastfm_api_key: '' },
         poller: null,
 
         async init() {
@@ -1399,6 +1466,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);
@@ -1462,6 +1530,32 @@ function adminV2() {
             }
         },
 
+        async loadSettings(showErrors = true) {
+            try {
+                this.settings = await this.request(`${this.apiBase}/settings`);
+                this.settingsDraft.lastfm_api_key = this.settings.lastfm_api_key || '';
+            } catch (error) {
+                if (showErrors) this.showToast(error.message);
+            } finally {
+                this.icons();
+            }
+        },
+
+        async saveSettings() {
+            try {
+                await this.request(`${this.apiBase}/settings`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        lastfm_api_key: this.settingsDraft.lastfm_api_key || ''
+                    })
+                });
+                await this.loadSettings(false);
+                this.showToast('Settings saved');
+            } catch (error) {
+                this.showToast(error.message);
+            }
+        },
+
         setReviewStatus(status) {
             this.reviewFilter.status = status;
             this.loadReviews();
@@ -1770,6 +1864,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 +1872,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

@@ -4,7 +4,7 @@
             <div class="modal-box info-modal">
                 <div class="info-modal-head">
                     <h3 x-text="$store.info.modal.title"></h3>
-                    <button class="mobile-list-action" @click="$store.info.close()" title="Close">
+                    <button class="mobile-list-action" @click="$store.info.close()" title="{{ t.player_close }}">
                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                             <line x1="18" y1="6" x2="6" y2="18"/>
                             <line x1="6" y1="6" x2="18" y2="18"/>
@@ -20,13 +20,13 @@
     <template x-if="$store.playlists.modal">
         <div class="modal-overlay" @click.self="$store.playlists.modal = null">
             <div class="modal-box">
-                <h3 x-text="$store.playlists.modal.mode === 'create' ? 'New Playlist' : 'Rename Playlist'"></h3>
-                <input type="text" x-model="$store.playlists.modal.title" placeholder="Playlist name"
+                <h3 x-text="$store.playlists.modal.mode === 'create' ? '{{ t.player_new_playlist }}' : '{{ t.player_rename_playlist }}'"></h3>
+                <input type="text" x-model="$store.playlists.modal.title" placeholder="{{ t.player_playlist_name }}"
                        @keydown.enter="$store.playlists.submitModal()" x-init="$nextTick(() => $el.focus())">
                 <div class="modal-footer">
-                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.modal = null">Cancel</button>
+                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.modal = null">{{ t.player_cancel }}</button>
                     <button class="modal-btn modal-btn-primary" @click="$store.playlists.submitModal()"
-                            x-text="$store.playlists.modal.mode === 'create' ? 'Create' : 'Save'"></button>
+                            x-text="$store.playlists.modal.mode === 'create' ? '{{ t.player_create }}' : '{{ t.player_save }}'"></button>
                 </div>
             </div>
         </div>
@@ -36,7 +36,7 @@
     <template x-if="$store.playlists.picker">
         <div class="modal-overlay" @click.self="$store.playlists.picker = null">
             <div class="modal-box">
-                <h3>Add to Playlist</h3>
+                <h3>{{ t.player_add_to_playlist }}</h3>
                 <div class="modal-playlist-list">
                     <template x-for="pl in $store.playlists.list.filter(p => p.kind === 'user' && p.is_own)" :key="pl.id">
                         <div class="modal-playlist-item" @click="$store.playlists.addToPicked(pl.id)">
@@ -46,8 +46,8 @@
                     </template>
                 </div>
                 <div class="modal-footer">
-                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.picker = null">Cancel</button>
-                    <button class="modal-btn modal-btn-primary" @click="$store.playlists.picker = null; $store.playlists.showCreate()">New Playlist</button>
+                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.picker = null">{{ t.player_cancel }}</button>
+                    <button class="modal-btn modal-btn-primary" @click="$store.playlists.picker = null; $store.playlists.showCreate()">{{ t.player_new_playlist }}</button>
                 </div>
             </div>
         </div>
@@ -59,84 +59,161 @@
             <div class="modal-box torrent-modal">
                 <div class="torrent-modal-head">
                     <div>
-                        <h3>Torrent manager</h3>
+                        <h3>{{ t.player_torrent_manager }}</h3>
                         <p class="torrent-message" style="margin:4px 0 0"
                            :class="{ error: $store.torrents.error }"
                            x-text="$store.torrents.message"></p>
                     </div>
+                    <button class="torrent-modal-close"
+                            @click="$store.torrents.close()"
+                            title="{{ t.player_close }}"
+                            aria-label="{{ t.player_close }}">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
                     <div class="torrent-client-status">
                         <span class="torrent-status-pill"
                               :class="{ active: $store.torrents.activeCount() > 0 }"
                               x-text="$store.torrents.clientSummary()"></span>
+                        <span class="torrent-status-pill torrent-agent-pill"
+                              :class="{ active: $store.torrents.agentBusy() }">
+                            <span class="torrent-agent-dot"></span>
+                            <span x-text="$store.torrents.agentSummary()"></span>
+                        </span>
                         <span class="torrent-status-pill"
-                              x-text="$store.torrents.sessions.length + ' saved'"></span>
+                              x-text="$store.torrents.sessions.length + ' ' + T.saved"></span>
                     </div>
                 </div>
 
                 <div class="torrent-manager-layout">
                     <aside class="torrent-manager-sidebar">
                         <div class="torrent-manager-title">
-                            <span>Saved torrents</span>
+                            <span>{{ t.player_saved_torrents }}</span>
                             <button class="modal-btn modal-btn-ghost" style="padding:4px 8px"
                                     @click="$store.torrents.loadSessions()"
-                                    :disabled="$store.torrents.loading">Refresh</button>
+                                    :disabled="$store.torrents.loading">{{ t.player_refresh }}</button>
                         </div>
                         <div class="torrent-session-list">
                             <template x-if="!$store.torrents.loadingSessions && $store.torrents.sessions.length === 0">
                                 <div class="empty-state" style="padding:28px 12px">
-                                    <p>No saved torrents</p>
+                                    <p>{{ t.player_no_saved_torrents }}</p>
                                 </div>
                             </template>
                             <template x-for="job in $store.torrents.sessions" :key="job.id">
                                 <div class="torrent-session-row"
-                                     :class="{ active: $store.torrents.previewData && $store.torrents.previewData.id === job.id }"
+                                     :class="{ active: $store.torrents.workspaceMode === 'session' && $store.torrents.previewData && $store.torrents.previewData.id === job.id }"
                                      @click="$store.torrents.openSession(job.id)">
-                                    <div style="min-width:0">
+                                    <div class="torrent-session-main">
+                                        <div class="torrent-session-topline">
                                             <div class="torrent-session-name" x-text="job.name"></div>
-                                        <div class="torrent-session-meta" x-text="$store.torrents.sessionMeta(job)"></div>
+                                            <span class="torrent-status-badge"
+                                                  :class="$store.torrents.statusBadgeClass(job)"
+                                                  x-text="$store.torrents.statusLabel(job)"></span>
+                                        </div>
+                                        <div class="torrent-session-meta" x-text="$store.torrents.sessionMeta(job)"></div>
+                                        <div class="torrent-session-progress">
+                                            <div class="torrent-session-progress-bar"
+                                                 :style="'width:' + $store.torrents.progressValue(job) + '%'"></div>
+                                        </div>
                                     </div>
-                                    <button class="torrent-session-remove"
-                                            @click.stop="$store.torrents.removeSession(job.id)">Delete</button>
                                 </div>
                             </template>
+                            <button type="button"
+                                    class="torrent-session-row torrent-session-add"
+                                    :class="{ active: $store.torrents.isImporting() }"
+                                    @click="$store.torrents.addNew()"
+                                    :disabled="$store.torrents.loading">
+                                <span class="torrent-session-add-icon">+</span>
+                                <span>{{ t.player_upload }}</span>
+                            </button>
                         </div>
                     </aside>
 
                     <section class="torrent-workspace">
+                        <template x-if="$store.torrents.workspaceMode === 'empty'">
+                            <div class="empty-state torrent-workspace-empty">
+                                <p x-text="T.chooseSavedOrAddTorrent"></p>
+                            </div>
+                        </template>
+
+                        <template x-if="$store.torrents.isImporting()">
+                            <div class="torrent-import-panel">
                                 <div class="torrent-modal-grid">
                                     <div>
-                                <label for="torrent-file-input">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">Magnet link</label>
+                                        <label for="torrent-magnet-input">{{ t.player_magnet_link }}</label>
                                         <input id="torrent-magnet-input" type="text"
                                                x-model="$store.torrents.magnet"
                                                placeholder="magnet:?xt=urn:btih:...">
                                     </div>
+                                    <div>
+                                        <label for="torrent-file-input">{{ t.player_torrent_file }}</label>
+                                        <input id="torrent-file-input" type="file" accept=".torrent,application/x-bittorrent"
+                                               @change="$store.torrents.file = $event.target.files[0] || null">
+                                    </div>
+                                </div>
+                                <div class="torrent-upload-progress"
+                                    x-show="$store.torrents.uploadProgress > 0 || ($store.torrents.localFiles.length > 0 && $store.torrents.loading)">
+                                    <div class="torrent-progress-head">
+                                        <span x-text="$store.torrents.uploadProgress >= 100 ? T.uploadComplete : T.uploadingFiles"></span>
+                                        <span x-text="$store.torrents.uploadProgressText"></span>
+                                    </div>
+                                    <div class="torrent-progress-track">
+                                        <div class="torrent-progress-bar"
+                                             :style="'width:' + $store.torrents.uploadProgress + '%'"></div>
+                                    </div>
                                 </div>
                                 <div class="torrent-actions">
                                     <button class="modal-btn modal-btn-primary" @click="$store.torrents.preview()" :disabled="$store.torrents.loading">
-                                Preview content
+                                        {{ t.player_upload_content }}
                                     </button>
-                            <button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearSelection()" :disabled="!$store.torrents.previewData">Clear</button>
                                 </div>
+                            </div>
+                        </template>
 
                         <template x-if="$store.torrents.currentJob">
                             <div class="torrent-progress-card">
                                 <div class="torrent-progress-head">
                                     <span x-text="$store.torrents.statusText($store.torrents.currentJob)"></span>
-                                    <span x-text="$store.torrents.currentJob.progress_percent.toFixed(1) + '%'"></span>
+                                    <span x-text="$store.torrents.progressValue($store.torrents.currentJob).toFixed(1) + '%'"></span>
                                 </div>
                                 <div class="torrent-progress-track">
                                     <div class="torrent-progress-bar"
-                                         :style="'width:' + Math.max(0, Math.min(100, $store.torrents.currentJob.progress_percent || 0)) + '%'"></div>
+                                         :style="'width:' + $store.torrents.progressValue($store.torrents.currentJob) + '%'"></div>
                                 </div>
-                                <div class="torrent-progress-details">
-                                    <span x-text="$store.torrents.bytes($store.torrents.currentJob.downloaded_bytes) + ' / ' + $store.torrents.bytes($store.torrents.currentJob.selected_size || $store.torrents.currentJob.total_size)"></span>
-                                    <span x-text="$store.torrents.speedText($store.torrents.currentJob)"></span>
-                                    <span x-text="$store.torrents.peerText($store.torrents.currentJob)"></span>
+                                <div class="torrent-progress-details"
+                                     :class="{ completed: $store.torrents.isCompleted($store.torrents.currentJob) }">
+                                    <span class="torrent-progress-metric">
+                                        <span class="torrent-progress-label"
+                                              x-text="$store.torrents.isCompleted($store.torrents.currentJob) ? T.size : T.downloaded"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.progressDetailText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.speed"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.speedText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.peers"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.peerText($store.torrents.currentJob)"></span>
+                                    </span>
+                                    <span class="torrent-progress-metric"
+                                          x-show="!$store.torrents.isCompleted($store.torrents.currentJob) && $store.torrents.etaText($store.torrents.currentJob)">
+                                        <span class="torrent-progress-label" x-text="T.eta"></span>
+                                        <span class="torrent-progress-value"
+                                              x-text="$store.torrents.etaText($store.torrents.currentJob)"></span>
+                                    </span>
                                 </div>
                             </div>
                         </template>
@@ -146,18 +223,28 @@
                             <div style="min-width:0">
                                 <div class="torrent-preview-title" x-text="$store.torrents.previewData.name"></div>
                                 <div class="torrent-preview-meta"
-                                     x-text="$store.torrents.previewData.files.length + ' files - ' + $store.torrents.bytes($store.torrents.previewData.total_size)"></div>
+                                     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 modal-btn-primary" @click="$store.torrents.start()" :disabled="$store.torrents.loading">
-                                Download selected
+                            <div class="torrent-preview-actions">
+                                <button class="modal-btn"
+                                        :class="$store.torrents.actionButtonClass()"
+                                        @click="$store.torrents.toggleDownloadAction()"
+                                        :disabled="$store.torrents.actionButtonDisabled()">
+                                    <span x-text="$store.torrents.actionButtonText()"></span>
                                 </button>
+                                <button class="modal-btn modal-btn-danger"
+                                        @click="$store.torrents.removeSession($store.torrents.previewData.id)"
+                                        :disabled="$store.torrents.loading">
+                                    {{ t.player_delete }}
+                                </button>
+                            </div>
                         </div>
                         <div class="torrent-tree-toolbar">
                             <div class="torrent-selected-summary"
-                                 x-text="$store.torrents.selected.size + ' selected - ' + $store.torrents.bytes($store.torrents.selectedBytes())"></div>
+                                 x-text="$store.torrents.selected.size + ' {{ t.player_selected }} - ' + $store.torrents.bytes($store.torrents.selectedBytes())"></div>
                             <div class="torrent-actions" style="margin-top:0">
-                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(true)">Expand all</button>
-                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(false)">Collapse</button>
+                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(true)">{{ t.player_expand_all }}</button>
+                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.expandAll(false)">{{ t.player_collapse }}</button>
                             </div>
                         </div>
                         <div class="torrent-file-tree">
@@ -215,20 +302,20 @@
     <template x-if="$store.history.modal">
         <div class="modal-overlay" @click.self="$store.history.close()">
             <div class="modal-box history-modal">
-                <h3>Play history</h3>
+                <h3>{{ t.player_play_history }}</h3>
                 <p class="torrent-message" :class="{ error: $store.history.error }"
                    x-text="$store.history.message"></p>
                 <div class="history-list">
                     <template x-if="!$store.history.loading && $store.history.items.length === 0">
                         <div class="empty-state" style="padding:32px 16px">
-                            <p>No plays yet</p>
+                            <p>{{ t.player_no_plays_yet }}</p>
                         </div>
                     </template>
                     <template x-for="item in $store.history.items" :key="item.id">
                         <div class="history-row">
                             <div style="min-width:0">
                                 <div class="history-title" x-text="item.track_title"></div>
-                                <div class="history-release" x-text="item.release_title || 'Unknown release'"></div>
+                                <div class="history-release" x-text="item.release_title || '{{ t.player_unknown_release }}'"></div>
                             </div>
                             <div>
                                 <div class="history-date" x-text="$store.history.date(item.played_at)"></div>
@@ -241,18 +328,17 @@
                     <button class="modal-btn modal-btn-ghost"
                             @click="$store.history.load($store.history.page - 1)"
                             :disabled="$store.history.loading || $store.history.page <= 1">
-                        Previous
+                        {{ t.player_previous }}
                     </button>
                     <span class="history-release"
-                          x-text="'Page ' + $store.history.page + ' of ' + $store.history.totalPages()"></span>
+                          x-text="'{{ t.player_page }} ' + $store.history.page + ' {{ t.player_of }} ' + $store.history.totalPages()"></span>
                     <button class="modal-btn modal-btn-primary"
                             @click="$store.history.load($store.history.page + 1)"
                             :disabled="$store.history.loading || $store.history.page >= $store.history.totalPages()">
-                        Next
+                        {{ t.player_next }}
                     </button>
                 </div>
             </div>
         </div>
     </template>
 </div>
-

templates/player/scripts.html

@@ -1,5 +1,94 @@
 <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
 <script>
+const T = {
+    info: "{{ t.player_info }}",
+    noDetails: "{{ t.player_no_details }}",
+    loadingHistory: "{{ t.player_loading_history }}",
+    failedLoadHistory: "{{ t.player_failed_load_history }}",
+    totalPlays: "{{ t.player_total_plays }}",
+    unknown: "{{ t.player_unknown }}",
+    unknownSize: "{{ t.player_unknown_size }}",
+    unknownRelease: "{{ t.player_unknown_release }}",
+    unknownTrack: "{{ t.player_unknown_track }}",
+    unknownAudio: "{{ t.player_unknown_audio }}",
+    type: "{{ t.player_type }}",
+    year: "{{ t.player_year }}",
+    tracks: "{{ t.player_tracks }}",
+    uploaders: "{{ t.player_uploaders }}",
+    artists: "{{ t.player_artists }}",
+    releaseYear: "{{ t.player_release_year }}",
+    duration: "{{ t.player_duration }}",
+    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 }}",
+    aiIdle: "{{ t.player_ai_idle }}",
+    aiPrefix: "{{ t.player_ai_prefix }}",
+    processing: "{{ t.player_processing }}",
+    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 }}",
+    failed: "{{ t.player_failed }}",
+    paused: "{{ t.player_paused }}",
+    noTorrentSelected: "{{ t.player_no_torrent_selected }}",
+    downloaded: "{{ t.player_downloaded }}",
+    speed: "{{ t.player_speed }}",
+    down: "{{ t.player_down }}",
+    up: "{{ t.player_up }}",
+    peers: "{{ t.player_peers }}",
+    live: "{{ t.player_live }}",
+    seen: "{{ t.player_seen }}",
+    eta: "{{ t.player_eta }}",
+    selected: "{{ t.player_selected }}",
+    downloadSelected: "{{ t.player_download_selected }}",
+    pauseDownload: "{{ t.player_pause_download }}",
+    chooseTorrent: "{{ t.player_choose_torrent }}",
+    readingTorrent: "{{ t.player_reading_torrent }}",
+    resolvingMagnet: "{{ t.player_resolving_magnet }}",
+    previewFailed: "{{ t.player_preview_failed }}",
+    allFilesSelected: "{{ t.player_all_files_selected }}",
+    openingSavedTorrent: "{{ t.player_opening_saved_torrent }}",
+    savedTorrentOpened: "{{ t.player_saved_torrent_opened }}",
+    removeTorrentConfirm: "{{ t.player_remove_torrent_confirm }}",
+    torrentRemoved: "{{ t.player_torrent_removed }}",
+    selectOneFile: "{{ t.player_select_one_file }}",
+    startingDownload: "{{ t.player_starting_download }}",
+    downloadStarted: "{{ t.player_download_started }}",
+    pausingDownload: "{{ t.player_pausing_download }}",
+    downloadPaused: "{{ t.player_download_paused }}",
+    statusFailed: "{{ t.player_status_failed }}",
+    startFailed: "{{ t.player_start_failed }}",
+    pauseFailed: "{{ t.player_pause_failed }}",
+    loadTorrentsFailed: "{{ t.player_load_torrents_failed }}",
+    openTorrentFailed: "{{ t.player_open_torrent_failed }}",
+    deleteTorrentFailed: "{{ t.player_delete_torrent_failed }}",
+    loadAiQueueFailed: "{{ t.player_load_ai_queue_failed }}",
+    deletePlaylistConfirm: "{{ t.player_delete_playlist_confirm }}",
+    albums: "{{ t.player_albums }}",
+    eps: "{{ t.player_eps }}",
+    singles: "{{ t.player_singles }}",
+    compilations: "{{ t.player_compilations }}",
+    mixtapes: "{{ t.player_mixtapes }}",
+    liveReleases: "{{ t.player_live_releases }}",
+    soundtracks: "{{ t.player_soundtracks }}",
+    likesPlaylist: "{{ t.player_likes_playlist }}",
+};
+
 function formatTime(seconds) {
     if (!seconds || isNaN(seconds)) return '0:00';
     const s = Math.floor(seconds);
@@ -30,8 +119,8 @@ document.addEventListener('alpine:init', () => {
         modal: null,
         open(title, body) {
             this.modal = {
-                title: title || 'Info',
-                body: body || 'No details available.',
+                title: title || T.info,
+                body: body || T.noDetails,
             };
         },
         close() {
@@ -125,16 +214,16 @@ document.addEventListener('alpine:init', () => {
             page = Math.max(1, page || 1);
             this.loading = true;
             this.error = false;
-            this.message = 'Loading history...';
+            this.message = T.loadingHistory;
             try {
                 const res = await fetch(`/api/player/history?page=${page}&limit=${this.perPage}`);
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Failed to load history');
+                if (!res.ok) throw new Error(data.error || T.failedLoadHistory);
                 this.items = data.items || [];
                 this.page = data.page || page;
                 this.perPage = data.per_page || this.perPage;
                 this.total = data.total || 0;
-                this.message = this.total ? (this.total + ' total plays') : '';
+                this.message = this.total ? (this.total + ' ' + T.totalPlays) : '';
             } catch (err) {
                 this.error = true;
                 this.message = err.message || String(err);
@@ -650,13 +739,13 @@ document.addEventListener('alpine:init', () => {
             const releases = this.currentArtist?.releases || [];
             const order = ['album', 'ep', 'single', 'compilation', 'mixtape', 'live', 'soundtrack'];
             const labels = {
-                album: 'Albums',
-                ep: 'EPs',
-                single: 'Singles',
-                compilation: 'Compilations',
-                mixtape: 'Mixtapes',
-                live: 'Live releases',
-                soundtrack: 'Soundtracks',
+                album: T.albums,
+                ep: T.eps,
+                single: T.singles,
+                compilation: T.compilations,
+                mixtape: T.mixtapes,
+                live: T.liveReleases,
+                soundtrack: T.soundtracks,
             };
             const groups = new Map();
             for (const release of releases) {
@@ -692,7 +781,7 @@ document.addEventListener('alpine:init', () => {
         },
 
         bytes(value) {
-            if (!value) return 'unknown size';
+            if (!value) return T.unknownSize;
             const units = ['B', 'KB', 'MB', 'GB', 'TB'];
             let size = Number(value);
             let idx = 0;
@@ -707,40 +796,49 @@ document.addEventListener('alpine:init', () => {
             const rows = uploaders || [];
             if (!rows.length) return 'UFO';
             return rows
-                .map(row => `${row.name || 'UFO'} (${row.track_count} track${row.track_count === 1 ? '' : 's'})`)
+                .map(row => `${row.name || 'UFO'} (${row.track_count} ${T.trackWord})`)
                 .join(', ');
         },
 
         releaseInfo(release) {
             if (!release) return '';
             const lines = [
-                release.title || 'Unknown release',
-                `Type: ${release.release_type || 'unknown'}`,
-                `Year: ${release.year || 'unknown'}`,
-                `Tracks: ${release.track_count || release.tracks?.length || 0}`,
-                `Uploaders: ${this.uploadersInfo(release.uploaders || [])}`,
+                release.title || T.unknownRelease,
+                `${T.type}: ${release.release_type || T.unknown}`,
+                `${T.year}: ${release.year || T.unknown}`,
+                `${T.tracks}: ${release.track_count || release.tracks?.length || 0}`,
+                `${T.uploaders}: ${this.uploadersInfo(release.uploaders || [])}`,
             ];
             return lines.join('\n');
         },
 
         trackInfo(track) {
             if (!track) return '';
-            const artists = this.trackArtistLinks(track).map(artist => artist.label).join(', ') || 'unknown';
+            const artists = this.trackArtistLinks(track).map(artist => artist.label).join(', ') || T.unknown;
             const audio = [
                 track.audio_format || null,
                 track.audio_bitrate ? `${track.audio_bitrate} kbps` : null,
                 track.audio_sample_rate ? `${track.audio_sample_rate} Hz` : null,
                 track.audio_bit_depth ? `${track.audio_bit_depth}-bit` : null,
-            ].filter(Boolean).join(' · ') || 'unknown audio details';
+            ].filter(Boolean).join(' · ') || T.unknownAudio;
             const lines = [
-                track.title || 'Unknown track',
-                `Artists: ${artists}`,
-                `Release year: ${track.release_year || 'unknown'}`,
-                `Duration: ${formatTime(track.duration_seconds)}`,
-                `Audio: ${audio}`,
-                `Size: ${this.bytes(track.file_size_bytes)}`,
-                `Uploader: ${track.uploader_name || 'UFO'}`,
+                track.title || T.unknownTrack,
+                `${T.artists}: ${artists}`,
+                `${T.releaseYear}: ${track.release_year || T.unknown}`,
+                `${T.duration}: ${formatTime(track.duration_seconds)}`,
+                `${T.audio}: ${audio}`,
+                `${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) ? rating.toFixed(2) : 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');
         },
 
@@ -1003,11 +1101,13 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('torrents', {
         modal: false,
         file: null,
+        localFiles: [],
         magnet: '',
         sessions: [],
         loadingSessions: false,
         currentJob: null,
         previewData: null,
+        workspaceMode: 'empty',
         treeRoot: null,
         selected: new Set(),
         expanded: new Set(),
@@ -1015,16 +1115,54 @@ document.addEventListener('alpine:init', () => {
         message: '',
         error: false,
         _pollTimer: null,
+        _pollJobId: null,
+        _refreshTimer: null,
+        queuedTasks: 0,
+        processingTasks: 0,
+        loadingAgentStatus: false,
+        uploadProgress: 0,
+        uploadProgressText: '',
 
         open() {
             this.modal = true;
             this.message = '';
             this.error = false;
             this.loadSessions();
+            this.loadAgentStatus();
+            this._startRefresh();
         },
 
         close() {
             this.modal = false;
+            this._stopRefresh();
+            this._stopPoll();
+        },
+
+        _stopPoll() {
+            if (this._pollTimer) clearInterval(this._pollTimer);
+            this._pollTimer = null;
+            this._pollJobId = null;
+        },
+
+        isImporting() {
+            return this.workspaceMode === 'new';
+        },
+
+        addNew() {
+            if (this.loading) return;
+            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;
+            this.selected = new Set();
+            this.expanded = new Set();
+            this._setMessage(T.chooseTorrent);
         },
 
         _setMessage(message, error = false) {
@@ -1048,47 +1186,214 @@ document.addEventListener('alpine:init', () => {
             return this.sessions.filter(job => job.active || job.status === 'downloading' || job.status === 'moving').length;
         },
 
+        isDownloading(job) {
+            return !!job && (job.active || job.status === 'downloading' || job.status === 'moving');
+        },
+
+        isCurrentDownloading() {
+            return this.isDownloading(this.currentJob);
+        },
+
+        isCompleted(job) {
+            return this.normalizedStatus(job) === 'completed';
+        },
+
+        isCurrentCompleted() {
+            return this.isCompleted(this.currentJob);
+        },
+
+        selectedArray() {
+            return [...this.selected].sort((a, b) => Number(a) - Number(b));
+        },
+
+        selectionMatchesJob(job) {
+            if (!job) return false;
+            const saved = Array.isArray(job.selected_files) ? job.selected_files : [];
+            const selected = this.selectedArray();
+            if (saved.length !== selected.length) return false;
+            const savedSet = new Set(saved.map(index => Number(index)));
+            return selected.every(index => savedSet.has(Number(index)));
+        },
+
+        hasCurrentSelectionChanges() {
+            return !!this.currentJob && !this.selectionMatchesJob(this.currentJob);
+        },
+
+        isCurrentCompletedLocked() {
+            return this.isCurrentCompleted() && !this.hasCurrentSelectionChanges();
+        },
+
+        normalizedStatus(job) {
+            const status = String(job?.status || 'preview').toLowerCase();
+            if (status === 'complete') return 'completed';
+            return status;
+        },
+
+        statusLabel(job) {
+            const labels = {
+                preview: T.preview,
+                resolving: T.resolving,
+                downloading: T.downloading,
+                moving: T.moving,
+                completed: T.completed,
+                failed: T.failed,
+                paused: T.paused,
+            };
+            const status = this.normalizedStatus(job);
+            return labels[status] || status;
+        },
+
+        statusBadgeClass(job) {
+            return 'status-' + this.normalizedStatus(job);
+        },
+
+        progressValue(job) {
+            if (!job) return 0;
+            if (this.normalizedStatus(job) === 'completed') return 100;
+            return Math.max(0, Math.min(100, Number(job.progress_percent || 0)));
+        },
+
         clientSummary() {
             const active = this.activeCount();
-            return active > 0 ? active + ' active' : 'Client idle';
+            return active > 0 ? active + ' ' + T.active : T.clientIdle;
+        },
+
+        agentSummary() {
+            const queued = Number(this.queuedTasks || 0);
+            const processing = Number(this.processingTasks || 0);
+            if (queued === 0 && processing === 0) return T.aiIdle;
+            const parts = [];
+            if (processing > 0) parts.push(processing + ' ' + T.processing);
+            parts.push(queued + ' ' + T.queued);
+            return T.aiPrefix + ' ' + parts.join(' / ');
+        },
+
+        agentBusy() {
+            return Number(this.queuedTasks || 0) > 0 || Number(this.processingTasks || 0) > 0;
         },
 
         statusText(job) {
-            if (!job) return 'No torrent selected';
+            if (!job) return T.noTorrentSelected;
             const state = job.client_state ? ' / ' + job.client_state : '';
-            return job.status + state;
+            return this.statusLabel(job) + state;
         },
 
         speedText(job) {
             if (!job) return '0 B/s';
             const down = Number(job.download_speed_mbps || 0);
-            const up = Number(job.upload_speed_mbps || 0);
-            return 'down ' + down.toFixed(2) + ' MiB/s - up ' + up.toFixed(2) + ' MiB/s';
+            return down.toFixed(2) + ' MiB/s';
         },
 
         peerText(job) {
-            if (!job) return 'peers n/a';
+            if (!job) return 'n/a';
             const live = job.peers_live == null ? '?' : job.peers_live;
             const seen = job.peers_seen == null ? '?' : job.peers_seen;
-            return 'peers ' + live + ' live / ' + seen + ' seen' + (job.eta ? ' - eta ' + job.eta : '');
+            return live + ' ' + T.live + ' / ' + seen + ' ' + T.seen;
+        },
+
+        etaText(job) {
+            return job && job.eta ? job.eta : '';
+        },
+
+        progressDetailText(job) {
+            if (!job) return '';
+            const size = this.bytes(job.selected_size || job.total_size);
+            if (this.isCompleted(job)) return size;
+            return this.bytes(job.downloaded_bytes) + ' / ' + size;
+        },
+
+        actionButtonClass() {
+            if (this.isCurrentCompletedLocked()) return 'modal-btn-ghost';
+            return this.isCurrentDownloading() ? 'modal-btn-pause' : 'modal-btn-primary';
+        },
+
+        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()
+                || this.normalizedStatus(this.currentJob) === 'resolving'
+                || !this.previewData
+                || !Array.isArray(this.previewData.files)
+                || this.previewData.files.length === 0;
+        },
+
+        toggleDownloadAction() {
+            if (this.isCurrentCompletedLocked()) return;
+            if (this.isCurrentDownloading()) this.pause();
+            else this.start();
         },
 
         sessionMeta(job) {
             if (!job) return '';
             const size = this.bytes(job.selected_size || job.total_size);
-            return job.status + ' - ' + (job.progress_percent || 0).toFixed(1) + '% - ' + size;
+            return this.progressValue(job).toFixed(1) + '% - ' + size;
+        },
+
+        async loadAgentStatus() {
+            this.loadingAgentStatus = true;
+            try {
+                const res = await fetch('/api/player/agent-queue');
+                const data = await res.json();
+                if (!res.ok) throw new Error(data.error || T.loadAiQueueFailed);
+                this.queuedTasks = Number(data.queued_count || 0);
+                this.processingTasks = Number(data.processing_count || 0);
+            } catch {
+                this.queuedTasks = 0;
+                this.processingTasks = 0;
+            } finally {
+                this.loadingAgentStatus = false;
+            }
+        },
+
+        _startRefresh() {
+            this._stopRefresh();
+            this._refreshTimer = setInterval(() => {
+                if (!this.modal) return;
+                this.loadSessions();
+                this.loadAgentStatus();
+            }, 5000);
+        },
+
+        _stopRefresh() {
+            if (this._refreshTimer) clearInterval(this._refreshTimer);
+            this._refreshTimer = null;
         },
 
         _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;
         },
 
+        _isSelectedJob(id) {
+            return this.workspaceMode === 'session'
+                && this.currentJob
+                && this.currentJob.id === id
+                && this.previewData
+                && this.previewData.id === id;
+        },
+
+        _syncCurrentJobFromSessions() {
+            if (!this.currentJob || !this.previewData) return;
+            const selected = this.sessions.find(job => job.id === this.currentJob.id && job.id === this.previewData.id);
+            if (selected) this.currentJob = selected;
+        },
+
         _applySession(data) {
             const preview = data.preview || data;
             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
@@ -1104,8 +1409,10 @@ document.addEventListener('alpine:init', () => {
             try {
                 const res = await fetch('/api/player/torrents');
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Could not load torrents');
+                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 {
@@ -1113,16 +1420,30 @@ 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();
             this.loading = true;
-            this._setMessage('Opening saved torrent...');
+            this._setMessage(T.openingSavedTorrent);
             try {
                 const res = await fetch(`/api/player/torrents/session/${id}`);
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Could not open torrent');
+                if (!res.ok) throw new Error(data.error || T.openTorrentFailed);
                 this._applySession(data);
-                this._setMessage('Saved torrent opened. Adjust files or resume download.');
+                this._setMessage(T.savedTorrentOpened);
                 if (data.job && (data.job.active || data.job.status === 'downloading' || data.job.status === 'moving')) {
                     this._poll(data.job.id);
                 }
@@ -1135,20 +1456,21 @@ document.addEventListener('alpine:init', () => {
 
         async removeSession(id) {
             if (!id || this.loading) return;
-            if (!confirm('Remove this torrent from the client list? Downloaded files will stay on disk.')) return;
+            if (!confirm(T.removeTorrentConfirm)) return;
             this.loading = true;
             try {
                 const res = await fetch(`/api/player/torrents/session/${id}`, { method: 'DELETE' });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Could not delete torrent');
+                if (!res.ok) throw new Error(data.error || T.deleteTorrentFailed);
                 this.sessions = this.sessions.filter(job => job.id !== id);
                 if (this.previewData && this.previewData.id === id) {
                     this.previewData = null;
                     this.currentJob = null;
                     this.treeRoot = null;
                     this.selected = new Set();
+                    this.workspaceMode = this.sessions.length ? 'empty' : 'new';
                 }
-                this._setMessage('Torrent removed from the client list.');
+                this._setMessage(T.torrentRemoved);
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
             } finally {
@@ -1168,11 +1490,79 @@ 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('Choose a .torrent file or paste a magnet link.', true);
+                this._setMessage(T.chooseTorrent, true);
                 return;
             }
 
@@ -1180,9 +1570,10 @@ document.addEventListener('alpine:init', () => {
             this.previewData = null;
             this.treeRoot = null;
             this.currentJob = null;
+            this.workspaceMode = 'new';
             this.selected = new Set();
             this.expanded = new Set();
-            this._setMessage(this.file ? 'Reading torrent file...' : 'Resolving magnet metadata. This can take a while...');
+            this._setMessage(this.file ? T.readingTorrent : T.resolvingMagnet);
 
             try {
                 const payload = this.file
@@ -1194,10 +1585,10 @@ document.addEventListener('alpine:init', () => {
                     body: JSON.stringify(payload),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Preview failed');
+                if (!res.ok) throw new Error(data.error || T.previewFailed);
 
                 this._applySession(data);
-                this._setMessage('All files are selected by default. Clear or adjust the tree before download.');
+                this._setMessage((data.preview?.files || []).length ? T.allFilesSelected : T.resolving);
                 await this.loadSessions();
             } catch (err) {
                 this._setMessage(err.message || String(err), true);
@@ -1391,14 +1782,14 @@ document.addEventListener('alpine:init', () => {
 
         async start() {
             if (!this.previewData || this.loading) return;
-            const selected = [...this.selected];
+            const selected = this.selectedArray();
             if (selected.length === 0) {
-                this._setMessage('Select at least one file.', true);
+                this._setMessage(T.selectOneFile, true);
                 return;
             }
 
             this.loading = true;
-            this._setMessage('Starting download...');
+            this._setMessage(T.startingDownload);
             try {
                 const res = await fetch(`/api/player/torrents/${this.previewData.id}/start`, {
                     method: 'POST',
@@ -1406,10 +1797,10 @@ document.addEventListener('alpine:init', () => {
                     body: JSON.stringify({ selected_files: selected }),
                 });
                 const data = await res.json();
-                if (!res.ok) throw new Error(data.error || 'Start failed');
+                if (!res.ok) throw new Error(data.error || T.startFailed);
                 this.currentJob = data;
                 this._rememberJob(data);
-                this._setMessage('Download started. Files will move to inbox when complete.');
+                this._setMessage(T.downloadStarted);
                 this._poll(data.id);
                 await this.loadSessions();
             } catch (err) {
@@ -1419,28 +1810,53 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        async pause() {
+            if (!this.currentJob || this.loading || !this.isCurrentDownloading()) return;
+
+            this.loading = true;
+            this._setMessage(T.pausingDownload);
+            try {
+                const res = await fetch(`/api/player/torrents/${this.currentJob.id}/pause`, {
+                    method: 'POST',
+                });
+                const data = await res.json();
+                if (!res.ok) throw new Error(data.error || T.pauseFailed);
+                this.currentJob = data;
+                this._rememberJob(data);
+                this._setMessage(T.downloadPaused);
+                this._stopPoll();
+                await this.loadSessions();
+            } catch (err) {
+                this._setMessage(err.message || String(err), true);
+            } finally {
+                this.loading = false;
+            }
+        },
+
         _poll(id) {
-            if (this._pollTimer) clearInterval(this._pollTimer);
+            this._stopPoll();
+            this._pollJobId = id;
             this._pollTimer = setInterval(async () => {
                 try {
                     const res = await fetch(`/api/player/torrents/${id}/status`);
                     const data = await res.json();
-                    if (!res.ok) throw new Error(data.error || 'Status failed');
-                    this.currentJob = data;
+                    if (!res.ok) throw new Error(data.error || T.statusFailed);
                     this._rememberJob(data);
+                    if (this._isSelectedJob(id)) {
+                        this.currentJob = data;
                         this._setMessage(
-                        data.status + ' - ' + data.progress_percent.toFixed(1) + '% - ' + this.bytes(data.downloaded_bytes),
+                            this.statusLabel(data) + ' - ' + this.progressValue(data).toFixed(1) + '% - ' + this.bytes(data.downloaded_bytes),
                             data.status === 'failed'
                         );
+                    }
                     if (data.status === 'complete' || data.status === 'failed') {
-                        clearInterval(this._pollTimer);
-                        this._pollTimer = null;
+                        this._stopPoll();
                         this.loadSessions();
+                        this.loadAgentStatus();
                     }
                 } catch (err) {
-                    this._setMessage(err.message || String(err), true);
-                    clearInterval(this._pollTimer);
-                    this._pollTimer = null;
+                    if (this._isSelectedJob(id)) this._setMessage(err.message || String(err), true);
+                    this._stopPoll();
                 }
             }, 2000);
         },
@@ -1481,6 +1897,10 @@ document.addEventListener('alpine:init', () => {
             ));
         },
 
+        displayTitle(pl) {
+            return pl?.kind === 'likes' ? T.likesPlaylist : (pl?.title || '');
+        },
+
         showCreate() {
             this.modal = { mode: 'create', title: '' };
         },
@@ -1517,7 +1937,7 @@ document.addEventListener('alpine:init', () => {
         },
 
         async deletePlaylist(id) {
-            if (!confirm('Delete this playlist?')) return;
+            if (!confirm(T.deletePlaylistConfirm)) return;
             try {
                 await fetch(`/api/player/playlists/${id}`, { method: 'DELETE' });
                 await this.reload();

templates/player/shell.html

@@ -16,7 +16,7 @@
                         <div class="user-name" x-text="$store.user.profile?.name || ''"></div>
                         <div class="user-role" x-text="$store.user.profile?.role || ''"></div>
                     </div>
-                    <button class="user-logout-btn" @click="$store.user.logout()" title="Log out">
+                    <button class="user-logout-btn" @click="$store.user.logout()" title="{{ t.player_log_out }}">
                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                             <path d="M9 21H5a2 2 0 01-2-2V5a2 2 0 012-2h4"/>
                             <polyline points="16 17 21 12 16 7"/>
@@ -27,37 +27,37 @@
                 <div class="user-stats">
                     <button class="user-stat" @click="$store.history.open()">
                         <span class="user-stat-value" x-text="$store.user.format($store.user.profile?.stats?.plays)"></span>
-                        <span class="user-stat-label">plays</span>
+                        <span class="user-stat-label">{{ t.player_plays_count }}</span>
                     </button>
                     <div class="user-stat">
                         <span class="user-stat-value" x-text="$store.user.format($store.user.profile?.stats?.liked_tracks)"></span>
-                        <span class="user-stat-label">likes</span>
+                        <span class="user-stat-label">{{ t.player_likes_count }}</span>
                     </div>
                     <div class="user-stat">
                         <span class="user-stat-value" x-text="$store.user.duration($store.user.profile?.stats?.listened_minutes)"></span>
-                        <span class="user-stat-label">listened</span>
+                        <span class="user-stat-label">{{ t.player_listened }}</span>
                     </div>
                 </div>
             </div>
             <div class="sidebar-header">
-                <h2>Library</h2>
+                <h2>{{ t.player_library }}</h2>
             </div>
             <div class="sidebar-nav">
                 <div class="sidebar-nav-item"
                      :class="{ active: $store.library.view === 'artists' }"
                      @click="$store.library.goArtists()">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
-                    Artists
+                    {{ t.player_artists }}
                 </div>
             </div>
             <div class="sidebar-section">
                 <div class="sidebar-section-title">
-                    Following
+                    {{ t.player_following }}
                     <span x-show="$store.follows.artists.length > 0"
                           x-text="'(' + $store.follows.artists.length + ')'"></span>
                 </div>
                 <template x-if="$store.follows.artists.length === 0">
-                    <div class="following-empty">No followed artists</div>
+                    <div class="following-empty">{{ t.player_no_followed_artists }}</div>
                 </template>
                 <div class="following-list" x-show="$store.follows.artists.length > 0" x-cloak>
                     <template x-for="artist in $store.follows.artists" :key="artist.id">
@@ -84,20 +84,20 @@
                             <template x-if="pl.kind === 'likes'">
                                 <span style="display:flex;align-items:center;gap:6px">
                                     <svg viewBox="0 0 24 24" fill="var(--accent)" stroke="none" width="14" height="14"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
-                                    <span x-text="pl.title"></span>
+                                    <span x-text="$store.playlists.displayTitle(pl)"></span>
                                 </span>
                             </template>
                             <template x-if="pl.kind !== 'likes'">
-                                <span x-text="pl.title"></span>
+                                <span x-text="$store.playlists.displayTitle(pl)"></span>
                             </template>
-                            <span class="playlist-count" x-text="pl.track_count + ' tracks'"></span>
+                            <span class="playlist-count" x-text="pl.track_count + ' {{ t.player_tracks_count }}'"></span>
                         </div>
                         <template x-if="pl.is_own && pl.kind === 'user'">
                             <div class="playlist-item-actions">
-                                <button class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="Rename">
+                                <button class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="{{ t.player_rename }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
                                 </button>
-                                <button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="Delete">
+                                <button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
                                 </button>
                             </div>
@@ -106,22 +106,22 @@
                 </template>
                 <button class="sidebar-create-btn" @click="$store.playlists.showCreate()">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
-                    New Playlist
+                    {{ t.player_new_playlist }}
                 </button>
                 <template x-if="$store.playlists.publishedList().length > 0">
                     <div class="playlist-public-section">
-                        <div class="sidebar-section-title playlist-subtitle">Published Playlists</div>
+                        <div class="sidebar-section-title playlist-subtitle">{{ t.player_published_playlists }}</div>
                         <template x-for="pl in $store.playlists.publishedList()" :key="'published-' + pl.id">
                             <div class="playlist-item-row">
                                 <div class="playlist-item playlist-item-public" @click="$store.library.openPlaylist(pl.id)">
                                     <div class="playlist-title-line">
-                                        <span class="playlist-title-text" x-text="pl.title"></span>
-                                        <span class="playlist-public-badge">Public</span>
+                                        <span class="playlist-title-text" x-text="$store.playlists.displayTitle(pl)"></span>
+                                        <span class="playlist-public-badge">{{ t.player_public }}</span>
                                     </div>
                                     <div class="playlist-meta-line">
-                                        <span class="playlist-owner" x-show="pl.owner_name" x-text="'by ' + pl.owner_name"></span>
+                                        <span class="playlist-owner" x-show="pl.owner_name" x-text="'{{ t.player_by }} ' + pl.owner_name"></span>
                                         <span x-show="pl.owner_name">&middot;</span>
-                                        <span x-text="pl.track_count + ' tracks'"></span>
+                                        <span x-text="pl.track_count + ' {{ t.player_tracks_count }}'"></span>
                                     </div>
                                 </div>
                             </div>
@@ -130,7 +130,7 @@
                 </template>
             </div>
             <div class="sidebar-bottom">
-                <a href="/admin/">Admin Panel</a>
+                <a href="/admin/">{{ t.player_admin_panel }}</a>
             </div>
         </div>
 
@@ -139,10 +139,10 @@
                 <aside class="mobile-library-drawer">
                     <div class="mobile-drawer-head">
                         <div>
-                            <div class="mobile-drawer-title">Library</div>
-                            <div class="playlist-count">Playlists and followed artists</div>
+                            <div class="mobile-drawer-title">{{ t.player_library }}</div>
+                            <div class="playlist-count">{{ t.player_playlists }} / {{ t.player_following }}</div>
                         </div>
-                        <button class="mobile-list-action" @click="$store.mobile.closeLibrary()" title="Close">
+                        <button class="mobile-list-action" @click="$store.mobile.closeLibrary()" title="{{ t.player_close }}">
                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                 <line x1="18" y1="6" x2="6" y2="18"/>
                                 <line x1="6" y1="6" x2="18" y2="18"/>
@@ -155,18 +155,18 @@
                                  :class="{ active: $store.library.view === 'artists' }"
                                  @click="$store.library.goArtists(); $store.mobile.closeLibrary()">
                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
-                                Artists
+                                {{ t.player_artists }}
                             </div>
                         </div>
 
                         <div class="mobile-drawer-section">
                             <div class="sidebar-section-title">
-                                Following
+                                {{ t.player_following }}
                                 <span x-show="$store.follows.artists.length > 0"
                                       x-text="'(' + $store.follows.artists.length + ')'"></span>
                             </div>
                             <template x-if="$store.follows.artists.length === 0">
-                                <div class="following-empty">No followed artists</div>
+                                <div class="following-empty">{{ t.player_no_followed_artists }}</div>
                             </template>
                             <div class="following-list" x-show="$store.follows.artists.length > 0" x-cloak>
                                 <template x-for="artist in $store.follows.artists" :key="'mobile-follow-' + artist.id">
@@ -186,7 +186,7 @@
                                         </div>
                                         <button class="mobile-list-action"
                                                 @click.stop="$store.follows.toggle(artist.id)"
-                                                title="Unfollow artist">
+                                                title="{{ t.player_unfollow_artist }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                                 <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
                                                 <circle cx="9" cy="7" r="4"/>
@@ -199,27 +199,27 @@
                         </div>
 
                         <div class="mobile-drawer-section">
-                            <div class="sidebar-section-title">Playlists</div>
+                            <div class="sidebar-section-title">{{ t.player_playlists }}</div>
                             <template x-for="pl in $store.playlists.regularList()" :key="'mobile-playlist-' + pl.id">
                                 <div class="playlist-item-row">
                                     <div class="playlist-item" @click="$store.library.openPlaylist(pl.id); $store.mobile.closeLibrary()">
                                         <template x-if="pl.kind === 'likes'">
                                             <span style="display:flex;align-items:center;gap:6px">
                                                 <svg viewBox="0 0 24 24" fill="var(--accent)" stroke="none" width="14" height="14"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
-                                                <span x-text="pl.title"></span>
+                                                <span x-text="$store.playlists.displayTitle(pl)"></span>
                                             </span>
                                         </template>
                                         <template x-if="pl.kind !== 'likes'">
-                                            <span x-text="pl.title"></span>
+                                            <span x-text="$store.playlists.displayTitle(pl)"></span>
                                         </template>
-                                        <span class="playlist-count" x-text="pl.track_count + ' tracks'"></span>
+                                        <span class="playlist-count" x-text="pl.track_count + ' {{ t.player_tracks_count }}'"></span>
                                     </div>
                                     <template x-if="pl.is_own && pl.kind === 'user'">
                                         <div class="playlist-item-actions">
-                                            <button class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="Rename">
+                                            <button class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="{{ t.player_rename }}">
                                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
                                             </button>
-                                            <button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="Delete">
+                                            <button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
                                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
                                             </button>
                                         </div>
@@ -228,22 +228,22 @@
                             </template>
                             <button class="sidebar-create-btn" @click="$store.mobile.closeLibrary(); $store.playlists.showCreate()">
                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
-                                New Playlist
+                                {{ t.player_new_playlist }}
                             </button>
                             <template x-if="$store.playlists.publishedList().length > 0">
                                 <div class="playlist-public-section">
-                                    <div class="sidebar-section-title playlist-subtitle">Published Playlists</div>
+                                    <div class="sidebar-section-title playlist-subtitle">{{ t.player_published_playlists }}</div>
                                     <template x-for="pl in $store.playlists.publishedList()" :key="'mobile-published-' + pl.id">
                                         <div class="playlist-item-row">
                                             <div class="playlist-item playlist-item-public" @click="$store.library.openPlaylist(pl.id); $store.mobile.closeLibrary()">
                                                 <div class="playlist-title-line">
-                                                    <span class="playlist-title-text" x-text="pl.title"></span>
-                                                    <span class="playlist-public-badge">Public</span>
+                                                    <span class="playlist-title-text" x-text="$store.playlists.displayTitle(pl)"></span>
+                                                    <span class="playlist-public-badge">{{ t.player_public }}</span>
                                                 </div>
                                                 <div class="playlist-meta-line">
-                                                    <span class="playlist-owner" x-show="pl.owner_name" x-text="'by ' + pl.owner_name"></span>
+                                                    <span class="playlist-owner" x-show="pl.owner_name" x-text="'{{ t.player_by }} ' + pl.owner_name"></span>
                                                     <span x-show="pl.owner_name">&middot;</span>
-                                                    <span x-text="pl.track_count + ' tracks'"></span>
+                                                    <span x-text="pl.track_count + ' {{ t.player_tracks_count }}'"></span>
                                                 </div>
                                             </div>
                                         </div>
@@ -262,7 +262,7 @@
             <div class="content-topbar" @click.outside="$store.user.menuOpen = false">
                 <button class="mobile-library-btn"
                         @click="$store.user.menuOpen = false; $store.mobile.toggleLibrary()"
-                        title="Library">
+                        title="{{ t.player_library }}">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                         <path d="M4 19.5A2.5 2.5 0 016.5 17H20"/>
                         <path d="M4 4.5A2.5 2.5 0 016.5 2H20v20H6.5A2.5 2.5 0 014 19.5z"/>
@@ -270,7 +270,7 @@
                 </button>
                 <div class="search-bar">
                     <span class="search-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg></span>
-                    <input id="search-input" type="text" placeholder="Search artists, releases, tracks..."
+                    <input id="search-input" type="text" placeholder="{{ t.player_search_placeholder }}"
                            x-model="$store.library.searchQuery"
                            @input.debounce.300ms="$store.library.search($store.library.searchQuery)"
                            @keydown.escape="$store.library.clearSearch(); $el.blur()">
@@ -285,14 +285,13 @@
                 </div>
                 <button class="torrent-import-btn"
                         @click="$store.torrents.open()"
-                        title="Import torrent">
+                        title="{{ t.player_import_torrent }}">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                         <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/>
                         <polyline points="7 10 12 15 17 10"/>
                         <line x1="12" y1="15" x2="12" y2="3"/>
                     </svg>
                 </button>
-                <span class="version-chip">v{{ t.app_version() }}</span>
                 <button class="mobile-account-chip"
                         x-show="$store.user.profile"
                         x-cloak
@@ -314,20 +313,20 @@
                     <div class="user-stats">
                         <button class="user-stat" @click="$store.history.open(); $store.user.menuOpen = false">
                             <span class="user-stat-value" x-text="$store.user.format($store.user.profile?.stats?.plays)"></span>
-                            <span class="user-stat-label">plays</span>
+                            <span class="user-stat-label">{{ t.player_plays_count }}</span>
                         </button>
                         <div class="user-stat">
                             <span class="user-stat-value" x-text="$store.user.format($store.user.profile?.stats?.liked_tracks)"></span>
-                            <span class="user-stat-label">likes</span>
+                            <span class="user-stat-label">{{ t.player_likes_count }}</span>
                         </div>
                         <div class="user-stat">
                             <span class="user-stat-value" x-text="$store.user.duration($store.user.profile?.stats?.listened_minutes)"></span>
-                            <span class="user-stat-label">listened</span>
+                            <span class="user-stat-label">{{ t.player_listened }}</span>
                         </div>
                     </div>
                     <button class="modal-btn modal-btn-primary mobile-account-logout"
                             @click="$store.user.logout()">
-                        Log out
+                        {{ t.player_log_out }}
                     </button>
                 </div>
             </div>
@@ -343,13 +342,13 @@
                             <template x-if="$store.library.searchResults.artists.length === 0 && $store.library.searchResults.releases.length === 0 && $store.library.searchResults.tracks.length === 0">
                                 <div class="empty-state">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
-                                    <p>No results found</p>
+                                    <p>{{ t.player_no_results }}</p>
                                 </div>
                             </template>
                             <!-- Artists section -->
                             <template x-if="$store.library.searchResults.artists.length > 0">
                                 <div class="search-section">
-                                    <h2 class="search-section-title">Artists</h2>
+                                    <h2 class="search-section-title">{{ t.player_artists }}</h2>
                                     <div class="search-artists-row">
                                         <template x-for="artist in $store.library.searchResults.artists" :key="artist.id">
                                             <div class="search-artist-card" @click="$store.library.openArtist(artist.id)">
@@ -363,7 +362,7 @@
                                                     <button class="artist-follow-card-btn"
                                                             :class="{ followed: $store.follows.has(artist.id) }"
                                                             @click.stop="$store.follows.toggle(artist.id)"
-                                                            :title="$store.follows.has(artist.id) ? 'Unfollow artist' : 'Follow artist'">
+                                                            :title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
                                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                                             <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
                                                             <circle cx="9" cy="7" r="4"/>
@@ -381,7 +380,7 @@
                             <!-- Releases section -->
                             <template x-if="$store.library.searchResults.releases.length > 0">
                                 <div class="search-section">
-                                    <h2 class="search-section-title">Releases</h2>
+                                    <h2 class="search-section-title">{{ t.player_releases }}</h2>
                                     <div class="search-releases-row">
                                         <template x-for="release in $store.library.searchResults.releases" :key="release.id">
                                             <div class="search-release-card" @click="$store.library.openRelease(release.id)" style="position:relative">
@@ -392,8 +391,8 @@
                                                     <template x-if="!release.cover_url">
                                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
                                                     </template>
-                                                    <button class="card-info-btn" @click.stop="$store.info.open('Release info', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="Release info">
-                                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                                    <button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                                     </button>
                                                 </div>
                                                 <div class="card-title" x-text="release.title"></div>
@@ -409,13 +408,13 @@
                             <!-- Tracks section -->
                             <template x-if="$store.library.searchResults.tracks.length > 0">
                                 <div class="search-section">
-                                    <h2 class="search-section-title">Tracks</h2>
+                                    <h2 class="search-section-title">{{ t.player_tracks }}</h2>
                                     <div class="track-list-header">
                                         <span>#</span>
-                                        <span>Title</span>
+                                        <span>{{ t.player_title }}</span>
                                         <span></span>
                                         <span></span>
-                                        <span style="text-align:right">Duration</span>
+                                        <span style="text-align:right">{{ t.player_duration }}</span>
                                     </div>
                                     <template x-for="(track, idx) in $store.library.searchResults.tracks" :key="track.id">
                                         <div class="track-row"
@@ -435,22 +434,22 @@
                                             </div>
                                             <span></span>
                                             <div class="track-actions">
-                                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('Track info', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="Track info">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                                <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>
-                                                <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="Play">
+                                                <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="{{ t.player_play }}">
                                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
                                                 </button>
-                                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="Like">
+                                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="Play next">
+                                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="Add to queue">
+                                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="Add to playlist">
+                                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                                 </button>
                                             </div>
@@ -467,7 +466,7 @@
             <!-- Artists Grid -->
             <template x-if="$store.library.view === 'artists'">
                 <div>
-                    <h1 class="section-title">Artists</h1>
+                    <h1 class="section-title">{{ t.player_artists }}</h1>
                     <div class="card-grid">
                         <template x-for="artist in $store.library.artists" :key="artist.id">
                             <div class="card" @click="$store.library.openArtist(artist.id)">
@@ -481,7 +480,7 @@
                                     <button class="artist-follow-card-btn"
                                             :class="{ followed: $store.follows.has(artist.id) }"
                                             @click.stop="$store.follows.toggle(artist.id)"
-                                            :title="$store.follows.has(artist.id) ? 'Unfollow artist' : 'Follow artist'">
+                                            :title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                             <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
                                             <circle cx="9" cy="7" r="4"/>
@@ -491,7 +490,7 @@
                                     </button>
                                 </div>
                                 <div class="card-title" x-text="artist.name"></div>
-                                <div class="card-subtitle" x-text="artist.release_count + ' releases · ' + artist.track_count + ' tracks'"></div>
+                                <div class="card-subtitle" x-text="artist.release_count + ' {{ t.player_releases_count }} · ' + artist.track_count + ' {{ t.player_tracks_count }}'"></div>
                             </div>
                         </template>
                     </div>
@@ -506,7 +505,7 @@
             <template x-if="$store.library.view === 'artist_detail' && $store.library.currentArtist">
                 <div>
                     <div class="breadcrumb">
-                        <a @click="$store.library.goArtists()">Artists</a>
+                        <a @click="$store.library.goArtists()">{{ t.player_artists }}</a>
                         <span>/</span>
                         <span x-text="$store.library.currentArtist.name"></span>
                     </div>
@@ -522,24 +521,24 @@
                         <div>
                             <div class="artist-name" x-text="$store.library.currentArtist.name"></div>
                             <div class="artist-stats">
-                                <span x-text="$store.library.currentArtist.releases.length + ' releases'"></span>
+                                <span x-text="$store.library.currentArtist.releases.length + ' {{ t.player_releases_count }}'"></span>
                                 <span>•</span>
-                                <span x-text="$store.library.currentArtist.total_track_count + ' tracks'"></span>
+                                <span x-text="$store.library.currentArtist.total_track_count + ' {{ t.player_tracks_count }}'"></span>
                                 <span>•</span>
-                                <span x-text="$store.library.currentArtist.total_play_count + ' plays'"></span>
+                                <span x-text="$store.library.currentArtist.total_play_count + ' {{ t.player_plays_count }}'"></span>
                             </div>
                             <div class="release-actions">
                                 <button class="release-action-btn secondary"
                                         :class="{ followed: $store.follows.has($store.library.currentArtist.id) }"
                                         @click="$store.follows.toggle($store.library.currentArtist.id)"
-                                        :title="$store.follows.has($store.library.currentArtist.id) ? 'Unfollow artist' : 'Follow artist'">
+                                        :title="$store.follows.has($store.library.currentArtist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                         <path d="M16 21v-2a4 4 0 00-4-4H6a4 4 0 00-4 4v2"/>
                                         <circle cx="9" cy="7" r="4"/>
                                         <path x-show="!$store.follows.has($store.library.currentArtist.id)" d="M19 8v6M16 11h6"/>
                                         <path x-show="$store.follows.has($store.library.currentArtist.id)" d="M16 11l2 2 4-5"/>
                                     </svg>
-                                    <span x-text="$store.follows.has($store.library.currentArtist.id) ? 'Following' : 'Follow'"></span>
+                                    <span x-text="$store.follows.has($store.library.currentArtist.id) ? '{{ t.player_followed }}' : '{{ t.player_follow }}'"></span>
                                 </button>
                             </div>
                         </div>
@@ -557,10 +556,10 @@
                                             <template x-if="!release.cover_url">
                                                 <span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg></span>
                                             </template>
-                                            <button class="card-info-btn" @click.stop="$store.info.open('Release info', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="Release info">
-                                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                            <button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                             </button>
-                                            <button class="card-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="Add to queue">
+                                            <button class="card-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="{{ t.player_add_to_queue }}">
                                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
                                             </button>
                                             <button class="card-play-btn" @click.stop="$store.library.playRelease(release.id)">
@@ -570,7 +569,7 @@
                                         <div class="card-title" x-text="release.title"></div>
                                         <div class="card-subtitle">
                                             <span x-text="release.year || ''"></span>
-                                            <span x-text="release.track_count + ' tracks'"></span>
+                                            <span x-text="release.track_count + ' {{ t.player_tracks_count }}'"></span>
                                         </div>
                                     </div>
                                 </template>
@@ -579,13 +578,13 @@
                     </template>
                     <template x-if="$store.library.currentArtist.featured_tracks && $store.library.currentArtist.featured_tracks.length > 0">
                         <section class="artist-release-group">
-                            <h2 class="artist-release-group-title">Appears on</h2>
+                            <h2 class="artist-release-group-title">{{ t.player_appears_on }}</h2>
                             <div class="track-list-header">
                                 <span>#</span>
-                                <span>Title</span>
+                                <span>{{ t.player_title }}</span>
                                 <span></span>
                                 <span></span>
-                                <span style="text-align:right">Duration</span>
+                                <span style="text-align:right">{{ t.player_duration }}</span>
                             </div>
                             <template x-for="(track, idx) in $store.library.currentArtist.featured_tracks" :key="track.id">
                                 <div class="track-row"
@@ -609,22 +608,22 @@
                                     </div>
                                     <span></span>
                                     <div class="track-actions">
-                                        <button class="track-action-btn info-btn" @click.stop="$store.info.open('Track info', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="Track info">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                        <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>
-                                        <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="Play">
+                                        <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="{{ t.player_play }}">
                                             <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
                                         </button>
-                                        <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="Like">
+                                        <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                             <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="Play next">
+                                        <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="Add to queue">
+                                        <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="Add to playlist">
+                                        <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                         </button>
                                     </div>
@@ -640,7 +639,7 @@
             <template x-if="$store.library.view === 'release_detail' && $store.library.currentRelease">
                 <div>
                     <div class="breadcrumb">
-                        <a @click="$store.library.goArtists()">Artists</a>
+                        <a @click="$store.library.goArtists()">{{ t.player_artists }}</a>
                         <span>/</span>
                         <template x-if="$store.library.currentRelease.artists.length > 0">
                             <a @click="$store.library.openArtist($store.library.currentRelease.artists[0].id)" x-text="$store.library.currentRelease.artists[0].name"></a>
@@ -659,7 +658,15 @@
                         </div>
                         <div class="release-meta">
                             <div class="release-type" x-text="$store.library.currentRelease.release_type"></div>
+                            <div class="release-title-row">
                                 <div class="release-title" x-text="$store.library.currentRelease.title"></div>
+                                <button class="like-btn like-btn-lg release-title-like"
+                                        :class="{ liked: $store.likes.isReleaseLiked($store.library.currentRelease) }"
+                                        @click.stop="$store.likes.toggleRelease($store.library.currentRelease.id)"
+                                        title="{{ t.player_like }}">
+                                    <svg viewBox="0 0 24 24" :fill="$store.likes.isReleaseLiked($store.library.currentRelease) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
+                                </button>
+                            </div>
                             <div class="release-artists">
                                 <template x-for="(artist, artistIdx) in $store.library.currentRelease.artists" :key="artist.id">
                                     <span>
@@ -671,29 +678,23 @@
                             <div class="release-year" x-text="$store.library.currentRelease.year || ''"></div>
                             <div class="release-actions">
                                 <button class="release-action-btn secondary"
-                                        @click.stop="$store.info.open('Release info', $store.library.releaseInfo($store.library.currentRelease))"
+                                        @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo($store.library.currentRelease))"
                                         :title="$store.library.releaseInfo($store.library.currentRelease)"
-                                        aria-label="Release info">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
-                                    Info
+                                        aria-label="{{ t.player_release_info }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
+                                    {{ t.player_info }}
                                 </button>
                                 <button class="release-action-btn primary" @click="$store.queue.playRelease($store.library.currentRelease.tracks, 0)">
                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                    Play
+                                    {{ t.player_play }}
                                 </button>
-                                <button class="like-btn like-btn-lg" style="margin-left:4px"
-                                        :class="{ liked: $store.likes.isReleaseLiked($store.library.currentRelease) }"
-                                        @click.stop="$store.likes.toggleRelease($store.library.currentRelease.id)"
-                                        title="Like">
-                                    <svg viewBox="0 0 24 24" :fill="$store.likes.isReleaseLiked($store.library.currentRelease) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
-                                </button>
-                                <button class="release-action-btn secondary" @click="$store.queue.addToEnd($store.library.currentRelease.tracks)" title="Add to end of queue">
+                                <button class="release-action-btn secondary" @click="$store.queue.addToEnd($store.library.currentRelease.tracks)" title="{{ t.player_add_to_end_queue }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
-                                    Queue
+                                    {{ t.player_queue }}
                                 </button>
-                                <button class="release-action-btn secondary" @click="$store.queue.addNextInQueue($store.library.currentRelease.tracks)" title="Play next">
+                                <button class="release-action-btn secondary" @click="$store.queue.addNextInQueue($store.library.currentRelease.tracks)" title="{{ t.player_play_next }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
-                                    Next
+                                    {{ t.player_next }}
                                 </button>
                             </div>
                         </div>
@@ -701,10 +702,10 @@
                     <!-- Track list -->
                     <div class="track-list-header">
                         <span>#</span>
-                        <span>Title</span>
+                        <span>{{ t.player_title }}</span>
                         <span></span>
                         <span></span>
-                        <span style="text-align:right">Duration</span>
+                        <span style="text-align:right">{{ t.player_duration }}</span>
                     </div>
                     <template x-for="(track, idx) in $store.library.currentRelease.tracks" :key="track.id">
                         <div class="track-row"
@@ -724,22 +725,22 @@
                             </div>
                             <span></span>
                             <div class="track-actions">
-                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('Track info', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="Track info">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                <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>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="Play">
+                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="{{ t.player_play }}">
                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
                                 </button>
-                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="Like">
+                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="Play next">
+                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="Add to queue">
+                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="Add to playlist">
+                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -753,28 +754,28 @@
             <template x-if="$store.library.view === 'playlist_detail' && $store.library.currentPlaylist">
                 <div>
                     <div class="breadcrumb">
-                        <a @click="$store.library.goArtists()">Library</a>
+                        <a @click="$store.library.goArtists()">{{ t.player_library }}</a>
                         <span>/</span>
-                        <span x-text="$store.library.currentPlaylist.title"></span>
+                        <span x-text="$store.playlists.displayTitle($store.library.currentPlaylist)"></span>
                     </div>
-                    <h1 class="section-title" x-text="$store.library.currentPlaylist.title"></h1>
+                    <h1 class="section-title" x-text="$store.playlists.displayTitle($store.library.currentPlaylist)"></h1>
                     <div class="playlist-detail-meta"
                          x-show="$store.library.currentPlaylist.owner_name || $store.library.currentPlaylist.is_public">
                         <span x-show="$store.library.currentPlaylist.owner_name"
-                              x-text="'by ' + $store.library.currentPlaylist.owner_name"></span>
+                              x-text="'{{ t.player_by }} ' + $store.library.currentPlaylist.owner_name"></span>
                         <span x-show="$store.library.currentPlaylist.owner_name && $store.library.currentPlaylist.is_public">&middot;</span>
                         <span class="playlist-public-badge"
-                              x-show="$store.library.currentPlaylist.is_public">Published</span>
+                              x-show="$store.library.currentPlaylist.is_public">{{ t.player_published }}</span>
                     </div>
                     <template x-if="$store.library.currentPlaylist.description">
                         <p style="color:var(--text-subdued);margin-bottom:16px" x-text="$store.library.currentPlaylist.description"></p>
                     </template>
                     <div class="track-list-header">
                         <span>#</span>
-                        <span>Title</span>
+                        <span>{{ t.player_title }}</span>
                         <span></span>
                         <span></span>
-                        <span style="text-align:right">Duration</span>
+                        <span style="text-align:right">{{ t.player_duration }}</span>
                     </div>
                     <template x-for="(track, idx) in $store.library.currentPlaylist.tracks" :key="track.id">
                         <div class="track-row"
@@ -794,22 +795,22 @@
                             </div>
                             <span></span>
                             <div class="track-actions">
-                                <button class="track-action-btn info-btn" @click.stop="$store.info.open('Track info', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="Track info">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                                <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>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="Play">
+                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="{{ t.player_play }}">
                                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
                                 </button>
-                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="Like">
+                                <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="Play next">
+                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="Add to queue">
+                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="Add to playlist">
+                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -827,14 +828,14 @@
              @click="$store.queue.visible = false"></div>
         <div class="queue-panel" :class="{ hidden: !$store.queue.visible }">
             <div class="queue-header">
-                <h3>Queue</h3>
-                <button class="queue-clear-btn" @click="$store.queue.clear()">Clear</button>
+                <h3>{{ t.player_queue }}</h3>
+                <button class="queue-clear-btn" @click="$store.queue.clear()">{{ t.player_clear }}</button>
             </div>
             <div class="queue-tracks">
                 <template x-if="$store.queue.tracks.length === 0">
                     <div class="empty-state">
                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
-                        <p>Queue is empty</p>
+                        <p>{{ t.player_queue_empty }}</p>
                     </div>
                 </template>
                 <template x-for="(track, idx) in $store.queue.tracks" :key="idx + '-' + track.id">
@@ -870,10 +871,10 @@
                             </div>
                         </div>
                         <div class="queue-track-actions">
-                            <button class="queue-track-remove info-btn" @click.stop="$store.info.open('Track info', $store.library.trackInfo(track))" :title="$store.library.trackInfo(track)" aria-label="Track info">
-                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/></svg>
+                            <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>
-                            <button class="queue-track-remove" @click.stop="$store.queue.remove(idx)" title="Remove">
+                            <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>
                             </button>
                         </div>
@@ -916,10 +917,10 @@
 
         <div class="player-controls">
             <div class="player-buttons">
-                <button class="player-btn" :class="{ active: $store.player.shuffle }" @click="$store.player.toggleShuffle()" title="Shuffle">
+                <button class="player-btn" :class="{ active: $store.player.shuffle }" @click="$store.player.toggleShuffle()" title="{{ t.player_shuffle }}">
                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 3 21 3 21 8"/><line x1="4" y1="20" x2="21" y2="3"/><polyline points="21 16 21 21 16 21"/><line x1="15" y1="15" x2="21" y2="21"/><line x1="4" y1="4" x2="9" y2="9"/></svg>
                 </button>
-                <button class="player-btn" @click="$store.player.prev()" title="Previous">
+                <button class="player-btn" @click="$store.player.prev()" title="{{ t.player_previous }}">
                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M6 6h2v12H6zm3.5 6l8.5 6V6z"/></svg>
                 </button>
                 <button class="player-btn player-btn-play" @click="$store.player.toggle()">
@@ -930,10 +931,10 @@
                         <svg viewBox="0 0 24 24" fill="currentColor"><path d="M6 4h4v16H6zM14 4h4v16h-4z"/></svg>
                     </template>
                 </button>
-                <button class="player-btn" @click="$store.player.next()" title="Next">
+                <button class="player-btn" @click="$store.player.next()" title="{{ t.player_next }}">
                     <svg viewBox="0 0 24 24" fill="currentColor"><path d="M6 18l8.5-6L6 6v12zM16 6v12h2V6h-2z"/></svg>
                 </button>
-                <button class="player-btn" :class="{ active: $store.player.repeatMode !== 'off' }" @click="$store.player.cycleRepeat()" title="Repeat">
+                <button class="player-btn" :class="{ active: $store.player.repeatMode !== 'off' }" @click="$store.player.cycleRepeat()" title="{{ t.player_repeat }}">
                     <template x-if="$store.player.repeatMode !== 'one'">
                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="17 1 21 5 17 9"/><path d="M3 11V9a4 4 0 014-4h14"/><polyline points="7 23 3 19 7 15"/><path d="M21 13v2a4 4 0 01-4 4H3"/></svg>
                     </template>
@@ -951,6 +952,7 @@
                 </div>
                 <span class="player-time" x-text="formatTime($store.player.duration)"></span>
             </div>
+            <div class="player-version-chip">v{{ t.app_version() }}</div>
         </div>
 
         <div class="player-right">
@@ -968,13 +970,13 @@
                 </button>
                 <div class="volume-slider"
                      @pointerdown.prevent="$store.player.startVolumeDrag($event)"
-                     aria-label="Volume">
+                     aria-label="{{ t.player_volume }}">
                     <div class="volume-slider-fill" :style="'width:' + ($store.player.volume * 100) + '%'">
                         <div class="volume-slider-thumb"></div>
                     </div>
                 </div>
             </div>
-            <button class="queue-toggle-btn" :class="{ active: $store.queue.visible }" @click="$store.queue.visible = !$store.queue.visible" title="Queue">
+            <button class="queue-toggle-btn" :class="{ active: $store.queue.visible }" @click="$store.queue.visible = !$store.queue.visible" title="{{ t.player_queue }}">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>
             </button>
         </div>

templates/player/styles.html

@@ -571,6 +571,21 @@ button.user-stat:hover {
 
 .release-meta .release-type { font-size: 12px; text-transform: uppercase; letter-spacing: 0.5px; color: var(--text-secondary); }
 .release-meta .release-title { font-size: 36px; font-weight: 900; line-height: 1.2; margin: 4px 0; }
+.release-title-row {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    min-width: 0;
+}
+
+.release-title-row .release-title {
+    min-width: 0;
+}
+
+.release-title-like {
+    flex: 0 0 auto;
+    margin-top: 4px;
+}
 .release-meta .release-artists { font-size: 14px; color: var(--text-secondary); }
 
 .artist-link {
@@ -1232,6 +1247,20 @@ button.user-stat:hover {
     white-space: nowrap;
 }
 
+.player-version-chip {
+    width: 100%;
+    max-width: 600px;
+    margin-top: -2px;
+    padding-left: 0;
+    color: var(--text-subdued);
+    opacity: 0.55;
+    font-size: 9px;
+    line-height: 1;
+    font-weight: 500;
+    text-align: center;
+    pointer-events: none;
+}
+
 .mobile-account-chip {
     display: none;
     align-items: center;
@@ -1707,7 +1736,16 @@ button.user-stat:hover {
 
 .modal-btn:hover { filter: brightness(1.1); }
 .modal-btn-primary { background: var(--accent); color: #000; }
+.modal-btn-pause {
+    background: #f0b84d;
+    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;
@@ -1716,9 +1754,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;
 }
 
@@ -1728,6 +1767,8 @@ button.user-stat:hover {
     justify-content: space-between;
     gap: 14px;
     margin-bottom: 12px;
+    flex: 0 0 auto;
+    position: relative;
 }
 
 .torrent-modal-head h3 {
@@ -1759,16 +1800,53 @@ 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;
 }
 
+.torrent-agent-pill.active {
+    border-color: rgba(240,184,77,0.45);
+    color: #ffd78a;
+}
+
+.torrent-agent-dot {
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+    background: var(--text-subdued);
+}
+
+.torrent-agent-pill.active .torrent-agent-dot {
+    background: #f0b84d;
+    box-shadow: 0 0 0 3px rgba(240,184,77,0.14);
+}
+
 .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,
@@ -1801,23 +1879,67 @@ 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);
     cursor: pointer;
 }
 
+.torrent-session-add {
+    width: 100%;
+    grid-template-columns: auto minmax(0, 1fr);
+    align-items: center;
+    border: 0;
+    border-bottom: 1px solid var(--border-color);
+    background: transparent;
+    color: var(--text-secondary);
+    text-align: left;
+    font: inherit;
+    font-size: 13px;
+    font-weight: 800;
+}
+
+.torrent-session-add:disabled {
+    cursor: default;
+    opacity: 0.6;
+}
+
+.torrent-session-add-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 22px;
+    height: 22px;
+    border-radius: 999px;
+    border: 1px solid rgba(29,185,84,0.38);
+    color: #9ff0b9;
+    font-size: 16px;
+    line-height: 1;
+}
+
 .torrent-session-row:last-child { border-bottom: 0; }
 .torrent-session-row:hover,
 .torrent-session-row.active { background: var(--bg-hover); }
 
+.torrent-session-main {
+    min-width: 0;
+}
+
+.torrent-session-topline {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto;
+    gap: 8px;
+    align-items: center;
+}
+
 .torrent-session-name {
     min-width: 0;
     color: var(--text-primary);
@@ -1828,6 +1950,54 @@ button.user-stat:hover {
     white-space: nowrap;
 }
 
+.torrent-status-badge {
+    display: inline-flex;
+    align-items: center;
+    min-height: 20px;
+    padding: 2px 7px;
+    border-radius: 999px;
+    font-size: 10px;
+    font-weight: 900;
+    line-height: 1;
+    text-transform: uppercase;
+    white-space: nowrap;
+}
+
+.torrent-status-badge.status-preview {
+    background: rgba(122,162,255,0.16);
+    color: #adc3ff;
+}
+
+.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(110,211,123,0.16);
+    color: #b8f7be;
+}
+
+.torrent-status-badge.status-paused {
+    background: rgba(240,184,77,0.18);
+    color: #ffd78a;
+}
+
+.torrent-status-badge.status-failed {
+    background: rgba(229,96,96,0.18);
+    color: #ffb9b9;
+}
+
 .torrent-session-meta {
     margin-top: 4px;
     color: var(--text-subdued);
@@ -1837,21 +2007,20 @@ button.user-stat:hover {
     white-space: nowrap;
 }
 
-.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-progress {
+    height: 5px;
+    margin-top: 7px;
+    overflow: hidden;
+    border-radius: 999px;
+    background: var(--bg-secondary);
 }
 
-.torrent-session-remove:hover {
-    background: rgba(229,96,96,0.2);
-    color: #ffd7d7;
+.torrent-session-progress-bar {
+    height: 100%;
+    width: 0%;
+    border-radius: inherit;
+    background: linear-gradient(90deg, var(--accent), #7ee4a2);
+    transition: width 0.25s ease;
 }
 
 .torrent-progress-card {
@@ -1889,12 +2058,44 @@ button.user-stat:hover {
 }
 
 .torrent-progress-details {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px 12px;
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 8px;
     margin-top: 8px;
     color: var(--text-subdued);
+    min-height: 38px;
+}
+
+.torrent-progress-details.completed {
+    grid-template-columns: minmax(0, 1fr);
+}
+
+.torrent-progress-metric {
+    min-width: 0;
+    min-height: 38px;
+    padding: 5px 7px;
+    border-radius: 6px;
+    background: var(--bg-secondary);
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 2px;
+}
+
+.torrent-progress-label {
+    color: var(--text-muted);
+    font-size: 10px;
+    line-height: 12px;
+    text-transform: uppercase;
+    font-weight: 800;
+}
+
+.torrent-progress-value {
+    color: var(--text-secondary);
     font-size: 12px;
+    line-height: 14px;
+    font-weight: 700;
+    overflow-wrap: anywhere;
 }
 
 .history-modal {
@@ -1958,6 +2159,26 @@ button.user-stat:hover {
     max-width: 360px;
 }
 
+.torrent-import-panel,
+.torrent-workspace-empty {
+    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;
@@ -2002,6 +2223,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;
@@ -2058,7 +2286,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);
@@ -2256,12 +2484,8 @@ button.user-stat:hover {
         display: block;
     }
 
-    .version-chip {
-        display: none;
-    }
-
     .torrent-modal {
-        width: calc(100vw - 24px);
+        width: min(1180px, calc(100vw - 32px));
     }
 
     .card-grid {
@@ -2397,6 +2621,13 @@ button.user-stat:hover {
         gap: 6px;
     }
 
+    .player-version-chip {
+        max-width: none;
+        padding-left: 0;
+        opacity: 0.62;
+        font-size: 9px;
+    }
+
     .player-time {
         min-width: 34px;
         font-size: 10px;
@@ -2598,34 +2829,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 {
@@ -2634,6 +2880,14 @@ button.user-stat:hover {
         gap: 4px;
     }
 
+    .torrent-progress-details {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
+    .torrent-progress-details.completed {
+        grid-template-columns: minmax(0, 1fr);
+    }
+
     .torrent-modal h3 {
         margin-bottom: 12px;
     }
@@ -2671,8 +2925,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 {
@@ -2703,6 +2957,12 @@ button.user-stat:hover {
     .player-track-artist { font-size: 10px; }
     .player-buttons { gap: 10px; }
 
+    .player-version-chip {
+        padding-left: 0;
+        font-size: 8px;
+        opacity: 0.58;
+    }
+
     .volume-control {
         gap: 4px;
     }