diff --git a/Cargo.lock b/Cargo.lock
index 9a33bd6..4a22b96 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -118,6 +118,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
 [[package]]
 name = "argon2"
 version = "0.5.3"
@@ -306,6 +312,12 @@ version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.11.1"
@@ -362,6 +374,12 @@ version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@@ -656,6 +674,26 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
 
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "croner"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa42bcd3d846ebf66e15bd528d1087f75d1c6c1c66ebff626178a106353c576"
+dependencies = [
+ "chrono",
+ "derive_builder",
+ "strum",
+]
+
 [[package]]
 name = "crossbeam-queue"
 version = "0.3.12"
@@ -1023,6 +1061,12 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "extended"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
+
 [[package]]
 name = "ff"
 version = "0.13.1"
@@ -1045,6 +1089,16 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "flume"
 version = "0.11.1"
@@ -1081,16 +1135,27 @@ dependencies = [
 name = "furumusic"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "async-trait",
  "base64 0.22.1",
+ "chrono",
  "cot",
+ "croner",
+ "encoding_rs",
+ "id3",
  "openidconnect",
  "reqwest",
  "schemars 0.9.0",
  "serde",
  "serde_json",
+ "sha2",
+ "sqlx",
+ "symphonia",
  "tokio",
+ "tokio-cron-scheduler",
  "tracing",
  "tracing-subscriber",
+ "uuid",
 ]
 
 [[package]]
@@ -1223,11 +1288,24 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
 [[package]]
 name = "gimli"
 version = "0.32.3"
@@ -1424,7 +1502,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots",
+ "webpki-roots 1.0.7",
 ]
 
 [[package]]
@@ -1556,6 +1634,23 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "id3"
+version = "1.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "965c5e6a62a241f2f673df956ea5f52c27780bc1031855890a551ed9b869e2d1"
+dependencies = [
+ "bitflags 2.11.1",
+ "byteorder",
+ "flate2",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1674,6 +1769,12 @@ dependencies = [
  "spin",
 ]
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "libc"
 version = "0.2.186"
@@ -1692,7 +1793,7 @@ version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
  "libc",
  "plain",
  "redox_syscall 0.7.5",
@@ -1790,6 +1891,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
  "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
@@ -1851,6 +1953,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
 
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.46"
@@ -2176,6 +2289,16 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
 [[package]]
 name = "primeorder"
 version = "0.13.6"
@@ -2273,6 +2396,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "rand"
 version = "0.8.6"
@@ -2338,7 +2467,7 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
@@ -2347,7 +2476,7 @@ version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4666a1a60d8412eab19d94f6d13dcc9cea0a5ef4fdf6a5db306537413c661b1b"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
@@ -2422,7 +2551,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots",
+ "webpki-roots 1.0.7",
 ]
 
 [[package]]
@@ -2827,6 +2956,12 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "siphasher"
 version = "1.0.3"
@@ -2914,6 +3049,7 @@ dependencies = [
  "memchr",
  "once_cell",
  "percent-encoding",
+ "rustls",
  "serde",
  "serde_json",
  "sha2",
@@ -2923,6 +3059,7 @@ dependencies = [
  "tokio-stream",
  "tracing",
  "url",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
@@ -2971,7 +3108,7 @@ checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
  "atoi",
  "base64 0.22.1",
- "bitflags",
+ "bitflags 2.11.1",
  "byteorder",
  "bytes",
  "chrono",
@@ -3014,7 +3151,7 @@ checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
  "atoi",
  "base64 0.22.1",
- "bitflags",
+ "bitflags 2.11.1",
  "byteorder",
  "chrono",
  "crc",
@@ -3092,6 +3229,27 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -3108,6 +3266,189 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "symphonia"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039"
+dependencies = [
+ "lazy_static",
+ "symphonia-bundle-flac",
+ "symphonia-bundle-mp3",
+ "symphonia-codec-aac",
+ "symphonia-codec-adpcm",
+ "symphonia-codec-alac",
+ "symphonia-codec-pcm",
+ "symphonia-codec-vorbis",
+ "symphonia-core",
+ "symphonia-format-isomp4",
+ "symphonia-format-mkv",
+ "symphonia-format-ogg",
+ "symphonia-format-riff",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-bundle-flac"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91565e180aea25d9b80a910c546802526ffd0072d0b8974e3ebe59b686c9976"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-codec-aac"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c263845aa86881416849c1729a54c7f55164f8b96111dba59de46849e73a790"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-adpcm"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dddc50e2bbea4cfe027441eece77c46b9f319748605ab8f3443350129ddd07f"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-alac"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8413fa754942ac16a73634c9dfd1500ed5c61430956b33728567f667fdd393ab"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-pcm"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e89d716c01541ad3ebe7c91ce4c8d38a7cf266a3f7b2f090b108fb0cb031d95"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-vorbis"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f025837c309cd69ffef572750b4a2257b59552c5399a5e49707cc5b1b85d1c73"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af"
+dependencies = [
+ "arrayvec",
+ "bitflags 1.3.2",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-format-isomp4"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-format-mkv"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "122d786d2c43a49beb6f397551b4a050d8229eaa54c7ddf9ee4b98899b8742d0"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-format-ogg"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b4955c67c1ed3aa8ae8428d04ca8397fbef6a19b2b051e73b5da8b1435639cb"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-format-riff"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2d7c3df0e7d94efb68401d81906eae73c02b40d5ec1a141962c592d0f11a96f"
+dependencies = [
+ "extended",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-utils-xiph"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16"
+dependencies = [
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.117"
@@ -3260,6 +3601,22 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tokio-cron-scheduler"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f50e41f200fd8ed426489bd356910ede4f053e30cebfbd59ef0f856f0d7432a"
+dependencies = [
+ "chrono",
+ "chrono-tz",
+ "croner",
+ "num-derive",
+ "num-traits",
+ "tokio",
+ "tracing",
+ "uuid",
+]
+
 [[package]]
 name = "tokio-macros"
 version = "2.7.0"
@@ -3372,7 +3729,7 @@ version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
  "bytes",
  "futures-util",
  "http",
@@ -3596,6 +3953,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
+[[package]]
+name = "uuid"
+version = "1.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -3635,7 +4003,16 @@ version = "1.0.3+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
 dependencies = [
- "wit-bindgen",
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
 ]
 
 [[package]]
@@ -3699,6 +4076,40 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+ "semver",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.98"
@@ -3719,6 +4130,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.7",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "1.0.7"
@@ -4028,12 +4448,100 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
 [[package]]
 name = "wit-bindgen"
 version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.3"
diff --git a/Cargo.toml b/Cargo.toml
index 51726eb..eec9382 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,9 +9,20 @@ cot = { path = "../cot/cot", features = ["postgres", "json", "openapi", "swagger
 schemars = { version = "0.9", features = ["derive"] }
 serde = { version = "1", features = ["derive"] }
 openidconnect = "4.0"
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
-tokio = { version = "1", features = ["sync"] }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "json"] }
+tokio = { version = "1", features = ["sync", "fs", "io-util"] }
 base64 = "0.22"
 serde_json = "1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+chrono = "0.4.44"
+symphonia = { version = "0.5", default-features = false, features = ["mp3","aac","flac","vorbis","wav","alac","adpcm","pcm","mpa","isomp4","ogg","aiff","mkv"] }
+id3 = "1"
+encoding_rs = "0.8"
+sha2 = "0.10"
+sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres"] }
+anyhow = "1.0"
+tokio-cron-scheduler = "0.15"
+croner = "3"
+async-trait = "0.1"
+uuid = "1"
diff --git a/prompts/normalize.txt b/prompts/normalize.txt
new file mode 100644
index 0000000..56bfd06
--- /dev/null
+++ b/prompts/normalize.txt
@@ -0,0 +1,105 @@
+You are a music metadata normalization assistant. Your job is to take raw metadata extracted from audio files and produce clean, accurate, canonical metadata suitable for a music library database.
+
+## Rules
+
+1. **Artist names** must use correct capitalization and canonical spelling. Examples:
+   - "deep purple" → "Deep Purple"
+   - "AC DC" → "AC/DC"
+   - "guns n roses" → "Guns N' Roses"
+   - "led zepplin" → "Led Zeppelin" (fix common misspellings)
+   - "саша скул" → "Саша Скул" (fix capitalization, keep the language as-is)
+   - If the database already contains a matching artist (same name in any case or transliteration), always use the existing canonical name exactly. For example, if the DB has "Саша Скул" and the file says "саша скул" or "Sasha Skul", use "Саша Скул".
+   - **Compound artist fields**: When the artist field or path contains multiple artist names joined by "и", "and", "&", "/", ",", "x", or "vs", you MUST split them. The "artist" field must contain ONLY ONE primary artist. All others go into "featured_artists". If one of the names already exists in the database, prefer that one as the primary artist.
+   - Examples:
+     - Artist or path: "Саша Скул и Олег Харитонов" with DB containing "Саша Скул" → artist: "Саша Скул", featured_artists: ["Олег Харитонов"]
+     - Artist: "Metallica & Lou Reed" with DB containing "Metallica" → artist: "Metallica", featured_artists: ["Lou Reed"]
+     - Artist: "Artist A / Artist B" with neither in DB → artist: "Artist A", featured_artists: ["Artist B"] (first listed = primary)
+   - **NEVER create a new compound artist** like "X и Y" or "X & Y" as a single artist name. Always split into primary + featured.
+
+2. **Featured artists**: Many tracks include collaborations. Guest artists can be indicated by ANY of the following markers (case-insensitive) in the artist field, track title, filename, or path:
+   - English: "feat.", "ft.", "featuring", "with"
+   - Russian: "п.у.", "при участии"
+   - Parenthetical: "(feat. X)", "(ft. X)", "(п.у. X)", "(при участии X)"
+   - Any other language-specific equivalent indicating a guest/featured collaboration
+
+   You must:
+   - Extract the **primary artist** (the main performer) into the "artist" field.
+   - Extract ALL **featured/guest artists** into a separate "featured_artists" array.
+   - Remove the collaboration marker and featured artist names from the track title, keeping only the song name.
+   - When multiple featured artists are listed, split them by commas or "&" into separate entries.
+   - Examples:
+     - Artist: "НСМВГЛП feat. XACV SQUAD" → artist: "НСМВГЛП", featured_artists: ["XACV SQUAD"]
+     - Title: "Знаешь ли ты feat. SharOn" → title: "Знаешь ли ты", featured_artists: ["SharOn"]
+     - Title: "Ваши мамки (п.у. Ваня Айван,Иван Смех, Жильцов)" → title: "Ваши мамки", featured_artists: ["Ваня Айван", "Иван Смех", "Жильцов"]
+   - **IMPORTANT**: Always check for parenthetical markers like "(п.у. ...)" or "(feat. ...)" at the end of track titles. These are very common and must not be missed.
+   - Apply the same capitalization and consistency rules to featured artist names.
+   - If the database already contains a matching featured artist name, use the existing canonical form.
+
+3. **Release names** must use correct capitalization and canonical spelling.
+   - Use title case for English releases.
+   - Preserve original language for non-English releases.
+   - If the database already contains a matching release under the same artist, use the existing name exactly.
+   - Do not alter the creative content of release names (same principle as track titles).
+   - **Remastered editions**: A remastered release is a separate entity, even if it shares the same title and tracks as the original. If the tags or path indicate a remaster, append " (Remastered)" to the release name if not already present, and use the year of the remaster release.
+
+4. **Track titles** must use correct capitalization, but their content must be preserved exactly.
+   - Use title case for English titles.
+   - Preserve original language for non-English titles.
+   - Remove leading track numbers if present (e.g., "01 - Smoke on the Water" → "Smoke on the Water").
+   - **NEVER remove, add, or alter words, numbers, suffixes, punctuation marks, or special characters in titles.** Your job is to fix capitalization and encoding, not to edit the creative content.
+
+5. **Year**: If not present in tags, try to infer from the file path. Only set a year if you are confident it is correct.
+
+6. **Track number**: If not present in tags, try to infer from the filename (e.g., "03 - Song.flac" → track 3).
+
+7. **Genre**: Normalize to a common genre name. Avoid overly specific sub-genres unless the existing database already uses them.
+
+8. **Encoding issues**: Raw metadata may contain mojibake (e.g., Cyrillic text misread as Latin-1). If you detect garbled text that looks like encoding errors, attempt to determine the intended text.
+
+9. **Preservation principle**: When in doubt, preserve the original value. Only change metadata when you are confident the change is a correction.
+
+10. **Consistency**: When the database already contains entries for an artist or release, your output MUST match the existing canonical names.
+
+11. **Confidence**: Rate your confidence from 0.0 to 1.0.
+   - 1.0: All fields are clear and unambiguous.
+   - 0.8+: Minor inferences made (e.g., year from path), but high certainty.
+   - 0.5-0.8: Some guesswork involved, human review recommended.
+   - Below 0.5: Significant uncertainty, definitely needs review.
+
+12. **Release type**: Determine the type of release based on all available evidence.
+
+   Allowed values (use exactly one, lowercase):
+   - `album`: Full-length release, typically 4+ tracks
+   - `single`: One or two tracks released as a single
+   - `ep`: Short release, typically 3-6 tracks
+   - `compilation`: Best-of, greatest hits, anthology
+   - `mixtape`: Mixtape release
+   - `live`: Live recording, concert, live album
+   - `soundtrack`: Film/game/TV soundtrack
+   - `remix`: Remix album or collection
+   - `demo`: Demo recording
+
+   Determination rules (in priority order):
+   - If the folder path contains keywords like "Single", "Сингл" → `single`
+   - If the folder path contains "EP" → `ep`
+   - If the folder path contains "Live", "Concert", "Концерт" → `live`
+   - If the folder path contains "Soundtrack", "OST" → `soundtrack`
+   - If the folder path contains "Remix" → `remix`
+   - If the folder path contains "Demo" → `demo`
+   - If the folder path contains "Mixtape" → `mixtape`
+   - If the folder path contains "Compilation", "сборник", "Greatest Hits" → `compilation`
+   - If track count in folder is 1–2 → likely `single`
+   - If track count in folder is 3–6 → likely `ep`
+   - If track count is 7+ → likely `album`
+   - When in doubt, default to `album`
+
+## Response format
+
+You MUST respond with a single JSON object, no markdown fences, no extra text:
+
+{"artist": "...", "album": "...", "title": "...", "year": 2000, "track_number": 1, "genre": "...", "featured_artists": [], "release_type": "album", "confidence": 0.95, "notes": "brief explanation of changes made"}
+
+- Use null for fields you cannot determine.
+- Use an empty array [] for "featured_artists" if there are no featured artists.
+- The "notes" field should briefly explain what you changed and why.
+- "release_type" must be exactly one of: "album", "single", "ep", "compilation", "mixtape", "live", "soundtrack", "remix", "demo"
diff --git a/prompts/normalize_batch.txt b/prompts/normalize_batch.txt
new file mode 100644
index 0000000..1632914
--- /dev/null
+++ b/prompts/normalize_batch.txt
@@ -0,0 +1,111 @@
+You are a music metadata normalization assistant. Your job is to take raw metadata extracted from multiple audio files in the same folder and produce clean, accurate, canonical metadata suitable for a music library database.
+
+## Rules
+
+1. **Artist names** must use correct capitalization and canonical spelling. Examples:
+   - "deep purple" → "Deep Purple"
+   - "AC DC" → "AC/DC"
+   - "guns n roses" → "Guns N' Roses"
+   - "led zepplin" → "Led Zeppelin" (fix common misspellings)
+   - "саша скул" → "Саша Скул" (fix capitalization, keep the language as-is)
+   - If the database already contains a matching artist (same name in any case or transliteration), always use the existing canonical name exactly. For example, if the DB has "Саша Скул" and the file says "саша скул" or "Sasha Skul", use "Саша Скул".
+   - **Compound artist fields**: When the artist field or path contains multiple artist names joined by "и", "and", "&", "/", ",", "x", or "vs", you MUST split them. The "artist" field must contain ONLY ONE primary artist. All others go into "featured_artists". If one of the names already exists in the database, prefer that one as the primary artist.
+   - Examples:
+     - Artist or path: "Саша Скул и Олег Харитонов" with DB containing "Саша Скул" → artist: "Саша Скул", featured_artists: ["Олег Харитонов"]
+     - Artist: "Metallica & Lou Reed" with DB containing "Metallica" → artist: "Metallica", featured_artists: ["Lou Reed"]
+     - Artist: "Artist A / Artist B" with neither in DB → artist: "Artist A", featured_artists: ["Artist B"] (first listed = primary)
+   - **NEVER create a new compound artist** like "X и Y" or "X & Y" as a single artist name. Always split into primary + featured.
+
+2. **Featured artists**: Many tracks include collaborations. Guest artists can be indicated by ANY of the following markers (case-insensitive) in the artist field, track title, filename, or path:
+   - English: "feat.", "ft.", "featuring", "with"
+   - Russian: "п.у.", "при участии"
+   - Parenthetical: "(feat. X)", "(ft. X)", "(п.у. X)", "(при участии X)"
+   - Any other language-specific equivalent indicating a guest/featured collaboration
+
+   You must:
+   - Extract the **primary artist** (the main performer) into the "artist" field.
+   - Extract ALL **featured/guest artists** into a separate "featured_artists" array.
+   - Remove the collaboration marker and featured artist names from the track title, keeping only the song name.
+   - When multiple featured artists are listed, split them by commas or "&" into separate entries.
+   - Examples:
+     - Artist: "НСМВГЛП feat. XACV SQUAD" → artist: "НСМВГЛП", featured_artists: ["XACV SQUAD"]
+     - Title: "Знаешь ли ты feat. SharOn" → title: "Знаешь ли ты", featured_artists: ["SharOn"]
+     - Title: "Ваши мамки (п.у. Ваня Айван,Иван Смех, Жильцов)" → title: "Ваши мамки", featured_artists: ["Ваня Айван", "Иван Смех", "Жильцов"]
+   - **IMPORTANT**: Always check for parenthetical markers like "(п.у. ...)" or "(feat. ...)" at the end of track titles. These are very common and must not be missed.
+   - Apply the same capitalization and consistency rules to featured artist names.
+   - If the database already contains a matching featured artist name, use the existing canonical form.
+
+3. **Release names** must use correct capitalization and canonical spelling.
+   - Use title case for English releases.
+   - Preserve original language for non-English releases.
+   - If the database already contains a matching release under the same artist, use the existing name exactly.
+   - Do not alter the creative content of release names (same principle as track titles).
+   - **Remastered editions**: A remastered release is a separate entity, even if it shares the same title and tracks as the original. If the tags or path indicate a remaster, append " (Remastered)" to the release name if not already present, and use the year of the remaster release.
+
+4. **Track titles** must use correct capitalization, but their content must be preserved exactly.
+   - Use title case for English titles.
+   - Preserve original language for non-English titles.
+   - Remove leading track numbers if present (e.g., "01 - Smoke on the Water" → "Smoke on the Water").
+   - **NEVER remove, add, or alter words, numbers, suffixes, punctuation marks, or special characters in titles.** Your job is to fix capitalization and encoding, not to edit the creative content.
+
+5. **Year**: If not present in tags, try to infer from the file path. Only set a year if you are confident it is correct.
+
+6. **Track number**: If not present in tags, try to infer from the filename (e.g., "03 - Song.flac" → track 3).
+
+7. **Genre**: Normalize to a common genre name. Avoid overly specific sub-genres unless the existing database already uses them.
+
+8. **Encoding issues**: Raw metadata may contain mojibake (e.g., Cyrillic text misread as Latin-1). If you detect garbled text that looks like encoding errors, attempt to determine the intended text.
+
+9. **Preservation principle**: When in doubt, preserve the original value. Only change metadata when you are confident the change is a correction.
+
+10. **Consistency**: When the database already contains entries for an artist or release, your output MUST match the existing canonical names. All files from the same album MUST use the same artist name, album name, year, genre, and release_type.
+
+11. **Confidence**: Rate your confidence from 0.0 to 1.0 per file.
+   - 1.0: All fields are clear and unambiguous.
+   - 0.8+: Minor inferences made (e.g., year from path), but high certainty.
+   - 0.5-0.8: Some guesswork involved, human review recommended.
+   - Below 0.5: Significant uncertainty, definitely needs review.
+
+12. **Release type**: Determine the type of release based on all available evidence.
+
+   Allowed values (use exactly one, lowercase):
+   - `album`: Full-length release, typically 4+ tracks
+   - `single`: One or two tracks released as a single
+   - `ep`: Short release, typically 3-6 tracks
+   - `compilation`: Best-of, greatest hits, anthology
+   - `mixtape`: Mixtape release
+   - `live`: Live recording, concert, live album
+   - `soundtrack`: Film/game/TV soundtrack
+   - `remix`: Remix album or collection
+   - `demo`: Demo recording
+
+   Determination rules (in priority order):
+   - If the folder path contains keywords like "Single", "Сингл" → `single`
+   - If the folder path contains "EP" → `ep`
+   - If the folder path contains "Live", "Concert", "Концерт" → `live`
+   - If the folder path contains "Soundtrack", "OST" → `soundtrack`
+   - If the folder path contains "Remix" → `remix`
+   - If the folder path contains "Demo" → `demo`
+   - If the folder path contains "Mixtape" → `mixtape`
+   - If the folder path contains "Compilation", "сборник", "Greatest Hits" → `compilation`
+   - If total track count is 1–2 → likely `single`
+   - If total track count is 3–6 → likely `ep`
+   - If track count is 7+ → likely `album`
+   - When in doubt, default to `album`
+
+## Input format
+
+You will receive metadata for MULTIPLE files from the same folder at once. Each file is separated by a heading with its filename. Process ALL files and return results for each one.
+
+## Response format
+
+You MUST respond with a JSON array. Each element corresponds to one input file and MUST include the "filename" field matching the input filename exactly:
+
+[{"filename": "01 - Song.flac", "artist": "...", "album": "...", "title": "...", "year": 2000, "track_number": 1, "genre": "...", "featured_artists": [], "release_type": "album", "confidence": 0.95, "notes": "..."}, {"filename": "02 - Song.flac", "artist": "...", "album": "...", "title": "...", "year": 2000, "track_number": 2, "genre": "...", "featured_artists": [], "release_type": "album", "confidence": 0.95, "notes": "..."}]
+
+- Use null for fields you cannot determine.
+- Use an empty array [] for "featured_artists" if there are no featured artists.
+- The "notes" field should briefly explain what you changed and why.
+- "release_type" must be exactly one of: "album", "single", "ep", "compilation", "mixtape", "live", "soundtrack", "remix", "demo"
+- You MUST return exactly one result per input file. Do not skip any files.
+- The "filename" field MUST match the input filename character-for-character.
diff --git a/src/admin/mod.rs b/src/admin/mod.rs
index b511770..f1fd8f5 100644
--- a/src/admin/mod.rs
+++ b/src/admin/mod.rs
@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use cot::db::Database;
 use cot::db::migrations::SyncDynMigration;
+use cot::json::Json;
 use cot::request::extractors::{Path, RequestForm, UrlQuery};
 use cot::response::IntoResponse;
 use cot::router::method::get;
@@ -15,8 +16,14 @@ use serde::Deserialize;
 use crate::auth;
 use crate::config::AppConfig;
 use crate::i18n::I18n;
+use crate::scheduler::{JobRegistry, SchedulerHandle};
 use crate::user::User;
-use views::{OidcSettingsForm, SetupForm, UserForm};
+use views::{ArtistForm, CronForm, OidcSettingsForm, ReleaseForm, SetImageBody, SetupForm, UploadImageBody, UserForm};
+
+#[derive(Debug, Deserialize)]
+struct ReviewsQuery {
+    status: Option<String>,
+}
 
 /// Build-time metadata baked in by `build.rs` and Cargo env vars.
 #[derive(Debug)]
@@ -42,11 +49,17 @@ pub static BUILD_INFO: BuildInfo = BuildInfo {
 
 pub struct AdminApp {
     config: Arc<AppConfig>,
+    registry: Arc<JobRegistry>,
+    scheduler_handle: Arc<tokio::sync::OnceCell<Arc<SchedulerHandle>>>,
 }
 
 impl AdminApp {
-    pub fn new(config: Arc<AppConfig>) -> Self {
-        Self { config }
+    pub fn new(
+        config: Arc<AppConfig>,
+        registry: Arc<JobRegistry>,
+        scheduler_handle: Arc<tokio::sync::OnceCell<Arc<SchedulerHandle>>>,
+    ) -> Self {
+        Self { config, registry, scheduler_handle }
     }
 }
 
@@ -60,12 +73,32 @@ struct PathId {
     id: i64,
 }
 
+#[derive(Debug, Deserialize)]
+struct PathName {
+    name: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct PathNameRunId {
+    name: String,
+    run_id: i64,
+}
+
+#[derive(Debug, Deserialize)]
+struct ReleasesQuery {
+    artist_id: Option<i64>,
+}
+
 impl App for AdminApp {
     fn name(&self) -> &'static str {
         "admin"
     }
 
     fn router(&self) -> Router {
+        // Create a shared sqlx pool for admin routes that need it
+        let pool_config = Arc::clone(&self.config);
+        let pool: Arc<tokio::sync::OnceCell<sqlx::PgPool>> = Arc::new(tokio::sync::OnceCell::new());
+
         Router::with_urls([
             // -- Setup (first-run, no auth required) --------------------------
             Route::with_handler_and_name(
@@ -95,15 +128,15 @@ impl App for AdminApp {
             Route::with_handler_and_name(
                 "/",
                 |session: Session, db: Database, i18n: I18n| async move {
-                    // First-run redirect
                     let count = User::count_all(&db).await.unwrap_or(0);
                     if count == 0 {
                         return Ok(auth::redirect("/admin/setup"));
                     }
-                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
-                        Ok(u) => u,
-                        Err(resp) => return Ok(resp),
-                    };
+                    let admin =
+                        match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
                     views::admin_index(admin, i18n).await?.into_response()
                 },
                 "admin_index",
@@ -167,6 +200,27 @@ impl App for AdminApp {
                 }),
                 "admin_settings",
             ),
+            // -- Settings probe (HTMX fragment) -----------------------------------
+            Route::with_handler_and_name(
+                "/settings/probe",
+                {
+                    let config = Arc::clone(&self.config);
+                    move |session: Session, db: Database, i18n: I18n| {
+                        let config = Arc::clone(&config);
+                        async move {
+                            let admin =
+                                match auth::require_admin_or_redirect(&session, &db).await {
+                                    Ok(u) => u,
+                                    Err(resp) => return Ok(resp),
+                                };
+                            views::settings_probe_handler(admin, i18n, &config, &db)
+                                .await?
+                                .into_response()
+                        }
+                    }
+                },
+                "admin_settings_probe",
+            ),
             // -- Users --------------------------------------------------------
             Route::with_handler_and_name(
                 "/users",
@@ -238,6 +292,463 @@ impl App for AdminApp {
                 ),
                 "admin_users_delete",
             ),
+            // -- Artists ------------------------------------------------------
+            Route::with_handler_and_name(
+                "/artists",
+                |session: Session, db: Database, i18n: I18n| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::artists_list(admin, i18n, &db).await?.into_response()
+                },
+                "admin_artists",
+            ),
+            Route::with_handler_and_name(
+                "/artists/new",
+                get(|session: Session, db: Database, i18n: I18n| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::artists_new(admin, i18n).await?.into_response()
+                })
+                .post(
+                    |session: Session, db: Database, form: RequestForm<ArtistForm>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_create(admin, &db, form).await
+                    },
+                ),
+                "admin_artists_new",
+            ),
+            Route::with_handler_and_name(
+                "/artists/{id}/edit",
+                get(
+                    |session: Session, db: Database, i18n: I18n,
+                     path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_edit(admin, i18n, &db, path.0.id)
+                            .await?
+                            .into_response()
+                    },
+                )
+                .post(
+                    |session: Session, db: Database, path: Path<PathId>,
+                     form: RequestForm<ArtistForm>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_update(admin, &db, path.0.id, form).await
+                    },
+                ),
+                "admin_artists_edit",
+            ),
+            Route::with_handler_and_name(
+                "/artists/{id}/delete",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_delete(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_artists_delete",
+            ),
+            Route::with_handler_and_name(
+                "/artists/{id}/available-covers",
+                get(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_available_covers(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_artists_available_covers",
+            ),
+            Route::with_handler_and_name(
+                "/artists/{id}/set-image",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>,
+                     json: Json<SetImageBody>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::artists_set_image(admin, &db, path.0.id, json.0).await
+                    },
+                ),
+                "admin_artists_set_image",
+            ),
+            Route::with_handler_and_name(
+                "/artists/{id}/upload-image",
+                cot::router::method::post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>,
+                          json: Json<UploadImageBody>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            let pg_pool = pool.get_or_init(|| async {
+                                sqlx::postgres::PgPoolOptions::new()
+                                    .max_connections(3)
+                                    .connect(&pool_config.database_url)
+                                    .await
+                                    .expect("admin pool")
+                            }).await;
+                            let (live_config, _) = AppConfig::load_with_db(&db).await;
+                            views::artists_upload_image(admin, &db, pg_pool, &live_config, path.0.id, json.0).await
+                        }
+                    }
+                }),
+                "admin_artists_upload_image",
+            ),
+            // -- Releases -----------------------------------------------------
+            Route::with_handler_and_name(
+                "/releases",
+                |session: Session, db: Database, i18n: I18n,
+                 query: UrlQuery<ReleasesQuery>| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::releases_list(admin, i18n, &db, query.0.artist_id)
+                        .await?
+                        .into_response()
+                },
+                "admin_releases",
+            ),
+            Route::with_handler_and_name(
+                "/releases/new",
+                get(|session: Session, db: Database, i18n: I18n| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::releases_new(admin, i18n, &db).await?.into_response()
+                })
+                .post(
+                    |session: Session, db: Database,
+                     form: RequestForm<ReleaseForm>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::releases_create(admin, &db, form).await
+                    },
+                ),
+                "admin_releases_new",
+            ),
+            Route::with_handler_and_name(
+                "/releases/{id}/edit",
+                get(
+                    |session: Session, db: Database, i18n: I18n,
+                     path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::releases_edit(admin, i18n, &db, path.0.id)
+                            .await?
+                            .into_response()
+                    },
+                )
+                .post(
+                    |session: Session, db: Database, path: Path<PathId>,
+                     form: RequestForm<ReleaseForm>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::releases_update(admin, &db, path.0.id, form).await
+                    },
+                ),
+                "admin_releases_edit",
+            ),
+            Route::with_handler_and_name(
+                "/releases/{id}/delete",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::releases_delete(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_releases_delete",
+            ),
+            // -- Media Files --------------------------------------------------
+            Route::with_handler_and_name(
+                "/media-files",
+                |session: Session, db: Database, i18n: I18n| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::media_files_list(admin, i18n, &db).await?.into_response()
+                },
+                "admin_media_files",
+            ),
+            Route::with_handler_and_name(
+                "/media-files/{id}/delete",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::media_files_delete(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_media_files_delete",
+            ),
+            // -- Jobs ---------------------------------------------------------
+            Route::with_handler_and_name(
+                "/jobs",
+                {
+                    let registry = Arc::clone(&self.registry);
+                    move |session: Session, db: Database, i18n: I18n| {
+                        let registry = Arc::clone(&registry);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            views::jobs_list(admin, i18n, &db, &registry).await?.into_response()
+                        }
+                    }
+                },
+                "admin_jobs",
+            ),
+            Route::with_handler_and_name(
+                "/jobs/{name}/run",
+                cot::router::method::post({
+                    let handle = Arc::clone(&self.scheduler_handle);
+                    move |session: Session, db: Database, path: Path<PathName>| {
+                        let handle = Arc::clone(&handle);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            views::job_run_now(admin, &handle, &path.0.name).await
+                        }
+                    }
+                }),
+                "admin_job_run",
+            ),
+            Route::with_handler_and_name(
+                "/jobs/{name}/toggle",
+                cot::router::method::post({
+                    let handle = Arc::clone(&self.scheduler_handle);
+                    move |session: Session, db: Database, path: Path<PathName>| {
+                        let handle = Arc::clone(&handle);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            views::job_toggle_enabled(admin, &db, &handle, &path.0.name).await
+                        }
+                    }
+                }),
+                "admin_job_toggle",
+            ),
+            Route::with_handler_and_name(
+                "/jobs/{name}/cron",
+                cot::router::method::post({
+                    let handle = Arc::clone(&self.scheduler_handle);
+                    move |session: Session, db: Database, path: Path<PathName>,
+                          form: RequestForm<CronForm>| {
+                        let handle = Arc::clone(&handle);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            views::job_update_cron(admin, &db, &handle, &path.0.name, form).await
+                        }
+                    }
+                }),
+                "admin_job_cron",
+            ),
+            Route::with_handler_and_name(
+                "/jobs/{name}/runs/{run_id}",
+                {
+                    move |session: Session, db: Database, i18n: I18n,
+                          path: Path<PathNameRunId>| {
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            views::job_run_detail(admin, i18n, &db, &path.0.name, path.0.run_id)
+                                .await?
+                                .into_response()
+                        }
+                    }
+                },
+                "admin_job_run_detail",
+            ),
+            Route::with_handler_and_name(
+                "/jobs/{name}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, i18n: I18n,
+                          path: Path<PathName>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            let pg_pool = pool.get_or_init(|| async {
+                                sqlx::postgres::PgPoolOptions::new()
+                                    .max_connections(3)
+                                    .connect(&pool_config.database_url)
+                                    .await
+                                    .expect("admin pool")
+                            }).await;
+                            views::job_detail(admin, i18n, &db, pg_pool, &path.0.name)
+                                .await?
+                                .into_response()
+                        }
+                    }
+                },
+                "admin_job_detail",
+            ),
+            // -- Reviews: clear -----------------------------------------------
+            Route::with_handler_and_name(
+                "/reviews/clear",
+                cot::router::method::post(
+                    |session: Session, db: Database,
+                     query: UrlQuery<ReviewsQuery>| async move {
+                        let admin =
+                            match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                        views::reviews_clear(admin, &db, query.0.status.as_deref()).await
+                    },
+                ),
+                "admin_reviews_clear",
+            ),
+            // -- Reviews ------------------------------------------------------
+            Route::with_handler_and_name(
+                "/reviews",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, i18n: I18n,
+                          query: UrlQuery<ReviewsQuery>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            let pg_pool = pool.get_or_init(|| async {
+                                sqlx::postgres::PgPoolOptions::new()
+                                    .max_connections(3)
+                                    .connect(&pool_config.database_url)
+                                    .await
+                                    .expect("admin pool")
+                            }).await;
+                            views::reviews_list(admin, i18n, &db, pg_pool, query.0.status.as_deref())
+                                .await?
+                                .into_response()
+                        }
+                    }
+                },
+                "admin_reviews",
+            ),
+            Route::with_handler_and_name(
+                "/reviews/{id}",
+                |session: Session, db: Database, i18n: I18n,
+                 path: Path<PathId>| async move {
+                    let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                        Ok(u) => u,
+                        Err(resp) => return Ok(resp),
+                    };
+                    views::review_detail(admin, i18n, &db, path.0.id)
+                        .await?
+                        .into_response()
+                },
+                "admin_review_detail",
+            ),
+            Route::with_handler_and_name(
+                "/reviews/{id}/approve",
+                cot::router::method::post({
+                    let config = Arc::clone(&self.config);
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>| {
+                        let config = Arc::clone(&config);
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                                Ok(u) => u,
+                                Err(resp) => return Ok(resp),
+                            };
+                            let pg_pool = pool.get_or_init(|| async {
+                                sqlx::postgres::PgPoolOptions::new()
+                                    .max_connections(3)
+                                    .connect(&pool_config.database_url)
+                                    .await
+                                    .expect("admin pool")
+                            }).await;
+                            views::review_approve(admin, &config, &db, pg_pool, path.0.id).await
+                        }
+                    }
+                }),
+                "admin_review_approve",
+            ),
+            Route::with_handler_and_name(
+                "/reviews/{id}/reject",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::review_reject(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_review_reject",
+            ),
+            Route::with_handler_and_name(
+                "/reviews/{id}/requeue",
+                cot::router::method::post(
+                    |session: Session, db: Database, path: Path<PathId>| async move {
+                        let admin = match auth::require_admin_or_redirect(&session, &db).await {
+                            Ok(u) => u,
+                            Err(resp) => return Ok(resp),
+                        };
+                        views::review_requeue(admin, &db, path.0.id).await
+                    },
+                ),
+                "admin_review_requeue",
+            ),
         ])
     }
 
@@ -247,6 +758,12 @@ impl App for AdminApp {
         all.extend(cot::db::migrations::wrap_migrations(
             crate::user::db_migrations::MIGRATIONS,
         ));
+        all.extend(cot::db::migrations::wrap_migrations(
+            crate::music::db_migrations::MIGRATIONS,
+        ));
+        all.extend(cot::db::migrations::wrap_migrations(
+            crate::scheduler::db_migrations::MIGRATIONS,
+        ));
         all
     }
 }
diff --git a/src/admin/views.rs b/src/admin/views.rs
index 1e80a33..a98a47c 100644
--- a/src/admin/views.rs
+++ b/src/admin/views.rs
@@ -6,12 +6,20 @@ use cot::response::IntoResponse;
 use cot::session::Session;
 use cot::{Body, Template};
 
+use std::collections::HashMap;
+use std::sync::Arc;
+
 use crate::auth::{self, AuthenticatedUser};
+use crate::agent;
 use crate::config::{AppConfig, ConfigEntry, ConfigSources};
 use crate::i18n::{I18n, Translations};
+use crate::music::{Artist, MediaFile, Release, ReleaseArtist, Track, TrackArtist, RELEASE_TYPES};
+use crate::scheduler::{self, JobRegistry, JobRun, PendingReview, ScheduledJob};
 use crate::user::User;
 use super::BUILD_INFO;
 
+use crate::agent::AgentProbeResult;
+
 /// A config entry for display in the unified debug table.
 #[derive(Debug)]
 pub struct ConfigDisplayEntry {
@@ -87,6 +95,15 @@ fn config_display_entries(config: &AppConfig, sources: &ConfigSources) -> Vec<Co
         entry!(oidc_button_text, config.oidc_button_text.clone(), defaults.oidc_button_text.clone()),
         entry!(oidc_admin_groups, config.oidc_admin_groups.clone(), defaults.oidc_admin_groups.clone()),
         entry!(swagger_enabled, config.swagger_enabled.to_string(), defaults.swagger_enabled.to_string()),
+        entry!(agent_enabled, config.agent_enabled.to_string(), defaults.agent_enabled.to_string()),
+        entry!(agent_inbox_dir, config.agent_inbox_dir.clone(), defaults.agent_inbox_dir.clone()),
+        entry!(agent_storage_dir, config.agent_storage_dir.clone(), defaults.agent_storage_dir.clone()),
+        entry!(agent_llm_url, config.agent_llm_url.clone(), defaults.agent_llm_url.clone()),
+        entry!(agent_llm_model, config.agent_llm_model.clone(), defaults.agent_llm_model.clone()),
+        entry!(agent_llm_auth, config.agent_llm_auth.clone(), defaults.agent_llm_auth.clone()),
+        entry!(agent_confidence_threshold, config.agent_confidence_threshold.to_string(), defaults.agent_confidence_threshold.to_string()),
+        entry!(agent_context_limit, config.agent_context_limit.to_string(), defaults.agent_context_limit.to_string()),
+        entry!(agent_concurrency, config.agent_concurrency.to_string(), defaults.agent_concurrency.to_string()),
     ]
 }
 
@@ -158,6 +175,24 @@ struct SettingsTemplate {
     oidc_admin_groups_source: &'static str,
     swagger_enabled: bool,
     swagger_enabled_source: &'static str,
+    agent_enabled: bool,
+    agent_enabled_source: &'static str,
+    agent_inbox_dir: String,
+    agent_inbox_dir_source: &'static str,
+    agent_storage_dir: String,
+    agent_storage_dir_source: &'static str,
+    agent_llm_url: String,
+    agent_llm_url_source: &'static str,
+    agent_llm_model: String,
+    agent_llm_model_source: &'static str,
+    agent_llm_auth: String,
+    agent_llm_auth_source: &'static str,
+    agent_confidence_threshold: String,
+    agent_confidence_threshold_source: &'static str,
+    agent_context_limit: String,
+    agent_context_limit_source: &'static str,
+    agent_concurrency: String,
+    agent_concurrency_source: &'static str,
 }
 
 pub async fn settings_handler(
@@ -190,6 +225,24 @@ pub async fn settings_handler(
         oidc_admin_groups_source: sources.oidc_admin_groups.code(),
         swagger_enabled: config.swagger_enabled,
         swagger_enabled_source: sources.swagger_enabled.code(),
+        agent_enabled: config.agent_enabled,
+        agent_enabled_source: sources.agent_enabled.code(),
+        agent_inbox_dir: config.agent_inbox_dir.clone(),
+        agent_inbox_dir_source: sources.agent_inbox_dir.code(),
+        agent_storage_dir: config.agent_storage_dir.clone(),
+        agent_storage_dir_source: sources.agent_storage_dir.code(),
+        agent_llm_url: config.agent_llm_url.clone(),
+        agent_llm_url_source: sources.agent_llm_url.code(),
+        agent_llm_model: config.agent_llm_model.clone(),
+        agent_llm_model_source: sources.agent_llm_model.code(),
+        agent_llm_auth: config.agent_llm_auth.clone(),
+        agent_llm_auth_source: sources.agent_llm_auth.code(),
+        agent_confidence_threshold: config.agent_confidence_threshold.to_string(),
+        agent_confidence_threshold_source: sources.agent_confidence_threshold.code(),
+        agent_context_limit: config.agent_context_limit.to_string(),
+        agent_context_limit_source: sources.agent_context_limit.code(),
+        agent_concurrency: config.agent_concurrency.to_string(),
+        agent_concurrency_source: sources.agent_concurrency.code(),
     };
     Ok(Html::new(template.render()?))
 }
@@ -198,12 +251,21 @@ pub async fn settings_handler(
 pub struct OidcSettingsForm {
     auth_password_enabled: Option<String>,
     auth_sso_enabled: Option<String>,
-    oidc_button_text: String,
-    oidc_issuer: String,
-    oidc_client_id: String,
-    oidc_client_secret: String,
-    oidc_admin_groups: String,
+    oidc_button_text: Option<String>,
+    oidc_issuer: Option<String>,
+    oidc_client_id: Option<String>,
+    oidc_client_secret: Option<String>,
+    oidc_admin_groups: Option<String>,
     swagger_enabled: Option<String>,
+    agent_enabled: Option<String>,
+    agent_inbox_dir: Option<String>,
+    agent_storage_dir: Option<String>,
+    agent_llm_url: Option<String>,
+    agent_llm_model: Option<String>,
+    agent_llm_auth: Option<String>,
+    agent_confidence_threshold: Option<String>,
+    agent_context_limit: Option<String>,
+    agent_concurrency: Option<String>,
 }
 
 pub async fn settings_submit(
@@ -219,15 +281,38 @@ pub async fn settings_submit(
             let pw_enabled = if data.auth_password_enabled.is_some() { "true" } else { "false" };
             let sso_enabled = if data.auth_sso_enabled.is_some() { "true" } else { "false" };
             let swagger = if data.swagger_enabled.is_some() { "true" } else { "false" };
-            let fields: [(&str, &str); 8] = [
+            let agent_en = if data.agent_enabled.is_some() { "true" } else { "false" };
+            let oidc_button_text = data.oidc_button_text.unwrap_or_default();
+            let oidc_issuer = data.oidc_issuer.unwrap_or_default();
+            let oidc_client_id = data.oidc_client_id.unwrap_or_default();
+            let oidc_client_secret = data.oidc_client_secret.unwrap_or_default();
+            let oidc_admin_groups = data.oidc_admin_groups.unwrap_or_default();
+            let agent_inbox_dir = data.agent_inbox_dir.unwrap_or_default();
+            let agent_storage_dir = data.agent_storage_dir.unwrap_or_default();
+            let agent_llm_url = data.agent_llm_url.unwrap_or_default();
+            let agent_llm_model = data.agent_llm_model.unwrap_or_default();
+            let agent_llm_auth = data.agent_llm_auth.unwrap_or_default();
+            let agent_confidence_threshold = data.agent_confidence_threshold.unwrap_or_default();
+            let agent_context_limit = data.agent_context_limit.unwrap_or_default();
+            let agent_concurrency = data.agent_concurrency.unwrap_or_default();
+            let fields: [(&str, &str); 17] = [
                 ("auth_password_enabled", pw_enabled),
                 ("auth_sso_enabled", sso_enabled),
-                ("oidc_button_text", &data.oidc_button_text),
-                ("oidc_issuer", &data.oidc_issuer),
-                ("oidc_client_id", &data.oidc_client_id),
-                ("oidc_client_secret", &data.oidc_client_secret),
-                ("oidc_admin_groups", &data.oidc_admin_groups),
+                ("oidc_button_text", &oidc_button_text),
+                ("oidc_issuer", &oidc_issuer),
+                ("oidc_client_id", &oidc_client_id),
+                ("oidc_client_secret", &oidc_client_secret),
+                ("oidc_admin_groups", &oidc_admin_groups),
                 ("swagger_enabled", swagger),
+                ("agent_enabled", agent_en),
+                ("agent_inbox_dir", &agent_inbox_dir),
+                ("agent_storage_dir", &agent_storage_dir),
+                ("agent_llm_url", &agent_llm_url),
+                ("agent_llm_model", &agent_llm_model),
+                ("agent_llm_auth", &agent_llm_auth),
+                ("agent_confidence_threshold", &agent_confidence_threshold),
+                ("agent_context_limit", &agent_context_limit),
+                ("agent_concurrency", &agent_concurrency),
             ];
             for (key, value) in fields {
                 let mut entry = ConfigEntry::new(key.to_owned(), value.to_owned());
@@ -240,11 +325,48 @@ pub async fn settings_submit(
             Ok(auth::redirect("/admin/settings?saved=1"))
         }
         FormResult::ValidationError(_ctx) => {
+            tracing::warn!("settings form validation failed");
             Ok(auth::redirect("/admin/settings"))
         }
     }
 }
 
+// ---------------------------------------------------------------------------
+// Agent probe fragment (loaded via HTMX)
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Template)]
+#[template(path = "admin/probe_fragment.html")]
+struct ProbeFragmentTemplate {
+    t: &'static Translations,
+    agent_enabled: bool,
+    agent_llm_url: String,
+    agent_probe: AgentProbeResult,
+}
+
+pub async fn settings_probe_handler(
+    _admin: AuthenticatedUser,
+    i18n: I18n,
+    _startup_config: &AppConfig,
+    db: &Database,
+) -> cot::Result<Html> {
+    let (config, _sources) = AppConfig::load_with_db(db).await;
+
+    let probe = if config.agent_enabled && !config.agent_llm_url.is_empty() {
+        agent::probe_llm(&config.agent_llm_url, &config.agent_llm_model, &config.agent_llm_auth).await
+    } else {
+        AgentProbeResult::default()
+    };
+
+    let template = ProbeFragmentTemplate {
+        t: i18n.t,
+        agent_enabled: config.agent_enabled,
+        agent_llm_url: config.agent_llm_url,
+        agent_probe: probe,
+    };
+    Ok(Html::new(template.render()?))
+}
+
 // ---------------------------------------------------------------------------
 // User management
 // ---------------------------------------------------------------------------
@@ -437,3 +559,1011 @@ pub async fn setup_submit(
     auth::login(session, user.id_val()).await?;
     Ok(auth::redirect("/admin/"))
 }
+
+// ---------------------------------------------------------------------------
+// Artist management
+// ---------------------------------------------------------------------------
+
+/// Row for artist list with computed stats.
+#[derive(Debug)]
+pub struct ArtistRow {
+    pub artist: Artist,
+    pub release_count: u64,
+    pub track_count: u64,
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/artists.html")]
+struct ArtistsTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    rows: Vec<ArtistRow>,
+}
+
+pub async fn artists_list(admin: AuthenticatedUser, i18n: I18n, db: &Database) -> cot::Result<Html> {
+    let artists = Artist::list_all(db).await.unwrap_or_default();
+    let mut rows = Vec::with_capacity(artists.len());
+    for artist in artists {
+        let release_count = ReleaseArtist::count_by_artist(db, artist.id_val()).await.unwrap_or(0);
+        let track_count = TrackArtist::count_by_artist(db, artist.id_val()).await.unwrap_or(0);
+        rows.push(ArtistRow { artist, release_count, track_count });
+    }
+    let template = ArtistsTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        rows,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/artist_form.html")]
+struct ArtistFormTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    is_edit: bool,
+    form_artist_id: i64,
+    form_name: String,
+    current_image_url: Option<String>,
+}
+
+pub async fn artists_new(admin: AuthenticatedUser, i18n: I18n) -> cot::Result<Html> {
+    let template = ArtistFormTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        is_edit: false,
+        form_artist_id: 0,
+        form_name: String::new(),
+        current_image_url: None,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+#[derive(Debug, Form)]
+pub struct ArtistForm {
+    name: String,
+}
+
+pub async fn artists_create(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    form: RequestForm<ArtistForm>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let RequestForm(result) = form;
+    match result {
+        FormResult::Ok(data) => {
+            Artist::create(db, &data.name, None)
+                .await
+                .map_err(|e| cot::Error::internal(format!("failed to create artist: {e}")))?;
+            Ok(auth::redirect("/admin/artists"))
+        }
+        FormResult::ValidationError(_) => Ok(auth::redirect("/admin/artists/new")),
+    }
+}
+
+pub async fn artists_edit(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    artist_id: i64,
+) -> cot::Result<Html> {
+    let artist = Artist::get_by_id(db, artist_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("artist not found"))?;
+
+    let current_image_url = match artist.image_file_id {
+        Some(fid) => {
+            MediaFile::get_by_id(db, fid)
+                .await
+                .ok()
+                .flatten()
+                .map(|mf| format!("/api/player/cover/{}", mf.id_val()))
+        }
+        None => None,
+    };
+
+    let template = ArtistFormTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        is_edit: true,
+        form_artist_id: artist.id_val(),
+        form_name: artist.name_str().to_owned(),
+        current_image_url,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+pub async fn artists_update(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    artist_id: i64,
+    form: RequestForm<ArtistForm>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let RequestForm(result) = form;
+    match result {
+        FormResult::Ok(data) => {
+            let mut artist = Artist::get_by_id(db, artist_id)
+                .await
+                .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+                .ok_or_else(|| cot::Error::internal("artist not found"))?;
+            artist
+                .update_name(db, &data.name)
+                .await
+                .map_err(|e| cot::Error::internal(format!("failed to update artist: {e}")))?;
+            Ok(auth::redirect("/admin/artists"))
+        }
+        FormResult::ValidationError(_) => {
+            Ok(auth::redirect(&format!("/admin/artists/{artist_id}/edit")))
+        }
+    }
+}
+
+pub async fn artists_delete(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    artist_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    Artist::delete_by_id(db, artist_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to delete artist: {e}")))?;
+    Ok(auth::redirect("/admin/artists"))
+}
+
+// ---------------------------------------------------------------------------
+// Artist image endpoints
+// ---------------------------------------------------------------------------
+
+/// JSON response for available album covers for an artist.
+#[derive(serde::Serialize)]
+pub struct AvailableCover {
+    pub media_file_id: i64,
+    pub release_title: String,
+    pub cover_url: String,
+}
+
+pub async fn artists_available_covers(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    artist_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    let links = ReleaseArtist::find_by_artist(db, artist_id)
+        .await
+        .unwrap_or_default();
+
+    let mut covers: Vec<AvailableCover> = Vec::new();
+    for link in &links {
+        if let Ok(Some(release)) = Release::get_by_id(db, link.release_id()).await {
+            if let Some(cover_fid) = release.cover_file_id {
+                covers.push(AvailableCover {
+                    media_file_id: cover_fid,
+                    release_title: release.title_str().to_owned(),
+                    cover_url: format!("/api/player/cover/{cover_fid}"),
+                });
+            }
+        }
+    }
+
+    let json = serde_json::to_string(&covers).unwrap_or_else(|_| "[]".into());
+    let resp = cot::http::Response::builder()
+        .status(cot::http::StatusCode::OK)
+        .header(cot::http::header::CONTENT_TYPE, "application/json")
+        .body(Body::fixed(json))
+        .expect("valid response");
+    Ok(resp)
+}
+
+#[derive(serde::Deserialize)]
+pub struct SetImageBody {
+    pub media_file_id: Option<i64>,
+}
+
+pub async fn artists_set_image(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    artist_id: i64,
+    parsed: SetImageBody,
+) -> cot::Result<cot::http::Response<Body>> {
+    let mut artist = Artist::get_by_id(db, artist_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("artist not found"))?;
+
+    // Validate media file exists when setting (not removing)
+    if let Some(fid) = parsed.media_file_id {
+        MediaFile::get_by_id(db, fid)
+            .await
+            .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+            .ok_or_else(|| cot::Error::internal("media file not found"))?;
+    }
+
+    artist
+        .set_image_file_id(db, parsed.media_file_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to set image: {e}")))?;
+
+    let resp = cot::http::Response::builder()
+        .status(cot::http::StatusCode::OK)
+        .header(cot::http::header::CONTENT_TYPE, "application/json")
+        .body(Body::fixed(r#"{"ok":true}"#))
+        .expect("valid response");
+    Ok(resp)
+}
+
+#[derive(serde::Deserialize)]
+pub struct UploadImageBody {
+    pub data: String,
+    pub filename: String,
+    pub mime_type: String,
+}
+
+pub async fn artists_upload_image(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    pool: &sqlx::PgPool,
+    config: &AppConfig,
+    artist_id: i64,
+    parsed: UploadImageBody,
+) -> cot::Result<cot::http::Response<Body>> {
+    let mut artist = Artist::get_by_id(db, artist_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("artist not found"))?;
+
+    let storage_dir = &config.agent_storage_dir;
+    if storage_dir.is_empty() {
+        return Err(cot::Error::internal("agent_storage_dir is not configured"));
+    }
+
+    // Decode base64 image data
+    use base64::Engine;
+    let image_data = base64::engine::general_purpose::STANDARD
+        .decode(&parsed.data)
+        .map_err(|e| cot::Error::internal(format!("invalid base64: {e}")))?;
+
+    // Build a CoverImage and reuse save_cover_to_storage
+    let cover = crate::agent::cover_art::CoverImage {
+        data: image_data,
+        mime_type: parsed.mime_type.clone(),
+        source: crate::agent::cover_art::CoverSource::FolderFile(
+            std::path::PathBuf::from(&parsed.filename),
+        ),
+    };
+
+    let cover_file_id = crate::agent::cover_art::save_cover_to_storage(
+        db,
+        pool,
+        storage_dir,
+        artist.name_str(),
+        "__artist_image__",
+        &cover,
+    )
+    .await
+    .map_err(|e| cot::Error::internal(format!("failed to save image: {e}")))?;
+
+    artist
+        .set_image_file_id(db, Some(cover_file_id))
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to set image: {e}")))?;
+
+    let resp = cot::http::Response::builder()
+        .status(cot::http::StatusCode::OK)
+        .header(cot::http::header::CONTENT_TYPE, "application/json")
+        .body(Body::fixed(r#"{"ok":true}"#))
+        .expect("valid response");
+    Ok(resp)
+}
+
+// ---------------------------------------------------------------------------
+// Release management
+// ---------------------------------------------------------------------------
+
+/// Row for release list with resolved artist names.
+#[derive(Debug)]
+pub struct ReleaseRow {
+    pub release: Release,
+    pub artist_names: String,
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/releases.html")]
+struct ReleasesTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    rows: Vec<ReleaseRow>,
+    artists: Vec<Artist>,
+    filter_artist_id: Option<i64>,
+}
+
+/// Build a map of artist_id → artist_name from a list of artists.
+fn artist_name_map(artists: &[Artist]) -> HashMap<i64, String> {
+    artists
+        .iter()
+        .map(|a| (a.id_val(), a.name_str().to_owned()))
+        .collect()
+}
+
+/// Resolve artist names for a release, joined by ", ".
+async fn resolve_artist_names(
+    db: &Database,
+    release_id: i64,
+    names: &HashMap<i64, String>,
+) -> String {
+    let links = ReleaseArtist::find_by_release(db, release_id)
+        .await
+        .unwrap_or_default();
+    let mut sorted = links;
+    sorted.sort_by_key(|l| l.position);
+    sorted
+        .iter()
+        .filter_map(|l| names.get(&l.artist_id()))
+        .cloned()
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+pub async fn releases_list(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    filter_artist_id: Option<i64>,
+) -> cot::Result<Html> {
+    let all_artists = Artist::list_all(db).await.unwrap_or_default();
+    let names = artist_name_map(&all_artists);
+
+    let releases = Release::list_all(db).await.unwrap_or_default();
+
+    // If filtering by artist, find the set of release_ids for that artist
+    let filtered_release_ids: Option<Vec<i64>> = match filter_artist_id {
+        Some(aid) => {
+            let links = ReleaseArtist::find_by_artist(db, aid).await.unwrap_or_default();
+            Some(links.iter().map(|l| l.release_id()).collect())
+        }
+        None => None,
+    };
+
+    let mut rows = Vec::new();
+    for release in releases {
+        if let Some(ref ids) = filtered_release_ids {
+            if !ids.contains(&release.id_val()) {
+                continue;
+            }
+        }
+        let artist_names = resolve_artist_names(db, release.id_val(), &names).await;
+        rows.push(ReleaseRow { release, artist_names });
+    }
+
+    let template = ReleasesTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        rows,
+        artists: all_artists,
+        filter_artist_id,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/release_form.html")]
+struct ReleaseFormTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    is_edit: bool,
+    form_release_id: i64,
+    form_title: String,
+    form_release_type: String,
+    form_year: String,
+    form_artist_ids: Vec<i64>,
+    artists: Vec<Artist>,
+    release_types: &'static [(&'static str, &'static str, &'static str)],
+    lang_code: &'static str,
+}
+
+pub async fn releases_new(admin: AuthenticatedUser, i18n: I18n, db: &Database) -> cot::Result<Html> {
+    let artists = Artist::list_all(db).await.unwrap_or_default();
+    let template = ReleaseFormTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        is_edit: false,
+        form_release_id: 0,
+        form_title: String::new(),
+        form_release_type: "album".into(),
+        form_year: String::new(),
+        form_artist_ids: Vec::new(),
+        artists,
+        release_types: RELEASE_TYPES,
+        lang_code: i18n.t.lang.code(),
+    };
+    Ok(Html::new(template.render()?))
+}
+
+#[derive(Debug, Form)]
+pub struct ReleaseForm {
+    title: String,
+    release_type: String,
+    year: String,
+    artist_id: String, // comma-separated IDs or single ID
+}
+
+fn parse_artist_ids(raw: &str) -> Vec<i64> {
+    raw.split(',')
+        .filter_map(|s| s.trim().parse::<i64>().ok())
+        .collect()
+}
+
+pub async fn releases_create(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    form: RequestForm<ReleaseForm>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let RequestForm(result) = form;
+    match result {
+        FormResult::Ok(data) => {
+            let year = data.year.trim().parse::<i32>().ok();
+            let release = Release::create(db, &data.title, &data.release_type, year, None)
+                .await
+                .map_err(|e| cot::Error::internal(format!("failed to create release: {e}")))?;
+            let artist_ids = parse_artist_ids(&data.artist_id);
+            if !artist_ids.is_empty() {
+                ReleaseArtist::set_artists(db, release.id_val(), &artist_ids)
+                    .await
+                    .map_err(|e| cot::Error::internal(format!("failed to link artists: {e}")))?;
+            }
+            Ok(auth::redirect("/admin/releases"))
+        }
+        FormResult::ValidationError(_) => Ok(auth::redirect("/admin/releases/new")),
+    }
+}
+
+pub async fn releases_edit(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    release_id: i64,
+) -> cot::Result<Html> {
+    let release = Release::get_by_id(db, release_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("release not found"))?;
+
+    let links = ReleaseArtist::find_by_release(db, release_id)
+        .await
+        .unwrap_or_default();
+    let mut current_artist_ids: Vec<i64> = links.iter().map(|l| l.artist_id()).collect();
+    current_artist_ids.sort();
+
+    let artists = Artist::list_all(db).await.unwrap_or_default();
+
+    let template = ReleaseFormTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        is_edit: true,
+        form_release_id: release.id_val(),
+        form_title: release.title_str().to_owned(),
+        form_release_type: release.release_type_str().to_owned(),
+        form_year: release.year_display(),
+        form_artist_ids: current_artist_ids,
+        artists,
+        release_types: RELEASE_TYPES,
+        lang_code: i18n.t.lang.code(),
+    };
+    Ok(Html::new(template.render()?))
+}
+
+pub async fn releases_update(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    release_id: i64,
+    form: RequestForm<ReleaseForm>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let RequestForm(result) = form;
+    match result {
+        FormResult::Ok(data) => {
+            let mut release = Release::get_by_id(db, release_id)
+                .await
+                .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+                .ok_or_else(|| cot::Error::internal("release not found"))?;
+            let year = data.year.trim().parse::<i32>().ok();
+            release
+                .update_fields(db, &data.title, &data.release_type, year)
+                .await
+                .map_err(|e| cot::Error::internal(format!("failed to update release: {e}")))?;
+            let artist_ids = parse_artist_ids(&data.artist_id);
+            ReleaseArtist::set_artists(db, release_id, &artist_ids)
+                .await
+                .map_err(|e| cot::Error::internal(format!("failed to update artists: {e}")))?;
+            Ok(auth::redirect("/admin/releases"))
+        }
+        FormResult::ValidationError(_) => {
+            Ok(auth::redirect(&format!("/admin/releases/{release_id}/edit")))
+        }
+    }
+}
+
+pub async fn releases_delete(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    release_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    Release::delete_by_id(db, release_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to delete release: {e}")))?;
+    Ok(auth::redirect("/admin/releases"))
+}
+
+// ===========================================================================
+// Media Files
+// ===========================================================================
+
+#[derive(Debug)]
+pub struct MediaFileRow {
+    pub media_file: MediaFile,
+    pub track_title: String,
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/media_files.html")]
+struct MediaFilesTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    rows: Vec<MediaFileRow>,
+}
+
+pub async fn media_files_list(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+) -> cot::Result<Html> {
+    let files = MediaFile::list_all(db).await.unwrap_or_default();
+    let tracks = Track::list_all(db).await.unwrap_or_default();
+
+    // Build a map of audio_file_id → track title
+    let track_map: HashMap<i64, String> = tracks
+        .iter()
+        .map(|t| (t.audio_file_id, t.title.to_string()))
+        .collect();
+
+    let rows: Vec<MediaFileRow> = files
+        .into_iter()
+        .map(|mf| {
+            let track_title = track_map
+                .get(&mf.id_val())
+                .cloned()
+                .unwrap_or_default();
+            MediaFileRow {
+                media_file: mf,
+                track_title,
+            }
+        })
+        .collect();
+
+    let template = MediaFilesTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        rows,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+pub async fn media_files_delete(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    file_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    MediaFile::delete_by_id(db, file_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to delete media file: {e}")))?;
+    Ok(auth::redirect("/admin/media-files"))
+}
+
+// ===========================================================================
+// Jobs
+// ===========================================================================
+
+#[derive(Debug, Template)]
+#[template(path = "admin/jobs.html")]
+struct JobsTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    jobs: Vec<ScheduledJob>,
+}
+
+pub async fn jobs_list(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    registry: &JobRegistry,
+) -> cot::Result<Html> {
+    // Ensure all registered jobs exist in DB and remove orphans
+    sync_registered_jobs(db, registry).await;
+
+    let jobs = ScheduledJob::list_all(db).await.unwrap_or_default();
+    let template = JobsTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        jobs,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+/// Ensure the DB has a ScheduledJob row for every registered job and remove
+/// rows for jobs that are no longer registered.
+async fn sync_registered_jobs(db: &Database, registry: &JobRegistry) {
+    for job in registry.all_jobs() {
+        if let Err(e) = ScheduledJob::upsert(db, job.name(), job.description(), job.default_cron()).await {
+            tracing::error!("failed to upsert scheduled job {}: {e}", job.name());
+        }
+    }
+    if let Ok(all) = ScheduledJob::list_all(db).await {
+        for sched_job in all {
+            if registry.get(sched_job.name_str()).is_none() {
+                tracing::warn!(
+                    "Removing orphaned scheduled job '{}'",
+                    sched_job.name_str()
+                );
+                let _ = ScheduledJob::delete_by_name(db, sched_job.name_str()).await;
+            }
+        }
+    }
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/job_detail.html")]
+struct JobDetailTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    job: ScheduledJob,
+    runs: Vec<JobRun>,
+}
+
+pub async fn job_detail(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    pool: &sqlx::PgPool,
+    job_name: &str,
+) -> cot::Result<Html> {
+    let job = ScheduledJob::get_by_name(db, job_name)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("job not found"))?;
+
+    let runs = JobRun::list_by_job(pool, job_name, 50)
+        .await
+        .unwrap_or_default();
+
+    let template = JobDetailTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        job,
+        runs,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+pub async fn job_run_now(
+    _admin: AuthenticatedUser,
+    handle_cell: &Arc<tokio::sync::OnceCell<Arc<scheduler::SchedulerHandle>>>,
+    job_name: &str,
+) -> cot::Result<cot::http::Response<Body>> {
+    if let Some(handle) = handle_cell.get() {
+        match handle.trigger_job_now(job_name).await {
+            Ok(_run_id) => {}
+            Err(e) => {
+                tracing::error!(?e, job_name, "manual job trigger failed");
+            }
+        }
+    } else {
+        tracing::error!(job_name, "scheduler not ready, cannot trigger job");
+    }
+    Ok(auth::redirect(&format!("/admin/jobs/{job_name}")))
+}
+
+pub async fn job_toggle_enabled(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    handle_cell: &Arc<tokio::sync::OnceCell<Arc<scheduler::SchedulerHandle>>>,
+    job_name: &str,
+) -> cot::Result<cot::http::Response<Body>> {
+    let job = ScheduledJob::get_by_name(db, job_name)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("job not found"))?;
+
+    let new_enabled = !job.enabled;
+
+    if let Some(handle) = handle_cell.get() {
+        if let Err(e) = handle.toggle_job(job_name, new_enabled).await {
+            tracing::error!(?e, job_name, new_enabled, "toggle_job failed");
+        }
+    } else {
+        tracing::error!(job_name, "scheduler not ready, cannot toggle job");
+    }
+
+    Ok(auth::redirect("/admin/jobs"))
+}
+
+#[derive(Debug, Form)]
+pub struct CronForm {
+    cron_expression: String,
+}
+
+pub async fn job_update_cron(
+    _admin: AuthenticatedUser,
+    _db: &Database,
+    handle_cell: &Arc<tokio::sync::OnceCell<Arc<scheduler::SchedulerHandle>>>,
+    job_name: &str,
+    form: RequestForm<CronForm>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let RequestForm(result) = form;
+    if let FormResult::Ok(data) = result {
+        if let Some(handle) = handle_cell.get() {
+            if let Err(e) = handle.reschedule_job(job_name, &data.cron_expression).await {
+                tracing::error!(?e, job_name, "reschedule_job failed");
+            }
+        } else {
+            tracing::error!(job_name, "scheduler not ready, cannot update cron");
+        }
+    }
+    Ok(auth::redirect(&format!("/admin/jobs/{job_name}")))
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/job_run_detail.html")]
+struct JobRunDetailTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    run: JobRun,
+    job_name: String,
+}
+
+pub async fn job_run_detail(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    _job_name: &str,
+    run_id: i64,
+) -> cot::Result<Html> {
+    let run = JobRun::get_by_id(db, run_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("run not found"))?;
+
+    let template = JobRunDetailTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        job_name: run.job_name.to_string(),
+        run,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+// ===========================================================================
+// Reviews
+// ===========================================================================
+
+#[derive(Debug, Template)]
+#[template(path = "admin/reviews.html")]
+struct ReviewsTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    reviews: Vec<PendingReview>,
+    stats_map: HashMap<i64, scheduler::ProcessingStatsRow>,
+    status_filter: String,
+}
+
+pub async fn reviews_list(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    pool: &sqlx::PgPool,
+    status: Option<&str>,
+) -> cot::Result<Html> {
+    let reviews = match status {
+        Some(s) if !s.is_empty() => PendingReview::list_by_status(db, s)
+            .await
+            .unwrap_or_default(),
+        _ => PendingReview::list_all(db).await.unwrap_or_default(),
+    };
+
+    let review_ids: Vec<i64> = reviews.iter().map(|r| r.id_val()).collect();
+    let stats_map = scheduler::ProcessingStats::list_by_review_ids(pool, &review_ids)
+        .await
+        .unwrap_or_default();
+
+    let template = ReviewsTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        reviews,
+        stats_map,
+        status_filter: status.unwrap_or("").to_owned(),
+    };
+    Ok(Html::new(template.render()?))
+}
+
+#[derive(Debug, Template)]
+#[template(path = "admin/review_detail.html")]
+struct ReviewDetailTemplate {
+    t: &'static Translations,
+    user_name: String,
+    user_role: String,
+    review: PendingReview,
+    context_pretty: String,
+    result_pretty: String,
+    error_message: String,
+    stats: Option<scheduler::ProcessingStats>,
+}
+
+pub async fn review_detail(
+    admin: AuthenticatedUser,
+    i18n: I18n,
+    db: &Database,
+    review_id: i64,
+) -> cot::Result<Html> {
+    let review = PendingReview::get_by_id(db, review_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("review not found"))?;
+
+    let context_pretty = review
+        .context_json
+        .as_deref()
+        .and_then(|s| serde_json::from_str::<serde_json::Value>(s).ok())
+        .map(|v| serde_json::to_string_pretty(&v).unwrap_or_default())
+        .unwrap_or_default();
+
+    let result_pretty = review
+        .result_json
+        .as_deref()
+        .and_then(|s| serde_json::from_str::<serde_json::Value>(s).ok())
+        .map(|v| serde_json::to_string_pretty(&v).unwrap_or_default())
+        .unwrap_or_default();
+
+    let error_message = review.error_message_str().to_owned();
+
+    let stats = scheduler::ProcessingStats::get_by_review_id(db, review_id)
+        .await
+        .unwrap_or(None);
+
+    let template = ReviewDetailTemplate {
+        t: i18n.t,
+        user_name: admin.name,
+        user_role: admin.role.code().to_owned(),
+        review,
+        context_pretty,
+        result_pretty,
+        error_message,
+        stats,
+    };
+    Ok(Html::new(template.render()?))
+}
+
+pub async fn review_approve(
+    _admin: AuthenticatedUser,
+    _config: &Arc<AppConfig>,
+    db: &Database,
+    pool: &sqlx::PgPool,
+    review_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    let mut review = PendingReview::get_by_id(db, review_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("review not found"))?;
+
+    let result_str = review.result_json_str().to_owned();
+    let context_str = review.context_json_str().to_owned();
+    let input_path = review.input_path_str().to_owned();
+
+    if result_str.is_empty() {
+        let _ = review.set_rejected(db).await;
+        return Ok(auth::redirect(&format!("/admin/reviews/{review_id}")));
+    }
+
+    let normalized: crate::agent::dto::NormalizedFields =
+        serde_json::from_str(&result_str)
+            .map_err(|e| cot::Error::internal(format!("invalid result_json: {e}")))?;
+
+    let context: serde_json::Value = serde_json::from_str(&context_str).unwrap_or_default();
+
+    // Load live config from DB so admin-set values are used
+    let (live_config, _) = AppConfig::load_with_db(db).await;
+
+    // Look up the model name from processing stats (if LLM processed this review)
+    let stats = scheduler::ProcessingStats::get_by_review_id(db, review_id)
+        .await
+        .unwrap_or(None);
+    let model_name_str = stats.as_ref().map(|s| s.model_name.to_string());
+
+    match crate::jobs::inbox_process::finalize_approved(
+        db,
+        pool,
+        &live_config,
+        &input_path,
+        &normalized,
+        &context,
+        &live_config.agent_storage_dir,
+        model_name_str.as_deref(),
+    )
+    .await
+    {
+        Ok(()) => {
+            let _ = review.set_approved(db).await;
+        }
+        Err(e) => {
+            tracing::error!(?e, "review approval failed");
+            let _ = review.set_rejected(db).await;
+        }
+    }
+
+    Ok(auth::redirect(&format!("/admin/reviews/{review_id}")))
+}
+
+pub async fn review_reject(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    review_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    let mut review = PendingReview::get_by_id(db, review_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("review not found"))?;
+    let _ = review.set_rejected(db).await;
+    Ok(auth::redirect(&format!("/admin/reviews/{review_id}")))
+}
+
+pub async fn reviews_clear(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    status: Option<&str>,
+) -> cot::Result<cot::http::Response<Body>> {
+    match status {
+        Some(s) if !s.is_empty() => {
+            PendingReview::delete_by_status(db, s)
+                .await
+                .map_err(|e| cot::Error::internal(format!("db error: {e}")))?;
+        }
+        _ => {
+            PendingReview::delete_all(db)
+                .await
+                .map_err(|e| cot::Error::internal(format!("db error: {e}")))?;
+        }
+    }
+    let redirect_url = match status {
+        Some(s) if !s.is_empty() => format!("/admin/reviews?status={s}"),
+        _ => "/admin/reviews".to_owned(),
+    };
+    Ok(auth::redirect(&redirect_url))
+}
+
+pub async fn review_requeue(
+    _admin: AuthenticatedUser,
+    db: &Database,
+    review_id: i64,
+) -> cot::Result<cot::http::Response<Body>> {
+    let mut review = PendingReview::get_by_id(db, review_id)
+        .await
+        .map_err(|e| cot::Error::internal(format!("db error: {e}")))?
+        .ok_or_else(|| cot::Error::internal("review not found"))?;
+    let _ = review.set_queued(db).await;
+    Ok(auth::redirect(&format!("/admin/reviews/{review_id}")))
+}
diff --git a/src/agent/cover_art.rs b/src/agent/cover_art.rs
new file mode 100644
index 0000000..4220a4a
--- /dev/null
+++ b/src/agent/cover_art.rs
@@ -0,0 +1,408 @@
+//! Cover art extraction and management.
+//!
+//! Sources (in priority order):
+//! 1. Standalone image files in the album folder (cover.jpg, folder.jpg, etc.)
+//! 2. Embedded cover art in audio file metadata (ID3 APIC, Vorbis METADATA_BLOCK_PICTURE, etc.)
+//!
+//! The first usable image found is saved as a MediaFile with file_type="cover_art"
+//! and linked to the Release via cover_file_id.
+
+use std::path::{Path, PathBuf};
+
+use sha2::{Digest, Sha256};
+
+/// Image data extracted from an audio file or found on disk.
+#[derive(Debug)]
+pub struct CoverImage {
+    pub data: Vec<u8>,
+    pub mime_type: String,
+    /// Where this image came from (for logging).
+    pub source: CoverSource,
+}
+
+#[derive(Debug)]
+pub enum CoverSource {
+    /// A standalone image file in the folder.
+    FolderFile(PathBuf),
+    /// Embedded in an audio file's metadata.
+    Embedded(PathBuf),
+}
+
+/// Well-known cover art filenames, in priority order.
+/// Case-insensitive matching is used.
+const COVER_FILENAMES: &[&str] = &[
+    "cover",
+    "folder",
+    "front",
+    "album",
+    "albumart",
+    "albumartsmall",
+    "thumb",
+    "artwork",
+];
+
+const IMAGE_EXTENSIONS: &[&str] = &["jpg", "jpeg", "png", "webp", "bmp", "gif"];
+
+fn is_image_file(name: &str) -> bool {
+    let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+    IMAGE_EXTENSIONS.contains(&ext.as_str())
+}
+
+fn mime_for_image(path: &Path) -> String {
+    let ext = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("")
+        .to_lowercase();
+    match ext.as_str() {
+        "jpg" | "jpeg" => "image/jpeg".to_string(),
+        "png" => "image/png".to_string(),
+        "webp" => "image/webp".to_string(),
+        "gif" => "image/gif".to_string(),
+        "bmp" => "image/bmp".to_string(),
+        _ => "application/octet-stream".to_string(),
+    }
+}
+
+/// Scan a folder for image files that look like cover art.
+///
+/// Returns image file paths sorted by priority:
+/// - Files with well-known names (cover.jpg, front.png, etc.) first
+/// - Then any other image files
+pub fn find_folder_images(folder: &Path) -> Vec<PathBuf> {
+    let entries = match std::fs::read_dir(folder) {
+        Ok(rd) => rd,
+        Err(_) => return Vec::new(),
+    };
+
+    let mut images: Vec<PathBuf> = entries
+        .filter_map(|e| e.ok())
+        .filter(|e| {
+            let name = e.file_name().to_string_lossy().into_owned();
+            !name.starts_with('.') && is_image_file(&name)
+        })
+        .map(|e| e.path())
+        .collect();
+
+    // Sort: well-known names first (by priority index), then alphabetically
+    images.sort_by(|a, b| {
+        let pri_a = cover_name_priority(a);
+        let pri_b = cover_name_priority(b);
+        pri_a.cmp(&pri_b).then_with(|| a.cmp(b))
+    });
+
+    images
+}
+
+/// Return a priority index for a filename (lower = higher priority).
+/// Well-known cover filenames get indices 0..N, unknown ones get usize::MAX.
+fn cover_name_priority(path: &Path) -> usize {
+    let stem = path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_lowercase();
+
+    for (i, &known) in COVER_FILENAMES.iter().enumerate() {
+        if stem == known {
+            return i;
+        }
+    }
+    usize::MAX
+}
+
+/// Try to find the best cover image for a folder of audio files.
+///
+/// Strategy:
+/// 1. Look for standalone image files in the folder (prioritized by filename).
+/// 2. Try to extract embedded cover art from each audio file.
+///
+/// Returns the first usable image found, or None.
+pub async fn find_best_cover(
+    folder: &Path,
+    audio_files: &[PathBuf],
+) -> Option<CoverImage> {
+    // Strategy 1: folder images
+    let folder_images = find_folder_images(folder);
+    for img_path in &folder_images {
+        match tokio::fs::read(img_path).await {
+            Ok(data) if !data.is_empty() => {
+                let mime = mime_for_image(img_path);
+                return Some(CoverImage {
+                    data,
+                    mime_type: mime,
+                    source: CoverSource::FolderFile(img_path.clone()),
+                });
+            }
+            _ => continue,
+        }
+    }
+
+    // Strategy 2: embedded cover art from audio files
+    for audio_path in audio_files {
+        let path = audio_path.to_path_buf();
+        let result = tokio::task::spawn_blocking(move || extract_embedded_cover(&path)).await;
+        if let Ok(Some(cover)) = result {
+            return Some(cover);
+        }
+    }
+
+    None
+}
+
+/// Extract embedded cover art from an audio file.
+///
+/// Tries Symphonia first (works for FLAC, OGG, etc.), then falls back to
+/// id3 crate for MP3 files.
+///
+/// Must be called from a blocking context.
+fn extract_embedded_cover(path: &Path) -> Option<CoverImage> {
+    // Try Symphonia visuals first
+    if let Some(cover) = extract_cover_symphonia(path) {
+        return Some(cover);
+    }
+
+    // Fallback: id3 for MP3
+    let is_mp3 = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.eq_ignore_ascii_case("mp3"))
+        .unwrap_or(false);
+
+    if is_mp3 {
+        return extract_cover_id3(path);
+    }
+
+    None
+}
+
+fn extract_cover_symphonia(path: &Path) -> Option<CoverImage> {
+    use symphonia::core::formats::FormatOptions;
+    use symphonia::core::io::MediaSourceStream;
+    use symphonia::core::meta::MetadataOptions;
+    use symphonia::core::probe::Hint;
+
+    let file = std::fs::File::open(path).ok()?;
+    let mss = MediaSourceStream::new(Box::new(file), Default::default());
+
+    let mut hint = Hint::new();
+    if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+        hint.with_extension(ext);
+    }
+
+    let mut probed = symphonia::default::get_probe()
+        .format(
+            &hint,
+            mss,
+            &FormatOptions {
+                enable_gapless: false,
+                ..Default::default()
+            },
+            &MetadataOptions::default(),
+        )
+        .ok()?;
+
+    // Check side-data metadata (ID3 before format)
+    if let Some(rev) = probed.metadata.get().as_ref().and_then(|m| m.current()) {
+        for visual in rev.visuals() {
+            if !visual.data.is_empty() {
+                let mime = if visual.media_type.is_empty() {
+                    guess_image_mime(&visual.data)
+                } else {
+                    visual.media_type.to_string()
+                };
+                return Some(CoverImage {
+                    data: visual.data.to_vec(),
+                    mime_type: mime,
+                    source: CoverSource::Embedded(path.to_path_buf()),
+                });
+            }
+        }
+    }
+
+    // Check format-level metadata
+    if let Some(rev) = probed.format.metadata().current() {
+        for visual in rev.visuals() {
+            if !visual.data.is_empty() {
+                let mime = if visual.media_type.is_empty() {
+                    guess_image_mime(&visual.data)
+                } else {
+                    visual.media_type.to_string()
+                };
+                return Some(CoverImage {
+                    data: visual.data.to_vec(),
+                    mime_type: mime,
+                    source: CoverSource::Embedded(path.to_path_buf()),
+                });
+            }
+        }
+    }
+
+    None
+}
+
+fn extract_cover_id3(path: &Path) -> Option<CoverImage> {
+    let tag = id3::Tag::read_from_path(path).ok()?;
+
+    // Prefer front cover (picture type 3), then any picture
+    let mut best: Option<&id3::frame::Picture> = None;
+    for pic in tag.pictures() {
+        if pic.picture_type == id3::frame::PictureType::CoverFront {
+            best = Some(pic);
+            break;
+        }
+        if best.is_none() {
+            best = Some(pic);
+        }
+    }
+
+    let pic = best?;
+    if pic.data.is_empty() {
+        return None;
+    }
+
+    let mime = if pic.mime_type.is_empty() || pic.mime_type == "image/" {
+        guess_image_mime(&pic.data)
+    } else {
+        pic.mime_type.clone()
+    };
+
+    Some(CoverImage {
+        data: pic.data.clone(),
+        mime_type: mime,
+        source: CoverSource::Embedded(path.to_path_buf()),
+    })
+}
+
+/// Guess MIME type from image magic bytes.
+fn guess_image_mime(data: &[u8]) -> String {
+    if data.starts_with(&[0xFF, 0xD8, 0xFF]) {
+        "image/jpeg".to_string()
+    } else if data.starts_with(&[0x89, 0x50, 0x4E, 0x47]) {
+        "image/png".to_string()
+    } else if data.starts_with(b"RIFF") && data.len() > 12 && &data[8..12] == b"WEBP" {
+        "image/webp".to_string()
+    } else if data.starts_with(b"GIF8") {
+        "image/gif".to_string()
+    } else if data.starts_with(&[0x42, 0x4D]) {
+        "image/bmp".to_string()
+    } else {
+        "image/jpeg".to_string() // default assumption
+    }
+}
+
+/// Compute SHA-256 hash of image data.
+pub fn hash_image(data: &[u8]) -> String {
+    let digest = Sha256::digest(data);
+    format!("{:x}", digest)
+}
+
+/// Extension for a MIME type.
+pub fn extension_for_mime(mime: &str) -> &str {
+    match mime {
+        "image/jpeg" => "jpg",
+        "image/png" => "png",
+        "image/webp" => "webp",
+        "image/gif" => "gif",
+        "image/bmp" => "bmp",
+        _ => "jpg",
+    }
+}
+
+/// Save cover image data to the storage directory and create a MediaFile record.
+///
+/// Returns the MediaFile ID on success.
+pub async fn save_cover_to_storage(
+    db: &cot::db::Database,
+    pool: &sqlx::PgPool,
+    storage_dir: &str,
+    artist_name: &str,
+    release_title: &str,
+    cover: &CoverImage,
+) -> anyhow::Result<i64> {
+    let hash = hash_image(&cover.data);
+
+    // Check if we already have this exact image in the DB
+    let existing: Option<(i64,)> = sqlx::query_as(
+        "SELECT id FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
+    )
+    .bind(&hash)
+    .fetch_optional(pool)
+    .await?;
+
+    if let Some((id,)) = existing {
+        return Ok(id);
+    }
+
+    let ext = extension_for_mime(&cover.mime_type);
+    let filename = format!("cover.{ext}");
+
+    let artist_dir = sanitize_dir_name(artist_name);
+    let album_dir = sanitize_dir_name(release_title);
+
+    let dest_dir = Path::new(storage_dir).join(&artist_dir).join(&album_dir);
+    tokio::fs::create_dir_all(&dest_dir).await?;
+
+    let dest_path = dest_dir.join(&filename);
+
+    // Write image data
+    tokio::fs::write(&dest_path, &cover.data).await?;
+
+    let relative_path = dest_path.to_string_lossy().to_string();
+    let file_size = cover.data.len() as i64;
+
+    let media_file = crate::music::MediaFile::create(
+        db,
+        "cover_art",
+        &relative_path,
+        &filename,
+        &cover.mime_type,
+        file_size,
+        &hash,
+        None,
+        None,
+        None,
+        None,
+    )
+    .await
+    .map_err(|e| anyhow::anyhow!("failed to create cover MediaFile: {e}"))?;
+
+    tracing::info!(
+        media_file_id = media_file.id_val(),
+        hash = %hash,
+        mime = %cover.mime_type,
+        size = file_size,
+        "Saved cover art"
+    );
+
+    Ok(media_file.id_val())
+}
+
+/// Set the cover_file_id on a release (if not already set).
+pub async fn assign_cover_to_release(
+    pool: &sqlx::PgPool,
+    release_id: i64,
+    cover_file_id: i64,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        "UPDATE furumusic__release SET cover_file_id = $1, updated_at = $3 WHERE id = $2 AND cover_file_id IS NULL",
+    )
+    .bind(cover_file_id)
+    .bind(release_id)
+    .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+fn sanitize_dir_name(name: &str) -> String {
+    name.chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' | '\0' => '_',
+            _ => c,
+        })
+        .collect::<String>()
+        .trim()
+        .trim_matches('.')
+        .to_owned()
+}
diff --git a/src/agent/dto.rs b/src/agent/dto.rs
new file mode 100644
index 0000000..90516e3
--- /dev/null
+++ b/src/agent/dto.rs
@@ -0,0 +1,65 @@
+use serde::{Deserialize, Serialize};
+
+/// Raw metadata extracted from audio file tags.
+#[derive(Debug, Default)]
+pub struct RawMetadata {
+    pub title: Option<String>,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub track_number: Option<u32>,
+    pub year: Option<u32>,
+    pub genre: Option<String>,
+    pub duration_secs: Option<f64>,
+}
+
+/// Hints parsed from the file path (directory structure + filename).
+#[derive(Debug, Default)]
+pub struct PathHints {
+    pub title: Option<String>,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub year: Option<i32>,
+    pub track_number: Option<i32>,
+}
+
+/// Normalized metadata returned by the LLM.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct NormalizedFields {
+    pub title: Option<String>,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub year: Option<i32>,
+    pub track_number: Option<i32>,
+    pub genre: Option<String>,
+    #[serde(default)]
+    pub featured_artists: Vec<String>,
+    pub release_type: Option<String>,
+    pub confidence: Option<f64>,
+    pub notes: Option<String>,
+}
+
+/// A similar artist found via pg_trgm fuzzy search.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SimilarArtist {
+    pub id: i64,
+    pub name: String,
+    pub similarity: f32,
+}
+
+/// A similar release found via pg_trgm fuzzy search.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SimilarRelease {
+    pub id: i64,
+    pub title: String,
+    pub year: Option<i32>,
+    pub similarity: f32,
+}
+
+/// Context about other files in the same folder (for the LLM).
+pub struct FolderContext {
+    pub folder_path: String,
+    pub folder_files: Vec<String>,
+    pub track_count: usize,
+}
diff --git a/src/agent/metadata.rs b/src/agent/metadata.rs
new file mode 100644
index 0000000..6983179
--- /dev/null
+++ b/src/agent/metadata.rs
@@ -0,0 +1,169 @@
+use std::path::Path;
+
+use symphonia::core::{
+    codecs::CODEC_TYPE_NULL,
+    formats::FormatOptions,
+    io::MediaSourceStream,
+    meta::{MetadataOptions, StandardTagKey},
+    probe::Hint,
+};
+
+use super::dto::RawMetadata;
+
+/// Extract metadata from an audio file.
+///
+/// For MP3, falls back to the `id3` crate when Symphonia cannot probe the file
+/// (e.g. ID3 tag with large embedded cover art exceeds Symphonia's probe limit).
+///
+/// Must be called from a blocking context (`spawn_blocking`).
+pub fn extract(path: &Path) -> anyhow::Result<RawMetadata> {
+    match extract_via_symphonia(path) {
+        Ok(meta) => Ok(meta),
+        Err(e) => {
+            let is_mp3 = path
+                .extension()
+                .and_then(|e| e.to_str())
+                .map(|e| e.eq_ignore_ascii_case("mp3"))
+                .unwrap_or(false);
+            if is_mp3 {
+                tracing::debug!(error = %e, "Symphonia failed on MP3, falling back to id3 crate");
+                extract_mp3_via_id3(path)
+            } else {
+                Err(e)
+            }
+        }
+    }
+}
+
+fn extract_via_symphonia(path: &Path) -> anyhow::Result<RawMetadata> {
+    let file = std::fs::File::open(path)?;
+    let mss = MediaSourceStream::new(Box::new(file), Default::default());
+
+    let mut hint = Hint::new();
+    if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+        hint.with_extension(ext);
+    }
+
+    let mut probed = symphonia::default::get_probe().format(
+        &hint,
+        mss,
+        &FormatOptions {
+            enable_gapless: false,
+            ..Default::default()
+        },
+        &MetadataOptions::default(),
+    )?;
+
+    let mut meta = RawMetadata::default();
+
+    // Check metadata side-data (e.g. ID3 tags probed before format)
+    if let Some(rev) = probed.metadata.get().as_ref().and_then(|m| m.current()) {
+        extract_tags(rev.tags(), &mut meta);
+    }
+
+    // Also check format-embedded metadata
+    if let Some(rev) = probed.format.metadata().current() {
+        if meta.title.is_none() {
+            extract_tags(rev.tags(), &mut meta);
+        }
+    }
+
+    // Duration
+    meta.duration_secs = probed
+        .format
+        .tracks()
+        .iter()
+        .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+        .and_then(|t| {
+            let n_frames = t.codec_params.n_frames?;
+            let tb = t.codec_params.time_base?;
+            Some(n_frames as f64 * tb.numer as f64 / tb.denom as f64)
+        });
+
+    Ok(meta)
+}
+
+/// Read MP3 tags via the `id3` crate. Duration is not available this way.
+fn extract_mp3_via_id3(path: &Path) -> anyhow::Result<RawMetadata> {
+    use id3::TagLike;
+
+    let tag =
+        id3::Tag::read_from_path(path).map_err(|e| anyhow::anyhow!("id3 read failed: {}", e))?;
+
+    let mut meta = RawMetadata::default();
+    meta.title = tag.title().map(|s| fix_encoding(s.to_owned()));
+    meta.artist = tag.artist().map(|s| fix_encoding(s.to_owned()));
+    meta.album = tag.album().map(|s| fix_encoding(s.to_owned()));
+    meta.year = tag.year().and_then(|y| u32::try_from(y).ok());
+    meta.track_number = tag.track();
+    meta.genre = tag.genre().map(|s: &str| fix_encoding(s.to_owned()));
+
+    Ok(meta)
+}
+
+fn extract_tags(tags: &[symphonia::core::meta::Tag], meta: &mut RawMetadata) {
+    for tag in tags {
+        let value = fix_encoding(tag.value.to_string());
+        if let Some(key) = tag.std_key {
+            match key {
+                StandardTagKey::TrackTitle => {
+                    if meta.title.is_none() {
+                        meta.title = Some(value);
+                    }
+                }
+                StandardTagKey::Artist | StandardTagKey::Performer => {
+                    if meta.artist.is_none() {
+                        meta.artist = Some(value);
+                    }
+                }
+                StandardTagKey::Album => {
+                    if meta.album.is_none() {
+                        meta.album = Some(value);
+                    }
+                }
+                StandardTagKey::TrackNumber => {
+                    if meta.track_number.is_none() {
+                        meta.track_number = value.parse().ok();
+                    }
+                }
+                StandardTagKey::Date | StandardTagKey::OriginalDate => {
+                    if meta.year.is_none() {
+                        meta.year = value[..4.min(value.len())].parse().ok();
+                    }
+                }
+                StandardTagKey::Genre => {
+                    if meta.genre.is_none() {
+                        meta.genre = Some(value);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+/// Heuristic to fix mojibake (CP1251 bytes interpreted as Latin-1/Windows-1252).
+fn fix_encoding(s: String) -> String {
+    let bytes: Vec<u8> = s
+        .chars()
+        .map(|c| c as u32)
+        .filter(|&c| c <= 255)
+        .map(|c| c as u8)
+        .collect();
+
+    if bytes.len() != s.chars().count() {
+        return s;
+    }
+
+    let has_mojibake = bytes.iter().any(|&b| b >= 0xC0);
+    if !has_mojibake {
+        return s;
+    }
+
+    let (decoded, _, errors) = encoding_rs::WINDOWS_1251.decode(&bytes);
+    if errors {
+        return s;
+    }
+
+    decoded.into_owned()
+}
diff --git a/src/agent/mod.rs b/src/agent/mod.rs
new file mode 100644
index 0000000..f35655f
--- /dev/null
+++ b/src/agent/mod.rs
@@ -0,0 +1,156 @@
+pub mod cover_art;
+pub mod dto;
+pub mod metadata;
+pub mod mover;
+pub mod normalize;
+pub mod path_hints;
+pub mod rag;
+
+use serde::Deserialize;
+
+// ---------------------------------------------------------------------------
+// LLM health probe — called from the admin settings page
+// ---------------------------------------------------------------------------
+
+/// Result of probing the LLM API.
+#[derive(Debug, Default)]
+pub struct AgentProbeResult {
+    pub ok: bool,
+    pub model_intro: String,
+    pub model_name: String,
+    pub prompt_tokens: Option<u32>,
+    pub completion_tokens: Option<u32>,
+    pub tokens_per_sec: Option<f64>,
+    pub latency_ms: u64,
+    pub error: String,
+}
+
+/// Send a lightweight "introduce yourself" prompt to the LLM and return the
+/// response together with timing / usage statistics when available.
+pub async fn probe_llm(
+    llm_url: &str,
+    llm_model: &str,
+    llm_auth: &str,
+) -> AgentProbeResult {
+    let start = std::time::Instant::now();
+
+    let client = match reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(30))
+        .build()
+    {
+        Ok(c) => c,
+        Err(e) => {
+            return AgentProbeResult {
+                error: format!("failed to create HTTP client: {e}"),
+                ..Default::default()
+            };
+        }
+    };
+
+    let body = serde_json::json!({
+        "model": llm_model,
+        "messages": [
+            {
+                "role": "user",
+                "content": "Introduce yourself briefly: what model are you, who made you? Reply in 1–2 sentences."
+            }
+        ],
+        "stream": false,
+        "temperature": 0.3,
+        "max_tokens": 256
+    });
+
+    let url = format!("{}/v1/chat/completions", llm_url.trim_end_matches('/'));
+    let mut req = client.post(&url).json(&body);
+    if !llm_auth.is_empty() {
+        req = req.header("Authorization", llm_auth);
+    }
+
+    let resp = match req.send().await {
+        Ok(r) => r,
+        Err(e) => {
+            return AgentProbeResult {
+                latency_ms: start.elapsed().as_millis() as u64,
+                error: format!("connection failed: {e}"),
+                ..Default::default()
+            };
+        }
+    };
+
+    let elapsed = start.elapsed();
+    let latency_ms = elapsed.as_millis() as u64;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let body_text = resp.text().await.unwrap_or_default();
+        return AgentProbeResult {
+            latency_ms,
+            error: format!("HTTP {status}: {}", &body_text[..body_text.len().min(300)]),
+            ..Default::default()
+        };
+    }
+
+    #[derive(Deserialize)]
+    struct ProbeResponse {
+        choices: Option<Vec<ProbeChoice>>,
+        model: Option<String>,
+        usage: Option<ProbeUsage>,
+    }
+    #[derive(Deserialize)]
+    struct ProbeChoice {
+        message: Option<ProbeMessage>,
+    }
+    #[derive(Deserialize)]
+    struct ProbeMessage {
+        content: Option<String>,
+    }
+    #[derive(Deserialize)]
+    struct ProbeUsage {
+        prompt_tokens: Option<u32>,
+        completion_tokens: Option<u32>,
+    }
+
+    let raw: ProbeResponse = match resp.json().await {
+        Ok(r) => r,
+        Err(e) => {
+            return AgentProbeResult {
+                latency_ms,
+                error: format!("failed to parse response: {e}"),
+                ..Default::default()
+            };
+        }
+    };
+
+    let model_intro = raw
+        .choices
+        .as_ref()
+        .and_then(|c| c.first())
+        .and_then(|c| c.message.as_ref())
+        .and_then(|m| m.content.clone())
+        .unwrap_or_default();
+
+    let model_name = raw.model.unwrap_or_default();
+
+    let prompt_tokens = raw.usage.as_ref().and_then(|u| u.prompt_tokens);
+    let completion_tokens = raw.usage.as_ref().and_then(|u| u.completion_tokens);
+
+    // Compute tokens/sec from completion tokens and wall time
+    let tokens_per_sec = completion_tokens.map(|ct| {
+        if elapsed.as_secs_f64() > 0.0 {
+            ct as f64 / elapsed.as_secs_f64()
+        } else {
+            0.0
+        }
+    });
+
+    AgentProbeResult {
+        ok: true,
+        model_intro,
+        model_name,
+        prompt_tokens,
+        completion_tokens,
+        tokens_per_sec,
+        latency_ms,
+        error: String::new(),
+    }
+}
diff --git a/src/agent/mover.rs b/src/agent/mover.rs
new file mode 100644
index 0000000..d630a15
--- /dev/null
+++ b/src/agent/mover.rs
@@ -0,0 +1,66 @@
+use std::path::{Path, PathBuf};
+
+pub enum MoveOutcome {
+    /// File was moved/renamed to destination.
+    Moved(PathBuf),
+    /// Destination already existed; inbox duplicate was removed.
+    Merged(PathBuf),
+}
+
+/// Move a file from inbox to the permanent storage directory.
+///
+/// Creates the directory structure: `storage_dir/artist/album/filename`
+///
+/// If `rename` fails (cross-device), falls back to copy + remove.
+/// If the destination already exists the inbox copy is removed and
+/// `MoveOutcome::Merged` is returned.
+pub async fn move_to_storage(
+    storage_dir: &Path,
+    artist: &str,
+    album: &str,
+    filename: &str,
+    source: &Path,
+) -> anyhow::Result<MoveOutcome> {
+    let artist_dir = sanitize_dir_name(artist);
+    let album_dir = sanitize_dir_name(album);
+
+    let dest_dir = storage_dir.join(&artist_dir).join(&album_dir);
+    tokio::fs::create_dir_all(&dest_dir).await?;
+
+    let dest = dest_dir.join(filename);
+
+    // File already at destination — remove the inbox duplicate
+    if dest.exists() {
+        if source.exists() {
+            tokio::fs::remove_file(source).await?;
+            tracing::info!(from = ?source, to = ?dest, "merged duplicate into existing storage file");
+        }
+        return Ok(MoveOutcome::Merged(dest));
+    }
+
+    // Try atomic rename first (same filesystem)
+    match tokio::fs::rename(source, &dest).await {
+        Ok(()) => {}
+        Err(_) => {
+            // Cross-device: copy then remove
+            tokio::fs::copy(source, &dest).await?;
+            tokio::fs::remove_file(source).await?;
+        }
+    }
+
+    tracing::info!(from = ?source, to = ?dest, "moved file to storage");
+    Ok(MoveOutcome::Moved(dest))
+}
+
+/// Remove characters that are unsafe for directory names.
+fn sanitize_dir_name(name: &str) -> String {
+    name.chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' | '\0' => '_',
+            _ => c,
+        })
+        .collect::<String>()
+        .trim()
+        .trim_matches('.')
+        .to_owned()
+}
diff --git a/src/agent/normalize.rs b/src/agent/normalize.rs
new file mode 100644
index 0000000..8fd3090
--- /dev/null
+++ b/src/agent/normalize.rs
@@ -0,0 +1,483 @@
+use serde::{Deserialize, Serialize};
+
+use super::dto::{FolderContext, NormalizedFields, PathHints, RawMetadata, SimilarArtist, SimilarRelease};
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/// A single message in the chat history.
+#[derive(Clone, Serialize)]
+pub struct ChatMessage {
+    pub role: String,
+    pub content: String,
+}
+
+#[derive(Serialize)]
+struct ChatRequest {
+    model: String,
+    messages: Vec<ChatMessage>,
+    response_format: ChatResponseFormat,
+    stream: bool,
+    temperature: f64,
+}
+
+#[derive(Serialize)]
+struct ChatResponseFormat {
+    #[serde(rename = "type")]
+    kind: String,
+}
+
+#[derive(Deserialize)]
+struct ChatResponse {
+    model: Option<String>,
+    choices: Vec<ChatChoice>,
+    usage: Option<ChatUsage>,
+}
+
+#[derive(Deserialize)]
+struct ChatChoice {
+    message: ChatResponseMessage,
+}
+
+#[derive(Deserialize)]
+struct ChatResponseMessage {
+    content: String,
+}
+
+#[derive(Deserialize, Default)]
+struct ChatUsage {
+    prompt_tokens: Option<u32>,
+    completion_tokens: Option<u32>,
+}
+
+async fn call_llm_chat(
+    base_url: &str,
+    model: &str,
+    messages: &[ChatMessage],
+    auth: Option<&str>,
+) -> anyhow::Result<(String, String, ChatUsage)> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(600))
+        .build()?;
+
+    let request = ChatRequest {
+        model: model.to_owned(),
+        messages: messages.to_vec(),
+        response_format: ChatResponseFormat {
+            kind: "json_object".to_owned(),
+        },
+        stream: false,
+        temperature: 0.1,
+    };
+
+    let url = format!("{}/v1/chat/completions", base_url.trim_end_matches('/'));
+    tracing::info!(
+        %url,
+        model,
+        message_count = messages.len(),
+        "Calling LLM API (chat mode)..."
+    );
+
+    let start = std::time::Instant::now();
+    let mut req = client.post(&url).json(&request);
+    if let Some(auth_header) = auth {
+        req = req.header("Authorization", auth_header);
+    }
+    let resp = req.send().await?;
+    let elapsed = start.elapsed();
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        tracing::error!(%status, body = &body[..body.len().min(500)], "LLM API error");
+        anyhow::bail!("LLM returned {}: {}", status, body);
+    }
+
+    let chat_resp: ChatResponse = resp.json().await?;
+    let resp_model = chat_resp.model.unwrap_or_else(|| model.to_owned());
+    let usage = chat_resp.usage.unwrap_or_default();
+    let content = chat_resp
+        .choices
+        .into_iter()
+        .next()
+        .ok_or_else(|| anyhow::anyhow!("LLM returned empty choices"))?
+        .message
+        .content;
+
+    tracing::info!(
+        elapsed_ms = elapsed.as_millis() as u64,
+        response_len = content.len(),
+        prompt_tokens = usage.prompt_tokens.unwrap_or(0),
+        completion_tokens = usage.completion_tokens.unwrap_or(0),
+        model = %resp_model,
+        "LLM response received"
+    );
+    tracing::debug!(raw_response = %content, "LLM raw output");
+
+    Ok((content, resp_model, usage))
+}
+
+// ---------------------------------------------------------------------------
+// Batch normalize — process multiple files in one LLM call
+// ---------------------------------------------------------------------------
+
+/// Input for one file in a batch normalize call.
+pub struct BatchFileInput {
+    pub filename: String,
+    pub raw: RawMetadata,
+    pub hints: PathHints,
+}
+
+/// Result of a batch normalize call.
+pub struct BatchNormalizeResult {
+    /// (filename, normalized_fields) pairs.
+    pub results: Vec<(String, NormalizedFields)>,
+    pub model: String,
+    pub prompt_tokens: u64,
+    pub completion_tokens: u64,
+    pub duration_ms: u64,
+}
+
+/// Estimate the token count for a batch of files.
+/// Uses the rough heuristic of 1 token per 4 characters.
+fn estimate_batch_tokens(
+    system_prompt: &str,
+    files: &[BatchFileInput],
+    similar_artists: &[SimilarArtist],
+    similar_releases: &[SimilarRelease],
+    folder_ctx: Option<&FolderContext>,
+) -> u64 {
+    let system_tokens = system_prompt.len() as u64 / 4;
+
+    // Shared context (RAG + folder) — sent once
+    let mut shared_chars: u64 = 0;
+    for a in similar_artists {
+        shared_chars += 40 + a.name.len() as u64;
+    }
+    for r in similar_releases {
+        shared_chars += 50 + r.title.len() as u64;
+    }
+    if let Some(ctx) = folder_ctx {
+        shared_chars += 60 + ctx.folder_path.len() as u64;
+        for f in &ctx.folder_files {
+            shared_chars += 4 + f.len() as u64;
+        }
+    }
+    let shared_tokens = shared_chars / 4;
+
+    // Per-file: metadata input + expected response
+    let mut per_file_tokens: u64 = 0;
+    for f in files {
+        let mut chars: u64 = 40 + f.filename.len() as u64; // header
+        if let Some(v) = &f.raw.title { chars += 10 + v.len() as u64; }
+        if let Some(v) = &f.raw.artist { chars += 12 + v.len() as u64; }
+        if let Some(v) = &f.raw.album { chars += 12 + v.len() as u64; }
+        if f.raw.year.is_some() { chars += 12; }
+        if f.raw.track_number.is_some() { chars += 18; }
+        if let Some(v) = &f.raw.genre { chars += 10 + v.len() as u64; }
+        // hints
+        if let Some(v) = &f.hints.artist { chars += 16 + v.len() as u64; }
+        if let Some(v) = &f.hints.album { chars += 16 + v.len() as u64; }
+        if let Some(v) = &f.hints.title { chars += 15 + v.len() as u64; }
+        if f.hints.year.is_some() { chars += 14; }
+        if f.hints.track_number.is_some() { chars += 20; }
+        per_file_tokens += chars / 4;
+        // Expected response per file (~150 tokens)
+        per_file_tokens += 150;
+    }
+
+    system_tokens + shared_tokens + per_file_tokens
+}
+
+/// Build the user message for a batch of files.
+fn build_batch_user_message(
+    files: &[BatchFileInput],
+    similar_artists: &[SimilarArtist],
+    similar_releases: &[SimilarRelease],
+    folder_ctx: Option<&FolderContext>,
+) -> String {
+    let mut msg = String::with_capacity(4096);
+
+    // Shared context first
+    if let Some(ctx) = folder_ctx {
+        msg.push_str("## Folder context\n");
+        msg.push_str(&format!("Folder path: \"{}\"\n", ctx.folder_path));
+        msg.push_str(&format!("Total files in folder: {}\n\n", ctx.track_count));
+    }
+
+    if !similar_artists.is_empty() {
+        msg.push_str("## Existing artists in database\n");
+        for a in similar_artists {
+            msg.push_str(&format!("- \"{}\" (similarity: {:.2})\n", a.name, a.similarity));
+        }
+        msg.push('\n');
+    }
+
+    if !similar_releases.is_empty() {
+        msg.push_str("## Existing releases in database\n");
+        for r in similar_releases {
+            let year_str = r.year.map(|y| format!(", year: {y}")).unwrap_or_default();
+            msg.push_str(&format!("- \"{}\" (similarity: {:.2}{})\n", r.title, r.similarity, year_str));
+        }
+        msg.push('\n');
+    }
+
+    // Per-file metadata
+    msg.push_str(&format!("## Files to process ({})\n\n", files.len()));
+
+    for f in files {
+        msg.push_str(&format!("### {}\n", f.filename));
+
+        if let Some(v) = &f.raw.title { msg.push_str(&format!("Title: \"{v}\"\n")); }
+        if let Some(v) = &f.raw.artist { msg.push_str(&format!("Artist: \"{v}\"\n")); }
+        if let Some(v) = &f.raw.album { msg.push_str(&format!("Release: \"{v}\"\n")); }
+        if let Some(v) = f.raw.year { msg.push_str(&format!("Year: {v}\n")); }
+        if let Some(v) = f.raw.track_number { msg.push_str(&format!("Track: {v}\n")); }
+        if let Some(v) = &f.raw.genre { msg.push_str(&format!("Genre: \"{v}\"\n")); }
+
+        // Path hints (only if different from tag metadata)
+        let has_hints = f.hints.artist.is_some()
+            || f.hints.album.is_some()
+            || f.hints.title.is_some()
+            || f.hints.year.is_some()
+            || f.hints.track_number.is_some();
+        if has_hints {
+            if let Some(v) = &f.hints.artist { msg.push_str(&format!("Path artist: \"{v}\"\n")); }
+            if let Some(v) = &f.hints.album { msg.push_str(&format!("Path release: \"{v}\"\n")); }
+            if let Some(v) = &f.hints.title { msg.push_str(&format!("Path title: \"{v}\"\n")); }
+            if let Some(v) = f.hints.year { msg.push_str(&format!("Path year: {v}\n")); }
+            if let Some(v) = f.hints.track_number { msg.push_str(&format!("Path track: {v}\n")); }
+        }
+        msg.push('\n');
+    }
+
+    msg
+}
+
+/// Normalize a batch of files in one LLM call.
+/// If the batch is too large for the context window, it is automatically
+/// split in half and each half is processed recursively.
+pub async fn normalize_batch(
+    llm_url: &str,
+    llm_model: &str,
+    llm_auth: &str,
+    system_prompt: &str,
+    context_limit: u64,
+    files: Vec<BatchFileInput>,
+    similar_artists: &[SimilarArtist],
+    similar_releases: &[SimilarRelease],
+    folder_ctx: Option<&FolderContext>,
+) -> anyhow::Result<BatchNormalizeResult> {
+    // Estimate tokens
+    let estimated = estimate_batch_tokens(
+        system_prompt, &files, similar_artists, similar_releases, folder_ctx,
+    );
+
+    // If over 80% of context limit and more than 1 file, split
+    let limit_80 = context_limit * 80 / 100;
+    if estimated > limit_80 && files.len() > 1 {
+        tracing::info!(
+            estimated_tokens = estimated,
+            context_limit,
+            file_count = files.len(),
+            "Batch too large, splitting in half"
+        );
+        let mid = files.len() / 2;
+        let mut files_vec = files;
+        let right = files_vec.split_off(mid);
+        let left = files_vec;
+
+        let left_result = Box::pin(normalize_batch(
+            llm_url, llm_model, llm_auth, system_prompt, context_limit,
+            left, similar_artists, similar_releases, folder_ctx,
+        )).await?;
+
+        let right_result = Box::pin(normalize_batch(
+            llm_url, llm_model, llm_auth, system_prompt, context_limit,
+            right, similar_artists, similar_releases, folder_ctx,
+        )).await?;
+
+        // Merge results
+        let mut results = left_result.results;
+        results.extend(right_result.results);
+        return Ok(BatchNormalizeResult {
+            results,
+            model: left_result.model,
+            prompt_tokens: left_result.prompt_tokens + right_result.prompt_tokens,
+            completion_tokens: left_result.completion_tokens + right_result.completion_tokens,
+            duration_ms: left_result.duration_ms + right_result.duration_ms,
+        });
+    }
+
+    // Build and send
+    let user_message = build_batch_user_message(
+        &files, similar_artists, similar_releases, folder_ctx,
+    );
+
+    let messages = vec![
+        ChatMessage { role: "system".into(), content: system_prompt.to_owned() },
+        ChatMessage { role: "user".into(), content: user_message },
+    ];
+
+    let start = std::time::Instant::now();
+    let call_result = call_llm_chat(
+        llm_url, llm_model, &messages,
+        if llm_auth.is_empty() { None } else { Some(llm_auth) },
+    ).await;
+    let duration_ms = start.elapsed().as_millis() as u64;
+
+    // If LLM error and batch > 1, try splitting (handles context overflow errors)
+    let (response_text, resp_model, usage) = match call_result {
+        Ok(r) => r,
+        Err(e) if files.len() > 1 => {
+            let err_str = e.to_string().to_lowercase();
+            let is_context_error = err_str.contains("context")
+                || err_str.contains("too long")
+                || err_str.contains("maximum")
+                || err_str.contains("length")
+                || err_str.contains("token");
+            if is_context_error {
+                tracing::warn!(
+                    file_count = files.len(),
+                    "LLM error suggests context overflow, splitting batch: {e}"
+                );
+                let mid = files.len() / 2;
+                let mut files_vec = files;
+                let right = files_vec.split_off(mid);
+                let left = files_vec;
+
+                let left_result = Box::pin(normalize_batch(
+                    llm_url, llm_model, llm_auth, system_prompt, context_limit,
+                    left, similar_artists, similar_releases, folder_ctx,
+                )).await?;
+                let right_result = Box::pin(normalize_batch(
+                    llm_url, llm_model, llm_auth, system_prompt, context_limit,
+                    right, similar_artists, similar_releases, folder_ctx,
+                )).await?;
+
+                let mut results = left_result.results;
+                results.extend(right_result.results);
+                return Ok(BatchNormalizeResult {
+                    results,
+                    model: left_result.model,
+                    prompt_tokens: left_result.prompt_tokens + right_result.prompt_tokens,
+                    completion_tokens: left_result.completion_tokens + right_result.completion_tokens,
+                    duration_ms: left_result.duration_ms + right_result.duration_ms,
+                });
+            }
+            return Err(e);
+        }
+        Err(e) => return Err(e),
+    };
+
+    let prompt_tokens = usage.prompt_tokens.unwrap_or(0) as u64;
+    let completion_tokens = usage.completion_tokens.unwrap_or(0) as u64;
+
+    // Parse batch response
+    let results = parse_batch_response(&response_text, &files)?;
+
+    Ok(BatchNormalizeResult {
+        results,
+        model: resp_model,
+        prompt_tokens,
+        completion_tokens,
+        duration_ms,
+    })
+}
+
+/// Parse a batch JSON array response from the LLM.
+/// Returns (filename, NormalizedFields) pairs.
+/// Handles: clean JSON array, markdown-fenced JSON, and wrapped `{"results": [...]}`.
+fn parse_batch_response(
+    response: &str,
+    files: &[BatchFileInput],
+) -> anyhow::Result<Vec<(String, NormalizedFields)>> {
+    let cleaned = response.trim();
+
+    // Strip markdown code fences if present
+    let json_str = if cleaned.starts_with("```") {
+        let start = cleaned.find('[')
+            .or_else(|| cleaned.find('{'))
+            .unwrap_or(0);
+        let end_bracket = cleaned.rfind(']').map(|i| i + 1);
+        let end_brace = cleaned.rfind('}').map(|i| i + 1);
+        let end = end_bracket.or(end_brace).unwrap_or(cleaned.len());
+        &cleaned[start..end]
+    } else {
+        cleaned
+    };
+
+    #[derive(Deserialize)]
+    struct BatchLlmOutput {
+        filename: Option<String>,
+        artist: Option<String>,
+        album: Option<String>,
+        title: Option<String>,
+        year: Option<i32>,
+        track_number: Option<i32>,
+        genre: Option<String>,
+        #[serde(default)]
+        featured_artists: Vec<String>,
+        release_type: Option<String>,
+        confidence: Option<f64>,
+        notes: Option<String>,
+    }
+
+    // Try parsing as array first, then as {"results": [...]} wrapper
+    let items: Vec<BatchLlmOutput> = if json_str.starts_with('[') {
+        serde_json::from_str(json_str)
+    } else {
+        // Try as wrapper object with a "results" or "files" key
+        #[derive(Deserialize)]
+        struct Wrapper {
+            #[serde(alias = "files")]
+            results: Vec<BatchLlmOutput>,
+        }
+        serde_json::from_str::<Wrapper>(json_str).map(|w| w.results)
+    }
+    .map_err(|e| {
+        anyhow::anyhow!(
+            "Failed to parse batch LLM response: {} — raw: {}",
+            e,
+            &response[..response.len().min(500)]
+        )
+    })?;
+
+    // Build a map of filename → NormalizedFields
+    let mut results = Vec::with_capacity(files.len());
+    let mut matched = std::collections::HashSet::new();
+
+    for item in &items {
+        let filename = match &item.filename {
+            Some(f) => f.clone(),
+            None => continue,
+        };
+        let fields = NormalizedFields {
+            title: item.title.clone(),
+            artist: item.artist.clone(),
+            album: item.album.clone(),
+            year: item.year,
+            track_number: item.track_number,
+            genre: item.genre.clone(),
+            featured_artists: item.featured_artists.clone(),
+            release_type: item.release_type.clone(),
+            confidence: item.confidence,
+            notes: item.notes.clone(),
+        };
+        matched.insert(filename.clone());
+        results.push((filename, fields));
+    }
+
+    // Warn about files the LLM missed
+    for f in files {
+        if !matched.contains(&f.filename) {
+            tracing::warn!(
+                filename = %f.filename,
+                "LLM batch response missing result for file"
+            );
+        }
+    }
+
+    Ok(results)
+}
diff --git a/src/agent/path_hints.rs b/src/agent/path_hints.rs
new file mode 100644
index 0000000..75371ca
--- /dev/null
+++ b/src/agent/path_hints.rs
@@ -0,0 +1,197 @@
+use std::path::Path;
+
+use super::dto::PathHints;
+
+/// Parse metadata hints from the file path relative to the inbox directory.
+///
+/// Recognized patterns:
+///   Artist/Album/01 - Title.ext
+///   Artist/Album (Year)/01 - Title.ext
+///   Artist/(Year) Album/01 - Title.ext
+///   Artist/Album [Year]/01 - Title.ext
+///   01 - Title.ext  (flat, no artist/album)
+pub fn parse(relative_path: &Path) -> PathHints {
+    let components: Vec<&str> = relative_path
+        .components()
+        .filter_map(|c| c.as_os_str().to_str())
+        .collect();
+
+    let mut hints = PathHints::default();
+
+    let filename = components.last().copied().unwrap_or("");
+    let stem = Path::new(filename)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("");
+
+    // Parse track number and title from filename
+    parse_filename(stem, &mut hints);
+
+    match components.len() {
+        // Artist/Album/file.ext
+        3.. => {
+            hints.artist = Some(components[0].to_owned());
+
+            let album_raw = components[1];
+            let (album, year) = parse_album_with_year(album_raw);
+            hints.album = Some(album);
+            if year.is_some() {
+                hints.year = year;
+            }
+        }
+        // Album/file.ext (or Artist/file.ext — ambiguous, treat as album)
+        2 => {
+            let dir = components[0];
+            let (name, year) = parse_album_with_year(dir);
+            hints.album = Some(name);
+            if year.is_some() {
+                hints.year = year;
+            }
+        }
+        // Just file.ext
+        _ => {}
+    }
+
+    hints
+}
+
+/// Try to extract track number and title from a filename stem.
+///
+/// Patterns: "01 - Title", "01. Title", "1 Title", "Title"
+fn parse_filename(stem: &str, hints: &mut PathHints) {
+    let trimmed = stem.trim();
+
+    // Try "NN - Title" or "NN. Title"
+    if let Some(rest) = try_strip_track_prefix(trimmed) {
+        let (num_str, title) = rest;
+        if let Ok(num) = num_str.parse::<i32>() {
+            hints.track_number = Some(num);
+            if !title.is_empty() {
+                hints.title = Some(title.to_owned());
+            }
+            return;
+        }
+    }
+
+    // No track number found, use full stem as title
+    if !trimmed.is_empty() {
+        hints.title = Some(trimmed.to_owned());
+    }
+}
+
+/// Try to parse "NN - Rest" or "NN. Rest" from a string.
+/// Returns (number_str, rest) if successful.
+fn try_strip_track_prefix(s: &str) -> Option<(&str, &str)> {
+    let digit_end = s.find(|c: char| !c.is_ascii_digit())?;
+    if digit_end == 0 {
+        return None;
+    }
+    let num_str = &s[..digit_end];
+    let rest = s[digit_end..].trim_start();
+
+    let title = if let Some(stripped) = rest.strip_prefix("- ") {
+        stripped.trim()
+    } else if let Some(stripped) = rest.strip_prefix(". ") {
+        stripped.trim()
+    } else if let Some(stripped) = rest.strip_prefix('.') {
+        stripped.trim()
+    } else {
+        rest
+    };
+
+    Some((num_str, title))
+}
+
+/// Extract album name and optional year from directory name.
+///
+/// Patterns: "Album (2001)", "(2001) Album", "Album [2001]", "Album"
+fn parse_album_with_year(dir: &str) -> (String, Option<i32>) {
+    // Try "Album (YYYY)" or "Album [YYYY]"
+    for (open, close) in [('(', ')'), ('[', ']')] {
+        if let Some(start) = dir.rfind(open) {
+            if let Some(end) = dir[start..].find(close) {
+                let inside = &dir[start + 1..start + end];
+                if let Ok(year) = inside.trim().parse::<i32>() {
+                    if (1900..=2100).contains(&year) {
+                        let album = format!(
+                            "{}{}",
+                            &dir[..start].trim(),
+                            &dir[start + end + 1..].trim()
+                        );
+                        let album = album.trim().to_owned();
+                        return (album, Some(year));
+                    }
+                }
+            }
+        }
+    }
+
+    // Try "(YYYY) Album"
+    if dir.starts_with('(') {
+        if let Some(end) = dir.find(')') {
+            let inside = &dir[1..end];
+            if let Ok(year) = inside.trim().parse::<i32>() {
+                if (1900..=2100).contains(&year) {
+                    let album = dir[end + 1..].trim().to_owned();
+                    return (album, Some(year));
+                }
+            }
+        }
+    }
+
+    (dir.to_owned(), None)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_artist_album_track() {
+        let p = PathBuf::from("Pink Floyd/Wish You Were Here (1975)/03 - Have a Cigar.flac");
+        let h = parse(&p);
+        assert_eq!(h.artist.as_deref(), Some("Pink Floyd"));
+        assert_eq!(h.album.as_deref(), Some("Wish You Were Here"));
+        assert_eq!(h.year, Some(1975));
+        assert_eq!(h.track_number, Some(3));
+        assert_eq!(h.title.as_deref(), Some("Have a Cigar"));
+    }
+
+    #[test]
+    fn test_year_prefix() {
+        let p = PathBuf::from("Artist/(2020) Album Name/01. Song.flac");
+        let h = parse(&p);
+        assert_eq!(h.artist.as_deref(), Some("Artist"));
+        assert_eq!(h.album.as_deref(), Some("Album Name"));
+        assert_eq!(h.year, Some(2020));
+        assert_eq!(h.track_number, Some(1));
+        assert_eq!(h.title.as_deref(), Some("Song"));
+    }
+
+    #[test]
+    fn test_flat_file() {
+        let p = PathBuf::from("05 - Something.mp3");
+        let h = parse(&p);
+        assert_eq!(h.artist, None);
+        assert_eq!(h.album, None);
+        assert_eq!(h.track_number, Some(5));
+        assert_eq!(h.title.as_deref(), Some("Something"));
+    }
+
+    #[test]
+    fn test_no_track_number() {
+        let p = PathBuf::from("Artist/Album/Song Name.flac");
+        let h = parse(&p);
+        assert_eq!(h.track_number, None);
+        assert_eq!(h.title.as_deref(), Some("Song Name"));
+    }
+
+    #[test]
+    fn test_square_bracket_year() {
+        let p = PathBuf::from("Band/Album [1999]/track.flac");
+        let h = parse(&p);
+        assert_eq!(h.album.as_deref(), Some("Album"));
+        assert_eq!(h.year, Some(1999));
+    }
+}
diff --git a/src/agent/rag.rs b/src/agent/rag.rs
new file mode 100644
index 0000000..5c14a44
--- /dev/null
+++ b/src/agent/rag.rs
@@ -0,0 +1,97 @@
+use sqlx::PgPool;
+
+use super::dto::{SimilarArtist, SimilarRelease};
+
+/// Find artists with similar names using pg_trgm.
+/// Short names (<3 chars) fall back to ILIKE prefix match.
+pub async fn find_similar_artists(
+    pool: &PgPool,
+    name: &str,
+    limit: i32,
+) -> anyhow::Result<Vec<SimilarArtist>> {
+    if name.chars().count() < 3 {
+        let rows: Vec<(i64, String, f32)> = sqlx::query_as(
+            "SELECT id, name, 1.0::real AS similarity FROM furumusic__artist \
+             WHERE name_sort ILIKE $1 || '%' ORDER BY name LIMIT $2",
+        )
+        .bind(name.to_lowercase())
+        .bind(limit)
+        .fetch_all(pool)
+        .await?;
+        Ok(rows
+            .into_iter()
+            .map(|(id, name, similarity)| SimilarArtist {
+                id,
+                name,
+                similarity,
+            })
+            .collect())
+    } else {
+        let rows: Vec<(i64, String, f32)> = sqlx::query_as(
+            r#"SELECT id, name, MAX(sim) AS similarity FROM (
+                SELECT id, name, similarity(name_sort, $1) AS sim
+                FROM furumusic__artist WHERE name_sort % $1
+                UNION ALL
+                SELECT id, name, 0.01::real AS sim
+                FROM furumusic__artist WHERE name_sort ILIKE '%' || $1 || '%'
+            ) sub GROUP BY id, name ORDER BY similarity DESC LIMIT $2"#,
+        )
+        .bind(name.to_lowercase())
+        .bind(limit)
+        .fetch_all(pool)
+        .await?;
+        Ok(rows
+            .into_iter()
+            .map(|(id, name, similarity)| SimilarArtist {
+                id,
+                name,
+                similarity,
+            })
+            .collect())
+    }
+}
+
+/// Find releases with similar titles using pg_trgm.
+pub async fn find_similar_releases(
+    pool: &PgPool,
+    title: &str,
+    limit: i32,
+) -> anyhow::Result<Vec<SimilarRelease>> {
+    let rows: Vec<(i64, String, Option<i32>, f32)> = sqlx::query_as(
+        "SELECT id, title, year, similarity(title_sort, $1) AS similarity \
+         FROM furumusic__release WHERE title_sort % $1 \
+         ORDER BY similarity DESC LIMIT $2",
+    )
+    .bind(title.to_lowercase())
+    .bind(limit)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(id, title, year, similarity)| SimilarRelease {
+            id,
+            title,
+            year,
+            similarity,
+        })
+        .collect())
+}
+
+/// Check if a file with the given SHA-256 hash is actively used in the library.
+/// Returns true only if a media_file with this hash exists AND at least one
+/// track references it via audio_file_id.  Orphaned media_files (no track)
+/// are ignored so that re-discovery is possible after the user deletes
+/// artists/releases/tracks.
+pub async fn file_hash_exists(pool: &PgPool, sha256: &str) -> anyhow::Result<bool> {
+    let row: (bool,) = sqlx::query_as(
+        "SELECT EXISTS(\
+            SELECT 1 FROM furumusic__media_file mf \
+            JOIN furumusic__track t ON t.audio_file_id = mf.id \
+            WHERE mf.sha256_hash = $1\
+         )",
+    )
+    .bind(sha256)
+    .fetch_one(pool)
+    .await?;
+    Ok(row.0)
+}
diff --git a/src/config.rs b/src/config.rs
index a7a2a84..9abf3e8 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -128,6 +128,15 @@ pub struct ConfigSources {
     pub oidc_button_text: ConfigSource,
     pub oidc_admin_groups: ConfigSource,
     pub swagger_enabled: ConfigSource,
+    pub agent_enabled: ConfigSource,
+    pub agent_inbox_dir: ConfigSource,
+    pub agent_storage_dir: ConfigSource,
+    pub agent_llm_url: ConfigSource,
+    pub agent_llm_model: ConfigSource,
+    pub agent_llm_auth: ConfigSource,
+    pub agent_confidence_threshold: ConfigSource,
+    pub agent_context_limit: ConfigSource,
+    pub agent_concurrency: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -143,6 +152,15 @@ impl Default for ConfigSources {
             oidc_button_text: ConfigSource::Default,
             oidc_admin_groups: ConfigSource::Default,
             swagger_enabled: ConfigSource::Default,
+            agent_enabled: ConfigSource::Default,
+            agent_inbox_dir: ConfigSource::Default,
+            agent_storage_dir: ConfigSource::Default,
+            agent_llm_url: ConfigSource::Default,
+            agent_llm_model: ConfigSource::Default,
+            agent_llm_auth: ConfigSource::Default,
+            agent_confidence_threshold: ConfigSource::Default,
+            agent_context_limit: ConfigSource::Default,
+            agent_concurrency: ConfigSource::Default,
         }
     }
 }
@@ -227,6 +245,24 @@ pub struct AppConfig {
     pub oidc_admin_groups: String,
     /// Whether the Swagger UI is served at /swagger/.
     pub swagger_enabled: bool,
+    /// Whether the AI agent background loop is enabled.
+    pub agent_enabled: bool,
+    /// Directory to scan for incoming audio files.
+    pub agent_inbox_dir: String,
+    /// Directory for organized permanent storage.
+    pub agent_storage_dir: String,
+    /// LLM API URL (OpenAI-compatible).
+    pub agent_llm_url: String,
+    /// LLM model name.
+    pub agent_llm_model: String,
+    /// LLM Authorization header value (e.g. "Bearer sk-...").
+    pub agent_llm_auth: String,
+    /// Confidence threshold for auto-approval (0.0–1.0).
+    pub agent_confidence_threshold: f64,
+    /// LLM context window size in tokens. Chat history resets when approaching this limit.
+    pub agent_context_limit: u64,
+    /// Number of files to process in parallel via the LLM.
+    pub agent_concurrency: u64,
 }
 
 impl Default for AppConfig {
@@ -242,6 +278,15 @@ impl Default for AppConfig {
             oidc_button_text: "Sign in with SSO".into(),
             oidc_admin_groups: String::new(),
             swagger_enabled: false,
+            agent_enabled: false,
+            agent_inbox_dir: String::new(),
+            agent_storage_dir: String::new(),
+            agent_llm_url: "http://localhost:8080".into(),
+            agent_llm_model: "default".into(),
+            agent_llm_auth: String::new(),
+            agent_confidence_threshold: 0.85,
+            agent_context_limit: 8192,
+            agent_concurrency: 2,
         }
     }
 }
@@ -258,6 +303,15 @@ impl_env_overrides!(
     oidc_button_text,
     oidc_admin_groups,
     swagger_enabled,
+    agent_enabled,
+    agent_inbox_dir,
+    agent_storage_dir,
+    agent_llm_url,
+    agent_llm_model,
+    agent_llm_auth,
+    agent_confidence_threshold,
+    agent_context_limit,
+    agent_concurrency,
 );
 
 impl AppConfig {
@@ -324,6 +378,15 @@ impl AppConfig {
         apply_db_field!(oidc_button_text);
         apply_db_field!(oidc_admin_groups);
         apply_db_field!(swagger_enabled);
+        apply_db_field!(agent_enabled);
+        apply_db_field!(agent_inbox_dir);
+        apply_db_field!(agent_storage_dir);
+        apply_db_field!(agent_llm_url);
+        apply_db_field!(agent_llm_model);
+        apply_db_field!(agent_llm_auth);
+        apply_db_field!(agent_confidence_threshold);
+        apply_db_field!(agent_context_limit);
+        apply_db_field!(agent_concurrency);
     }
 }
 
diff --git a/src/i18n/mod.rs b/src/i18n/mod.rs
index 9dfd538..35b4835 100644
--- a/src/i18n/mod.rs
+++ b/src/i18n/mod.rs
@@ -40,6 +40,7 @@ impl Lang {
 macro_rules! translations {
     ( $( $key:ident : $en:expr , $ru:expr );* $(;)? ) => {
         #[derive(Debug)]
+        #[allow(dead_code)]
         pub struct Translations {
             pub lang: $crate::i18n::Lang,
             $( pub $key: &'static str, )*
@@ -149,6 +150,7 @@ fn resolve_lang(headers: &cot::http::HeaderMap) -> Lang {
 // I18n extractor
 // ---------------------------------------------------------------------------
 
+#[allow(dead_code)]
 pub struct I18n {
     pub lang: Lang,
     pub t: &'static Translations,
diff --git a/src/i18n/phrases.rs b/src/i18n/phrases.rs
index ee782f9..f668b0c 100644
--- a/src/i18n/phrases.rs
+++ b/src/i18n/phrases.rs
@@ -97,4 +97,153 @@ translations! {
     // OIDC login errors
     login_oidc_error:         "SSO login failed. Please try again." , "Ошибка входа через SSO. Попробуйте ещё раз.";
     login_sso_disabled:       "SSO login is not configured." , "Вход через SSO не настроен.";
+
+    // Artist management
+    nav_artists:              "Artists"                       , "Артисты";
+    artists_heading:          "Artists"                       , "Артисты";
+    artists_add:              "Add artist"                    , "Добавить артиста";
+    artists_name:             "Name"                          , "Имя";
+    artists_hidden:           "Hidden"                        , "Скрыт";
+    artists_actions:          "Actions"                       , "Действия";
+    artists_edit:             "Edit"                          , "Редактировать";
+    artists_delete:           "Delete"                        , "Удалить";
+    artists_delete_confirm:   "Are you sure?"                 , "Вы уверены?";
+    artists_new_heading:      "New artist"                    , "Новый артист";
+    artists_edit_heading:     "Edit artist"                   , "Редактирование артиста";
+    artists_empty:            "No artists yet."               , "Артистов пока нет.";
+    artists_releases:         "Releases"                      , "Релизы";
+    artists_tracks:           "Tracks"                        , "Треки";
+    artists_view_releases:    "View releases"                 , "Показать релизы";
+    artists_image:            "Artist Image"                  , "Изображение артиста";
+    artists_no_image:         "No image set."                 , "Изображение не задано.";
+    artists_upload_image:     "Upload custom image"           , "Загрузить изображение";
+    artists_upload:           "Upload"                        , "Загрузить";
+    artists_pick_cover:       "Or pick from album covers"     , "Или выберите обложку альбома";
+    artists_no_covers:        "No album covers available."    , "Обложки альбомов недоступны.";
+    artists_remove_image:     "Remove image"                  , "Удалить изображение";
+
+    // Release management
+    nav_releases:             "Releases"                       , "Релизы";
+    releases_heading:         "Releases"                       , "Релизы";
+    releases_add:             "Add release"                    , "Добавить релиз";
+    releases_title:           "Title"                          , "Название";
+    releases_type:            "Type"                           , "Тип";
+    releases_year:            "Year"                           , "Год";
+    releases_artist:          "Artist"                         , "Артист";
+    releases_artists:         "Artists"                        , "Артисты";
+    releases_hidden:          "Hidden"                         , "Скрыт";
+    releases_actions:         "Actions"                        , "Действия";
+    releases_edit:            "Edit"                           , "Редактировать";
+    releases_delete:          "Delete"                         , "Удалить";
+    releases_delete_confirm:  "Are you sure?"                  , "Вы уверены?";
+    releases_new_heading:     "New release"                    , "Новый релиз";
+    releases_edit_heading:    "Edit release"                   , "Редактирование релиза";
+    releases_empty:           "No releases yet."               , "Релизов пока нет.";
+    releases_no_artist:       "— no artist —"                  , "— без артиста —";
+    releases_select_artist:   "Select artist..."               , "Выберите артиста...";
+    releases_filter_all:      "All artists"                    , "Все артисты";
+    releases_filter_label:    "Filter by artist"               , "Фильтр по артисту";
+
+    // Media files
+    nav_media_files:          "Media Files"                    , "Медиафайлы";
+    media_files_heading:      "Media Files"                    , "Медиафайлы";
+    media_files_empty:        "No media files found."          , "Медиафайлы не найдены.";
+    media_files_filename:     "Filename"                       , "Файл";
+    media_files_type:         "Type"                           , "Тип";
+    media_files_format:       "Format"                         , "Формат";
+    media_files_size:         "Size"                           , "Размер";
+    media_files_path:         "Path"                           , "Путь";
+    media_files_hash:         "SHA-256"                        , "SHA-256";
+    media_files_created:      "Created"                        , "Создан";
+    media_files_track:        "Track"                          , "Трек";
+    media_files_orphan:       "Orphan"                         , "Без трека";
+    media_files_actions:      "Actions"                        , "Действия";
+    media_files_delete:       "Delete"                         , "Удалить";
+    media_files_delete_confirm: "Delete this media file?"      , "Удалить этот медиафайл?";
+
+    // Job management
+    nav_jobs:                 "Jobs"                             , "Задания";
+    nav_reviews:              "Reviews"                          , "Проверки";
+    jobs_heading:             "Scheduled Jobs"                   , "Запланированные задания";
+    jobs_name:                "Name"                             , "Имя";
+    jobs_description:         "Description"                      , "Описание";
+    jobs_cron:                "Cron"                             , "Cron";
+    jobs_enabled:             "Enabled"                          , "Включено";
+    jobs_last_run:            "Last run"                         , "Последний запуск";
+    jobs_next_run:            "Next run"                         , "Следующий запуск";
+    jobs_actions:             "Actions"                          , "Действия";
+    jobs_run_now:             "Run now"                          , "Запустить";
+    jobs_enable:              "Enable"                           , "Включить";
+    jobs_disable:             "Disable"                          , "Выключить";
+    jobs_run_history:         "Run history"                      , "История запусков";
+    jobs_run_status:          "Status"                           , "Статус";
+    jobs_run_started:         "Started"                          , "Начало";
+    jobs_run_duration:        "Duration"                         , "Длительность";
+    jobs_run_trigger:         "Trigger"                          , "Триггер";
+    jobs_run_log:             "Log"                              , "Лог";
+    jobs_run_error:           "Error"                            , "Ошибка";
+    jobs_cron_help:           "7-field cron: sec min hour day month weekday year" , "7-полевой cron: сек мин час день месяц день_недели год";
+    jobs_cron_update:         "Update cron"                      , "Обновить cron";
+    jobs_back_to_list:        "Back to jobs"                     , "Назад к заданиям";
+    jobs_run_detail:          "Run detail"                       , "Детали запуска";
+    jobs_back_to_job:         "Back to job"                      , "Назад к заданию";
+
+    // Review management
+    reviews_heading:          "Pending Reviews"                  , "Ожидающие проверки";
+    reviews_empty:            "No reviews."                      , "Проверок нет.";
+    reviews_status:           "Status"                           , "Статус";
+    reviews_type:             "Type"                             , "Тип";
+    reviews_input_path:       "Input"                            , "Файл";
+    reviews_confidence:       "Confidence"                       , "Уверенность";
+    reviews_approve:          "Approve"                          , "Подтвердить";
+    reviews_reject:           "Reject"                           , "Отклонить";
+    reviews_context:          "Context"                          , "Контекст";
+    reviews_result:           "Result"                           , "Результат";
+    reviews_created:          "Created"                          , "Создано";
+    reviews_view:             "View"                             , "Открыть";
+    reviews_clear_all:        "Clear all"                        , "Очистить все";
+    reviews_clear_filtered:   "Clear shown"                      , "Очистить показанные";
+    reviews_clear_confirm:    "Are you sure? This will delete the selected reviews." , "Вы уверены? Выбранные проверки будут удалены.";
+    reviews_back_to_list:     "Back to reviews"                  , "Назад к проверкам";
+    reviews_filter_all:       "All"                              , "Все";
+    reviews_filter_pending:   "Pending"                          , "Ожидают";
+    reviews_filter_approved:  "Approved"                         , "Подтверждённые";
+    reviews_filter_rejected:  "Rejected"                         , "Отклонённые";
+    reviews_filter_queued:    "Queued"                            , "В очереди";
+    reviews_filter_processing: "Processing"                      , "В обработке";
+    reviews_filter_auto_approved: "Auto-approved"                , "Авто-подтверждённые";
+    reviews_filter_failed:    "Failed"                            , "Ошибочные";
+    reviews_error:            "Error"                             , "Ошибка";
+    reviews_requeue:          "Re-queue"                          , "В очередь";
+    reviews_requeue_confirm:  "Re-queue this item for processing?" , "Поставить в очередь на повторную обработку?";
+
+    // Processing stats
+    settings_agent_concurrency: "Concurrency"                     , "Параллелизм";
+
+    reviews_model:            "Model"                             , "Модель";
+    reviews_llm_duration:     "LLM time"                          , "Время LLM";
+    reviews_tokens:           "Tokens (in/out)"                   , "Токены (вх/вых)";
+
+    // Agent settings
+    settings_agent:           "Agent"                           , "Агент";
+    settings_agent_help:      "AI music processing agent configuration. Enable and configure the background agent that automatically processes audio files." , "Настройки AI-агента обработки музыки. Включите и настройте фоновый агент, который автоматически обрабатывает аудиофайлы.";
+    settings_agent_enabled:   "Agent enabled"                   , "Агент включён";
+    settings_agent_inbox:     "Inbox directory"                 , "Папка входящих";
+    settings_agent_storage:   "Storage directory"               , "Папка хранилища";
+    settings_agent_llm_url:   "LLM API URL"                    , "URL API LLM";
+    settings_agent_llm_model: "LLM model"                      , "Модель LLM";
+    settings_agent_threshold: "Confidence threshold"            , "Порог уверенности";
+    settings_agent_context:   "Context limit (tokens)"          , "Лимит контекста (токены)";
+    settings_agent_llm_auth:  "LLM auth header"                 , "Заголовок авторизации LLM";
+    settings_agent_status:    "Agent Status"                    , "Статус агента";
+    settings_agent_status_disabled: "Agent is disabled."        , "Агент отключён.";
+    settings_agent_status_no_url: "LLM URL is not configured."  , "URL LLM не настроен.";
+    settings_agent_status_ok:     "LLM connection OK"           , "Подключение к LLM OK";
+    settings_agent_status_error:  "LLM connection error"        , "Ошибка подключения к LLM";
+    settings_agent_model_name:    "Model"                       , "Модель";
+    settings_agent_latency:       "Latency"                     , "Задержка";
+    settings_agent_prompt_tokens: "Prompt tokens"               , "Токенов на промпт";
+    settings_agent_completion_tokens: "Completion tokens"       , "Токенов на ответ";
+    settings_agent_tokens_per_sec: "Tokens/sec"                 , "Токенов/сек";
+    settings_agent_status_loading: "Checking connection"         , "Проверка подключения";
 }
diff --git a/src/jobs/artist_image_backfill.rs b/src/jobs/artist_image_backfill.rs
new file mode 100644
index 0000000..60f1133
--- /dev/null
+++ b/src/jobs/artist_image_backfill.rs
@@ -0,0 +1,58 @@
+use crate::scheduler::{Job, JobContext, JobLog};
+
+/// Periodic job that auto-assigns artist images from their release covers.
+///
+/// For every artist that has no `image_file_id`, picks the cover of the most
+/// recent release (by year) that has one. Runs after the cover backfill job
+/// so freshly-extracted covers are available.
+pub struct ArtistImageBackfillJob;
+
+#[async_trait::async_trait]
+impl Job for ArtistImageBackfillJob {
+    fn name(&self) -> &'static str {
+        "artist_image_backfill"
+    }
+
+    fn description(&self) -> &'static str {
+        "Auto-assign artist images from release covers"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // 03:15 daily — after cover_backfill at 03:00
+        "0 15 3 * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        let result = sqlx::query(
+            "UPDATE furumusic__artist a \
+             SET image_file_id = ( \
+                 SELECT r.cover_file_id \
+                 FROM furumusic__release_artist ra \
+                 JOIN furumusic__release r ON r.id = ra.release_id \
+                 WHERE ra.artist_id = a.id \
+                   AND r.cover_file_id IS NOT NULL \
+                 ORDER BY r.year DESC NULLS LAST \
+                 LIMIT 1 \
+             ), \
+             updated_at = $1 \
+             WHERE a.image_file_id IS NULL \
+               AND EXISTS ( \
+                   SELECT 1 FROM furumusic__release_artist ra2 \
+                   JOIN furumusic__release r2 ON r2.id = ra2.release_id \
+                   WHERE ra2.artist_id = a.id AND r2.cover_file_id IS NOT NULL \
+               )",
+        )
+        .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
+        .execute(&ctx.pool)
+        .await?;
+
+        let count = result.rows_affected();
+        if count > 0 {
+            log.info(&format!("Assigned images to {count} artists from release covers"));
+        } else {
+            log.info("All artists already have images (or no covers available)");
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/jobs/artist_track_image_backfill.rs b/src/jobs/artist_track_image_backfill.rs
new file mode 100644
index 0000000..6b5f1c2
--- /dev/null
+++ b/src/jobs/artist_track_image_backfill.rs
@@ -0,0 +1,69 @@
+use crate::scheduler::{Job, JobContext, JobLog};
+
+/// Fallback job that assigns artist images from track cover art.
+///
+/// The primary `artist_image_backfill` job uses release covers.  This job
+/// runs afterwards and covers the case where the release itself has no
+/// cover but individual tracks do (e.g. when cover art is embedded in the
+/// audio file and extracted per-track rather than per-release).
+///
+/// For every artist that *still* has no `image_file_id` after the release-
+/// based backfill, picks the `cover_file_id` of the most recent track
+/// (by year, then track id) that has one.
+pub struct ArtistTrackImageBackfillJob;
+
+#[async_trait::async_trait]
+impl Job for ArtistTrackImageBackfillJob {
+    fn name(&self) -> &'static str {
+        "artist_track_image_backfill"
+    }
+
+    fn description(&self) -> &'static str {
+        "Auto-assign artist images from track covers (fallback)"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // 03:30 daily — after artist_image_backfill at 03:15
+        "0 30 3 * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        let result = sqlx::query(
+            "UPDATE furumusic__artist a \
+             SET image_file_id = ( \
+                 SELECT t.cover_file_id \
+                 FROM furumusic__track_artist ta \
+                 JOIN furumusic__track t ON t.id = ta.track_id \
+                 WHERE ta.artist_id = a.id \
+                   AND t.cover_file_id IS NOT NULL \
+                   AND t.is_hidden = false \
+                 ORDER BY t.year DESC NULLS LAST, t.id DESC \
+                 LIMIT 1 \
+             ), \
+             updated_at = $1 \
+             WHERE a.image_file_id IS NULL \
+               AND a.is_hidden = false \
+               AND EXISTS ( \
+                   SELECT 1 FROM furumusic__track_artist ta2 \
+                   JOIN furumusic__track t2 ON t2.id = ta2.track_id \
+                   WHERE ta2.artist_id = a.id \
+                     AND t2.cover_file_id IS NOT NULL \
+                     AND t2.is_hidden = false \
+               )",
+        )
+        .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
+        .execute(&ctx.pool)
+        .await?;
+
+        let count = result.rows_affected();
+        if count > 0 {
+            log.info(&format!(
+                "Assigned images to {count} artists from track covers"
+            ));
+        } else {
+            log.info("All artists already have images (or no track covers available)");
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/jobs/cover_backfill.rs b/src/jobs/cover_backfill.rs
new file mode 100644
index 0000000..0fede17
--- /dev/null
+++ b/src/jobs/cover_backfill.rs
@@ -0,0 +1,172 @@
+use std::path::{Path, PathBuf};
+
+use crate::agent::cover_art;
+use crate::scheduler::{Job, JobContext, JobLog};
+
+/// One-shot / periodic job that finds releases without cover art and attempts
+/// to extract or discover covers from their audio files in storage.
+pub struct CoverBackfillJob;
+
+#[async_trait::async_trait]
+impl Job for CoverBackfillJob {
+    fn name(&self) -> &'static str {
+        "cover_backfill"
+    }
+
+    fn description(&self) -> &'static str {
+        "Backfill cover art for releases missing covers"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Once a day at 03:00
+        "0 0 3 * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        let storage_dir = &ctx.config.agent_storage_dir;
+        if storage_dir.is_empty() {
+            log.warn("agent_storage_dir is not configured, skipping cover backfill");
+            return Ok(());
+        }
+
+        // Find all releases without a cover
+        let rows: Vec<(i64, String)> = sqlx::query_as(
+            "SELECT r.id, r.title \
+             FROM furumusic__release r \
+             WHERE r.cover_file_id IS NULL \
+             ORDER BY r.id",
+        )
+        .fetch_all(&ctx.pool)
+        .await?;
+
+        if rows.is_empty() {
+            log.info("All releases already have cover art, nothing to backfill");
+            return Ok(());
+        }
+
+        log.info(&format!(
+            "Found {} releases without cover art, starting backfill...",
+            rows.len()
+        ));
+
+        let mut assigned = 0u32;
+        let mut failed = 0u32;
+        let mut skipped_no_audio = 0u32;
+        let mut skipped_no_cover = 0u32;
+        let total = rows.len();
+
+        for (i, (release_id, release_title)) in rows.iter().enumerate() {
+            log.info(&format!(
+                "[{}/{}] Processing release {release_id} \"{release_title}\"...",
+                i + 1,
+                total,
+            ));
+
+            // Find audio files belonging to this release via tracks → media_file
+            let audio_paths: Vec<(String,)> = sqlx::query_as(
+                "SELECT mf.file_path \
+                 FROM furumusic__track t \
+                 JOIN furumusic__media_file mf ON mf.id = t.audio_file_id \
+                 WHERE t.release_id = $1 AND mf.file_type = 'audio'",
+            )
+            .bind(release_id)
+            .fetch_all(&ctx.pool)
+            .await
+            .unwrap_or_default();
+
+            if audio_paths.is_empty() {
+                log.warn(&format!(
+                    "Release {release_id} \"{release_title}\": no audio files found, skipping"
+                ));
+                skipped_no_audio += 1;
+                continue;
+            }
+
+            // Determine the folder from the first audio file's path
+            let first_path = Path::new(&audio_paths[0].0);
+            let folder = first_path.parent().unwrap_or(Path::new("."));
+
+            // Collect all audio file paths as PathBuf
+            let audio_files: Vec<PathBuf> = audio_paths
+                .iter()
+                .map(|(p,)| PathBuf::from(p))
+                .collect();
+
+            // Try to find cover art
+            let cover = match cover_art::find_best_cover(folder, &audio_files).await {
+                Some(c) => c,
+                None => {
+                    log.info(&format!(
+                        "Release {release_id} \"{release_title}\": no cover image found in {} audio files, skipping",
+                        audio_files.len(),
+                    ));
+                    skipped_no_cover += 1;
+                    continue;
+                }
+            };
+
+            let source_desc = match &cover.source {
+                cover_art::CoverSource::FolderFile(p) => format!("folder: {}", p.display()),
+                cover_art::CoverSource::Embedded(p) => format!("embedded: {}", p.display()),
+            };
+
+            // Look up artist name for storage path
+            let artist_name: String = sqlx::query_scalar(
+                "SELECT a.name FROM furumusic__artist a \
+                 JOIN furumusic__release_artist ra ON ra.artist_id = a.id \
+                 WHERE ra.release_id = $1 \
+                 ORDER BY ra.position LIMIT 1",
+            )
+            .bind(release_id)
+            .fetch_optional(&ctx.pool)
+            .await
+            .ok()
+            .flatten()
+            .unwrap_or_else(|| "Unknown Artist".to_string());
+
+            match cover_art::save_cover_to_storage(
+                &ctx.db,
+                &ctx.pool,
+                storage_dir,
+                &artist_name,
+                release_title,
+                &cover,
+            )
+            .await
+            {
+                Ok(cover_file_id) => {
+                    if let Err(e) = cover_art::assign_cover_to_release(
+                        &ctx.pool,
+                        *release_id,
+                        cover_file_id,
+                    )
+                    .await
+                    {
+                        log.warn(&format!(
+                            "Release {release_id} \"{release_title}\": saved cover but failed to assign: {e}"
+                        ));
+                        failed += 1;
+                    } else {
+                        log.info(&format!(
+                            "Release {release_id} \"{release_title}\": assigned cover from {source_desc}"
+                        ));
+                        assigned += 1;
+                    }
+                }
+                Err(e) => {
+                    log.warn(&format!(
+                        "Release {release_id} \"{release_title}\": failed to save cover: {e}"
+                    ));
+                    failed += 1;
+                }
+            }
+        }
+
+        log.info(&format!(
+            "Cover backfill complete: {assigned} assigned, {failed} failed, \
+             {skipped_no_audio} skipped (no audio), {skipped_no_cover} skipped (no cover found)"
+        ));
+
+        Ok(())
+    }
+}
diff --git a/src/jobs/inbox_discover.rs b/src/jobs/inbox_discover.rs
new file mode 100644
index 0000000..6c93c75
--- /dev/null
+++ b/src/jobs/inbox_discover.rs
@@ -0,0 +1,240 @@
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use sha2::{Digest, Sha256};
+
+use crate::scheduler::{Job, JobContext, JobLog, PendingReview};
+
+/// Guard to prevent overlapping inbox_discover runs.
+static DISCOVER_RUNNING: AtomicBool = AtomicBool::new(false);
+
+const AUDIO_EXTENSIONS: &[&str] = &[
+    "mp3", "flac", "ogg", "opus", "aac", "m4a", "wav", "ape", "wv", "wma", "tta", "aiff", "aif",
+];
+
+pub struct InboxDiscoverJob;
+
+#[async_trait::async_trait]
+impl Job for InboxDiscoverJob {
+    fn name(&self) -> &'static str {
+        "inbox_discover"
+    }
+
+    fn description(&self) -> &'static str {
+        "Scan inbox for new audio files and queue them for processing"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        "0 */5 * * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        // Prevent overlapping discover runs
+        if DISCOVER_RUNNING.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_err() {
+            log.info("Another inbox_discover is already running, skipping");
+            return Ok(());
+        }
+        struct Guard;
+        impl Drop for Guard {
+            fn drop(&mut self) {
+                DISCOVER_RUNNING.store(false, Ordering::SeqCst);
+            }
+        }
+        let _guard = Guard;
+
+        let config = &ctx.config;
+
+        if config.agent_inbox_dir.is_empty() {
+            log.info("No inbox directory configured, skipping");
+            return Ok(());
+        }
+
+        let inbox = Path::new(&config.agent_inbox_dir);
+        if !inbox.exists() {
+            log.warn(&format!("Inbox path does not exist: {}", inbox.display()));
+            return Ok(());
+        }
+
+        let mut audio_files = Vec::new();
+        collect_audio_files(inbox, &mut audio_files).await?;
+
+        log.info(&format!("Found {} audio files in inbox", audio_files.len()));
+        if audio_files.is_empty() {
+            return Ok(());
+        }
+
+        let groups = group_by_folder(&audio_files);
+        log.info(&format!("Grouped into {} folder batches", groups.len()));
+
+        let mut discovered = 0u64;
+        let mut skipped_hash = 0u64;
+        let mut skipped_existing = 0u64;
+
+        for (_folder, files) in &groups {
+            for file_path in files {
+                let input_path_str = file_path.to_string_lossy().to_string();
+
+                // Skip if a PendingReview already exists for this path
+                match PendingReview::exists_for_path(&ctx.db, &input_path_str).await {
+                    Ok(true) => {
+                        skipped_existing += 1;
+                        continue;
+                    }
+                    Ok(false) => {}
+                    Err(e) => {
+                        log.warn(&format!("Error checking existing review for {}: {e}", input_path_str));
+                        continue;
+                    }
+                }
+
+                // Compute SHA-256 hash
+                let path_clone = file_path.to_path_buf();
+                let (hash, file_size) = match tokio::task::spawn_blocking(move || -> anyhow::Result<(String, i64)> {
+                    let data = std::fs::read(&path_clone)?;
+                    let digest = Sha256::digest(&data);
+                    let hash = format!("{:x}", digest);
+                    let size = data.len() as i64;
+                    Ok((hash, size))
+                })
+                .await?
+                {
+                    Ok(v) => v,
+                    Err(e) => {
+                        log.warn(&format!("Failed to hash {}: {e}", file_path.display()));
+                        continue;
+                    }
+                };
+
+                // Skip if hash already in media_files
+                if crate::agent::rag::file_hash_exists(&ctx.pool, &hash).await.unwrap_or(false) {
+                    skipped_hash += 1;
+                    continue;
+                }
+
+                // Extract raw metadata
+                let path_for_meta = file_path.to_path_buf();
+                let raw_meta = match tokio::task::spawn_blocking(move || {
+                    crate::agent::metadata::extract(&path_for_meta)
+                })
+                .await?
+                {
+                    Ok(m) => m,
+                    Err(e) => {
+                        log.warn(&format!("Failed to extract metadata from {}: {e}", file_path.display()));
+                        continue;
+                    }
+                };
+
+                // Parse path hints
+                let relative = file_path.strip_prefix(inbox).unwrap_or(file_path);
+                let hints = crate::agent::path_hints::parse(relative);
+
+                // Build context JSON
+                let context = serde_json::json!({
+                    "sha256": hash,
+                    "file_size": file_size,
+                    "raw_title": raw_meta.title,
+                    "raw_artist": raw_meta.artist,
+                    "raw_album": raw_meta.album,
+                    "raw_track_number": raw_meta.track_number,
+                    "raw_year": raw_meta.year,
+                    "raw_genre": raw_meta.genre,
+                    "duration_secs": raw_meta.duration_secs,
+                    "path_title": hints.title,
+                    "path_artist": hints.artist,
+                    "path_album": hints.album,
+                    "path_year": hints.year,
+                    "path_track_number": hints.track_number,
+                });
+                let context_str = serde_json::to_string(&context).unwrap_or_default();
+
+                // Create PendingReview with status "queued"
+                PendingReview::create_queued(
+                    &ctx.db,
+                    ctx.run_id,
+                    "new_file",
+                    Some(&input_path_str),
+                    Some(&context_str),
+                )
+                .await
+                .map_err(|e| anyhow::anyhow!("failed to create queued review: {e}"))?;
+
+                discovered += 1;
+            }
+        }
+
+        log.info(&format!(
+            "Discovered {} new files, skipped {} (hash known), skipped {} (already queued)",
+            discovered, skipped_hash, skipped_existing
+        ));
+
+        // Trigger inbox_process in background if new files were discovered
+        // and no orchestrator is already running
+        if discovered > 0 {
+            if crate::jobs::inbox_process::is_orchestrator_running() {
+                log.info("New files discovered but inbox_process already running, it will pick them up");
+            } else {
+                log.info("Spawning inbox_process in background...");
+                let config = ctx.config.clone();
+                let db = ctx.db.clone();
+                let pool = ctx.pool.clone();
+                let registry = ctx.registry.clone();
+                tokio::spawn(async move {
+                    if let Err(e) = crate::scheduler::trigger_job_now(
+                        &config, &db, &pool, &registry, "inbox_process",
+                    )
+                    .await
+                    {
+                            tracing::error!("Background inbox_process trigger failed: {e}");
+                    }
+                });
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers (moved from inbox_scan.rs)
+// ---------------------------------------------------------------------------
+
+pub fn group_by_folder(files: &[PathBuf]) -> Vec<(PathBuf, Vec<PathBuf>)> {
+    use std::collections::HashMap;
+    let mut map: HashMap<PathBuf, Vec<PathBuf>> = HashMap::new();
+    for f in files {
+        let folder = f.parent().unwrap_or(f).to_path_buf();
+        map.entry(folder).or_default().push(f.clone());
+    }
+    let mut groups: Vec<(PathBuf, Vec<PathBuf>)> = map.into_iter().collect();
+    groups.sort_by(|a, b| a.0.cmp(&b.0));
+    for (_, files) in &mut groups {
+        files.sort();
+    }
+    groups
+}
+
+pub async fn collect_audio_files(
+    dir: &Path,
+    audio: &mut Vec<PathBuf>,
+) -> anyhow::Result<()> {
+    let mut entries = tokio::fs::read_dir(dir).await?;
+    while let Some(entry) = entries.next_entry().await? {
+        let name = entry.file_name().to_string_lossy().into_owned();
+        if name.starts_with('.') {
+            continue;
+        }
+        let ft = entry.file_type().await?;
+        if ft.is_dir() {
+            Box::pin(collect_audio_files(&entry.path(), audio)).await?;
+        } else if ft.is_file() && is_audio_file(&name) {
+            audio.push(entry.path());
+        }
+    }
+    Ok(())
+}
+
+pub fn is_audio_file(name: &str) -> bool {
+    let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+    AUDIO_EXTENSIONS.contains(&ext.as_str())
+}
diff --git a/src/jobs/inbox_process.rs b/src/jobs/inbox_process.rs
new file mode 100644
index 0000000..e4b73bd
--- /dev/null
+++ b/src/jobs/inbox_process.rs
@@ -0,0 +1,957 @@
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use cot::db::{Database, Model};
+
+/// Guard to prevent multiple inbox_process orchestrators from running simultaneously.
+static ORCHESTRATOR_RUNNING: AtomicBool = AtomicBool::new(false);
+
+/// Well-known advisory lock ID for the inbox_process orchestrator.
+/// PostgreSQL advisory locks use a 64-bit key; this is an arbitrary unique value.
+const ORCHESTRATOR_ADVISORY_LOCK_ID: i64 = 0x4655_5255_4D55_5349; // "FURUMUSI" in hex
+
+/// Check if an orchestrator is currently running (used by inbox_discover to avoid redundant triggers).
+pub fn is_orchestrator_running() -> bool {
+    ORCHESTRATOR_RUNNING.load(Ordering::SeqCst)
+}
+
+/// Try to acquire the PostgreSQL advisory lock for the orchestrator.
+/// Returns true if the lock was acquired (no other orchestrator is running).
+async fn try_acquire_orchestrator_lock(pool: &sqlx::PgPool) -> bool {
+    match sqlx::query_scalar::<_, bool>(
+        "SELECT pg_try_advisory_lock($1)"
+    )
+    .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
+    .fetch_one(pool)
+    .await
+    {
+        Ok(acquired) => acquired,
+        Err(e) => {
+            tracing::error!("Failed to acquire advisory lock: {e}");
+            false
+        }
+    }
+}
+
+/// Release the PostgreSQL advisory lock for the orchestrator.
+async fn release_orchestrator_lock(pool: &sqlx::PgPool) {
+    let _ = sqlx::query("SELECT pg_advisory_unlock($1)")
+        .bind(ORCHESTRATOR_ADVISORY_LOCK_ID)
+        .execute(pool)
+        .await;
+}
+
+use crate::config::AppConfig;
+use crate::music::{
+    Artist, MediaFile, Release, ReleaseArtist, Track, TrackArtist,
+};
+use crate::scheduler::{Job, JobContext, JobLog, JobRun, PendingReview, ProcessingStats};
+use crate::agent::dto::{FolderContext, NormalizedFields, RawMetadata, PathHints};
+use crate::agent::normalize::BatchFileInput;
+use crate::agent::mover;
+
+const AUDIO_EXTENSIONS: &[&str] = &[
+    "mp3", "flac", "ogg", "opus", "aac", "m4a", "wav", "ape", "wv", "wma", "tta", "aiff", "aif",
+];
+
+// ---------------------------------------------------------------------------
+// InboxProcessJob — orchestrator that runs until ALL queued files are done
+// ---------------------------------------------------------------------------
+
+pub struct InboxProcessJob;
+
+#[async_trait::async_trait]
+impl Job for InboxProcessJob {
+    fn name(&self) -> &'static str {
+        "inbox_process"
+    }
+
+    fn description(&self) -> &'static str {
+        "Orchestrator: process queued files in folder batches"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        "30 */5 * * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        // --- Guard 1: AtomicBool (fast in-process check) ---
+        let prev = ORCHESTRATOR_RUNNING.load(Ordering::SeqCst);
+        tracing::info!(
+            previous_value = prev,
+            "inbox_process: checking ORCHESTRATOR_RUNNING AtomicBool"
+        );
+        if ORCHESTRATOR_RUNNING.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_err() {
+            log.info("Another inbox_process orchestrator is already running (AtomicBool), skipping");
+            return Ok(());
+        }
+        struct AtomicGuard;
+        impl Drop for AtomicGuard {
+            fn drop(&mut self) {
+                tracing::info!("inbox_process: releasing ORCHESTRATOR_RUNNING AtomicBool");
+                ORCHESTRATOR_RUNNING.store(false, Ordering::SeqCst);
+            }
+        }
+        let _atomic_guard = AtomicGuard;
+
+        // --- Guard 2: PostgreSQL advisory lock (cross-process/binary safe) ---
+        if !try_acquire_orchestrator_lock(&ctx.pool).await {
+            log.info("Another inbox_process orchestrator holds the advisory lock, skipping");
+            return Ok(());
+        }
+        tracing::info!("inbox_process: advisory lock acquired");
+        let pool_for_unlock = ctx.pool.clone();
+        struct AdvisoryGuard {
+            pool: sqlx::PgPool,
+        }
+        impl Drop for AdvisoryGuard {
+            fn drop(&mut self) {
+                let pool = self.pool.clone();
+                tokio::spawn(async move {
+                    release_orchestrator_lock(&pool).await;
+                    tracing::info!("inbox_process: advisory lock released");
+                });
+            }
+        }
+        let _advisory_guard = AdvisoryGuard { pool: pool_for_unlock };
+
+        let config = Arc::clone(&ctx.config);
+        let mut total_ok = 0u64;
+        let mut total_fail = 0u64;
+
+        // Outer loop: re-check for newly queued files after each round
+        loop {
+            let queued = PendingReview::list_queued(&ctx.db)
+                .await
+                .map_err(|e| anyhow::anyhow!("failed to list queued reviews: {e}"))?;
+
+            if queued.is_empty() {
+                if total_ok == 0 && total_fail == 0 {
+                    log.info("No queued files to process");
+                } else {
+                    log.info("No more queued files, finishing");
+                }
+                break;
+            }
+
+            // Group queued reviews by parent folder
+            let groups = group_reviews_by_folder(&queued, &config.agent_inbox_dir);
+            log.info(&format!(
+                "{} queued file(s) in {} folder batch(es)",
+                queued.len(),
+                groups.len(),
+            ));
+
+            for (folder_rel, reviews) in groups {
+                let file_count = reviews.len();
+                log.info(&format!(
+                    "Folder batch: \"{}\" ({} files)",
+                    folder_rel, file_count,
+                ));
+
+                let (ok, fail) = process_folder_batch(
+                    &ctx.db, &config, &ctx.pool, &folder_rel, reviews, log,
+                ).await;
+
+                total_ok += ok;
+                total_fail += fail;
+                log.info(&format!(
+                    "Folder done: {ok} ok, {fail} err. Total so far: {total_ok} ok, {total_fail} err"
+                ));
+            }
+        }
+
+        // Cleanup empty dirs
+        let inbox_path = Path::new(&config.agent_inbox_dir);
+        if total_ok > 0 && !config.agent_inbox_dir.is_empty() {
+            cleanup_empty_dirs(inbox_path).await;
+        }
+
+        log.info(&format!(
+            "Orchestrator finished: {total_ok} succeeded, {total_fail} failed"
+        ));
+
+        Ok(())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// FileProcessJob — registered for admin UI visibility (no cron, never auto-triggered)
+// ---------------------------------------------------------------------------
+
+pub struct FileProcessJob;
+
+#[async_trait::async_trait]
+impl Job for FileProcessJob {
+    fn name(&self) -> &'static str {
+        "file_process"
+    }
+
+    fn description(&self) -> &'static str {
+        "Process audio files through LLM (spawned by orchestrator)"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        "" // no cron — only spawned by the orchestrator
+    }
+
+    async fn run(&self, _ctx: &JobContext, _log: &mut JobLog) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Prepared file — metadata extracted, ready for LLM
+// ---------------------------------------------------------------------------
+
+struct PreparedFile {
+    review: PendingReview,
+    filename: String,
+    raw_meta: RawMetadata,
+    hints: PathHints,
+    context: serde_json::Value,
+}
+
+// ---------------------------------------------------------------------------
+// Group reviews by parent folder
+// ---------------------------------------------------------------------------
+
+fn group_reviews_by_folder(
+    reviews: &[PendingReview],
+    inbox_dir: &str,
+) -> Vec<(String, Vec<PendingReview>)> {
+    let inbox = Path::new(inbox_dir);
+    let mut map: HashMap<String, Vec<PendingReview>> = HashMap::new();
+
+    for r in reviews {
+        let path = Path::new(r.input_path_str());
+        let folder = path.parent().unwrap_or(path);
+        let rel = folder.strip_prefix(inbox).unwrap_or(folder);
+        let key = rel.to_string_lossy().to_string();
+        map.entry(key).or_default().push(r.clone());
+    }
+
+    let mut groups: Vec<(String, Vec<PendingReview>)> = map.into_iter().collect();
+    groups.sort_by(|a, b| a.0.cmp(&b.0));
+    // Sort files within each group by path
+    for (_, reviews) in &mut groups {
+        reviews.sort_by(|a, b| a.input_path_str().cmp(b.input_path_str()));
+    }
+    groups
+}
+
+// ---------------------------------------------------------------------------
+// Process one folder batch
+// ---------------------------------------------------------------------------
+
+async fn process_folder_batch(
+    db: &Database,
+    config: &AppConfig,
+    pool: &sqlx::PgPool,
+    folder_rel: &str,
+    reviews: Vec<PendingReview>,
+    orch_log: &mut JobLog,
+) -> (u64, u64) {
+    let inbox_path = Path::new(&config.agent_inbox_dir);
+    let file_count = reviews.len();
+
+    // Create a single JobRun for the folder batch
+    let trigger_label = if folder_rel.is_empty() {
+        format!("batch({})", file_count)
+    } else {
+        let short = truncate_path(folder_rel, 20);
+        format!("{short}({})", file_count)
+    };
+    let mut run = match JobRun::create_running(db, "file_process", &trigger_label).await {
+        Ok(r) => r,
+        Err(e) => {
+            orch_log.error(&format!("Failed to create batch JobRun: {e}"));
+            return (0, file_count as u64);
+        }
+    };
+    let batch_start = std::time::Instant::now();
+    let mut log = JobLog::with_live_flush(pool.clone(), run.id_val());
+
+    log.info(&format!(
+        "Folder batch: \"{folder_rel}\" — {file_count} file(s)"
+    ));
+
+    // Phase 1: Prepare all files (extract metadata, parse hints)
+    log.info("Phase 1: extracting metadata...");
+    let mut prepared: Vec<PreparedFile> = Vec::with_capacity(file_count);
+    let mut failed_reviews: Vec<PendingReview> = Vec::new();
+
+    for mut review in reviews {
+        let input_path_str = review.input_path_str().to_owned();
+        let file_path = Path::new(&input_path_str);
+        let filename = file_path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("unknown")
+            .to_owned();
+
+        // Set status → processing
+        let _ = review.set_processing(db).await;
+
+        // Parse context_json
+        let context: serde_json::Value = review
+            .context_json
+            .as_deref()
+            .and_then(|s| serde_json::from_str(s).ok())
+            .unwrap_or_default();
+
+        // Extract metadata (with 60s timeout)
+        let path_for_meta = file_path.to_path_buf();
+        let meta_future = tokio::task::spawn_blocking(move || {
+            crate::agent::metadata::extract(&path_for_meta)
+        });
+        let raw_meta = match tokio::time::timeout(
+            std::time::Duration::from_secs(60),
+            meta_future,
+        ).await {
+            Ok(Ok(Ok(m))) => m,
+            Ok(Ok(Err(e))) => {
+                let msg = format!("{filename}: metadata error: {e}");
+                log.error(&msg);
+                let _ = review.set_failed(db, &msg).await;
+                failed_reviews.push(review);
+                continue;
+            }
+            Ok(Err(e)) => {
+                let msg = format!("{filename}: metadata panic: {e}");
+                log.error(&msg);
+                let _ = review.set_failed(db, &msg).await;
+                failed_reviews.push(review);
+                continue;
+            }
+            Err(_) => {
+                let msg = format!("{filename}: metadata timeout (60s)");
+                log.error(&msg);
+                let _ = review.set_failed(db, &msg).await;
+                failed_reviews.push(review);
+                continue;
+            }
+        };
+
+        // Parse path hints
+        let relative = file_path.strip_prefix(inbox_path).unwrap_or(file_path);
+        let hints = crate::agent::path_hints::parse(relative);
+
+        prepared.push(PreparedFile {
+            review,
+            filename,
+            raw_meta,
+            hints,
+            context,
+        });
+    }
+
+    log.info(&format!(
+        "Phase 1 done: {} prepared, {} failed metadata",
+        prepared.len(),
+        failed_reviews.len(),
+    ));
+
+    if prepared.is_empty() {
+        let duration_ms = batch_start.elapsed().as_millis() as i64;
+        let _ = run.set_completed(db, duration_ms, &log.output()).await;
+        return (0, failed_reviews.len() as u64);
+    }
+
+    // Phase 2: RAG lookup (collect unique artist/album queries from all files)
+    log.info("Phase 2: RAG lookup...");
+    let mut artist_queries: Vec<String> = Vec::new();
+    let mut album_queries: Vec<String> = Vec::new();
+
+    for p in &prepared {
+        let artist_q = p.raw_meta.artist.as_deref()
+            .or(p.hints.artist.as_deref())
+            .unwrap_or("")
+            .to_owned();
+        if !artist_q.is_empty() && !artist_queries.contains(&artist_q) {
+            artist_queries.push(artist_q);
+        }
+        let album_q = p.raw_meta.album.as_deref()
+            .or(p.hints.album.as_deref())
+            .unwrap_or("")
+            .to_owned();
+        if !album_q.is_empty() && !album_queries.contains(&album_q) {
+            album_queries.push(album_q);
+        }
+    }
+
+    // Lookup all unique artist queries
+    let mut all_similar_artists = Vec::new();
+    for q in &artist_queries {
+        match tokio::time::timeout(
+            std::time::Duration::from_secs(30),
+            crate::agent::rag::find_similar_artists(pool, q, 5),
+        ).await {
+            Ok(Ok(results)) => {
+                for a in results {
+                    if !all_similar_artists.iter().any(|x: &crate::agent::dto::SimilarArtist| x.id == a.id) {
+                        all_similar_artists.push(a);
+                    }
+                }
+            }
+            Ok(Err(e)) => log.warn(&format!("RAG artist lookup failed for \"{q}\": {e}")),
+            Err(_) => log.warn(&format!("RAG artist lookup timed out for \"{q}\"")),
+        }
+    }
+
+    let mut all_similar_releases = Vec::new();
+    for q in &album_queries {
+        match tokio::time::timeout(
+            std::time::Duration::from_secs(30),
+            crate::agent::rag::find_similar_releases(pool, q, 5),
+        ).await {
+            Ok(Ok(results)) => {
+                for r in results {
+                    if !all_similar_releases.iter().any(|x: &crate::agent::dto::SimilarRelease| x.id == r.id) {
+                        all_similar_releases.push(r);
+                    }
+                }
+            }
+            Ok(Err(e)) => log.warn(&format!("RAG release lookup failed for \"{q}\": {e}")),
+            Err(_) => log.warn(&format!("RAG release lookup timed out for \"{q}\"")),
+        }
+    }
+
+    log.info(&format!(
+        "Phase 2 done: {} similar artists, {} similar releases",
+        all_similar_artists.len(),
+        all_similar_releases.len(),
+    ));
+
+    // Phase 3: Build folder context and call batch LLM
+    log.info("Phase 3: calling LLM (batch)...");
+
+    // Build folder context from the first file's folder
+    let folder_ctx = {
+        let first_path = Path::new(prepared[0].review.input_path_str());
+        let folder = first_path.parent().unwrap_or(first_path);
+        let mut folder_files: Vec<String> = std::fs::read_dir(folder)
+            .ok()
+            .map(|rd| {
+                rd.filter_map(|e| e.ok())
+                    .filter_map(|e| {
+                        let name = e.file_name().to_string_lossy().into_owned();
+                        let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+                        if AUDIO_EXTENSIONS.contains(&ext.as_str()) {
+                            Some(name)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        folder_files.sort();
+        let track_count = folder_files.len();
+        FolderContext {
+            folder_path: folder_rel.to_owned(),
+            folder_files,
+            track_count,
+        }
+    };
+
+    // Build batch input
+    let batch_files: Vec<BatchFileInput> = prepared.iter().map(|p| {
+        BatchFileInput {
+            filename: p.filename.clone(),
+            raw: RawMetadata {
+                title: p.raw_meta.title.clone(),
+                artist: p.raw_meta.artist.clone(),
+                album: p.raw_meta.album.clone(),
+                track_number: p.raw_meta.track_number,
+                year: p.raw_meta.year,
+                genre: p.raw_meta.genre.clone(),
+                duration_secs: p.raw_meta.duration_secs,
+            },
+            hints: PathHints {
+                title: p.hints.title.clone(),
+                artist: p.hints.artist.clone(),
+                album: p.hints.album.clone(),
+                year: p.hints.year,
+                track_number: p.hints.track_number,
+            },
+        }
+    }).collect();
+
+    let system_prompt = include_str!("../../prompts/normalize_batch.txt");
+    let context_limit = config.agent_context_limit;
+
+    let llm_result = crate::agent::normalize::normalize_batch(
+        &config.agent_llm_url,
+        &config.agent_llm_model,
+        &config.agent_llm_auth,
+        system_prompt,
+        context_limit,
+        batch_files,
+        &all_similar_artists,
+        &all_similar_releases,
+        Some(&folder_ctx),
+    ).await;
+
+    let batch_result = match llm_result {
+        Ok(r) => r,
+        Err(e) => {
+            let err_msg = format!("Batch LLM call failed: {e}");
+            log.error(&err_msg);
+            // Mark all files as failed
+            for mut p in prepared {
+                let _ = p.review.set_failed(db, &err_msg).await;
+            }
+            let total_fail_count = failed_reviews.len() as u64 + file_count as u64;
+            let duration_ms = batch_start.elapsed().as_millis() as i64;
+            let _ = run.set_failed(db, duration_ms, &log.output(), &err_msg).await;
+            return (0, total_fail_count);
+        }
+    };
+
+    log.info(&format!(
+        "Phase 3 done: LLM returned {} results in {}ms (model={}, tokens={}/{})",
+        batch_result.results.len(),
+        batch_result.duration_ms,
+        batch_result.model,
+        batch_result.prompt_tokens,
+        batch_result.completion_tokens,
+    ));
+
+    // Phase 4: Match results to files and finalize
+    log.info("Phase 4: finalizing...");
+
+    // Build lookup map: filename → NormalizedFields
+    let result_map: HashMap<String, NormalizedFields> = batch_result.results
+        .into_iter()
+        .collect();
+
+    let llm_model = &batch_result.model;
+    let prompt_per_file = batch_result.prompt_tokens / prepared.len().max(1) as u64;
+    let completion_per_file = batch_result.completion_tokens / prepared.len().max(1) as u64;
+    let duration_per_file = batch_result.duration_ms as i64 / prepared.len().max(1) as i64;
+
+    let mut ok_count = 0u64;
+    let mut fail_count = failed_reviews.len() as u64;
+
+    for mut p in prepared {
+        let filename = &p.filename;
+
+        let normalized = match result_map.get(filename) {
+            Some(n) => n,
+            None => {
+                let msg = format!("LLM returned no result for \"{filename}\"");
+                log.error(&msg);
+                let _ = p.review.set_failed(db, &msg).await;
+                fail_count += 1;
+                continue;
+            }
+        };
+
+        // Record processing stats
+        let _ = ProcessingStats::create(
+            db,
+            p.review.id_val(),
+            llm_model,
+            duration_per_file,
+            prompt_per_file as i64,
+            completion_per_file as i64,
+        ).await;
+
+        let result_json = serde_json::to_string(normalized).unwrap_or_default();
+        let confidence = normalized.confidence.unwrap_or(0.0);
+
+        let feat = if normalized.featured_artists.is_empty() {
+            String::new()
+        } else {
+            format!(" feat=[{}]", normalized.featured_artists.join(", "))
+        };
+        log.info(&format!(
+            "{filename}: artist={} | album={} | title={} | track={} | year={} | conf={}{}",
+            normalized.artist.as_deref().unwrap_or("-"),
+            normalized.album.as_deref().unwrap_or("-"),
+            normalized.title.as_deref().unwrap_or("-"),
+            normalized.track_number.map_or("-".into(), |n| n.to_string()),
+            normalized.year.map_or("-".into(), |y| y.to_string()),
+            confidence,
+            feat,
+        ));
+
+        p.review.result_json = Some(result_json);
+        let _ = p.review.save(db).await;
+
+        let input_path_str = p.review.input_path_str().to_owned();
+
+        if confidence >= config.agent_confidence_threshold {
+            match finalize_approved(
+                db, pool, config, &input_path_str, normalized, &p.context,
+                &config.agent_storage_dir, Some(llm_model),
+            ).await {
+                Ok(()) => {
+                    let _ = p.review.set_auto_approved(db).await;
+                    ok_count += 1;
+                }
+                Err(e) => {
+                    let msg = format!("{filename}: finalize failed: {e}");
+                    log.error(&msg);
+                    let _ = p.review.set_failed(db, &msg).await;
+                    fail_count += 1;
+                }
+            }
+        } else {
+            p.review.status = cot::db::LimitedString::new("pending").unwrap();
+            p.review.updated_at = cot::db::LimitedString::new(
+                &chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string(),
+            ).unwrap();
+            let _ = p.review.save(db).await;
+            log.info(&format!(
+                "{filename}: manual review (confidence {confidence} < {})",
+                config.agent_confidence_threshold,
+            ));
+            ok_count += 1; // Not a failure, just needs review
+        }
+    }
+
+    let duration_ms = batch_start.elapsed().as_millis() as i64;
+    if fail_count == 0 {
+        let _ = run.set_completed(db, duration_ms, &log.output()).await;
+    } else {
+        let msg = format!("{fail_count} file(s) failed");
+        let _ = run.set_failed(db, duration_ms, &log.output(), &msg).await;
+    }
+
+    (ok_count, fail_count)
+}
+
+// ---------------------------------------------------------------------------
+// Finalization (called on approve or auto-approve)
+// ---------------------------------------------------------------------------
+
+pub async fn finalize_approved(
+    db: &cot::db::Database,
+    pool: &sqlx::PgPool,
+    _config: &crate::config::AppConfig,
+    input_path_str: &str,
+    normalized: &NormalizedFields,
+    context: &serde_json::Value,
+    storage_dir_str: &str,
+    model_name: Option<&str>,
+) -> anyhow::Result<()> {
+    let artist_name = normalized.artist.as_deref().unwrap_or("Unknown Artist");
+    let release_title = normalized.album.as_deref().unwrap_or("Unknown Release");
+    let track_title = normalized.title.as_deref().unwrap_or("Unknown Title");
+    let release_type = normalized.release_type.as_deref().unwrap_or("album");
+    let year = normalized.year;
+    let track_number = normalized.track_number;
+
+    let artist = find_or_create_artist(db, artist_name, model_name).await?;
+    let release = find_or_create_release(db, release_title, release_type, year, model_name).await?;
+
+    // Link ReleaseArtist
+    let existing_links = ReleaseArtist::find_by_release(db, release.id_val())
+        .await
+        .unwrap_or_default();
+    let already_linked = existing_links
+        .iter()
+        .any(|l| l.artist_id() == artist.id_val());
+    if !already_linked {
+        let position = existing_links.len() as i32;
+        let mut link = ReleaseArtist {
+            id: cot::db::Auto::auto(),
+            release_id: release.id_val(),
+            artist_id: artist.id_val(),
+            position,
+        };
+        link.insert(db)
+            .await
+            .map_err(|e| anyhow::anyhow!("failed to link release-artist: {e}"))?;
+    }
+
+    let sha256 = context
+        .get("sha256")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let file_size = context
+        .get("file_size")
+        .and_then(|v| v.as_i64())
+        .unwrap_or(0);
+    let duration_secs = context
+        .get("duration_secs")
+        .and_then(|v| v.as_f64())
+        .unwrap_or(0.0);
+
+    let source_path = Path::new(input_path_str);
+    let original_filename = source_path
+        .file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("unknown");
+    let ext = source_path
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("flac");
+
+    let mime_type = match ext.to_lowercase().as_str() {
+        "mp3" => "audio/mpeg",
+        "flac" => "audio/flac",
+        "ogg" | "opus" => "audio/ogg",
+        "aac" | "m4a" => "audio/mp4",
+        "wav" => "audio/wav",
+        "aiff" | "aif" => "audio/aiff",
+        _ => "application/octet-stream",
+    };
+
+    let track_num = track_number.unwrap_or(0);
+    let dest_filename = if track_num > 0 {
+        format!(
+            "{:02} - {}.{}",
+            track_num,
+            sanitize_filename(track_title),
+            ext
+        )
+    } else {
+        format!("{}.{}", sanitize_filename(track_title), ext)
+    };
+
+    let storage_dir = Path::new(storage_dir_str);
+    let storage_path = if source_path.exists() {
+        match mover::move_to_storage(
+            storage_dir,
+            artist_name,
+            release_title,
+            &dest_filename,
+            source_path,
+        )
+        .await?
+        {
+            mover::MoveOutcome::Moved(p) => p.to_string_lossy().to_string(),
+            mover::MoveOutcome::Merged(p) => p.to_string_lossy().to_string(),
+        }
+    } else {
+        storage_dir
+            .join(sanitize_filename(artist_name))
+            .join(sanitize_filename(release_title))
+            .join(&dest_filename)
+            .to_string_lossy()
+            .to_string()
+    };
+
+    let media_file = MediaFile::create(
+        db,
+        "audio",
+        &storage_path,
+        original_filename,
+        mime_type,
+        file_size,
+        sha256,
+        Some(ext),
+        None,
+        None,
+        None,
+    )
+    .await
+    .map_err(|e| anyhow::anyhow!("failed to create media file: {e}"))?;
+
+    let track = Track::create(
+        db,
+        track_title,
+        release.id_val(),
+        track_number,
+        None,
+        duration_secs,
+        media_file.id_val(),
+        year,
+        model_name,
+    )
+    .await
+    .map_err(|e| anyhow::anyhow!("failed to create track: {e}"))?;
+
+    TrackArtist::create(db, track.id_val(), artist.id_val(), "main", 0)
+        .await
+        .map_err(|e| anyhow::anyhow!("failed to link track-artist: {e}"))?;
+
+    for (i, feat_name) in normalized.featured_artists.iter().enumerate() {
+        let feat_artist = find_or_create_artist(db, feat_name, model_name).await?;
+        let _ = TrackArtist::create(
+            db,
+            track.id_val(),
+            feat_artist.id_val(),
+            "featuring",
+            (i + 1) as i32,
+        )
+        .await;
+    }
+
+    // Cover art: if the release has no cover yet, try to find one
+    if release.cover_file_id.is_none() {
+        let source_folder = Path::new(input_path_str)
+            .parent()
+            .unwrap_or(Path::new("."));
+
+        // Collect audio files in the same folder to try embedded extraction
+        let audio_files_in_folder: Vec<std::path::PathBuf> = std::fs::read_dir(source_folder)
+            .ok()
+            .map(|rd| {
+                rd.filter_map(|e| e.ok())
+                    .filter(|e| {
+                        let name = e.file_name().to_string_lossy().into_owned();
+                        let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+                        AUDIO_EXTENSIONS.contains(&ext.as_str())
+                    })
+                    .map(|e| e.path())
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        match crate::agent::cover_art::find_best_cover(source_folder, &audio_files_in_folder).await
+        {
+            Some(cover) => {
+                let source_desc = match &cover.source {
+                    crate::agent::cover_art::CoverSource::FolderFile(p) => {
+                        format!("folder file: {}", p.display())
+                    }
+                    crate::agent::cover_art::CoverSource::Embedded(p) => {
+                        format!("embedded in: {}", p.display())
+                    }
+                };
+                match crate::agent::cover_art::save_cover_to_storage(
+                    db,
+                    pool,
+                    storage_dir_str,
+                    artist_name,
+                    release_title,
+                    &cover,
+                )
+                .await
+                {
+                    Ok(cover_file_id) => {
+                        let _ = crate::agent::cover_art::assign_cover_to_release(
+                            pool,
+                            release.id_val(),
+                            cover_file_id,
+                        )
+                        .await;
+                        tracing::info!(
+                            release_id = release.id_val(),
+                            cover_file_id,
+                            source = %source_desc,
+                            "Assigned cover art to release"
+                        );
+                    }
+                    Err(e) => {
+                        tracing::warn!(
+                            release_id = release.id_val(),
+                            error = %e,
+                            "Failed to save cover art"
+                        );
+                    }
+                }
+            }
+            None => {
+                tracing::debug!(
+                    release_id = release.id_val(),
+                    "No cover art found for release"
+                );
+            }
+        }
+    }
+
+    tracing::info!(
+        track_id = track.id_val(),
+        artist = artist_name,
+        release = release_title,
+        title = track_title,
+        "Track finalized"
+    );
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async fn find_or_create_artist(
+    db: &cot::db::Database,
+    name: &str,
+    model_name: Option<&str>,
+) -> anyhow::Result<Artist> {
+    let name_sort = name.trim().to_lowercase();
+    let all = Artist::list_all(db).await.unwrap_or_default();
+    for a in &all {
+        if a.name_sort.as_str() == name_sort {
+            return Ok(a.clone());
+        }
+    }
+    Artist::create(db, name, model_name)
+        .await
+        .map_err(|e| anyhow::anyhow!("failed to create artist: {e}"))
+}
+
+async fn find_or_create_release(
+    db: &cot::db::Database,
+    title: &str,
+    release_type: &str,
+    year: Option<i32>,
+    model_name: Option<&str>,
+) -> anyhow::Result<Release> {
+    let title_sort = title.trim().to_lowercase();
+    let all = Release::list_all(db).await.unwrap_or_default();
+    for r in &all {
+        if r.title_sort.as_str() == title_sort && r.release_type.as_str() == release_type {
+            return Ok(r.clone());
+        }
+    }
+    Release::create(db, title, release_type, year, model_name)
+        .await
+        .map_err(|e| anyhow::anyhow!("failed to create release: {e}"))
+}
+
+async fn cleanup_empty_dirs(dir: &Path) -> bool {
+    let mut entries = match tokio::fs::read_dir(dir).await {
+        Ok(e) => e,
+        Err(_) => return false,
+    };
+
+    let mut is_empty = true;
+    while let Ok(Some(entry)) = entries.next_entry().await {
+        let ft = match entry.file_type().await {
+            Ok(ft) => ft,
+            Err(_) => {
+                is_empty = false;
+                continue;
+            }
+        };
+        if ft.is_dir() {
+            let child_empty = Box::pin(cleanup_empty_dirs(&entry.path())).await;
+            if child_empty {
+                let _ = tokio::fs::remove_dir(&entry.path()).await;
+            } else {
+                is_empty = false;
+            }
+        } else {
+            is_empty = false;
+        }
+    }
+    is_empty
+}
+
+fn sanitize_filename(name: &str) -> String {
+    name.chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            _ => c,
+        })
+        .collect::<String>()
+        .trim()
+        .to_owned()
+}
+
+fn truncate_path(path: &str, max_len: usize) -> String {
+    if path.len() <= max_len {
+        path.to_owned()
+    } else {
+        format!("...{}", &path[path.len() - (max_len - 3)..])
+    }
+}
diff --git a/src/jobs/mod.rs b/src/jobs/mod.rs
new file mode 100644
index 0000000..ab9cec3
--- /dev/null
+++ b/src/jobs/mod.rs
@@ -0,0 +1,5 @@
+pub mod artist_image_backfill;
+pub mod artist_track_image_backfill;
+pub mod cover_backfill;
+pub mod inbox_discover;
+pub mod inbox_process;
diff --git a/src/main.rs b/src/main.rs
index 00b8a0b..ee4c400 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,14 @@
 mod admin;
+mod agent;
 mod api;
 mod auth;
 mod config;
 mod i18n;
+mod jobs;
+mod music;
 mod oidc;
+mod player;
+mod scheduler;
 mod user;
 
 use std::sync::Arc;
@@ -12,8 +17,8 @@ use cot::auth::PasswordVerificationResult;
 use cot::cli::CliMetadata;
 use cot::common_types::Password;
 use cot::config::{
-    DatabaseConfig, MiddlewareConfig, ProjectConfig, SessionMiddlewareConfig, SessionStoreConfig,
-    SessionStoreTypeConfig,
+    DatabaseConfig, MiddlewareConfig, ProjectConfig, SameSite, SessionMiddlewareConfig,
+    SessionStoreConfig, SessionStoreTypeConfig,
 };
 use cot::db::Database;
 use cot::form::{Form, FormResult};
@@ -31,8 +36,24 @@ use serde::Deserialize;
 
 use crate::config::AppConfig;
 use crate::i18n::{I18n, Translations};
+use crate::scheduler::{JobRegistry, SchedulerHandle};
 use crate::user::User;
 
+// ---------------------------------------------------------------------------
+// Build the job registry
+// ---------------------------------------------------------------------------
+
+fn build_registry() -> Arc<JobRegistry> {
+    let mut registry = JobRegistry::new();
+    registry.register(jobs::inbox_discover::InboxDiscoverJob);
+    registry.register(jobs::inbox_process::InboxProcessJob);
+    registry.register(jobs::inbox_process::FileProcessJob);
+    registry.register(jobs::cover_backfill::CoverBackfillJob);
+    registry.register(jobs::artist_image_backfill::ArtistImageBackfillJob);
+    registry.register(jobs::artist_track_image_backfill::ArtistTrackImageBackfillJob);
+    Arc::new(registry)
+}
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -42,23 +63,12 @@ async fn index(
     db: Database,
     i18n: I18n,
 ) -> cot::Result<cot::response::Response> {
-    let user = match auth::get_session_user(&session, &db).await {
+    let _user = match auth::get_session_user(&session, &db).await {
         Some(u) => u,
         None => return Ok(auth::redirect("/login")),
     };
-    let role_label = match user.role {
-        auth::Role::Admin => format!(
-            r#"{} | <a href="/admin/">{}</a>"#,
-            user.role.code(),
-            i18n.t.nav_admin
-        ),
-        _ => user.role.code().to_owned(),
-    };
-    Html::new(format!(
-        "<h1>{}</h1><p>{}</p><p>{}: {}</p>",
-        i18n.t.index_heading, i18n.t.index_status, user.name, role_label
-    ))
-    .into_response()
+    let template = player::PlayerPageTemplate { t: i18n.t };
+    Html::new(template.render()?).into_response()
 }
 
 #[derive(Deserialize)]
@@ -154,7 +164,12 @@ impl App for FuruApp {
                 get(|| async { Ok::<_, cot::Error>(auth::redirect("/swagger/")) }),
                 "swagger_redirect",
             ),
-            Route::with_handler_and_name("/", index, "index"),
+            Route::with_handler_and_name("/",
+                |session: Session, db: Database, i18n: I18n| async move {
+                    index(session, db, i18n).await
+                },
+                "index",
+            ),
             Route::with_handler_and_name(
                 "/login",
                 get({
@@ -236,6 +251,8 @@ impl App for FuruApp {
 
 struct FuruProject {
     app_config: Arc<AppConfig>,
+    registry: Arc<JobRegistry>,
+    scheduler_handle: Arc<tokio::sync::OnceCell<Arc<SchedulerHandle>>>,
 }
 
 impl Project for FuruProject {
@@ -289,6 +306,8 @@ impl Project for FuruProject {
                 MiddlewareConfig::builder()
                     .session(
                         SessionMiddlewareConfig::builder()
+                            .secure(false)
+                            .same_site(SameSite::Lax)
                             .store(
                                 SessionStoreConfig::builder()
                                     .store_type(SessionStoreTypeConfig::Database)
@@ -310,14 +329,30 @@ impl Project for FuruProject {
     ) -> cot::project::RootHandler {
         handler
             .middleware(StaticFilesMiddleware::from_context(context))
-            .middleware(
-                SessionMiddleware::from_context(context)
-                    .same_site(cot::config::SameSite::Lax),
-            )
+            .middleware(SessionMiddleware::from_context(context))
             .build()
     }
 
     fn register_apps(&self, apps: &mut AppBuilder, _context: &RegisterAppsContext) {
+        // Spawn the scheduler in background — it runs independently of HTTP
+        // requests.  The OnceCell ensures it starts exactly once.
+        let sched_cell = Arc::clone(&self.scheduler_handle);
+        let sched_config = Arc::clone(&self.app_config);
+        let sched_registry = Arc::clone(&self.registry);
+        tokio::spawn(async move {
+            let _ = sched_cell
+                .get_or_init(|| async {
+                    match scheduler::start_scheduler(&sched_config, sched_registry).await {
+                        Ok(handle) => handle,
+                        Err(e) => {
+                            tracing::error!("Failed to start scheduler: {e:#}");
+                            panic!("scheduler failed to start: {e}");
+                        }
+                    }
+                })
+                .await;
+        });
+
         apps.register(cot::session::db::SessionApp::new());
         apps.register_with_views(
             FuruApp {
@@ -326,10 +361,18 @@ impl Project for FuruProject {
             "",
         );
         apps.register_with_views(
-            admin::AdminApp::new(Arc::clone(&self.app_config)),
+            admin::AdminApp::new(
+                Arc::clone(&self.app_config),
+                Arc::clone(&self.registry),
+                Arc::clone(&self.scheduler_handle),
+            ),
             "/admin",
         );
         apps.register_with_views(api::ApiApp, "/api");
+        apps.register_with_views(
+            player::PlayerApp::new(Arc::clone(&self.app_config)),
+            "/api/player",
+        );
         if self.app_config.swagger_enabled {
             apps.register_with_views(
                 cot::openapi::swagger_ui::SwaggerUi::new(),
@@ -362,5 +405,11 @@ fn main() -> impl Project {
 
     tracing::info!("loaded config: {:?}", app_config);
 
-    FuruProject { app_config }
+    let registry = build_registry();
+
+    FuruProject {
+        app_config,
+        registry,
+        scheduler_handle: Arc::new(tokio::sync::OnceCell::new()),
+    }
 }
diff --git a/src/music/mod.rs b/src/music/mod.rs
new file mode 100644
index 0000000..a581dc4
--- /dev/null
+++ b/src/music/mod.rs
@@ -0,0 +1,1443 @@
+/// Music library models and migrations.
+///
+/// This module contains all database models related to the music library:
+/// content (files, artists, releases, tracks, genres), user interactions
+/// (likes, follows, playlists, play history, playback state), and the
+/// AI-agent processing queue.
+
+use cot::db::{Auto, Database, LimitedString, Model};
+
+// ---------------------------------------------------------------------------
+// MediaFile — audio files and cover art on disk
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct MediaFile {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    /// "audio" or "cover_art"
+    pub file_type: LimitedString<32>,
+    /// Relative path on disk from the media root
+    pub file_path: String,
+    /// Original filename as uploaded
+    pub original_filename: LimitedString<255>,
+    /// MIME type, e.g. "audio/flac", "image/jpeg"
+    pub mime_type: LimitedString<100>,
+    /// File size in bytes
+    pub file_size_bytes: i64,
+    /// SHA-256 hex digest for dedup
+    pub sha256_hash: LimitedString<64>,
+    // Audio-specific fields (NULL for non-audio files)
+    /// e.g. "mp3", "flac", "ogg", "wav"
+    pub audio_format: Option<LimitedString<32>>,
+    /// Bitrate in kbps
+    pub audio_bitrate: Option<i32>,
+    /// Sample rate in Hz
+    pub audio_sample_rate: Option<i32>,
+    /// Bit depth (16, 24, 32)
+    pub audio_bit_depth: Option<i32>,
+    pub created_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// Artist
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct Artist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    /// Canonical display name
+    pub name: LimitedString<255>,
+    /// Normalized for search/dedup (lowercase, stripped)
+    pub name_sort: LimitedString<255>,
+    /// FK → media_file (artist image), nullable
+    pub image_file_id: Option<i64>,
+    pub is_hidden: bool,
+    /// NULL = human-created, non-NULL = LLM model that created it
+    pub model_name: Option<LimitedString<128>>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+}
+
+fn now_iso() -> LimitedString<32> {
+    LimitedString::new(&chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()).unwrap()
+}
+
+fn normalize_name(name: &str) -> String {
+    name.trim().to_lowercase()
+}
+
+impl Artist {
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn get_by_id(db: &Database, artist_id: i64) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, Auto::Fixed(artist_id)).await
+    }
+
+    pub async fn create(
+        db: &Database,
+        name: &str,
+        model_name: Option<&str>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut artist = Self {
+            id: Auto::auto(),
+            name: LimitedString::new(name).unwrap(),
+            name_sort: LimitedString::new(&normalize_name(name)).unwrap(),
+            image_file_id: None,
+            is_hidden: false,
+            model_name: model_name.map(|s| LimitedString::new(s).unwrap()),
+            created_at: now.clone(),
+            updated_at: now,
+        };
+        artist.insert(db).await?;
+        Ok(artist)
+    }
+
+    pub async fn update_name(
+        &mut self,
+        db: &Database,
+        name: &str,
+    ) -> cot::db::Result<()> {
+        self.name = LimitedString::new(name).unwrap();
+        self.name_sort = LimitedString::new(&normalize_name(name)).unwrap();
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_image_file_id(
+        &mut self,
+        db: &Database,
+        file_id: Option<i64>,
+    ) -> cot::db::Result<()> {
+        self.image_file_id = file_id;
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn delete_by_id(db: &Database, artist_id: i64) -> cot::db::Result<()> {
+        cot::db::query!(Artist, $id == Auto::Fixed(artist_id))
+            .delete(db)
+            .await?;
+        Ok(())
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+
+    pub fn name_str(&self) -> &str {
+        &self.name
+    }
+
+    pub fn is_hidden(&self) -> bool {
+        self.is_hidden
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Release (album / single / EP / etc.)
+// ---------------------------------------------------------------------------
+
+pub const RELEASE_TYPES: &[(&str, &str, &str)] = &[
+    ("album", "Album", "Альбом"),
+    ("single", "Single", "Сингл"),
+    ("ep", "EP", "EP"),
+    ("compilation", "Compilation", "Сборник"),
+    ("mixtape", "Mixtape", "Микстейп"),
+    ("live", "Live", "Концерт"),
+    ("soundtrack", "Soundtrack", "Саундтрек"),
+    ("remix", "Remix", "Ремикс"),
+    ("demo", "Demo", "Демо"),
+];
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct Release {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub title: LimitedString<255>,
+    /// Normalized for search/dedup
+    pub title_sort: LimitedString<255>,
+    /// One of: album, single, ep, compilation, mixtape, live, soundtrack, remix, demo
+    pub release_type: LimitedString<32>,
+    pub year: Option<i32>,
+    /// FK → media_file (cover art), nullable
+    pub cover_file_id: Option<i64>,
+    pub total_tracks: Option<i32>,
+    pub total_discs: Option<i32>,
+    pub is_hidden: bool,
+    /// NULL = human-created, non-NULL = LLM model that created it
+    pub model_name: Option<LimitedString<128>>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+}
+
+#[allow(dead_code)]
+impl Release {
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn get_by_id(db: &Database, release_id: i64) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, Auto::Fixed(release_id)).await
+    }
+
+    pub async fn create(
+        db: &Database,
+        title: &str,
+        release_type: &str,
+        year: Option<i32>,
+        model_name: Option<&str>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut release = Self {
+            id: Auto::auto(),
+            title: LimitedString::new(title).unwrap(),
+            title_sort: LimitedString::new(&normalize_name(title)).unwrap(),
+            release_type: LimitedString::new(release_type).unwrap(),
+            year,
+            cover_file_id: None,
+            total_tracks: None,
+            total_discs: None,
+            is_hidden: false,
+            model_name: model_name.map(|s| LimitedString::new(s).unwrap()),
+            created_at: now.clone(),
+            updated_at: now,
+        };
+        release.insert(db).await?;
+        Ok(release)
+    }
+
+    pub async fn update_fields(
+        &mut self,
+        db: &Database,
+        title: &str,
+        release_type: &str,
+        year: Option<i32>,
+    ) -> cot::db::Result<()> {
+        self.title = LimitedString::new(title).unwrap();
+        self.title_sort = LimitedString::new(&normalize_name(title)).unwrap();
+        self.release_type = LimitedString::new(release_type).unwrap();
+        self.year = year;
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn delete_by_id(db: &Database, release_id: i64) -> cot::db::Result<()> {
+        // Also clean up release_artist links
+        cot::db::query!(ReleaseArtist, $release_id == release_id)
+            .delete(db)
+            .await?;
+        cot::db::query!(Release, $id == Auto::Fixed(release_id))
+            .delete(db)
+            .await?;
+        Ok(())
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+
+    pub fn title_str(&self) -> &str {
+        &self.title
+    }
+
+    pub fn release_type_str(&self) -> &str {
+        &self.release_type
+    }
+
+    pub fn year_val(&self) -> Option<i32> {
+        self.year
+    }
+
+    pub fn year_display(&self) -> String {
+        self.year.map(|y| y.to_string()).unwrap_or_default()
+    }
+
+    pub fn is_hidden(&self) -> bool {
+        self.is_hidden
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ReleaseArtist — M2M between releases and artists
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct ReleaseArtist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub release_id: i64,
+    pub artist_id: i64,
+    /// Display order
+    pub position: i32,
+}
+
+impl ReleaseArtist {
+    pub async fn find_by_release(db: &Database, release_id: i64) -> cot::db::Result<Vec<Self>> {
+        cot::db::query!(ReleaseArtist, $release_id == release_id)
+            .all(db)
+            .await
+    }
+
+    pub async fn find_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<Vec<Self>> {
+        cot::db::query!(ReleaseArtist, $artist_id == artist_id)
+            .all(db)
+            .await
+    }
+
+    pub async fn count_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<u64> {
+        cot::db::query!(ReleaseArtist, $artist_id == artist_id)
+            .count(db)
+            .await
+    }
+
+    pub async fn set_artists(
+        db: &Database,
+        release_id: i64,
+        artist_ids: &[i64],
+    ) -> cot::db::Result<()> {
+        // Remove existing links
+        cot::db::query!(ReleaseArtist, $release_id == release_id)
+            .delete(db)
+            .await?;
+        // Insert new links
+        for (pos, &aid) in artist_ids.iter().enumerate() {
+            let mut link = Self {
+                id: Auto::auto(),
+                release_id,
+                artist_id: aid,
+                position: pos as i32,
+            };
+            link.insert(db).await?;
+        }
+        Ok(())
+    }
+
+    pub fn artist_id(&self) -> i64 {
+        self.artist_id
+    }
+
+    pub fn release_id(&self) -> i64 {
+        self.release_id
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Track
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct Track {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub title: LimitedString<255>,
+    /// Normalized for search/dedup
+    pub title_sort: LimitedString<255>,
+    /// FK → release
+    pub release_id: i64,
+    pub track_number: Option<i32>,
+    pub disc_number: Option<i32>,
+    /// Duration in seconds (float stored as f64)
+    pub duration_seconds: f64,
+    /// FK → media_file (audio)
+    pub audio_file_id: i64,
+    /// FK → media_file (cover art), nullable — falls back to release cover
+    pub cover_file_id: Option<i64>,
+    pub year: Option<i32>,
+    pub is_hidden: bool,
+    /// NULL = human-created, non-NULL = LLM model that created it
+    pub model_name: Option<LimitedString<128>>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// TrackArtist — M2M between tracks and artists (with role)
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct TrackArtist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub track_id: i64,
+    pub artist_id: i64,
+    /// "main", "featuring", "remixer", "producer"
+    pub role: LimitedString<32>,
+    /// Display order
+    pub position: i32,
+}
+
+impl TrackArtist {
+    pub async fn count_by_artist(db: &Database, artist_id: i64) -> cot::db::Result<u64> {
+        cot::db::query!(TrackArtist, $artist_id == artist_id)
+            .count(db)
+            .await
+    }
+
+    pub async fn create(
+        db: &Database,
+        track_id: i64,
+        artist_id: i64,
+        role: &str,
+        position: i32,
+    ) -> cot::db::Result<Self> {
+        let mut link = Self {
+            id: Auto::auto(),
+            track_id,
+            artist_id,
+            role: LimitedString::new(role).unwrap(),
+            position,
+        };
+        link.insert(db).await?;
+        Ok(link)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Genre
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct Genre {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub name: LimitedString<100>,
+    /// Normalized for dedup (lowercase, trimmed)
+    pub name_normalized: LimitedString<100>,
+}
+
+// ---------------------------------------------------------------------------
+// TrackGenre — M2M between tracks and genres
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct TrackGenre {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub track_id: i64,
+    pub genre_id: i64,
+}
+
+// ---------------------------------------------------------------------------
+// UserLikedTrack
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct UserLikedTrack {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub user_id: i64,
+    pub track_id: i64,
+    pub created_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// UserFollowedArtist
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct UserFollowedArtist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub user_id: i64,
+    pub artist_id: i64,
+    pub created_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// Playlist
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct Playlist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    /// FK → user (owner/creator)
+    pub owner_id: i64,
+    pub title: LimitedString<255>,
+    pub description: Option<String>,
+    pub is_public: bool,
+    /// FK → media_file (custom cover), nullable
+    pub cover_file_id: Option<i64>,
+    /// FK → playlist (original, if this is a fork), nullable
+    pub forked_from_id: Option<i64>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// PlaylistTrack
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct PlaylistTrack {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub playlist_id: i64,
+    pub track_id: i64,
+    /// Order within the playlist
+    pub position: i32,
+    pub added_at: LimitedString<32>,
+    /// FK → user (who added this track)
+    pub added_by_user_id: i64,
+}
+
+// ---------------------------------------------------------------------------
+// SavedPlaylist — user "follows" someone else's playlist
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct SavedPlaylist {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub user_id: i64,
+    pub playlist_id: i64,
+    pub saved_at: LimitedString<32>,
+}
+
+// ---------------------------------------------------------------------------
+// PlayHistory
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct PlayHistory {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub user_id: i64,
+    pub track_id: i64,
+    pub played_at: LimitedString<32>,
+    /// How many seconds the user actually listened
+    pub duration_listened: Option<i32>,
+    /// Did the user listen to the end?
+    pub completed: bool,
+}
+
+// ---------------------------------------------------------------------------
+// PlaybackState — one per user, current queue + position
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct PlaybackState {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub user_id: i64,
+    /// FK → track (currently playing), nullable
+    pub current_track_id: Option<i64>,
+    /// Current position in the track, in milliseconds
+    pub position_ms: i32,
+    /// JSON array of track IDs
+    pub queue_json: String,
+    /// Index of the current track in the queue
+    pub queue_position: i32,
+    pub shuffle: bool,
+    /// "off", "all", "one"
+    pub repeat_mode: LimitedString<16>,
+    /// Volume level 0.0 – 1.0
+    pub volume: f64,
+    pub updated_at: LimitedString<32>,
+}
+
+impl Track {
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn create(
+        db: &Database,
+        title: &str,
+        release_id: i64,
+        track_number: Option<i32>,
+        disc_number: Option<i32>,
+        duration_seconds: f64,
+        audio_file_id: i64,
+        year: Option<i32>,
+        model_name: Option<&str>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut track = Self {
+            id: Auto::auto(),
+            title: LimitedString::new(title).unwrap(),
+            title_sort: LimitedString::new(&normalize_name(title)).unwrap(),
+            release_id,
+            track_number,
+            disc_number,
+            duration_seconds,
+            audio_file_id,
+            cover_file_id: None,
+            year,
+            is_hidden: false,
+            model_name: model_name.map(|s| LimitedString::new(s).unwrap()),
+            created_at: now.clone(),
+            updated_at: now,
+        };
+        track.insert(db).await?;
+        Ok(track)
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+}
+
+#[allow(dead_code)]
+impl MediaFile {
+    pub async fn create(
+        db: &Database,
+        file_type: &str,
+        file_path: &str,
+        original_filename: &str,
+        mime_type: &str,
+        file_size_bytes: i64,
+        sha256_hash: &str,
+        audio_format: Option<&str>,
+        audio_bitrate: Option<i32>,
+        audio_sample_rate: Option<i32>,
+        audio_bit_depth: Option<i32>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut mf = Self {
+            id: Auto::auto(),
+            file_type: LimitedString::new(file_type).unwrap(),
+            file_path: file_path.to_owned(),
+            original_filename: LimitedString::new(original_filename).unwrap(),
+            mime_type: LimitedString::new(mime_type).unwrap(),
+            file_size_bytes,
+            sha256_hash: LimitedString::new(sha256_hash).unwrap(),
+            audio_format: audio_format.map(|s| LimitedString::new(s).unwrap()),
+            audio_bitrate,
+            audio_sample_rate,
+            audio_bit_depth,
+            created_at: now,
+        };
+        mf.insert(db).await?;
+        Ok(mf)
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn get_by_id(db: &Database, id: i64) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, Auto::Fixed(id)).await
+    }
+
+    pub async fn delete_by_id(db: &Database, id: i64) -> cot::db::Result<()> {
+        db.raw(&format!(
+            "DELETE FROM furumusic__media_file WHERE id = {}",
+            id
+        ))
+        .await?;
+        Ok(())
+    }
+
+    pub fn file_type_str(&self) -> &str {
+        &self.file_type
+    }
+
+    pub fn file_path_str(&self) -> &str {
+        &self.file_path
+    }
+
+    pub fn original_filename_str(&self) -> &str {
+        &self.original_filename
+    }
+
+    pub fn mime_type_str(&self) -> &str {
+        &self.mime_type
+    }
+
+    pub fn sha256_hash_str(&self) -> &str {
+        &self.sha256_hash
+    }
+
+    pub fn audio_format_str(&self) -> &str {
+        self.audio_format.as_ref().map_or("", |s| s.as_str())
+    }
+
+    pub fn created_at_str(&self) -> &str {
+        &self.created_at
+    }
+
+    pub fn file_size_display(&self) -> String {
+        let bytes = self.file_size_bytes;
+        if bytes >= 1_073_741_824 {
+            format!("{:.1} GB", bytes as f64 / 1_073_741_824.0)
+        } else if bytes >= 1_048_576 {
+            format!("{:.1} MB", bytes as f64 / 1_048_576.0)
+        } else if bytes >= 1024 {
+            format!("{:.1} KB", bytes as f64 / 1024.0)
+        } else {
+            format!("{bytes} B")
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Migrations
+// ---------------------------------------------------------------------------
+
+pub mod db_migrations {
+    use cot::db::migrations::{self, Field, Operation, SyncDynMigration};
+    use cot::db::{DatabaseField, Identifier, LimitedString};
+
+    // -- M0006: create furumusic__media_file ----------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0006CreateMediaFile;
+
+    impl migrations::Migration for M0006CreateMediaFile {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0006_create_media_file";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0005_oidc_link_indexes",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__media_file"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("file_type"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("file_path"), <String as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("original_filename"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("mime_type"), <LimitedString<100> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("file_size_bytes"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("sha256_hash"), <LimitedString<64> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("audio_format"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("audio_bitrate"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("audio_sample_rate"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("audio_bit_depth"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0007: create furumusic__artist --------------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0007CreateArtist;
+
+    impl migrations::Migration for M0007CreateArtist {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0007_create_artist";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0006_create_media_file",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__artist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("name"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("name_sort"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("image_file_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("is_hidden"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0008: create furumusic__release -------------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0008CreateRelease;
+
+    impl migrations::Migration for M0008CreateRelease {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0008_create_release";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0007_create_artist",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__release"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("title"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("title_sort"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("release_type"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("year"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("cover_file_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("total_tracks"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("total_discs"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("is_hidden"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0009: create furumusic__release_artist ------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0009CreateReleaseArtist;
+
+    impl migrations::Migration for M0009CreateReleaseArtist {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0009_create_release_artist";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0008_create_release",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__release_artist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("release_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("artist_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("position"), <i32 as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0010: create furumusic__track ---------------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0010CreateTrack;
+
+    impl migrations::Migration for M0010CreateTrack {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0010_create_track";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0009_create_release_artist",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__track"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("title"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("title_sort"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("release_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("track_number"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("disc_number"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("duration_seconds"), <f64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("audio_file_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("cover_file_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("year"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("is_hidden"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0011: create furumusic__track_artist --------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0011CreateTrackArtist;
+
+    impl migrations::Migration for M0011CreateTrackArtist {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0011_create_track_artist";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0010_create_track",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__track_artist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("track_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("artist_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("role"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("position"), <i32 as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0012: create furumusic__genre + furumusic__track_genre ---------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0012CreateGenreTables;
+
+    impl migrations::Migration for M0012CreateGenreTables {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0012_create_genre_tables";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0011_create_track_artist",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__genre"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("name"), <LimitedString<100> as DatabaseField>::TYPE)
+                        .unique(),
+                    Field::new(Identifier::new("name_normalized"), <LimitedString<100> as DatabaseField>::TYPE),
+                ])
+                .build(),
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__track_genre"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("track_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("genre_id"), <i64 as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0013: create furumusic__user_liked_track ----------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0013CreateUserLikedTrack;
+
+    impl migrations::Migration for M0013CreateUserLikedTrack {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0013_create_user_liked_track";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0012_create_genre_tables",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__user_liked_track"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("user_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("track_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0014: create furumusic__user_followed_artist ------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0014CreateUserFollowedArtist;
+
+    impl migrations::Migration for M0014CreateUserFollowedArtist {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0014_create_user_followed_artist";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0013_create_user_liked_track",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__user_followed_artist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("user_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("artist_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0015: create playlist tables ----------------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0015CreatePlaylistTables;
+
+    impl migrations::Migration for M0015CreatePlaylistTables {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0015_create_playlist_tables";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0014_create_user_followed_artist",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__playlist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("owner_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("title"), <LimitedString<255> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("description"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("is_public"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("cover_file_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("forked_from_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__playlist_track"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("playlist_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("track_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("position"), <i32 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("added_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("added_by_user_id"), <i64 as DatabaseField>::TYPE),
+                ])
+                .build(),
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__saved_playlist"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("user_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("playlist_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("saved_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0016: create furumusic__play_history --------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0016CreatePlayHistory;
+
+    impl migrations::Migration for M0016CreatePlayHistory {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0016_create_play_history";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0015_create_playlist_tables",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__play_history"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("user_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("track_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("played_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("duration_listened"), <i32 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("completed"), <bool as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0017: create furumusic__playback_state ------------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0017CreatePlaybackState;
+
+    impl migrations::Migration for M0017CreatePlaybackState {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0017_create_playback_state";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0016_create_play_history",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__playback_state"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("user_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("current_track_id"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("position_ms"), <i32 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("queue_json"), <String as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("queue_position"), <i32 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("shuffle"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("repeat_mode"), <LimitedString<16> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0018: create furumusic__processing_task -----------------------------
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0018CreateProcessingTask;
+
+    impl migrations::Migration for M0018CreateProcessingTask {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0018_create_processing_task";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0017_create_playback_state",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__processing_task"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("status"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("task_type"), <LimitedString<64> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("input_path"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("context_json"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("result_json"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("error_message"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("attempts"), <i32 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("max_attempts"), <i32 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("started_at"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("completed_at"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                ])
+                .build(),
+        ];
+    }
+
+    // -- M0019: indexes for all music tables ----------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_music_indexes(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        let stmts = [
+            // media_file: lookup by hash for dedup
+            "CREATE INDEX idx_media_file_sha256 ON furumusic__media_file (sha256_hash)",
+            // media_file: filter by type
+            "CREATE INDEX idx_media_file_type ON furumusic__media_file (file_type)",
+
+            // artist: search by normalized name
+            "CREATE INDEX idx_artist_name_sort ON furumusic__artist (name_sort)",
+
+            // release: search by normalized title
+            "CREATE INDEX idx_release_title_sort ON furumusic__release (title_sort)",
+            // release: filter by type
+            "CREATE INDEX idx_release_type ON furumusic__release (release_type)",
+
+            // release_artist: unique pair + lookup
+            "CREATE UNIQUE INDEX idx_release_artist_uniq ON furumusic__release_artist (release_id, artist_id)",
+            "CREATE INDEX idx_release_artist_artist ON furumusic__release_artist (artist_id)",
+
+            // track: search by normalized title
+            "CREATE INDEX idx_track_title_sort ON furumusic__track (title_sort)",
+            // track: FK to release
+            "CREATE INDEX idx_track_release ON furumusic__track (release_id)",
+            // track: FK to audio file
+            "CREATE INDEX idx_track_audio_file ON furumusic__track (audio_file_id)",
+
+            // track_artist: unique triple + lookups
+            "CREATE UNIQUE INDEX idx_track_artist_uniq ON furumusic__track_artist (track_id, artist_id, role)",
+            "CREATE INDEX idx_track_artist_artist ON furumusic__track_artist (artist_id)",
+
+            // track_genre: unique pair + lookup
+            "CREATE UNIQUE INDEX idx_track_genre_uniq ON furumusic__track_genre (track_id, genre_id)",
+            "CREATE INDEX idx_track_genre_genre ON furumusic__track_genre (genre_id)",
+
+            // genre: lookup by normalized name
+            "CREATE INDEX idx_genre_normalized ON furumusic__genre (name_normalized)",
+
+            // user_liked_track: unique pair + lookup by track
+            "CREATE UNIQUE INDEX idx_user_liked_track_uniq ON furumusic__user_liked_track (user_id, track_id)",
+            "CREATE INDEX idx_user_liked_track_track ON furumusic__user_liked_track (track_id)",
+
+            // user_followed_artist: unique pair + lookup by artist
+            "CREATE UNIQUE INDEX idx_user_followed_artist_uniq ON furumusic__user_followed_artist (user_id, artist_id)",
+            "CREATE INDEX idx_user_followed_artist_artist ON furumusic__user_followed_artist (artist_id)",
+
+            // playlist: owner lookup
+            "CREATE INDEX idx_playlist_owner ON furumusic__playlist (owner_id)",
+
+            // playlist_track: ordered tracks in playlist + lookup by track
+            "CREATE INDEX idx_playlist_track_playlist ON furumusic__playlist_track (playlist_id, position)",
+            "CREATE INDEX idx_playlist_track_track ON furumusic__playlist_track (track_id)",
+
+            // saved_playlist: unique pair + lookup by playlist
+            "CREATE UNIQUE INDEX idx_saved_playlist_uniq ON furumusic__saved_playlist (user_id, playlist_id)",
+            "CREATE INDEX idx_saved_playlist_playlist ON furumusic__saved_playlist (playlist_id)",
+
+            // play_history: user timeline + lookup by track
+            "CREATE INDEX idx_play_history_user ON furumusic__play_history (user_id, played_at)",
+            "CREATE INDEX idx_play_history_track ON furumusic__play_history (track_id)",
+
+            // playback_state: one per user
+            "CREATE UNIQUE INDEX idx_playback_state_user ON furumusic__playback_state (user_id)",
+
+            // processing_task: queue polling (status + created_at)
+            "CREATE INDEX idx_processing_task_status ON furumusic__processing_task (status, created_at)",
+        ];
+
+        for stmt in stmts {
+            ctx.db.raw(stmt).await?;
+        }
+
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0019CreateMusicIndexes;
+
+    impl migrations::Migration for M0019CreateMusicIndexes {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0019_create_music_indexes";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0018_create_processing_task",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(create_music_indexes).build(),
+        ];
+    }
+
+    // -- M0020: enable pg_trgm extension --------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn enable_pg_trgm(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0020EnablePgTrgm;
+
+    impl migrations::Migration for M0020EnablePgTrgm {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0020_enable_pg_trgm";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0019_create_music_indexes",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(enable_pg_trgm).build(),
+        ];
+    }
+
+    // -- M0021: GIN trigram indexes for fuzzy search --------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_trgm_indexes(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db.raw("CREATE INDEX idx_artist_name_sort_trgm ON furumusic__artist USING gin (name_sort gin_trgm_ops)").await?;
+        ctx.db.raw("CREATE INDEX idx_release_title_sort_trgm ON furumusic__release USING gin (title_sort gin_trgm_ops)").await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0021CreateTrgmIndexes;
+
+    impl migrations::Migration for M0021CreateTrgmIndexes {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0021_create_trgm_indexes";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0020_enable_pg_trgm",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(create_trgm_indexes).build(),
+        ];
+    }
+
+    // -- M0022: GIN trigram index on track.title_sort ---------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_track_trgm_index(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db.raw("CREATE INDEX IF NOT EXISTS idx_track_title_sort_trgm ON furumusic__track USING gin (title_sort gin_trgm_ops)").await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0022CreateTrackTrgmIndex;
+
+    impl migrations::Migration for M0022CreateTrackTrgmIndex {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0022_create_track_trgm_index";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0021_create_trgm_indexes",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(create_track_trgm_index).build(),
+        ];
+    }
+
+    // -- M0028: add model_name to artist, release, track -----------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn add_model_name_columns(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db
+            .raw("ALTER TABLE furumusic__artist ADD COLUMN model_name VARCHAR(128) DEFAULT NULL")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__release ADD COLUMN model_name VARCHAR(128) DEFAULT NULL")
+            .await?;
+        ctx.db
+            .raw("ALTER TABLE furumusic__track ADD COLUMN model_name VARCHAR(128) DEFAULT NULL")
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0028AddModelNameColumns;
+
+    impl migrations::Migration for M0028AddModelNameColumns {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0028_add_model_name_columns";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0027_create_processing_stats",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(add_model_name_columns).build(),
+        ];
+    }
+
+    // -- M0029: add volume column to playback_state ----------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn add_playback_volume(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db
+            .raw("ALTER TABLE furumusic__playback_state ADD COLUMN volume DOUBLE PRECISION NOT NULL DEFAULT 0.7")
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0029AddPlaybackVolume;
+
+    impl migrations::Migration for M0029AddPlaybackVolume {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0029_add_playback_volume";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0028_add_model_name_columns",
+            ),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(add_playback_volume).build(),
+        ];
+    }
+
+    pub const MIGRATIONS: &[&SyncDynMigration] = &[
+        &M0006CreateMediaFile,
+        &M0007CreateArtist,
+        &M0008CreateRelease,
+        &M0009CreateReleaseArtist,
+        &M0010CreateTrack,
+        &M0011CreateTrackArtist,
+        &M0012CreateGenreTables,
+        &M0013CreateUserLikedTrack,
+        &M0014CreateUserFollowedArtist,
+        &M0015CreatePlaylistTables,
+        &M0016CreatePlayHistory,
+        &M0017CreatePlaybackState,
+        &M0018CreateProcessingTask,
+        &M0019CreateMusicIndexes,
+        &M0020EnablePgTrgm,
+        &M0021CreateTrgmIndexes,
+        &M0022CreateTrackTrgmIndex,
+        &M0028AddModelNameColumns,
+        &M0029AddPlaybackVolume,
+    ];
+}
diff --git a/src/oidc.rs b/src/oidc.rs
index d406a63..4339c2e 100644
--- a/src/oidc.rs
+++ b/src/oidc.rs
@@ -190,6 +190,11 @@ pub async fn oidc_start_handler(
     let redirect_url = RedirectUrl::new(redirect_uri_str.clone())
         .map_err(|e| cot::Error::internal(format!("bad redirect URI: {e}")))?;
     let client = client.set_redirect_uri(redirect_url);
+    tracing::info!(
+        redirect_uri = %redirect_uri_str,
+        oidc_issuer = %config.oidc_issuer,
+        "OIDC start: building authorization request",
+    );
 
     // Build PKCE challenge.
     let (pkce_challenge, pkce_verifier) = PkceCodeChallenge::new_random_sha256();
@@ -206,6 +211,7 @@ pub async fn oidc_start_handler(
         .add_scope(Scope::new("profile".to_string()))
         .set_pkce_challenge(pkce_challenge)
         .url();
+    tracing::info!(auth_url = %auth_url, "OIDC start: redirecting to provider");
 
     // Store OIDC flow state in the session.
     session
diff --git a/src/player/mod.rs b/src/player/mod.rs
new file mode 100644
index 0000000..07199c1
--- /dev/null
+++ b/src/player/mod.rs
@@ -0,0 +1,2440 @@
+use std::sync::Arc;
+
+use cot::db::Database;
+use cot::http::header::{ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE};
+use cot::http::StatusCode;
+use cot::json::Json;
+use cot::request::extractors::Path;
+use cot::response::IntoResponse;
+use cot::router::method::{get, post};
+use cot::router::{Route, Router};
+use cot::session::Session;
+use cot::{App, Body, Template};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::auth;
+use crate::config::AppConfig;
+use crate::i18n::Translations;
+
+// ---------------------------------------------------------------------------
+// JSON error helper
+// ---------------------------------------------------------------------------
+
+fn json_error(status: StatusCode, message: &str) -> cot::response::Response {
+    let body = serde_json::json!({ "error": message });
+    cot::http::Response::builder()
+        .status(status)
+        .header(CONTENT_TYPE, "application/json")
+        .body(Body::fixed(body.to_string()))
+        .expect("valid response")
+}
+
+// ---------------------------------------------------------------------------
+// DTO structs
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ArtistCard {
+    id: i64,
+    name: String,
+    image_url: Option<String>,
+    release_count: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct Paginated<T: Serialize> {
+    items: Vec<T>,
+    total: i64,
+    page: i32,
+    per_page: i32,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ReleaseCard {
+    id: i64,
+    title: String,
+    release_type: String,
+    year: Option<i32>,
+    cover_url: Option<String>,
+    track_count: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ArtistDetail {
+    id: i64,
+    name: String,
+    image_url: Option<String>,
+    releases: Vec<ReleaseCard>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ArtistRef {
+    id: i64,
+    name: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct TrackItem {
+    id: i64,
+    title: String,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
+    duration_seconds: f64,
+    artists: Vec<ArtistRef>,
+    featured_artists: Vec<ArtistRef>,
+    cover_url: Option<String>,
+    stream_url: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ReleaseDetail {
+    id: i64,
+    title: String,
+    release_type: String,
+    year: Option<i32>,
+    cover_url: Option<String>,
+    artists: Vec<ArtistRef>,
+    tracks: Vec<TrackItem>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct PlaylistCard {
+    id: i64,
+    title: String,
+    track_count: i64,
+    is_own: bool,
+    kind: String, // "user" or "likes"
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+struct PlaybackStateDto {
+    current_track_id: Option<i64>,
+    position_ms: i32,
+    queue: Vec<i64>,
+    queue_position: i32,
+    shuffle: bool,
+    repeat_mode: String,
+    volume: f64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct PlaylistDetail {
+    id: i64,
+    title: String,
+    description: Option<String>,
+    is_own: bool,
+    kind: String,
+    tracks: Vec<TrackItem>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct SearchResults {
+    artists: Vec<ArtistCard>,
+    releases: Vec<ReleaseCard>,
+    tracks: Vec<TrackItem>,
+}
+
+#[derive(Debug, Deserialize)]
+struct HistoryEntry {
+    track_id: i64,
+    duration_listened: Option<i32>,
+    completed: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct TracksByIdsRequest {
+    ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CreatePlaylistRequest {
+    title: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct UpdatePlaylistRequest {
+    title: Option<String>,
+    description: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AddTracksRequest {
+    track_ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RemoveTrackRequest {
+    track_id: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct LikeStatus {
+    liked: bool,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct LikedIds {
+    track_ids: Vec<i64>,
+}
+
+
+// ---------------------------------------------------------------------------
+// Query helpers
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Deserialize)]
+struct PaginationQuery {
+    page: Option<i32>,
+    limit: Option<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PathId {
+    id: i64,
+}
+
+#[derive(Debug, Deserialize)]
+struct SearchQuery {
+    q: String,
+    limit: Option<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PathTrackId {
+    track_id: i64,
+}
+
+#[derive(Debug, Deserialize)]
+struct PathMediaFileId {
+    media_file_id: i64,
+}
+
+// ---------------------------------------------------------------------------
+// sqlx row types
+// ---------------------------------------------------------------------------
+
+#[derive(sqlx::FromRow)]
+struct ArtistRow {
+    id: i64,
+    name: String,
+    image_file_id: Option<i64>,
+    release_count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct CountRow {
+    count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct ReleaseRow {
+    id: i64,
+    title: String,
+    release_type: String,
+    year: Option<i32>,
+    cover_file_id: Option<i64>,
+    track_count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct ArtistBriefRow {
+    id: i64,
+    name: String,
+}
+
+#[derive(sqlx::FromRow)]
+struct TrackRow {
+    id: i64,
+    title: String,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
+    duration_seconds: f64,
+    cover_file_id: Option<i64>,
+    release_cover_file_id: Option<i64>,
+}
+
+#[derive(sqlx::FromRow)]
+struct TrackArtistRow {
+    track_id: i64,
+    artist_id: i64,
+    artist_name: String,
+    role: String,
+}
+
+#[derive(sqlx::FromRow)]
+struct MediaFileRow {
+    file_path: String,
+    mime_type: String,
+    file_size_bytes: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct PlaybackStateRow {
+    current_track_id: Option<i64>,
+    position_ms: i32,
+    queue_json: String,
+    queue_position: i32,
+    shuffle: bool,
+    repeat_mode: String,
+    volume: f64,
+}
+
+#[derive(sqlx::FromRow)]
+struct PlaylistRow {
+    id: i64,
+    title: String,
+    track_count: i64,
+    is_own: bool,
+}
+
+#[derive(sqlx::FromRow)]
+struct PlaylistInfoRow {
+    id: i64,
+    title: String,
+    description: Option<String>,
+    owner_id: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct PlaylistTrackRow {
+    id: i64,
+    title: String,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
+    duration_seconds: f64,
+    cover_file_id: Option<i64>,
+    release_cover_file_id: Option<i64>,
+}
+
+#[derive(sqlx::FromRow)]
+struct SearchArtistRow {
+    id: i64,
+    name: String,
+    image_file_id: Option<i64>,
+    release_count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct SearchReleaseRow {
+    id: i64,
+    title: String,
+    release_type: String,
+    year: Option<i32>,
+    cover_file_id: Option<i64>,
+    track_count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+struct SearchTrackRow {
+    id: i64,
+    title: String,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
+    duration_seconds: f64,
+    cover_file_id: Option<i64>,
+    release_cover_file_id: Option<i64>,
+}
+
+#[derive(sqlx::FromRow)]
+struct ReleaseInfoRow {
+    id: i64,
+    title: String,
+    release_type: String,
+    year: Option<i32>,
+    cover_file_id: Option<i64>,
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn cover_url(file_id: Option<i64>) -> Option<String> {
+    file_id.map(|id| format!("/api/player/cover/{id}"))
+}
+
+fn track_cover_url(track_cover: Option<i64>, release_cover: Option<i64>) -> Option<String> {
+    cover_url(track_cover.or(release_cover))
+}
+
+// ---------------------------------------------------------------------------
+// SPA shell
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Template)]
+#[template(path = "player.html")]
+pub struct PlayerPageTemplate {
+    pub t: &'static Translations,
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/artists?page=N&limit=N
+// ---------------------------------------------------------------------------
+
+async fn artists_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    query: cot::request::extractors::UrlQuery<PaginationQuery>,
+) -> 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 page = query.0.page.unwrap_or(1).max(1);
+    let per_page = query.0.limit.unwrap_or(60).clamp(1, 200);
+    let offset = (page - 1) as i64 * per_page as i64;
+
+    let total_row = sqlx::query_as::<_, CountRow>(
+        "SELECT COUNT(*) as count FROM furumusic__artist WHERE is_hidden = false",
+    )
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let rows = sqlx::query_as::<_, ArtistRow>(
+        r#"SELECT a.id, a.name::text as name, a.image_file_id,
+           COALESCE((SELECT COUNT(*) FROM furumusic__release_artist ra
+                     JOIN furumusic__release r ON r.id = ra.release_id AND r.is_hidden = false
+                     WHERE ra.artist_id = a.id), 0) as release_count
+           FROM furumusic__artist a
+           WHERE a.is_hidden = false
+           ORDER BY a.name_sort
+           LIMIT $1 OFFSET $2"#,
+    )
+    .bind(per_page as i64)
+    .bind(offset)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let items: Vec<ArtistCard> = rows
+        .into_iter()
+        .map(|r| ArtistCard {
+            id: r.id,
+            name: r.name,
+            image_url: cover_url(r.image_file_id),
+            release_count: r.release_count,
+        })
+        .collect();
+
+    Json(Paginated {
+        items,
+        total: total_row.count,
+        page,
+        per_page,
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/artists/{id}
+// ---------------------------------------------------------------------------
+
+async fn artist_detail_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+) -> 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 artist_id = path.0.id;
+
+    let artist = sqlx::query_as::<_, ArtistBriefRow>(
+        "SELECT id, name::text as name FROM furumusic__artist WHERE id = $1 AND is_hidden = false",
+    )
+    .bind(artist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let Some(artist) = artist else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "artist not found"));
+    };
+
+    let image_file_id: Option<i64> = sqlx::query_scalar(
+        "SELECT image_file_id FROM furumusic__artist WHERE id = $1",
+    )
+    .bind(artist_id)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let releases = sqlx::query_as::<_, ReleaseRow>(
+        r#"SELECT r.id, r.title::text as title, r.release_type::text as release_type,
+                  r.year, r.cover_file_id,
+                  COALESCE((SELECT COUNT(*) FROM furumusic__track t WHERE t.release_id = r.id AND t.is_hidden = false), 0) as track_count
+           FROM furumusic__release r
+           JOIN furumusic__release_artist ra ON ra.release_id = r.id
+           WHERE ra.artist_id = $1 AND r.is_hidden = false
+           ORDER BY r.year DESC NULLS LAST, r.title_sort"#,
+    )
+    .bind(artist_id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let release_cards: Vec<ReleaseCard> = releases
+        .into_iter()
+        .map(|r| ReleaseCard {
+            id: r.id,
+            title: r.title,
+            release_type: r.release_type,
+            year: r.year,
+            cover_url: cover_url(r.cover_file_id),
+            track_count: r.track_count,
+        })
+        .collect();
+
+    Json(ArtistDetail {
+        id: artist.id,
+        name: artist.name,
+        image_url: cover_url(image_file_id),
+        releases: release_cards,
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/releases/{id}
+// ---------------------------------------------------------------------------
+
+async fn release_detail_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+) -> 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 release_id = path.0.id;
+
+    let release = sqlx::query_as::<_, ReleaseInfoRow>(
+        r#"SELECT id, title::text as title, release_type::text as release_type, year, cover_file_id
+           FROM furumusic__release WHERE id = $1 AND is_hidden = false"#,
+    )
+    .bind(release_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let Some(release) = release else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "release not found"));
+    };
+
+    // Release artists
+    let release_artists = sqlx::query_as::<_, ArtistBriefRow>(
+        r#"SELECT a.id, a.name::text as name
+           FROM furumusic__artist a
+           JOIN furumusic__release_artist ra ON ra.artist_id = a.id
+           WHERE ra.release_id = $1
+           ORDER BY ra.position"#,
+    )
+    .bind(release_id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    // Tracks
+    let tracks = sqlx::query_as::<_, TrackRow>(
+        r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
+                  t.duration_seconds, t.cover_file_id,
+                  r.cover_file_id as release_cover_file_id
+           FROM furumusic__track t
+           JOIN furumusic__release r ON r.id = t.release_id
+           WHERE t.release_id = $1 AND t.is_hidden = false
+           ORDER BY t.disc_number NULLS FIRST, t.track_number NULLS LAST"#,
+    )
+    .bind(release_id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let track_ids: Vec<i64> = tracks.iter().map(|t| t.id).collect();
+
+    // Track artists (batch)
+    let track_artists = if track_ids.is_empty() {
+        Vec::new()
+    } else {
+        sqlx::query_as::<_, TrackArtistRow>(
+            r#"SELECT ta.track_id, ta.artist_id, a.name::text as artist_name, ta.role::text as role
+               FROM furumusic__track_artist ta
+               JOIN furumusic__artist a ON a.id = ta.artist_id
+               WHERE ta.track_id = ANY($1)
+               ORDER BY ta.track_id, ta.position"#,
+        )
+        .bind(&track_ids)
+        .fetch_all(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    };
+
+    // Group track artists
+    let mut track_main_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+    let mut track_feat_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+
+    for ta in &track_artists {
+        let artist_ref = ArtistRef {
+            id: ta.artist_id,
+            name: ta.artist_name.clone(),
+        };
+        if ta.role == "featuring" {
+            track_feat_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        } else {
+            track_main_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        }
+    }
+
+    let track_items: Vec<TrackItem> = tracks
+        .into_iter()
+        .map(|t| {
+            let tid = t.id;
+            TrackItem {
+                id: t.id,
+                title: t.title,
+                track_number: t.track_number,
+                disc_number: t.disc_number,
+                duration_seconds: t.duration_seconds,
+                artists: track_main_artists.remove(&tid).unwrap_or_default(),
+                featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                stream_url: format!("/api/player/stream/{tid}"),
+            }
+        })
+        .collect();
+
+    Json(ReleaseDetail {
+        id: release.id,
+        title: release.title,
+        release_type: release.release_type,
+        year: release.year,
+        cover_url: cover_url(release.cover_file_id),
+        artists: release_artists
+            .into_iter()
+            .map(|a| ArtistRef {
+                id: a.id,
+                name: a.name,
+            })
+            .collect(),
+        tracks: track_items,
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/playlists
+// ---------------------------------------------------------------------------
+
+async fn playlists_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"));
+    };
+
+    // Count liked tracks for the virtual Likes playlist
+    let likes_count: (i64,) = sqlx::query_as(
+        "SELECT COUNT(*) FROM furumusic__user_liked_track WHERE user_id = $1",
+    )
+    .bind(user.id)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let mut cards = vec![PlaylistCard {
+        id: -1,
+        title: "Likes".to_string(),
+        track_count: likes_count.0,
+        is_own: true,
+        kind: "likes".to_string(),
+    }];
+
+    let rows = sqlx::query_as::<_, PlaylistRow>(
+        r#"SELECT p.id, p.title::text as title,
+                  COALESCE((SELECT COUNT(*) FROM furumusic__playlist_track pt WHERE pt.playlist_id = p.id), 0) as track_count,
+                  (p.owner_id = $1) as is_own
+           FROM furumusic__playlist p
+           WHERE p.owner_id = $1
+              OR p.id IN (SELECT sp.playlist_id FROM furumusic__saved_playlist sp WHERE sp.user_id = $1)
+              OR p.is_public = true
+           ORDER BY p.title"#,
+    )
+    .bind(user.id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    cards.extend(rows.into_iter().map(|r| PlaylistCard {
+        id: r.id,
+        title: r.title,
+        track_count: r.track_count,
+        is_own: r.is_own,
+        kind: "user".to_string(),
+    }));
+
+    Json(cards).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/playlists/{id}
+// ---------------------------------------------------------------------------
+
+async fn playlist_detail_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+) -> 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 playlist_id = path.0.id;
+
+    // Virtual Likes playlist (id = -1)
+    if playlist_id == -1 {
+        return likes_playlist_handler(user.id, pool).await;
+    }
+
+    let info = sqlx::query_as::<_, PlaylistInfoRow>(
+        "SELECT id, title::text as title, description, owner_id FROM furumusic__playlist WHERE id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let Some(info) = info else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "playlist not found"));
+    };
+
+    let tracks = sqlx::query_as::<_, PlaylistTrackRow>(
+        r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
+                  t.duration_seconds, t.cover_file_id,
+                  r.cover_file_id as release_cover_file_id
+           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
+           WHERE pt.playlist_id = $1 AND t.is_hidden = false
+           ORDER BY pt.position"#,
+    )
+    .bind(playlist_id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let track_items = build_track_items(tracks, pool).await?;
+
+    Json(PlaylistDetail {
+        id: info.id,
+        title: info.title,
+        description: info.description,
+        is_own: info.owner_id == user.id,
+        kind: "user".to_string(),
+        tracks: track_items,
+    })
+    .into_response()
+}
+
+/// Shared helper: given PlaylistTrackRows, fetch artists and build TrackItems.
+async fn build_track_items(
+    tracks: Vec<PlaylistTrackRow>,
+    pool: &sqlx::PgPool,
+) -> cot::Result<Vec<TrackItem>> {
+    let track_ids: Vec<i64> = tracks.iter().map(|t| t.id).collect();
+
+    let track_artists = if track_ids.is_empty() {
+        Vec::new()
+    } else {
+        sqlx::query_as::<_, TrackArtistRow>(
+            r#"SELECT ta.track_id, ta.artist_id, a.name::text as artist_name, ta.role::text as role
+               FROM furumusic__track_artist ta
+               JOIN furumusic__artist a ON a.id = ta.artist_id
+               WHERE ta.track_id = ANY($1)
+               ORDER BY ta.track_id, ta.position"#,
+        )
+        .bind(&track_ids)
+        .fetch_all(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    };
+
+    let mut track_main_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+    let mut track_feat_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+
+    for ta in &track_artists {
+        let artist_ref = ArtistRef {
+            id: ta.artist_id,
+            name: ta.artist_name.clone(),
+        };
+        if ta.role == "featuring" {
+            track_feat_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        } else {
+            track_main_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        }
+    }
+
+    Ok(tracks
+        .into_iter()
+        .map(|t| {
+            let tid = t.id;
+            TrackItem {
+                id: t.id,
+                title: t.title,
+                track_number: t.track_number,
+                disc_number: t.disc_number,
+                duration_seconds: t.duration_seconds,
+                artists: track_main_artists.remove(&tid).unwrap_or_default(),
+                featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                stream_url: format!("/api/player/stream/{tid}"),
+            }
+        })
+        .collect())
+}
+
+/// Return the virtual "Likes" playlist for a given user.
+async fn likes_playlist_handler(
+    user_id: i64,
+    pool: &sqlx::PgPool,
+) -> cot::Result<cot::response::Response> {
+    let tracks = sqlx::query_as::<_, PlaylistTrackRow>(
+        r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
+                  t.duration_seconds, t.cover_file_id,
+                  r.cover_file_id as release_cover_file_id
+           FROM furumusic__user_liked_track ult
+           JOIN furumusic__track t ON t.id = ult.track_id
+           JOIN furumusic__release r ON r.id = t.release_id
+           WHERE ult.user_id = $1 AND t.is_hidden = false
+           ORDER BY ult.created_at DESC"#,
+    )
+    .bind(user_id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let track_items = build_track_items(tracks, pool).await?;
+
+    Json(PlaylistDetail {
+        id: -1,
+        title: "Likes".to_string(),
+        description: None,
+        is_own: true,
+        kind: "likes".to_string(),
+        tracks: track_items,
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/stream/{track_id}  — Range-aware audio streaming
+// ---------------------------------------------------------------------------
+
+async fn stream_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    config: &AppConfig,
+    request: &cot::http::Request<Body>,
+    path: Path<PathTrackId>,
+) -> 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 track_id = path.0.track_id;
+
+    // Look up track → audio_file_id → MediaFile
+    let media = sqlx::query_as::<_, MediaFileRow>(
+        r#"SELECT mf.file_path, mf.mime_type::text as mime_type, mf.file_size_bytes
+           FROM furumusic__track t
+           JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
+           WHERE t.id = $1"#,
+    )
+    .bind(track_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let Some(media) = media else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "track not found"));
+    };
+
+    let full_path = std::path::Path::new(&config.agent_storage_dir).join(&media.file_path);
+
+    if !full_path.exists() {
+        return Ok(json_error(
+            StatusCode::NOT_FOUND,
+            "audio file not found on disk",
+        ));
+    }
+
+    let file_size = media.file_size_bytes as u64;
+
+    // Parse Range header
+    let range_header = request.headers().get(RANGE).and_then(|v| v.to_str().ok());
+
+    if let Some(range_str) = range_header {
+        // Parse "bytes=START-END" or "bytes=START-"
+        if let Some(range) = parse_range(range_str, file_size) {
+            let (start, end) = range;
+            let chunk_size = end - start + 1;
+
+            let data = read_file_range(&full_path, start, chunk_size).await?;
+
+            let response = cot::http::Response::builder()
+                .status(StatusCode::PARTIAL_CONTENT)
+                .header(CONTENT_TYPE, media.mime_type.as_str())
+                .header(ACCEPT_RANGES, "bytes")
+                .header(
+                    CONTENT_RANGE,
+                    format!("bytes {start}-{end}/{file_size}"),
+                )
+                .header(CONTENT_LENGTH, chunk_size.to_string())
+                .body(Body::fixed(data))
+                .expect("valid response");
+
+            return Ok(response);
+        }
+    }
+
+    // No Range or invalid range: return full file
+    let data = tokio::fs::read(&full_path)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let response = cot::http::Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, media.mime_type.as_str())
+        .header(ACCEPT_RANGES, "bytes")
+        .header(CONTENT_LENGTH, file_size.to_string())
+        .body(Body::fixed(data))
+        .expect("valid response");
+
+    Ok(response)
+}
+
+fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
+    let bytes_prefix = "bytes=";
+    if !header.starts_with(bytes_prefix) {
+        return None;
+    }
+    let range_spec = &header[bytes_prefix.len()..];
+    let parts: Vec<&str> = range_spec.splitn(2, '-').collect();
+    if parts.len() != 2 {
+        return None;
+    }
+
+    let start: u64 = if parts[0].is_empty() {
+        // Suffix range: bytes=-N means last N bytes
+        let suffix: u64 = parts[1].parse().ok()?;
+        file_size.saturating_sub(suffix)
+    } else {
+        parts[0].parse().ok()?
+    };
+
+    let end: u64 = if parts[1].is_empty() || parts[0].is_empty() {
+        file_size - 1
+    } else {
+        parts[1].parse::<u64>().ok()?.min(file_size - 1)
+    };
+
+    if start > end || start >= file_size {
+        return None;
+    }
+
+    Some((start, end))
+}
+
+async fn read_file_range(
+    path: &std::path::Path,
+    start: u64,
+    length: u64,
+) -> cot::Result<Vec<u8>> {
+    use tokio::io::{AsyncReadExt, AsyncSeekExt};
+
+    let mut file = tokio::fs::File::open(path)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    file.seek(std::io::SeekFrom::Start(start))
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let mut buf = vec![0u8; length as usize];
+    file.read_exact(&mut buf)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Ok(buf)
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/cover/{media_file_id}
+// ---------------------------------------------------------------------------
+
+async fn cover_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    config: &AppConfig,
+    path: Path<PathMediaFileId>,
+) -> cot::Result<cot::http::Response<Body>> {
+    let Some(_user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+
+    let media_file_id = path.0.media_file_id;
+
+    let media = sqlx::query_as::<_, MediaFileRow>(
+        "SELECT file_path, mime_type::text as mime_type, file_size_bytes FROM furumusic__media_file WHERE id = $1",
+    )
+    .bind(media_file_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let Some(media) = media else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "media file not found"));
+    };
+
+    let full_path = std::path::Path::new(&config.agent_storage_dir).join(&media.file_path);
+
+    if !full_path.exists() {
+        return Ok(json_error(StatusCode::NOT_FOUND, "file not found on disk"));
+    }
+
+    let data = tokio::fs::read(&full_path)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let response = cot::http::Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, media.mime_type.as_str())
+        .header(CONTENT_LENGTH, data.len().to_string())
+        .header("Cache-Control", "public, max-age=86400")
+        .body(Body::fixed(data))
+        .expect("valid response");
+
+    Ok(response)
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/state
+// ---------------------------------------------------------------------------
+
+async fn get_state_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 state = sqlx::query_as::<_, PlaybackStateRow>(
+        r#"SELECT current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode::text as repeat_mode, volume
+           FROM furumusic__playback_state WHERE user_id = $1"#,
+    )
+    .bind(user.id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let dto = match state {
+        Some(s) => {
+            let queue: Vec<i64> =
+                serde_json::from_str(&s.queue_json).unwrap_or_default();
+            PlaybackStateDto {
+                current_track_id: s.current_track_id,
+                position_ms: s.position_ms,
+                queue,
+                queue_position: s.queue_position,
+                shuffle: s.shuffle,
+                repeat_mode: s.repeat_mode,
+                volume: s.volume,
+            }
+        }
+        None => PlaybackStateDto {
+            current_track_id: None,
+            position_ms: 0,
+            queue: Vec::new(),
+            queue_position: 0,
+            shuffle: false,
+            repeat_mode: "off".to_string(),
+            volume: 0.7,
+        },
+    };
+
+    Json(dto).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// PUT /api/player/state
+// ---------------------------------------------------------------------------
+
+async fn put_state_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(dto): Json<PlaybackStateDto>,
+) -> 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 queue_json = serde_json::to_string(&dto.queue)
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+
+    sqlx::query(
+        r#"INSERT INTO furumusic__playback_state (user_id, current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode, volume, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+           ON CONFLICT (user_id) DO UPDATE SET
+             current_track_id = $2, position_ms = $3, queue_json = $4,
+             queue_position = $5, shuffle = $6, repeat_mode = $7, volume = $8, updated_at = $9"#,
+    )
+    .bind(user.id)
+    .bind(dto.current_track_id)
+    .bind(dto.position_ms)
+    .bind(&queue_json)
+    .bind(dto.queue_position)
+    .bind(dto.shuffle)
+    .bind(&dto.repeat_mode)
+    .bind(dto.volume)
+    .bind(&now)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/history
+// ---------------------------------------------------------------------------
+
+async fn history_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(entry): Json<HistoryEntry>,
+) -> 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 now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+
+    sqlx::query(
+        r#"INSERT INTO furumusic__play_history (user_id, track_id, played_at, duration_listened, completed)
+           VALUES ($1, $2, $3, $4, $5)"#,
+    )
+    .bind(user.id)
+    .bind(entry.track_id)
+    .bind(&now)
+    .bind(entry.duration_listened)
+    .bind(entry.completed)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/search?q=...&limit=N
+// ---------------------------------------------------------------------------
+
+async fn search_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    query: cot::request::extractors::UrlQuery<SearchQuery>,
+) -> 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 q = query.0.q.trim().to_lowercase();
+    if q.is_empty() {
+        return Json(SearchResults {
+            artists: Vec::new(),
+            releases: Vec::new(),
+            tracks: Vec::new(),
+        })
+        .into_response();
+    }
+
+    let limit = query.0.limit.unwrap_or(10).clamp(1, 50) as i64;
+    let short = q.chars().count() < 3;
+
+    let (artist_rows, release_rows, track_rows) = if short {
+        let a = sqlx::query_as::<_, SearchArtistRow>(
+            r#"SELECT a.id, a.name::text AS name, a.image_file_id,
+                      COALESCE((SELECT COUNT(*) FROM furumusic__release_artist ra
+                                JOIN furumusic__release r ON r.id = ra.release_id AND r.is_hidden = false
+                                WHERE ra.artist_id = a.id), 0) AS release_count
+               FROM furumusic__artist a
+               WHERE a.is_hidden = false AND a.name_sort ILIKE '%' || $1 || '%'
+               ORDER BY a.name_sort LIMIT $2"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        let r = sqlx::query_as::<_, SearchReleaseRow>(
+            r#"SELECT r.id, r.title::text AS title, r.release_type::text AS release_type,
+                      r.year, r.cover_file_id,
+                      COALESCE((SELECT COUNT(*) FROM furumusic__track t WHERE t.release_id = r.id AND t.is_hidden = false), 0) AS track_count
+               FROM furumusic__release r
+               WHERE r.is_hidden = false AND r.title_sort ILIKE '%' || $1 || '%'
+               ORDER BY r.title_sort LIMIT $2"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        let t = sqlx::query_as::<_, SearchTrackRow>(
+            r#"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
+               FROM furumusic__track t
+               JOIN furumusic__release rel ON rel.id = t.release_id
+               WHERE t.is_hidden = false AND t.title_sort ILIKE '%' || $1 || '%'
+               ORDER BY t.title_sort LIMIT $2"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        tokio::try_join!(a, r, t).map_err(|e| cot::Error::internal(e.to_string()))?
+    } else {
+        let a = sqlx::query_as::<_, SearchArtistRow>(
+            r#"SELECT id, name, image_file_id, release_count FROM (
+                SELECT a.id, a.name::text AS name, a.image_file_id,
+                       COALESCE((SELECT COUNT(*) FROM furumusic__release_artist ra
+                                 JOIN furumusic__release r ON r.id = ra.release_id AND r.is_hidden = false
+                                 WHERE ra.artist_id = a.id), 0) AS release_count,
+                       MAX(sim) AS similarity
+                FROM (
+                    SELECT id, name, image_file_id, name_sort, similarity(name_sort, $1) AS sim
+                    FROM furumusic__artist WHERE is_hidden = false AND name_sort % $1
+                    UNION ALL
+                    SELECT id, name, image_file_id, name_sort, 0.01::real AS sim
+                    FROM furumusic__artist WHERE is_hidden = false AND name_sort ILIKE '%' || $1 || '%'
+                ) a
+                GROUP BY a.id, a.name, a.image_file_id
+                ORDER BY similarity DESC
+                LIMIT $2
+            ) sub"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        let r = sqlx::query_as::<_, SearchReleaseRow>(
+            r#"SELECT id, title, release_type, year, cover_file_id, track_count FROM (
+                SELECT r.id, r.title::text AS title, r.release_type::text AS release_type,
+                       r.year, r.cover_file_id,
+                       COALESCE((SELECT COUNT(*) FROM furumusic__track t WHERE t.release_id = r.id AND t.is_hidden = false), 0) AS track_count,
+                       MAX(sim) AS similarity
+                FROM (
+                    SELECT id, title, release_type, year, cover_file_id, title_sort, similarity(title_sort, $1) AS sim
+                    FROM furumusic__release WHERE is_hidden = false AND title_sort % $1
+                    UNION ALL
+                    SELECT id, title, release_type, year, cover_file_id, title_sort, 0.01::real AS sim
+                    FROM furumusic__release WHERE is_hidden = false AND title_sort ILIKE '%' || $1 || '%'
+                ) r
+                GROUP BY r.id, r.title, r.release_type, r.year, r.cover_file_id
+                ORDER BY similarity DESC
+                LIMIT $2
+            ) sub"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        let t = sqlx::query_as::<_, SearchTrackRow>(
+            r#"SELECT id, title, track_number, disc_number, duration_seconds, cover_file_id, release_cover_file_id 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,
+                       MAX(sim) AS similarity
+                FROM (
+                    SELECT id, title, title_sort, track_number, disc_number, duration_seconds, cover_file_id, release_id,
+                           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,
+                           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
+                GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id
+                ORDER BY similarity DESC
+                LIMIT $2
+            ) sub"#,
+        )
+        .bind(&q)
+        .bind(limit)
+        .fetch_all(pool);
+
+        tokio::try_join!(a, r, t).map_err(|e| cot::Error::internal(e.to_string()))?
+    };
+
+    // Collect track IDs for batch artist lookup
+    let track_ids: Vec<i64> = track_rows.iter().map(|t| t.id).collect();
+
+    let track_artists = if track_ids.is_empty() {
+        Vec::new()
+    } else {
+        sqlx::query_as::<_, TrackArtistRow>(
+            r#"SELECT ta.track_id, ta.artist_id, a.name::text AS artist_name, ta.role::text AS role
+               FROM furumusic__track_artist ta
+               JOIN furumusic__artist a ON a.id = ta.artist_id
+               WHERE ta.track_id = ANY($1)
+               ORDER BY ta.track_id, ta.position"#,
+        )
+        .bind(&track_ids)
+        .fetch_all(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    };
+
+    let mut track_main_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+    let mut track_feat_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+
+    for ta in &track_artists {
+        let artist_ref = ArtistRef {
+            id: ta.artist_id,
+            name: ta.artist_name.clone(),
+        };
+        if ta.role == "featuring" {
+            track_feat_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        } else {
+            track_main_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        }
+    }
+
+    let artists: Vec<ArtistCard> = artist_rows
+        .into_iter()
+        .map(|r| ArtistCard {
+            id: r.id,
+            name: r.name,
+            image_url: cover_url(r.image_file_id),
+            release_count: r.release_count,
+        })
+        .collect();
+
+    let releases: Vec<ReleaseCard> = release_rows
+        .into_iter()
+        .map(|r| ReleaseCard {
+            id: r.id,
+            title: r.title,
+            release_type: r.release_type,
+            year: r.year,
+            cover_url: cover_url(r.cover_file_id),
+            track_count: r.track_count,
+        })
+        .collect();
+
+    let tracks: Vec<TrackItem> = track_rows
+        .into_iter()
+        .map(|t| {
+            let tid = t.id;
+            TrackItem {
+                id: t.id,
+                title: t.title,
+                track_number: t.track_number,
+                disc_number: t.disc_number,
+                duration_seconds: t.duration_seconds,
+                artists: track_main_artists.remove(&tid).unwrap_or_default(),
+                featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+                stream_url: format!("/api/player/stream/{tid}"),
+            }
+        })
+        .collect();
+
+    Json(SearchResults {
+        artists,
+        releases,
+        tracks,
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/playlists  — create playlist
+// ---------------------------------------------------------------------------
+
+async fn create_playlist_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(body): Json<CreatePlaylistRequest>,
+) -> 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 title = body.title.trim().to_string();
+    if title.is_empty() {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "title is required"));
+    }
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    let row: (i64,) = sqlx::query_as(
+        "INSERT INTO furumusic__playlist (owner_id, title, is_public, created_at, updated_at) \
+         VALUES ($1, $2, false, $3, $3) RETURNING id",
+    )
+    .bind(user.id)
+    .bind(&title)
+    .bind(&now)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(PlaylistCard {
+        id: row.0,
+        title,
+        track_count: 0,
+        is_own: true,
+        kind: "user".to_string(),
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// PUT /api/player/playlists/{id}  — rename / update playlist
+// ---------------------------------------------------------------------------
+
+async fn update_playlist_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+    Json(body): Json<UpdatePlaylistRequest>,
+) -> 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 playlist_id = path.0.id;
+    // Verify ownership
+    let owner: Option<(i64,)> = sqlx::query_as(
+        "SELECT owner_id FROM furumusic__playlist WHERE id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(owner) = owner else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "playlist not found"));
+    };
+    if owner.0 != user.id {
+        return Ok(json_error(StatusCode::FORBIDDEN, "not your playlist"));
+    }
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    if let Some(title) = &body.title {
+        let t = title.trim();
+        if !t.is_empty() {
+            sqlx::query("UPDATE furumusic__playlist SET title = $1, updated_at = $2 WHERE id = $3")
+                .bind(t)
+                .bind(&now)
+                .bind(playlist_id)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
+        }
+    }
+    if let Some(desc) = &body.description {
+        sqlx::query("UPDATE furumusic__playlist SET description = $1, updated_at = $2 WHERE id = $3")
+            .bind(desc)
+            .bind(&now)
+            .bind(playlist_id)
+            .execute(pool)
+            .await
+            .map_err(|e| cot::Error::internal(e.to_string()))?;
+    }
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// DELETE /api/player/playlists/{id}
+// ---------------------------------------------------------------------------
+
+async fn delete_playlist_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+) -> 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 playlist_id = path.0.id;
+    let owner: Option<(i64,)> = sqlx::query_as(
+        "SELECT owner_id FROM furumusic__playlist WHERE id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(owner) = owner else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "playlist not found"));
+    };
+    if owner.0 != user.id {
+        return Ok(json_error(StatusCode::FORBIDDEN, "not your playlist"));
+    }
+    sqlx::query("DELETE FROM furumusic__playlist_track WHERE playlist_id = $1")
+        .bind(playlist_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__saved_playlist WHERE playlist_id = $1")
+        .bind(playlist_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__playlist WHERE id = $1")
+        .bind(playlist_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/playlists/{id}/tracks  — add tracks to playlist
+// ---------------------------------------------------------------------------
+
+async fn add_tracks_to_playlist_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+    Json(body): Json<AddTracksRequest>,
+) -> 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 playlist_id = path.0.id;
+    let owner: Option<(i64,)> = sqlx::query_as(
+        "SELECT owner_id FROM furumusic__playlist WHERE id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(owner) = owner else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "playlist not found"));
+    };
+    if owner.0 != user.id {
+        return Ok(json_error(StatusCode::FORBIDDEN, "not your playlist"));
+    }
+
+    // Get next position
+    let max_pos: (Option<i32>,) = sqlx::query_as(
+        "SELECT MAX(position) FROM furumusic__playlist_track WHERE playlist_id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let mut pos = max_pos.0.unwrap_or(-1) + 1;
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+
+    for track_id in &body.track_ids {
+        sqlx::query(
+            "INSERT INTO furumusic__playlist_track (playlist_id, track_id, position, added_at, added_by_user_id) \
+             VALUES ($1, $2, $3, $4, $5)",
+        )
+        .bind(playlist_id)
+        .bind(track_id)
+        .bind(pos)
+        .bind(&now)
+        .bind(user.id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        pos += 1;
+    }
+
+    sqlx::query("UPDATE furumusic__playlist SET updated_at = $1 WHERE id = $2")
+        .bind(&now)
+        .bind(playlist_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// DELETE /api/player/playlists/{id}/tracks  — remove a track from playlist
+// ---------------------------------------------------------------------------
+
+async fn remove_track_from_playlist_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+    Json(body): Json<RemoveTrackRequest>,
+) -> 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 playlist_id = path.0.id;
+    let owner: Option<(i64,)> = sqlx::query_as(
+        "SELECT owner_id FROM furumusic__playlist WHERE id = $1",
+    )
+    .bind(playlist_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(owner) = owner else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "playlist not found"));
+    };
+    if owner.0 != user.id {
+        return Ok(json_error(StatusCode::FORBIDDEN, "not your playlist"));
+    }
+
+    sqlx::query(
+        "DELETE FROM furumusic__playlist_track WHERE playlist_id = $1 AND track_id = $2",
+    )
+    .bind(playlist_id)
+    .bind(body.track_id)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    // Re-number positions
+    sqlx::query(
+        r#"WITH ordered AS (
+             SELECT id, ROW_NUMBER() OVER (ORDER BY position) - 1 as new_pos
+             FROM furumusic__playlist_track WHERE playlist_id = $1
+           )
+           UPDATE furumusic__playlist_track pt
+           SET position = o.new_pos
+           FROM ordered o WHERE pt.id = o.id"#,
+    )
+    .bind(playlist_id)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/likes/toggle/{track_id}  — toggle like on a track
+// ---------------------------------------------------------------------------
+
+async fn toggle_like_track_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathTrackId>,
+) -> 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 track_id = path.0.track_id;
+    let existing: Option<(i64,)> = sqlx::query_as(
+        "SELECT id FROM furumusic__user_liked_track WHERE user_id = $1 AND track_id = $2",
+    )
+    .bind(user.id)
+    .bind(track_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    if existing.is_some() {
+        sqlx::query(
+            "DELETE FROM furumusic__user_liked_track WHERE user_id = $1 AND track_id = $2",
+        )
+        .bind(user.id)
+        .bind(track_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        Json(LikeStatus { liked: false }).into_response()
+    } else {
+        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+        sqlx::query(
+            "INSERT INTO furumusic__user_liked_track (user_id, track_id, created_at) VALUES ($1, $2, $3)",
+        )
+        .bind(user.id)
+        .bind(track_id)
+        .bind(&now)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        Json(LikeStatus { liked: true }).into_response()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/likes/release/{release_id}  — like all tracks in release
+// ---------------------------------------------------------------------------
+
+async fn like_release_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    path: Path<PathId>,
+) -> 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 release_id = path.0.id;
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+
+    // Check if ALL tracks in this release are already liked
+    let total: (i64,) = sqlx::query_as(
+        "SELECT COUNT(*) FROM furumusic__track WHERE release_id = $1 AND is_hidden = false",
+    )
+    .bind(release_id)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let liked_count: (i64,) = sqlx::query_as(
+        r#"SELECT COUNT(*) FROM furumusic__user_liked_track ult
+           JOIN furumusic__track t ON t.id = ult.track_id
+           WHERE ult.user_id = $1 AND t.release_id = $2 AND t.is_hidden = false"#,
+    )
+    .bind(user.id)
+    .bind(release_id)
+    .fetch_one(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    if liked_count.0 >= total.0 && total.0 > 0 {
+        // Unlike all tracks in release
+        sqlx::query(
+            r#"DELETE FROM furumusic__user_liked_track
+               WHERE user_id = $1 AND track_id IN (
+                   SELECT id FROM furumusic__track WHERE release_id = $2 AND is_hidden = false
+               )"#,
+        )
+        .bind(user.id)
+        .bind(release_id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        Json(LikeStatus { liked: false }).into_response()
+    } else {
+        // Like all tracks in release (skip already liked)
+        sqlx::query(
+            r#"INSERT INTO furumusic__user_liked_track (user_id, track_id, created_at)
+               SELECT $1, t.id, $3
+               FROM furumusic__track t
+               WHERE t.release_id = $2 AND t.is_hidden = false
+                 AND NOT EXISTS (
+                     SELECT 1 FROM furumusic__user_liked_track ult
+                     WHERE ult.user_id = $1 AND ult.track_id = t.id
+                 )"#,
+        )
+        .bind(user.id)
+        .bind(release_id)
+        .bind(&now)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        Json(LikeStatus { liked: true }).into_response()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// GET /api/player/likes  — get all liked track IDs for current user
+// ---------------------------------------------------------------------------
+
+async fn liked_ids_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 rows: Vec<(i64,)> = sqlx::query_as(
+        "SELECT track_id FROM furumusic__user_liked_track WHERE user_id = $1",
+    )
+    .bind(user.id)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(LikedIds {
+        track_ids: rows.into_iter().map(|r| r.0).collect(),
+    })
+    .into_response()
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/player/tracks-by-ids
+// ---------------------------------------------------------------------------
+
+async fn tracks_by_ids_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(body): Json<TracksByIdsRequest>,
+) -> cot::Result<cot::response::Response> {
+    let Some(_user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+
+    if body.ids.is_empty() {
+        return Json(Vec::<TrackItem>::new()).into_response();
+    }
+
+    // Limit to 500 IDs to prevent abuse
+    let ids: Vec<i64> = body.ids.into_iter().take(500).collect();
+
+    let tracks = sqlx::query_as::<_, TrackRow>(
+        r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
+                  t.duration_seconds, t.cover_file_id,
+                  r.cover_file_id as release_cover_file_id
+           FROM furumusic__track t
+           JOIN furumusic__release r ON r.id = t.release_id
+           WHERE t.id = ANY($1) AND t.is_hidden = false"#,
+    )
+    .bind(&ids)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let track_ids: Vec<i64> = tracks.iter().map(|t| t.id).collect();
+
+    let track_artists = if track_ids.is_empty() {
+        Vec::new()
+    } else {
+        sqlx::query_as::<_, TrackArtistRow>(
+            r#"SELECT ta.track_id, ta.artist_id, a.name::text as artist_name, ta.role::text as role
+               FROM furumusic__track_artist ta
+               JOIN furumusic__artist a ON a.id = ta.artist_id
+               WHERE ta.track_id = ANY($1)
+               ORDER BY ta.track_id, ta.position"#,
+        )
+        .bind(&track_ids)
+        .fetch_all(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    };
+
+    let mut track_main_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+    let mut track_feat_artists: std::collections::HashMap<i64, Vec<ArtistRef>> =
+        std::collections::HashMap::new();
+
+    for ta in &track_artists {
+        let artist_ref = ArtistRef {
+            id: ta.artist_id,
+            name: ta.artist_name.clone(),
+        };
+        if ta.role == "featuring" {
+            track_feat_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        } else {
+            track_main_artists
+                .entry(ta.track_id)
+                .or_default()
+                .push(artist_ref);
+        }
+    }
+
+    // Build a map from id -> TrackItem
+    let mut track_map: std::collections::HashMap<i64, TrackItem> = std::collections::HashMap::new();
+    for t in tracks {
+        let tid = t.id;
+        track_map.insert(tid, TrackItem {
+            id: t.id,
+            title: t.title,
+            track_number: t.track_number,
+            disc_number: t.disc_number,
+            duration_seconds: t.duration_seconds,
+            artists: track_main_artists.remove(&tid).unwrap_or_default(),
+            featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+            cover_url: track_cover_url(t.cover_file_id, t.release_cover_file_id),
+            stream_url: format!("/api/player/stream/{tid}"),
+        });
+    }
+
+    // Reorder results to match input order
+    let result: Vec<TrackItem> = ids
+        .iter()
+        .filter_map(|id| track_map.remove(id))
+        .collect();
+
+    Json(result).into_response()
+}
+
+// ---------------------------------------------------------------------------
+// PlayerApp
+// ---------------------------------------------------------------------------
+
+pub struct PlayerApp {
+    config: Arc<AppConfig>,
+}
+
+impl PlayerApp {
+    pub fn new(config: Arc<AppConfig>) -> Self {
+        Self { config }
+    }
+}
+
+impl App for PlayerApp {
+    fn name(&self) -> &'static str {
+        "player"
+    }
+
+    fn router(&self) -> Router {
+        let pool_config = Arc::clone(&self.config);
+        let pool: Arc<tokio::sync::OnceCell<sqlx::PgPool>> =
+            Arc::new(tokio::sync::OnceCell::new());
+
+        Router::with_urls([
+            // -- Artists (paginated) --
+            Route::with_handler_and_name(
+                "/artists",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database,
+                              query: cot::request::extractors::UrlQuery<PaginationQuery>| {
+                        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;
+                            artists_handler(session, db, pg_pool, query).await
+                        }
+                    })
+                },
+                "player_artists",
+            ),
+            // -- Artist detail --
+            Route::with_handler_and_name(
+                "/artists/{id}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database, path: Path<PathId>| {
+                        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;
+                            artist_detail_handler(session, db, pg_pool, path).await
+                        }
+                    })
+                },
+                "player_artist_detail",
+            ),
+            // -- Release detail --
+            Route::with_handler_and_name(
+                "/releases/{id}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session, db: Database, path: Path<PathId>| {
+                        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;
+                            release_detail_handler(session, db, pg_pool, path).await
+                        }
+                    })
+                },
+                "player_release_detail",
+            ),
+            // -- Playlists (list + create) --
+            Route::with_handler_and_name(
+                "/playlists",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    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;
+                            playlists_handler(session, db, pg_pool).await
+                        }
+                    }
+                })
+                .post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<CreatePlaylistRequest>| {
+                        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;
+                            create_playlist_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_playlists",
+            ),
+            // -- Playlist detail (get, update, delete) --
+            Route::with_handler_and_name(
+                "/playlists/{id}",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>| {
+                        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;
+                            playlist_detail_handler(session, db, pg_pool, path).await
+                        }
+                    }
+                })
+                .put({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>, json: Json<UpdatePlaylistRequest>| {
+                        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;
+                            update_playlist_handler(session, db, pg_pool, path, json).await
+                        }
+                    }
+                })
+                .delete({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>| {
+                        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;
+                            delete_playlist_handler(session, db, pg_pool, path).await
+                        }
+                    }
+                }),
+                "player_playlist_detail",
+            ),
+            // -- Playlist tracks (add / remove) --
+            Route::with_handler_and_name(
+                "/playlists/{id}/tracks",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>, json: Json<AddTracksRequest>| {
+                        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;
+                            add_tracks_to_playlist_handler(session, db, pg_pool, path, json).await
+                        }
+                    }
+                })
+                .delete({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>, json: Json<RemoveTrackRequest>| {
+                        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;
+                            remove_track_from_playlist_handler(session, db, pg_pool, path, json).await
+                        }
+                    }
+                }),
+                "player_playlist_tracks",
+            ),
+            // -- Likes (get liked IDs) --
+            Route::with_handler_and_name(
+                "/likes",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    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;
+                            liked_ids_handler(session, db, pg_pool).await
+                        }
+                    }
+                }),
+                "player_likes",
+            ),
+            // -- Toggle like on track --
+            Route::with_handler_and_name(
+                "/likes/toggle/{track_id}",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathTrackId>| {
+                        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;
+                            toggle_like_track_handler(session, db, pg_pool, path).await
+                        }
+                    }
+                }),
+                "player_like_toggle",
+            ),
+            // -- Like/unlike release --
+            Route::with_handler_and_name(
+                "/likes/release/{id}",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, path: Path<PathId>| {
+                        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;
+                            like_release_handler(session, db, pg_pool, path).await
+                        }
+                    }
+                }),
+                "player_like_release",
+            ),
+            // -- Audio stream --
+            Route::with_handler_and_name(
+                "/stream/{track_id}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    let config = Arc::clone(&self.config);
+                    get(move |session: Session, db: Database,
+                              path: Path<PathTrackId>,
+                              request: cot::request::Request| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        let config = Arc::clone(&config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            stream_handler(session, db, pg_pool, &config, &request, path).await
+                        }
+                    })
+                },
+                "player_stream",
+            ),
+            // -- Cover art --
+            Route::with_handler_and_name(
+                "/cover/{media_file_id}",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    let config = Arc::clone(&self.config);
+                    get(move |session: Session, db: Database,
+                              path: Path<PathMediaFileId>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        let config = Arc::clone(&config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            cover_handler(session, db, pg_pool, &config, path).await
+                        }
+                    })
+                },
+                "player_cover",
+            ),
+            // -- Playback state GET --
+            Route::with_handler_and_name(
+                "/state",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    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;
+                            get_state_handler(session, db, pg_pool).await
+                        }
+                    }
+                })
+                .put({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<PlaybackStateDto>| {
+                        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;
+                            put_state_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                })
+                .post({
+                    // POST handler for sendBeacon (used on page unload)
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<PlaybackStateDto>| {
+                        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;
+                            put_state_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_state",
+            ),
+            // -- Play history --
+            Route::with_handler_and_name(
+                "/history",
+                cot::router::method::post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<HistoryEntry>| {
+                        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;
+                            history_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_history",
+            ),
+            // -- Search --
+            Route::with_handler_and_name(
+                "/search",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database,
+                          query: cot::request::extractors::UrlQuery<SearchQuery>| {
+                        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;
+                            search_handler(session, db, pg_pool, query).await
+                        }
+                    }
+                }),
+                "player_search",
+            ),
+            // -- Tracks by IDs --
+            Route::with_handler_and_name(
+                "/tracks-by-ids",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<TracksByIdsRequest>| {
+                        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;
+                            tracks_by_ids_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_tracks_by_ids",
+            ),
+        ])
+    }
+}
diff --git a/src/scheduler/mod.rs b/src/scheduler/mod.rs
new file mode 100644
index 0000000..07fa8b0
--- /dev/null
+++ b/src/scheduler/mod.rs
@@ -0,0 +1,1321 @@
+/// Job scheduler: models, migrations, Job trait, JobRegistry, and scheduler loop.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use cot::db::migrations::{self, Field, Operation, SyncDynMigration};
+use cot::db::{Auto, Database, DatabaseField, Identifier, LimitedString, Model};
+
+use crate::config::AppConfig;
+
+// ---------------------------------------------------------------------------
+// ScheduledJob
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct ScheduledJob {
+    #[model(primary_key)]
+    pub name: String,
+    pub description: String,
+    pub cron_expression: LimitedString<100>,
+    pub enabled: bool,
+    pub last_run_at: Option<LimitedString<32>>,
+    pub next_run_at: Option<LimitedString<32>>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+}
+
+fn now_iso() -> LimitedString<32> {
+    LimitedString::new(&chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()).unwrap()
+}
+
+impl ScheduledJob {
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn get_by_name(db: &Database, name: &str) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, name.to_owned()).await
+    }
+
+    pub async fn upsert(db: &Database, name: &str, description: &str, cron_expression: &str) -> cot::db::Result<Self> {
+        if let Some(mut existing) = Self::get_by_name(db, name).await? {
+            // Update cron expression and description if they changed
+            let mut changed = false;
+            if existing.cron_expression.as_str() != cron_expression {
+                tracing::info!(
+                    job = name,
+                    old = existing.cron_expression.as_str(),
+                    new = cron_expression,
+                    "Updating cron expression"
+                );
+                existing.cron_expression = LimitedString::new(cron_expression).unwrap();
+                existing.next_run_at = compute_next_run(cron_expression)
+                    .map(|s| LimitedString::new(&s).unwrap());
+                changed = true;
+            }
+            if existing.description != description {
+                existing.description = description.to_owned();
+                changed = true;
+            }
+            if changed {
+                existing.updated_at = now_iso();
+                existing.save(db).await?;
+            }
+            return Ok(existing);
+        }
+        let now = now_iso();
+        let next = compute_next_run(cron_expression);
+        let mut job = Self {
+            name: name.to_owned(),
+            description: description.to_owned(),
+            cron_expression: LimitedString::new(cron_expression).unwrap(),
+            enabled: true,
+            last_run_at: None,
+            next_run_at: next.map(|s| LimitedString::new(&s).unwrap()),
+            created_at: now.clone(),
+            updated_at: now,
+        };
+        job.insert(db).await?;
+        Ok(job)
+    }
+
+    pub fn name_str(&self) -> &str {
+        &self.name
+    }
+
+    pub fn description_str(&self) -> &str {
+        &self.description
+    }
+
+    pub fn cron_expression_str(&self) -> &str {
+        &self.cron_expression
+    }
+
+    pub fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    pub fn last_run_at_str(&self) -> &str {
+        self.last_run_at.as_ref().map_or("", |v| v.as_str())
+    }
+
+    pub fn next_run_at_str(&self) -> &str {
+        self.next_run_at.as_ref().map_or("", |v| v.as_str())
+    }
+
+    pub async fn delete_by_name(db: &Database, name: &str) -> cot::db::Result<()> {
+        db.raw(&format!(
+            "DELETE FROM furumusic__scheduled_job WHERE name = '{}'",
+            name.replace('\'', "''")
+        ))
+        .await?;
+        Ok(())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// JobRun
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct JobRun {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub job_name: LimitedString<100>,
+    pub status: LimitedString<32>,
+    pub started_at: LimitedString<32>,
+    pub finished_at: Option<LimitedString<32>>,
+    pub duration_ms: Option<i64>,
+    pub log_output: Option<String>,
+    pub error_message: Option<String>,
+    pub trigger: LimitedString<32>,
+}
+
+#[allow(dead_code)]
+impl JobRun {
+    pub async fn create_running(db: &Database, job_name: &str, trigger: &str) -> cot::db::Result<Self> {
+        let mut run = Self {
+            id: Auto::auto(),
+            job_name: LimitedString::new(job_name).unwrap(),
+            status: LimitedString::new("running").unwrap(),
+            started_at: now_iso(),
+            finished_at: None,
+            duration_ms: None,
+            log_output: None,
+            error_message: None,
+            trigger: LimitedString::new(trigger).unwrap(),
+        };
+        run.insert(db).await?;
+        Ok(run)
+    }
+
+    pub async fn set_completed(&mut self, db: &Database, duration_ms: i64, log: &str) -> cot::db::Result<()> {
+        self.status = LimitedString::new("completed").unwrap();
+        self.finished_at = Some(now_iso());
+        self.duration_ms = Some(duration_ms);
+        self.log_output = Some(log.to_owned());
+        self.save(db).await
+    }
+
+    pub async fn set_failed(&mut self, db: &Database, duration_ms: i64, log: &str, error: &str) -> cot::db::Result<()> {
+        self.status = LimitedString::new("failed").unwrap();
+        self.finished_at = Some(now_iso());
+        self.duration_ms = Some(duration_ms);
+        self.log_output = Some(log.to_owned());
+        self.error_message = Some(error.to_owned());
+        self.save(db).await
+    }
+
+    pub async fn get_by_id(db: &Database, id: i64) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, Auto::Fixed(id)).await
+    }
+
+    pub async fn list_by_job(pool: &sqlx::PgPool, job_name: &str, limit: i64) -> anyhow::Result<Vec<Self>> {
+        let rows = sqlx::query_as::<_, JobRunRow>(
+            "SELECT id, job_name, status, started_at, finished_at, duration_ms, log_output, error_message, trigger \
+             FROM furumusic__job_run WHERE job_name = $1 ORDER BY id DESC LIMIT $2"
+        )
+        .bind(job_name)
+        .bind(limit)
+        .fetch_all(pool)
+        .await?;
+
+        Ok(rows.into_iter().map(|r| r.into_model()).collect())
+    }
+
+    /// Mark all "running" job runs as "failed" — called at scheduler startup
+    /// to recover from process crashes.
+    pub async fn recover_stale(pool: &sqlx::PgPool) -> anyhow::Result<u64> {
+        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+        let result = sqlx::query(
+            "UPDATE furumusic__job_run \
+             SET status = 'failed', \
+                 finished_at = $1, \
+                 error_message = 'Process restarted while job was running' \
+             WHERE status = 'running'"
+        )
+        .bind(&now)
+        .execute(pool)
+        .await?;
+        Ok(result.rows_affected())
+    }
+
+    pub async fn delete_by_job(pool: &sqlx::PgPool, job_name: &str) -> anyhow::Result<()> {
+        sqlx::query("DELETE FROM furumusic__job_run WHERE job_name = $1")
+            .bind(job_name)
+            .execute(pool)
+            .await?;
+        Ok(())
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+
+    pub fn status_str(&self) -> &str {
+        &self.status
+    }
+
+    pub fn started_at_str(&self) -> &str {
+        &self.started_at
+    }
+
+    pub fn finished_at_str(&self) -> &str {
+        self.finished_at.as_ref().map_or("", |v| v.as_str())
+    }
+
+    pub fn duration_display(&self) -> String {
+        match self.duration_ms {
+            Some(ms) if ms >= 1000 => format!("{:.1}s", ms as f64 / 1000.0),
+            Some(ms) => format!("{}ms", ms),
+            None => "-".into(),
+        }
+    }
+
+    pub fn log_output_str(&self) -> &str {
+        self.log_output.as_deref().unwrap_or("")
+    }
+
+    pub fn error_message_str(&self) -> &str {
+        self.error_message.as_deref().unwrap_or("")
+    }
+
+    pub fn trigger_str(&self) -> &str {
+        &self.trigger
+    }
+
+    pub fn status_badge_class(&self) -> &str {
+        match self.status.as_str() {
+            "completed" => "badge-completed",
+            "failed" => "badge-failed",
+            "running" => "badge-processing",
+            _ => "badge-default",
+        }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct JobRunRow {
+    id: i64,
+    job_name: String,
+    status: String,
+    started_at: String,
+    finished_at: Option<String>,
+    duration_ms: Option<i64>,
+    log_output: Option<String>,
+    error_message: Option<String>,
+    trigger: String,
+}
+
+impl JobRunRow {
+    fn into_model(self) -> JobRun {
+        JobRun {
+            id: Auto::Fixed(self.id),
+            job_name: LimitedString::new(&self.job_name).unwrap(),
+            status: LimitedString::new(&self.status).unwrap(),
+            started_at: LimitedString::new(&self.started_at).unwrap(),
+            finished_at: self.finished_at.map(|s| LimitedString::new(&s).unwrap()),
+            duration_ms: self.duration_ms,
+            log_output: self.log_output,
+            error_message: self.error_message,
+            trigger: LimitedString::new(&self.trigger).unwrap(),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// PendingReview
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct PendingReview {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub job_run_id: i64,
+    pub review_type: LimitedString<64>,
+    pub input_path: Option<String>,
+    pub context_json: Option<String>,
+    pub result_json: Option<String>,
+    pub status: LimitedString<32>,
+    pub created_at: LimitedString<32>,
+    pub updated_at: LimitedString<32>,
+    pub error_message: Option<String>,
+}
+
+#[allow(dead_code)]
+impl PendingReview {
+    pub async fn create(
+        db: &Database,
+        job_run_id: i64,
+        review_type: &str,
+        input_path: Option<&str>,
+        context_json: Option<&str>,
+        result_json: Option<&str>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut review = Self {
+            id: Auto::auto(),
+            job_run_id,
+            review_type: LimitedString::new(review_type).unwrap(),
+            input_path: input_path.map(|s| s.to_owned()),
+            context_json: context_json.map(|s| s.to_owned()),
+            result_json: result_json.map(|s| s.to_owned()),
+            status: LimitedString::new("pending").unwrap(),
+            created_at: now.clone(),
+            updated_at: now,
+            error_message: None,
+        };
+        review.insert(db).await?;
+        Ok(review)
+    }
+
+    pub async fn create_queued(
+        db: &Database,
+        job_run_id: i64,
+        review_type: &str,
+        input_path: Option<&str>,
+        context_json: Option<&str>,
+    ) -> cot::db::Result<Self> {
+        let now = now_iso();
+        let mut review = Self {
+            id: Auto::auto(),
+            job_run_id,
+            review_type: LimitedString::new(review_type).unwrap(),
+            input_path: input_path.map(|s| s.to_owned()),
+            context_json: context_json.map(|s| s.to_owned()),
+            result_json: None,
+            status: LimitedString::new("queued").unwrap(),
+            created_at: now.clone(),
+            updated_at: now,
+            error_message: None,
+        };
+        review.insert(db).await?;
+        Ok(review)
+    }
+
+    pub async fn list_all(db: &Database) -> cot::db::Result<Vec<Self>> {
+        Self::objects().all(db).await
+    }
+
+    pub async fn list_by_status(db: &Database, status: &str) -> cot::db::Result<Vec<Self>> {
+        let status_val: LimitedString<32> = LimitedString::new(status).unwrap();
+        cot::db::query!(PendingReview, $status == status_val)
+            .all(db)
+            .await
+    }
+
+    pub async fn get_by_id(db: &Database, id: i64) -> cot::db::Result<Option<Self>> {
+        Self::get_by_primary_key(db, Auto::Fixed(id)).await
+    }
+
+    pub async fn set_approved(&mut self, db: &Database) -> cot::db::Result<()> {
+        self.status = LimitedString::new("approved").unwrap();
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_rejected(&mut self, db: &Database) -> cot::db::Result<()> {
+        self.status = LimitedString::new("rejected").unwrap();
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_queued(&mut self, db: &Database) -> cot::db::Result<()> {
+        self.status = LimitedString::new("queued").unwrap();
+        self.error_message = None;
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_processing(&mut self, db: &Database) -> cot::db::Result<()> {
+        self.status = LimitedString::new("processing").unwrap();
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_auto_approved(&mut self, db: &Database) -> cot::db::Result<()> {
+        self.status = LimitedString::new("auto_approved").unwrap();
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn set_failed(&mut self, db: &Database, error: &str) -> cot::db::Result<()> {
+        self.status = LimitedString::new("failed").unwrap();
+        self.error_message = Some(error.to_owned());
+        self.updated_at = now_iso();
+        self.save(db).await
+    }
+
+    pub async fn list_queued(db: &Database) -> cot::db::Result<Vec<Self>> {
+        let status_val: LimitedString<32> = LimitedString::new("queued").unwrap();
+        cot::db::query!(PendingReview, $status == status_val)
+            .all(db)
+            .await
+    }
+
+    pub async fn exists_for_path(db: &Database, path: &str) -> cot::db::Result<bool> {
+        let all = Self::objects().all(db).await?;
+        let exists = all.iter().any(|r| {
+            let s = r.status.as_str();
+            // "rejected" and "failed" reviews should not block re-discovery
+            s != "rejected" && s != "failed" && r.input_path.as_deref() == Some(path)
+        });
+        Ok(exists)
+    }
+
+    /// Mark all "processing" reviews as "failed" — called at scheduler
+    /// startup to recover from process crashes. These reviews will never
+    /// complete because the process restarted; the user can re-queue them
+    /// manually from the admin UI.
+    pub async fn recover_stale(pool: &sqlx::PgPool) -> anyhow::Result<u64> {
+        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+        let result = sqlx::query(
+            "UPDATE furumusic__pending_review \
+             SET status = 'failed', \
+                 error_message = 'Process restarted while review was being processed', \
+                 updated_at = $1 \
+             WHERE status = 'processing'"
+        )
+        .bind(&now)
+        .execute(pool)
+        .await?;
+        Ok(result.rows_affected())
+    }
+
+    pub fn error_message_str(&self) -> &str {
+        self.error_message.as_deref().unwrap_or("")
+    }
+
+    pub async fn delete_all(db: &Database) -> cot::db::Result<()> {
+        db.raw("DELETE FROM furumusic__pending_review").await?;
+        Ok(())
+    }
+
+    pub async fn delete_by_status(db: &Database, status: &str) -> cot::db::Result<()> {
+        let status_val: LimitedString<32> = LimitedString::new(status).unwrap();
+        cot::db::query!(PendingReview, $status == status_val)
+            .delete(db)
+            .await?;
+        Ok(())
+    }
+
+    pub fn id_val(&self) -> i64 {
+        self.id.unwrap()
+    }
+
+    pub fn status_str(&self) -> &str {
+        &self.status
+    }
+
+    pub fn review_type_str(&self) -> &str {
+        &self.review_type
+    }
+
+    pub fn input_path_str(&self) -> &str {
+        self.input_path.as_deref().unwrap_or("")
+    }
+
+    pub fn context_json_str(&self) -> &str {
+        self.context_json.as_deref().unwrap_or("")
+    }
+
+    pub fn result_json_str(&self) -> &str {
+        self.result_json.as_deref().unwrap_or("")
+    }
+
+    pub fn confidence(&self) -> Option<f64> {
+        let rj = self.result_json.as_deref()?;
+        let v: serde_json::Value = serde_json::from_str(rj).ok()?;
+        v.get("confidence")?.as_f64()
+    }
+
+    pub fn status_badge_class(&self) -> &str {
+        match self.status.as_str() {
+            "approved" | "auto_approved" => "badge-completed",
+            "rejected" | "failed" => "badge-failed",
+            "pending" => "badge-pending",
+            "queued" => "badge-queued",
+            "processing" => "badge-processing",
+            _ => "badge-default",
+        }
+    }
+
+    pub fn created_at_str(&self) -> &str {
+        &self.created_at
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ProcessingStats — per-file LLM processing statistics
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+#[cot::db::model]
+pub struct ProcessingStats {
+    #[model(primary_key)]
+    pub id: Auto<i64>,
+    pub pending_review_id: i64,
+    pub model_name: LimitedString<128>,
+    pub llm_duration_ms: i64,
+    pub prompt_tokens: i64,
+    pub completion_tokens: i64,
+    pub created_at: LimitedString<32>,
+}
+
+impl ProcessingStats {
+    pub async fn create(
+        db: &Database,
+        pending_review_id: i64,
+        model_name: &str,
+        llm_duration_ms: i64,
+        prompt_tokens: i64,
+        completion_tokens: i64,
+    ) -> cot::db::Result<Self> {
+        let mut stats = Self {
+            id: Auto::auto(),
+            pending_review_id,
+            model_name: LimitedString::new(model_name).unwrap(),
+            llm_duration_ms,
+            prompt_tokens,
+            completion_tokens,
+            created_at: now_iso(),
+        };
+        stats.insert(db).await?;
+        Ok(stats)
+    }
+
+    pub async fn get_by_review_id(db: &Database, review_id: i64) -> cot::db::Result<Option<Self>> {
+        let all = cot::db::query!(ProcessingStats, $pending_review_id == review_id)
+            .all(db)
+            .await?;
+        Ok(all.into_iter().next())
+    }
+
+    pub async fn list_by_review_ids(pool: &sqlx::PgPool, ids: &[i64]) -> anyhow::Result<HashMap<i64, ProcessingStatsRow>> {
+        if ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+        // Build comma-separated ID list
+        let id_list: String = ids.iter().map(|id| id.to_string()).collect::<Vec<_>>().join(",");
+        let query = format!(
+            "SELECT pending_review_id, model_name, llm_duration_ms, prompt_tokens, completion_tokens \
+             FROM furumusic__processing_stats WHERE pending_review_id IN ({id_list})"
+        );
+        let rows = sqlx::query_as::<_, ProcessingStatsRow>(&query)
+            .fetch_all(pool)
+            .await?;
+        let map = rows.into_iter().map(|r| (r.pending_review_id, r)).collect();
+        Ok(map)
+    }
+
+    pub fn model_name_str(&self) -> &str {
+        &self.model_name
+    }
+
+    pub fn duration_display(&self) -> String {
+        if self.llm_duration_ms >= 1000 {
+            format!("{:.1}s", self.llm_duration_ms as f64 / 1000.0)
+        } else {
+            format!("{}ms", self.llm_duration_ms)
+        }
+    }
+
+    pub fn tokens_display(&self) -> String {
+        format!("{}/{}", self.prompt_tokens, self.completion_tokens)
+    }
+}
+
+#[derive(Debug, Clone, sqlx::FromRow)]
+pub struct ProcessingStatsRow {
+    pub pending_review_id: i64,
+    pub model_name: String,
+    pub llm_duration_ms: i64,
+    pub prompt_tokens: i64,
+    pub completion_tokens: i64,
+}
+
+impl ProcessingStatsRow {
+    pub fn duration_display(&self) -> String {
+        if self.llm_duration_ms >= 1000 {
+            format!("{:.1}s", self.llm_duration_ms as f64 / 1000.0)
+        } else {
+            format!("{}ms", self.llm_duration_ms)
+        }
+    }
+
+    pub fn tokens_display(&self) -> String {
+        format!("{}/{}", self.prompt_tokens, self.completion_tokens)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Migrations
+// ---------------------------------------------------------------------------
+
+pub mod db_migrations {
+    use super::*;
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0022CreateScheduledJob;
+
+    impl migrations::Migration for M0022CreateScheduledJob {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0022_create_scheduled_job";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0021_create_trgm_indexes"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__scheduled_job"))
+                .fields(&[
+                    Field::new(Identifier::new("name"), <String as DatabaseField>::TYPE)
+                        .primary_key()
+                        .set_null(<String as DatabaseField>::NULLABLE),
+                    Field::new(Identifier::new("description"), <String as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("cron_expression"), <LimitedString<100> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("enabled"), <bool as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("last_run_at"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("next_run_at"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0023CreateJobRun;
+
+    impl migrations::Migration for M0023CreateJobRun {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0023_create_job_run";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0022_create_scheduled_job"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__job_run"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("job_name"), <LimitedString<100> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("status"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("started_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("finished_at"), <LimitedString<32> as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("duration_ms"), <i64 as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("log_output"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("error_message"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("trigger"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0024CreatePendingReview;
+
+    impl migrations::Migration for M0024CreatePendingReview {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0024_create_pending_review";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0023_create_job_run"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__pending_review"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("job_run_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("review_type"), <LimitedString<64> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("input_path"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("context_json"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("result_json"), <String as DatabaseField>::TYPE)
+                        .set_null(true),
+                    Field::new(Identifier::new("status"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("updated_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    #[cot::db::migrations::migration_op]
+    async fn create_scheduler_indexes(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        let stmts = [
+            "CREATE INDEX idx_job_run_job_name ON furumusic__job_run (job_name, id DESC)",
+            "CREATE INDEX idx_job_run_status ON furumusic__job_run (status)",
+            "CREATE INDEX idx_pending_review_status ON furumusic__pending_review (status, created_at)",
+            "CREATE INDEX idx_pending_review_job_run ON furumusic__pending_review (job_run_id)",
+        ];
+        for stmt in stmts {
+            ctx.db.raw(stmt).await?;
+        }
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0025CreateSchedulerIndexes;
+
+    impl migrations::Migration for M0025CreateSchedulerIndexes {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0025_create_scheduler_indexes";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0024_create_pending_review"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(create_scheduler_indexes).build(),
+        ];
+    }
+
+    #[cot::db::migrations::migration_op]
+    async fn add_pending_review_error_message(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
+        ctx.db
+            .raw("ALTER TABLE furumusic__pending_review ADD COLUMN error_message TEXT")
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0026AddPendingReviewErrorMessage;
+
+    impl migrations::Migration for M0026AddPendingReviewErrorMessage {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0026_add_pending_review_error_message";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0025_create_scheduler_indexes"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::custom(add_pending_review_error_message).build(),
+        ];
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0027CreateProcessingStats;
+
+    impl migrations::Migration for M0027CreateProcessingStats {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0027_create_processing_stats";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
+            migrations::MigrationDependency::migration("furumusic", "m_0026_add_pending_review_error_message"),
+        ];
+        const OPERATIONS: &'static [Operation] = &[
+            Operation::create_model()
+                .table_name(Identifier::new("furumusic__processing_stats"))
+                .fields(&[
+                    Field::new(Identifier::new("id"), <i64 as DatabaseField>::TYPE)
+                        .primary_key()
+                        .auto(),
+                    Field::new(Identifier::new("pending_review_id"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("model_name"), <LimitedString<128> as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("llm_duration_ms"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("prompt_tokens"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("completion_tokens"), <i64 as DatabaseField>::TYPE),
+                    Field::new(Identifier::new("created_at"), <LimitedString<32> as DatabaseField>::TYPE),
+                ])
+                .build(),
+        ];
+    }
+
+    pub const MIGRATIONS: &[&SyncDynMigration] = &[
+        &M0022CreateScheduledJob,
+        &M0023CreateJobRun,
+        &M0024CreatePendingReview,
+        &M0025CreateSchedulerIndexes,
+        &M0026AddPendingReviewErrorMessage,
+        &M0027CreateProcessingStats,
+    ];
+}
+
+// ---------------------------------------------------------------------------
+// Job Trait + JobContext + JobLog
+// ---------------------------------------------------------------------------
+
+pub struct JobContext {
+    pub config: Arc<AppConfig>,
+    pub db: Database,
+    pub pool: sqlx::PgPool,
+    pub run_id: i64,
+    pub registry: Arc<JobRegistry>,
+}
+
+pub struct JobLog {
+    lines: Vec<String>,
+    pool: Option<sqlx::PgPool>,
+    run_id: i64,
+}
+
+#[allow(dead_code)]
+impl JobLog {
+    pub fn new() -> Self {
+        Self { lines: Vec::new(), pool: None, run_id: 0 }
+    }
+
+    pub fn with_live_flush(pool: sqlx::PgPool, run_id: i64) -> Self {
+        Self { lines: Vec::new(), pool: Some(pool), run_id }
+    }
+
+    pub fn info(&mut self, msg: &str) {
+        let ts = chrono::Utc::now().format("%H:%M:%S");
+        self.lines.push(format!("[{ts} INFO] {msg}"));
+        tracing::info!("{msg}");
+        self.flush_to_db();
+    }
+
+    pub fn warn(&mut self, msg: &str) {
+        let ts = chrono::Utc::now().format("%H:%M:%S");
+        self.lines.push(format!("[{ts} WARN] {msg}"));
+        tracing::warn!("{msg}");
+        self.flush_to_db();
+    }
+
+    pub fn error(&mut self, msg: &str) {
+        let ts = chrono::Utc::now().format("%H:%M:%S");
+        self.lines.push(format!("[{ts} ERROR] {msg}"));
+        tracing::error!("{msg}");
+        self.flush_to_db();
+    }
+
+    pub fn output(&self) -> String {
+        self.lines.join("\n")
+    }
+
+    fn flush_to_db(&self) {
+        if let Some(pool) = &self.pool {
+            let output = self.output();
+            let run_id = self.run_id;
+            let pool = pool.clone();
+            tokio::spawn(async move {
+                let _ = sqlx::query(
+                    "UPDATE furumusic__job_run SET log_output = $1 WHERE id = $2"
+                )
+                .bind(&output)
+                .bind(run_id)
+                .execute(&pool)
+                .await;
+            });
+        }
+    }
+}
+
+#[async_trait::async_trait]
+pub trait Job: Send + Sync + 'static {
+    fn name(&self) -> &'static str;
+    fn description(&self) -> &'static str;
+    fn default_cron(&self) -> &'static str;
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()>;
+}
+
+pub struct JobRegistry {
+    jobs: HashMap<&'static str, Box<dyn Job>>,
+}
+
+impl JobRegistry {
+    pub fn new() -> Self {
+        Self {
+            jobs: HashMap::new(),
+        }
+    }
+
+    pub fn register(&mut self, job: impl Job) {
+        self.jobs.insert(job.name(), Box::new(job));
+    }
+
+    pub fn get(&self, name: &str) -> Option<&dyn Job> {
+        self.jobs.get(name).map(|b| b.as_ref())
+    }
+
+    pub fn all_jobs(&self) -> Vec<&dyn Job> {
+        self.jobs.values().map(|b| b.as_ref()).collect()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Cron helper — uses croner (via tokio-cron-scheduler) for 6-field cron
+// ---------------------------------------------------------------------------
+
+pub fn compute_next_run(cron_expr: &str) -> Option<String> {
+    let cron = croner::parser::CronParser::new().parse(cron_expr).ok()?;
+    let now = chrono::Utc::now();
+    let next = cron.find_next_occurrence(&now, false).ok()?;
+    Some(next.format("%Y-%m-%dT%H:%M:%SZ").to_string())
+}
+
+// ---------------------------------------------------------------------------
+// SchedulerHandle — shared state for the cron scheduler
+// ---------------------------------------------------------------------------
+
+pub struct SchedulerHandle {
+    pub scheduler: tokio_cron_scheduler::JobScheduler,
+    pub registry: Arc<JobRegistry>,
+    job_uuids: tokio::sync::RwLock<HashMap<String, uuid::Uuid>>,
+    /// Shared database connection — avoids creating a new one per cron fire.
+    shared_db: Database,
+    /// Shared connection pool — avoids creating a new pool per cron fire.
+    shared_pool: sqlx::PgPool,
+}
+
+impl SchedulerHandle {
+    /// Execute a job immediately (manual or programmatic trigger).
+    pub async fn trigger_job_now(&self, job_name: &str) -> anyhow::Result<i64> {
+        let job_impl = self
+            .registry
+            .get(job_name)
+            .ok_or_else(|| anyhow::anyhow!("unknown job: {job_name}"))?;
+
+        let db = &self.shared_db;
+        let pool = &self.shared_pool;
+
+        let (live_config, _) = AppConfig::load_with_db(db).await;
+
+        let mut run = JobRun::create_running(db, job_name, "manual")
+            .await
+            .map_err(|e| anyhow::anyhow!("failed to create job run: {e}"))?;
+
+        let start = std::time::Instant::now();
+        let ctx = JobContext {
+            config: Arc::new(live_config),
+            db: db.clone(),
+            pool: pool.clone(),
+            run_id: run.id_val(),
+            registry: Arc::clone(&self.registry),
+        };
+        let mut log = JobLog::with_live_flush(pool.clone(), run.id_val());
+
+        match job_impl.run(&ctx, &mut log).await {
+            Ok(()) => {
+                let duration_ms = start.elapsed().as_millis() as i64;
+                let _ = run.set_completed(db, duration_ms, &log.output()).await;
+            }
+            Err(e) => {
+                let duration_ms = start.elapsed().as_millis() as i64;
+                let _ = run.set_failed(db, duration_ms, &log.output(), &e.to_string()).await;
+            }
+        }
+
+        if let Ok(Some(mut sched_job)) = ScheduledJob::get_by_name(db, job_name).await {
+            sched_job.last_run_at = Some(now_iso());
+            sched_job.updated_at = now_iso();
+            let _ = sched_job.save(db).await;
+        }
+
+        Ok(run.id_val())
+    }
+
+    /// Remove a cron job from the scheduler and re-add it with a new cron
+    /// expression.  Also updates the DB row.
+    pub async fn reschedule_job(&self, job_name: &str, new_cron: &str) -> anyhow::Result<()> {
+        // Remove old UUID if present
+        {
+            let mut uuids = self.job_uuids.write().await;
+            if let Some(old_uuid) = uuids.remove(job_name) {
+                let _ = self.scheduler.remove(&old_uuid).await;
+            }
+        }
+
+        // Add new cron job
+        self.add_cron_job(job_name, new_cron).await?;
+
+        // Update DB
+        if let Ok(Some(mut sched_job)) = ScheduledJob::get_by_name(&self.shared_db, job_name).await {
+            sched_job.cron_expression = LimitedString::new(new_cron).unwrap();
+            sched_job.next_run_at = compute_next_run(new_cron)
+                .map(|s| LimitedString::new(&s).unwrap());
+            sched_job.updated_at = now_iso();
+            let _ = sched_job.save(&self.shared_db).await;
+        }
+
+        Ok(())
+    }
+
+    /// Enable or disable a job.  When disabling, removes it from the cron
+    /// scheduler.  When enabling, adds it back.
+    pub async fn toggle_job(&self, job_name: &str, enabled: bool) -> anyhow::Result<()> {
+        let mut sched_job = ScheduledJob::get_by_name(&self.shared_db, job_name)
+            .await
+            .map_err(|e| anyhow::anyhow!("db: {e}"))?
+            .ok_or_else(|| anyhow::anyhow!("job not found: {job_name}"))?;
+
+        if !enabled {
+            // Remove from scheduler
+            let mut uuids = self.job_uuids.write().await;
+            if let Some(old_uuid) = uuids.remove(job_name) {
+                let _ = self.scheduler.remove(&old_uuid).await;
+            }
+        } else {
+            // Add to scheduler with current cron
+            let cron = sched_job.cron_expression_str().to_owned();
+            self.add_cron_job(job_name, &cron).await?;
+        }
+
+        sched_job.enabled = enabled;
+        if enabled {
+            sched_job.next_run_at = compute_next_run(sched_job.cron_expression_str())
+                .map(|s| LimitedString::new(&s).unwrap());
+        }
+        sched_job.updated_at = now_iso();
+        let _ = sched_job.save(&self.shared_db).await;
+
+        Ok(())
+    }
+
+    /// Internal: create a tokio-cron-scheduler Job and register it.
+    async fn add_cron_job(&self, job_name: &str, cron_expr: &str) -> anyhow::Result<()> {
+        let name = job_name.to_owned();
+        let registry = Arc::clone(&self.registry);
+        let shared_db = self.shared_db.clone();
+        let shared_pool = self.shared_pool.clone();
+
+        let cron_job = tokio_cron_scheduler::Job::new_async(cron_expr, move |_uuid, _lock| {
+            let name = name.clone();
+            let registry = Arc::clone(&registry);
+            let db = shared_db.clone();
+            let pool = shared_pool.clone();
+            Box::pin(async move {
+                run_scheduled_job(&name, &registry, &db, &pool).await;
+            })
+        })?;
+
+        let uuid = self.scheduler.add(cron_job).await?;
+        self.job_uuids.write().await.insert(job_name.to_owned(), uuid);
+
+        Ok(())
+    }
+}
+
+/// Runs a single scheduled job — called from cron closure.
+async fn run_scheduled_job(
+    job_name: &str,
+    registry: &Arc<JobRegistry>,
+    db: &Database,
+    pool: &sqlx::PgPool,
+) {
+    tracing::info!(job = job_name, "Cron fire received");
+
+    let job_impl = match registry.get(job_name) {
+        Some(j) => j,
+        None => {
+            tracing::error!(job = job_name, "Cron fired but job not found in registry");
+            return;
+        }
+    };
+
+    // Check agent_enabled (re-read from DB every run)
+    let (live_config, _) = AppConfig::load_with_db(db).await;
+    if !live_config.agent_enabled {
+        tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
+        return;
+    }
+
+    // Check if job is still enabled in DB
+    match ScheduledJob::get_by_name(db, job_name).await {
+        Ok(Some(sj)) if !sj.enabled => {
+            tracing::warn!(job = job_name, "Skipping: job disabled in DB");
+            return;
+        }
+        _ => {}
+    }
+
+    // Pre-check: skip inbox_process if orchestrator is already running
+    // (avoids creating a JobRun that will immediately exit)
+    if job_name == "inbox_process" && crate::jobs::inbox_process::is_orchestrator_running() {
+        tracing::info!(
+            job = job_name,
+            "Scheduler: skipping — orchestrator already running (pre-check)"
+        );
+        return;
+    }
+
+    tracing::info!(job = job_name, "Scheduler: starting job");
+
+    let mut run = match JobRun::create_running(db, job_name, "scheduled").await {
+        Ok(r) => r,
+        Err(e) => {
+            tracing::error!(job = job_name, "Failed to create job run: {e}");
+            return;
+        }
+    };
+
+    let start = std::time::Instant::now();
+    let ctx = JobContext {
+        config: Arc::new(live_config),
+        db: db.clone(),
+        pool: pool.clone(),
+        run_id: run.id_val(),
+        registry: Arc::clone(registry),
+    };
+    let mut log = JobLog::with_live_flush(pool.clone(), run.id_val());
+
+    match job_impl.run(&ctx, &mut log).await {
+        Ok(()) => {
+            let duration_ms = start.elapsed().as_millis() as i64;
+            tracing::info!(job = job_name, duration_ms, "Job completed successfully");
+            let _ = run.set_completed(db, duration_ms, &log.output()).await;
+        }
+        Err(e) => {
+            let duration_ms = start.elapsed().as_millis() as i64;
+            tracing::error!(job = job_name, duration_ms, "Job failed: {e}");
+            let _ = run.set_failed(db, duration_ms, &log.output(), &e.to_string()).await;
+        }
+    }
+
+    // Update ScheduledJob last_run_at + next_run_at
+    let now = now_iso();
+    let cron_expr = match ScheduledJob::get_by_name(db, job_name).await {
+        Ok(Some(j)) => j.cron_expression_str().to_owned(),
+        _ => return,
+    };
+    let next = compute_next_run(&cron_expr);
+    let next_str = next.as_deref().unwrap_or("");
+    let _ = sqlx::query(
+        "UPDATE furumusic__scheduled_job SET last_run_at = $1, next_run_at = $2, updated_at = $3 WHERE name = $4"
+    )
+        .bind(now.as_str())
+        .bind(next_str)
+        .bind(now.as_str())
+        .bind(job_name)
+        .execute(pool)
+        .await;
+}
+
+// ---------------------------------------------------------------------------
+// start_scheduler — creates and starts the SchedulerHandle
+// ---------------------------------------------------------------------------
+
+pub async fn start_scheduler(
+    config: &Arc<AppConfig>,
+    registry: Arc<JobRegistry>,
+) -> anyhow::Result<Arc<SchedulerHandle>> {
+    if config.database_url.is_empty() {
+        anyhow::bail!("No database URL configured, scheduler will not start");
+    }
+
+    let db = Database::new(&config.database_url)
+        .await
+        .map_err(|e| anyhow::anyhow!("scheduler db connect: {e}"))?;
+    let pool = sqlx::postgres::PgPoolOptions::new()
+        .max_connections(10)
+        .connect(&config.database_url)
+        .await?;
+
+    // Recover stale runs and reviews from previous process crash
+    match JobRun::recover_stale(&pool).await {
+        Ok(0) => {}
+        Ok(n) => tracing::warn!("Recovered {n} stale job run(s) stuck in 'running' status"),
+        Err(e) => tracing::error!("Failed to recover stale job runs: {e}"),
+    }
+    match PendingReview::recover_stale(&pool).await {
+        Ok(0) => {}
+        Ok(n) => tracing::warn!("Marked {n} stale review(s) stuck in 'processing' as 'failed'"),
+        Err(e) => tracing::error!("Failed to recover stale reviews: {e}"),
+    }
+
+    // Upsert ScheduledJob rows
+    for job in registry.all_jobs() {
+        ScheduledJob::upsert(&db, job.name(), job.description(), job.default_cron())
+            .await
+            .map_err(|e| anyhow::anyhow!("failed to upsert scheduled job {}: {e}", job.name()))?;
+    }
+
+    // Clean orphans
+    if let Ok(all_jobs) = ScheduledJob::list_all(&db).await {
+        for sched_job in &all_jobs {
+            if registry.get(sched_job.name_str()).is_none() {
+                tracing::warn!(
+                    "Removing orphaned scheduled job '{}' (no longer registered)",
+                    sched_job.name_str()
+                );
+                let _ = ScheduledJob::delete_by_name(&db, sched_job.name_str()).await;
+            }
+        }
+    }
+
+    // Create scheduler
+    let sched = tokio_cron_scheduler::JobScheduler::new().await?;
+
+    let handle = Arc::new(SchedulerHandle {
+        scheduler: sched,
+        registry: Arc::clone(&registry),
+        job_uuids: tokio::sync::RwLock::new(HashMap::new()),
+        shared_db: db.clone(),
+        shared_pool: pool.clone(),
+    });
+
+    // Register cron jobs for enabled jobs
+    let mut cron_count = 0u32;
+    if let Ok(all_jobs) = ScheduledJob::list_all(&db).await {
+        for sched_job in &all_jobs {
+            if !sched_job.enabled {
+                continue;
+            }
+            let cron_expr = sched_job.cron_expression_str();
+            if cron_expr.is_empty() {
+                continue;
+            }
+            match handle.add_cron_job(sched_job.name_str(), cron_expr).await {
+                Ok(()) => {
+                    cron_count += 1;
+                    // Update next_run_at in DB
+                    if let Some(next) = compute_next_run(cron_expr) {
+                        let _ = sqlx::query(
+                            "UPDATE furumusic__scheduled_job SET next_run_at = $1 WHERE name = $2"
+                        )
+                            .bind(&next)
+                            .bind(sched_job.name_str())
+                            .execute(&pool)
+                            .await;
+                    }
+                }
+                Err(e) => {
+                    tracing::error!(
+                        job = sched_job.name_str(),
+                        cron = cron_expr,
+                        "Failed to register cron job: {e}"
+                    );
+                }
+            }
+        }
+    }
+
+    handle.scheduler.start().await?;
+    tracing::info!("Scheduler started with {cron_count} cron jobs");
+
+    Ok(handle)
+}
+
+// ---------------------------------------------------------------------------
+// Standalone trigger — for programmatic (job→job) chaining
+// ---------------------------------------------------------------------------
+
+/// Trigger a job immediately without needing a SchedulerHandle.
+/// Used by jobs to chain-spawn other jobs (e.g. inbox_discover → inbox_process).
+/// Reuses the caller's db/pool to avoid creating new connections.
+pub async fn trigger_job_now(
+    _config: &Arc<AppConfig>,
+    db: &Database,
+    pool: &sqlx::PgPool,
+    registry: &Arc<JobRegistry>,
+    job_name: &str,
+) -> anyhow::Result<i64> {
+    // Pre-check: skip inbox_process if orchestrator is already running
+    if job_name == "inbox_process" && crate::jobs::inbox_process::is_orchestrator_running() {
+        tracing::info!(
+            job = job_name,
+            "trigger_job_now: skipping — orchestrator already running (pre-check)"
+        );
+        anyhow::bail!("orchestrator already running");
+    }
+
+    let job_impl = registry
+        .get(job_name)
+        .ok_or_else(|| anyhow::anyhow!("unknown job: {job_name}"))?;
+
+    let (live_config, _) = AppConfig::load_with_db(db).await;
+
+    let mut run = JobRun::create_running(db, job_name, "programmatic")
+        .await
+        .map_err(|e| anyhow::anyhow!("failed to create job run: {e}"))?;
+
+    let start = std::time::Instant::now();
+    let ctx = JobContext {
+        config: Arc::new(live_config),
+        db: db.clone(),
+        pool: pool.clone(),
+        run_id: run.id_val(),
+        registry: Arc::clone(registry),
+    };
+    let mut log = JobLog::with_live_flush(pool.clone(), run.id_val());
+
+    match job_impl.run(&ctx, &mut log).await {
+        Ok(()) => {
+            let duration_ms = start.elapsed().as_millis() as i64;
+            let _ = run.set_completed(db, duration_ms, &log.output()).await;
+        }
+        Err(e) => {
+            let duration_ms = start.elapsed().as_millis() as i64;
+            let _ = run.set_failed(db, duration_ms, &log.output(), &e.to_string()).await;
+        }
+    }
+
+    if let Ok(Some(mut sched_job)) = ScheduledJob::get_by_name(db, job_name).await {
+        sched_job.last_run_at = Some(now_iso());
+        sched_job.updated_at = now_iso();
+        let _ = sched_job.save(db).await;
+    }
+
+    Ok(run.id_val())
+}
diff --git a/templates/admin/artist_form.html b/templates/admin/artist_form.html
new file mode 100644
index 0000000..fdc6bb0
--- /dev/null
+++ b/templates/admin/artist_form.html
@@ -0,0 +1,133 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{% if is_edit %}{{ t.artists_edit_heading }}{% else %}{{ t.artists_new_heading }}{% endif %}{% endblock admin_title %}
+
+{% block content %}
+<h1>{% if is_edit %}{{ t.artists_edit_heading }}{% else %}{{ t.artists_new_heading }}{% endif %}</h1>
+
+<form method="post" action="{% if is_edit %}/admin/artists/{{ form_artist_id }}/edit{% else %}/admin/artists/new{% endif %}">
+  <table>
+    <tr>
+      <td><label for="name">{{ t.artists_name }}</label></td>
+      <td><input name="name" id="name" value="{{ form_name }}" required style="width:100%"></td>
+    </tr>
+  </table>
+  <button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
+</form>
+
+{% if is_edit %}
+<hr style="margin: 2rem 0;">
+<h2>{{ t.artists_image }}</h2>
+
+<div id="artist-image-section" style="margin-top: 1rem;">
+  <!-- Current image -->
+  <div style="margin-bottom: 1.5rem;">
+    {% match current_image_url %}
+      {% when Some with (url) %}
+        <img id="current-image" src="{{ url }}" alt="" style="max-width: 200px; max-height: 200px; border-radius: 6px; border: 1px solid #ddd;">
+        <br>
+        <button type="button" onclick="removeImage()" style="margin-top: .5rem; padding: .3rem 1rem; cursor: pointer;">{{ t.artists_remove_image }}</button>
+      {% when None %}
+        <p style="color: #888;">{{ t.artists_no_image }}</p>
+    {% endmatch %}
+  </div>
+
+  <!-- Upload custom image -->
+  <div style="margin-bottom: 1.5rem;">
+    <h3 style="font-size: .95rem; margin-bottom: .5rem;">{{ t.artists_upload_image }}</h3>
+    <input type="file" id="image-upload" accept="image/*" style="margin-bottom: .5rem;">
+    <br>
+    <button type="button" id="upload-btn" onclick="uploadImage()" style="padding: .3rem 1rem; cursor: pointer;" disabled>{{ t.artists_upload }}</button>
+  </div>
+
+  <!-- Pick from album covers -->
+  <div>
+    <h3 style="font-size: .95rem; margin-bottom: .5rem;">{{ t.artists_pick_cover }}</h3>
+    <div id="covers-grid" style="display: flex; flex-wrap: wrap; gap: .75rem;">
+      <p style="color: #888;" id="covers-loading">...</p>
+    </div>
+  </div>
+</div>
+
+<script>
+  const artistId = {{ form_artist_id }};
+
+  // Enable upload button when file selected
+  document.getElementById('image-upload').addEventListener('change', function() {
+    document.getElementById('upload-btn').disabled = !this.files.length;
+  });
+
+  // Upload custom image
+  function uploadImage() {
+    const fileInput = document.getElementById('image-upload');
+    const file = fileInput.files[0];
+    if (!file) return;
+
+    const reader = new FileReader();
+    reader.onload = function() {
+      const base64 = reader.result.split(',')[1];
+      fetch('/admin/artists/' + artistId + '/upload-image', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          data: base64,
+          filename: file.name,
+          mime_type: file.type || 'image/jpeg'
+        })
+      }).then(function(r) {
+        if (r.ok) location.reload();
+        else r.text().then(function(t) { alert('Error: ' + t); });
+      });
+    };
+    reader.readAsDataURL(file);
+  }
+
+  // Set image from album cover
+  function setImage(mediaFileId) {
+    fetch('/admin/artists/' + artistId + '/set-image', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ media_file_id: mediaFileId })
+    }).then(function(r) {
+      if (r.ok) location.reload();
+      else r.text().then(function(t) { alert('Error: ' + t); });
+    });
+  }
+
+  // Remove image
+  function removeImage() {
+    fetch('/admin/artists/' + artistId + '/set-image', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ media_file_id: null })
+    }).then(function(r) {
+      if (r.ok) location.reload();
+      else r.text().then(function(t) { alert('Error: ' + t); });
+    });
+  }
+
+  // Load available covers
+  fetch('/admin/artists/' + artistId + '/available-covers')
+    .then(function(r) { return r.json(); })
+    .then(function(covers) {
+      const grid = document.getElementById('covers-grid');
+      grid.innerHTML = '';
+      if (!covers.length) {
+        grid.innerHTML = '<p style="color: #888;">{{ t.artists_no_covers }}</p>';
+        return;
+      }
+      covers.forEach(function(c) {
+        const div = document.createElement('div');
+        div.style.cssText = 'cursor:pointer; text-align:center;';
+        div.title = c.release_title;
+        div.innerHTML = '<img src="' + c.cover_url + '" alt="" style="width:100px; height:100px; object-fit:cover; border-radius:4px; border:2px solid #ddd;">'
+          + '<br><small style="font-size:.75rem; color:#666;">' + c.release_title.substring(0, 20) + '</small>';
+        div.onclick = function() { setImage(c.media_file_id); };
+        grid.appendChild(div);
+      });
+    })
+    .catch(function() {
+      document.getElementById('covers-grid').innerHTML = '<p style="color: #888;">{{ t.artists_no_covers }}</p>';
+    });
+</script>
+{% endif %}
+{% endblock content %}
diff --git a/templates/admin/artists.html b/templates/admin/artists.html
new file mode 100644
index 0000000..1c704b0
--- /dev/null
+++ b/templates/admin/artists.html
@@ -0,0 +1,45 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.nav_artists }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.artists_heading }}</h1>
+
+<p style="margin-bottom: 1rem;">
+    <a href="/admin/artists/new" style="display:inline-block; padding:.5rem 1rem; background:#1a1a2e; color:#fff; text-decoration:none; border-radius:4px;">{{ t.artists_add }}</a>
+</p>
+
+{% if rows.is_empty() %}
+<p>{{ t.artists_empty }}</p>
+{% else %}
+<table>
+    <tr>
+        <th>ID</th>
+        <th>{{ t.artists_name }}</th>
+        <th>{{ t.artists_releases }}</th>
+        <th>{{ t.artists_tracks }}</th>
+        <th>{{ t.artists_hidden }}</th>
+        <th>{{ t.artists_actions }}</th>
+    </tr>
+    {% for row in rows %}
+    <tr>
+        <td>{{ row.artist.id_val() }}</td>
+        <td>{{ row.artist.name_str() }}</td>
+        <td>
+            <a href="/admin/releases?artist_id={{ row.artist.id_val() }}">{{ row.release_count }}</a>
+        </td>
+        <td>{{ row.track_count }}</td>
+        <td>{{ row.artist.is_hidden() }}</td>
+        <td>
+            <a href="/admin/artists/{{ row.artist.id_val() }}/edit">{{ t.artists_edit }}</a>
+            &nbsp;|&nbsp;
+            <a href="/admin/releases?artist_id={{ row.artist.id_val() }}">{{ t.artists_view_releases }}</a>
+            &nbsp;|&nbsp;
+            <form method="post" action="/admin/artists/{{ row.artist.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.artists_delete_confirm }}')">
+                <button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.artists_delete }}</button>
+            </form>
+        </td>
+    </tr>
+    {% endfor %}
+</table>
+{% endif %}
+{% endblock content %}
diff --git a/templates/admin/job_detail.html b/templates/admin/job_detail.html
new file mode 100644
index 0000000..5e2997b
--- /dev/null
+++ b/templates/admin/job_detail.html
@@ -0,0 +1,68 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ job.name_str() }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ job.name_str() }}</h1>
+
+<table>
+    <tr><th>{{ t.jobs_description }}</th><td>{{ job.description_str() }}</td></tr>
+    <tr><th>{{ t.jobs_cron }}</th><td><code>{{ job.cron_expression_str() }}</code></td></tr>
+    <tr><th>{{ t.jobs_enabled }}</th><td>{% if job.enabled() %}&#9989;{% else %}&#10060;{% endif %}</td></tr>
+    <tr><th>{{ t.jobs_last_run }}</th><td>{{ job.last_run_at_str() }}</td></tr>
+    <tr><th>{{ t.jobs_next_run }}</th><td>{{ job.next_run_at_str() }}</td></tr>
+</table>
+
+<div style="margin: 1rem 0; display: flex; gap: .5rem; align-items: flex-end;">
+    <form method="post" action="/admin/jobs/{{ job.name_str() }}/run" style="margin:0;">
+        <button type="submit" style="padding:.4rem 1rem; background:#007bff; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_run_now }}</button>
+    </form>
+    <form method="post" action="/admin/jobs/{{ job.name_str() }}/toggle" style="margin:0;">
+        {% if job.enabled() %}
+        <button type="submit" style="padding:.4rem 1rem; background:#dc3545; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_disable }}</button>
+        {% else %}
+        <button type="submit" style="padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_enable }}</button>
+        {% endif %}
+    </form>
+</div>
+
+<h2>{{ t.jobs_cron }}</h2>
+<p style="font-size:.85rem;color:#666;margin-bottom:.5rem;">{{ t.jobs_cron_help }}</p>
+<form method="post" action="/admin/jobs/{{ job.name_str() }}/cron" style="display:flex;gap:.5rem;align-items:center;margin-bottom:1.5rem;">
+    <input name="cron_expression" value="{{ job.cron_expression_str() }}" style="width:20em;font-family:monospace;">
+    <button type="submit" style="padding:.4rem 1rem; background:#6c757d; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.jobs_cron_update }}</button>
+</form>
+
+<h2>{{ t.jobs_run_history }}</h2>
+{% if runs.is_empty() %}
+<p>No runs yet.</p>
+{% else %}
+<table>
+    <tr>
+        <th>ID</th>
+        <th>{{ t.jobs_run_status }}</th>
+        <th>{{ t.jobs_run_started }}</th>
+        <th>{{ t.jobs_run_duration }}</th>
+        <th>{{ t.jobs_run_trigger }}</th>
+        <th>{{ t.jobs_actions }}</th>
+    </tr>
+    {% for run in runs %}
+    <tr>
+        <td>{{ run.id_val() }}</td>
+        <td><span class="badge {{ run.status_badge_class() }}">{{ run.status_str() }}</span></td>
+        <td>{{ run.started_at_str() }}</td>
+        <td>{{ run.duration_display() }}</td>
+        <td>{{ run.trigger_str() }}</td>
+        <td><a href="/admin/jobs/{{ job.name_str() }}/runs/{{ run.id_val() }}">{{ t.reviews_view }}</a></td>
+    </tr>
+    {% endfor %}
+</table>
+{% endif %}
+
+<p style="margin-top:1rem;"><a href="/admin/jobs">&larr; {{ t.jobs_back_to_list }}</a></p>
+
+<style>
+    .badge-completed { background: #d4edda; color: #155724; }
+    .badge-failed { background: #f8d7da; color: #721c24; }
+    .badge-processing { background: #d1ecf1; color: #0c5460; }
+</style>
+{% endblock content %}
diff --git a/templates/admin/job_run_detail.html b/templates/admin/job_run_detail.html
new file mode 100644
index 0000000..d277094
--- /dev/null
+++ b/templates/admin/job_run_detail.html
@@ -0,0 +1,31 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.jobs_run_detail }} #{{ run.id_val() }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.jobs_run_detail }} #{{ run.id_val() }}</h1>
+
+<table>
+    <tr><th>{{ t.jobs_run_status }}</th><td><span class="badge {{ run.status_badge_class() }}">{{ run.status_str() }}</span></td></tr>
+    <tr><th>{{ t.jobs_run_trigger }}</th><td>{{ run.trigger_str() }}</td></tr>
+    <tr><th>{{ t.jobs_run_started }}</th><td>{{ run.started_at_str() }}</td></tr>
+    <tr><th>{{ t.jobs_run_duration }}</th><td>{{ run.duration_display() }}</td></tr>
+</table>
+
+{% if !run.error_message_str().is_empty() %}
+<h2>{{ t.jobs_run_error }}</h2>
+<pre style="background:#f8d7da; color:#721c24; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ run.error_message_str() }}</pre>
+{% endif %}
+
+{% if !run.log_output_str().is_empty() %}
+<h2>{{ t.jobs_run_log }}</h2>
+<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem; max-height:40em; overflow-y:auto;">{{ run.log_output_str() }}</pre>
+{% endif %}
+
+<p style="margin-top:1rem;"><a href="/admin/jobs/{{ job_name }}">&larr; {{ t.jobs_back_to_job }}</a></p>
+
+<style>
+    .badge-completed { background: #d4edda; color: #155724; }
+    .badge-failed { background: #f8d7da; color: #721c24; }
+    .badge-processing { background: #d1ecf1; color: #0c5460; }
+</style>
+{% endblock content %}
diff --git a/templates/admin/jobs.html b/templates/admin/jobs.html
new file mode 100644
index 0000000..5c2d700
--- /dev/null
+++ b/templates/admin/jobs.html
@@ -0,0 +1,40 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.nav_jobs }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.jobs_heading }}</h1>
+
+<table>
+    <tr>
+        <th>{{ t.jobs_name }}</th>
+        <th>{{ t.jobs_description }}</th>
+        <th>{{ t.jobs_cron }}</th>
+        <th>{{ t.jobs_enabled }}</th>
+        <th>{{ t.jobs_last_run }}</th>
+        <th>{{ t.jobs_next_run }}</th>
+        <th>{{ t.jobs_actions }}</th>
+    </tr>
+    {% for job in jobs %}
+    <tr>
+        <td><a href="/admin/jobs/{{ job.name_str() }}">{{ job.name_str() }}</a></td>
+        <td>{{ job.description_str() }}</td>
+        <td><code>{{ job.cron_expression_str() }}</code></td>
+        <td>{% if job.enabled() %}&#9989;{% else %}&#10060;{% endif %}</td>
+        <td>{{ job.last_run_at_str() }}</td>
+        <td>{{ job.next_run_at_str() }}</td>
+        <td style="display:flex;gap:.3rem;">
+            <form method="post" action="/admin/jobs/{{ job.name_str() }}/run" style="margin:0;">
+                <button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #007bff; background:#007bff; color:#fff; cursor:pointer;">{{ t.jobs_run_now }}</button>
+            </form>
+            <form method="post" action="/admin/jobs/{{ job.name_str() }}/toggle" style="margin:0;">
+                {% if job.enabled() %}
+                <button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #dc3545; background:#fff; color:#dc3545; cursor:pointer;">{{ t.jobs_disable }}</button>
+                {% else %}
+                <button type="submit" style="padding:.3rem .6rem; border-radius:4px; border:1px solid #28a745; background:#fff; color:#28a745; cursor:pointer;">{{ t.jobs_enable }}</button>
+                {% endif %}
+            </form>
+        </td>
+    </tr>
+    {% endfor %}
+</table>
+{% endblock content %}
diff --git a/templates/admin/layout.html b/templates/admin/layout.html
index 3b439e4..8878540 100644
--- a/templates/admin/layout.html
+++ b/templates/admin/layout.html
@@ -3,6 +3,7 @@
 {% block title %}{% block admin_title %}{{ t.nav_admin }}{% endblock admin_title %} | {{ t.site_name }}{% endblock title %}
 
 {% block head_extra %}
+<script src="https://unpkg.com/htmx.org@2.0.4" integrity="sha384-HGfztofotfshcF7+8n44JQL2oJmowVChPTg48S+jvZoztPfvwD79OC/LTtG6dMp+" crossorigin="anonymous"></script>
 <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body { font-family: system-ui, -apple-system, sans-serif; display: flex; min-height: 100vh; background: #f5f5f5; color: #333; }
@@ -37,6 +38,11 @@
 <nav class="sidebar">
     <h2>{{ t.site_name }} {{ t.nav_admin }}</h2>
     <a href="/admin/">{{ t.nav_dashboard }}</a>
+    <a href="/admin/artists">{{ t.nav_artists }}</a>
+    <a href="/admin/releases">{{ t.nav_releases }}</a>
+    <a href="/admin/media-files">{{ t.nav_media_files }}</a>
+    <a href="/admin/jobs">{{ t.nav_jobs }}</a>
+    <a href="/admin/reviews">{{ t.nav_reviews }}</a>
     <a href="/admin/users">{{ t.nav_users }}</a>
     <a href="/admin/settings">{{ t.nav_settings }}</a>
     <a href="/admin/debug">{{ t.nav_debug }}</a>
diff --git a/templates/admin/media_files.html b/templates/admin/media_files.html
new file mode 100644
index 0000000..e372d99
--- /dev/null
+++ b/templates/admin/media_files.html
@@ -0,0 +1,51 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.nav_media_files }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.media_files_heading }}</h1>
+
+{% if rows.is_empty() %}
+<p>{{ t.media_files_empty }}</p>
+{% else %}
+<table>
+    <tr>
+        <th>ID</th>
+        <th>{{ t.media_files_filename }}</th>
+        <th>{{ t.media_files_type }}</th>
+        <th>{{ t.media_files_format }}</th>
+        <th>{{ t.media_files_size }}</th>
+        <th>{{ t.media_files_track }}</th>
+        <th>{{ t.media_files_path }}</th>
+        <th>{{ t.media_files_created }}</th>
+        <th>{{ t.media_files_actions }}</th>
+    </tr>
+    {% for row in rows %}
+    <tr>
+        <td>{{ row.media_file.id_val() }}</td>
+        <td>{{ row.media_file.original_filename_str() }}</td>
+        <td>{{ row.media_file.file_type_str() }}</td>
+        <td>{{ row.media_file.audio_format_str() }}</td>
+        <td>{{ row.media_file.file_size_display() }}</td>
+        <td>
+            {% if row.track_title.is_empty() %}
+            <span class="badge badge-orphan">{{ t.media_files_orphan }}</span>
+            {% else %}
+            {{ row.track_title }}
+            {% endif %}
+        </td>
+        <td style="max-width:250px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;" title="{{ row.media_file.file_path_str() }}">{{ row.media_file.file_path_str() }}</td>
+        <td>{{ row.media_file.created_at_str() }}</td>
+        <td>
+            <form method="post" action="/admin/media-files/{{ row.media_file.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.media_files_delete_confirm }}')">
+                <button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.media_files_delete }}</button>
+            </form>
+        </td>
+    </tr>
+    {% endfor %}
+</table>
+{% endif %}
+
+<style>
+    .badge-orphan { background: #fff3cd; color: #856404; }
+</style>
+{% endblock content %}
diff --git a/templates/admin/probe_fragment.html b/templates/admin/probe_fragment.html
new file mode 100644
index 0000000..8b0c261
--- /dev/null
+++ b/templates/admin/probe_fragment.html
@@ -0,0 +1,32 @@
+{% if !agent_enabled %}
+<p style="color:#999;">{{ t.settings_agent_status_disabled }}</p>
+{% else if agent_llm_url.is_empty() %}
+<p style="color:#999;">{{ t.settings_agent_status_no_url }}</p>
+{% else if agent_probe.ok %}
+<div style="border:1px solid #28a745; border-radius:6px; padding:1rem; margin-bottom:1rem; background:#f0fff0;">
+  <p style="margin:0 0 .5rem; font-weight:bold; color:#28a745;">{{ t.settings_agent_status_ok }}</p>
+  {% if !agent_probe.model_intro.is_empty() %}
+  <blockquote style="border-left:3px solid #28a745; padding-left:.75rem; margin:.5rem 0; color:#333; font-style:italic;">{{ agent_probe.model_intro }}</blockquote>
+  {% endif %}
+  <table style="font-size:.85rem; margin-top:.5rem;">
+    {% if !agent_probe.model_name.is_empty() %}
+    <tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_model_name }}</td><td><code>{{ agent_probe.model_name }}</code></td></tr>
+    {% endif %}
+    <tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_latency }}</td><td>{{ agent_probe.latency_ms }} ms</td></tr>
+    {% if let Some(pt) = agent_probe.prompt_tokens %}
+    <tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_prompt_tokens }}</td><td>{{ pt }}</td></tr>
+    {% endif %}
+    {% if let Some(ct) = agent_probe.completion_tokens %}
+    <tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_completion_tokens }}</td><td>{{ ct }}</td></tr>
+    {% endif %}
+    {% if let Some(tps) = agent_probe.tokens_per_sec %}
+    <tr><td style="padding-right:1rem; color:#666;">{{ t.settings_agent_tokens_per_sec }}</td><td>{{ format!("{:.1}", tps) }}</td></tr>
+    {% endif %}
+  </table>
+</div>
+{% else %}
+<div style="border:1px solid #dc3545; border-radius:6px; padding:1rem; margin-bottom:1rem; background:#fff5f5;">
+  <p style="margin:0 0 .5rem; font-weight:bold; color:#dc3545;">{{ t.settings_agent_status_error }}</p>
+  <p style="margin:0; font-size:.85rem; color:#666;">{{ agent_probe.error }}</p>
+</div>
+{% endif %}
diff --git a/templates/admin/release_form.html b/templates/admin/release_form.html
new file mode 100644
index 0000000..406fadd
--- /dev/null
+++ b/templates/admin/release_form.html
@@ -0,0 +1,130 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{% if is_edit %}{{ t.releases_edit_heading }}{% else %}{{ t.releases_new_heading }}{% endif %}{% endblock admin_title %}
+
+{% block content %}
+<h1>{% if is_edit %}{{ t.releases_edit_heading }}{% else %}{{ t.releases_new_heading }}{% endif %}</h1>
+
+<form method="post" action="{% if is_edit %}/admin/releases/{{ form_release_id }}/edit{% else %}/admin/releases/new{% endif %}" id="release-form">
+  <table>
+    <tr>
+      <td><label for="title">{{ t.releases_title }}</label></td>
+      <td><input name="title" id="title" value="{{ form_title }}" required style="width:100%"></td>
+    </tr>
+    <tr>
+      <td><label for="release_type">{{ t.releases_type }}</label></td>
+      <td>
+        <select name="release_type" id="release_type" style="width:100%; padding:.4rem;">
+          {% for rt in release_types %}
+          <option value="{{ rt.0 }}"{% if form_release_type == rt.0 %} selected{% endif %}>{% if lang_code == "ru" %}{{ rt.2 }}{% else %}{{ rt.1 }}{% endif %} ({{ rt.0 }})</option>
+          {% endfor %}
+        </select>
+      </td>
+    </tr>
+    <tr>
+      <td><label for="year">{{ t.releases_year }}</label></td>
+      <td><input name="year" id="year" type="number" min="1900" max="2100" value="{{ form_year }}" style="width:100%"></td>
+    </tr>
+    <tr>
+      <td><label>{{ t.releases_artists }}</label></td>
+      <td>
+        <div id="artist-tags" style="display:flex; flex-wrap:wrap; gap:.3rem; margin-bottom:.5rem;"></div>
+        <div style="display:flex; gap:.5rem;">
+          <input list="artist-list" id="artist-input" placeholder="{{ t.releases_select_artist }}" style="flex:1; padding:.4rem;">
+          <datalist id="artist-list">
+            {% for a in artists %}
+            <option value="{{ a.name_str() }}" data-id="{{ a.id_val() }}"></option>
+            {% endfor %}
+          </datalist>
+          <button type="button" onclick="addArtist()" style="padding:.4rem .8rem;">+</button>
+        </div>
+        <input type="hidden" name="artist_id" id="artist-ids-hidden" value="">
+      </td>
+    </tr>
+  </table>
+  <button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
+</form>
+
+<script>
+(function() {
+    // Artist data from server
+    var allArtists = [
+        {% for a in artists %}
+        { id: {{ a.id_val() }}, name: "{{ a.name_str() }}" },
+        {% endfor %}
+    ];
+
+    // Currently selected artist IDs
+    var selectedIds = [{% for aid in form_artist_ids %}{{ aid }},{% endfor %}];
+
+    var tagsContainer = document.getElementById('artist-tags');
+    var hiddenInput = document.getElementById('artist-ids-hidden');
+    var artistInput = document.getElementById('artist-input');
+
+    function findArtistByName(name) {
+        var lower = name.toLowerCase().trim();
+        for (var i = 0; i < allArtists.length; i++) {
+            if (allArtists[i].name.toLowerCase() === lower) return allArtists[i];
+        }
+        return null;
+    }
+
+    function findArtistById(id) {
+        for (var i = 0; i < allArtists.length; i++) {
+            if (allArtists[i].id === id) return allArtists[i];
+        }
+        return null;
+    }
+
+    function syncHidden() {
+        hiddenInput.value = selectedIds.join(',');
+    }
+
+    function renderTags() {
+        tagsContainer.innerHTML = '';
+        for (var i = 0; i < selectedIds.length; i++) {
+            var artist = findArtistById(selectedIds[i]);
+            if (!artist) continue;
+            var tag = document.createElement('span');
+            tag.style.cssText = 'display:inline-flex; align-items:center; gap:.3rem; padding:.2rem .5rem; background:#e9ecef; border-radius:4px; font-size:.85rem;';
+            tag.textContent = artist.name;
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.textContent = '\u00d7';
+            btn.style.cssText = 'background:none; border:none; cursor:pointer; font-size:1rem; color:#c00; padding:0; line-height:1;';
+            btn.setAttribute('data-id', artist.id);
+            btn.onclick = function() {
+                var rid = parseInt(this.getAttribute('data-id'));
+                selectedIds = selectedIds.filter(function(x) { return x !== rid; });
+                renderTags();
+                syncHidden();
+            };
+            tag.appendChild(btn);
+            tagsContainer.appendChild(tag);
+        }
+    }
+
+    window.addArtist = function() {
+        var artist = findArtistByName(artistInput.value);
+        if (!artist) return;
+        if (selectedIds.indexOf(artist.id) === -1) {
+            selectedIds.push(artist.id);
+            renderTags();
+            syncHidden();
+        }
+        artistInput.value = '';
+    };
+
+    // Allow pressing Enter in the artist input to add
+    artistInput.addEventListener('keydown', function(e) {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            window.addArtist();
+        }
+    });
+
+    // Initial render
+    renderTags();
+    syncHidden();
+})();
+</script>
+{% endblock content %}
diff --git a/templates/admin/releases.html b/templates/admin/releases.html
new file mode 100644
index 0000000..136a30b
--- /dev/null
+++ b/templates/admin/releases.html
@@ -0,0 +1,51 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.nav_releases }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.releases_heading }}</h1>
+
+<div style="display:flex; gap:1rem; align-items:center; margin-bottom:1rem; flex-wrap:wrap;">
+    <a href="/admin/releases/new" style="display:inline-block; padding:.5rem 1rem; background:#1a1a2e; color:#fff; text-decoration:none; border-radius:4px;">{{ t.releases_add }}</a>
+
+    <form method="get" action="/admin/releases" style="display:flex; gap:.5rem; align-items:center;">
+        <label for="artist_id" style="font-size:.85rem; color:#555;">{{ t.releases_filter_label }}:</label>
+        <select name="artist_id" id="artist_id" onchange="this.form.submit()" style="padding:.35rem .5rem; border:1px solid #ccc; border-radius:4px;">
+            <option value="">{{ t.releases_filter_all }}</option>
+            {% for a in artists %}
+            <option value="{{ a.id_val() }}"{% match filter_artist_id %}{% when Some with (fid) %}{% if *fid == a.id_val() %} selected{% endif %}{% when None %}{% endmatch %}>{{ a.name_str() }}</option>
+            {% endfor %}
+        </select>
+    </form>
+</div>
+
+{% if rows.is_empty() %}
+<p>{{ t.releases_empty }}</p>
+{% else %}
+<table>
+    <tr>
+        <th>ID</th>
+        <th>{{ t.releases_title }}</th>
+        <th>{{ t.releases_artists }}</th>
+        <th>{{ t.releases_type }}</th>
+        <th>{{ t.releases_year }}</th>
+        <th>{{ t.releases_actions }}</th>
+    </tr>
+    {% for row in rows %}
+    <tr>
+        <td>{{ row.release.id_val() }}</td>
+        <td>{{ row.release.title_str() }}</td>
+        <td>{% if row.artist_names.is_empty() %}<span style="color:#999;">{{ t.releases_no_artist }}</span>{% else %}{{ row.artist_names }}{% endif %}</td>
+        <td><code>{{ row.release.release_type_str() }}</code></td>
+        <td>{{ row.release.year_display() }}</td>
+        <td>
+            <a href="/admin/releases/{{ row.release.id_val() }}/edit">{{ t.releases_edit }}</a>
+            &nbsp;|&nbsp;
+            <form method="post" action="/admin/releases/{{ row.release.id_val() }}/delete" style="display:inline;" onsubmit="return confirm('{{ t.releases_delete_confirm }}')">
+                <button type="submit" style="background:none; border:none; color:#c00; cursor:pointer; padding:0; text-decoration:underline;">{{ t.releases_delete }}</button>
+            </form>
+        </td>
+    </tr>
+    {% endfor %}
+</table>
+{% endif %}
+{% endblock content %}
diff --git a/templates/admin/review_detail.html b/templates/admin/review_detail.html
new file mode 100644
index 0000000..743c4ad
--- /dev/null
+++ b/templates/admin/review_detail.html
@@ -0,0 +1,63 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}Review #{{ review.id_val() }}{% endblock admin_title %}
+
+{% block content %}
+<h1>Review #{{ review.id_val() }}</h1>
+
+<table>
+    <tr><th>{{ t.reviews_status }}</th><td><span class="badge {{ review.status_badge_class() }}">{{ review.status_str() }}</span></td></tr>
+    <tr><th>{{ t.reviews_type }}</th><td>{{ review.review_type_str() }}</td></tr>
+    <tr><th>{{ t.reviews_input_path }}</th><td style="word-break:break-all;">{{ review.input_path_str() }}</td></tr>
+    <tr><th>{{ t.reviews_confidence }}</th><td>{% match review.confidence() %}{% when Some with (c) %}{{ c }}{% when None %}-{% endmatch %}</td></tr>
+    <tr><th>{{ t.reviews_created }}</th><td>{{ review.created_at_str() }}</td></tr>
+    {% match stats %}
+    {% when Some with (s) %}
+    <tr><th>{{ t.reviews_model }}</th><td>{{ s.model_name_str() }}</td></tr>
+    <tr><th>{{ t.reviews_llm_duration }}</th><td>{{ s.duration_display() }}</td></tr>
+    <tr><th>{{ t.reviews_tokens }}</th><td>{{ s.tokens_display() }}</td></tr>
+    {% when None %}
+    {% endmatch %}
+</table>
+
+{% if !error_message.is_empty() %}
+<div style="margin: 1rem 0; padding: 1rem; background: #f8d7da; color: #721c24; border-radius: 6px;">
+    <strong>{{ t.reviews_error }}:</strong> {{ error_message }}
+</div>
+{% endif %}
+
+<div style="margin: 1rem 0; display: flex; gap: .5rem;">
+    {% if review.status_str() == "pending" %}
+    <form method="post" action="/admin/reviews/{{ review.id_val() }}/approve" style="display:inline;">
+        <button type="submit" style="padding:.4rem 1rem; background:#28a745; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_approve }}</button>
+    </form>
+    <form method="post" action="/admin/reviews/{{ review.id_val() }}/reject" style="display:inline;">
+        <button type="submit" style="padding:.4rem 1rem; background:#dc3545; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_reject }}</button>
+    </form>
+    {% endif %}
+    {% if review.status_str() == "failed" || review.status_str() == "processing" %}
+    <form method="post" action="/admin/reviews/{{ review.id_val() }}/requeue" style="display:inline;" onsubmit="return confirm('{{ t.reviews_requeue_confirm }}');">
+        <button type="submit" style="padding:.4rem 1rem; background:#17a2b8; color:#fff; border:none; border-radius:4px; cursor:pointer;">{{ t.reviews_requeue }}</button>
+    </form>
+    {% endif %}
+</div>
+
+{% if !context_pretty.is_empty() %}
+<h2>{{ t.reviews_context }}</h2>
+<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ context_pretty }}</pre>
+{% endif %}
+
+{% if !result_pretty.is_empty() %}
+<h2>{{ t.reviews_result }}</h2>
+<pre style="background:#f4f4f4; padding:1rem; border-radius:6px; overflow-x:auto; font-size:.85rem;">{{ result_pretty }}</pre>
+{% endif %}
+
+<p style="margin-top:1rem;"><a href="/admin/reviews">&larr; {{ t.reviews_back_to_list }}</a></p>
+
+<style>
+    .badge-completed { background: #d4edda; color: #155724; }
+    .badge-failed { background: #f8d7da; color: #721c24; }
+    .badge-pending { background: #fff3cd; color: #856404; }
+    .badge-queued { background: #d1ecf1; color: #0c5460; }
+    .badge-processing { background: #cce5ff; color: #004085; }
+</style>
+{% endblock content %}
diff --git a/templates/admin/reviews.html b/templates/admin/reviews.html
new file mode 100644
index 0000000..5a041fb
--- /dev/null
+++ b/templates/admin/reviews.html
@@ -0,0 +1,73 @@
+{% extends "admin/layout.html" %}
+{% block admin_title %}{{ t.nav_reviews }}{% endblock admin_title %}
+
+{% block content %}
+<h1>{{ t.reviews_heading }}</h1>
+
+<div style="margin-bottom: 1rem; display: flex; gap: .5rem; align-items: center;">
+    <a href="/admin/reviews" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "" %} #333; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_all }}</a>
+    <a href="/admin/reviews?status=pending" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "pending" %} #ffc107; color: #000{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_pending }}</a>
+    <a href="/admin/reviews?status=approved" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "approved" %} #28a745; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_approved }}</a>
+    <a href="/admin/reviews?status=rejected" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "rejected" %} #dc3545; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_rejected }}</a>
+    <a href="/admin/reviews?status=queued" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "queued" %} #17a2b8; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_queued }}</a>
+    <a href="/admin/reviews?status=processing" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "processing" %} #007bff; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_processing }}</a>
+    <a href="/admin/reviews?status=auto_approved" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "auto_approved" %} #28a745; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_auto_approved }}</a>
+    <a href="/admin/reviews?status=failed" style="padding: .3rem .8rem; border-radius: 4px; text-decoration: none; background:{% if status_filter == "failed" %} #dc3545; color: #fff{% else %} #e9ecef; color: #333{% endif %};">{{ t.reviews_filter_failed }}</a>
+    {% if !reviews.is_empty() %}
+    <span style="flex:1;"></span>
+    <form method="post" action="/admin/reviews/clear{% if !status_filter.is_empty() %}?status={{ status_filter }}{% endif %}" style="margin:0;" onsubmit="return confirm('{{ t.reviews_clear_confirm }}');">
+        <button type="submit" style="padding:.3rem .8rem; border-radius:4px; border:1px solid #dc3545; background:#fff; color:#dc3545; cursor:pointer;">{% if status_filter.is_empty() %}{{ t.reviews_clear_all }}{% else %}{{ t.reviews_clear_filtered }}{% endif %}</button>
+    </form>
+    {% endif %}
+</div>
+
+{% if reviews.is_empty() %}
+<p>{{ t.reviews_empty }}</p>
+{% else %}
+<table>
+    <tr>
+        <th>ID</th>
+        <th>{{ t.reviews_status }}</th>
+        <th>{{ t.reviews_type }}</th>
+        <th>{{ t.reviews_input_path }}</th>
+        <th>{{ t.reviews_confidence }}</th>
+        <th>{{ t.reviews_model }}</th>
+        <th>{{ t.reviews_llm_duration }}</th>
+        <th>{{ t.reviews_tokens }}</th>
+        <th>{{ t.reviews_created }}</th>
+        <th>{{ t.jobs_actions }}</th>
+    </tr>
+    {% for review in reviews %}
+    <tr>
+        <td><a href="/admin/reviews/{{ review.id_val() }}">{{ review.id_val() }}</a></td>
+        <td><span class="badge {{ review.status_badge_class() }}">{{ review.status_str() }}</span></td>
+        <td>{{ review.review_type_str() }}</td>
+        <td style="max-width:300px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;" title="{{ review.input_path_str() }}">{{ review.input_path_str() }}</td>
+        <td>{% match review.confidence() %}{% when Some with (c) %}{{ c }}{% when None %}-{% endmatch %}</td>
+        {% match stats_map.get(&review.id_val()) %}
+        {% when Some with (s) %}
+        <td>{{ s.model_name }}</td>
+        <td>{{ s.duration_display() }}</td>
+        <td>{{ s.tokens_display() }}</td>
+        {% when None %}
+        <td>-</td>
+        <td>-</td>
+        <td>-</td>
+        {% endmatch %}
+        <td>{{ review.created_at_str() }}</td>
+        <td>
+            <a href="/admin/reviews/{{ review.id_val() }}">{{ t.reviews_view }}</a>
+        </td>
+    </tr>
+    {% endfor %}
+</table>
+{% endif %}
+
+<style>
+    .badge-completed { background: #d4edda; color: #155724; }
+    .badge-failed { background: #f8d7da; color: #721c24; }
+    .badge-pending { background: #fff3cd; color: #856404; }
+    .badge-queued { background: #d1ecf1; color: #0c5460; }
+    .badge-processing { background: #cce5ff; color: #004085; }
+</style>
+{% endblock content %}
diff --git a/templates/admin/settings.html b/templates/admin/settings.html
index 579e612..b718e80 100644
--- a/templates/admin/settings.html
+++ b/templates/admin/settings.html
@@ -82,6 +82,70 @@
   </tr>
 </table>
 
+<h2>{{ t.settings_agent }}</h2>
+<p style="font-size:.85rem;color:#666;margin-bottom:.5rem;">{{ t.settings_agent_help }}</p>
+<table>
+  <tr>
+    <th>{{ t.debug_field }}</th>
+    <th>{{ t.debug_value }}</th>
+    <th>{{ t.debug_source }}</th>
+  </tr>
+  <tr>
+    <td><label for="agent_enabled">{{ t.settings_agent_enabled }}</label></td>
+    <td><input type="checkbox" name="agent_enabled" id="agent_enabled" value="on"{% if agent_enabled %} checked{% endif %}></td>
+    <td><span class="badge badge-{{ agent_enabled_source }}">{{ agent_enabled_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_inbox_dir">{{ t.settings_agent_inbox }}</label></td>
+    <td><input name="agent_inbox_dir" id="agent_inbox_dir" value="{{ agent_inbox_dir }}" style="width:100%"></td>
+    <td><span class="badge badge-{{ agent_inbox_dir_source }}">{{ agent_inbox_dir_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_storage_dir">{{ t.settings_agent_storage }}</label></td>
+    <td><input name="agent_storage_dir" id="agent_storage_dir" value="{{ agent_storage_dir }}" style="width:100%"></td>
+    <td><span class="badge badge-{{ agent_storage_dir_source }}">{{ agent_storage_dir_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_llm_url">{{ t.settings_agent_llm_url }}</label></td>
+    <td><input name="agent_llm_url" id="agent_llm_url" value="{{ agent_llm_url }}" style="width:100%"></td>
+    <td><span class="badge badge-{{ agent_llm_url_source }}">{{ agent_llm_url_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_llm_model">{{ t.settings_agent_llm_model }}</label></td>
+    <td><input name="agent_llm_model" id="agent_llm_model" value="{{ agent_llm_model }}" style="width:100%"></td>
+    <td><span class="badge badge-{{ agent_llm_model_source }}">{{ agent_llm_model_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_llm_auth">{{ t.settings_agent_llm_auth }}</label></td>
+    <td><input name="agent_llm_auth" id="agent_llm_auth" type="password" value="{{ agent_llm_auth }}" style="width:100%"></td>
+    <td><span class="badge badge-{{ agent_llm_auth_source }}">{{ agent_llm_auth_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_confidence_threshold">{{ t.settings_agent_threshold }}</label></td>
+    <td><input name="agent_confidence_threshold" id="agent_confidence_threshold" value="{{ agent_confidence_threshold }}" style="width:6em"></td>
+    <td><span class="badge badge-{{ agent_confidence_threshold_source }}">{{ agent_confidence_threshold_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_context_limit">{{ t.settings_agent_context }}</label></td>
+    <td><input name="agent_context_limit" id="agent_context_limit" value="{{ agent_context_limit }}" style="width:6em"></td>
+    <td><span class="badge badge-{{ agent_context_limit_source }}">{{ agent_context_limit_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="agent_concurrency">{{ t.settings_agent_concurrency }}</label></td>
+    <td><input name="agent_concurrency" id="agent_concurrency" value="{{ agent_concurrency }}" type="number" min="1" max="32" style="width:6em"></td>
+    <td><span class="badge badge-{{ agent_concurrency_source }}">{{ agent_concurrency_source }}</span></td>
+  </tr>
+</table>
+
+<h2>{{ t.settings_agent_status }}</h2>
+<div hx-get="/admin/settings/probe" hx-trigger="load" hx-swap="innerHTML">
+  <p style="color:#999;">
+    <span class="htmx-indicator" style="display:inline;">
+      &#9696; {{ t.settings_agent_status_loading }}...
+    </span>
+  </p>
+</div>
+
   <button type="submit" style="margin-top: 1rem; padding: .5rem 1.5rem;">{{ t.settings_save }}</button>
 </form>
 {% endblock content %}
diff --git a/templates/player.html b/templates/player.html
new file mode 100644
index 0000000..26a977f
--- /dev/null
+++ b/templates/player.html
@@ -0,0 +1,2441 @@
+{% extends "base.html" %}
+
+{% block title %}{{ t.site_name }}{% endblock title %}
+
+{% block head_extra %}
+<style>
+:root {
+    --bg-primary: #121212;
+    --bg-secondary: #181818;
+    --bg-elevated: #232323;
+    --bg-hover: #2a2a2a;
+    --bg-active: #333;
+    --text-primary: #fff;
+    --text-secondary: #b3b3b3;
+    --text-subdued: #6a6a6a;
+    --accent: #1db954;
+    --accent-hover: #1ed760;
+    --player-height: 80px;
+    --sidebar-width: 240px;
+    --queue-width: 300px;
+    --border-color: #282828;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+html, body { height: 100%; overflow: hidden; }
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+}
+
+/* Layout */
+.app-layout {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+}
+
+.main-content {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Left Sidebar */
+.sidebar-left {
+    width: var(--sidebar-width);
+    min-width: var(--sidebar-width);
+    background: var(--bg-secondary);
+    border-right: 1px solid var(--border-color);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.sidebar-header {
+    padding: 16px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sidebar-header h2 {
+    font-size: 14px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    color: var(--text-secondary);
+}
+
+.sidebar-nav {
+    padding: 8px;
+}
+
+.sidebar-nav-item {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 8px 12px;
+    border-radius: 6px;
+    cursor: pointer;
+    color: var(--text-secondary);
+    font-size: 14px;
+    font-weight: 500;
+    transition: background 0.15s, color 0.15s;
+}
+
+.sidebar-nav-item:hover { background: var(--bg-hover); color: var(--text-primary); }
+.sidebar-nav-item.active { background: var(--bg-active); color: var(--text-primary); }
+
+.sidebar-nav-item svg { width: 20px; height: 20px; flex-shrink: 0; }
+
+.playlist-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 8px;
+    border-top: 1px solid var(--border-color);
+}
+
+.playlist-item {
+    padding: 8px 12px;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 13px;
+    color: var(--text-secondary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    transition: background 0.15s, color 0.15s;
+}
+
+.playlist-item:hover { background: var(--bg-hover); color: var(--text-primary); }
+
+.playlist-count {
+    font-size: 11px;
+    color: var(--text-subdued);
+}
+
+.sidebar-bottom {
+    padding: 12px 16px;
+    border-top: 1px solid var(--border-color);
+}
+
+.sidebar-bottom a {
+    color: var(--text-subdued);
+    text-decoration: none;
+    font-size: 12px;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.sidebar-bottom a:hover { color: var(--text-secondary); }
+
+/* Center Content */
+.center-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: 24px;
+    background: var(--bg-primary);
+}
+
+.center-content::-webkit-scrollbar { width: 8px; }
+.center-content::-webkit-scrollbar-track { background: transparent; }
+.center-content::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 4px; }
+
+.section-title {
+    font-size: 24px;
+    font-weight: 700;
+    margin-bottom: 20px;
+}
+
+.breadcrumb {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 16px;
+    font-size: 13px;
+    color: var(--text-subdued);
+}
+
+.breadcrumb a {
+    color: var(--text-secondary);
+    text-decoration: none;
+    cursor: pointer;
+}
+
+.breadcrumb a:hover { color: var(--text-primary); text-decoration: underline; }
+
+/* Artist / Release Grid */
+.card-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(170px, 1fr));
+    gap: 20px;
+}
+
+.card {
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    padding: 14px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.card:hover { background: var(--bg-elevated); }
+
+.card-img {
+    width: 100%;
+    aspect-ratio: 1;
+    border-radius: 6px;
+    background: var(--bg-elevated);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+    margin-bottom: 12px;
+    position: relative;
+}
+
+.card-img img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.card-img .placeholder-icon {
+    color: var(--text-subdued);
+}
+
+.card-img .placeholder-icon svg { width: 48px; height: 48px; }
+
+.card-play-btn {
+    position: absolute;
+    bottom: 8px;
+    right: 8px;
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    background: var(--accent);
+    border: none;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    opacity: 0;
+    transform: translateY(8px);
+    transition: opacity 0.2s, transform 0.2s;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+}
+
+.card:hover .card-play-btn { opacity: 1; transform: translateY(0); }
+.card-play-btn:hover { background: var(--accent-hover); transform: scale(1.05); }
+.card-play-btn svg { width: 18px; height: 18px; fill: #000; }
+
+.card-title {
+    font-size: 14px;
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    margin-bottom: 4px;
+}
+
+.card-subtitle {
+    font-size: 12px;
+    color: var(--text-subdued);
+}
+
+/* Artist detail header */
+.artist-header {
+    display: flex;
+    align-items: flex-end;
+    gap: 24px;
+    margin-bottom: 32px;
+}
+
+.artist-header .artist-img {
+    width: 200px;
+    height: 200px;
+    border-radius: 50%;
+    background: var(--bg-elevated);
+    overflow: hidden;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.artist-header .artist-img img { width: 100%; height: 100%; object-fit: cover; }
+.artist-header .artist-img svg { width: 80px; height: 80px; color: var(--text-subdued); }
+
+.artist-header .artist-name { font-size: 48px; font-weight: 900; line-height: 1.1; }
+
+/* Release detail header */
+.release-header {
+    display: flex;
+    align-items: flex-end;
+    gap: 24px;
+    margin-bottom: 24px;
+}
+
+.release-header .release-cover {
+    width: 200px;
+    height: 200px;
+    border-radius: 8px;
+    background: var(--bg-elevated);
+    overflow: hidden;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 8px 24px rgba(0,0,0,0.4);
+}
+
+.release-header .release-cover img { width: 100%; height: 100%; object-fit: cover; }
+.release-header .release-cover svg { width: 80px; height: 80px; color: var(--text-subdued); }
+
+.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-meta .release-artists { font-size: 14px; color: var(--text-secondary); }
+.release-meta .release-year { font-size: 14px; color: var(--text-subdued); margin-top: 4px; }
+
+/* Track list table */
+.track-list { width: 100%; border-collapse: collapse; }
+
+.track-list-header {
+    display: grid;
+    grid-template-columns: 40px 1fr 1fr 120px 60px;
+    padding: 8px 16px;
+    border-bottom: 1px solid var(--border-color);
+    color: var(--text-subdued);
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 4px;
+}
+
+.track-row {
+    display: grid;
+    grid-template-columns: 40px 1fr 1fr 120px 60px;
+    padding: 8px 16px;
+    border-radius: 4px;
+    cursor: default;
+    align-items: center;
+    transition: background 0.15s;
+}
+
+.track-row:hover { background: var(--bg-hover); }
+.track-row.playing { color: var(--accent); }
+.track-row.playing .track-num { color: var(--accent); }
+
+.track-num {
+    font-size: 14px;
+    color: var(--text-subdued);
+    text-align: center;
+}
+
+.track-info .track-title { font-size: 14px; font-weight: 500; }
+.track-info .track-artists-inline {
+    font-size: 12px;
+    color: var(--text-subdued);
+    margin-top: 2px;
+}
+
+.track-album { font-size: 13px; color: var(--text-subdued); }
+.track-duration { font-size: 13px; color: var(--text-subdued); text-align: right; }
+
+/* Track action buttons */
+.track-actions {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.track-row:hover .track-actions { opacity: 1; }
+
+.track-action-btn {
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    cursor: pointer;
+    padding: 4px;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.15s, background 0.15s;
+}
+
+.track-action-btn:hover { color: var(--text-primary); background: var(--bg-active); }
+.track-action-btn.play-btn:hover { color: var(--accent); }
+.track-action-btn svg { width: 16px; height: 16px; }
+
+/* Card enqueue button (next to play button on release cards) */
+.card-enqueue-btn {
+    position: absolute;
+    bottom: 8px;
+    right: 56px;
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-color);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    opacity: 0;
+    transform: translateY(8px);
+    transition: opacity 0.2s, transform 0.2s;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+}
+
+.card:hover .card-enqueue-btn { opacity: 1; transform: translateY(0); }
+.card-enqueue-btn:hover { background: var(--bg-hover); border-color: var(--text-subdued); }
+.card-enqueue-btn svg { width: 14px; height: 14px; color: var(--text-primary); }
+
+/* Release header action buttons */
+.release-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 12px;
+}
+
+.release-action-btn {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 16px;
+    border-radius: 20px;
+    border: none;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 600;
+    transition: transform 0.1s, filter 0.15s;
+}
+
+.release-action-btn:hover { filter: brightness(1.1); }
+.release-action-btn:active { transform: scale(0.97); }
+.release-action-btn svg { width: 16px; height: 16px; }
+
+.release-action-btn.primary {
+    background: var(--accent);
+    color: #000;
+}
+
+.release-action-btn.secondary {
+    background: var(--bg-active);
+    color: var(--text-primary);
+}
+
+/* Queue Panel */
+.queue-panel {
+    width: var(--queue-width);
+    min-width: var(--queue-width);
+    background: var(--bg-secondary);
+    border-left: 1px solid var(--border-color);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.queue-panel.hidden { display: none; }
+
+.queue-header {
+    padding: 16px;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.queue-header h3 { font-size: 14px; font-weight: 600; }
+
+.queue-clear-btn {
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    font-size: 12px;
+    cursor: pointer;
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+
+.queue-clear-btn:hover { color: var(--text-primary); background: var(--bg-hover); }
+
+.queue-tracks {
+    flex: 1;
+    overflow-y: auto;
+    padding: 8px;
+}
+
+.queue-track {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 8px;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: background 0.15s;
+}
+
+.queue-track:hover { background: var(--bg-hover); }
+.queue-track.active { background: var(--bg-active); }
+
+.queue-track-cover {
+    width: 40px;
+    height: 40px;
+    border-radius: 4px;
+    background: var(--bg-elevated);
+    overflow: hidden;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.queue-track-cover img { width: 100%; height: 100%; object-fit: cover; }
+.queue-track-cover svg { width: 20px; height: 20px; color: var(--text-subdued); }
+
+.queue-track-info { overflow: hidden; flex: 1; }
+.queue-track-title {
+    font-size: 13px;
+    font-weight: 500;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.queue-track.active .queue-track-title { color: var(--accent); }
+
+.queue-track-artist {
+    font-size: 11px;
+    color: var(--text-subdued);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.queue-track-actions {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    opacity: 0;
+    transition: opacity 0.15s;
+    flex-shrink: 0;
+}
+
+.queue-track:hover .queue-track-actions { opacity: 1; }
+
+.queue-track-remove {
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    cursor: pointer;
+    padding: 4px;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.15s, background 0.15s;
+}
+
+.queue-track-remove:hover { color: var(--text-primary); background: var(--bg-hover); }
+
+/* Drag handle */
+.queue-drag-handle {
+    cursor: grab;
+    color: var(--text-subdued);
+    padding: 4px 2px;
+    display: flex;
+    align-items: center;
+    flex-shrink: 0;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.queue-track:hover .queue-drag-handle { opacity: 1; }
+.queue-drag-handle:active { cursor: grabbing; }
+.queue-drag-handle svg { width: 14px; height: 14px; }
+
+/* Drag states */
+.queue-track.dragging { opacity: 0.4; }
+.queue-track.drag-over { border-top: 2px solid var(--accent); margin-top: -2px; }
+
+/* Player Bar */
+.player-bar {
+    height: var(--player-height);
+    background: var(--bg-secondary);
+    border-top: 1px solid var(--border-color);
+    display: grid;
+    grid-template-columns: 1fr 2fr 1fr;
+    align-items: center;
+    padding: 0 16px;
+    z-index: 10;
+}
+
+.player-now-playing {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    overflow: hidden;
+}
+
+.player-cover {
+    width: 56px;
+    height: 56px;
+    border-radius: 4px;
+    background: var(--bg-elevated);
+    overflow: hidden;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.player-cover img { width: 100%; height: 100%; object-fit: cover; }
+.player-cover svg { width: 24px; height: 24px; color: var(--text-subdued); }
+
+.player-track-info { overflow: hidden; }
+.player-track-title {
+    font-size: 13px;
+    font-weight: 500;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.player-track-artist {
+    font-size: 11px;
+    color: var(--text-subdued);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.player-controls {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 4px;
+}
+
+.player-buttons {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+}
+
+.player-btn {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: 4px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.15s, transform 0.1s;
+}
+
+.player-btn:hover { color: var(--text-primary); }
+.player-btn:active { transform: scale(0.95); }
+.player-btn svg { width: 18px; height: 18px; }
+
+.player-btn.active { color: var(--accent); }
+
+.player-btn-play {
+    width: 32px;
+    height: 32px;
+    background: var(--text-primary);
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.player-btn-play svg { width: 16px; height: 16px; fill: #000; color: #000; }
+.player-btn-play:hover { transform: scale(1.06); background: #fff; }
+
+.player-timeline {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    width: 100%;
+    max-width: 600px;
+}
+
+.player-time { font-size: 11px; color: var(--text-subdued); min-width: 40px; text-align: center; }
+
+.progress-bar {
+    flex: 1;
+    height: 4px;
+    background: var(--bg-active);
+    border-radius: 2px;
+    cursor: pointer;
+    position: relative;
+}
+
+.progress-bar:hover { height: 6px; }
+
+.progress-bar-fill {
+    height: 100%;
+    background: var(--text-primary);
+    border-radius: 2px;
+    position: relative;
+    transition: width 0.1s linear;
+}
+
+.progress-bar:hover .progress-bar-fill { background: var(--accent); }
+
+.progress-bar-thumb {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    background: var(--text-primary);
+    position: absolute;
+    right: -6px;
+    top: 50%;
+    transform: translateY(-50%);
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.progress-bar:hover .progress-bar-thumb { opacity: 1; }
+
+.player-right {
+    display: flex;
+    align-items: center;
+    justify-content: flex-end;
+    gap: 8px;
+}
+
+.volume-control {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.volume-btn {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: 4px;
+    display: flex;
+    align-items: center;
+}
+
+.volume-btn:hover { color: var(--text-primary); }
+.volume-btn svg { width: 18px; height: 18px; }
+
+.volume-slider {
+    width: 80px;
+    height: 4px;
+    background: var(--bg-active);
+    border-radius: 2px;
+    cursor: pointer;
+    position: relative;
+}
+
+.volume-slider-fill {
+    height: 100%;
+    background: var(--text-primary);
+    border-radius: 2px;
+}
+
+.volume-slider:hover .volume-slider-fill { background: var(--accent); }
+
+.queue-toggle-btn {
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    cursor: pointer;
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+
+.queue-toggle-btn:hover { color: var(--text-primary); }
+.queue-toggle-btn.active { color: var(--accent); }
+.queue-toggle-btn svg { width: 18px; height: 18px; }
+
+/* Loading */
+.loading-spinner {
+    display: flex;
+    justify-content: center;
+    padding: 40px;
+}
+
+.spinner {
+    width: 32px;
+    height: 32px;
+    border: 3px solid var(--bg-active);
+    border-top-color: var(--accent);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin { to { transform: rotate(360deg); } }
+
+/* Empty state */
+.empty-state {
+    text-align: center;
+    padding: 60px 20px;
+    color: var(--text-subdued);
+}
+
+.empty-state svg { width: 64px; height: 64px; margin-bottom: 16px; }
+.empty-state p { font-size: 14px; }
+
+/* Search bar */
+.search-bar {
+    position: relative;
+    margin-bottom: 20px;
+}
+
+.search-bar input {
+    width: 100%;
+    padding: 10px 40px 10px 40px;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    color: var(--text-primary);
+    font-size: 14px;
+    outline: none;
+    transition: border-color 0.15s, background 0.15s;
+}
+
+.search-bar input::placeholder { color: var(--text-subdued); }
+.search-bar input:focus { border-color: var(--text-secondary); background: var(--bg-hover); }
+
+.search-bar .search-icon {
+    position: absolute;
+    left: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    color: var(--text-subdued);
+    pointer-events: none;
+}
+
+.search-bar .search-icon svg { width: 18px; height: 18px; }
+
+.search-bar .search-clear {
+    position: absolute;
+    right: 8px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    cursor: pointer;
+    padding: 4px;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+}
+
+.search-bar .search-clear:hover { color: var(--text-primary); background: var(--bg-hover); }
+.search-bar .search-clear svg { width: 16px; height: 16px; }
+
+.search-bar .search-shortcut {
+    position: absolute;
+    right: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    color: var(--text-subdued);
+    font-size: 11px;
+    pointer-events: none;
+    background: var(--bg-active);
+    padding: 2px 6px;
+    border-radius: 4px;
+}
+
+/* Search results */
+.search-section { margin-bottom: 24px; }
+.search-section-title {
+    font-size: 18px;
+    font-weight: 700;
+    margin-bottom: 12px;
+}
+
+.search-artists-row {
+    display: flex;
+    gap: 16px;
+    overflow-x: auto;
+    padding-bottom: 8px;
+}
+
+.search-artists-row::-webkit-scrollbar { height: 6px; }
+.search-artists-row::-webkit-scrollbar-track { background: transparent; }
+.search-artists-row::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 3px; }
+
+.search-artist-card {
+    flex-shrink: 0;
+    width: 140px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    padding: 12px;
+    cursor: pointer;
+    transition: background 0.2s;
+    text-align: center;
+}
+
+.search-artist-card:hover { background: var(--bg-elevated); }
+
+.search-artist-img {
+    width: 80px;
+    height: 80px;
+    border-radius: 50%;
+    background: var(--bg-elevated);
+    margin: 0 auto 8px;
+    overflow: hidden;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.search-artist-img img { width: 100%; height: 100%; object-fit: cover; }
+.search-artist-img svg { width: 32px; height: 32px; color: var(--text-subdued); }
+
+.search-artist-name {
+    font-size: 13px;
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.search-releases-row {
+    display: flex;
+    gap: 16px;
+    overflow-x: auto;
+    padding-bottom: 8px;
+}
+
+.search-releases-row::-webkit-scrollbar { height: 6px; }
+.search-releases-row::-webkit-scrollbar-track { background: transparent; }
+.search-releases-row::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 3px; }
+
+.search-release-card {
+    flex-shrink: 0;
+    width: 150px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    padding: 12px;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+
+.search-release-card:hover { background: var(--bg-elevated); }
+
+.search-release-cover {
+    width: 100%;
+    aspect-ratio: 1;
+    border-radius: 6px;
+    background: var(--bg-elevated);
+    margin-bottom: 8px;
+    overflow: hidden;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.search-release-cover img { width: 100%; height: 100%; object-fit: cover; }
+.search-release-cover svg { width: 40px; height: 40px; color: var(--text-subdued); }
+
+/* Like button */
+.like-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 4px;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.15s, transform 0.1s;
+    color: var(--text-subdued);
+}
+
+.like-btn:hover { color: var(--text-primary); }
+.like-btn:active { transform: scale(0.9); }
+.like-btn.liked { color: var(--accent); }
+.like-btn svg { width: 16px; height: 16px; }
+
+.like-btn-lg svg { width: 22px; height: 22px; }
+
+/* Playlist modal overlay */
+.modal-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.6);
+    z-index: 100;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-box {
+    background: var(--bg-elevated);
+    border-radius: 12px;
+    padding: 24px;
+    min-width: 320px;
+    max-width: 400px;
+    max-height: 70vh;
+    display: flex;
+    flex-direction: column;
+    box-shadow: 0 16px 48px rgba(0,0,0,0.5);
+}
+
+.modal-box h3 {
+    font-size: 18px;
+    font-weight: 700;
+    margin-bottom: 16px;
+}
+
+.modal-box input[type="text"] {
+    width: 100%;
+    padding: 10px 12px;
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    color: var(--text-primary);
+    font-size: 14px;
+    outline: none;
+    margin-bottom: 12px;
+}
+
+.modal-box input[type="text"]:focus { border-color: var(--accent); }
+
+.modal-playlist-list {
+    overflow-y: auto;
+    max-height: 40vh;
+    margin-bottom: 12px;
+}
+
+.modal-playlist-item {
+    padding: 10px 12px;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    color: var(--text-secondary);
+    transition: background 0.15s, color 0.15s;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.modal-playlist-item:hover { background: var(--bg-hover); color: var(--text-primary); }
+.modal-playlist-item svg { width: 16px; height: 16px; flex-shrink: 0; }
+
+.modal-btn {
+    padding: 8px 16px;
+    border-radius: 20px;
+    border: none;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 600;
+    transition: filter 0.15s;
+}
+
+.modal-btn:hover { filter: brightness(1.1); }
+.modal-btn-primary { background: var(--accent); color: #000; }
+.modal-btn-ghost { background: transparent; color: var(--text-secondary); }
+
+.modal-footer {
+    display: flex;
+    justify-content: flex-end;
+    gap: 8px;
+}
+
+/* Sidebar playlist actions */
+.playlist-item-row {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}
+
+.playlist-item-row .playlist-item { flex: 1; min-width: 0; }
+
+.playlist-item-actions {
+    display: flex;
+    gap: 2px;
+    opacity: 0;
+    transition: opacity 0.15s;
+    flex-shrink: 0;
+}
+
+.playlist-item-row:hover .playlist-item-actions { opacity: 1; }
+
+.playlist-action-btn {
+    background: none;
+    border: none;
+    color: var(--text-subdued);
+    cursor: pointer;
+    padding: 3px;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+}
+
+.playlist-action-btn:hover { color: var(--text-primary); background: var(--bg-hover); }
+.playlist-action-btn svg { width: 14px; height: 14px; }
+
+.sidebar-create-btn {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    width: 100%;
+    padding: 8px 12px;
+    background: none;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    color: var(--text-subdued);
+    font-size: 13px;
+    transition: background 0.15s, color 0.15s;
+}
+
+.sidebar-create-btn:hover { background: var(--bg-hover); color: var(--text-primary); }
+.sidebar-create-btn svg { width: 16px; height: 16px; }
+
+/* Responsive */
+@media (max-width: 900px) {
+    .sidebar-left { display: none; }
+    .queue-panel { display: none; }
+}
+
+/* Scrollbar for queue and sidebar */
+.queue-tracks::-webkit-scrollbar,
+.playlist-list::-webkit-scrollbar { width: 6px; }
+.queue-tracks::-webkit-scrollbar-track,
+.playlist-list::-webkit-scrollbar-track { background: transparent; }
+.queue-tracks::-webkit-scrollbar-thumb,
+.playlist-list::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 3px; }
+</style>
+{% endblock head_extra %}
+
+{% block body %}
+<div class="app-layout"
+     x-data
+     @keydown.window.space="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.toggle(); }"
+     @keydown.window.arrow-left="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.seekRelative(-5); }"
+     @keydown.window.arrow-right="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.seekRelative(5); }"
+     @keydown.window="if ((e=$event).ctrlKey && e.key==='k') { e.preventDefault(); document.getElementById('search-input')?.focus(); } else if (e.key==='/' && !['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { e.preventDefault(); document.getElementById('search-input')?.focus(); }"
+     >
+
+    <div class="main-content">
+        <!-- Left Sidebar -->
+        <div class="sidebar-left">
+            <div class="sidebar-header">
+                <h2>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
+                </div>
+            </div>
+            <div class="playlist-list">
+                <template x-for="pl in $store.playlists.list" :key="pl.id">
+                    <div class="playlist-item-row">
+                        <div class="playlist-item" @click="$store.library.openPlaylist(pl.id)">
+                            <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>
+                            </template>
+                            <template x-if="pl.kind !== 'likes'">
+                                <span x-text="pl.title"></span>
+                            </template>
+                            <span class="playlist-count" x-text="pl.track_count + ' tracks'"></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">
+                                    <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">
+                                    <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>
+                        </template>
+                    </div>
+                </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
+                </button>
+            </div>
+            <div class="sidebar-bottom">
+                <a href="/admin/">Admin Panel</a>
+            </div>
+        </div>
+
+        <!-- Center Content -->
+        <div class="center-content" id="center-scroll">
+            <!-- Search Bar -->
+            <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..."
+                       x-model="$store.library.searchQuery"
+                       @input.debounce.300ms="$store.library.search($store.library.searchQuery)"
+                       @keydown.escape="$store.library.clearSearch(); $el.blur()">
+                <template x-if="$store.library.searchQuery">
+                    <button class="search-clear" @click="$store.library.clearSearch()">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+                    </button>
+                </template>
+                <template x-if="!$store.library.searchQuery">
+                    <span class="search-shortcut">Ctrl+K</span>
+                </template>
+            </div>
+
+            <!-- Search Results -->
+            <template x-if="$store.library.view === 'search'">
+                <div>
+                    <template x-if="$store.library.searchLoading">
+                        <div class="loading-spinner"><div class="spinner"></div></div>
+                    </template>
+                    <template x-if="!$store.library.searchLoading && $store.library.searchResults">
+                        <div>
+                            <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>
+                                </div>
+                            </template>
+                            <!-- Artists section -->
+                            <template x-if="$store.library.searchResults.artists.length > 0">
+                                <div class="search-section">
+                                    <h2 class="search-section-title">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)">
+                                                <div class="search-artist-img">
+                                                    <template x-if="artist.image_url">
+                                                        <img :src="artist.image_url" :alt="artist.name" loading="lazy">
+                                                    </template>
+                                                    <template x-if="!artist.image_url">
+                                                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
+                                                    </template>
+                                                </div>
+                                                <div class="search-artist-name" x-text="artist.name"></div>
+                                            </div>
+                                        </template>
+                                    </div>
+                                </div>
+                            </template>
+                            <!-- Releases section -->
+                            <template x-if="$store.library.searchResults.releases.length > 0">
+                                <div class="search-section">
+                                    <h2 class="search-section-title">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">
+                                                <div class="search-release-cover" style="position:relative">
+                                                    <template x-if="release.cover_url">
+                                                        <img :src="release.cover_url" :alt="release.title" loading="lazy">
+                                                    </template>
+                                                    <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>
+                                                </div>
+                                                <div class="card-title" x-text="release.title"></div>
+                                                <div class="card-subtitle">
+                                                    <span x-text="release.year || ''"></span>
+                                                    <span x-text="release.release_type"></span>
+                                                </div>
+                                            </div>
+                                        </template>
+                                    </div>
+                                </div>
+                            </template>
+                            <!-- Tracks section -->
+                            <template x-if="$store.library.searchResults.tracks.length > 0">
+                                <div class="search-section">
+                                    <h2 class="search-section-title">Tracks</h2>
+                                    <div class="track-list-header">
+                                        <span>#</span>
+                                        <span>Title</span>
+                                        <span></span>
+                                        <span></span>
+                                        <span style="text-align:right">Duration</span>
+                                    </div>
+                                    <template x-for="(track, idx) in $store.library.searchResults.tracks" :key="track.id">
+                                        <div class="track-row"
+                                             :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
+                                             @dblclick="$store.library.playSearchTrack(idx)">
+                                            <span class="track-num" x-text="idx + 1"></span>
+                                            <div class="track-info">
+                                                <div class="track-title" x-text="track.title"></div>
+                                                <div class="track-artists-inline" x-text="[...track.artists, ...track.featured_artists.map(a => ({...a, name: 'ft. ' + a.name}))].map(a => a.name).join(', ')"></div>
+                                            </div>
+                                            <span></span>
+                                            <div class="track-actions">
+                                                <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="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">
+                                                    <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">
+                                                    <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">
+                                                    <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">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
+                                                </button>
+                                            </div>
+                                            <span class="track-duration" x-text="formatTime(track.duration_seconds)"></span>
+                                        </div>
+                                    </template>
+                                </div>
+                            </template>
+                        </div>
+                    </template>
+                </div>
+            </template>
+
+            <!-- Artists Grid -->
+            <template x-if="$store.library.view === 'artists'">
+                <div>
+                    <h1 class="section-title">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)">
+                                <div class="card-img">
+                                    <template x-if="artist.image_url">
+                                        <img :src="artist.image_url" :alt="artist.name" loading="lazy">
+                                    </template>
+                                    <template x-if="!artist.image_url">
+                                        <span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg></span>
+                                    </template>
+                                </div>
+                                <div class="card-title" x-text="artist.name"></div>
+                                <div class="card-subtitle" x-text="artist.release_count + ' releases'"></div>
+                            </div>
+                        </template>
+                    </div>
+                    <template x-if="$store.library.loading">
+                        <div class="loading-spinner"><div class="spinner"></div></div>
+                    </template>
+                    <div id="artist-sentinel" style="height:1px"></div>
+                </div>
+            </template>
+
+            <!-- Artist Detail -->
+            <template x-if="$store.library.view === 'artist_detail' && $store.library.currentArtist">
+                <div>
+                    <div class="breadcrumb">
+                        <a @click="$store.library.goArtists()">Artists</a>
+                        <span>/</span>
+                        <span x-text="$store.library.currentArtist.name"></span>
+                    </div>
+                    <div class="artist-header">
+                        <div class="artist-img">
+                            <template x-if="$store.library.currentArtist.image_url">
+                                <img :src="$store.library.currentArtist.image_url" :alt="$store.library.currentArtist.name">
+                            </template>
+                            <template x-if="!$store.library.currentArtist.image_url">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg>
+                            </template>
+                        </div>
+                        <div>
+                            <div class="artist-header .artist-name" x-text="$store.library.currentArtist.name" style="font-size:48px;font-weight:900;line-height:1.1"></div>
+                            <div style="color:var(--text-subdued);margin-top:8px" x-text="$store.library.currentArtist.releases.length + ' releases'"></div>
+                        </div>
+                    </div>
+                    <h2 class="section-title" style="font-size:20px">Releases</h2>
+                    <div class="card-grid">
+                        <template x-for="release in $store.library.currentArtist.releases" :key="release.id">
+                            <div class="card" @click="$store.library.openRelease(release.id)">
+                                <div class="card-img">
+                                    <template x-if="release.cover_url">
+                                        <img :src="release.cover_url" :alt="release.title" loading="lazy">
+                                    </template>
+                                    <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-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="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)">
+                                        <svg viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg>
+                                    </button>
+                                </div>
+                                <div class="card-title" x-text="release.title"></div>
+                                <div class="card-subtitle">
+                                    <span x-text="release.year || ''"></span>
+                                    <span x-text="release.release_type"></span>
+                                </div>
+                            </div>
+                        </template>
+                    </div>
+                </div>
+            </template>
+
+            <!-- Release Detail -->
+            <template x-if="$store.library.view === 'release_detail' && $store.library.currentRelease">
+                <div>
+                    <div class="breadcrumb">
+                        <a @click="$store.library.goArtists()">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>
+                        </template>
+                        <span>/</span>
+                        <span x-text="$store.library.currentRelease.title"></span>
+                    </div>
+                    <div class="release-header">
+                        <div class="release-cover">
+                            <template x-if="$store.library.currentRelease.cover_url">
+                                <img :src="$store.library.currentRelease.cover_url" :alt="$store.library.currentRelease.title">
+                            </template>
+                            <template x-if="!$store.library.currentRelease.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>
+                        </div>
+                        <div class="release-meta">
+                            <div class="release-type" x-text="$store.library.currentRelease.release_type"></div>
+                            <div class="release-title" x-text="$store.library.currentRelease.title"></div>
+                            <div class="release-artists" x-text="$store.library.currentRelease.artists.map(a => a.name).join(', ')"></div>
+                            <div class="release-year" x-text="$store.library.currentRelease.year || ''"></div>
+                            <div class="release-actions">
+                                <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
+                                </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">
+                                    <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
+                                </button>
+                                <button class="release-action-btn secondary" @click="$store.queue.addNextInQueue($store.library.currentRelease.tracks)" title="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
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                    <!-- Track list -->
+                    <div class="track-list-header">
+                        <span>#</span>
+                        <span>Title</span>
+                        <span></span>
+                        <span></span>
+                        <span style="text-align:right">Duration</span>
+                    </div>
+                    <template x-for="(track, idx) in $store.library.currentRelease.tracks" :key="track.id">
+                        <div class="track-row"
+                             :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
+                             @dblclick="$store.queue.playRelease($store.library.currentRelease.tracks, idx)">
+                            <span class="track-num" x-text="track.track_number || (idx + 1)"></span>
+                            <div class="track-info">
+                                <div class="track-title" x-text="track.title"></div>
+                                <div class="track-artists-inline" x-text="[...track.artists, ...track.featured_artists.map(a => ({...a, name: 'ft. ' + a.name}))].map(a => a.name).join(', ')"></div>
+                            </div>
+                            <span></span>
+                            <div class="track-actions">
+                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="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">
+                                    <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">
+                                    <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">
+                                    <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">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
+                                </button>
+                            </div>
+                            <span class="track-duration" x-text="formatTime(track.duration_seconds)"></span>
+                        </div>
+                    </template>
+                </div>
+            </template>
+
+            <!-- Playlist Detail -->
+            <template x-if="$store.library.view === 'playlist_detail' && $store.library.currentPlaylist">
+                <div>
+                    <div class="breadcrumb">
+                        <a @click="$store.library.goArtists()">Library</a>
+                        <span>/</span>
+                        <span x-text="$store.library.currentPlaylist.title"></span>
+                    </div>
+                    <h1 class="section-title" x-text="$store.library.currentPlaylist.title"></h1>
+                    <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></span>
+                        <span></span>
+                        <span style="text-align:right">Duration</span>
+                    </div>
+                    <template x-for="(track, idx) in $store.library.currentPlaylist.tracks" :key="track.id">
+                        <div class="track-row"
+                             :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
+                             @dblclick="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)">
+                            <span class="track-num" x-text="idx + 1"></span>
+                            <div class="track-info">
+                                <div class="track-title" x-text="track.title"></div>
+                                <div class="track-artists-inline" x-text="[...track.artists, ...track.featured_artists.map(a => ({...a, name: 'ft. ' + a.name}))].map(a => a.name).join(', ')"></div>
+                            </div>
+                            <span></span>
+                            <div class="track-actions">
+                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="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">
+                                    <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">
+                                    <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">
+                                    <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">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
+                                </button>
+                            </div>
+                            <span class="track-duration" x-text="formatTime(track.duration_seconds)"></span>
+                        </div>
+                    </template>
+                </div>
+            </template>
+        </div>
+
+        <!-- Queue Panel -->
+        <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>
+            </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>
+                    </div>
+                </template>
+                <template x-for="(track, idx) in $store.queue.tracks" :key="idx + '-' + track.id">
+                    <div class="queue-track"
+                         :class="{ active: idx === $store.queue.currentIndex, dragging: $store.queue._dragIdx === idx }"
+                         @click="$store.queue.playFromIndex(idx)"
+                         draggable="true"
+                         @dragstart="$store.queue._dragIdx = idx; $event.dataTransfer.effectAllowed = 'move'"
+                         @dragend="$store.queue._dragIdx = null; document.querySelectorAll('.drag-over').forEach(el => el.classList.remove('drag-over'))"
+                         @dragover.prevent="$event.dataTransfer.dropEffect = 'move'; $event.currentTarget.classList.add('drag-over')"
+                         @dragleave="$event.currentTarget.classList.remove('drag-over')"
+                         @drop.prevent="$event.currentTarget.classList.remove('drag-over'); if ($store.queue._dragIdx !== null) { $store.queue.moveTrack($store.queue._dragIdx, idx); $store.queue._dragIdx = null; }">
+                        <div class="queue-drag-handle" @mousedown.stop>
+                            <svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9" cy="6" r="1.5"/><circle cx="15" cy="6" r="1.5"/><circle cx="9" cy="12" r="1.5"/><circle cx="15" cy="12" r="1.5"/><circle cx="9" cy="18" r="1.5"/><circle cx="15" cy="18" r="1.5"/></svg>
+                        </div>
+                        <div class="queue-track-cover">
+                            <template x-if="track.cover_url">
+                                <img :src="track.cover_url" :alt="track.title" loading="lazy">
+                            </template>
+                            <template x-if="!track.cover_url">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                            </template>
+                        </div>
+                        <div class="queue-track-info">
+                            <div class="queue-track-title" x-text="track.title"></div>
+                            <div class="queue-track-artist" x-text="track.artists.map(a => a.name).join(', ')"></div>
+                        </div>
+                        <div class="queue-track-actions">
+                            <button class="queue-track-remove" @click.stop="$store.queue.remove(idx)" title="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>
+                    </div>
+                </template>
+            </div>
+        </div>
+    </div>
+
+    <!-- Player Bar -->
+    <div class="player-bar">
+        <div class="player-now-playing">
+            <template x-if="$store.player.currentTrack">
+                <div style="display:flex;align-items:center;gap:12px;overflow:hidden">
+                    <div class="player-cover">
+                        <template x-if="$store.player.currentTrack.cover_url">
+                            <img :src="$store.player.currentTrack.cover_url" :alt="$store.player.currentTrack.title">
+                        </template>
+                        <template x-if="!$store.player.currentTrack.cover_url">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                        </template>
+                    </div>
+                    <div class="player-track-info">
+                        <div class="player-track-title" x-text="$store.player.currentTrack.title"></div>
+                        <div class="player-track-artist" x-text="$store.player.currentTrack.artists.map(a => a.name).join(', ')"></div>
+                    </div>
+                </div>
+            </template>
+        </div>
+
+        <div class="player-controls">
+            <div class="player-buttons">
+                <button class="player-btn" :class="{ active: $store.player.shuffle }" @click="$store.player.toggleShuffle()" title="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">
+                    <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()">
+                    <template x-if="!$store.player.isPlaying">
+                        <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
+                    </template>
+                    <template x-if="$store.player.isPlaying">
+                        <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">
+                    <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">
+                    <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>
+                    <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"/><text x="12" y="14" font-size="8" fill="currentColor" text-anchor="middle" font-weight="bold">1</text></svg>
+                    </template>
+                </button>
+            </div>
+            <div class="player-timeline">
+                <span class="player-time" x-text="formatTime($store.player.currentTime)"></span>
+                <div class="progress-bar" @click="$store.player.seekFromClick($event)">
+                    <div class="progress-bar-fill" :style="'width:' + $store.player.progress + '%'">
+                        <div class="progress-bar-thumb"></div>
+                    </div>
+                </div>
+                <span class="player-time" x-text="formatTime($store.player.duration)"></span>
+            </div>
+        </div>
+
+        <div class="player-right">
+            <div class="volume-control">
+                <button class="volume-btn" @click="$store.player.toggleMute()">
+                    <template x-if="$store.player.volume === 0">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><line x1="23" y1="9" x2="17" y2="15"/><line x1="17" y1="9" x2="23" y2="15"/></svg>
+                    </template>
+                    <template x-if="$store.player.volume > 0 && $store.player.volume < 0.5">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><path d="M15.54 8.46a5 5 0 010 7.07"/></svg>
+                    </template>
+                    <template x-if="$store.player.volume >= 0.5">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/><path d="M19.07 4.93a10 10 0 010 14.14M15.54 8.46a5 5 0 010 7.07"/></svg>
+                    </template>
+                </button>
+                <div class="volume-slider" @click="$store.player.setVolumeFromClick($event)">
+                    <div class="volume-slider-fill" :style="'width:' + ($store.player.volume * 100) + '%'"></div>
+                </div>
+            </div>
+            <button class="queue-toggle-btn" :class="{ active: $store.queue.visible }" @click="$store.queue.visible = !$store.queue.visible" title="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>
+    </div>
+
+    <!-- Create / Rename Playlist Modal -->
+    <template x-if="$store.playlists.modal">
+        <div class="modal-overlay" @click.self="$store.playlists.modal = null">
+            <div class="modal-box">
+                <h3 x-text="$store.playlists.modal.mode === 'create' ? 'New Playlist' : 'Rename Playlist'"></h3>
+                <input type="text" x-model="$store.playlists.modal.title" placeholder="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-primary" @click="$store.playlists.submitModal()"
+                            x-text="$store.playlists.modal.mode === 'create' ? 'Create' : 'Save'"></button>
+                </div>
+            </div>
+        </div>
+    </template>
+
+    <!-- Add to Playlist Modal -->
+    <template x-if="$store.playlists.picker">
+        <div class="modal-overlay" @click.self="$store.playlists.picker = null">
+            <div class="modal-box">
+                <h3>Add to Playlist</h3>
+                <div class="modal-playlist-list">
+                    <template x-for="pl in $store.playlists.list.filter(p => p.kind === 'user' && p.is_own)" :key="pl.id">
+                        <div class="modal-playlist-item" @click="$store.playlists.addToPicked(pl.id)">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                            <span x-text="pl.title"></span>
+                        </div>
+                    </template>
+                </div>
+                <div class="modal-footer">
+                    <button class="modal-btn modal-btn-ghost" @click="$store.playlists.picker = null">Cancel</button>
+                    <button class="modal-btn modal-btn-primary" @click="$store.playlists.picker = null; $store.playlists.showCreate()">New Playlist</button>
+                </div>
+            </div>
+        </div>
+    </template>
+</div>
+
+<script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
+<script>
+function formatTime(seconds) {
+    if (!seconds || isNaN(seconds)) return '0:00';
+    const s = Math.floor(seconds);
+    const m = Math.floor(s / 60);
+    const sec = s % 60;
+    return m + ':' + (sec < 10 ? '0' : '') + sec;
+}
+
+document.addEventListener('alpine:init', () => {
+    // -----------------------------------------------------------------------
+    // Audio element
+    // -----------------------------------------------------------------------
+    const audio = new Audio();
+    audio.preload = 'auto';
+
+    // -----------------------------------------------------------------------
+    // Player store
+    // -----------------------------------------------------------------------
+    Alpine.store('player', {
+        currentTrack: null,
+        isPlaying: false,
+        currentTime: 0,
+        duration: 0,
+        volume: 0.7,
+        _prevVolume: 0.7,
+        shuffle: false,
+        repeatMode: 'off', // off, all, one
+        progress: 0,
+        _saveTimer: null,
+        _historyRecorded: false,
+
+        init() {
+            audio.volume = this.volume;
+
+            audio.addEventListener('timeupdate', () => {
+                this.currentTime = audio.currentTime;
+                this.duration = audio.duration || 0;
+                this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0;
+            });
+
+            audio.addEventListener('ended', () => {
+                this._recordHistory(true);
+                this.next();
+            });
+
+            audio.addEventListener('play', () => { this.isPlaying = true; });
+            audio.addEventListener('pause', () => { this.isPlaying = false; });
+
+            audio.addEventListener('loadedmetadata', () => {
+                this.duration = audio.duration || 0;
+            });
+
+            // Periodic state save
+            this._saveTimer = setInterval(() => {
+                this._saveState();
+            }, 10000);
+
+            // Restore state
+            this._restoreState();
+
+            // Save state on page unload
+            window.addEventListener('beforeunload', () => {
+                this._saveStateSync();
+            });
+        },
+
+        play(track) {
+            this.currentTrack = track;
+            this._historyRecorded = false;
+            audio.src = track.stream_url;
+            audio.play().catch(() => {});
+            this._updateMediaSession();
+        },
+
+        pause() { audio.pause(); },
+        resume() { audio.play().catch(() => {}); },
+
+        toggle() {
+            if (!this.currentTrack) return;
+            if (this.isPlaying) { this.pause(); }
+            else { this.resume(); }
+        },
+
+        seek(time) {
+            audio.currentTime = time;
+        },
+
+        seekRelative(delta) {
+            if (!this.currentTrack) return;
+            audio.currentTime = Math.max(0, Math.min(audio.duration || 0, audio.currentTime + delta));
+        },
+
+        seekFromClick(event) {
+            const bar = event.currentTarget;
+            const rect = bar.getBoundingClientRect();
+            const pct = (event.clientX - rect.left) / rect.width;
+            if (this.duration > 0) {
+                this.seek(pct * this.duration);
+            }
+        },
+
+        next() {
+            const queue = Alpine.store('queue');
+            if (queue.tracks.length === 0) return;
+
+            let nextIdx;
+            if (this.repeatMode === 'one') {
+                this.seek(0);
+                this.resume();
+                return;
+            } else if (this.shuffle) {
+                nextIdx = Math.floor(Math.random() * queue.tracks.length);
+            } else {
+                nextIdx = queue.currentIndex + 1;
+                if (nextIdx >= queue.tracks.length) {
+                    if (this.repeatMode === 'all') {
+                        nextIdx = 0;
+                    } else {
+                        this.isPlaying = false;
+                        return;
+                    }
+                }
+            }
+            queue.playFromIndex(nextIdx);
+        },
+
+        prev() {
+            if (this.currentTime > 3) {
+                this.seek(0);
+                return;
+            }
+            const queue = Alpine.store('queue');
+            if (queue.tracks.length === 0) return;
+
+            let prevIdx = queue.currentIndex - 1;
+            if (prevIdx < 0) {
+                if (this.repeatMode === 'all') {
+                    prevIdx = queue.tracks.length - 1;
+                } else {
+                    this.seek(0);
+                    return;
+                }
+            }
+            queue.playFromIndex(prevIdx);
+        },
+
+        setVolume(v) {
+            this.volume = Math.max(0, Math.min(1, v));
+            audio.volume = this.volume;
+        },
+
+        setVolumeFromClick(event) {
+            const bar = event.currentTarget;
+            const rect = bar.getBoundingClientRect();
+            const pct = (event.clientX - rect.left) / rect.width;
+            this.setVolume(pct);
+        },
+
+        toggleMute() {
+            if (this.volume > 0) {
+                this._prevVolume = this.volume;
+                this.setVolume(0);
+            } else {
+                this.setVolume(this._prevVolume || 0.7);
+            }
+        },
+
+        toggleShuffle() {
+            this.shuffle = !this.shuffle;
+        },
+
+        cycleRepeat() {
+            if (this.repeatMode === 'off') this.repeatMode = 'all';
+            else if (this.repeatMode === 'all') this.repeatMode = 'one';
+            else this.repeatMode = 'off';
+        },
+
+        _updateMediaSession() {
+            if (!('mediaSession' in navigator) || !this.currentTrack) return;
+            const t = this.currentTrack;
+            navigator.mediaSession.metadata = new MediaMetadata({
+                title: t.title,
+                artist: t.artists.map(a => a.name).join(', '),
+                artwork: t.cover_url ? [{ src: t.cover_url, sizes: '512x512', type: 'image/jpeg' }] : [],
+            });
+            navigator.mediaSession.setActionHandler('play', () => this.resume());
+            navigator.mediaSession.setActionHandler('pause', () => this.pause());
+            navigator.mediaSession.setActionHandler('previoustrack', () => this.prev());
+            navigator.mediaSession.setActionHandler('nexttrack', () => this.next());
+            navigator.mediaSession.setActionHandler('seekto', (d) => { if (d.seekTime != null) this.seek(d.seekTime); });
+        },
+
+        _buildStatePayload() {
+            const queue = Alpine.store('queue');
+            return {
+                current_track_id: this.currentTrack ? this.currentTrack.id : null,
+                position_ms: Math.floor(this.currentTime * 1000),
+                queue: queue.tracks.map(t => t.id),
+                queue_position: queue.currentIndex,
+                shuffle: this.shuffle,
+                repeat_mode: this.repeatMode,
+                volume: this.volume,
+            };
+        },
+
+        _saveState() {
+            const queue = Alpine.store('queue');
+            if (!this.currentTrack && queue.tracks.length === 0) return;
+            const state = this._buildStatePayload();
+            fetch('/api/player/state', {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(state),
+            }).catch(() => {});
+        },
+
+        _saveStateSync() {
+            const queue = Alpine.store('queue');
+            if (!this.currentTrack && queue.tracks.length === 0) return;
+            const state = this._buildStatePayload();
+            const blob = new Blob([JSON.stringify(state)], { type: 'application/json' });
+            navigator.sendBeacon('/api/player/state', blob);
+        },
+
+        async _restoreState() {
+            try {
+                const res = await fetch('/api/player/state');
+                if (!res.ok) return;
+                const state = await res.json();
+                this.shuffle = state.shuffle || false;
+                this.repeatMode = state.repeat_mode || 'off';
+                this.setVolume(typeof state.volume === 'number' ? state.volume : 0.7);
+
+                // Restore queue if there are track IDs
+                if (state.queue && state.queue.length > 0) {
+                    try {
+                        const tracksRes = await fetch('/api/player/tracks-by-ids', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ ids: state.queue }),
+                        });
+                        if (tracksRes.ok) {
+                            const tracks = await tracksRes.json();
+                            if (tracks.length > 0) {
+                                const queue = Alpine.store('queue');
+                                queue.tracks = tracks;
+                                const idx = Math.max(0, Math.min(state.queue_position, tracks.length - 1));
+                                queue.currentIndex = idx;
+
+                                // Restore current track
+                                const currentTrack = state.current_track_id
+                                    ? tracks.find(t => t.id === state.current_track_id)
+                                    : tracks[idx];
+                                if (currentTrack) {
+                                    this.currentTrack = currentTrack;
+                                    this._historyRecorded = false;
+                                    audio.src = currentTrack.stream_url;
+                                    // Seek to saved position once metadata is loaded
+                                    const seekMs = state.position_ms || 0;
+                                    if (seekMs > 0) {
+                                        const onLoaded = () => {
+                                            audio.currentTime = seekMs / 1000;
+                                            audio.removeEventListener('loadedmetadata', onLoaded);
+                                        };
+                                        audio.addEventListener('loadedmetadata', onLoaded);
+                                    }
+                                    this._updateMediaSession();
+                                }
+                            }
+                        }
+                    } catch {}
+                }
+            } catch {}
+        },
+
+        _recordHistory(completed) {
+            if (this._historyRecorded || !this.currentTrack) return;
+            this._historyRecorded = true;
+            fetch('/api/player/history', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    track_id: this.currentTrack.id,
+                    duration_listened: Math.floor(this.currentTime),
+                    completed: completed,
+                }),
+            }).catch(() => {});
+        },
+    });
+
+    // -----------------------------------------------------------------------
+    // Queue store
+    // -----------------------------------------------------------------------
+    Alpine.store('queue', {
+        tracks: [],
+        currentIndex: 0,
+        visible: true,
+        _dragIdx: null,
+
+        add(track) {
+            this.tracks.push(track);
+        },
+
+        addToEnd(tracks) {
+            this.tracks = [...this.tracks, ...tracks];
+        },
+
+        addNextInQueue(tracks) {
+            const insertAt = this.currentIndex + 1;
+            this.tracks.splice(insertAt, 0, ...tracks);
+        },
+
+        playRelease(tracks, startIndex) {
+            this.tracks = [...tracks];
+            this.playFromIndex(startIndex || 0);
+        },
+
+        playFromIndex(idx) {
+            if (idx < 0 || idx >= this.tracks.length) return;
+            this.currentIndex = idx;
+            Alpine.store('player').play(this.tracks[idx]);
+        },
+
+        remove(idx) {
+            if (idx < 0 || idx >= this.tracks.length) return;
+            this.tracks.splice(idx, 1);
+            if (this.tracks.length === 0) {
+                this.currentIndex = 0;
+            } else if (idx < this.currentIndex) {
+                this.currentIndex--;
+            } else if (idx === this.currentIndex) {
+                if (this.currentIndex >= this.tracks.length) {
+                    this.currentIndex = this.tracks.length - 1;
+                }
+            }
+        },
+
+        moveTrack(fromIdx, toIdx) {
+            if (fromIdx === toIdx) return;
+            if (fromIdx < 0 || fromIdx >= this.tracks.length) return;
+            if (toIdx < 0 || toIdx >= this.tracks.length) return;
+            const [track] = this.tracks.splice(fromIdx, 1);
+            this.tracks.splice(toIdx, 0, track);
+            // Adjust currentIndex to follow the currently playing track
+            if (this.currentIndex === fromIdx) {
+                this.currentIndex = toIdx;
+            } else if (fromIdx < this.currentIndex && toIdx >= this.currentIndex) {
+                this.currentIndex--;
+            } else if (fromIdx > this.currentIndex && toIdx <= this.currentIndex) {
+                this.currentIndex++;
+            }
+        },
+
+        clear() {
+            this.tracks = [];
+            this.currentIndex = 0;
+        },
+    });
+
+    // -----------------------------------------------------------------------
+    // Library store
+    // -----------------------------------------------------------------------
+    Alpine.store('library', {
+        view: 'artists',
+        artists: [],
+        artistsPage: 0,
+        artistsTotal: 0,
+        loading: false,
+        _allLoaded: false,
+        currentArtist: null,
+        currentRelease: null,
+        currentPlaylist: null,
+        _observer: null,
+        searchQuery: '',
+        searchResults: null,
+        searchLoading: false,
+        _previousView: 'artists',
+
+        _hashNav: false, // guard against circular hash updates
+
+        init() {
+            this.loadArtists(1);
+            this._setupScroll();
+
+            // Listen for browser back/forward
+            window.addEventListener('hashchange', () => {
+                this._navigateFromHash();
+            });
+
+            // Navigate to initial hash (if any)
+            this._navigateFromHash();
+        },
+
+        _setHash(hash) {
+            this._hashNav = true;
+            location.hash = hash;
+            // Reset guard after a tick
+            setTimeout(() => { this._hashNav = false; }, 0);
+        },
+
+        _navigateFromHash() {
+            if (this._hashNav) return;
+            const hash = location.hash || '#artists';
+            const match = hash.match(/^#(\w+)(?:\/([-]?\d+))?(?:\?(.*))?$/);
+            if (!match) {
+                this.goArtists();
+                return;
+            }
+            const view = match[1];
+            const id = match[2] ? parseInt(match[2], 10) : null;
+            const params = match[3] || '';
+
+            if (view === 'artists' && !id) {
+                if (this.view !== 'artists') this.goArtists();
+            } else if (view === 'artist' && id) {
+                this.openArtist(id);
+            } else if (view === 'release' && id) {
+                this.openRelease(id);
+            } else if (view === 'playlist' && id) {
+                this.openPlaylist(id);
+            } else if (view === 'search') {
+                const qMatch = params.match(/q=([^&]*)/);
+                if (qMatch) {
+                    const q = decodeURIComponent(qMatch[1]);
+                    this.searchQuery = q;
+                    this.search(q);
+                }
+            } else {
+                this.goArtists();
+            }
+        },
+
+        goArtists() {
+            this.view = 'artists';
+            this.currentArtist = null;
+            this.currentRelease = null;
+            this.currentPlaylist = null;
+            this.searchQuery = '';
+            this.searchResults = null;
+            this._previousView = 'artists';
+            this._setHash('#artists');
+            this.$nextTick(() => { this._setupScroll(); });
+        },
+
+        async loadArtists(page) {
+            if (this.loading || this._allLoaded) return;
+            this.loading = true;
+            try {
+                const res = await fetch(`/api/player/artists?page=${page}&limit=60`);
+                if (!res.ok) throw new Error('failed');
+                const data = await res.json();
+                if (page === 1) {
+                    this.artists = data.items;
+                } else {
+                    this.artists = [...this.artists, ...data.items];
+                }
+                this.artistsPage = data.page;
+                this.artistsTotal = data.total;
+                if (this.artists.length >= data.total) {
+                    this._allLoaded = true;
+                }
+            } catch {}
+            this.loading = false;
+        },
+
+        async openArtist(id) {
+            this.searchQuery = '';
+            this.searchResults = null;
+            this.view = 'artist_detail';
+            this.currentArtist = null;
+            this._setHash('#artist/' + id);
+            try {
+                const res = await fetch(`/api/player/artists/${id}`);
+                if (!res.ok) throw new Error('failed');
+                this.currentArtist = await res.json();
+            } catch {}
+        },
+
+        async openRelease(id) {
+            this.searchQuery = '';
+            this.searchResults = null;
+            this.view = 'release_detail';
+            this.currentRelease = null;
+            this._setHash('#release/' + id);
+            try {
+                const res = await fetch(`/api/player/releases/${id}`);
+                if (!res.ok) throw new Error('failed');
+                this.currentRelease = await res.json();
+            } catch {}
+        },
+
+        async openPlaylist(id) {
+            this.view = 'playlist_detail';
+            this.currentPlaylist = null;
+            this._setHash('#playlist/' + id);
+            try {
+                const res = await fetch(`/api/player/playlists/${id}`);
+                if (!res.ok) throw new Error('failed');
+                this.currentPlaylist = await res.json();
+            } catch {}
+        },
+
+        async playRelease(releaseId) {
+            try {
+                const res = await fetch(`/api/player/releases/${releaseId}`);
+                if (!res.ok) return;
+                const release = await res.json();
+                if (release.tracks.length > 0) {
+                    Alpine.store('queue').playRelease(release.tracks, 0);
+                }
+            } catch {}
+        },
+
+        async enqueueRelease(releaseId) {
+            try {
+                const res = await fetch(`/api/player/releases/${releaseId}`);
+                if (!res.ok) return;
+                const release = await res.json();
+                if (release.tracks.length > 0) {
+                    Alpine.store('queue').addToEnd(release.tracks);
+                }
+            } catch {}
+        },
+
+        async enqueueReleaseNext(releaseId) {
+            try {
+                const res = await fetch(`/api/player/releases/${releaseId}`);
+                if (!res.ok) return;
+                const release = await res.json();
+                if (release.tracks.length > 0) {
+                    Alpine.store('queue').addNextInQueue(release.tracks);
+                }
+            } catch {}
+        },
+
+        async search(query) {
+            const q = (query || '').trim();
+            if (!q) {
+                this.clearSearch();
+                return;
+            }
+            if (this.view !== 'search') {
+                this._previousView = this.view;
+            }
+            this.view = 'search';
+            this._setHash('#search?q=' + encodeURIComponent(q));
+            this.searchLoading = true;
+            try {
+                const res = await fetch(`/api/player/search?q=${encodeURIComponent(q)}&limit=10`);
+                if (!res.ok) throw new Error('failed');
+                this.searchResults = await res.json();
+            } catch {
+                this.searchResults = { artists: [], releases: [], tracks: [] };
+            }
+            this.searchLoading = false;
+        },
+
+        clearSearch() {
+            this.searchQuery = '';
+            this.searchResults = null;
+            this.searchLoading = false;
+            if (this.view === 'search') {
+                this.view = this._previousView || 'artists';
+                this._setHash('#artists');
+                if (this.view === 'artists') {
+                    this.$nextTick(() => { this._setupScroll(); });
+                }
+            }
+        },
+
+        playSearchTrack(idx) {
+            if (!this.searchResults || !this.searchResults.tracks) return;
+            Alpine.store('queue').playRelease(this.searchResults.tracks, idx);
+        },
+
+        _setupScroll() {
+            if (this._observer) this._observer.disconnect();
+            this.$nextTick(() => {
+                const sentinel = document.getElementById('artist-sentinel');
+                if (!sentinel) return;
+                this._observer = new IntersectionObserver((entries) => {
+                    if (entries[0].isIntersecting && !this.loading && !this._allLoaded) {
+                        this.loadArtists(this.artistsPage + 1);
+                    }
+                }, { root: document.getElementById('center-scroll'), threshold: 0.1 });
+                this._observer.observe(sentinel);
+            });
+        },
+
+        $nextTick(fn) {
+            setTimeout(fn, 50);
+        },
+    });
+
+    // -----------------------------------------------------------------------
+    // Likes store
+    // -----------------------------------------------------------------------
+    Alpine.store('likes', {
+        _set: new Set(),
+
+        init() {
+            fetch('/api/player/likes')
+                .then(r => r.json())
+                .then(d => { this._set = new Set(d.track_ids || []); })
+                .catch(() => {});
+        },
+
+        has(trackId) {
+            return this._set.has(trackId);
+        },
+
+        async toggle(trackId) {
+            // Optimistic update
+            if (this._set.has(trackId)) {
+                this._set.delete(trackId);
+            } else {
+                this._set.add(trackId);
+            }
+            // Force Alpine reactivity
+            this._set = new Set(this._set);
+            try {
+                const res = await fetch(`/api/player/likes/toggle/${trackId}`, { method: 'POST' });
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.liked) {
+                        this._set.add(trackId);
+                    } else {
+                        this._set.delete(trackId);
+                    }
+                    this._set = new Set(this._set);
+                    Alpine.store('playlists').reload();
+                }
+            } catch {}
+        },
+
+        async toggleRelease(releaseId) {
+            try {
+                const res = await fetch(`/api/player/likes/release/${releaseId}`, { method: 'POST' });
+                if (res.ok) {
+                    // Reload liked IDs
+                    const likesRes = await fetch('/api/player/likes');
+                    if (likesRes.ok) {
+                        const d = await likesRes.json();
+                        this._set = new Set(d.track_ids || []);
+                    }
+                    Alpine.store('playlists').reload();
+                }
+            } catch {}
+        },
+
+        isReleaseLiked(release) {
+            if (!release || !release.tracks || release.tracks.length === 0) return false;
+            return release.tracks.every(t => this._set.has(t.id));
+        },
+    });
+
+    // -----------------------------------------------------------------------
+    // Playlists store
+    // -----------------------------------------------------------------------
+    Alpine.store('playlists', {
+        list: [],
+        modal: null,   // { mode: 'create'|'rename', title: '', id?: number }
+        picker: null,  // { trackIds: [1,2,3] }
+
+        init() {
+            this.reload();
+        },
+
+        async reload() {
+            try {
+                const res = await fetch('/api/player/playlists');
+                if (res.ok) this.list = await res.json();
+            } catch {}
+        },
+
+        showCreate() {
+            this.modal = { mode: 'create', title: '' };
+        },
+
+        startRename(pl) {
+            this.modal = { mode: 'rename', title: pl.title, id: pl.id };
+        },
+
+        async submitModal() {
+            if (!this.modal) return;
+            const title = this.modal.title.trim();
+            if (!title) return;
+
+            if (this.modal.mode === 'create') {
+                try {
+                    await fetch('/api/player/playlists', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ title }),
+                    });
+                    await this.reload();
+                } catch {}
+            } else if (this.modal.mode === 'rename') {
+                try {
+                    await fetch(`/api/player/playlists/${this.modal.id}`, {
+                        method: 'PUT',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ title }),
+                    });
+                    await this.reload();
+                } catch {}
+            }
+            this.modal = null;
+        },
+
+        async deletePlaylist(id) {
+            if (!confirm('Delete this playlist?')) return;
+            try {
+                await fetch(`/api/player/playlists/${id}`, { method: 'DELETE' });
+                await this.reload();
+            } catch {}
+        },
+
+        showPicker(trackIds) {
+            this.picker = { trackIds };
+        },
+
+        async addToPicked(playlistId) {
+            if (!this.picker) return;
+            try {
+                await fetch(`/api/player/playlists/${playlistId}/tracks`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ track_ids: this.picker.trackIds }),
+                });
+                await this.reload();
+            } catch {}
+            this.picker = null;
+        },
+    });
+});
+</script>
+{% endblock body %}