diff --git a/.workbuddy/memory/2026-09-12.md b/.workbuddy/memory/2026-09-12.md
new file mode 100644
index 0000000..2131974
--- /dev/null
+++ b/.workbuddy/memory/2026-09-12.md
@@ -0,0 +1,253 @@
+# 2026-09-12
+
+## 设置页图标修复 + WebDAV 凭据加密存储 / 配置后隐藏
+
+- **图标不显示根因**：设置页模板用了 `HardDriveDownload` 但从未 import——`vue-tsc` 不报错（未在 script 中引用、模板解析为未知组件静默失败），**运行时图标直接消失**。以后设置页新增图标必须同步加到 lucide import 列表。
+- **WebDAV 凭据加密**：新增 Rust 命令 `webdav_get_secret` / `webdav_save_secret`（`commands.rs`，非 specta，走 raw invoke；已注册 mod.rs 导出 + lib.rs generate_handler）。Windows 用 **keyring v3（windows-native，凭据管理器，DPAPI 保护）**，service="Thing" user="webdav-credentials"，blob 为 `{"username","password"}` JSON；NoEntry 视为未配置。
+- **feiniuStore**：`WEBDAV_KEY` localStorage 现在只存 `{url, dir}`；`patchWebdav` 检测 `username/password` 字段时调 `webdav_save_secret`；`init()` 从凭据管理器加载凭据，并做一次性迁移（localStorage 有旧明文凭据 → 写入凭据管理器 + 立即改写 LS 去掉明文；用 `hasStoredSecret` 标志避免误覆盖）。`davConfig()` 仍从内存取明文传给 webdav_* 命令，链路不变。
+- **设置页 UI**：`webdavEditing` ref 控制——`webdavReady && !webdavEditing` 时显示摘要卡（服务地址/目标目录 + 「账号/密码已保存（系统凭据管理器加密存储）」），带「修改配置」「测试连接」；编辑态完整表单（密码框 type=password 本身掩码）+「收起」。
+- 校验：cargo check（新增 keyring 3.6.3）/ vue-tsc / vite build 全 0。
+
+## 音乐模块全链路检查 + 排序/设置页/任务页调整
+
+- **模块排序**：`music/index.ts` order 55→15（代理=10 之后、整体第二）；`appStore.ts` loadSettings 增加一次性迁移（`musicOrderMigrated` 标记随设置持久化，声明在 store setup 内的非响应式 let），已保存过 moduleOrder 的用户下次启动自动把 music 移到 proxy 后，之后尊重手动拖动。
+- **隐藏 bug 修复（MusicModule.vue）**：
+  1. `downloadToFeiniu` 早退分支（Rust 引擎/无下载源）未清理 `feiniuUploadingKeys` → 行按钮 spinner 永久卡死；
+  2. `resolvePendingUploads` 只处理 done，临时「下载到飞牛」任务 error/cancelled/interrupted 或被手动移除时 spinner 同样卡死 → 增加失败/移除清理分支（注意：临时任务的 tempTaskIds.add 发生在任务进入 tasks 之后，watch 触发时序依赖后续状态变化再触发一次）；
+  3. `feiniu.uploading` 时不再叠加触发 `uploadRecentToFeiniu`。
+- **下载任务 tabs**：去掉标题上的进行中计数（连同 `activeTaskCount` computed，noUnusedLocals 会拦未用变量）；任务卡片容器 `py-4`→`pb-4`，贴近 tabs。
+- **设置页 UI 重做**：section+Separator 改为 Card/CardHeader/CardTitle/CardContent 卡片式（max-w-2xl、gap-4、图标+text-base 标题，与 DownloaderModule 设置页一致）；「播放条常驻在所有模块底部」等过时文案改为「标题栏播放控制」。
+- 全链路审查结论：旧审查的 P0（曲库搜索失效/重启后播放键失效/双音频引擎）均已在现码修复；musicdl 事件幂等、任务持久化签名 watch、歌词二分+邻近缓存等设计良好。
+- 校验：`vue-tsc --noEmit` 0 错误，`vite build` 通过。
+
+## 「下载到飞牛」改为同链路落地即传（用户实测 URL 直传失败）
+
+用户确认：WebDAV 测试连接 OK、下载+自动上传 OK，但发现音乐行的「下载并上传」失败（旧的 URL 拉流直传机制）。按要求改为与「下载完成后自动上传」完全同链路：
+
+- `downloadToFeiniu`：直接 `store.startDownload([song])`（musicdl 引擎，含引擎侧解析/代理/音质），不再手动 resolve + 拼 headers；记 `tempTaskStarts`（taskId→创建时刻，扫描下界）。
+- 任务 done → `finishTempUpload`：`uploadRecentToFeiniu(0, { since, deleteLocal: true })` 上传 → `feiniu_delete_local` 删本地音频及同名 lrc/封面 → `store.removeTask` 移除记录。**失败时保留本地文件与任务记录**供排查重试。
+- `uploadRecentToFeiniu` 扩展 opts `{ since?, deleteLocal? }`；默认行为（自动上传）不变、不删本地。
+- 后端新增 `feiniu_delete_local`（音频/歌词/封面扩展名白名单 + 拒绝目录）；**删除** `webdav_upload_from_url` 命令与 webdav.rs `upload_from_url`（机制废弃）。
+- musicdl 引擎守卫保留：Rust 引擎任务在「下载器」模块，无法回传。
+- 校验：tsc / vite / cargo 全 0。
+
+## 文件服务 → WebDAV（飞牛传输改版，最终形态）
+
+fnOS 文件服务（WS + RSA/AES 登录）经三轮协议修复仍无法在用户 NAS 上稳定登录，且会话易失（重启要重登）。用户确认局域网场景改用标准文件协议，整体替换为 **WebDAV**（fnOS 系统设置 → 文件服务 → WebDAV，HTTP 5005/HTTPS 5006，Basic 认证，文件夹需在可见范围+团队文件夹要勾"允许协议挂载"）。
+
+- **删除**：`fnos.rs`（WS 客户端）、`Feiniu.fnos_sessions`、`feiniu_fnos_*` 与 `feiniu_upload_from_url` 命令、ConnectionsSettings 云朵登录弹窗。
+- **新增**：`src-tauri/src/music/feiniu/webdav.rs`——无状态：`test`（PROPFIND Depth 0）、`upload_file`（128KB 分块流式 PUT，unfold 转 Stream 免 tokio-util）、`upload_from_url`（GET 拉流→直接 PUT，本地不落地，**不再要求 Content-Length**）、`delete`；上传前逐级 MKCOL；URL 逐段百分号编码；401/403/404/409 可读错误。
+- **命令**：`webdav_test` / `webdav_upload` / `webdav_upload_from_url` / `webdav_delete`（config 由前端每次传入，serde+specta 结构 `WebDavConfig`）。
+- **前端**：`feiniuStore.webdav = {url, username, password, dir}` 持久化 `thing.music.feiniu.webdav`（密码明文 localStorage，LAN 工具可接受）；`webdavReady` computed 四项齐备；`patchWebdav` / `testWebdav`；曲库目标目录语义改为 **WebDAV 根下相对路径**。设置页「存储与上传」为配置表单 + 测试按钮 + fnOS 侧设置折叠提示；TrackItem/发现音乐「下载到飞牛」门控全部改 `webdavReady`。
+- 校验：vue-tsc / vite build / cargo check 全 0。
+
+## fnOS 登录协议修复（第三轮："fnOS 登录未返回 token"）
+
+第二轮修复后登录请求**有响应了**（不再超时），但 rid 命中的回包里没有 token。对照 pyfnos 发现关键行为：**登录最终成功包可能不按 reqid 关联**——pyfnos 的 `_is_final_login_success` 是按内容特征（`result=="succ" && token && secret`）识别任意消息，而非按 reqid 匹配。rid 命中的那条很可能只是中间应答，带 token 的包以独立推送到达，被旧 reader 直接丢弃。
+
+修复（`fnos.rs`）：
+- 新增 `login_waiter` 通道；reader 对每条消息先做内容识别，命中最终成功包就投递给登录流程，reqid 匹配照旧（并容忍服务端把 reqid 回显成数字，`resp_rid` 辅助函数）。
+- `login()` 双通道等待：rid 应答里直接有 token → 用之；是中间应答 → 最多再等 8s 登录推送；send_and_wait 超时 → 再宽限 5s 等推送。
+- 识别两步验证挑战（`isBindTwofaSecret` / `isTwofaEnforced` / `accessToken`），明确报"账号开启了两步验证"而不是干等。
+- 诊断兜底：若始终等不到 token，报错里带上服务端实际回包的前 300 字符，用户可直接贴回继续定位。
+- 断开时同时唤醒登录等待者（Null）。
+
+`cargo check` 通过。协议参考：pyfnos `client.py`（响应扁平结构：`result/token/secret/longToken/reqid` 顶层）。
+
+## fnOS 登录协议修复（第二轮："fnOS 请求超时(encrypted)"）
+
+上一轮修完 WS 并发缺陷后，错误变成"请求超时(encrypted)"——说明握手和 `util.crypto.getRSAPub` 都通了，**卡在登录这一条**。根因：**加密登录体里缺字段**。
+
+已对照两个参考实现逐字核对并修复：
+- **FNOSP/fnnas-api** `sdk/encryption.py` 的 `login_encrypt()` 示例（原开发注释里引用的就是它）
+- **Timandes/pyfnos** `fnos/client.py` 的 `_encrypt_login_data()`
+
+### 正确的加密登录体（必须逐字段对齐）
+```json
+{"reqid":"...","user":"...","password":"...","deviceType":"Browser",
+ "deviceName":"...","stay":false,"req":"user.login","si":"..."}
+```
+要点：
+- **`req: "user.login"` 必须在加密体内** —— 服务端靠它路由；缺了就静默不回包（=超时）。
+- **`reqid` 必须在加密体内**，且与 `pending` 等待者登记的 key 一致；外层 `encrypted` **不带** reqid。
+- **没有 `did` 字段**（FNOSP 示例没有；pyfnos 有但非必需，为减少变量已去掉）。
+- `stay: false`。
+- 加密方式：AES-256-CBC(key=32 字节随机 ASCII 串, iv=16 字节随机) + PKCS7，RSA 只加密那个 32 字符 key（PKCS1v1.5），全部 base64。
+
+### 顺带核对过、确认我们原本就正确的部分
+- 签名：`hmac_sha256_b64(sign_key, json) + json`（签名前置）；`sign_key` = 登录响应 `secret` → AES 解密 → base64(明文) → **base64 解码后的字节**。
+- **不签名白名单**：`encrypted` / `util.getSI` / `util.crypto.getRSAPub`（已按参考实现补上 `UNSIGNED_REQ`）。
+- 后续请求不携带 token 字段，服务端靠 WS 连接 + 签名识别会话；HTTP 上传走 `Trim-Token` 头。
+- reqid 格式宽松（各实现 18~28 位不等），我们现有的 `0000000000000000<hex毫秒>` 服务端接受（getRSAPub 已验证）。
+
+### 其他改动
+- `request()` 拆成 `send_and_wait(message, rid, label)` + `request()`，登录走前者以便用加密体内的 reqid 关联。
+- 错误处理补齐 `result=="fail"` 分支并带出 `msg`/`errmsg`（密码错误等现在能看到具体原因）。
+- 新增**应用层心跳**：fnOS 网关会关闭长时间无消息的连接（参考实现默认 10s 一次 `{"req":"ping"}`）。做成"发请求前按需补发"（>20s 才发），避免常驻任务的生命周期问题——多文件批量上传时 WS 不会被闲置断开。
+- 报错里的 label 更可读（如 `user.login(encrypted)`）。
+
+校验：`cargo check` exit 0。**仍未对真实 NAS 验证**，需要用户实测。
+
+---
+
+## 修复 fnOS 文件服务登录（"输入密码没反应，很久后报发送请求失败"）
+
+### 根因（`src-tauri/src/music/feiniu/fnos.rs`）
+1. **WS 读写共用一个 `tokio::sync::Mutex`，且 reader 在持锁状态下 `await stream.next()`** —— `request()` 要拿同一把锁才能发送。第一次 `request()` 里 `ensure_reader()` 先 spawn 了 reader，reader 抢到锁后就在等一条永远不会发出的消息；发送方要么永久阻塞（超时也覆盖不到锁获取），要么在 reader 已退出后发送才报错 —— 这正是"等很久 → 发送请求失败"的来源。
+2. **握手没带 `Origin`**。浏览器发起的 WS 必带 `Origin`，Rust 客户端默认不带；fnOS 会据此判断来源，缺了它会"握手成功但立刻被对端关闭"。这是"连上了却什么都没发生"的典型原因。
+3. **没有回 Pong**。tungstenite 的 Stream/Sink API 不会自动回 Pong，服务端 ping 得不到响应会判定死连接。
+4. 连接/请求均**没有超时覆盖**（`timeout` 只包了 `rx`，不含锁获取与握手），主机不可达时会干等系统 TCP 重试。
+
+### 修复
+- 读写分离：`futures_util::StreamExt::split(ws)` → writer 任务独占写半边（mpsc 队列），reader 独占读半边。发送不再与"等响应"争锁。
+- 握手请求改为构造 `Request` 并注入 `Origin`（由 ws url 反推 `http://host:port`）与浏览器 UA。
+- reader 显式处理 `Ping → Pong`，并记录断开原因到 `closed: Arc<Mutex<Option<String>>>`。
+- `connect_async` 加 12s 超时；`request` 的 15s 超时改为覆盖整个等待，并在入口先检查 `closed`，断开时立刻带原因报错。
+- 所有报错都带上尝试的 ws 地址或断开原因，例如 `连接 fnOS 文件服务失败：ws://ip:port/websocket?type=main → ...`。
+- 前端：`ConnectionsSettings` 的 fnOS 弹窗加 `fnosConnecting`（按钮显示"连接中…"）与弹窗内联错误块（错误里含地址/状态码，留在弹窗里可复制），并显示"当前地址"供核对。
+- `feiniuStore.fnosLogin(connectionId, ...)` 改为显式接收 connectionId 并校验它等于 activeId —— 上传命令按 `settings.feiniu_active_id` 找会话，登录非激活连接会存成永远用不上的会话。
+
+**注意**：以上都只做了 `cargo check` + 前端构建校验，没有对真实飞牛 NAS 验证过协议细节（`Origin` 校验、`file.checkUpload`/`Trim-Path` 约定可能随 fnOS 版本不同）。如果仍失败，报错文案已包含具体地址与失败阶段。
+
+---
+
+## 发现音乐：分组头去白底 + 新增「下载到飞牛」一条龙 + 飞牛上传链路修复
+
+### 分组头
+`MusicModule.vue` 里源分组头原来是 `sticky top-0 z-10 bg-background/95 backdrop-blur`，在浅色背景下会形成一条白色横条。已去掉 sticky 与底色，改为普通的 `border-b border-border/60 px-2` 分组标签（px-2 与行对齐）。
+
+### 新增 Rust 命令 `feiniu_upload_from_url`（下载 + 上传一条龙，本地不留文件）
+链路：前端 `feiniuStore.uploadUrlToFeiniu()` → `invoke('feiniu_upload_from_url')` → `Feiniu::fnos_upload_from_url()` → `fnos::upload_stream()`。
+
+- `fnos.rs` 新增泛型 `upload_stream<S, E>()`：`Part::stream_with_length(Body::wrap_stream(stream), size)`，配套 `upload_client(proxy)`（`proxy` 为空则 `no_proxy()`）。
+- `upload_file()` 重写为**流式**（`stream::unfold` + `tokio::fs::File` 分块 128KB）。原来用 `std::fs::read` 把整个文件读进内存，100MB 无损会直接吃 100MB RAM。用 unfold 是为了不引入 `tokio-util` 依赖。
+- `FnOsSession::connect` 增加 scheme 校验：`https://` 直接返回可读错误（`ws_url` 只把 `http://` 换成 `ws://`，https 会变成非法 WS scheme 并抛出难懂的 tungstenite 错误）。
+- `guess_mime(&Path)` 改为 `mime_of(&str)`（现在需要按 NAS 上的文件名推断）。
+- **依赖音源返回 `Content-Length`**（fnOS `checkUpload` 需要精确 size），缺失时返回可读错误，而不是先把整首缓冲进内存。
+- 前端 `downloadToFeiniu()`：懒解析歌曲先 `resolveSong(source, index, quality)` 拿真实链接（quality 取默认下载音质），合并 `defaultDownloadHeaders` + `defaultDownloadCookies` 为 Cookie 头，并**过滤非 ASCII 头**（reqwest 遇到非法头值会 panic，不能把外部数据直接塞进去）。
+
+### 飞牛上传链路审查结论（重要）
+1. **fnOS 会话只存在内存里**（`Feiniu.fnos_sessions`），应用重启即失效 → 设置页显示的「未连接」是准确的，需要重新点云朵图标登录。已在设置页与登录弹窗里明确写出"仅本次运行有效"。
+2. **仅支持 `http://` 局域网直连**，https/frp 无法上传（协议限制），已给出明确报错。
+3. `feiniu_scan_local` 扫描 `savedir` + `feiniu_local_dirs`，因此下载到本地目录的文件能被"上传最近下载"找到；但该功能是**按 mtime 10 分钟窗口**筛选，与具体下载任务无关联——这是它不可靠的根因（这就是为什么要新增 URL 直传）。
+4. `feiniu_fnos_upload` 用 `settings.feiniu_active_id` 找连接，`fnos_login` 用传入的 connection_id；只要激活连接一致就没问题。
+
+### 校验（本机 bash 不可用，PowerShell + 绝对路径）
+- `cargo check`（`src-tauri`，`%USERPROFILE%\.cargo\bin\cargo.exe`）→ exit 0，仅 3 个既有 warning
+- `vue-tsc --noEmit` → exit 0；`vite build` → exit 0
+
+---
+
+## 曲库左栏：去掉灰底容器、数量列对齐、行高统一
+
+用户反馈截图问题（灰底 + 文字竖向不齐）后的修正，`MyMusicLibrary.vue`：
+- **去掉 `bg-muted` 容器**：来源项不再包在灰色圆角块里。选中态保留 `bg-background font-medium shadow-sm`，并**补 `ring-1 ring-border`**——否则白底上的白色胶囊只有 5% 透明度的阴影，几乎看不见（顶部 Tabs 那个"可见边框"其实是 `:focus-visible` 的 ring，不是常态样式，不能照抄）。
+- **数量列始终渲染**：原来 `v-if="nav.count"` 会在 0 时隐藏整列，造成右侧数字列参差。改为无歌曲时显示 `0`，并加 `min-w-[3ch] text-right tabular-nums` 让个位数/三位数右边缘对齐。
+- **行高统一为固定值**：来源项 `h-8`、歌单子项 `h-7`，配合 `items-center`，不再依赖 `py-1.5` + 行高推算，彻底消除逐行细微的垂直错位。
+- 未选中项 hover 从 `hover:bg-accent/50` 统一为 `hover:bg-accent/60`（无容器后需要更明显的悬停反馈）。
+- 歌单子项的选中态也同步改成同一套胶囊样式，保持层级内一致。
+
+---
+
+## 曲库左栏收窄 + 选中态对齐顶部 Tabs + 切换动画
+
+`MyMusicLibrary.vue`：
+- 左栏宽度 `w-[210px]` → `w-[168px]`（"飞牛曲库 → 数量"之间的大段空白因此明显收窄）。内边距 `p-2.5` → `p-2`，字号 13px → 保留。
+- 三个来源（飞牛曲库/本地曲库/我的歌单）从裸列表改为 **`rounded-lg bg-muted p-1` 容器 + 选中项 `bg-background font-medium shadow-sm rounded-md`**，与顶部 `TabsList`/`TabsTrigger` 的默认选中态一致。
+- 歌单子树加 `border-l` 缩进表示层级；展开/收起加了 `pl-list` Transition（opacity + translateY(-6px)，0.18s）。
+- **标签截断修复**：`<span class="truncate">` 在 flex 行里不会真正截断（flex item 默认 `min-width:auto`）。改成 `min-w-0 flex-1 truncate` + 右侧计数 `shrink-0`，并去掉 `ml-auto`。以后左栏加条目记得照这个写。
+- 右栏内容切换动画：给 `<section>` 加 `:key="view"` + 全局 `tab-animate`，靠重挂载触发动画（与模块级 TabsContent 的做法一致，无需自造 Transition）。
+
+---
+
+## 歌单新增「编辑音乐」编辑器
+
+- 新组件 `src/modules/music/components/PlaylistEditorDialog.vue`（props `open` / `playlistId`，emit `update:open`）。
+  - 双 Tab：**全部音乐**（来源筛选 全部/飞牛/本地 → 勾选加入；已在歌单的项置灰并标「已加入」，不可重复勾选）、**已在歌单**（勾选批量移出，勾选框用 destructive 色）。
+  - 含搜索（歌名/歌手/专辑）、全选当前列表、增量渲染每批 120 + 「显示更多」、飞牛曲库「继续加载」、本地曲库未扫描时的内联「扫描本地」按钮。
+  - 勾选框**不用** `Checkbox` 组件：整行是 `<button>`，视觉勾选框是纯 span（避免 label/按钮与 Checkbox 双重触发导致 net-zero toggle）。若以后要加交互型复选框，注意这个坑。
+  - 关闭/打开时 `resetState()`，切 Tab 与切来源时清空选择（避免"看不见的项仍被选中"导致数量对不上）。
+- 入口：`MyMusicLibrary.vue` 歌单详情工具栏的「编辑音乐」按钮，以及歌单为空时 `Empty` 里的按钮。
+- 依赖 store 既有 API：`addToPlaylist`（内部已按 `guid+source` 去重）、`removeItemsFromPlaylist(id, keys)`（key 形如 `${source}:${guid}`）。
+
+---
+
+## 音乐模块播放器入口改版 + tabs 统一（在同日重构之后）
+
+> 本节修订上面「结构变更」里的播放器结论，以本节为准。
+
+- **删除底部播放条**：`GlobalPlayerBar.vue` 已删除，`App.vue` 不再渲染播放条。不要再新增底部坞站播放条。
+- **新增标题栏音乐栏** `src/components/layout/TitleBarMusic.vue`，插在 `TitleBar.vue` 里**搜索输入框的左侧**（在保存设置按钮与搜索框之间），外层包 `pointer-events-auto`，触发按钮带 `@mousedown.stop`（标题栏是 Tauri 拖拽区，不加会导致点击被拖拽吞掉）。
+  - 未播放过（`store.nowPlaying` 为空）→ 只显示唱片图标，隐藏歌名。
+  - 有曲目 → 图标替换为封面（`rounded-full` + `overflow-hidden`），`store.playing` 为真时用 CSS `animation-play-state` 旋转（8s/圈，暂停保留角度）。
+  - 点击弹出方形控制窗（`Popover`，`w-[300px]`，约 300×340）：封面（点击进大屏）、曲目信息、`ScrubBar` 进度、循环/上下首/播放/队列、音量 `ScrubBar`、歌词/队列入口。
+  - `feiniu.playError` 的 toast 消费点从 GlobalPlayerBar 移到了这里——**删播放条时容易漏掉这个 watcher**，导致播放失败静默。
+- **音乐模块 tabs 回归统一写法**：改回 `<Tabs><div ref="tabsListRef" class="shrink-0"><TabsList class="grid w-full max-w-md grid-cols-4 !bg-transparent !p-0 !shadow-none">…<TabsTrigger class="gap-1.5"><Icon class="size-3.5"/>标签</TabsTrigger>` + `<TabsContent class="mt-4 min-h-0 flex-1 tab-animate">`；模块根节点恢复 `h-full p-6 overflow-hidden flex flex-col`。`SegmentedNav` 不再被 MusicModule 使用，仅 `NowPlayingDialog` 的歌词/队列切换仍在用。
+- 发现音乐 / 任务 / 设置三块内部的横向内边距改为 `0`（由模块根 `p-6` 统一提供，避免左右不对称）。
+
+---
+
+## 音乐模块重构（审查之后落地实施）
+
+### 结构变更（重要，改这块前先读）
+- ~~**播放器已提升到全局层**：`GlobalPlayerBar.vue` + `NowPlayingDialog.vue`~~ → 已被上一节取代；`NowPlayingDialog.vue`（大屏，含歌词/队列）保留，由标题栏方形控制窗打开。
+- **新增通用组件**：`src/components/common/ScrubBar.vue`（提交式 seek 进度条，含缓冲层/时间气泡/键盘支持）、`SegmentedNav.vue`（分段导航，现由 NowPlayingDialog 使用）。
+- **音乐模块导航**：模块级 `Tabs`（曲库/发现音乐/下载任务/设置）；「曲库」内部是 `MyMusicLibrary` 的「左侧来源树 + 右侧列表」两栏，来源树含飞牛曲库/本地曲库/我的歌单（歌单列表在树内展开）。
+- `TrackItem.vue` 重写为 44px 紧凑行（网格列 `28px 36px 1fr 74px 28px`，有专辑时多一列）；序号列悬停原位切换播放按钮，播放中显示 `.music-eq` 跳动均衡器（该 CSS 已加到 `style.css` 全局，NowPlayingDialog 复用）。
+- 所有列表表头/行网格用**字面量** Tailwind 类或内联 `gridTemplateColumns`（Tailwind v4 不识别运行时拼接的类名）。
+
+### feiniuStore 关键 API 变化
+- `PlayableItem.source` 增加 `'preview'`，另加 `coverUrl` / `url` / `ext` 字段。
+- 新增 `nowPlaying`（试听优先于队列当前项）、`playPreview` / `stopPreview`、`playNext` / `addToQueue` / `removeFromQueue` / `clearQueue`、`loadMoreTracks`（分页 200/页）、`searchKeyword`（曲库搜索，之前是孤立局部变量导致搜索无效）、`playError` / `clearPlayError`、`muted` / `toggleMute`、`setPlayMode`、`bufferedPercent`、`nowPlayingTab`。
+- `playItem(item, context?)` 第二参数是播放上下文；不传则退化为单曲播放。
+- `init()` 幂等；`setCacheMode`/`clearCache` 不再中断播放；shuffle 用「待播池 + 历史栈」，自动切歌也随机；`currentLine()` 改为缓存索引 + 二分。
+- 已移除 `queueVisible` / `lyricVisible`（改用 `nowPlayingOpen` + `nowPlayingTab`）。
+- `musicStore.startDownload` 返回值改为 `{ engine, skipped, taskId? }`。
+
+### 校验方式（本机 bash 工具不可用，用 PowerShell + node 直接跑）
+```
+node node_modules/vue-tsc/bin/vue-tsc.js --noEmit -p tsconfig.json
+node node_modules/vite/bin/vite.js build
+```
+两者在本次重构后均为 exit 0。注意：PowerShell 工具不返回 stdout，需 `| Out-File` 后再 Read；`Remove-Item` 被沙箱拦截（静默失败），删文件要用 `node -e "fs.unlinkSync(...)"`。
+
+排障经验：`feiniuStore` 任何「返回对象里引用了不存在的变量」（如漏掉 `clearQueue` 函数体）都会让 TS 对整个 store 的类型推断失败，进而让所有 `store.xxx` 变成 `any`，报出一堆看似无关的 `TS7006 implicitly has an 'any' type`。遇到成片 implicit any，先检查 store 自身的错误。
+
+### 报告
+`MUSIC_MODULE_REVIEW.md` 已追加「§9 重构落地记录」，逐条对应 30 项改动与「仍未做」清单。
+
+---
+
+## 音乐模块全链路审查（数据请求 / 播放控制 / 状态管理 / UI）
+
+产出：
+- `MUSIC_MODULE_REVIEW.md` —— 完整审查报告（P0/P1 bug + 性能瓶颈 + 25 条界面缺陷 + 重设计方案 + 分阶段落地路径）
+- `music-redesign-mockup.html` —— 「当前实现 / 建议方案」可切换的界面改版对照稿（浅色主题）
+
+### 关键结论（后续如要动这块，先看这些）
+
+**架构共识（不要改错方向）**
+- 搜索/解析/下载 → Python 桥接 musicdl；播放 → Rust 本地流代理 `127.0.0.1:<port>/feiniu/stream`（`src-tauri/src/music/feiniu/proxy.rs`），**真流式透传 Range，seek 依赖它，别改成前端直连 NAS**。
+- 播放内核在 `src/stores/feiniuStore.ts`（不是 musicStore）；`musicStore` 只管搜索/下载任务。
+- `PlayerBar.vue` / `PlayerFull.vue` 用的是 `useFeiniuStore`，不是 musicStore。
+
+**P0（确认可复现）**
+1. 飞牛曲库搜索框完全无效：`MyMusicLibrary.vue:21` 的 `keywordInput` 从未写入 `feiniuStore.keyword`，而 `loadTracks` 读的是 store 的 `keyword`（全仓无赋值点）。
+2. 重启后点播放键无反应：`restoreQueue()` 只恢复队列不设 `audio.src`，`toggle()` 里 `play()` 被空 catch 吞掉。
+3. 双音频引擎可同时发声：`MusicModule.vue:1413` 的试听 `<audio>` 与 `feiniuStore` 的 `new Audio()` 互不感知。
+
+**最值得优先做的一件事**
+把 `PlayerBar` + `PlayerFull` 从 `MusicModule.vue` 提升到 `App.vue` 全局层。原因：`App.vue` 的模块容器是 `:key="activeModule"` 重挂载，切到其他模块时播放条整体卸载，但音频继续播 → 用户失去所有控制入口。
+
+**其它已确认的坑**
+- shuffle 模式下自动切歌是顺序的（`next(manual)` 的随机分支带 `manual` 条件）。
+- `setCacheMode('stream')` / `clearCache()` 都会 `clearPlayback()`，改设置即中断播放。
+- `CacheSettings.vue` 的 `cacheEnabled` 开关从不回填 store 的 `cacheMode`，状态不同步；`cacheMax` 是死代码（后端字段是 `feiniu_cache_max_gb`）。
+- `feiniuStore.init()` 被 `MyMusicLibrary`/`CacheSettings` 重复调用，内含 `restoreQueue()` 会覆盖内存队列，应加幂等标志。
+- `musicStore` 任务持久化把每首歌的 `rawSearch` 一起写 localStorage，大歌单会爆 5MB 配额且静默失败。
+- `playItem` 未命中队列时替换整个队列（单曲播放语义），歌单里的 TrackItem 还没有双击且播放键会被 disabled → 正在播的歌无法暂停。
+- rust 下载引擎下 `doDownload` 仍跳「下载任务」tab，但该 tab 是空的（任务在下载器模块）。
+- 拖动进度条即写 `currentTime` → 流式下反复中断 Range 请求，应改「拖动预览 + 松手提交」。
+
+**界面主线（详见报告 §5）**
+播放条未贴底且离开模块即消失；模块左右内边距不对称（左 28 / 右 40 含滚动条）；三套切换控件（模块 Tabs / 自绘 segmented / 裸文字）；音质徽标 5 色抢戏；列表是「卡片堆」而非紧凑行；`Empty` 组件被裸 children 误用（gap-6 + md:p-12 + border-dashed 无 border）。改版方向：左侧来源树 + 紧凑表格列表 + 全宽坞站播放条 + 可折叠「正在播放」右栏。
diff --git a/.workbuddy/memory/MEMORY.md b/.workbuddy/memory/MEMORY.md
new file mode 100644
index 0000000..745f884
--- /dev/null
+++ b/.workbuddy/memory/MEMORY.md
@@ -0,0 +1,31 @@
+# 项目长期记忆（Thing / F:\AtieProject\Thing）
+
+Tauri + Vue 3 + Pinia + Tailwind v4 + reka-ui(shadcn-vue) 的桌面工具箱，按模块组织（`src/modules/<id>/`）。
+
+## 架构约定
+
+- **模块挂载**：`App.vue` 的 `ModuleContainer` 用 `:key="activeModule"` 重挂载，**模块不 keep-alive**。因此任何「需要跨模块常驻」的 UI 都必须挂在 `App.vue` 层，不能放在模块内部。
+- **音乐播放器**：内核在 `src/stores/feiniuStore.ts`（不是 musicStore）；UI 入口在**标题栏** `src/components/layout/TitleBarMusic.vue`（搜索框左侧：唱片图标 + 歌名，点击弹出方形控制窗，播放中图标换封面并旋转），大屏 `src/components/layout/NowPlayingDialog.vue`（歌词/队列）由控制窗的入口打开，由 `App.vue` 渲染。`musicStore` 只负责搜索/歌单解析/下载任务。
+  - 历史沿革：`PlayerBar/PlayerFull`（模块内）→ `GlobalPlayerBar`（App 全局坞站）→ 现为 `TitleBarMusic`（标题栏）。前者们均已删除，不要再新增底部播放条。
+- **模块顶部 tabs 统一写法**：`<Tabs v-model>` → `<div ref="tabsListRef" class="shrink-0">` → `<TabsList class="grid w-full max-w-md grid-cols-N !bg-transparent !p-0 !shadow-none">` → `TabsTrigger`(带 `class="gap-1.5"` + 图标) → `TabsContent class="mt-4 min-h-0 flex-1 ... tab-animate"`；模块根节点统一 `h-full p-6 overflow-hidden flex flex-col`。
+  - 注意：顶部 Tabs 上那个"可见边框"是 `:focus-visible` 的 ring，并非常态样式。别处若要复刻选中态且背景也是白色，需要自己补 `ring-1 ring-border`，否则白色胶囊只靠 `shadow-sm`（5% 透明度）在白底上几乎不可见。
+- **列表/导航行的对齐**：行高用固定值（`h-8` / `h-7`）+ `items-center`，不要靠 `py-x` 推算；右侧数字列始终渲染（空时显示 `0`）并加 `min-w-[3ch] text-right tabular-nums`，否则数字列会参差。
+- 音乐播放走 Rust 本地流代理 `127.0.0.1:<port>/feiniu/stream`，**真流式透传 Range**（`src-tauri/src/music/feiniu/proxy.rs`），seek 依赖它，不要改成前端直连 NAS。
+- 模块生命周期钩子：`src/modules/<id>/index.ts` 的 `lifecycle.onActivate/onDeactivate/onEnable/onDisable`。
+- 模块内分段导航统一用 `src/components/common/SegmentedNav.vue`；进度/音量统一用 `src/components/common/ScrubBar.vue`（拖动只预览、松手才提交 seek）。
+
+## 工程约定
+
+- **Tailwind v4**：不识别运行时拼接的类名。动态网格用内联 `gridTemplateColumns`，或把完整字面量类名写在模板里。
+- **tsconfig 开启 `noUnusedLocals` / `noUnusedParameters`**，未使用的 import 会导致构建失败。
+- 主题 token 在 `src/style.css`（`--primary` / `--muted` / `--background` 等）。**禁止硬编码** `bg-white` / `border-white/10`，否则暗色主题会失效。
+- 全局可复用动画类写在 `src/style.css`（如 `.music-eq`、`.tab-animate`）。
+- 构建校验：`npm run build`（= `vue-tsc --noEmit && vite build`）。
+
+## 本机环境注意事项
+
+- Bash 工具在本机不可用（PATH 未初始化，`ls`/`find` 等均 not found）。用 PowerShell + 显式绝对路径的 node 执行命令。
+- PowerShell 工具**不返回 stdout**：需 `| Out-File` 写文件后再用 Read 读取。
+- `Remove-Item` 被沙箱静默拦截；删除文件用 `node -e "require('fs').unlinkSync('绝对路径')"`。
+- 受管 node：`C:\Users\Administrator\.workbuddy\binaries\node\versions\22.22.2-3\node.exe`。
+- 排障经验：Pinia setup store 里若返回对象引用了未定义变量，TS 会让整个 store 退化成 `any`，进而报出成片无关的 `TS7006 implicitly has an 'any' type`。先查 store 自身的错误。
diff --git a/MUSIC_MODULE_REVIEW.md b/MUSIC_MODULE_REVIEW.md
new file mode 100644
index 0000000..2ed3cf3
--- /dev/null
+++ b/MUSIC_MODULE_REVIEW.md
@@ -0,0 +1,465 @@
+# 音乐模块全链路审查报告
+
+> 审查范围：数据请求（搜索/歌单解析/下载/解析真实链接）、播放控制（试听、播放器内核、队列、歌词、缓存）、状态管理（musicStore / feiniuStore）、UI 交互与视觉。
+> 覆盖文件（前端 11 个 + Rust 4 个）：
+> `src/stores/musicStore.ts`、`src/stores/feiniuStore.ts`、`src/modules/music/MusicModule.vue`、`components/PlayerBar.vue`、`components/PlayerFull.vue`、`components/MyMusicLibrary.vue`、`components/TrackItem.vue`、`components/settings/ConnectionsSettings.vue`、`components/settings/CacheSettings.vue`、`SourcePicker.vue`、`sources.ts`、`index.ts`、`src/App.vue`、`src/components/layout/ModuleContainer.vue`、`src-tauri/src/music/{mod,commands}.rs`、`src-tauri/src/music/feiniu/{mod,proxy}.rs`
+
+---
+
+## 0. 结论摘要
+
+整体架构是清晰的：**搜索/下载走 Python 桥接（musicdl）**，**播放走飞牛 NAS 本地流代理（Rust axum，支持 Range 透传）**，两个 store 职责分离，流代理与缓存设计是对的。问题集中在三类：
+
+| 类别 | 数量 | 代表问题 |
+|---|---|---|
+| P0 功能性失效 | 3 | 飞牛曲库搜索框完全无效；重启后播放键无响应；两个音频引擎可同时发声 |
+| P1 逻辑/状态缺陷 | 12 | shuffle 自动切歌不随机；缓存开关状态不同步；队列被单曲播放重置；任务持久化写入 `rawSearch` 撑爆 localStorage |
+| P2 性能瓶颈 | 9 | 拖动进度条即发 Range 请求；歌词/队列无虚拟滚动；全屏模糊背景；每行 2 个 Tooltip |
+| P3 界面与交互缺陷 | 25 | 播放条未贴底且离开模块即消失；左右内边距不对称；三套切换控件；徽标 5 色抢戏；列表变卡片堆 |
+
+**最需要优先决策的一件事**：把 `PlayerBar` / `PlayerFull` 从 `MusicModule.vue` 提升到 `App.vue` 全局层。当前它们挂载在音乐模块内部，而模块容器是 `:key="activeModule"` 重挂载（`App.vue:36-41`）——**切到任何其他模块，播放条和"正在播放"大屏整体卸载，但音频仍在后台播放，用户完全失去控制入口**。这是当前体验上最严重的问题。
+
+---
+
+## 1. P0 功能性失效（必须修）
+
+### 1.1 飞牛曲库搜索框完全无效
+**现象**：输入关键词、回车，曲库列表纹丝不动。
+
+**根因**：`MyMusicLibrary.vue:21` 定义了本地 `keywordInput`，`onSearchInput`（:24-29）只做了防抖后调用 `store.loadTracks(1)`，而 `loadTracks` 读的是 **store 里的 `keyword`**（`feiniuStore.ts:381`）。检查全仓：`store.keyword` **从未被任何 UI 赋值**。
+
+```ts
+// feiniuStore.ts:375-382
+const data = await invoke('feiniu_list_tracks', {
+  page: p, size: 50,
+  keyword: keyword.value.trim() || null   // ← keyword 永远是 ''
+})
+```
+
+**修复**：把输入直接接到 store 字段，去掉中间层。
+
+```vue
+<!-- MyMusicLibrary.vue -->
+<Input v-model="store.keyword" placeholder="搜索飞牛曲库（歌名 / 歌手）"
+       @input="onSearchInput" @keydown.enter="onSearchInput" />
+```
+```ts
+// onSearchInput 里补一句：清空关键词时立即回全量
+function onSearchInput() {
+  clearTimeout(searchTimer)
+  searchTimer = setTimeout(() => store.loadTracks(1).catch(e => toast.error(String(e))), 400)
+}
+```
+
+---
+
+### 1.2 应用重启后，播放键点了没反应
+**现象**：重启应用，底部播放条显示着上次的歌，点播放键没任何反应，也没有提示。
+
+**根因**：`restoreQueue()`（`feiniuStore.ts:644-655`）只恢复了 `queue` / `queueIndex`，**没有给 audio 设置 `src`**。此时点击播放走 `toggle()`（:564-568）：
+
+```ts
+function toggle() {
+  const a = ensureAudio()
+  if (a.paused) a.play().catch(() => {})   // ← 无 src，play() 直接 reject，被静默吞掉
+  else a.pause()
+}
+```
+
+`ensureAudio()` 新建的 `Audio()` 没有 `src`，`play()` 抛 `NotSupportedError`，被空 catch 吞掉。点「上一首/下一首」反而能用（走 `playCurrent()` 会设 src），所以表现为"只有播放键坏了"。
+
+**修复**：`toggle()` 检测无 src 时先走一次 `playCurrent()`；同时给失败加可见提示。
+
+```ts
+function toggle() {
+  const a = ensureAudio()
+  if (!a.src) {                 // 恢复队列后首次播放
+    if (current.value) playCurrent()
+    return
+  }
+  if (a.paused) a.play().catch(err => { playing.value = false; logger.error(`播放失败: ${err}`) })
+  else a.pause()
+}
+```
+另外建议 `startPlayback` 的 catch 里落一条 `toast.error('播放失败：' + err.message)`，当前 `:558-561` 是先 catch 再静默，用户拿不到任何信息。
+
+---
+
+### 1.3 两个独立音频引擎，可同时发声
+**现象**：在「发现音乐」点某首歌试听，再回到播放器播另一首 → 两首歌同时响；或者试听中点播放器播放，两路声音叠加。
+
+**根因**：存在两个互不知晓的 `<audio>`：
+- `MusicModule.vue:1413` —— 试听用的模板 `<audio ref="audioEl">`（`togglePlay` :372-406 驱动）
+- `feiniuStore.ts:109-126` —— 播放器内核 `new Audio()`
+
+二者没有互斥，`playingKey` 与 `store.playing` 彼此独立。附带问题：试听音频在**切换 tab / 卸载模块时不会停止**（模板 audio 被移除，引用置空，媒体仍可能继续播到自然结束）。
+
+**修复（推荐）**：废弃模块内试听 audio，试听直接走同一内核——`playQueue([{...}], 0)`，source 用 `'preview'`，播完即止。若短期不想动内核，至少在 `togglePlay` 之前 `feiniu.clearPlayback()`，并在 `onBeforeUnmount` 里 `audioEl.value?.pause()`。
+
+---
+
+## 2. P1 逻辑与状态缺陷
+
+| # | 问题 | 位置 | 说明与改法 |
+|---|---|---|---|
+| 2.1 | **shuffle 自动切歌不随机** | `feiniuStore.ts:570-586` | `next(manual)` 的随机分支带 `manual` 条件，`onEnded → next(false)` 在 shuffle 下走的是顺序 `++`。用户开了随机，一首播完却是下一首。改：把随机逻辑与 `manual` 解耦，`shuffle` 时无论手动/自动都随机（并记录已播集合避免短期重复）。 |
+| 2.2 | **prev 在 shuffle 下也是顺序** | `feiniuStore.ts:598-607` | 同上；随机模式应回退到历史栈。 |
+| 2.3 | **切缓存模式/清缓存会中断播放** | `feiniuStore.ts:266-280` | `setCacheMode('stream')` 和 `clearCache()` 都调 `clearPlayback()`；而 `CacheSettings.setEnabled(false)` 又会触发 `setCacheMode('stream')`。改设置就把歌停了，属于误伤。应只在必要（如清掉正在播的那首缓存）时停止，或改为"下一首生效"。 |
+| 2.4 | **缓存开关与真实模式不同步** | `CacheSettings.vue:13-23,32-35` | `cacheEnabled` 初始恒为 `false`，`onMounted` 只读了 `cacheMode` 没回填开关；若历史已是 cache 模式，打开设置页看到的是"关"，但实际在缓存。另外 `cacheMax = ref(5)` 是死代码（从未使用，后端对应字段是 `feiniu_cache_max_gb`），`cacheStatus` 在 onMounted 也没刷新。 |
+| 2.5 | **单曲播放会重置整个队列** | `feiniuStore.ts:500-511` | `playItem` 未命中队列时 `queue.value = [{...item}]`——用户从 2000 首的曲库点播放，队列被替换成 1 首，播完就停。播放器语义应是"以所在列表为上下文播放"。改：`playItem(item, contextList?)`，命中则跳转，未命中则以 `contextList` 建队列。 |
+| 2.6 | **歌单内的曲目无法暂停 / 无法整单播放** | `MyMusicLibrary.vue:228-233` | 歌单里的 `TrackItem` 既没有 `@dblclick`，播放按钮又被 `TrackItem.vue:71` 的 `:disabled="store.playing && store.current?.guid === item.guid"` 禁用——正在播这首时按钮变灰，**没有任何方式暂停**。且点击播放会走 2.5 的"单曲替换队列"。 |
+| 2.7 | **`init()` 被重复调用，会覆盖内存中的队列** | `feiniuStore.ts:129-157` | `MyMusicLibrary.onMounted`（:64-69）与 `CacheSettings.onMounted`（:16-20）都调 `store.init()`；`init` 内含 `restoreQueue()`，会在用户切到设置页时用 localStorage 的旧值覆盖当前队列/索引。应加 `inited` 标志位做幂等，或把 `restoreQueue` 只放在应用启动路径。 |
+| 2.8 | **任务持久化把 `rawSearch` 一起写进 localStorage** | `musicStore.ts:79-93,228-234,439` | `songsData: songs` 保留了每首歌的 `rawSearch`（上游 API 原始响应）。一个 500 首歌单任务 → 序列化后极易超过 5MB 配额，`persistTasks` 的 catch 会静默失败，历史记录随机丢失。改：持久化前剥离 `rawSearch` / `defaultDownloadHeaders`，只留重下所需字段。 |
+| 2.9 | **`pendingUploadOnDone` 泄漏，造成误上传** | `MusicModule.vue:60,74-82,483-500` | 该标志在下发下载请求时置 `true`，只有"检测到有任务 done"才清 `false`。若下载报错/被取消、或用户在选择音质弹窗点了取消，标志会残留，之后**任意一个无关任务完成**都会触发一次上传。`autoUpload` 打开时则是每个任务完成都重复全量上传一次。建议改为按 `taskId` 记录"待上传任务集合"，完成时精确消费。 |
+| 2.10 | **Rust 引擎下载后跳到空的任务页** | `MusicModule.vue:460` | `doDownload` 无条件 `activeTab.value = 'tasks'`，但 `downloadEngine === 'rust'` 时任务被交给「下载器」模块（`musicStore.ts:391-430` 不创建本模块任务），本模块任务列表是空的，用户看到"暂无下载任务"。且此时 `downloadTarget === 'feiniu'` 的自动上传链路也永远不会触发。应在 rust 引擎下改为提示"已交给下载器模块"并跳转到对应模块。 |
+| 2.11 | **`duration` 未知时拖动进度条无效** | `feiniuStore.ts:609-613`（配合 `PlayerBar.vue:18-20`） | `onProgress` 用 `store.duration` 换算秒数；若流没有返回 `Content-Length`，`loadedmetadata` 后 `duration` 为 `NaN`，`a.currentTime = NaN` 被忽略，进度条要么不动要么跳回 0。应在 `seek` 内做 `if (!isFinite(a.duration) || a.duration <= 0) return` 并给出"当前音频不支持跳转"的提示。 |
+| 2.12 | **`nowPlayingOpen` 状态跨模块残留** | `feiniuStore.ts:105` + `PlayerFull.vue:43` | 大屏开着时切走模块，Dialog 随模块卸载消失，但 `nowPlayingOpen` 仍是 `true`；回到音乐模块会突兀地自动弹出。建议改为由组件本地 `ref` 承载，或在 `onMounted` 时重置。 |
+
+其它可在后续清理的小项：`doneCount` 在重复 `done` 事件下会虚增（`musicStore.ts:320`）；`redownloadTask` 用的是**当前默认音质**而非原任务音质（`musicStore.ts:523`）；音质弹窗取消后 `selectedKeys` 已被清空（`MusicModule.vue:505-509`）；`installRuntime` 的进度监听清理逻辑正确，但 `installError` 与最后一条进度事件之间缺少"失败即清进度"的处理（注释已提到，代码未做）。
+
+---
+
+## 3. 性能瓶颈与优化点
+
+### 3.1 拖动进度条 = 连续发起 Range 请求（最该改的一项）
+`PlayerBar.vue:104-110` / `PlayerFull.vue:75-80` 把 Slider 的 `update:model-value` 直接接到 `store.seek()`，而 `seek` 立刻写 `a.currentTime`。飞牛流代理是**真流式透传 Range**（`proxy.rs:131-133`），所以拖动一次会触发几十次"中断旧请求 → 发新 Range 请求"：
+
+- 占用带宽、NAS 侧反复建连
+- 拖动过程中出现爆音/卡顿
+- 拖到底后又从新位置重新缓冲
+
+**推荐**：拖动期间只更新本地"预览位置"，`pointerup` / `change` 时提交 `seek`。
+
+```ts
+// 父组件维护 dragging + previewValue
+const dragging = ref(false)
+const preview = ref(0)
+function onProgressInput(v?: number[]) { dragging.value = true; preview.value = v?.[0] ?? 0 }
+function onProgressCommit(v?: number[]) {
+  dragging.value = false
+  store.seek(((v?.[0] ?? 0) / 100) * store.duration)
+}
+```
+```vue
+<Slider :model-value="[dragging ? preview : store.progress]" @update:model-value="onProgressInput" @value-commit="onProgressCommit" />
+```
+另外 `:step="0.5"`（200 档）对 4 分钟歌 ≈ 1.2s 粒度尚可，但对播客/长音频（1 小时以上）单档 ≈ 18s，建议改为按 `duration` 动态计算 step（如 `100 / duration`）。
+
+### 3.2 进度时间轴以 4Hz 驱动整棵组件树
+`timeupdate` 约每 250ms 一次写 `position.value`，凡是读它的组件都会重渲染。当前影响面：
+- `PlayerBar` + `PlayerFull` **同时挂载**（大屏打开时）→ 双份重渲染
+- `PlayerFull` 的 `currentLine()`（`feiniuStore.ts:710-717`）是**线性扫描**，每次重算 O(歌词行数)。改：缓存上次命中的索引，只在 `position > 下一行时间` 时 `idx++`（歌词已排序，单调推进），或二分查找。
+- `PlayerFull.vue:33-39` 的 `watchEffect` 每次行切换都 `querySelectorAll('[data-line]')` 全量查询后再 `scrollIntoView({behavior:'smooth'})`。改：用 `ref` 数组或在 v-for 里收集 DOM，仅对目标行滚动；并给滚动加 `prefers-reduced-motion` 降级。
+
+```ts
+let lastLineIdx = -1
+function currentLine(): number {
+  const lines = lyricLines.value
+  if (lastLineIdx >= 0 && lastLineIdx < lines.length
+      && (lastLineIdx + 1 >= lines.length || position.value < lines[lastLineIdx + 1].t)) {
+    while (lastLineIdx > 0 && position.value < lines[lastLineIdx].t) lastLineIdx--
+    while (lastLineIdx + 1 < lines.length && lines[lastLineIdx + 1].t <= position.value) lastLineIdx++
+    return lastLineIdx
+  }
+  lastLineIdx = -1
+  for (let k = 0; k < lines.length; k++) if (lines[k].t <= position.value) lastLineIdx = k; else break
+  return lastLineIdx
+}
+```
+同时建议歌词/队列上**虚拟滚动**：LRC 常有 80~200 行，长播放列表可上千行，当前是全量 DOM。
+
+### 3.3 大屏背景的整图高斯模糊
+`PlayerFull.vue:50-52`：`<img class="h-full w-full scale-110 object-cover blur-2xl opacity-30">` 铺满整个弹窗（`min-h-[70vh]`，实际常超 900×700）。一张全尺寸图叠加 `blur-2xl` + `scale-110`，在打开期间持续占用合成/光栅资源，低端机上会明显掉帧（拖进度条时最明显）。
+
+**推荐**：改为一次性低分辨率方案——用同图 `size=96` 缩略图 + CSS 渐变遮罩，或直接用取色（后端返回主色）生成柔和纯色/线性渐变背景。收益远大于视觉损失。
+
+### 3.4 搜索结果行每行 2 个 Tooltip 组件
+`MusicModule.vue:928-965`：每首歌行包了 2 个 `Tooltip`（reka-ui 组件 + 上下文）。首批 80 行 = 160 个 Tooltip 实例，滚动加载到 500 行 = 1000 个。挂载/更新成本高，且 Tooltip 会随列表 diff 频繁重建。
+
+**推荐**：列表行用原生 `title` 属性承载提示（无需组件）；只对"需要富文本提示"的 `+N` 音质档位保留一个 Tooltip。
+
+### 3.5 其它
+- **下载任务聚合计算**：`taskAggDone/taskAggTotal`（`MusicModule.vue:547-548`）每次渲染都遍历全部 `songs`。一个 500 首歌的任务，每来一次进度事件就重算 500×2。改：在 `handleDownloadEvent` 里维护 `task.doneBytes/totalBytes` 增量字段。
+- **`displayItems` / `groupKeys` / `groupAllSelected`**：模板中对每个源分组头调用 `groupAllSelected`，内部 `filteredResults.filter(...)` 是 O(n)；结果集大时是 O(n × 分组数)。改：用一次 `computed` 预生成 `Map<source, keys[]>`。
+- **飞牛曲库无分页**：`loadTracks` 固定 `size: 50`，`page/total` 暴露了却没有 UI。曲库 > 50 首时后面的歌**完全访问不到**（`playAll` 也只能播前 50 首）。应加无限滚动或分页。
+- **本地扫描无上限**：`scanLocal` 一次性返回全部条目，超大音乐目录下会长时间占住主线程做映射与渲染。
+- **缓存模式首播延迟**：`feiniu_cache_fetch`（`commands.rs:421-429` → `cache_fetch`）是"**下载完整文件后返回路径**"，即 `cache` 模式下首次播放要等整首下完；而 `loadingPlay` 这个状态在 UI 上**从未被使用**（`PlayerBar`/`PlayerFull` 都没读），用户看到的是"点了没反应"。要么改用边下边播的双源策略，要么至少把 `loadingPlay` 接上 spinner。
+
+---
+
+## 4. 交互体验问题（按操作路径）
+
+**播放控制**
+1. 播放/暂停按钮 `disabled` 时无视觉降级（`PlayerBar.vue:76-84`），看起来可点却没反应。
+2. 音量图标（`PlayerBar.vue:117`）不可点击，没有"一键静音"；音量条只有 80px，长按/滚轮调节都没有。
+3. 切歌没有 crossfade，也没有间奏/淡出，切歌瞬间是硬切。
+4. 播放模式按钮图标随状态变（Repeat/Repeat1/Shuffle），初看像三个不同功能，且没有文字提示（只有 Tooltip）。
+5. 队列入口用 `ListMusic` 图标 + 数字角标，但点击是**平铺开关**（`store.queueVisible = !store.queueVisible`），而队列实际渲染在 `PlayerFull` 的右栏里——在大屏没打开时点这个图标看不到任何反馈（因为它只切了右栏的 tab，而弹窗没开）。
+6. 上一首/下一首没有"按住快进/快退"（老播放器的常见预期）。
+
+**进度条**
+7. 没有 hover 时间气泡、没有缓冲进度层、没有"拖动时显示预览时间"。当前拖动时只能看两侧的小字。
+8. 轨道 6px + 16px 白色圆点滑块，`Slider.vue:40` 硬编码 `bg-white`，在浅色主题下白滑块白描边几乎隐形。
+
+**列表切换**
+9. 发现音乐页切到「我的音乐」再切回，搜索关键词和结果**全部丢失**（模块内 tab 用 `Tabs` 非 keep-alive，`flatResults` 被重算但 store 里 `results` 还在——实际是因为 `MusicModule` 未卸载所以结果还在，但 `visibleCount` 会被 `watch(filteredResults)` 重置，滚动位置丢失）。
+10. 列表里双击行不会播放（只有点小图标才播），不符合音乐软件的肌肉记忆。
+11. 键盘：无空格播放/暂停、无 ↑↓ 选行、无 Enter 播放；所有列表行都不可聚焦。
+12. 多选操作只有"下载所选"，缺"加入歌单""加入队列""下一首播放"。
+
+---
+
+## 5. 界面缺陷清单（具体位置 + 改法）
+
+### 5.1 结构与布局
+
+| # | 缺陷 | 位置 | 改法 |
+|---|---|---|---|
+| L1 | **播放条没贴底**：被模块根 `p-6` 包住，`border-t` 只在左右各缩进 24px 的宽度上出现，视觉上像一张"飘着的卡片"而非底部坞站 | `MusicModule.vue:688,1416` | 把 `PlayerBar` 提升到 `App.vue`，作为 `flex-col` 壳层的最后一行（全宽、`border-t`、`h-[72px]`）；音乐模块内容区 `pb-[72px]` 让位 |
+| L2 | **左右内边距不对称**：模块左 24px + `px-1`(4px) = 28px；右 24px + `pr-3`(12px) + `px-1` = 40px，右侧被滚动条再吃一层，卡片右边距明显窄于左边 | `MusicModule.vue:688,706-707,987-988` | 统一成 `px-6`，滚动区改成 `[&>[data-slot=scroll-area-viewport]]:pr-6` 或让 ScrollArea 用 `scrollbar-gutter: stable`，避免内边距被滚动条挤压 |
+| L3 | **三套切换控件**：模块级 `TabsList`（半透明覆盖）、`MyMusicLibrary` 自绘分段按钮（:89-114）、`PlayerFull` 的裸文字切换（:113-129）——三种视觉语言表达同一件事 | 三处 | 统一为一种 segmented 控件（建议用现有 `Tabs`/`TabsList`，或统一样式的 `ButtonGroup`），并用同一套"选中=主色底/浅底 + 中粗字"的规则 |
+| L4 | **`Empty` 组件误用**：直接塞裸 children，继承 `gap-6`(24px) 与 `md:p-12`(48px)，图标与文案间距过大且垂直被撑高；`border-dashed` 没有宽度声明，虚线框实际不显示 | `MusicModule.vue:801-809, 977-980`、`MyMusicLibrary.vue:76-83,135-140` | 用组件既定的子结构：`EmptyMedia / EmptyTitle / EmptyDescription`；或给容器加 `border` + `border-dashed`、`gap-3`、`p-8` |
+| L5 | **横向 Tab 与子 Tab 层级混乱**：顶层 4 个 tab 里，「我的音乐」内部又横排 3 个子 tab，「设置」内部又竖排 5 张卡；导航成本高 | `MusicModule.vue:691-696`、`MyMusicLibrary.vue:88-114` | 见 §6 的"左侧来源树 + 右侧主区"结构，把两级 tab 压成一级 |
+| L6 | **首屏被低价值信息占据**：「下载到 本地/飞牛」占一整个卡片行（`MusicModule.vue:709-726`），说明文字是 12px 灰字却放在最显眼位置；真正的搜索框被挤到第二行 | `MusicModule.vue:708-794` | 把"下载目标"收进搜索工具栏右侧的 `Select`（与源选择器同排），或放进设置页；首行只留 搜索输入 + 源选择 + 搜索按钮 |
+| L7 | **歌单详情页底部孤零零一个"移除最后一首"按钮** | `MyMusicLibrary.vue:234-243` | 语义错误，删掉。改为：行 hover 显示「⋯」菜单（从歌单移除 / 上移 / 下移），或支持多选后批量移除 |
+| L8 | **歌单左栏无滚动**：`grid-cols-[220px_1fr]`，左栏是普通 `div`，歌单多了会撑高整页 | `MyMusicLibrary.vue:189-205` | 左栏用 `ScrollArea` 并固定高度（`h-[calc(100vh-260px)]`），或整体改三栏布局 |
+| L9 | **设置页信息密度过低 + 语义重复**：「飞牛音乐连接」管连接，「上传到飞牛曲库」又要求用户回头去前一张卡点云朵登录；5 张卡片纵向拉得很长 | `MusicModule.vue:1123-1371` | 合并为「连接与存储」一张卡：连接列表 + NAS 文件服务登录 + 曲库目录 + 自动上传；「播放缓存」并入「播放」分组；「环境检查」做成折叠的"诊断"面板 |
+
+### 5.2 视觉与色彩
+
+| # | 缺陷 | 位置 | 改法 |
+|---|---|---|---|
+| V1 | **音质徽标 5 色抢戏**：Hi-Res=琥珀、无损=紫、320K=天蓝、192K=橙、128K=锌灰，一行里 2 个高饱和徽标 + 1 个 `+N`，视觉噪音压过歌名 | `MusicModule.vue:336-355, 879-905` | 降为**两档**：无损/高解析用实心浅色徽标（一个色），其余用 `outline` 中性色；颜色不承担"档位"信息，档位靠文字。或改为歌名后的一个小图标 + Tooltip 详情 |
+| V2 | **列表变成卡片堆**：每行 `border` + `rounded-lg` + `p-2.5` + `space-y-2`，80 行 = 80 张卡，行间 8px 空隙，扫描效率低 | `MusicModule.vue:845-859` | 改紧凑单行：行高 44~48px、无独立边框、`border-b border-border/60` 或干脆无分隔、hover `bg-accent/60`；表头一行（`# / 标题 / 专辑 / 时长 / 操作`） |
+| V3 | **源分组头与大卡片行不匹配**：分组头只是 12px 小字，紧贴一堆 56px 卡片 | `MusicModule.vue:848-857` | 分组头改 `sticky top-0 z-10 bg-background/95 backdrop-blur` + 底部分隔线，字号 13px medium；或改用左侧来源 Tab 过滤，取消组内嵌头 |
+| V4 | **当前播放项用"选中态"表达**：`border-primary bg-primary/10` 在浅色主题下是"近黑边框 + 10% 黑底"，像复选框选中而非"正在播放" | `TrackItem.vue:53-54` | 改为：左侧 3px 主色竖条 + 歌名主色 + 一个 12px 的跳动均衡器图标；hover 与 active 语义分离 |
+| V5 | **`PlayerFull` 硬编码白色边框**：`border-l border-white/10`，浅色主题下完全不可见 | `PlayerFull.vue:112` | 改用 `border-border` |
+| V6 | **`PlayerFull` 背景被"洗白"**：整图 `opacity-30` + 白→白渐变，浅色下糊成一片；同时是持续 GPU 开销 | `PlayerFull.vue:50-53` | 改为缩略图小尺寸模糊，或纯色/双色线性渐变（从封面取色）；浅色主题下用极浅的封面色调，深色主题下用暗化封面色 |
+| V7 | **滑块基本不可见**：`Slider.vue:40` 硬编码 `bg-white`，16px 白色滑块 + 白色描边叠在浅底上；轨道仅 6px | `Slider.vue:36-41` | 滑块改 `bg-background` + 主色描边（或直接用 `bg-primary`）；静息轨道 4px、hover/拖动时平滑增到 8px；加 `transition-[height]` |
+| V8 | **`PlayerFull` 歌词行区分度不足**：非当前行 `text-muted-foreground/60`，当前行仅 `font-medium text-foreground`，没有位置指示 | `PlayerFull.vue:136-145` | 当前行放大到 17~18px + `text-foreground` + 左侧或下方主色指示；两侧行逐级降透明度（60/40/25）形成景深；点击区域扩大到整行并加 hover 背景 |
+| V9 | **`PlayerFull` 进度时间只在下方一行小字**，且控制按钮组与进度条分属两个块，视觉不聚合 | `PlayerFull.vue:74-108` | 进度条与控制键合并为一块：`[时间] ──●──── [时间]` 上、`[模式][上一首][播放][下一首][队列]` 下的居中控制簇 |
+| V10 | **「词」按钮用单个汉字**当歌词开关 | `PlayerBar.vue:125-132` | 换成 `Lyrics` 图标（`FileText`/`MicVocal`），与两侧图标风格一致 |
+| V11 | **下载任务标题行过载**：状态标签 + 歌名 + 歌手 + 音质标签 + 已下载/总量 + 最多 4 个图标按钮挤在一行；且 `Card` 被 `gap-0 py-0` + `CardContent py-2` 覆盖，内边距与模块内其它卡片不一致 | `MusicModule.vue:995-1060` | 拆两行：第一行 `[状态] 歌名 · 歌手 ……… [音质] [⋯菜单]`；第二行进度条 + 大小 + "打开目录/取消/重下"收进 `⋯` 菜单。`Card` 统一 `p-0` + 内部 `p-3` |
+| V12 | **多曲目任务行进度条只有 56px**（`w-14`），几乎读不出进度；错误信息被截断到 112px | `MusicModule.vue:1086-1097` | 进度条改占满剩余宽度（去掉固定宽度，放歌名下方一行）；错误信息用 Tooltip 或点击展开 |
+| V13 | **`TrackItem` 悬停才出现的播放按钮占 40px 固定宽度**，未悬停时标题左侧留出空白列，触屏/键盘用户无法触发 | `TrackItem.vue:68-75` | 改为：封面左下角 24px 半透明播放浮层（hover 显现），或整行 hover 时标题左侧淡入小图标；并支持双击整行播放 |
+| V14 | **飞牛曲库行/本地曲库行/歌单行的"来源"标识不统一**：本地用行内小标签「本地」，飞牛没有标识，歌单混排时无法区分 | `TrackItem.vue:81` | 统一在行尾或封面角标显示来源（NAS 云图标 / 本机图标），并在歌单详情里按来源分组或加筛选 |
+| V15 | **搜索历史下拉不适合键盘操作**：`@focusout` 关闭 + `@mousedown.prevent` 的组合同样让 Tab 导航无法进入历史项 | `MusicModule.vue:738-760` | 改用 `Combobox`/`Popover` + `Command` 组件（仓库已有 `components/ui/combobox`），支持 ↑↓ 选择、Enter 确认、Esc 关闭 |
+| V16 | **`+N` 音质档位靠 Tooltip**，触屏不可达；`visibleTiers` 固定展示 2 个，长歌名下把歌名挤窄 | `MusicModule.vue:888-904` | 行内只留 1 个"最高音质"徽标，全部档位收进右侧 `⋯` 菜单或点击弹出 popover |
+| V17 | **`PlayerBar` 缺少播放态反馈**：`loadingPlay` 未接 UI；NAS 慢时点播放毫无反应 | `PlayerBar.vue:76-84` | 播放键上叠加 spinner（`loadingPlay` 时），或封面加旋转/脉冲 |
+| V18 | **`PlayerBar` 三段留白失衡**：左侧信息 `max-w-44`，中间控制区 `flex-1` 里塞了模式/上下首/播放/队列 + 进度条，右侧音量+词+最大化；窄窗口下中间进度条被压到很短 | `PlayerBar.vue:34-141` | 采用标准三段：左 `w-[240px]` 固定、中 `flex-1 min-w-0`（控制 + 进度）、右 `w-[200px]`（音量/词/大屏）；窄容器下用 `container query` 渐进隐藏音量条与歌词按钮 |
+| V19 | **`TabsList` 同时带 `grid w-full max-w-md` 与组件默认 `inline-flex w-fit`**，并靠 `!p-0 !bg-transparent !shadow-none` 强行覆盖 | `MusicModule.vue:691` | 不要用覆盖式改写；把"模块级分段导航"抽成一个 `SegmentedNav` 组件（`grid grid-cols-N`、`bg-muted p-0.5`、激活项 `bg-background shadow-sm`） |
+| V20 | **封面圆角/阴影规格不统一**：列表 40px `rounded-md`、播放条 44px `rounded-md shadow`、大屏 256px `rounded-xl shadow-2xl` | 多处 | 定规格：列表 6px 无阴影、播放条 6px 无阴影、大屏 12px + `ring-1 ring-border/60` 无重阴影 |
+| V21 | **下载任务空态文案指向错误**：「去"搜索"页选择歌曲下载」，但 tab 已改名为「发现音乐」 | `MusicModule.vue:991` | 改为"去「发现音乐」页选择歌曲下载" |
+| V22 | **`PlayerFull` 未提供音量、队列收起、下一首信息**；队列项没有播放态指示（只有 `bg-primary/10`） | `PlayerFull.vue:147-163` | 补：右上角音量滑条；队列项用序号↔均衡器切换表示当前项，hover 显示"下一首播放/移除" |
+| V23 | **`ConnectionsSettings` 图标按钮语义不明**：`Power` 既表示"激活"又表示"登出"，两个含义相同的图标相邻 | `ConnectionsSettings.vue:157-171` | 激活用 `CircleCheck`/`RadioButton`，登出用 `LogOut`，删除保留 `Trash2`；并为所有 icon-only 按钮补 `Tooltip` + `aria-label` |
+| V24 | **歌单/曲库的「播放全部」用文字 `▶ 播放全部`**，与其他按钮的图标风格不统一 | `MyMusicLibrary.vue:115-117,214-216` | 统一为图标 + 文字：`<Play class="size-4"/> 播放全部` |
+| V25 | **`MusicModule` 里两处搜索框文案不一致**（"输入歌名/歌手/专辑关键词" vs "粘贴歌单链接"）且歌单解析行的 Input 靠 `border-0 bg-transparent` 融进容器，缺少"这是一行输入"的暗示 | `MusicModule.vue:730-782` | 歌单解析改为折叠的"粘贴歌单链接"次级入口（默认收起），避免与主搜索竞争注意力 |
+
+---
+
+## 6. 重设计方案
+
+### 6.1 参考基准
+- **Spotify / Apple Music**：左侧来源树 + 中间列表 + 底部全宽播放条 + 右侧可折叠"正在播放"。
+- **网易云音乐 / QQ 音乐**：紧凑表格行（`# / 标题 / 歌手 / 专辑 / 时长`）、行内 hover 操作、双击播放、底部播放条 + 播放列表面板。
+- **foobar2000 / MusicBee**：信息密度高、可排序表头、键盘优先。
+本项目的定位是"NAS 曲库 + 本地曲库 + 多平台搜索下载"的**工具型播放器**，建议取 **Spotify 的骨架 + 网易云的列表密度**，避免做成消费级流媒体的强视觉风格。
+
+### 6.2 目标信息架构（三级 tab → 一级导航）
+
+```
+音乐
+├── 曲库
+│   ├── 飞牛曲库        (NAS 曲目，分页/无限滚动 + 搜索 + 排序)
+│   ├── 本地曲库        (扫描目录，按文件夹浏览)
+│   └── 我的歌单        (歌单列表 → 歌单详情，可拖拽排序)
+├── 发现音乐            (多平台搜索 + 歌单解析 + 下载)
+├── 下载任务            (进行中 / 已完成 分组)
+└── 设置                (连接与存储 / 播放 / 下载 / 诊断，用左侧锚点或分段)
+```
+把「我的音乐」内部的 3 个子 tab 提升为导航的一级子项（来源树），「设置」内部的 5 张卡片改为分组锚点。
+
+### 6.3 布局结构（目标）
+
+```
+┌───────────────────────────────────────────────────────────────────────┐
+│ TitleBar（含模块浮动切换器）                                            │
+├──────────┬──────────────┬─────────────────────────────────────────────┤
+│ Sidebar  │ 来源树        │ 内容主区                                     │
+│ （模块）  │ 240px        │  ┌ 固定工具栏 ────────────────────────────┐  │
+│          │              │  │ 搜索  来源筛  音质筛  排序   多选操作    │  │
+│          │ 曲库          │  ├ 表头 (# 标题 歌手 专辑 时长 操作) ──────┤  │
+│          │  · 飞牛曲库    │  │ 44px 紧凑行，hover 显示操作             │  │
+│          │  · 本地曲库    │  │ 播放中：主色竖条 + 跳动的均衡器          │  │
+│          │  · 我的歌单    │  │ ...                                    │  │
+│          │ 发现音乐      │  └────────────────────────────────────────┘  │
+│          │ 下载任务      │                                              │
+│          │ 设置          │         （可选右栏 320px：正在播放/歌词/队列） │
+├──────────┴──────────────┴─────────────────────────────────────────────┤
+│ MiniPlayer 72px（全宽坞站：左曲目 中控制+进度 右音量/歌词/大屏）           │
+└───────────────────────────────────────────────────────────────────────┘
+```
+要点：
+1. **MiniPlayer 提升到 `App.vue`**，全宽贴底、不参与任何模块内边距；音乐模块内容区 `pb-[72px]`。这样在任何模块都能控制播放。
+2. **`PlayerFull` 也提升到 `App.vue`**（全局 Dialog/Overlay），解决跨模块残留问题。
+3. **去掉"模块级横向 Tab"**，音乐模块内部用来源树；`useModuleTabs` 仍可保留，用于把来源树的第一级注册给 TitleBar 浮动切换器（保持现有能力）。
+4. **右栏"正在播放"可折叠**：窄窗口默认收起，宽窗口（≥1280px）默认展开，用 `container query` 或 `useMediaQuery` 决定。
+
+### 6.4 视觉规范（建议写入项目 Design Token）
+
+| 项目 | 规范 |
+|---|---|
+| 主色使用 | 只用于：主操作按钮、播放中指示、"正在播放"高亮。**不用于**徽标分类、分组头 |
+| 中性色阶 | 文本 `foreground` / 次文本 `muted-foreground` / 三级文本 `muted-foreground/70`；分隔线 `border/60`；hover 面 `accent/60` |
+| 圆角 | 行/输入 6px（`radius-md`）、卡片 10px（`radius-lg`）、大图 12px、头像/封面圆形仅用于单曲大图 |
+| 阴影 | 列表与播放条**不用阴影**，靠 `border` 分层；只有 Dialog/Popover 用 `shadow-lg` |
+| 行高 | 列表行 44px（紧凑）/ 48px（标准）；表头 32px |
+| 字号 | 歌名 14px/500，歌手·专辑 12px/400，时长时间数字 12px `tabular-nums` |
+| 徽标 | 一类语义一个样式：状态用实心浅底，属性（音质/格式）用 `outline` 中性色 + 文字；不超过 2 个 |
+| 动效 | 仅 `opacity` / `transform`，120~180ms `ease-out`；进度条高度过渡 150ms；尊重 `prefers-reduced-motion` |
+| 明暗主题 | **禁止硬编码** `bg-white` / `border-white/10` / `text-white`；一律走 token |
+| 空状态 | 统一 `EmptyMedia(32px 图标) → EmptyTitle(14px) → EmptyDescription(12px)`，`gap-3`、`p-10`、无边框 |
+
+### 6.5 关键组件规格
+
+**MiniPlayer**
+```
+高度 72px | 全宽 | border-t | bg-background/85 backdrop-blur
+左 240px ：封面 48px(6px 圆角) + 歌名 14px/500 截断 + 歌手 12px 截断 + ♥
+中 flex-1：① [模式][上一首][播放 40px 圆形主色][下一首][队列] 居中
+           ② [时间 00:00] ──进度条(hover 4→8px，含缓冲层)── [总时长]  居中 max-w-[560px]
+右 200px ：音量图标(可点静音) + 音量条 96px | 歌词 | 大屏 | （窄屏只留大屏）
+播放中：封面右侧叠加 3 条均衡器动效；`loadingPlay` 时播放键显示 spinner
+```
+
+**列表行（TrackItem 重写）**
+```
+[#/均衡器 24px] [封面 40px] [标题 14px/500 + 歌手 12px] [专辑 12px 可隐藏] [时长 12px tabular] [⋯ hover 显示]
+高度 44px | 无边框 | border-b border-border/50 | hover:bg-accent/60 | 当前项：左侧 3px 主色条 + 标题主色
+双击整行播放；⋯ 菜单：下一首播放 / 加入队列 / 加入歌单 / 查看文件位置 / 下载
+```
+
+**进度条交互**
+```
+拖动中：只更新预览位置 + 显示时间气泡；轨道加粗；不写 currentTime
+释放时：一次性 seek；若 duration 未知则禁用拖动并提示"该音频不支持跳转"
+缓冲层：在轨道里用 bg-muted-foreground/25 画已缓冲区间（audio.buffered）
+```
+
+---
+
+## 7. 落地路径（按性价比排序）
+
+| 阶段 | 内容 | 影响面 | 预估 |
+|---|---|---|---|
+| **S1 修 Bug（不做设计变更）** | 1.1 搜索框绑定 store.keyword；1.2 `toggle()` 无 src 兜底；1.3 试听与播放器互斥（或合并内核）；2.1/2.2 shuffle 自动切歌；2.4 缓存开关回填；2.7 `init` 幂等；2.8 持久化剥离 `rawSearch` | 仅改逻辑，风险低 | 半天 |
+| **S2 播放器骨架调整** | 3.1 拖动提交式 seek；3.2 歌词行索引缓存；3.3 大屏背景降级；4.1 播放键 loading 态；L1/V18 MiniPlayer 全宽贴底；V5/V7 主题 token 修正 | 播放条 + 大屏 | 1~2 天 |
+| **S3 列表与信息架构** | V2 紧凑列表；V1 徽标降噪；V3 分组头；V13/V4 TrackItem 重写；L6 首屏工具栏重构；2.5 上下文队列；2.6 歌单播放/暂停 | 发现音乐 + 曲库 | 3~4 天 |
+| **S4 结构性重构** | §6.2/6.3 左侧来源树 + 全局播放条；PlayerBar/PlayerFull 提升到 App.vue；右栏正在播放；设置页分组 | 模块外壳 | 1 周 |
+| **S5 体验补全** | 键盘快捷键、虚拟滚动、分页/无限滚动、拖拽排序歌单、音质档位 popover、缓冲层、桌面歌词 | — | 按需 |
+
+**建议先做 S1 + S2**：S1 全是低风险的逻辑修复，S2 集中在两个组件文件里，能立刻解决"卡顿 + 没有控制感 + 拖动难用"的主观感受；S4 的结构调整等到前面稳定后再动，避免一次改动面过大。
+
+---
+
+## 8. 附：值得保留的设计
+
+- 流代理走 `127.0.0.1` 动态端口 + `Cookie` 注入 + **Range 透传**（`proxy.rs`）——这是正确做法，seek 能真正生效，不要改成前端直连。
+- 桥接进程按需拉起、禁用模块时停止（`music/index.ts:34-45`）——避免了常驻 Python 进程。
+- `tasksSignature` 轻量签名代替深度 watch（`musicStore.ts:257-266`）——思路正确（只是 payload 需要瘦身）。
+- 搜索结果**懒解析**（搜索阶段拿档位、播放/下载前才解析真实链接）+ `rawSearch` 支持隔夜链接重解析（`musicStore.ts:355-370,458`）——设计合理。
+- 发现音乐列表的**增量渲染 + IntersectionObserver 哨兵**（`MusicModule.vue:265-305`）——方向正确，可平滑迁移为新列表的基础。
+
+---
+
+## 9. 重构落地记录（本次已实施）
+
+### 9.1 新增文件
+
+| 文件 | 作用 |
+|---|---|
+| `src/components/layout/TitleBarMusic.vue` | 标题栏音乐栏：唱片图标 + 歌名，点击弹出**方形播放控制窗** |
+| `src/modules/music/components/PlaylistEditorDialog.vue` | 歌单音乐编辑器：从全部音乐勾选加入 / 批量移出 |
+| `src/components/layout/NowPlayingDialog.vue` | 「正在播放」大屏（封面 + 控制 + 歌词 / 队列），由方形控制窗的「歌词 / 队列」入口打开 |
+| `src/components/common/ScrubBar.vue` | 通用拖拽进度条：**拖动只预览、松手才 seek**，含缓冲层与时间气泡 |
+| `src/components/common/SegmentedNav.vue` | 分段导航（现由 `NowPlayingDialog` 的「歌词 / 队列」切换使用） |
+
+`PlayerBar.vue` / `PlayerFull.vue` 已删除；`GlobalPlayerBar.vue` 曾短暂作为全局坞站播放条存在，现已被标题栏音乐栏取代并删除。
+
+**播放器入口最终形态**：标题栏搜索框左侧的音乐栏（`TitleBarMusic`）——未播放过时只显示唱片图标；有曲目后图标替换为封面并随播放旋转，右侧显示截断歌名。点击弹出约 300×340 的方形控制窗（封面 / 曲目信息 / 进度 / 循环·上下首·播放·队列 / 音量 / 歌词·队列入口），点击封面或「歌词 / 队列」进入大屏。
+
+### 9.2 修复的缺陷
+
+**P0**
+1. 飞牛曲库搜索框：直接 `v-model="store.searchKeyword"` 并新增 `loadTracks(page, append)` + `loadMoreTracks()`，搜索真正生效且支持分页续拉。
+2. 重启后播放键失效：`toggle()` 在 `audio` 无 src 时先按当前条目装载（试听或队列当前曲），失败原因经 `playError` 冒泡成 toast。
+3. 双音频引擎：删除模块内试听 `<audio>`，试听改走 `feiniu.playPreview()`，与队列播放**共用同一个 audio 实例**，天然互斥。
+
+**P1**
+4. shuffle 自动切歌：`next()` 不再区分手动/自动，随机模式下都从「待播池」抽取；新增切歌历史栈，`prev()` 在随机模式下真正回退。播放模式持久化。
+5. 缓存模式：`setCacheMode` / `clearCache` 不再调用 `clearPlayback`，改设置不中断播放。
+6. 缓存开关状态：`CacheSettings` 的开关改为 `cacheMode` 的双向 computed，删除死代码 `cacheMax`，补 `ensureCacheStatus` 刷新。
+7. `init()` 幂等化（`inited` 标志），不会再覆盖内存队列。
+8. 任务持久化：超过 1.5MB 时自动剥离 `rawSearch` / `defaultDownloadHeaders` 后重试。
+9. 上传触发：`pendingUploadOnDone` 布尔标志改为 `uploadOnDoneTaskIds` 任务集合 + `uploadedTaskIds` 去重表，每个任务最多触发一次；启动时的历史任务不触发重传。
+10. Rust 引擎下载：`startDownload` 返回 `{ engine, skipped, taskId }`；Rust 引擎不再跳到空的任务页，改为提示到「下载器」查看；「下载到飞牛 + Rust 引擎」组合直接给出可读的错误提示并阻止。
+11. 队列语义：`playItem(item, context?)` 支持以所在列表为播放上下文，解决「从大曲库点一首就只剩一首」；新增 `playNext` / `addToQueue` / `removeFromQueue`。
+12. `done` 事件幂等，`doneCount` 不再虚增；`redownloadTask` 沿用原任务音质。
+
+**性能**
+13. 提交式 seek（`ScrubBar`），拖动不再触发几十次 Range 请求中断重建。
+14. 歌词行索引由 O(n) 全量扫描改为「命中缓存微调 + 未命中二分」，并缓存上次索引。
+15. 大屏背景从「整图 `blur-2xl scale-110`」改为主题色径向渐变，去掉持续 GPU 开销。
+16. 列表行去掉 reka Tooltip（改用原生 `title` + 单个 Popover 展示音质档位），500 行不再产生 1000 个组件实例。
+17. 歌词滚动用函数 ref 收集节点，不再每次 `querySelectorAll`。
+18. 播放队列增量渲染（每批 200 行）。
+19. 曲库分页 200/页 + 滚动续拉；任务明细进度条由固定 56px 改为占满剩余宽度。
+
+**交互与视觉**
+20. 播放入口改到**标题栏**：移除模块内播放条与全局坞站播放条，在自定义标题栏搜索框左侧新增音乐栏（唱片图标 + 歌名，未播放过时隐藏歌名）；点击弹出方形控制窗；播放中图标替换为封面并旋转。
+21. 音乐模块顶部 tabs 改回与其余模块完全一致的写法：`<Tabs><div ref="tabsListRef"><TabsList class="grid w-full max-w-md grid-cols-4 !bg-transparent !p-0 !shadow-none">` + `TabsTrigger` + `TabsContent class="mt-4 min-h-0 flex-1 ... tab-animate"`，根节点恢复为 `h-full p-6 overflow-hidden flex flex-col`。
+22. 三级 tab 压成「模块 tab → 曲库内左侧来源树」两级。左栏由 `w-[210px]` 收窄到 `w-[168px]`，来源项的选中态对齐顶部 Tabs（`rounded-lg bg-muted` 容器 + `bg-background shadow-sm` 胶囊），歌单子树用 `border-l` 缩进 + 展开动画；右栏内容切换加 `tab-animate`（`:key="view"` 重挂载触发），不再生硬。
+23. 首屏工具栏：搜索框回到首行，下载目标 / 来源筛选 / 音质筛选收到筛选条，歌单解析收进 Popover。
+24. 列表改 44px 紧凑行：无独立边框、hover 高亮、双击整行播放、序号列悬停原位切换为播放按钮（不再出现 40px 空白列）；播放中行用 `music-eq` 跳动均衡器 + 主色文字。
+25. 音质徽标由 5 色降为单枚中性 outline 徽标 + Popover 详情。
+26. `Empty` 全部改为组件既定结构（`EmptyMedia` / `EmptyTitle` / `EmptyDescription`）。
+27. 歌单：删除语义奇怪的「移除最后一首」，改为行内「⋯」菜单的支持上移 / 下移 / 移除；新增重命名；左侧歌单列表可独立滚动。
+28. **歌单页新增「编辑音乐」**（`components/PlaylistEditorDialog.vue`）：双 Tab 编辑器——「全部音乐」按来源（全部 / 飞牛 / 本地）勾选加入，已在歌单的曲目置灰标记「已加入」不可重复勾选；「已在歌单」批量勾选移出。含搜索、全选当前列表、增量渲染（每批 120）、飞牛曲库续拉、本地未扫描时的内联扫描入口。
+29. 源分组头去掉 `sticky` 与白色底色（原 `bg-background/95 backdrop-blur` 会在浅色背景上形成白色横条）。
+30. **发现音乐每行新增「下载到飞牛」**（试听 / 下载右侧）：走新增的 Rust 命令 `feiniu_upload_from_url`，由后端边拉音源边传给 NAS，**本地不落地文件**；懒解析歌曲会先按默认音质解析真实链接，并合并 `defaultDownloadHeaders` + `defaultDownloadCookies`（过滤非 ASCII 头，避免 reqwest panic）。
+31. 设置页从「5 张卡片」改为「连接 / 存储与上传 / 播放 / 搜索与下载 / 环境与诊断（折叠）」分组，并把「NAS 文件服务登录」并入存储分组。
+32. 主题一致性：删除 `border-white/10`、`bg-white` 等硬编码；滑块、均衡器、进度条全部走 `--primary` / `--muted` / `--background` token。
+33. 连接管理图标语义修正（激活用 `CircleCheck`、登出用 `LogOut`），全部 icon-only 按钮补齐 `title` + `aria-label`。
+34. 搜索历史下拉改为 `focusin/focusout` 容器判定，Tab 键可以进入历史项。
+
+### 9.2.1 飞牛上传链路：fnOS 文件服务 → WebDAV（最终形态）
+
+> 演进：multipart over WS 的 fnOS 文件服务存在会话易失、握手/登录协议联调困难等问题（三轮修复：
+> WS 读写分离与 Origin → 加密登录体补 `req`/`reqid` → 登录结果双通道等待），最终整体替换为 **WebDAV**。
+
+| 结论 | 说明 |
+|---|---|
+| **协议选型** | fnOS 提供的 SMB / WebDAV / FTP / NFS 中选 **WebDAV**：纯 HTTP 语义、reqwest 即可实现、Basic 认证随请求携带**无会话**（重启免登录）；SMB 的 Rust 客户端生态差、FTP 明文且被动模式易出问题、NFS 无 Windows 客户端方案 |
+| 后端实现 | `src-tauri/src/music/feiniu/webdav.rs`（`fnos.rs` 已删除）：`test`（PROPFIND Depth 0）/ `upload_file`（本地文件 128KB 分块流式 PUT）/ `delete`；上传前逐级 MKCOL 补目录 |
+| 「下载到飞牛」机制 | **与自动上传同链路**：正常走 musicdl 下载（引擎侧解析/代理/音质）→ 任务完成后扫描下载目录（下界=任务创建时刻）→ WebDAV 上传 → 删除本地音频及同名歌词/封面（`feiniu_delete_local`，扩展名白名单）→ 移除任务记录。失败时保留本地文件与任务记录供排查。早期的「URL 拉流直传」（`webdav_upload_from_url`）因可靠性不足已移除 |
+| 前端配置 | `feiniuStore.webdav = { url, username, password, dir }` 持久化 localStorage（`thing.music.feiniu.webdav`）；`webdavReady` 四项齐备才放行上传；设置页「存储与上传」分组内配置 + 「测试连接」 |
+| fnOS 侧设置 | 系统设置 → 文件服务 → WebDAV 开启（HTTP 5005 / HTTPS 5006）；目标文件夹在「可见文件夹范围」内；团队文件夹需勾选「允许通过文件共享协议挂载」；账号需读写权限（已写成设置页折叠提示） |
+| 路径语义 | 目标目录是 **WebDAV 根下的相对路径**（不是 NAS 内部绝对路径），URL 逐段百分号编码 |
+| 错误可读化 | 401 认证失败 / 403 无权限 / 404 目录不存在或不在可见范围 / 409 父目录不存在，均带上下文 |
+
+### 9.3 校验
+
+```
+vue-tsc --noEmit   → exit 0（0 error）
+vite build         → exit 0（11.5s）
+cargo check        → exit 0
+```
+
+### 9.4 仍未做的部分（建议后续）
+
+- 键盘全局快捷键（空格播放/暂停、↑↓ 选行）——需接入项目既有快捷键体系，避免与输入框冲突。
+- 列表虚拟滚动（当前为增量渲染，千级以上仍有优化空间）。
+- 歌单拖拽排序（`vue-draggable-plus` 已在依赖中，可直接接入）。
+- 本地文件的时长 / 内嵌封面解析（当前时长列退化为文件大小）。
+- 缓存模式改为「边下边播」的双源策略（当前 `cache` 模式首播仍需等整首下完）。
+
diff --git a/bun.lock b/bun.lock
index 2f69fb4..53b9ff5 100644
--- a/bun.lock
+++ b/bun.lock
@@ -16,6 +16,7 @@
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "pinia": "^3.0.4",
+        "pinyin-pro": "^3.28.2",
         "reka-ui": "^2.10.1",
         "tailwind-merge": "^3.6.0",
         "tailwindcss": "^4.3.2",
@@ -381,6 +382,8 @@
 
     "pinia": ["pinia@3.0.4", "https://registry.npmmirror.com/pinia/-/pinia-3.0.4.tgz", { "dependencies": { "@vue/devtools-api": "^7.7.7" }, "peerDependencies": { "typescript": ">=4.5.0", "vue": "^3.5.11" }, "optionalPeers": ["typescript"] }, "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw=="],
 
+    "pinyin-pro": ["pinyin-pro@3.29.4", "https://registry.npmmirror.com/pinyin-pro/-/pinyin-pro-3.29.4.tgz", {}, "sha512-SPXpDT2cHEy+d26V1RXYMlVzXN42hotFAak1fzyWPi4o2dKXb61UqD4pzxDJHwk6gbv8vQ6EfErd+hYX0Qhzug=="],
+
     "postcss": ["postcss@8.5.19", "https://registry.npmmirror.com/postcss/-/postcss-8.5.19.tgz", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ=="],
 
     "reka-ui": ["reka-ui@2.10.1", "https://registry.npmmirror.com/reka-ui/-/reka-ui-2.10.1.tgz", { "dependencies": { "@floating-ui/dom": "^1.6.13", "@floating-ui/vue": "^1.1.6", "@internationalized/date": "^3.5.0", "@internationalized/number": "^3.5.0", "@tanstack/vue-virtual": "^3.12.0", "@vueuse/core": "^14.1.0", "@vueuse/shared": "^14.1.0", "aria-hidden": "^1.2.4", "defu": "^6.1.5", "ohash": "^2.0.11" }, "peerDependencies": { "vue": ">= 3.4.0" } }, "sha512-drcOQ4rQtDYAcGCsyQBqQg8QQ+H3B+zDaMJU0h8KPEPMa7g9BHu3zcOi4OB39XJSWizceFoNO0Z9tctSGLOXqg=="],
diff --git a/music-redesign-mockup.html b/music-redesign-mockup.html
new file mode 100644
index 0000000..2583ec9
--- /dev/null
+++ b/music-redesign-mockup.html
@@ -0,0 +1,430 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>音乐模块 · 界面改版对照稿</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  :root{
+    --bg:#f4f4f5; --panel:#ffffff; --panel-2:#fafafa; --line:#e7e7e9; --line-2:#f0f0f1;
+    --fg:#18181b; --fg-2:#71717a; --fg-3:#a1a1aa;
+    --primary:#18181b; --primary-fg:#fafafa; --accent:#f4f4f5;
+    --ok:#0f7b4f; --warn:#9a3412; --err:#b91c1c;
+  }
+  body{
+    font-family: system-ui,-apple-system,"Segoe UI","Microsoft YaHei","PingFang SC",sans-serif;
+    background:var(--bg); color:var(--fg); font-size:13px; line-height:1.55; padding:28px 20px 60px;
+    -webkit-font-smoothing:antialiased;
+  }
+  .wrap{ max-width:1180px; margin:0 auto; }
+  h1{ font-size:19px; font-weight:600; letter-spacing:-.01em; }
+  .sub{ color:var(--fg-2); font-size:12.5px; margin-top:4px; }
+  .toolbar{ display:flex; align-items:center; gap:10px; margin:18px 0 14px; flex-wrap:wrap; }
+  .seg{ display:inline-flex; background:#e9e9eb; border-radius:8px; padding:3px; gap:2px; }
+  .seg button{
+    border:0; background:transparent; font:inherit; font-size:12.5px; color:var(--fg-2);
+    padding:6px 14px; border-radius:6px; cursor:pointer; transition:.15s;
+  }
+  .seg button.on{ background:#fff; color:var(--fg); font-weight:500; box-shadow:0 1px 2px rgba(0,0,0,.08); }
+  .hint{ color:var(--fg-3); font-size:12px; }
+
+  /* ---------- window frame ---------- */
+  .win{
+    background:var(--panel); border:1px solid var(--line); border-radius:11px; overflow:hidden;
+    box-shadow:0 8px 28px rgba(0,0,0,.07); display:flex; flex-direction:column; height:640px;
+  }
+  .titlebar{
+    height:38px; flex:0 0 38px; display:flex; align-items:center; gap:8px; padding:0 12px;
+    background:var(--panel-2); border-bottom:1px solid var(--line);
+  }
+  .dots{ display:flex; gap:5px; }
+  .dots i{ width:9px; height:9px; border-radius:50%; background:#dcdce0; display:block; }
+  .tb-title{ font-size:12px; color:var(--fg-2); margin-left:6px; }
+  .tb-tabs{ margin-left:auto; display:flex; gap:4px; }
+  .tb-tabs span{ font-size:11px; color:var(--fg-2); padding:3px 9px; border-radius:5px; }
+  .tb-tabs span.on{ background:#e9e9eb; color:var(--fg); }
+  .body{ flex:1; display:flex; min-height:0; }
+
+  /* ---------- left module rail ---------- */
+  .rail{
+    width:52px; flex:0 0 52px; border-right:1px solid var(--line); background:var(--panel-2);
+    display:flex; flex-direction:column; align-items:center; gap:4px; padding:10px 0;
+  }
+  .rail i{
+    width:32px; height:32px; border-radius:8px; background:#ececed; display:grid; place-items:center;
+    font-size:12px; color:var(--fg-2); font-style:normal;
+  }
+  .rail i.on{ background:var(--primary); color:#fff; }
+
+  /* ---------- source tree ---------- */
+  .tree{ width:186px; flex:0 0 186px; border-right:1px solid var(--line); padding:12px 10px; background:var(--panel); }
+  .tree h4{ font-size:11px; color:var(--fg-3); font-weight:500; padding:6px 8px 4px; letter-spacing:.03em; }
+  .tree a{
+    display:flex; align-items:center; gap:8px; padding:6px 8px; border-radius:6px;
+    color:var(--fg-2); text-decoration:none; font-size:12.5px; margin-bottom:1px;
+  }
+  .tree a.on{ background:#ececed; color:var(--fg); font-weight:500; }
+  .tree a b{ margin-left:auto; font-weight:400; font-size:11px; color:var(--fg-3); }
+
+  /* ---------- main ---------- */
+  .main{ flex:1; min-width:0; display:flex; flex-direction:column; background:var(--panel); }
+  .main-head{ padding:12px 16px 10px; border-bottom:1px solid var(--line-2); display:flex; align-items:center; gap:8px; }
+  .field{
+    height:30px; border:1px solid var(--line); border-radius:7px; background:#fff;
+    display:flex; align-items:center; padding:0 10px; color:var(--fg-3); font-size:12.5px; flex:1; max-width:330px;
+  }
+  .btn{ height:30px; padding:0 12px; border-radius:7px; border:1px solid var(--line); background:#fff; color:var(--fg); font-size:12.5px; display:inline-flex; align-items:center; gap:5px; }
+  .btn.dark{ background:var(--primary); color:#fff; border-color:var(--primary); }
+  .main-body{ flex:1; min-height:0; overflow:hidden; }
+  .thead{
+    display:grid; grid-template-columns:34px 44px minmax(0,3fr) minmax(0,2fr) 52px 34px;
+    gap:10px; align-items:center; padding:6px 16px; border-bottom:1px solid var(--line-2);
+    font-size:11px; color:var(--fg-3);
+  }
+  .row{
+    display:grid; grid-template-columns:34px 44px minmax(0,3fr) minmax(0,2fr) 52px 34px;
+    gap:10px; align-items:center; padding:5px 16px; height:44px; border-bottom:1px solid var(--line-2);
+  }
+  .row:hover{ background:var(--accent); }
+  .row.on{ background:#f4f4f5; }
+  .row.on .t1{ color:var(--fg); font-weight:500; }
+  .idx{ font-size:11.5px; color:var(--fg-3); text-align:right; }
+  .eq{ display:flex; align-items:flex-end; gap:2px; height:12px; }
+  .eq i{ width:2.5px; background:var(--primary); border-radius:1px; display:block; }
+  .eq i:nth-child(1){ height:5px } .eq i:nth-child(2){ height:11px } .eq i:nth-child(3){ height:8px }
+  .cov{ width:36px; height:36px; border-radius:6px; background:#e9e9eb; }
+  .t1{ font-size:13px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+  .t2{ font-size:11.5px; color:var(--fg-2); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+  .tag{ font-size:10px; padding:1px 6px; border-radius:4px; border:1px solid var(--line); color:var(--fg-2); white-space:nowrap; }
+  .tag.solid{ background:#ececed; border-color:transparent; }
+  .dur{ font-size:11.5px; color:var(--fg-3); font-variant-numeric:tabular-nums; text-align:right; }
+  .more{ color:var(--fg-3); text-align:center; opacity:0; }
+  .row:hover .more{ opacity:1; }
+
+  /* ---------- right now playing ---------- */
+  .np{ width:250px; flex:0 0 250px; border-left:1px solid var(--line); padding:16px; display:flex; flex-direction:column; gap:12px; background:var(--panel); }
+  .np-cover{ width:100%; aspect-ratio:1; border-radius:10px; background:linear-gradient(150deg,#e8e8ea,#d6d6da); }
+  .np h3{ font-size:14px; font-weight:500; }
+  .np p{ font-size:12px; color:var(--fg-2); }
+  .lyric{ display:flex; flex-direction:column; gap:7px; margin-top:4px; }
+  .lyric span{ font-size:12.5px; color:var(--fg-3); }
+  .lyric span.on{ font-size:14px; color:var(--fg); font-weight:500; }
+
+  /* ---------- player bar ---------- */
+  .player{
+    flex:0 0 72px; height:72px; border-top:1px solid var(--line); background:rgba(255,255,255,.92);
+    backdrop-filter:blur(12px); display:flex; align-items:center; gap:14px; padding:0 16px;
+  }
+  .pl-left{ width:236px; flex:0 0 236px; display:flex; align-items:center; gap:10px; min-width:0; }
+  .pl-left .cov{ width:44px; height:44px; border-radius:6px; }
+  .pl-mid{ flex:1; min-width:0; display:flex; flex-direction:column; align-items:center; gap:4px; }
+  .pl-ctrl{ display:flex; align-items:center; gap:16px; color:var(--fg-2); }
+  .pl-play{ width:34px; height:34px; border-radius:50%; background:var(--primary); color:#fff; display:grid; place-items:center; font-size:11px; }
+  .pl-seek{ width:100%; max-width:520px; display:flex; align-items:center; gap:8px; }
+  .pl-seek .time{ font-size:10.5px; color:var(--fg-3); font-variant-numeric:tabular-nums; width:34px; }
+  .track{ flex:1; height:4px; border-radius:2px; background:#e4e4e7; position:relative; }
+  .track .buf{ position:absolute; inset:0 auto 0 0; width:34%; background:#d4d4d8; border-radius:2px; }
+  .track .fill{ position:absolute; inset:0 auto 0 0; width:22%; background:var(--primary); border-radius:2px; }
+  .track .knob{ position:absolute; left:22%; top:50%; width:10px; height:10px; margin:-5px 0 0 -5px; border-radius:50%; background:var(--primary); }
+  .pl-right{ width:196px; flex:0 0 196px; display:flex; align-items:center; justify-content:flex-end; gap:10px; color:var(--fg-2); }
+  .vol{ width:76px; height:4px; border-radius:2px; background:#e4e4e7; position:relative; }
+  .vol i{ position:absolute; inset:0 auto 0 0; width:70%; background:var(--primary); border-radius:2px; display:block; }
+
+  /* ---------- before view ---------- */
+  .before-pad{ padding:22px 22px 0; flex:1; min-height:0; display:flex; flex-direction:column; gap:14px; overflow:hidden; }
+  .b-tabs{ display:grid; grid-template-columns:repeat(4,1fr); max-width:430px; background:#ececed; border-radius:8px; padding:3px; font-size:12.5px; text-align:center; }
+  .b-tabs span{ padding:5px 0; border-radius:6px; color:var(--fg-2); }
+  .b-tabs span.on{ background:#fff; color:var(--fg); font-weight:500; }
+  .b-card{ border:1px solid var(--line); border-radius:9px; padding:9px 12px; display:flex; align-items:center; gap:10px; font-size:12.5px; }
+  .b-card.muted{ background:#fafafa; }
+  .b-row{ border:1px solid var(--line); border-radius:9px; padding:9px 11px; display:flex; align-items:center; gap:11px; margin-bottom:7px; }
+  .b-sub{ display:inline-flex; gap:3px; background:#ececed; border-radius:7px; padding:3px; font-size:12px; }
+  .b-sub span{ padding:4px 11px; border-radius:5px; color:var(--fg-2); }
+  .b-sub span.on{ background:var(--primary); color:#fff; }
+  .b-player{ border-top:1px solid var(--line); margin:0 22px; padding:10px 0; display:flex; align-items:center; gap:12px; }
+  .mark{
+    width:17px; height:17px; border-radius:50%; background:#b91c1c; color:#fff; font-size:10.5px;
+    display:inline-grid; place-items:center; flex:0 0 17px; font-weight:500;
+  }
+  .mark.g{ background:#0f7b4f; }
+  .mark.amber{ background:#b45309; }
+
+  /* ---------- legend ---------- */
+  .legend{ margin-top:20px; display:grid; grid-template-columns:repeat(auto-fit,minmax(310px,1fr)); gap:10px; }
+  .li{ background:#fff; border:1px solid var(--line); border-radius:9px; padding:11px 13px; display:flex; gap:10px; }
+  .li b{ display:block; font-size:12.5px; font-weight:500; margin-bottom:2px; }
+  .li p{ font-size:12px; color:var(--fg-2); }
+  .hide{ display:none !important; }
+  .note{ font-size:11.5px; color:var(--fg-3); margin-top:6px; }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <h1>音乐模块 · 界面改版对照稿</h1>
+  <p class="sub">左边是当前实现的实际问题，右边是按建议方案重排后的目标形态。改版要点见下方图例。</p>
+
+  <div class="toolbar">
+    <div class="seg" id="seg">
+      <button data-v="before" class="on">当前实现</button>
+      <button data-v="after">建议方案</button>
+    </div>
+    <span class="hint" id="hint">红/橙标记 = 缺陷位置</span>
+  </div>
+
+  <!-- ================= BEFORE ================= -->
+  <div class="win" id="view-before">
+    <div class="titlebar">
+      <div class="dots"><i></i><i></i><i></i></div>
+      <span class="tb-title">Thing</span>
+      <div class="tb-tabs"><span class="on">我的音乐</span><span>发现音乐</span><span>下载任务</span><span>设置</span></div>
+    </div>
+    <div class="body">
+      <div class="rail">
+        <i class="on">音</i><i>载</i><i>监</i><i>代</i><i>设</i>
+      </div>
+      <div class="before-pad">
+        <div style="display:flex;align-items:center;gap:10px">
+          <div class="b-tabs">
+            <span class="on">我的音乐</span><span>发现音乐</span><span>下载任务</span><span>设置</span>
+          </div>
+        </div>
+
+        <div style="display:flex;align-items:center;gap:10px">
+          <span class="b-sub"><span class="on">飞牛曲库</span><span>本地曲库</span><span>我的歌单</span></span>
+          <span class="hint">← 第二套切换控件，与上一行风格不同</span>
+          <span class="mark" style="margin-left:auto">3</span>
+        </div>
+
+        <div class="b-card">
+          <span class="hint">下载到</span>
+          <span class="tag">本地目录 ▾</span>
+          <span class="hint">下载到本地目录（musicdl）</span>
+          <span class="mark" style="margin-left:auto">1</span>
+        </div>
+
+        <div style="display:flex;gap:8px;align-items:center">
+          <div class="field" style="max-width:none">输入歌名 / 歌手 / 专辑关键词</div>
+          <span class="tag">已选 3 个源 ▾</span>
+          <span class="btn dark">搜索</span>
+        </div>
+
+        <div class="b-card muted">
+          <span class="hint">粘贴歌单链接（网易云 / QQ 音乐等）</span>
+          <span class="btn" style="margin-left:auto">解析歌单</span>
+        </div>
+
+        <div style="margin-top:2px">
+          <div class="b-row">
+            <span class="tag">☐</span><div class="cov" style="width:38px;height:38px"></div>
+            <div style="flex:1;min-width:0">
+              <div class="t1">海阔天空 <span class="tag" style="color:#7c3aed">无损 flac 32.4 MB</span> <span class="tag" style="color:#0369a1">320K mp3</span> <span class="tag">+2</span></div>
+              <div class="t2">Beyond · 乐与怒</div>
+            </div>
+            <span class="tag">05:21</span><span class="tag">▷</span><span class="tag">⤓</span>
+            <span class="mark">2</span><span class="mark">5</span>
+          </div>
+          <div class="b-row">
+            <span class="tag">☐</span><div class="cov" style="width:38px;height:38px"></div>
+            <div style="flex:1;min-width:0">
+              <div class="t1">光辉岁月 <span class="tag" style="color:#b45309">Hi-Res flac 96.1 MB</span> <span class="tag" style="color:#a16207">192K mp3</span></div>
+              <div class="t2">Beyond · 命运派对</div>
+            </div>
+            <span class="tag">04:58</span><span class="tag">▷</span><span class="tag">⤓</span>
+            <span class="mark">2</span>
+          </div>
+          <div class="b-row">
+            <span class="tag">☐</span><div class="cov" style="width:38px;height:38px"></div>
+            <div style="flex:1;min-width:0">
+              <div class="t1">喜欢你</div><div class="t2">Beyond · 秘密警察</div>
+            </div>
+            <span class="tag">04:35</span><span class="tag">▷</span><span class="tag">⤓</span>
+            <span class="mark">6</span>
+          </div>
+          <span class="note">每行都是独立圆角卡片 + 8px 间距；一行内 6~8 个视觉元素，彩色徽标抢过歌名。</span>
+        </div>
+      </div>
+    </div>
+    <div class="b-player">
+      <div class="cov" style="width:44px;height:44px;border-radius:6px"></div>
+      <div style="min-width:0;max-width:150px">
+        <div class="t1">未播放</div><div class="t2">选择一首歌曲开始播放</div>
+      </div>
+      <div style="flex:1;display:flex;flex-direction:column;align-items:center;gap:4px">
+        <div class="pl-ctrl" style="font-size:13px"><span>⟳</span><span>⏮</span><span class="pl-play">▶</span><span>⏭</span><span>☰</span></div>
+        <div class="pl-seek" style="max-width:360px">
+          <span class="time">--:--</span>
+          <div class="track"><div class="fill" style="width:0"></div><div class="knob" style="left:0"></div></div>
+          <span class="time">--:--</span>
+        </div>
+      </div>
+      <div class="pl-right"><span>🔊</span><div class="vol"><i></i></div><span>词</span><span>⤢</span></div>
+      <span class="mark" style="position:absolute">4</span>
+    </div>
+    <div style="position:relative">
+      <span class="mark" style="position:absolute;right:14px;bottom:44px">7</span>
+      <span class="mark" style="position:absolute;left:14px;bottom:60px">8</span>
+    </div>
+  </div>
+
+  <!-- ================= AFTER ================= -->
+  <div class="win hide" id="view-after">
+    <div class="titlebar">
+      <div class="dots"><i></i><i></i><i></i></div>
+      <span class="tb-title">Thing</span>
+      <div class="tb-tabs"><span class="on">曲库</span><span>发现音乐</span><span>下载任务</span><span>设置</span></div>
+      <span class="mark g" style="margin-left:8px">3</span>
+    </div>
+    <div class="body">
+      <div class="rail">
+        <i class="on">音</i><i>载</i><i>监</i><i>代</i><i>设</i>
+      </div>
+
+      <div class="tree">
+        <h4>曲库</h4>
+        <a class="on">飞牛曲库 <b>1.2k</b></a>
+        <a>本地曲库 <b>318</b></a>
+        <a>我的歌单 <b>7</b></a>
+        <h4>其他</h4>
+        <a>发现音乐</a>
+        <a>下载任务 <b>2</b></a>
+        <a>设置</a>
+        <span class="mark g" style="margin:10px 0 0 8px">3</span>
+      </div>
+
+      <div class="main">
+        <div class="main-head">
+          <div class="field">搜索歌名 / 歌手 / 专辑</div>
+          <span class="tag">全部来源 ▾</span>
+          <span class="tag">全部音质 ▾</span>
+          <span class="btn" style="margin-left:auto">排序 ▾</span>
+          <span class="btn">扫描本地</span>
+          <span class="btn dark">▶ 播放全部</span>
+          <span class="mark g" style="margin-left:6px">1</span>
+        </div>
+        <div class="main-body">
+          <div class="thead">
+            <span style="text-align:right">#</span><span></span><span>标题</span><span>专辑</span><span style="text-align:right">时长</span><span></span>
+          </div>
+          <div class="row on">
+            <span class="idx"><span class="eq"><i></i><i></i><i></i></span></span>
+            <div class="cov"></div>
+            <div style="min-width:0">
+              <div class="t1">海阔天空</div>
+              <div class="t2">Beyond · 1993</div>
+            </div>
+            <div class="t2">乐与怒</div>
+            <span class="dur">05:21</span>
+            <span class="more">⋯</span>
+          </div>
+          <div class="row">
+            <span class="idx">2</span>
+            <div class="cov"></div>
+            <div style="min-width:0"><div class="t1">光辉岁月</div><div class="t2">Beyond</div></div>
+            <div class="t2">命运派对</div>
+            <span class="dur">04:58</span>
+            <span class="more">⋯</span>
+          </div>
+          <div class="row">
+            <span class="idx">3</span>
+            <div class="cov"></div>
+            <div style="min-width:0"><div class="t1">喜欢你</div><div class="t2">Beyond</div></div>
+            <div class="t2">秘密警察</div>
+            <span class="dur">04:35</span>
+            <span class="more">⋯</span>
+          </div>
+          <div class="row">
+            <span class="idx">4</span>
+            <div class="cov"></div>
+            <div style="min-width:0"><div class="t1">冷雨夜</div><div class="t2">Beyond</div></div>
+            <div class="t2">现代舞台</div>
+            <span class="dur">04:12</span>
+            <span class="more">⋯</span>
+          </div>
+          <div class="row">
+            <span class="idx">5</span>
+            <div class="cov"></div>
+            <div style="min-width:0"><div class="t1">真的爱你</div><div class="t2">Beyond</div></div>
+            <div class="t2">Beyond IV</div>
+            <span class="dur">04:41</span>
+            <span class="more">⋯</span>
+          </div>
+          <div style="padding:8px 16px" class="note">
+            行高 44px、无独立边框、hover 高亮、双击整行播放；播放中行用主色竖条 + 均衡器表示，不再用“选中框”。
+            <span class="mark g">2</span>
+          </div>
+        </div>
+      </div>
+
+      <div class="np">
+        <div class="np-cover"></div>
+        <div>
+          <h3>海阔天空</h3>
+          <p>Beyond · 乐与怒</p>
+        </div>
+        <div class="track" style="height:4px"><div class="fill" style="width:38%"></div><div class="knob" style="left:38%"></div></div>
+        <div class="lyric">
+          <span>今天我 寒夜里看雪飘过</span>
+          <span>怀着冷却了的心窝漂远方</span>
+          <span class="on">风雨里追赶 雾里分不清影踪</span>
+          <span>天空海阔你与我</span>
+          <span>可会变（谁没在变）</span>
+        </div>
+        <span class="note">右栏“正在播放”可折叠（窄窗口自动收起）</span>
+      </div>
+    </div>
+
+    <div class="player">
+      <div class="pl-left">
+        <div class="cov"></div>
+        <div style="min-width:0">
+          <div class="t1">海阔天空</div>
+          <div class="t2">Beyond · 乐与怒</div>
+        </div>
+        <span class="mark g" style="margin-left:auto">4</span>
+      </div>
+      <div class="pl-mid">
+        <div class="pl-ctrl"><span>🔀</span><span>⏮</span><span class="pl-play">❚❚</span><span>⏭</span><span>☰</span></div>
+        <div class="pl-seek">
+          <span class="time">01:12</span>
+          <div class="track"><div class="buf"></div><div class="fill"></div><div class="knob"></div></div>
+          <span class="time">05:21</span>
+        </div>
+        <span class="note" style="margin:0">拖动只更新预览，松手才 seek；轨道含缓冲层，hover 加粗到 8px</span>
+      </div>
+      <div class="pl-right">
+        <span class="mark g">5</span>
+        <span>🔊</span><div class="vol"><i></i></div><span>詞</span><span>⤢</span>
+      </div>
+    </div>
+  </div>
+
+  <div class="legend" id="legend">
+    <div class="li"><span class="mark">1</span><div><b>首屏信息层级</b><p>“下载到 本地/飞牛”不再独占一行卡片，收进工具栏；搜索框回到首行黄金位置。</p></div></div>
+    <div class="li"><span class="mark">2</span><div><b>列表密度与徽标降噪</b><p>卡片堆 → 44px 紧凑表格行；音质徽标从 5 色降为 1 类中性 outline，档位详情收进 ⋯ 菜单。</p></div></div>
+    <div class="li"><span class="mark">3</span><div><b>两级横向 Tab → 左侧来源树</b><p>模块级 Tab + 子 Tab 合并为一条来源树，导航层级从三层降到两层。</p></div></div>
+    <div class="li"><span class="mark g">4</span><div><b>播放条全宽贴底</b><p>MiniPlayer 提升到 App 全局层：任何模块都能控制播放；离开音乐模块不再丢失控制入口。</p></div></div>
+    <div class="li"><span class="mark g">5</span><div><b>进度与音量交互</b><p>提交式 seek + 缓冲进度层；音量图标可点静音；滑块配色改走主题 token（原为硬编码纯白）。</p></div></div>
+    <div class="li"><span class="mark">6</span><div><b>来源与来源标识统一</b><p>本地/NAS/歌单混排时用统一图标标识来源，不再靠行内小标签。</p></div></div>
+    <div class="li"><span class="mark">7</span><div><b>内边距不对称</b><p>模块左 28px / 右 40px（含滚动条），卡片右边距明显偏窄；统一为 24px 并保留滚动条槽位。</p></div></div>
+    <div class="li"><span class="mark">8</span><div><b>播放条未贴底</b><p>被模块 p-6 包住，分隔线左右各缩进 24px，读作“漂浮卡片”而非底部坞站。</p></div></div>
+  </div>
+</div>
+
+<script>
+  var seg = document.getElementById('seg');
+  var before = document.getElementById('view-before');
+  var after = document.getElementById('view-after');
+  var hint = document.getElementById('hint');
+  seg.addEventListener('click', function (e) {
+    var b = e.target.closest('button');
+    if (!b) return;
+    var v = b.getAttribute('data-v');
+    seg.querySelectorAll('button').forEach(function (x) { x.classList.toggle('on', x === b); });
+    before.classList.toggle('hide', v !== 'before');
+    after.classList.toggle('hide', v !== 'after');
+    hint.textContent = v === 'before' ? '红/橙标记 = 缺陷位置' : '绿色标记 = 改版要点';
+  });
+</script>
+</body>
+</html>
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index e63c544..c6f403d 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -2865,6 +2865,18 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "keyring"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
+dependencies = [
+ "byteorder",
+ "log",
+ "windows-sys 0.60.2",
+ "zeroize",
+]
+
 [[package]]
 name = "kqueue"
 version = "1.2.0"
@@ -6149,6 +6161,7 @@ dependencies = [
  "futures-util",
  "hmac",
  "image",
+ "keyring",
  "librqbit",
  "md-5",
  "notify",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 3a078b4..645db3e 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -60,6 +60,8 @@ windows-capture = "2.0.1"
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.52"
+# WebDAV 凭据加密存储（Windows 凭据管理器，DPAPI 保护，不落明文）
+keyring = { version = "3", features = ["windows-native"] }
 raw-window-handle = "0.6"
 windows-sys = { version = "0.52", features = [
     "Win32_Networking_WinInet",
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 42f82f0..862e5ae 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -44,14 +44,13 @@ use monitor_kernel::{
 };
 use music::{
     feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
-    feiniu_delete_connection, feiniu_fnconnect_resolve, feiniu_fnos_delete, feiniu_fnos_list,
-    feiniu_fnos_login, feiniu_fnos_logout, feiniu_fnos_status, feiniu_fnos_upload,
-    feiniu_get_config, feiniu_list_connections, feiniu_list_tracks, feiniu_login, feiniu_logout,
-    feiniu_lyric, feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local,
-    feiniu_test_connection, music_cancel_runtime_install, music_download, music_download_cancel,
-    music_env_status, music_get_settings, music_get_sources, music_install_runtime,
-    music_parse_playlist, music_ping, music_resolve, music_save_settings, music_search,
-    music_stop_bridge, MusicManager,
+    feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+    feiniu_list_connections, feiniu_list_tracks, feiniu_login, feiniu_logout, feiniu_lyric,
+    feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
+    music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
+    music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
+    music_resolve, music_save_settings, music_search, music_stop_bridge, webdav_delete,
+    webdav_get_secret, webdav_save_secret, webdav_test, webdav_upload, MusicManager,
 };
 use network_monitor::network_status;
 use osd_window::{
@@ -287,13 +286,13 @@ pub fn run() {
             feiniu_cache_status,
             feiniu_cache_clear,
             feiniu_cache_fetch,
-            feiniu_fnos_login,
-            feiniu_fnos_logout,
-            feiniu_fnos_status,
-            feiniu_fnos_upload,
-            feiniu_fnos_delete,
-            feiniu_fnos_list,
             feiniu_fnconnect_resolve,
+            webdav_test,
+            webdav_upload,
+            webdav_delete,
+            webdav_get_secret,
+            webdav_save_secret,
+            feiniu_delete_local,
             network_status,
             osd_apply_overlay_style,
             osd_begin_drag,
diff --git a/src-tauri/src/music/commands.rs b/src-tauri/src/music/commands.rs
index a40e54c..de76f9b 100644
--- a/src-tauri/src/music/commands.rs
+++ b/src-tauri/src/music/commands.rs
@@ -437,102 +437,132 @@ fn new_conn_id() -> String {
     format!("c{n:x}")
 }
 
-// ============ P6：下载到飞牛 + 曲库增删（fnOS 文件服务） ============
+// ============ P6：下载到飞牛 + 曲库增删（WebDAV，无状态） ============
 
-/// fnOS 登录：为某连接建立 NAS 文件服务会话（WS + RSA/AES）。成功后不持久化凭据。
+/// 测试 WebDAV 连接与目标目录是否可达。
 #[tauri::command]
-pub async fn feiniu_fnos_login(
-    state: State<'_, MusicManager>,
-    connection_id: String,
-    username: String,
-    password: String,
+#[specta::specta]
+pub async fn webdav_test(
+    config: crate::music::feiniu::webdav::WebDavConfig,
+    dir: String,
 ) -> Result<serde_json::Value, String> {
-    let settings = state.load_settings();
-    let conn = settings
-        .feiniu_connections
-        .iter()
-        .find(|c| c.id == connection_id)
-        .cloned()
-        .ok_or_else(|| "连接不存在".to_string())?;
-    state
-        .feiniu
-        .fnos_login(&connection_id, &conn.base_url, &username, &password)
-        .await?;
-    Ok(json!({ "ok": true }))
+    let msg = crate::music::feiniu::webdav::test(&config, &dir).await?;
+    Ok(json!({ "ok": true, "message": msg }))
 }
 
-/// 登出 fnOS 文件服务会话。
+/// 上传本地文件到 WebDAV 目标目录（流式，不整载内存）。
 #[tauri::command]
-pub fn feiniu_fnos_logout(
-    state: State<'_, MusicManager>,
-    connection_id: String,
-) -> Result<serde_json::Value, String> {
-    state.feiniu.fnos_logout(&connection_id);
-    Ok(json!({ "ok": true }))
-}
-
-/// fnOS 文件服务登录状态：{ loggedIn }（按连接）。
-#[tauri::command]
-pub fn feiniu_fnos_status(
-    state: State<'_, MusicManager>,
-    connection_id: String,
-) -> Result<serde_json::Value, String> {
-    Ok(json!({ "loggedIn": state.feiniu.fnos_logged_in(&connection_id) }))
-}
-
-/// 上传本地文件到 NAS（激活连接的 fnOS 会话）。返回上传文件名。
-#[tauri::command]
-pub async fn feiniu_fnos_upload(
-    state: State<'_, MusicManager>,
+#[specta::specta]
+pub async fn webdav_upload(
+    config: crate::music::feiniu::webdav::WebDavConfig,
     local_path: String,
-    nas_path: String,
+    remote_path: String,
 ) -> Result<serde_json::Value, String> {
-    let settings = state.load_settings();
-    let conn = settings
-        .feiniu_connections
-        .iter()
-        .find(|c| c.id == settings.feiniu_active_id)
-        .cloned()
-        .ok_or_else(|| "没有激活连接".to_string())?;
-    let name = state
-        .feiniu
-        .fnos_upload(&conn.id, std::path::Path::new(&local_path), &nas_path)
-        .await?;
+    let name = crate::music::feiniu::webdav::upload_file(
+        &config,
+        std::path::Path::new(&local_path),
+        &remote_path,
+    )
+    .await?;
     Ok(json!({ "ok": true, "name": name }))
 }
 
-/// 删除 NAS 文件（激活连接的 fnOS 会话）。
+/// 删除 WebDAV 远程文件（404 视为已删除）。
 #[tauri::command]
-pub async fn feiniu_fnos_delete(
-    state: State<'_, MusicManager>,
-    nas_path: String,
+#[specta::specta]
+pub async fn webdav_delete(
+    config: crate::music::feiniu::webdav::WebDavConfig,
+    remote_path: String,
 ) -> Result<serde_json::Value, String> {
-    let settings = state.load_settings();
-    let conn = settings
-        .feiniu_connections
-        .iter()
-        .find(|c| c.id == settings.feiniu_active_id)
-        .cloned()
-        .ok_or_else(|| "没有激活连接".to_string())?;
-    state.feiniu.fnos_delete(&conn.id, &nas_path).await?;
+    crate::music::feiniu::webdav::delete(&config, &remote_path).await?;
     Ok(json!({ "ok": true }))
 }
 
-/// 列出 NAS 目录（激活连接的 fnOS 会话）。
+// ============ WebDAV 凭据加密存储（Windows 凭据管理器，DPAPI 保护） ============
+
+/// 凭据以 JSON blob 存入系统凭据管理器：{"username","password"}。
+/// 明文仅存在于内存与系统凭据库，绝不写回 localStorage / 配置文件。
+#[cfg(windows)]
+const WEBDAV_SECRET_SERVICE: &str = "Thing";
+#[cfg(windows)]
+const WEBDAV_SECRET_USER: &str = "webdav-credentials";
+
+#[cfg(windows)]
+fn webdav_secret_entry() -> Result<keyring::Entry, String> {
+    keyring::Entry::new(WEBDAV_SECRET_SERVICE, WEBDAV_SECRET_USER)
+        .map_err(|e| format!("无法访问系统凭据管理器: {e}"))
+}
+
+#[cfg(windows)]
+fn webdav_secret_read() -> Result<Option<serde_json::Value>, String> {
+    let entry = webdav_secret_entry()?;
+    match entry.get_password() {
+        Ok(blob) => serde_json::from_str(&blob)
+            .map(Some)
+            .map_err(|e| format!("凭据数据损坏: {e}")),
+        // 未配置过凭据不算错误
+        Err(keyring::Error::NoEntry) => Ok(None),
+        Err(e) => Err(format!("读取凭据失败: {e}")),
+    }
+}
+
+#[cfg(windows)]
+fn webdav_secret_write(username: &str, password: &str) -> Result<(), String> {
+    let blob = json!({ "username": username, "password": password }).to_string();
+    let entry = webdav_secret_entry()?;
+    entry.set_password(&blob).map_err(|e| format!("保存凭据失败: {e}"))
+}
+
+/// 读取 WebDAV 凭据。未配置时 username/password 为 null。
 #[tauri::command]
-pub async fn feiniu_fnos_list(
-    state: State<'_, MusicManager>,
-    path: String,
-) -> Result<serde_json::Value, String> {
-    let settings = state.load_settings();
-    let conn = settings
-        .feiniu_connections
-        .iter()
-        .find(|c| c.id == settings.feiniu_active_id)
-        .cloned()
-        .ok_or_else(|| "没有激活连接".to_string())?;
-    let v = state.feiniu.fnos_list(&conn.id, &path).await?;
-    Ok(v)
+pub fn webdav_get_secret() -> Result<serde_json::Value, String> {
+    #[cfg(windows)]
+    {
+        Ok(webdav_secret_read()?.unwrap_or_else(|| json!({ "username": null, "password": null })))
+    }
+    #[cfg(not(windows))]
+    {
+        Ok(json!({ "username": null, "password": null }))
+    }
+}
+
+/// 保存 WebDAV 凭据（账号 + 密码整体覆盖）。
+#[tauri::command]
+pub fn webdav_save_secret(username: String, password: String) -> Result<serde_json::Value, String> {
+    #[cfg(windows)]
+    {
+        webdav_secret_write(&username, &password)?;
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = (&username, &password);
+    }
+    Ok(json!({ "ok": true }))
+}
+
+/// 删除本地媒体文件（「下载到飞牛」落地即传流程的收尾）。
+/// 仅允许音频 / 歌词 / 封面扩展名，且拒绝目录——防止前端误删任意文件。
+#[tauri::command]
+#[specta::specta]
+pub fn feiniu_delete_local(path: String) -> Result<serde_json::Value, String> {
+    const ALLOWED: [&str; 13] = [
+        "mp3", "flac", "wav", "m4a", "aac", "ogg", "ape", "wma", "lrc", "jpg", "jpeg", "png", "webp",
+    ];
+    let p = std::path::Path::new(&path);
+    let ext_ok = p
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| ALLOWED.contains(&e.to_lowercase().as_str()))
+        .unwrap_or(false);
+    if !ext_ok {
+        return Err(format!("拒绝删除非媒体文件：{path}"));
+    }
+    let meta = std::fs::metadata(p).map_err(|e| format!("文件不存在: {e}"))?;
+    if meta.is_dir() {
+        return Err("拒绝删除目录".to_string());
+    }
+    std::fs::remove_file(p).map_err(|e| format!("删除失败: {e}"))?;
+    Ok(json!({ "ok": true }))
 }
 
 // ============ P7：FnConnect 远程连接解析 ============
diff --git a/src-tauri/src/music/feiniu/fnos.rs b/src-tauri/src/music/feiniu/fnos.rs
deleted file mode 100644
index 1b2fcd2..0000000
--- a/src-tauri/src/music/feiniu/fnos.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-//! fnOS 文件服务客户端（WebSocket 协议 + HTTP 上传）。
-//!
-//! 协议参照 `FNOSP/fnnas-api`：
-//! 1. 连接 `ws://{host}:{port}/websocket?type=main`
-//! 2. `util.crypto.getRSAPub` 取 RSA 公钥与 si
-//! 3. `user.login`：随机 AES key/iv，AES-CBC 加密登录体 + RSA 加密 key，发 `{"req":"encrypted",...}`
-//! 4. 之后每个请求 `{base64(HMAC-SHA256(json))}{json}` 签名
-//! 5. 上传：WS `file.checkUpload` → HTTP `POST /upload`（Trim-Token/Trim-Path/Trim-Sign）
-//! 6. 删除：WS `file.rm`
-//!
-//! 仅支持 http://（ws://）直连；https/frp 的文件上传留待后续。
-
-use std::collections::HashMap;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-use aes::cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
-use aes::Aes256;
-use base64::Engine;
-use futures_util::{SinkExt, StreamExt};
-use hmac::{Hmac, Mac};
-use rand::RngCore;
-use rsa::pkcs8::DecodePublicKey;
-use rsa::{Pkcs1v15Encrypt, RsaPublicKey};
-use serde_json::{json, Value};
-use sha2::Sha256;
-use tokio_tungstenite::tungstenite::Message;
-use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
-
-type HmacSha256 = Hmac<Sha256>;
-type WsStream = WebSocketStream<MaybeTlsStream<tokio::net::TcpStream>>;
-
-const KEY_CHARS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-fn random_key() -> String {
-    let mut rng = rand::thread_rng();
-    (0..32)
-        .map(|_| {
-            let i = rng.next_u64() as usize % KEY_CHARS.len();
-            KEY_CHARS[i] as char
-        })
-        .collect()
-}
-
-fn random_iv() -> [u8; 16] {
-    let mut iv = [0u8; 16];
-    rand::thread_rng().fill_bytes(&mut iv);
-    iv
-}
-
-/// 手动 AES-256-CBC 加密（避免 cbc crate trait 兼容问题），PKCS7 填充，返回 base64。
-fn aes_cbc_encrypt_b64(data: &[u8], key: &[u8; 32], iv: &[u8; 16]) -> String {
-    let cipher = Aes256::new(key.into());
-    let mut padded = data.to_vec();
-    let pad_len = 16 - (padded.len() % 16);
-    padded.extend(std::iter::repeat(pad_len as u8).take(pad_len));
-    let mut out = Vec::with_capacity(padded.len());
-    let mut prev = *iv;
-    for chunk in padded.chunks(16) {
-        let mut block = [0u8; 16];
-        for i in 0..16 {
-            block[i] = chunk[i] ^ prev[i];
-        }
-        cipher.encrypt_block((&mut block).into());
-        out.extend_from_slice(&block);
-        prev = block;
-    }
-    base64::engine::general_purpose::STANDARD.encode(out)
-}
-
-/// AES-256-CBC 解密 → 返回 base64(明文)（对齐 fnnas-api 的 aes_decrypt）。
-fn aes_cbc_decrypt_b64(ciphertext_b64: &str, key: &[u8; 32], iv: &[u8; 16]) -> Result<String, String> {
-    let ct = base64::engine::general_purpose::STANDARD
-        .decode(ciphertext_b64)
-        .map_err(|e| format!("AES 密文解码失败: {e}"))?;
-    let cipher = Aes256::new(key.into());
-    let mut prev = *iv;
-    let mut plain = Vec::with_capacity(ct.len());
-    for chunk in ct.chunks(16) {
-        let mut block = [0u8; 16];
-        block.copy_from_slice(chunk);
-        let enc = block;
-        cipher.decrypt_block((&mut block).into());
-        for i in 0..16 {
-            plain.push(block[i] ^ prev[i]);
-        }
-        prev = enc;
-    }
-    // 去 PKCS7 填充
-    if let Some(&last) = plain.last() {
-        let n = last as usize;
-        if n > 0 && n <= 16 && plain.len() >= n && plain[plain.len() - n..].iter().all(|&b| b == last) {
-            plain.truncate(plain.len() - n);
-        }
-    }
-    Ok(base64::engine::general_purpose::STANDARD.encode(plain))
-}
-
-fn rsa_encrypt_b64(pub_pem: &str, data: &str) -> Result<String, String> {
-    let key = RsaPublicKey::from_public_key_pem(pub_pem)
-        .map_err(|e| format!("解析 RSA 公钥失败: {e}"))?;
-    let mut rng = rand::thread_rng();
-    let ct = key
-        .encrypt(&mut rng, Pkcs1v15Encrypt, data.as_bytes())
-        .map_err(|e| format!("RSA 加密失败: {e}"))?;
-    Ok(base64::engine::general_purpose::STANDARD.encode(ct))
-}
-
-fn hmac_sha256_b64(key: &[u8], data: &str) -> String {
-    let mut mac = <HmacSha256 as Mac>::new_from_slice(key).expect("hmac key");
-    mac.update(data.as_bytes());
-    base64::engine::general_purpose::STANDARD.encode(mac.finalize().into_bytes())
-}
-
-fn reqid() -> String {
-    let n = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis())
-        .unwrap_or(0);
-    format!("0000000000000000{n:x}")
-}
-
-fn ws_url(base_url: &str) -> String {
-    let u = base_url.trim_end_matches('/');
-    u.replacen("http://", "ws://", 1) + "/websocket?type=main"
-}
-
-    /// 一次 fnOS 会话（登录后复用；命令层按 connection 存于 Feiniu）。
-pub struct FnOsSession {
-    pub base_url: String,
-    token: Mutex<String>,
-    sign_key: Mutex<Vec<u8>>,
-    ws: Arc<tokio::sync::Mutex<Option<WsStream>>>,
-    pending: Arc<Mutex<HashMap<String, tokio::sync::oneshot::Sender<Value>>>>,
-    reader: Arc<AtomicBool>,
-}
-
-impl FnOsSession {
-    /// 建立会话（新 WS 连接 + 登录）。
-    pub async fn connect(base_url: &str, username: &str, password: &str) -> Result<Self, String> {
-        let url = ws_url(base_url);
-        let (ws, _) = connect_async(&url)
-            .await
-            .map_err(|e| format!("连接 fnOS WebSocket 失败: {e}"))?;
-        let session = Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            token: Mutex::new(String::new()),
-            sign_key: Mutex::new(Vec::new()),
-            ws: Arc::new(tokio::sync::Mutex::new(Some(ws))),
-            pending: Arc::new(Mutex::new(HashMap::new())),
-            reader: Arc::new(AtomicBool::new(false)),
-        };
-        session.login(username, password).await?;
-        Ok(session)
-    }
-
-    pub fn token(&self) -> String {
-        self.token.lock().unwrap_or_else(|e| e.into_inner()).clone()
-    }
-
-    fn ensure_reader(&self) {
-        if self.reader.swap(true, Ordering::SeqCst) {
-            return;
-        }
-        let ws = self.ws.clone();
-        let pending = self.pending.clone();
-        tokio::spawn(async move {
-            loop {
-                let msg = {
-                    let mut guard = ws.lock().await;
-                    let Some(stream) = guard.as_mut() else { break };
-                    match stream.next().await {
-                        Some(Ok(m)) => m,
-                        _ => break,
-                    }
-                };
-                if let Message::Text(text) = msg {
-                    if let Ok(v) = serde_json::from_str::<Value>(&text) {
-                        if let Some(rid) = v["reqid"].as_str() {
-                            if let Some(sender) =
-                                pending.lock().unwrap_or_else(|e| e.into_inner()).remove(rid)
-                            {
-                                let _ = sender.send(v);
-                            }
-                        }
-                    }
-                }
-            }
-            let pendings: Vec<_> = pending
-                .lock()
-                .unwrap_or_else(|e| e.into_inner())
-                .drain()
-                .map(|(_, s)| s)
-                .collect();
-            for s in pendings {
-                let _ = s.send(Value::Null);
-            }
-        });
-    }
-
-    /// 发送签名请求并等待响应。
-    async fn request(&self, req: &str, data: Value) -> Result<Value, String> {
-        self.ensure_reader();
-        let rid = reqid();
-        let mut body = json!({ "req": req, "reqid": rid });
-        if let Value::Object(map) = data {
-            for (k, v) in map {
-                body[k] = v;
-            }
-        }
-        let json_str = serde_json::to_string(&body).map_err(|e| e.to_string())?;
-        let sign_key = self.sign_key.lock().unwrap_or_else(|e| e.into_inner()).clone();
-        let message = if sign_key.is_empty() {
-            json_str.clone()
-        } else {
-            hmac_sha256_b64(&sign_key, &json_str) + &json_str
-        };
-
-        let (tx, rx) = tokio::sync::oneshot::channel::<Value>();
-        self.pending
-            .lock()
-            .unwrap_or_else(|e| e.into_inner())
-            .insert(rid.clone(), tx);
-        {
-            let mut guard = self.ws.lock().await;
-            let stream = guard
-                .as_mut()
-                .ok_or_else(|| "fnOS 连接已断开".to_string())?;
-            stream
-                .send(Message::Text(message.into()))
-                .await
-                .map_err(|e| format!("发送请求失败: {e}"))?;
-        }
-
-        let resp = tokio::time::timeout(Duration::from_secs(10), rx)
-            .await
-            .map_err(|_| "fnOS 请求超时".to_string())?
-            .map_err(|_| "fnOS 请求通道关闭".to_string())?;
-        if resp.is_null() {
-            return Err("fnOS 连接已断开".to_string());
-        }
-        if let Some(errno) = resp["errno"].as_i64() {
-            if errno != 0 {
-                return Err(format!("fnOS 请求失败（errno {errno}）"));
-            }
-        }
-        Ok(resp)
-    }
-
-    async fn login(&self, username: &str, password: &str) -> Result<(), String> {
-        let resp = self.request("util.crypto.getRSAPub", Value::Null).await?;
-        let pub_pem = resp["pub"].as_str().ok_or("getRSAPub 未返回 pub")?.to_string();
-        let si = resp["si"].as_str().unwrap_or("").to_string();
-
-        let key = random_key();
-        let iv = random_iv();
-        let login_body = json!({
-            "user": username,
-            "password": password,
-            "deviceType": "Browser",
-            "deviceName": "Thing Client",
-            "stay": false,
-            "si": si,
-        });
-        let json_str = serde_json::to_string(&login_body).map_err(|e| e.to_string())?;
-        let key_bytes: [u8; 32] = key
-            .as_bytes()
-            .try_into()
-            .map_err(|_| "AES 密钥长度错误".to_string())?;
-        let aes_b64 = aes_cbc_encrypt_b64(json_str.as_bytes(), &key_bytes, &iv);
-        let rsa_b64 = rsa_encrypt_b64(&pub_pem, &key)?;
-        let enc = json!({
-            "req": "encrypted",
-            "iv": base64::engine::general_purpose::STANDARD.encode(iv),
-            "rsa": rsa_b64,
-            "aes": aes_b64,
-        });
-        let resp = self.request("encrypted", enc).await?;
-        let token = resp["token"].as_str().ok_or("fnOS 登录未返回 token")?.to_string();
-        let secret = resp["secret"].as_str().ok_or("fnOS 登录未返回 secret")?.to_string();
-        let secret_dec = aes_cbc_decrypt_b64(&secret, &key_bytes, &iv)?;
-        let sign_key = base64::engine::general_purpose::STANDARD
-            .decode(&secret_dec)
-            .map_err(|e| format!("sign_key base64 解码失败: {e}"))?;
-        *self.token.lock().unwrap_or_else(|e| e.into_inner()) = token;
-        *self.sign_key.lock().unwrap_or_else(|e| e.into_inner()) = sign_key;
-        Ok(())
-    }
-
-    /// `file.checkUpload`：返回 uploadName。
-    pub async fn check_upload(&self, nas_path: &str, size: u64, overwrite: u32) -> Result<String, String> {
-        let resp = self
-            .request(
-                "file.checkUpload",
-                json!({ "size": size, "path": nas_path, "overwrite": overwrite }),
-            )
-            .await?;
-        resp["uploadName"]
-            .as_str()
-            .map(|s| s.to_string())
-            .ok_or_else(|| "checkUpload 未返回 uploadName".to_string())
-    }
-
-    /// `file.rm`：删除 NAS 文件（移入回收站）。
-    pub async fn delete_file(&self, nas_path: &str) -> Result<(), String> {
-        let name = nas_path.rsplit('/').next().unwrap_or(nas_path).to_string();
-        self.request(
-            "file.rm",
-            json!({
-                "files": [nas_path],
-                "moveToTrashbin": true,
-                "details": { "name": name, "count": 1, "dir": 0 },
-            }),
-        )
-        .await?;
-        Ok(())
-    }
-
-    /// `file.ls`：列出目录。
-    pub async fn list(&self, path: &str) -> Result<Value, String> {
-        self.request("file.ls", json!({ "path": path })).await
-    }
-}
-
-/// HTTP 上传到 NAS（需要已登录的 session）。返回上传后的文件名。
-pub async fn upload_file(
-    session: &FnOsSession,
-    local_path: &std::path::Path,
-    nas_path: &str,
-    overwrite: u32,
-) -> Result<String, String> {
-    let size = std::fs::metadata(local_path)
-        .map_err(|e| format!("读取本地文件失败: {e}"))?
-        .len();
-    let upload_name = session.check_upload(nas_path, size, overwrite).await?;
-    let parent = nas_path.rsplit('/').nth(1).unwrap_or("").to_string();
-    let trim_path = if parent.is_empty() {
-        upload_name.clone()
-    } else {
-        format!("{parent}/{upload_name}")
-    };
-    let mtim = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_secs())
-        .unwrap_or(0)
-        .to_string();
-    let sign_key = session.sign_key.lock().unwrap_or_else(|e| e.into_inner()).clone();
-    let trim_sign = hmac_sha256_b64(&sign_key, &trim_path);
-    let token = session.token();
-
-    let file_name = local_path
-        .file_name()
-        .and_then(|n| n.to_str())
-        .unwrap_or("music.bin")
-        .to_string();
-    let bytes = std::fs::read(local_path).map_err(|e| format!("读取本地文件失败: {e}"))?;
-    let mime = guess_mime(local_path);
-    let form = reqwest::multipart::Form::new().part(
-        "trim-upload-file",
-        reqwest::multipart::Part::bytes(bytes)
-            .file_name(file_name)
-            .mime_str(mime)
-            .map_err(|e| e.to_string())?,
-    );
-
-    let client = reqwest::Client::builder()
-        .no_proxy()
-        .timeout(Duration::from_secs(300))
-        .build()
-        .map_err(|e| e.to_string())?;
-    let resp = client
-        .post(format!("{}/upload", session.base_url))
-        .header("Trim-Token", token)
-        .header("Trim-Path", trim_path)
-        .header("Trim-Sign", trim_sign)
-        .header("Trim-Mtim", mtim)
-        .header("Trim-Overwrite", overwrite.to_string())
-        .header("Referer", format!("{}/", session.base_url))
-        .header("User-Agent", "Thing/1.0")
-        .header("Accept", "application/json, text/plain, */*")
-        .multipart(form)
-        .send()
-        .await
-        .map_err(|e| format!("上传请求失败: {e}"))?;
-    let status = resp.status();
-    if !status.is_success() {
-        let body = resp.text().await.unwrap_or_default();
-        return Err(format!("上传失败（HTTP {status}）: {body}"));
-    }
-    Ok(upload_name)
-}
-
-fn guess_mime(p: &std::path::Path) -> &'static str {
-    match p
-        .extension()
-        .and_then(|e| e.to_str())
-        .map(|e| e.to_lowercase())
-        .as_deref()
-    {
-        Some("mp3") => "audio/mpeg",
-        Some("flac") => "audio/flac",
-        Some("wav") => "audio/wav",
-        Some("m4a") => "audio/mp4",
-        Some("aac") => "audio/aac",
-        Some("ogg") => "audio/ogg",
-        Some("ape") => "audio/x-ape",
-        _ => "application/octet-stream",
-    }
-}
\ No newline at end of file
diff --git a/src-tauri/src/music/feiniu/mod.rs b/src-tauri/src/music/feiniu/mod.rs
index fd7e1f0..5833c85 100644
--- a/src-tauri/src/music/feiniu/mod.rs
+++ b/src-tauri/src/music/feiniu/mod.rs
@@ -5,7 +5,6 @@
 //! 对照 FeiNiuMusic(Flutter) `api_client.dart` 的第三方纯前端实现翻译。
 //! 所有对 NAS 的 HTTP 请求在本模块收敛（页面/命令层不直接发请求）。
 
-use std::collections::HashMap;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -21,12 +20,11 @@ pub use conn::normalize_base_url;
 mod cache;
 mod conn;
 mod fnconnect;
-mod fnos;
 pub mod proxy;
+pub mod webdav;
 
 pub use cache::CacheManager;
 pub use fnconnect::{extract_fn_id, resolve_base_url};
-pub use fnos::FnOsSession;
 
 use conn::{generate_device_id, sha256_hex};
 use proxy::{ProxyCfg, ProxyShared};
@@ -90,8 +88,6 @@ pub struct Feiniu {
     conn: Mutex<Conn>,
     proxy: Mutex<Option<(u16, ProxyShared)>>,
     cache: CacheManager,
-    /// fnOS 文件服务会话：connection id → 会话
-    fnos_sessions: Mutex<HashMap<String, Arc<FnOsSession>>>,
 }
 
 impl Default for Feiniu {
@@ -108,7 +104,6 @@ impl Default for Feiniu {
             }),
             proxy: Mutex::new(None),
             cache: CacheManager::new(Path::new("placeholder")), // 由 set_cache_root 重建
-            fnos_sessions: Mutex::new(HashMap::new()),
         }
     }
 }
@@ -435,76 +430,8 @@ impl Feiniu {
         Ok(self.cache.hit(guid))
     }
 
-    // ===== fnOS 文件服务（P6：上传/删除） =====
-
-    /// fnOS 登录：为指定连接建立文件服务会话。
-    pub async fn fnos_login(
-        &self,
-        connection_id: &str,
-        base_url: &str,
-        username: &str,
-        password: &str,
-    ) -> Result<(), String> {
-        let session = Arc::new(FnOsSession::connect(base_url, username, password).await?);
-        if let Ok(mut m) = self.fnos_sessions.lock() {
-            m.insert(connection_id.to_string(), session);
-        }
-        Ok(())
-    }
-
-    pub fn fnos_logout(&self, connection_id: &str) {
-        if let Ok(mut m) = self.fnos_sessions.lock() {
-            m.remove(connection_id);
-        }
-    }
-
-    pub fn fnos_logged_in(&self, connection_id: &str) -> bool {
-        self.fnos_sessions
-            .lock()
-            .map(|m| m.contains_key(connection_id))
-            .unwrap_or(false)
-    }
-
-    /// 上传本地文件到 NAS（走 fnOS 会话；会话缺失返回 Err）。
-    pub async fn fnos_upload(
-        &self,
-        connection_id: &str,
-        local_path: &std::path::Path,
-        nas_path: &str,
-    ) -> Result<String, String> {
-        let session = self
-            .fnos_sessions
-            .lock()
-            .map(|m| m.get(connection_id).cloned())
-            .ok()
-            .flatten()
-            .ok_or_else(|| "请先登录 NAS 文件服务（设置 → 连接 → fnOS 登录）")?;
-        fnos::upload_file(&session, local_path, nas_path, 2).await
-    }
-
-    /// 删除 NAS 文件。
-    pub async fn fnos_delete(&self, connection_id: &str, nas_path: &str) -> Result<(), String> {
-        let session = self
-            .fnos_sessions
-            .lock()
-            .map(|m| m.get(connection_id).cloned())
-            .ok()
-            .flatten()
-            .ok_or_else(|| "请先登录 NAS 文件服务")?;
-        session.delete_file(nas_path).await
-    }
-
-    /// 列出 NAS 目录。
-    pub async fn fnos_list(&self, connection_id: &str, path: &str) -> Result<Value, String> {
-        let session = self
-            .fnos_sessions
-            .lock()
-            .map(|m| m.get(connection_id).cloned())
-            .ok()
-            .flatten()
-            .ok_or_else(|| "请先登录 NAS 文件服务")?;
-        session.list(path).await
-    }
+    // ===== WebDAV 传输（下载到飞牛 / 曲库增删）=====
+    // 无状态：配置由前端每次调用传入，实现在 webdav 模块，命令层直接调用。
 
     async fn ensure_proxy(&self) -> Result<u16, String> {
         if let Ok(g) = self.proxy.lock() {
diff --git a/src-tauri/src/music/feiniu/webdav.rs b/src-tauri/src/music/feiniu/webdav.rs
new file mode 100644
index 0000000..2f3f995
--- /dev/null
+++ b/src-tauri/src/music/feiniu/webdav.rs
@@ -0,0 +1,217 @@
+//! WebDAV 客户端（无状态）——用于把音乐传输到 fnOS NAS 的曲库目录。
+//!
+//! 选择 WebDAV 而非 SMB/FTP/NFS 的原因：
+//! - 纯 HTTP 语义，`reqwest` 即可实现，无原生依赖（SMB 在 Rust 侧生态差）；
+//! - **无会话**：Basic 认证随每个请求携带，没有"重启后要重新登录"的问题；
+//! - fnOS 原生支持：系统设置 → 文件服务 → WebDAV（HTTP 5005 / HTTPS 5006）。
+//!
+//! fnOS 侧需要的设置（作为 UI 提示展示）：
+//! 1. 开启 WebDAV 服务并记下端口；
+//! 2. 目标文件夹必须在「可见文件夹范围」内（团队文件夹需勾选
+//!    「允许通过文件共享协议(SMB、WebDAV、FTP)挂载到其他设备上」）；
+//! 3. 账号对该文件夹有读写权限。
+
+use bytes::Bytes;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+/// WebDAV 连接配置（由前端每次调用时传入，后端不持有状态）。
+#[derive(Debug, Clone, Deserialize, Serialize, specta::Type)]
+pub struct WebDavConfig {
+    /// 服务地址，如 `http://192.168.110.100:5005`
+    pub url: String,
+    pub username: String,
+    pub password: String,
+}
+
+/// WebDAV 操作结果状态码相关的可读错误。
+fn status_err(action: &str, status: u16, url: &str) -> String {
+    match status {
+        401 => format!("WebDAV 认证失败（401）：请检查账号与密码"),
+        403 => format!("WebDAV 拒绝访问（403）：账号可能没有该目录的写入权限"),
+        404 => format!("WebDAV 目标不存在（404）：{url}（目录需要先在 NAS 上创建，且在 WebDAV 可见范围内）"),
+        409 => format!("WebDAV 父目录不存在（409）：{url}"),
+        _ => format!("WebDAV {action}失败（HTTP {status}）：{url}"),
+    }
+}
+
+fn dav_client(_cfg: &WebDavConfig) -> Result<reqwest::Client, String> {
+    // NAS 通常在内网，默认禁用系统代理（走代理会连不上）；Basic 认证在请求级设置
+    reqwest::Client::builder()
+        .timeout(Duration::from_secs(600))
+        .connect_timeout(Duration::from_secs(10))
+        .no_proxy()
+        .build()
+        .map_err(|e| e.to_string())
+}
+
+/// 拼接 WebDAV 完整 URL：base + 远程路径（逐段百分号编码，保留 `/`）。
+fn dav_url(cfg: &WebDavConfig, remote_path: &str) -> String {
+    let base = cfg.url.trim_end_matches('/');
+    let path = remote_path.trim_start_matches('/');
+    let encoded: Vec<String> = path
+        .split('/')
+        .filter(|s| !s.is_empty())
+        .map(|seg| {
+            let mut out = String::new();
+            for b in seg.bytes() {
+                match b {
+                    b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                        out.push(b as char)
+                    }
+                    _ => out.push_str(&format!("%{b:02X}")),
+                }
+            }
+            out
+        })
+        .collect();
+    format!("{base}/{}", encoded.join("/"))
+}
+
+fn with_auth(mut rb: reqwest::RequestBuilder, cfg: &WebDavConfig) -> reqwest::RequestBuilder {
+    if !cfg.username.is_empty() {
+        rb = rb.basic_auth(&cfg.username, Some(&cfg.password));
+    }
+    rb
+}
+
+/// 逐级 MKCOL 创建远程目录（已存在会被忽略）。
+async fn ensure_dirs(cfg: &WebDavConfig, remote_path: &str) -> Result<(), String> {
+    let path = remote_path.trim_start_matches('/');
+    let segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
+    // 最后一段是文件名，只建目录部分
+    let dirs: Vec<String> = segs
+        .iter()
+        .take(segs.len().saturating_sub(1))
+        .fold(Vec::new(), |mut acc, s| {
+            let prev = acc.last().cloned().unwrap_or_default();
+            acc.push(if prev.is_empty() {
+                s.to_string()
+            } else {
+                format!("{prev}/{s}")
+            });
+            acc
+        });
+    let client = dav_client(cfg)?;
+    for d in dirs {
+        let url = dav_url(cfg, &d);
+        let method = reqwest::Method::from_bytes(b"MKCOL").expect("MKCOL 是合法的 HTTP 方法");
+        let resp = with_auth(client.request(method, &url), cfg)
+            .send()
+            .await
+            .map_err(|e| format!("WebDAV MKCOL 失败: {e}"))?;
+        // 201 创建成功；405 已存在；其余只记不阻断（权限问题会在 PUT 时暴露）
+        let code = resp.status().as_u16();
+        if code != 201 && code != 405 && code != 301 && code != 409 && code != 200 {
+            return Err(status_err("创建目录", code, &url));
+        }
+    }
+    Ok(())
+}
+
+/// 测试连接：PROPFIND 目标目录（Depth 0）。成功返回目录确认信息。
+pub async fn test(cfg: &WebDavConfig, dir: &str) -> Result<String, String> {
+    let url = dav_url(cfg, dir);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(
+        client
+            .request(reqwest::Method::from_bytes(b"PROPFIND").unwrap(), &url)
+            .header("Depth", "0")
+            .body(String::new()),
+        cfg,
+    )
+    .send()
+    .await
+    .map_err(|e| format!("无法连接 WebDAV 服务：{e}（请确认地址与端口）"))?;
+    let code = resp.status().as_u16();
+    match code {
+        207 | 200 => Ok(format!("连接成功：{url}")),
+        404 => Err(format!(
+            "WebDAV 服务可达，但目标目录不存在（404）：{url}\n请先在 NAS 上创建该目录，并确认它在 WebDAV「可见文件夹范围」内"
+        )),
+        401 => Err("WebDAV 认证失败（401）：请检查账号与密码".to_string()),
+        403 => Err("WebDAV 拒绝访问（403）：账号可能没有该目录的读取权限".to_string()),
+        _ => Err(status_err("连接", code, &url)),
+    }
+}
+
+/// 上传本地文件（流式读取，不整载内存）。返回远程路径。
+pub async fn upload_file(
+    cfg: &WebDavConfig,
+    local_path: &std::path::Path,
+    remote_path: &str,
+) -> Result<String, String> {
+    ensure_dirs(cfg, remote_path).await?;
+    let file = tokio::fs::File::open(local_path)
+        .await
+        .map_err(|e| format!("读取本地文件失败: {e}"))?;
+    // 128KB 分块流：用 unfold 把 AsyncRead 转 Stream，避免引入 tokio-util
+    let stream = futures_util::stream::unfold(file, |mut f| async move {
+        use tokio::io::AsyncReadExt;
+        let mut buf = vec![0u8; 128 * 1024];
+        match f.read(&mut buf).await {
+            Ok(0) => None,
+            Ok(n) => Some((Ok::<Bytes, std::io::Error>(Bytes::copy_from_slice(&buf[..n])), f)),
+            Err(e) => Some((Err(e), f)),
+        }
+    });
+    let url = dav_url(cfg, remote_path);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(client.put(&url), cfg)
+        .header("Content-Type", mime_of(remote_path))
+        .body(reqwest::Body::wrap_stream(stream))
+        .send()
+        .await
+        .map_err(|e| format!("WebDAV 上传失败: {e}"))?;
+    let code = resp.status().as_u16();
+    if !(200..300).contains(&code) {
+        return Err(status_err("上传", code, &url));
+    }
+    Ok(remote_path.to_string())
+}
+
+/// 删除远程文件（404 视为已删除）。
+pub async fn delete(cfg: &WebDavConfig, remote_path: &str) -> Result<(), String> {
+    let url = dav_url(cfg, remote_path);
+    let client = dav_client(cfg)?;
+    let resp = with_auth(client.delete(&url), cfg)
+        .send()
+        .await
+        .map_err(|e| format!("WebDAV 删除失败: {e}"))?;
+    let code = resp.status().as_u16();
+    if code == 404 {
+        return Ok(());
+    }
+    if !(200..300).contains(&code) {
+        return Err(status_err("删除", code, &url));
+    }
+    Ok(())
+}
+
+pub fn mime_of(name: &str) -> &'static str {
+    let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+    match ext.as_str() {
+        "mp3" => "audio/mpeg",
+        "flac" => "audio/flac",
+        "wav" => "audio/wav",
+        "m4a" => "audio/mp4",
+        "aac" => "audio/aac",
+        "ogg" => "audio/ogg",
+        "ape" => "audio/x-ape",
+        _ => "application/octet-stream",
+    }
+}
+
+/// 保留给调用方校验配置完整性。
+pub fn validate(cfg: &WebDavConfig, dir: &str) -> Result<(), String> {
+    if cfg.url.trim().is_empty() {
+        return Err("请先填写 WebDAV 服务地址（如 http://192.168.110.100:5005）".into());
+    }
+    if cfg.username.trim().is_empty() {
+        return Err("请先填写 WebDAV 账号".into());
+    }
+    if dir.trim().is_empty() {
+        return Err("请先填写 WebDAV 曲库目标目录".into());
+    }
+    Ok(())
+}
diff --git a/src-tauri/src/music/mod.rs b/src-tauri/src/music/mod.rs
index f47b8d9..a13ddaa 100644
--- a/src-tauri/src/music/mod.rs
+++ b/src-tauri/src/music/mod.rs
@@ -24,14 +24,13 @@ pub use feiniu::{extract_fn_id, normalize_base_url, resolve_base_url, Feiniu, Fe
 
 pub use commands::{
     feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
-    feiniu_delete_connection, feiniu_fnconnect_resolve, feiniu_fnos_delete, feiniu_fnos_list,
-    feiniu_fnos_login, feiniu_fnos_logout, feiniu_fnos_status, feiniu_fnos_upload,
-    feiniu_get_config, feiniu_list_connections, feiniu_list_tracks, feiniu_login, feiniu_logout,
-    feiniu_lyric, feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local,
-    feiniu_test_connection, music_cancel_runtime_install, music_download, music_download_cancel,
-    music_env_status, music_get_settings, music_get_sources, music_install_runtime,
-    music_parse_playlist, music_ping, music_resolve, music_save_settings, music_search,
-    music_stop_bridge,
+    feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+    feiniu_list_connections, feiniu_list_tracks, feiniu_login, feiniu_logout, feiniu_lyric,
+    feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
+    music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
+    music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
+    music_resolve, music_save_settings, music_search, music_stop_bridge, webdav_delete,
+    webdav_get_secret, webdav_save_secret, webdav_test, webdav_upload,
 };
 
 use serde::{Deserialize, Serialize};
diff --git a/src/App.vue b/src/App.vue
index 0b09f67..8c9a15c 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -5,8 +5,10 @@ import { getCurrentWindow } from '@tauri-apps/api/window'
 import TitleBar from '@/components/layout/TitleBar.vue'
 import Sidebar from '@/components/layout/Sidebar.vue'
 import ModuleContainer from '@/components/layout/ModuleContainer.vue'
+import NowPlayingDialog from '@/components/layout/NowPlayingDialog.vue'
 import { Toaster } from '@/components/ui/sonner'
 import { useAppStore } from '@/stores/appStore'
+import { useFeiniuStore } from '@/stores/feiniuStore'
 import { useScreenshotStore } from '@/stores/screenshotStore'
 import { useQuickPanelStore } from '@/stores/quickpanelStore'
 import { useMonitorStore } from '@/stores/monitorStore'
@@ -19,6 +21,7 @@ import { EVENTS, STORAGE_KEYS, WINDOWS } from '@/lib/constants'
 import { commands } from '@/lib/bindings'
 
 const appStore = useAppStore()
+const feiniuStore = useFeiniuStore()
 const screenshotStore = useScreenshotStore()
 const quickpanelStore = useQuickPanelStore()
 const monitorStore = useMonitorStore()
@@ -197,6 +200,9 @@ const resolveDefaultModule = (): string => {
 onMounted(async () => {
   await appStore.init().catch(e => console.error('App init error:', e))
 
+  // 全局播放器：恢复队列/音量/播放模式等本地状态（幂等，音乐模块内会再次调用但不会重复执行）
+  feiniuStore.init().catch(e => console.error('播放器初始化失败:', e))
+
   // 初始化监控 store：订阅后端 monitor-data / monitor-network 等事件，
   // 使 OSD 窗口在应用启动后即可接收数据流，不依赖用户手动打开监控模块。
   // init() 幂等：MonitorModule 挂载时再次调用不会重复订阅。
@@ -283,7 +289,7 @@ onUnmounted(() => {
   <TooltipProvider>
     <div class="flex flex-col h-screen w-screen overflow-hidden">
       <TitleBar :modules="availableModules" @search="handleSearch" />
-      <div class="flex-1 flex overflow-hidden">
+      <div class="flex-1 flex overflow-hidden min-h-0">
         <Sidebar
           :modules="availableModules"
           :active-module="activeModule"
@@ -292,6 +298,7 @@ onUnmounted(() => {
         <ModuleContainer :active-component="activeComponent" :active-module="activeModule" :loading="moduleLoading" />
       </div>
     </div>
+    <NowPlayingDialog />
     <Toaster position="bottom-right" rich-colors close-button :style="{ zIndex: 99999 }" />
   </TooltipProvider>
 </template>
diff --git a/src/components/common/ScrubBar.vue b/src/components/common/ScrubBar.vue
new file mode 100644
index 0000000..fe78dca
--- /dev/null
+++ b/src/components/common/ScrubBar.vue
@@ -0,0 +1,293 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+/**
+ * 通用拖拽进度条。
+ *
+ * 关键行为：拖动过程中**不**向外提交，只更新本地预览值；
+ * 指针抬起（或键盘操作）时才 emit `seek`。
+ * 这样流式音频不会因为拖动而反复中断并重建 Range 请求。
+ */
+const props = withDefaults(
+  defineProps<{
+    /** 当前进度 0~1 */
+    value: number
+    /** 已缓冲比例 0~1 */
+    buffered?: number
+    /** 总秒数：>0 时显示两侧时间与拖动气泡 */
+    durationSec?: number
+    /** 紧凑模式（音量条）：细轨道、无时间、无气泡 */
+    compact?: boolean
+    disabled?: boolean
+    /** 无障碍标签 */
+    label?: string
+  }>(),
+  { buffered: 0, durationSec: 0, compact: false, disabled: false, label: '进度' }
+)
+
+const emit = defineEmits<{ seek: [ratio: number] }>()
+
+const rootRef = ref<HTMLElement | null>(null)
+const dragging = ref(false)
+const dragRatio = ref(0)
+const hoverRatio = ref<number | null>(null)
+
+function clamp(v: number) {
+  return Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0))
+}
+function pct(v: number) {
+  return `${clamp(v) * 100}%`
+}
+const activeRatio = computed(() => (dragging.value ? dragRatio.value : clamp(props.value)))
+const bubbleRatio = computed(() => (dragging.value ? dragRatio.value : hoverRatio.value))
+const showTime = computed(() => !props.compact && props.durationSec > 0)
+
+function ratioFromClientX(clientX: number) {
+  const el = rootRef.value
+  if (!el) return 0
+  const r = el.getBoundingClientRect()
+  if (r.width <= 0) return 0
+  return clamp((clientX - r.left) / r.width)
+}
+
+function fmt(sec: number) {
+  if (!Number.isFinite(sec) || sec < 0) return '--:--'
+  const s = Math.floor(sec)
+  const h = Math.floor(s / 3600)
+  const m = Math.floor((s % 3600) / 60)
+  const r = s % 60
+  if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${String(r).padStart(2, '0')}`
+  return `${String(m).padStart(2, '0')}:${String(r).padStart(2, '0')}`
+}
+
+function onDown(e: PointerEvent) {
+  if (props.disabled) return
+  const el = e.currentTarget as HTMLElement
+  dragging.value = true
+  dragRatio.value = ratioFromClientX(e.clientX)
+  try {
+    el.focus({ preventScroll: true })
+    el.setPointerCapture(e.pointerId)
+  } catch {
+    /* 部分环境不支持指针捕获/聚焦，降级为普通拖动 */
+  }
+  e.preventDefault()
+}
+
+function onMove(e: PointerEvent) {
+  const r = ratioFromClientX(e.clientX)
+  hoverRatio.value = r
+  if (dragging.value) dragRatio.value = r
+}
+
+function onUp(e: PointerEvent) {
+  if (!dragging.value) return
+  dragging.value = false
+  dragRatio.value = ratioFromClientX(e.clientX)
+  emit('seek', dragRatio.value)
+}
+
+function onLeave() {
+  if (!dragging.value) hoverRatio.value = null
+}
+
+function onKey(e: KeyboardEvent) {
+  if (props.disabled) return
+  const step = e.shiftKey ? 0.1 : 0.02
+  let next: number | null = null
+  if (e.key === 'ArrowRight' || e.key === 'ArrowUp') next = clamp(props.value + step)
+  else if (e.key === 'ArrowLeft' || e.key === 'ArrowDown') next = clamp(props.value - step)
+  else if (e.key === 'Home') next = 0
+  else if (e.key === 'End') next = 1
+  if (next !== null) {
+    emit('seek', next)
+    e.preventDefault()
+  }
+}
+</script>
+
+<template>
+  <div
+    class="scrub"
+    :class="{ 'is-compact': compact, 'is-dragging': dragging, 'is-disabled': disabled }"
+  >
+    <span v-if="showTime" class="scrub-time">{{ fmt(activeRatio * durationSec) }}</span>
+
+    <div
+      ref="rootRef"
+      class="scrub-track"
+      role="slider"
+      :tabindex="disabled ? -1 : 0"
+      :aria-label="label"
+      :aria-valuenow="Math.round(activeRatio * 100)"
+      aria-valuemin="0"
+      aria-valuemax="100"
+      :aria-disabled="disabled"
+      @pointerdown="onDown"
+      @pointermove="onMove"
+      @pointerup="onUp"
+      @pointercancel="onUp"
+      @pointerleave="onLeave"
+      @keydown="onKey"
+    >
+      <span class="scrub-buffered" :style="{ width: pct(buffered) }" />
+      <span class="scrub-played" :style="{ width: pct(activeRatio) }" />
+      <span class="scrub-thumb" :style="{ left: pct(activeRatio) }" />
+      <span
+        v-if="showTime && bubbleRatio !== null"
+        class="scrub-bubble"
+        :style="{ left: pct(bubbleRatio) }"
+      >
+        {{ fmt(bubbleRatio * durationSec) }}
+      </span>
+    </div>
+
+    <span v-if="showTime" class="scrub-time">{{ fmt(durationSec) }}</span>
+  </div>
+</template>
+
+<style scoped>
+.scrub {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  width: 100%;
+  min-width: 0;
+}
+
+.scrub-time {
+  font-size: 11px;
+  color: var(--muted-foreground);
+  font-variant-numeric: tabular-nums;
+  flex: 0 0 auto;
+  min-width: 38px;
+  text-align: center;
+  user-select: none;
+}
+.scrub-time:first-child {
+  text-align: right;
+}
+
+.scrub-track {
+  position: relative;
+  flex: 1 1 auto;
+  min-width: 0;
+  height: 16px;
+  display: flex;
+  align-items: center;
+  cursor: pointer;
+  touch-action: none;
+  outline: none;
+}
+
+/* 视觉轨道（高 4px，hover / 拖动时增到 7px） */
+.scrub-track::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  right: 0;
+  height: 4px;
+  border-radius: 999px;
+  background: var(--muted);
+  transition: height 0.15s ease;
+}
+.scrub:hover .scrub-track::before,
+.scrub.is-dragging .scrub-track::before {
+  height: 7px;
+}
+.scrub-track:focus-visible::before {
+  box-shadow: 0 0 0 3px color-mix(in oklab, var(--ring) 45%, transparent);
+}
+
+.scrub-buffered,
+.scrub-played {
+  position: absolute;
+  left: 0;
+  height: 4px;
+  border-radius: 999px;
+  transition: height 0.15s ease;
+}
+.scrub:hover .scrub-buffered,
+.scrub.is-dragging .scrub-buffered,
+.scrub:hover .scrub-played,
+.scrub.is-dragging .scrub-played {
+  height: 7px;
+}
+.scrub-buffered {
+  background: color-mix(in oklab, var(--muted-foreground) 28%, transparent);
+}
+.scrub-played {
+  background: var(--primary);
+}
+
+.scrub-thumb {
+  position: absolute;
+  top: 50%;
+  width: 12px;
+  height: 12px;
+  margin: -6px 0 0 -6px;
+  border-radius: 50%;
+  background: var(--primary);
+  box-shadow: 0 0 0 2px var(--background);
+  opacity: 0;
+  transition: opacity 0.15s ease, transform 0.15s ease;
+  pointer-events: none;
+}
+.scrub:hover .scrub-thumb,
+.scrub.is-dragging .scrub-thumb,
+.scrub-track:focus-visible .scrub-thumb {
+  opacity: 1;
+}
+.scrub.is-dragging .scrub-thumb {
+  transform: scale(1.15);
+}
+
+.scrub-bubble {
+  position: absolute;
+  bottom: 18px;
+  transform: translateX(-50%);
+  padding: 2px 6px;
+  border-radius: 5px;
+  background: var(--popover);
+  color: var(--popover-foreground);
+  border: 1px solid var(--border);
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  pointer-events: none;
+  white-space: nowrap;
+}
+
+.scrub.is-compact .scrub-time {
+  display: none;
+}
+.scrub.is-compact .scrub-track {
+  height: 14px;
+}
+.scrub.is-compact .scrub-track::before,
+.scrub.is-compact .scrub-buffered,
+.scrub.is-compact .scrub-played {
+  height: 4px;
+}
+.scrub.is-compact:hover .scrub-track::before,
+.scrub.is-compact:hover .scrub-buffered,
+.scrub.is-compact:hover .scrub-played,
+.scrub.is-compact.is-dragging .scrub-track::before,
+.scrub.is-compact.is-dragging .scrub-buffered,
+.scrub.is-compact.is-dragging .scrub-played {
+  height: 6px;
+}
+
+.scrub.is-disabled {
+  opacity: 0.5;
+  pointer-events: none;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .scrub-track::before,
+  .scrub-buffered,
+  .scrub-played,
+  .scrub-thumb {
+    transition: none;
+  }
+}
+</style>
diff --git a/src/components/common/SegmentedNav.vue b/src/components/common/SegmentedNav.vue
new file mode 100644
index 0000000..3e758cf
--- /dev/null
+++ b/src/components/common/SegmentedNav.vue
@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import type { Component } from 'vue'
+
+export interface SegmentedItem {
+  value: string
+  label: string
+  /** lucide 图标组件 */
+  icon?: Component
+  /** 右侧计数徽标 */
+  count?: number
+}
+
+/** 模块内统一的分段导航（替代此前并存的三套切换控件） */
+defineProps<{
+  modelValue: string
+  items: SegmentedItem[]
+  /** 铺满容器宽度（等分） */
+  block?: boolean
+}>()
+
+const emit = defineEmits<{ 'update:modelValue': [value: string] }>()
+</script>
+
+<template>
+  <div
+    class="inline-flex items-center rounded-lg bg-muted p-0.5"
+    :class="block ? 'flex w-full' : 'w-fit'"
+    role="tablist"
+  >
+    <button
+      v-for="item in items"
+      :key="item.value"
+      type="button"
+      role="tab"
+      :aria-selected="modelValue === item.value"
+      class="flex min-w-0 flex-1 items-center justify-center gap-1.5 rounded-[7px] px-3 py-1.5 text-[13px] transition-colors duration-150 outline-none focus-visible:ring-2 focus-visible:ring-ring/50"
+      :class="
+        modelValue === item.value
+          ? 'bg-background font-medium text-foreground shadow-sm'
+          : 'text-muted-foreground hover:text-foreground'
+      "
+      @click="emit('update:modelValue', item.value)"
+    >
+      <component :is="item.icon" v-if="item.icon" class="size-3.5 shrink-0" />
+      <span class="truncate">{{ item.label }}</span>
+      <span
+        v-if="item.count"
+        class="shrink-0 rounded-full bg-muted px-1.5 text-[10px] tabular-nums text-muted-foreground"
+        :class="modelValue === item.value ? 'bg-muted' : 'bg-background/70'"
+      >
+        {{ item.count }}
+      </span>
+    </button>
+  </div>
+</template>
diff --git a/src/components/layout/NowPlayingDialog.vue b/src/components/layout/NowPlayingDialog.vue
new file mode 100644
index 0000000..526aa73
--- /dev/null
+++ b/src/components/layout/NowPlayingDialog.vue
@@ -0,0 +1,319 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { Music2, Pause, Play, Plus, Repeat, Repeat1, Shuffle, SkipBack, SkipForward, Trash2, X } from '@lucide/vue'
+import { useFeiniuStore } from '@/stores/feiniuStore'
+import ScrubBar from '@/components/common/ScrubBar.vue'
+import SegmentedNav from '@/components/common/SegmentedNav.vue'
+import { Dialog, DialogContent, DialogClose, DialogTitle } from '@/components/ui/dialog'
+import { ScrollArea } from '@/components/ui/scroll-area'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+
+const store = useFeiniuStore()
+
+const coverUrl = computed(() => {
+  const t = store.nowPlaying
+  if (!t) return ''
+  if (t.coverUrl) return t.coverUrl
+  if (t.source === 'feiniu' && t.coverId && store.mediaPrefix) {
+    return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(t.coverId)}&size=400`
+  }
+  return ''
+})
+const coverFailed = ref(false)
+watch(coverUrl, () => (coverFailed.value = false))
+
+const isPreview = computed(() => store.nowPlaying?.source === 'preview')
+const hasTrack = computed(() => !!store.nowPlaying)
+
+const modeIcon = computed(() => {
+  if (store.playMode === 'loopOne') return Repeat1
+  if (store.playMode === 'shuffle') return Shuffle
+  return Repeat
+})
+const modeLabel = computed(() =>
+  store.playMode === 'loopAll' ? '列表循环' : store.playMode === 'loopOne' ? '单曲循环' : '随机播放'
+)
+
+const tabs = computed(() => [
+  { value: 'lyric', label: '歌词' },
+  { value: 'queue', label: `队列` }
+])
+const activeTab = computed({
+  get: () => store.nowPlayingTab,
+  set: (v: string) => (store.nowPlayingTab = v === 'queue' ? 'queue' : 'lyric')
+})
+
+const currentLineIdx = computed(() => store.currentLine())
+
+// ===== 歌词滚动跟随（用函数 ref 收集节点，避免每次全量 querySelectorAll） =====
+const lineEls: (HTMLElement | null)[] = []
+function setLineEl(el: Element | { $el?: Element } | null, idx: number) {
+  lineEls[idx] = (el as HTMLElement) ?? null
+}
+const reduceMotion = typeof window !== 'undefined' && window.matchMedia
+  ? window.matchMedia('(prefers-reduced-motion: reduce)').matches
+  : false
+watch(currentLineIdx, (idx) => {
+  if (idx < 0) return
+  lineEls[idx]?.scrollIntoView({ block: 'center', behavior: reduceMotion ? 'auto' : 'smooth' })
+})
+watch(
+  () => store.lyricLines,
+  () => {
+    lineEls.length = 0
+  }
+)
+
+// ===== 队列：大列表增量渲染（避免上千行一次性挂载） =====
+const QUEUE_STEP = 200
+const queueLimit = ref(QUEUE_STEP)
+watch(
+  () => store.queue.length,
+  () => (queueLimit.value = QUEUE_STEP)
+)
+const visibleQueue = computed(() =>
+  store.queue.slice(0, queueLimit.value).map((item, index) => ({ item, index }))
+)
+const hasMoreQueue = computed(() => store.queue.length > queueLimit.value)
+
+function onSeek(ratio: number) {
+  store.seek(ratio * store.duration)
+}
+
+function playAt(index: number) {
+  const item = store.queue[index]
+  if (item) store.playItem(item)
+}
+
+/** 暂停/继续当前曲目（不切换上下文） */
+function toggleAt(index: number) {
+  if (index === store.queueIndex) store.toggle()
+  else playAt(index)
+}
+</script>
+
+<template>
+  <Dialog v-model:open="store.nowPlayingOpen">
+    <DialogContent
+      class="max-w-5xl overflow-hidden border p-0 sm:max-w-5xl"
+      :show-close-button="false"
+    >
+      <DialogTitle class="sr-only">正在播放</DialogTitle>
+
+      <div class="relative flex h-[min(78vh,600px)] flex-col">
+        <!-- 背景：主题色轻渐变（不使用整图高斯模糊，避免持续 GPU 开销） -->
+        <div
+          class="pointer-events-none absolute inset-0"
+          style="
+            background:
+              radial-gradient(120% 90% at 12% 0%, color-mix(in oklab, var(--muted) 92%, transparent), transparent 62%),
+              linear-gradient(180deg, color-mix(in oklab, var(--muted) 55%, transparent), var(--background) 72%);
+          "
+        />
+
+        <div class="relative flex min-h-0 flex-1">
+          <!-- ===== 左：封面 + 控制 ===== -->
+          <div class="flex w-[46%] min-w-0 flex-col justify-center gap-5 px-9 py-8">
+            <div class="flex justify-center">
+              <img
+                v-if="coverUrl && !coverFailed"
+                :src="coverUrl"
+                class="aspect-square w-[min(240px,60%)] rounded-xl object-cover ring-1 ring-border/60"
+                alt=""
+                referrerpolicy="no-referrer"
+                @error="coverFailed = true"
+              />
+              <div
+                v-else
+                class="flex aspect-square w-[min(240px,60%)] items-center justify-center rounded-xl bg-muted/60 text-muted-foreground ring-1 ring-border/60"
+              >
+                <Music2 class="size-16" />
+              </div>
+            </div>
+
+            <div class="min-w-0 text-center">
+              <div class="flex items-center justify-center gap-2">
+                <h3 class="truncate text-[19px] font-semibold">{{ store.nowPlaying?.title || '未播放' }}</h3>
+                <span
+                  v-if="isPreview"
+                  class="shrink-0 rounded bg-muted px-1.5 py-0.5 text-[10px] text-muted-foreground"
+                >
+                  试听
+                </span>
+              </div>
+              <p class="mt-1 truncate text-[13px] text-muted-foreground">
+                {{ store.nowPlaying?.artistNames || '—'
+                }}<template v-if="store.nowPlaying?.album"> · {{ store.nowPlaying.album }}</template>
+              </p>
+            </div>
+
+            <div class="flex flex-col gap-2">
+              <ScrubBar
+                :value="store.progress / 100"
+                :buffered="store.bufferedPercent / 100"
+                :duration-sec="store.duration"
+                :disabled="!hasTrack"
+                label="播放进度"
+                @seek="onSeek"
+              />
+              <div class="mt-1 flex items-center justify-center gap-6">
+                <Tooltip>
+                  <TooltipTrigger as-child>
+                    <button
+                      type="button"
+                      class="text-muted-foreground transition-colors hover:text-foreground"
+                      :aria-label="modeLabel"
+                      @click="store.togglePlayMode()"
+                    >
+                      <component :is="modeIcon" class="size-4" />
+                    </button>
+                  </TooltipTrigger>
+                  <TooltipContent>{{ modeLabel }}</TooltipContent>
+                </Tooltip>
+
+                <button
+                  type="button"
+                  class="text-muted-foreground transition-colors hover:text-foreground disabled:opacity-40"
+                  :disabled="!store.queue.length"
+                  aria-label="上一首"
+                  @click="store.prev()"
+                >
+                  <SkipBack class="size-6" />
+                </button>
+
+                <button
+                  type="button"
+                  class="flex size-14 items-center justify-center rounded-full bg-primary text-primary-foreground transition-opacity hover:opacity-90 disabled:opacity-40"
+                  :disabled="!hasTrack"
+                  :aria-label="store.playing ? '暂停' : '播放'"
+                  @click="store.toggle()"
+                >
+                  <span
+                    v-if="store.loadingPlay"
+                    class="size-5 animate-spin rounded-full border-2 border-current border-t-transparent"
+                  />
+                  <Pause v-else-if="store.playing" class="size-6" />
+                  <Play v-else class="size-6 translate-x-px" />
+                </button>
+
+                <button
+                  type="button"
+                  class="text-muted-foreground transition-colors hover:text-foreground disabled:opacity-40"
+                  :disabled="!store.queue.length"
+                  aria-label="下一首"
+                  @click="store.next()"
+                >
+                  <SkipForward class="size-6" />
+                </button>
+
+                <button
+                  type="button"
+                  class="text-muted-foreground transition-colors hover:text-foreground"
+                  :class="{ 'text-foreground': store.nowPlayingTab === 'queue' }"
+                  aria-label="播放队列"
+                  @click="store.nowPlayingTab = 'queue'"
+                >
+                  <Plus class="size-4" />
+                </button>
+              </div>
+            </div>
+          </div>
+
+          <!-- ===== 右：歌词 / 队列 ===== -->
+          <div class="flex min-w-0 flex-1 flex-col border-l border-border px-6 py-7">
+            <div class="mb-4 flex items-center">
+              <SegmentedNav v-model="activeTab" :items="tabs" />
+            </div>
+
+            <ScrollArea class="min-h-0 flex-1">
+              <div v-if="activeTab === 'lyric'" class="flex flex-col gap-0.5 px-1 pb-6" data-slot="lyric-list">
+                <p v-if="!store.lyricLines.length" class="py-8 text-center text-[13px] text-muted-foreground">
+                  {{ isPreview ? '试听不加载歌词' : store.nowPlaying?.source === 'local' ? '本地文件无歌词' : '暂无歌词' }}
+                </p>
+                <button
+                  v-for="(line, idx) in store.lyricLines"
+                  :key="idx"
+                  :ref="(el) => setLineEl(el as Element | null, idx)"
+                  type="button"
+                  class="rounded-md px-3 py-1.5 text-left text-[14px] leading-7 transition-all duration-200"
+                  :class="
+                    idx === currentLineIdx
+                      ? 'bg-accent/60 text-[16px] font-medium text-foreground'
+                      : idx < currentLineIdx
+                        ? 'text-muted-foreground/45 hover:text-muted-foreground'
+                        : 'text-muted-foreground/75 hover:text-foreground'
+                  "
+                  @click="store.seek(line.t)"
+                >
+                  {{ line.text }}
+                </button>
+              </div>
+
+              <div v-else class="flex flex-col gap-0.5 px-1 pb-6">
+                <div v-if="!store.queue.length" class="py-8 text-center text-[13px] text-muted-foreground">
+                  队列为空
+                </div>
+                <div
+                  v-for="row in visibleQueue"
+                  :key="`${row.item.source}:${row.item.guid ?? row.index}`"
+                  class="group flex items-center gap-3 rounded-md px-2 py-1.5 transition-colors"
+                  :class="row.index === store.queueIndex && !isPreview ? 'bg-accent/60' : 'hover:bg-accent/40'"
+                >
+                  <button
+                    type="button"
+                    class="flex size-6 shrink-0 items-center justify-center text-[11px] tabular-nums text-muted-foreground"
+                    :aria-label="row.index === store.queueIndex ? '暂停/继续' : '播放'"
+                    @click="toggleAt(row.index)"
+                  >
+                    <span v-if="row.index === store.queueIndex && !isPreview" class="music-eq" :class="{ 'is-paused': !store.playing }">
+                      <i /><i /><i />
+                    </span>
+                    <template v-else>
+                      <Play class="size-3.5 opacity-0 transition-opacity group-hover:opacity-100" />
+                      <span class="group-hover:hidden">{{ row.index + 1 }}</span>
+                    </template>
+                  </button>
+                  <div class="min-w-0 flex-1">
+                    <div
+                      class="truncate text-[13px]"
+                      :class="row.index === store.queueIndex && !isPreview ? 'font-medium' : ''"
+                    >
+                      {{ row.item.title }}
+                    </div>
+                    <div class="truncate text-[11.5px] text-muted-foreground">{{ row.item.artistNames || '—' }}</div>
+                  </div>
+                  <button
+                    type="button"
+                    class="shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-destructive group-hover:opacity-100"
+                    aria-label="从队列移除"
+                    @click="store.removeFromQueue(row.index)"
+                  >
+                    <Trash2 class="size-3.5" />
+                  </button>
+                </div>
+                <button
+                  v-if="hasMoreQueue"
+                  type="button"
+                  class="mt-1 rounded-md py-2 text-[12px] text-muted-foreground hover:bg-accent/40"
+                  @click="queueLimit += QUEUE_STEP"
+                >
+                  显示更多（{{ store.queue.length - queueLimit }}）
+                </button>
+              </div>
+            </ScrollArea>
+          </div>
+        </div>
+
+        <DialogClose as-child>
+          <button
+            type="button"
+            class="absolute right-4 top-4 z-10 rounded-md p-1.5 text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+            aria-label="关闭"
+          >
+            <X class="size-5" />
+          </button>
+        </DialogClose>
+      </div>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/src/components/layout/TitleBar.vue b/src/components/layout/TitleBar.vue
index aee1046..4eaf406 100644
--- a/src/components/layout/TitleBar.vue
+++ b/src/components/layout/TitleBar.vue
@@ -2,6 +2,7 @@
 import { ref, computed, onMounted, onUnmounted, nextTick, watch } from 'vue'
 import { Search, Settings, ChevronRight, ArrowUp, Check, Loader2 } from '@lucide/vue'
 import { Input } from '@/components/ui/input'
+import TitleBarMusic from '@/components/layout/TitleBarMusic.vue'
 import { invoke } from '@tauri-apps/api/core'
 import { getCurrentWindow } from '@tauri-apps/api/window'
 import { useSearchStore, type SearchItem } from '@/stores/searchStore'
@@ -363,6 +364,11 @@ const handleBlur = () => {
           保存设置
         </button>
       </Transition>
+      <!-- 音乐栏：唱片图标 + 歌名（点击弹出方形播放控制窗），位于搜索框左侧 -->
+      <div class="pointer-events-auto">
+        <TitleBarMusic />
+      </div>
+
       <div class="relative max-w-xs mr-3 pointer-events-auto">
         <Search 
           class="absolute left-2.5 top-1/2 -translate-y-1/2 size-4 text-muted-foreground" 
diff --git a/src/components/layout/TitleBarMusic.vue b/src/components/layout/TitleBarMusic.vue
new file mode 100644
index 0000000..2ba184c
--- /dev/null
+++ b/src/components/layout/TitleBarMusic.vue
@@ -0,0 +1,296 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { toast } from 'vue-sonner'
+import {
+  Disc3,
+  ListMusic,
+  Maximize2,
+  MicVocal,
+  Pause,
+  Play,
+  Repeat,
+  Repeat1,
+  Shuffle,
+  SkipBack,
+  SkipForward,
+  Volume2,
+  VolumeX
+} from '@lucide/vue'
+import { useFeiniuStore } from '@/stores/feiniuStore'
+import ScrubBar from '@/components/common/ScrubBar.vue'
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
+
+const store = useFeiniuStore()
+
+const open = ref(false)
+
+const coverUrl = computed(() => {
+  const t = store.nowPlaying
+  if (!t) return ''
+  if (t.coverUrl) return t.coverUrl
+  if (t.source === 'feiniu' && t.coverId && store.mediaPrefix) {
+    return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(t.coverId)}&size=96`
+  }
+  return ''
+})
+const bigCoverUrl = computed(() => {
+  const t = store.nowPlaying
+  if (!t) return ''
+  if (t.coverUrl) return t.coverUrl
+  if (t.source === 'feiniu' && t.coverId && store.mediaPrefix) {
+    return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(t.coverId)}&size=320`
+  }
+  return ''
+})
+const coverFailed = ref(false)
+watch(coverUrl, () => (coverFailed.value = false))
+
+/** 是否已播放过（未播放过时不展示歌名，只留唱片图标） */
+const hasTrack = computed(() => !!store.nowPlaying)
+const title = computed(() => store.nowPlaying?.title ?? '')
+const subtitle = computed(() => {
+  const t = store.nowPlaying
+  if (!t) return ''
+  return t.artistNames || (t.source === 'local' ? '本地文件' : '')
+})
+const isPreview = computed(() => store.nowPlaying?.source === 'preview')
+
+const modeIcon = computed(() => {
+  if (store.playMode === 'loopOne') return Repeat1
+  if (store.playMode === 'shuffle') return Shuffle
+  return Repeat
+})
+const modeLabel = computed(() =>
+  store.playMode === 'loopAll' ? '列表循环' : store.playMode === 'loopOne' ? '单曲循环' : '随机播放'
+)
+const volumePercent = computed(() => (store.muted ? 0 : store.volume))
+
+function onSeek(ratio: number) {
+  store.seek(ratio * store.duration)
+}
+
+function openLyrics(tab: 'lyric' | 'queue') {
+  store.nowPlayingTab = tab
+  store.nowPlayingOpen = true
+  open.value = false
+}
+
+// 播放失败统一在这里提示（store 只记录原因）
+watch(
+  () => store.playError,
+  (msg) => {
+    if (!msg) return
+    toast.error(msg)
+    store.clearPlayError()
+  }
+)
+</script>
+
+<template>
+  <Popover v-model:open="open">
+    <PopoverTrigger as-child>
+      <!-- 音乐栏：唱片图标 + 歌名（未播放过时只显示图标） -->
+      <button
+        type="button"
+        class="mr-2 flex h-7 max-w-[210px] items-center gap-2 rounded-md px-1.5 text-left transition-colors hover:bg-secondary/60"
+        :title="hasTrack ? `${title}${subtitle ? ' · ' + subtitle : ''}` : '未在播放'"
+        :aria-label="hasTrack ? `音乐控制：${title}` : '音乐控制'"
+        @mousedown.stop
+      >
+        <span
+          class="disc flex size-5 shrink-0 items-center justify-center overflow-hidden rounded-full"
+          :class="{ 'is-playing': store.playing }"
+        >
+          <img
+            v-if="coverUrl && !coverFailed"
+            :src="coverUrl"
+            class="size-full object-cover"
+            alt=""
+            referrerpolicy="no-referrer"
+            @error="coverFailed = true"
+          />
+          <Disc3 v-else class="size-4 text-muted-foreground" />
+        </span>
+        <span v-if="hasTrack" class="min-w-0 flex-1 truncate text-xs text-foreground/90">
+          {{ title }}
+        </span>
+      </button>
+    </PopoverTrigger>
+
+    <!-- 方形播放控制窗 -->
+    <PopoverContent
+      align="end"
+      :side-offset="8"
+      class="w-[300px] p-3"
+      @mousedown.stop
+    >
+      <div class="flex flex-col items-center gap-3">
+        <!-- 封面 -->
+        <button
+          type="button"
+          class="group relative aspect-square w-[132px] overflow-hidden rounded-lg bg-muted ring-1 ring-border/60"
+          :title="'打开歌词与大屏'"
+          @click="openLyrics('lyric')"
+        >
+          <img
+            v-if="bigCoverUrl"
+            :src="bigCoverUrl"
+            class="size-full object-cover transition-transform duration-300 group-hover:scale-105"
+            alt=""
+            referrerpolicy="no-referrer"
+            @error="($event.target as HTMLImageElement).style.display = 'none'"
+          />
+          <span v-else class="flex size-full items-center justify-center text-muted-foreground">
+            <Disc3 class="size-10" />
+          </span>
+          <span
+            class="absolute inset-0 hidden items-center justify-center bg-foreground/35 text-primary-foreground group-hover:flex"
+          >
+            <Maximize2 class="size-5" />
+          </span>
+        </button>
+
+        <!-- 曲目信息 -->
+        <div class="w-full min-w-0 text-center">
+          <div class="flex items-center justify-center gap-1.5">
+            <span class="truncate text-[13px] font-medium">{{ title || '未播放' }}</span>
+            <span
+              v-if="isPreview"
+              class="shrink-0 rounded bg-muted px-1 py-px text-[10px] text-muted-foreground"
+            >
+              试听
+            </span>
+          </div>
+          <p class="mt-0.5 truncate text-[11.5px] text-muted-foreground">
+            {{ subtitle || '—' }}<template v-if="store.nowPlaying?.album"> · {{ store.nowPlaying.album }}</template>
+          </p>
+        </div>
+
+        <!-- 进度 -->
+        <ScrubBar
+          class="w-full"
+          :value="store.progress / 100"
+          :buffered="store.bufferedPercent / 100"
+          :duration-sec="store.duration"
+          :disabled="!hasTrack"
+          label="播放进度"
+          @seek="onSeek"
+        />
+
+        <!-- 控制 -->
+        <div class="flex w-full items-center justify-center gap-5">
+          <button
+            type="button"
+            class="text-muted-foreground transition-colors hover:text-foreground"
+            :title="modeLabel"
+            :aria-label="modeLabel"
+            @click="store.togglePlayMode()"
+          >
+            <component :is="modeIcon" class="size-3.5" />
+          </button>
+          <button
+            type="button"
+            class="text-muted-foreground transition-colors hover:text-foreground disabled:opacity-40"
+            :disabled="!store.queue.length"
+            aria-label="上一首"
+            @click="store.prev()"
+          >
+            <SkipBack class="size-5" />
+          </button>
+          <button
+            type="button"
+            class="flex size-10 items-center justify-center rounded-full bg-primary text-primary-foreground transition-opacity hover:opacity-90 disabled:opacity-40"
+            :disabled="!hasTrack"
+            :aria-label="store.playing ? '暂停' : '播放'"
+            @click="store.toggle()"
+          >
+            <span
+              v-if="store.loadingPlay"
+              class="size-4 animate-spin rounded-full border-2 border-current border-t-transparent"
+            />
+            <Pause v-else-if="store.playing" class="size-4" />
+            <Play v-else class="size-4 translate-x-px" />
+          </button>
+          <button
+            type="button"
+            class="text-muted-foreground transition-colors hover:text-foreground disabled:opacity-40"
+            :disabled="!store.queue.length"
+            aria-label="下一首"
+            @click="store.next()"
+          >
+            <SkipForward class="size-5" />
+          </button>
+          <button
+            type="button"
+            class="text-muted-foreground transition-colors hover:text-foreground disabled:opacity-40"
+            :disabled="isPreview"
+            :title="`播放队列（${store.queue.length}）`"
+            aria-label="播放队列"
+            @click="openLyrics('queue')"
+          >
+            <ListMusic class="size-3.5" />
+          </button>
+        </div>
+
+        <!-- 音量 + 入口 -->
+        <div class="flex w-full items-center gap-2 border-t pt-2.5">
+          <button
+            type="button"
+            class="shrink-0 text-muted-foreground transition-colors hover:text-foreground"
+            :aria-label="store.muted ? '取消静音' : '静音'"
+            @click="store.toggleMute()"
+          >
+            <VolumeX v-if="volumePercent === 0" class="size-3.5" />
+            <Volume2 v-else class="size-3.5" />
+          </button>
+          <div class="w-16 shrink-0">
+            <ScrubBar compact :value="volumePercent" label="音量" @seek="store.setVolume($event)" />
+          </div>
+          <div class="ml-auto flex items-center gap-1">
+            <button
+              type="button"
+              class="flex items-center gap-1 rounded-md px-1.5 py-1 text-[11.5px] text-muted-foreground transition-colors hover:bg-secondary/60 hover:text-foreground"
+              @click="openLyrics('lyric')"
+            >
+              <MicVocal class="size-3.5" />
+              歌词
+            </button>
+            <button
+              type="button"
+              class="flex items-center gap-1 rounded-md px-1.5 py-1 text-[11.5px] text-muted-foreground transition-colors hover:bg-secondary/60 hover:text-foreground"
+              :disabled="isPreview"
+              @click="openLyrics('queue')"
+            >
+              <ListMusic class="size-3.5" />
+              队列
+            </button>
+          </div>
+        </div>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
+
+<style scoped>
+/* 唱片图标：播放时旋转（暂停保持当前角度继续待命） */
+.disc {
+  animation: discSpin 8s linear infinite;
+  animation-play-state: paused;
+  background: var(--muted);
+}
+.disc.is-playing {
+  animation-play-state: running;
+}
+
+@keyframes discSpin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .disc {
+    animation: none;
+  }
+}
+</style>
diff --git a/src/modules/music/MusicModule.vue b/src/modules/music/MusicModule.vue
index 7f685ec..b11c716 100644
--- a/src/modules/music/MusicModule.vue
+++ b/src/modules/music/MusicModule.vue
@@ -3,8 +3,37 @@ import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import { toast } from 'vue-sonner'
 import { open as openDialog } from '@tauri-apps/plugin-dialog'
 import { appDataDir } from '@tauri-apps/api/path'
-import { Search, Loader2, Play, Square, RotateCw, FolderOpen, CircleAlert, Info, Download, X, ListMusic, Music2, Settings as SettingsIcon, History, ChevronDown, ChevronUp, Trash2, Database, Upload } from '@lucide/vue'
-import { useMusicStore, type MusicDownloadTask, type MusicDownloadSongState, type MusicQuality, type MusicSong } from '@/stores/musicStore'
+import {
+  ChevronDown,
+  ChevronUp,
+  CircleAlert,
+  CloudUpload,
+  Download,
+  FolderOpen,
+  HardDriveDownload,
+  History,
+  Info,
+  Library,
+  Link2,
+  ListMusic,
+  Loader2,
+  Music2,
+  Play,
+  RotateCw,
+  Search,
+  Settings as SettingsIcon,
+  Square,
+  Trash2,
+  Upload,
+  X
+} from '@lucide/vue'
+import {
+  useMusicStore,
+  type MusicDownloadTask,
+  type MusicDownloadSongState,
+  type MusicQuality,
+  type MusicSong
+} from '@/stores/musicStore'
 import { useProxyStore } from '@/stores/proxyStore'
 import { useFeiniuStore } from '@/stores/feiniuStore'
 import { useModuleTabs } from '@/lib/use-module-tabs'
@@ -13,13 +42,11 @@ import { commands } from '@/lib/bindings'
 import { sourceName, PICKER_SOURCES } from './sources'
 import SourcePicker from './SourcePicker.vue'
 import MyMusicLibrary from './components/MyMusicLibrary.vue'
-import PlayerBar from './components/PlayerBar.vue'
-import PlayerFull from './components/PlayerFull.vue'
 import ConnectionsSettings from './components/settings/ConnectionsSettings.vue'
 import CacheSettings from './components/settings/CacheSettings.vue'
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
 import { Button } from '@/components/ui/button'
 import { Badge } from '@/components/ui/badge'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
 import {
   Dialog,
   DialogContent,
@@ -35,9 +62,9 @@ import { Separator } from '@/components/ui/separator'
 import { Progress } from '@/components/ui/progress'
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { Checkbox } from '@/components/ui/checkbox'
-import { Empty } from '@/components/ui/empty'
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { Empty, EmptyDescription, EmptyMedia, EmptyTitle } from '@/components/ui/empty'
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
 
 const store = useMusicStore()
@@ -45,21 +72,24 @@ const proxyStore = useProxyStore()
 const feiniu = useFeiniuStore()
 const logger = createLogger('music')
 
-// ===== 主 Tab 状态 =====
+// ===== 模块导航 =====
 const activeTab = ref('mymusic')
 const tabsListRef = useModuleTabs('music', activeTab, [
-  { value: 'mymusic', label: '我的音乐' },
+  { value: 'mymusic', label: '曲库' },
   { value: 'discover', label: '发现音乐' },
   { value: 'tasks', label: '下载任务' },
   { value: 'settings', label: '设置' }
 ])
 
-// ===== 发现音乐下载目标（本地 / 飞牛库） =====
+// ===== 发现音乐：下载目标 =====
 const downloadTarget = ref<'local' | 'feiniu'>('local')
-/** 本次下载完成后需上传到飞牛 */
-let pendingUploadOnDone = false
+/** 需要在完成后上传到飞牛的 musicdl 任务 id */
+const uploadOnDoneTaskIds = ref<Set<string>>(new Set())
+/** 已触发过上传的任务 id（每个任务最多触发一次，避免重复全量上传） */
+const uploadedTaskIds = new Set<string>()
+/** 初始化完成前不触发自动上传（避免应用启动时把历史任务重复上传一遍） */
+let uploadsArmed = false
 
-/** 把最近下载的本地音频批量上传到飞牛曲库 */
 async function uploadRecentToFeiniu() {
   try {
     const { total, ok } = await feiniu.uploadRecentToFeiniu(10)
@@ -70,28 +100,72 @@ async function uploadRecentToFeiniu() {
   }
 }
 
-// 下载任务完成 → 若目标是飞牛库或开启了自动上传 → 自动上传
-watch(
-  () => store.tasks.map((t) => `${t.taskId}:${t.status}`).join('|'),
-  () => {
-    const doneNow = store.tasks.some((t) => t.status === 'done' && (pendingUploadOnDone || feiniu.autoUpload))
-    if (!doneNow) return
-    pendingUploadOnDone = false
-    uploadRecentToFeiniu()
+/** 精确到任务的上传触发：不再让残留标志位污染后续无关任务 */
+function resolvePendingUploads() {
+  if (!uploadsArmed) return
+  // 上一轮上传尚未结束时不叠加并发上传（等下一次任务状态变化重试）
+  if (feiniu.uploading) return
+  const alive = new Set(store.tasks.map((t) => t.taskId))
+  for (const id of [...uploadedTaskIds]) if (!alive.has(id)) uploadedTaskIds.delete(id)
+  for (const t of store.tasks) {
+    if (t.status !== 'done') continue
+    // 「下载到飞牛」的临时任务：上传 + 清理本地副本 + 移除记录，不走常规自动上传
+    if (tempTaskIds.has(t.taskId)) {
+      tempTaskIds.delete(t.taskId)
+      void finishTempUpload(t.taskId)
+      continue
+    }
+    const wanted = uploadOnDoneTaskIds.value.has(t.taskId) || feiniu.autoUpload
+    if (!wanted || uploadedTaskIds.has(t.taskId)) continue
+    uploadedTaskIds.add(t.taskId)
+    if (uploadOnDoneTaskIds.value.has(t.taskId)) uploadOnDoneTaskIds.value.delete(t.taskId)
+    void uploadRecentToFeiniu()
   }
-)
+  // 临时任务下载失败/被取消：清理行按钮 spinner 与临时标记，避免永久转圈
+  for (const t of store.tasks) {
+    if (t.status === 'done' || t.status === 'downloading' || t.status === 'cancelling') continue
+    if (!tempTaskIds.has(t.taskId)) continue
+    tempTaskIds.delete(t.taskId)
+    tempTaskStarts.delete(t.taskId)
+    const key = tempTaskKeys.get(t.taskId)
+    tempTaskKeys.delete(t.taskId)
+    if (key) {
+      const next = new Set(feiniuUploadingKeys.value)
+      next.delete(key)
+      feiniuUploadingKeys.value = next
+    }
+    toast.error(`下载到飞牛失败：${t.errorMessage || '任务未完成，文件保留在本地下载目录'}`)
+  }
+  // 临时任务记录被手动删除（下载中移除）：同样释放行按钮 spinner
+  for (const id of [...tempTaskIds]) {
+    if (alive.has(id)) continue
+    tempTaskIds.delete(id)
+    tempTaskStarts.delete(id)
+    const key = tempTaskKeys.get(id)
+    tempTaskKeys.delete(id)
+    if (key) {
+      const next = new Set(feiniuUploadingKeys.value)
+      next.delete(key)
+      feiniuUploadingKeys.value = next
+    }
+  }
+}
+watch(() => store.tasks.map((t) => `${t.taskId}:${t.status}`).join('|'), resolvePendingUploads)
 
+// ===== 生命周期 =====
+const appDataPath = ref('')
 onMounted(async () => {
   loadHistory()
   try {
     await store.init()
   } catch (e) {
-    logger.error(`音乐模块初始化失败: ${e}`)
-  }
-  // musicdl 未安装时不拉起桥接（避免常驻空转的 Python 进程），安装完成后会手动加载
-  if (store.env?.musicdlInstalled) {
-    store.loadSources().catch(() => {})
+    logger.error(`音乐模块初始化失败：${e}`)
   }
+  // musicdl 未安装时不拉起桥接（避免常驻空转的 Python 进程）
+  if (store.env?.musicdlInstalled) store.loadSources().catch(() => {})
+  // 历史任务视为已处理：应用启动时不重传上一轮已上传过的文件
+  for (const t of store.tasks) if (t.status === 'done') uploadedTaskIds.add(t.taskId)
+  uploadsArmed = true
   appDataDir()
     .then((p) => (appDataPath.value = p))
     .catch(() => {})
@@ -104,14 +178,13 @@ const sourceOptions = computed<string[]>(() => {
   const list = store.availableSources.length
     ? PICKER_SOURCES.filter((s) => avail.has(s))
     : [...PICKER_SOURCES]
-  // 保留已选但不在常用列表中的源
   const selected = store.settings?.sources ?? []
   const extra = selected.filter((s) => !list.includes(s))
   return [...list, ...extra]
 })
 
 async function doSearch() {
-  if (store.searching) return // 重入保护：回车 + 按钮点击不重复发起
+  if (store.searching) return
   const kw = keyword.value.trim()
   if (!kw) return
   const sources = store.settings?.sources ?? []
@@ -126,19 +199,16 @@ async function doSearch() {
     await store.search(kw, sources)
     pushHistory(kw)
   } catch {
-    // 错误详情由搜索结果区的 Empty 状态展示，不再重复 toast
+    // 错误详情由结果区空态展示
   }
 }
 
-function onKeywordEnter() {
-  doSearch()
-}
-
-// ===== 搜索历史（localStorage，最多 10 条） =====
+// ===== 搜索历史 =====
 const HISTORY_KEY = 'thing.music.searchHistory'
 const HISTORY_MAX = 10
 const searchHistory = ref<string[]>([])
 const historyOpen = ref(false)
+const searchBoxRef = ref<HTMLElement | null>(null)
 
 function loadHistory() {
   try {
@@ -154,7 +224,7 @@ function pushHistory(kw: string) {
   try {
     localStorage.setItem(HISTORY_KEY, JSON.stringify(next))
   } catch {
-    // localStorage 不可用时静默降级（仅影响历史）
+    /* 忽略 */
   }
 }
 function clearHistory() {
@@ -162,10 +232,9 @@ function clearHistory() {
   try {
     localStorage.removeItem(HISTORY_KEY)
   } catch {
-    // 忽略
+    /* 忽略 */
   }
 }
-/** 按当前输入过滤的历史项（空输入显示全部） */
 const filteredHistory = computed(() => {
   const kw = keyword.value.trim().toLowerCase()
   if (!kw) return searchHistory.value
@@ -173,14 +242,22 @@ const filteredHistory = computed(() => {
 })
 function pickHistory(h: string) {
   keyword.value = h
+  historyOpen.value = false
   doSearch()
 }
+/** 焦点仍在搜索框/历史浮层内时保持展开，键盘 Tab 才能选中历史项 */
+function onHistoryFocusOut(e: FocusEvent) {
+  const next = e.relatedTarget as Node | null
+  if (next && searchBoxRef.value?.contains(next)) return
+  historyOpen.value = false
+}
 
 // ===== 歌单解析 =====
 const playlistUrl = ref('')
 const parsingPlaylist = ref(false)
+const playlistLinkOpen = ref(false)
 async function doParsePlaylist() {
-  if (parsingPlaylist.value) return // 重入保护
+  if (parsingPlaylist.value) return
   const url = playlistUrl.value.trim()
   if (!url) return
   const sources = store.settings?.sources ?? []
@@ -194,6 +271,8 @@ async function doParsePlaylist() {
   try {
     const n = await store.parsePlaylist(url, sources)
     toast.success(`歌单解析完成，共 ${n} 首`)
+    playlistLinkOpen.value = false
+    playlistUrl.value = ''
   } catch {
     toast.error(`歌单解析失败：${store.parseError || '未知错误'}`)
   } finally {
@@ -201,7 +280,7 @@ async function doParsePlaylist() {
   }
 }
 
-// 扁平化结果列表（按源返回顺序）
+// ===== 结果扁平化 / 筛选 / 增量渲染 =====
 interface FlatSong {
   song: MusicSong
   source: string
@@ -216,7 +295,6 @@ const flatResults = computed<FlatSong[]>(() => {
   return out
 })
 
-// ===== 源筛选 + 音质筛选 =====
 const LOSSLESS_EXTS = new Set(['flac', 'wav', 'alac', 'ape', 'wv', 'tta', 'dsf', 'dff'])
 const sourceFilter = ref('all')
 const qualityFilter = ref<'all' | 'lossless' | 'mp3'>('all')
@@ -227,42 +305,42 @@ const filteredResults = computed<FlatSong[]>(() => {
   return flatResults.value.filter((f) => {
     if (src !== 'all' && f.source !== src) return false
     if (q === 'all') return true
-    // 音质筛选：优先 ext（已解析歌），懒解析歌用 lossless 提示
-    // （酷狗 SQFileSize / 网易 privilege.maxbr / QQ 批量详情补查推断）
-    const ext = (f.song.ext ?? '').toLowerCase()
-    // qualities 为空数组时 some() 返回 false，需走 lossless 兜底（网易/酷狗提取器可能返回 []）
-    const lossless = ext
-      ? LOSSLESS_EXTS.has(ext)
-      : f.song.qualities?.length
-        ? f.song.qualities.some((q) => q.lossless === true)
-        : f.song.lossless === true
+    const lossless = isLossless(f.song)
     return q === 'lossless' ? lossless : !lossless
   })
 })
 
-// ===== 分组展示（源分组头 + 歌曲行） =====
+/** 分组后的展示项（源分组头 + 歌曲行） */
 interface DisplayItem {
   type: 'header' | 'song'
   source?: string
   count?: number
+  keys?: string[]
+  allSelected?: boolean
   song?: FlatSong
 }
 const displayItems = computed<DisplayItem[]>(() => {
-  const counts = new Map<string, number>()
-  for (const f of filteredResults.value) counts.set(f.source, (counts.get(f.source) ?? 0) + 1)
   const out: DisplayItem[] = []
-  let lastSource = ''
+  const bySource = new Map<string, FlatSong[]>()
   for (const f of filteredResults.value) {
-    if (f.source !== lastSource) {
-      lastSource = f.source
-      out.push({ type: 'header', source: f.source, count: counts.get(f.source) ?? 0 })
-    }
-    out.push({ type: 'song', song: f })
+    const arr = bySource.get(f.source)
+    if (arr) arr.push(f)
+    else bySource.set(f.source, [f])
+  }
+  for (const [source, list] of bySource) {
+    const keys = list.map((f) => f.key)
+    out.push({
+      type: 'header',
+      source,
+      count: list.length,
+      keys,
+      allSelected: keys.every((k) => selectedKeys.value.has(k))
+    })
+    for (const f of list) out.push({ type: 'song', song: f })
   }
   return out
 })
 
-// ===== 增量渲染（大歌单/多源搜索时避免一次性挂载上千行 DOM） =====
 const PAGE_SIZE = 80
 const visibleCount = ref(PAGE_SIZE)
 watch(filteredResults, () => {
@@ -278,7 +356,6 @@ onMounted(() => {
     (entries) => {
       if (entries.some((e) => e.isIntersecting)) {
         visibleCount.value += PAGE_SIZE
-        // DOM 增长后 sentinel 可能仍在视口内，重新挂观察器以再次触发
         nextTick(() => {
           const el = loadMoreRef.value
           if (el && loadMoreObserver) {
@@ -300,85 +377,67 @@ onMounted(() => {
     { immediate: true }
   )
 })
-onBeforeUnmount(() => {
-  loadMoreObserver?.disconnect()
-})
+onBeforeUnmount(() => loadMoreObserver?.disconnect())
 
-// ===== 组级全选 =====
-function groupKeys(source: string): string[] {
-  return filteredResults.value.filter((f) => f.source === source).map((f) => f.key)
-}
-function groupAllSelected(source: string): boolean {
-  const keys = groupKeys(source)
-  return keys.length > 0 && keys.every((k) => selectedKeys.value.has(k))
-}
-function toggleSelectGroup(source: string) {
-  const keys = groupKeys(source)
+function toggleSelectGroup(item: DisplayItem) {
+  const keys = item.keys ?? []
   const next = new Set(selectedKeys.value)
-  if (keys.every((k) => next.has(k))) keys.forEach((k) => next.delete(k))
+  if (item.allSelected) keys.forEach((k) => next.delete(k))
   else keys.forEach((k) => next.add(k))
   selectedKeys.value = next
 }
 
-/** bitrate 展示：≥1000 视为 Mbps 级，否则 kbps */
+// ===== 音质展示（降噪为单枚中性徽标 + 弹层详情） =====
+const TIER_ORDER = ['Hi-Res', '无损', 'FLAC', '320K', '192K', '128K', '96K', '标准']
+function tierRank(label?: string | null) {
+  const i = TIER_ORDER.indexOf((label ?? '').trim())
+  return i === -1 ? 99 : i
+}
+/** 该曲可用的最高音质档位 */
+function bestTier(song: MusicSong): MusicQuality | null {
+  const list = song.qualities
+  if (!list || list.length === 0) return null
+  return [...list].sort((a, b) => tierRank(a.label) - tierRank(b.label))[0]
+}
+function isLossless(song: MusicSong): boolean {
+  const ext = (song.ext ?? '').toLowerCase()
+  if (ext) return LOSSLESS_EXTS.has(ext)
+  if (song.qualities?.length) return song.qualities.some((q) => q.lossless === true)
+  return song.lossless === true
+}
+/** 列表里展示的一行音质摘要：优先档位 label，其次 ext / 无损标记 */
+function qualitySummary(song: MusicSong): string {
+  const best = bestTier(song)
+  if (best?.label) return best.ext ? `${best.label} · ${best.ext.toUpperCase()}` : best.label
+  if (song.ext) return song.ext.toUpperCase()
+  if (isLossless(song)) return '无损'
+  return ''
+}
 const formatBitrate = (b?: number | null) => {
   if (!b || b <= 0) return ''
-  return b >= 1000 ? `${(b / 1000).toFixed(1)}Mbps` : `${b}kbps`
+  return b >= 1000 ? `${(b / 1000).toFixed(1)} Mbps` : `${b} kbps`
 }
-
-// ===== 多音质档位展示 =====
-// 行内直接展示的档位数上限，超出部分收进 "+N" 悬浮弹层
-const maxTiers = 2
-/** 取前 maxTiers 个档位用于行内徽标；缺省返回空数组 */
-const visibleTiers = (t?: MusicQuality[] | null) => (t && t.length ? t.slice(0, maxTiers) : [])
-/** 按 label 档位返回徽标配色（同一档位恒定同色，搜索页与任务页共用）
- *  Hi-Res=金 · 无损/FLAC=紫 · 320K=蓝 · 192K=橙 · 128K 及以下=灰 · 最高/未知=主题色 */
-const qualityLabelClass = (label: string) => {
-  const l = (label ?? '').trim()
-  if (l === 'Hi-Res') return 'bg-amber-500/15 text-amber-700 border-amber-500/40 dark:text-amber-400'
-  if (l === '无损' || l === 'FLAC') return 'bg-purple-500/15 text-purple-700 border-purple-500/30 dark:text-purple-400'
-  if (l === '320K') return 'bg-sky-500/15 text-sky-700 border-sky-500/30 dark:text-sky-400'
-  if (l === '192K') return 'bg-orange-500/15 text-orange-600 border-orange-500/30 dark:text-orange-400'
-  if (l === '128K' || l === '96K' || l === '标准') return 'bg-zinc-500/15 text-zinc-600 border-zinc-500/30 dark:text-zinc-400'
-  return 'bg-primary/10 text-primary border-primary/30'
-}
-/** 不同音质的徽标配色（按 label 档位统一区分；无 label 时按 ext/码率兜底） */
-const qualityTagClass = (q: MusicQuality) => {
-  const label = (q.label ?? '').trim()
-  if (label) return qualityLabelClass(label)
-  const ext = (q.ext ?? '').toLowerCase()
-  const br = q.bitrate ?? 0
-  if (LOSSLESS_EXTS.has(ext)) return 'bg-purple-500/15 text-purple-700 border-purple-500/30 dark:text-purple-400'
-  if (br >= 320) return 'bg-sky-500/15 text-sky-700 border-sky-500/30 dark:text-sky-400'
-  if (br >= 192) return 'bg-orange-500/15 text-orange-600 border-orange-500/30 dark:text-orange-400'
-  return 'bg-zinc-500/15 text-zinc-600 border-zinc-500/30 dark:text-zinc-400'
-}
-/** 播放时长：分:秒（mm:ss） */
 const formatDuration = (sec?: number | null, fallback?: string | null) => {
   if (sec && sec > 0) {
     const m = Math.floor(sec / 60)
     const s = Math.floor(sec % 60)
     return `${m}:${String(s).padStart(2, '0')}`
   }
-  return fallback || ''
+  return fallback || '--:--'
 }
 
-// ===== 在线试听 =====
-const audioEl = ref<HTMLAudioElement | null>(null)
-const playingKey = ref('')
-// 懒解析中（试听按钮点击 → 解析真实链接 → 播放）的歌曲 key
+// ===== 在线试听（走全局播放内核，与播放器共用同一 audio，天然互斥） =====
 const resolvingKeys = ref<Set<string>>(new Set())
+const previewKey = computed(() => feiniu.preview?.guid ?? '')
 
-async function togglePlay(song: MusicSong, source: string, index: number) {
+async function togglePreview(song: MusicSong, source: string, index: number) {
   const key = `${source}|${index}`
-  if (playingKey.value === key) {
-    audioEl.value?.pause()
-    playingKey.value = ''
+  if (previewKey.value === key) {
+    feiniu.stopPreview()
     return
   }
   let target = song
   if (!target.downloadUrl) {
-    // 懒解析：先解析真实下载链接再试听
     if (!target.rawSearch || resolvingKeys.value.has(key)) return
     resolvingKeys.value.add(key)
     try {
@@ -395,26 +454,137 @@ async function togglePlay(song: MusicSong, source: string, index: number) {
       resolvingKeys.value.delete(key)
     }
   }
-  playingKey.value = key
-  if (audioEl.value) {
-    audioEl.value.src = target.downloadUrl!
-    audioEl.value.play().catch(() => {
-      toast.error('试听失败：该链接无法播放')
-      playingKey.value = ''
-    })
-  }
-}
-function onAudioEnded() {
-  playingKey.value = ''
+  feiniu.playPreview({
+    source: 'preview',
+    guid: key,
+    title: target.songName || '未知歌名',
+    artistNames: target.singers || '',
+    album: target.album || undefined,
+    coverUrl: target.coverUrl || undefined,
+    ext: target.ext || undefined,
+    url: target.downloadUrl!
+  })
 }
 
 // ===== 下载 =====
-/** 代理联动：mihomo mixed 端口 → 桥接 requests_overrides.proxies */
 const proxyUrl = computed(() => {
   const port = proxyStore.settings?.mixedPort
   return port ? `http://127.0.0.1:${port}` : ''
 })
 
+/** 每行「下载到飞牛」进行中的 key */
+const feiniuUploadingKeys = ref<Set<string>>(new Set())
+
+/** WebDAV 测试连接进行中 */
+const webdavTesting = ref(false)
+/** WebDAV 已配置时默认收起凭据表单（账号/密码隐藏），点「修改配置」展开 */
+const webdavEditing = ref(false)
+
+async function testWebdav() {
+  if (webdavTesting.value) return
+  webdavTesting.value = true
+  try {
+    const msg = await feiniu.testWebdav()
+    toast.success(msg)
+  } catch (e) {
+    toast.error(String(e))
+  } finally {
+    webdavTesting.value = false
+  }
+}
+
+/**
+ * 单曲「下载到飞牛」：与「下载完成后自动上传」同一条链路——
+ * 正常走 musicdl 下载（含引擎侧解析、代理、音质设置），任务完成后用 WebDAV
+ * 上传本地文件并删除本地副本（含同名歌词/封面），最后移除任务记录。
+ */
+const tempTaskIds = new Set<string>()
+/** taskId → 任务创建时刻（秒），上传扫描的下界，避免误传窗口外的无关文件 */
+const tempTaskStarts = new Map<string, number>()
+/** taskId → 行按钮 spinner key */
+const tempTaskKeys = new Map<string, string>()
+
+async function downloadToFeiniu(song: MusicSong, source: string, index: number) {
+  const key = `${source}|${index}`
+  if (feiniuUploadingKeys.value.has(key)) return
+  if (!feiniu.webdavReady) {
+    toast.error('请先在「设置 → 存储与上传」完成 WebDAV 配置（地址 / 账号 / 密码 / 目标目录）')
+    return
+  }
+  const s = store.settings
+  if (!s) return
+  // Rust 引擎的任务在「下载器」模块管理，无法回传飞牛曲库
+  if (s.downloadEngine === 'rust') {
+    toast.error(
+      'Rust 引擎的下载任务在「下载器」模块中管理，无法自动回传飞牛曲库。请改用 musicdl 引擎。'
+    )
+    return
+  }
+  const next = new Set(feiniuUploadingKeys.value)
+  next.add(key)
+  feiniuUploadingKeys.value = next
+  try {
+    const { engine, skipped, taskId } = await store.startDownload([song], {
+      savedir: s.savedir,
+      lyric: s.lyricDownload,
+      cover: s.coverDownload,
+      proxyUrl: s.useProxy ? proxyUrl.value : '',
+      engine: s.downloadEngine,
+      maxConcurrent: s.maxConcurrent,
+      quality: s.defaultDownloadQuality ?? ''
+    })
+    if (engine === 'rust' || skipped > 0) {
+      toast.error(skipped > 0 ? '该歌曲没有可用的下载源' : 'Rust 引擎无法回传飞牛曲库')
+      return
+    }
+    if (taskId) {
+      tempTaskIds.add(taskId)
+      tempTaskStarts.set(taskId, Date.now() / 1000 - 5)
+      tempTaskKeys.set(taskId, key)
+      // 任务记录在上传完成后移除；期间不出现在任务列表的常规上传流程里
+    }
+  } catch (e) {
+    toast.error(`启动下载失败：${e}`)
+    const done = new Set(feiniuUploadingKeys.value)
+    done.delete(key)
+    feiniuUploadingKeys.value = done
+  }
+}
+
+/** 临时任务的收尾：上传 → 删本地副本 → 移除任务记录。失败时保留任务记录供排查。 */
+async function finishTempUpload(taskId: string) {
+  const startedAt = tempTaskStarts.get(taskId) ?? Date.now() / 1000 - 600
+  tempTaskStarts.delete(taskId)
+  const key = tempTaskKeys.get(taskId)
+  tempTaskKeys.delete(taskId)
+  try {
+    const { total, ok, deleted } = await feiniu.uploadRecentToFeiniu(0, {
+      since: startedAt,
+      deleteLocal: true
+    })
+    const task = store.tasks.find((t) => t.taskId === taskId)
+    const name = task?.songs?.[0]?.songName || ''
+    if (ok > 0) {
+      toast.success(`已保存到飞牛曲库${name ? `：${name}` : ''}`)
+      store.removeTask(taskId)
+      if (deleted < total) toast.info(`${total - deleted} 个本地副本未能删除（可能被占用）`)
+    } else if (total === 0) {
+      toast.error('下载完成，但未在下载目录找到新文件——请检查下载目录设置')
+    } else {
+      throw new Error('上传失败')
+    }
+  } catch (e) {
+    // 失败：保留本地文件与任务记录，用户可在任务列表重试或排查
+    toast.error(`上传到飞牛失败：${e}`)
+  } finally {
+    if (key) {
+      const done = new Set(feiniuUploadingKeys.value)
+      done.delete(key)
+      feiniuUploadingKeys.value = done
+    }
+  }
+}
+
 const selectedKeys = ref<Set<string>>(new Set())
 const selectedSongs = computed<MusicSong[]>(() =>
   filteredResults.value.filter((f) => selectedKeys.value.has(f.key)).map((f) => f.song)
@@ -425,29 +595,29 @@ function toggleSelect(key: string) {
   else next.add(key)
   selectedKeys.value = next
 }
-
-// ===== 全选（作用于当前音质筛选后的可见结果） =====
 const allSelected = computed(
   () => filteredResults.value.length > 0 && filteredResults.value.every((f) => selectedKeys.value.has(f.key))
 )
 function toggleSelectAll() {
-  selectedKeys.value = allSelected.value
-    ? new Set()
-    : new Set(filteredResults.value.map((f) => f.key))
+  selectedKeys.value = allSelected.value ? new Set() : new Set(filteredResults.value.map((f) => f.key))
 }
 
-/** 用系统资源管理器打开目录（复用下载器模块命令） */
 function openDir(path?: string) {
   const dir = path || store.settings?.savedir
   if (!dir) return
   commands.downloaderOpenDir(dir).catch((e) => toast.error(`打开目录失败：${e}`))
 }
 
-async function doDownload(songs: MusicSong[], quality = '') {
+async function doDownload(songs: MusicSong[], quality = '', clearSelection = false) {
   const s = store.settings
-  if (!s) return
+  if (!s || songs.length === 0) return
+  // Rust 引擎的任务在「下载器」模块管理，无法回传飞牛曲库
+  if (downloadTarget.value === 'feiniu' && s.downloadEngine === 'rust') {
+    toast.error('Rust 引擎的下载任务在「下载器」模块中管理，无法自动回传飞牛曲库。请改用 musicdl 引擎，或把下载目标改为本地目录。')
+    return
+  }
   try {
-    const skipped = await store.startDownload(songs, {
+    const { engine, skipped, taskId } = await store.startDownload(songs, {
       savedir: s.savedir,
       lyric: s.lyricDownload,
       cover: s.coverDownload,
@@ -457,59 +627,62 @@ async function doDownload(songs: MusicSong[], quality = '') {
       quality
     })
     if (skipped > 0) toast.warning(`${skipped} 首歌曲无下载链接，已跳过`)
+    if (clearSelection) selectedKeys.value = new Set()
+    if (engine === 'rust') {
+      toast.success('已交给「下载器」模块下载，可在该模块查看进度')
+      return
+    }
+    if (taskId && downloadTarget.value === 'feiniu') uploadOnDoneTaskIds.value.add(taskId)
     activeTab.value = 'tasks'
   } catch (e) {
     toast.error(`启动下载失败：${e}`)
   }
 }
 
-// ===== 音质选择下载 =====
+// ===== 音质选择 =====
 const qualityDialogOpen = ref(false)
-/** 待下载歌曲（弹窗确认后真正调用 doDownload） */
 const pendingQualitySongs = ref<MusicSong[]>([])
-/** 弹窗中选中的音质（"" 表示最高） */
 const chosenQuality = ref('')
-/** 待下载歌曲的音质档位并集（有序，最高在前）+ 最高 */
+const pendingClearSelection = ref(false)
 function qualityOptionsFor(songs: MusicSong[]): string[] {
   const set = new Set<string>()
   for (const s of songs) for (const q of s.qualities ?? []) if (q.label) set.add(q.label)
-  // 常见顺序优先：无损级在前，其次按码率降序
-  const order = (l: string) => {
-    const idx = ['Hi-Res', '无损', 'FLAC', '320K', '192K', '128K', '96K'].indexOf(l)
-    return idx === -1 ? 99 : idx
-  }
-  return ['最高', ...[...set].sort((a, b) => order(a) - order(b))]
+  return ['最高', ...[...set].sort((a, b) => tierRank(a) - tierRank(b))]
 }
-function requestDownloadFlow(songs: MusicSong[]) {
+function requestDownloadFlow(songs: MusicSong[], clearSelection = false) {
   if (songs.length === 0) return
-  pendingUploadOnDone = downloadTarget.value === 'feiniu'
   const s = store.settings
   const defQ = s?.defaultDownloadQuality ?? ''
   if (s?.selectQualityOnDownload) {
     pendingQualitySongs.value = songs
+    pendingClearSelection.value = clearSelection
     chosenQuality.value = defQ && qualityOptionsFor(songs).includes(defQ) ? defQ : ''
     qualityDialogOpen.value = true
   } else {
-    doDownload(songs, defQ)
+    void doDownload(songs, defQ, clearSelection)
   }
 }
 function confirmQualityDialog() {
   qualityDialogOpen.value = false
-  doDownload(pendingQualitySongs.value, chosenQuality.value)
+  const songs = pendingQualitySongs.value
+  const clear = pendingClearSelection.value
   pendingQualitySongs.value = []
+  pendingClearSelection.value = false
+  void doDownload(songs, chosenQuality.value, clear)
 }
-
 function downloadOne(song: MusicSong) {
   requestDownloadFlow([song])
 }
 function downloadSelected() {
-  if (selectedSongs.value.length === 0) return
-  requestDownloadFlow(selectedSongs.value)
-  selectedKeys.value = new Set()
+  const songs = selectedSongs.value
+  if (songs.length === 0) return
+  requestDownloadFlow(songs, true)
 }
 
-// 任务展示辅助
-const taskStatusInfo = (task: MusicDownloadTask): { label: string; variant: 'default' | 'secondary' | 'destructive' | 'outline'; class?: string } => {
+// ===== 任务展示 =====
+const taskStatusInfo = (
+  task: MusicDownloadTask
+): { label: string; variant: 'default' | 'secondary' | 'destructive' | 'outline'; class?: string } => {
   switch (task.status) {
     case 'downloading':
       return { label: '下载中', variant: 'default' }
@@ -535,22 +708,17 @@ const formatBytes = (n?: number) => {
 }
 const songPercent = (st: MusicDownloadSongState) =>
   st.total > 0 ? Math.min(100, Math.round(((st.downloaded ?? 0) / st.total) * 100)) : 0
-
-/** 任务卡片首行标题：歌名（主）+ 副标题（歌手，多首追加"等 N 首"） */
 function taskHeadInfo(task: MusicDownloadTask): { name: string; sub: string } {
   const st = task.songs[0]
   if (!st) return { name: '', sub: '' }
   const n = task.songs.length
-  const sub = (st.singers || '未知歌手') + (n > 1 ? ` 等 ${n} 首` : '')
-  return { name: st.songName, sub }
+  return { name: st.songName, sub: (st.singers || '未知歌手') + (n > 1 ? ` 等 ${n} 首` : '') }
 }
 const taskAggDone = (task: MusicDownloadTask) => task.songs.reduce((a, s) => a + (s.downloaded || 0), 0)
 const taskAggTotal = (task: MusicDownloadTask) => task.songs.reduce((a, s) => a + (s.total || 0), 0)
-/** 任务音质展示：优先实际解析出的档位（start 事件回传），未知时回退请求档位（如"最高"） */
 const taskQualityDisplay = (task: MusicDownloadTask) =>
   task.songs.find((s) => s.quality)?.quality || task.quality || ''
 
-// ===== 任务歌曲列表截断（大歌单任务避免一次挂几百行 DOM） =====
 const TASK_SONGS_PREVIEW = 20
 const expandedTasks = ref<Set<string>>(new Set())
 function toggleTaskExpanded(taskId: string) {
@@ -560,13 +728,10 @@ function toggleTaskExpanded(taskId: string) {
   expandedTasks.value = next
 }
 function visibleSongs(task: MusicDownloadTask): MusicDownloadSongState[] {
-  return expandedTasks.value.has(task.taskId)
-    ? task.songs
-    : task.songs.slice(0, TASK_SONGS_PREVIEW)
+  return expandedTasks.value.has(task.taskId) ? task.songs : task.songs.slice(0, TASK_SONGS_PREVIEW)
 }
 
-// ===== 设置（400ms debounce 保存） =====
-// v-model 需要可赋值目标，用可写 computed 包装 store.settings 字段
+// ===== 设置 =====
 const settingsSources = computed<string[]>({
   get: () => store.settings?.sources ?? [],
   set: (v) => {
@@ -646,7 +811,6 @@ async function browseDir() {
   }
 }
 
-const appDataPath = ref('')
 const runtimeDisplay = computed(() => {
   const p = store.env?.runtimeDir
   if (!p) return ''
@@ -656,7 +820,6 @@ const runtimeDisplay = computed(() => {
   return p
 })
 
-// ===== 环境检查 =====
 const pinging = ref(false)
 async function testBridge() {
   pinging.value = true
@@ -682,707 +845,869 @@ async function doInstall() {
 
 const installPercent = computed(() => store.installProgress?.percent ?? 0)
 const installMessage = computed(() => store.installProgress?.message ?? '')
+const diagnosticsOpen = ref(false)
+
+/** 发现音乐结果行网格（表头与行保持一致） */
+const RESULT_GRID = { gridTemplateColumns: '24px 36px minmax(0,1fr) 108px 52px 92px' }
 </script>
 
 <template>
   <div class="h-full p-6 overflow-hidden flex flex-col">
-    <Tabs v-model="activeTab" class="h-full flex flex-col">
-      <div ref="tabsListRef">
-        <TabsList class="grid w-full grid-cols-4 max-w-md !bg-transparent !p-0 !shadow-none">
-          <TabsTrigger value="mymusic" class="gap-1.5"><Music2 class="size-3.5" />我的音乐</TabsTrigger>
+    <Tabs v-model="activeTab" class="min-h-0 flex-1 flex flex-col">
+      <!-- ===== 模块导航（与其他模块保持一致的 Tabs 写法） ===== -->
+      <div ref="tabsListRef" class="shrink-0">
+        <TabsList class="grid w-full max-w-md grid-cols-4 !bg-transparent !p-0 !shadow-none">
+          <TabsTrigger value="mymusic" class="gap-1.5"><Library class="size-3.5" />曲库</TabsTrigger>
           <TabsTrigger value="discover" class="gap-1.5"><Search class="size-3.5" />发现音乐</TabsTrigger>
-          <TabsTrigger value="tasks" class="gap-1.5"><ListMusic class="size-3.5" />下载任务</TabsTrigger>
+          <TabsTrigger value="tasks" class="gap-1.5">
+            <ListMusic class="size-3.5" />下载任务
+          </TabsTrigger>
           <TabsTrigger value="settings" class="gap-1.5"><SettingsIcon class="size-3.5" />设置</TabsTrigger>
         </TabsList>
       </div>
 
-      <!-- ============ 我的音乐 ============ -->
-      <TabsContent value="mymusic" class="flex-1 mt-4 min-h-0 tab-animate">
+      <!-- ===== 曲库 ===== -->
+      <TabsContent value="mymusic" class="mt-4 min-h-0 flex-1 tab-animate">
         <MyMusicLibrary />
       </TabsContent>
 
-      <!-- ============ 发现音乐（原搜索页 + 下载目标） ============ -->
-      <TabsContent value="discover" class="flex-1 mt-4 min-h-0 tab-animate">
-        <ScrollArea class="h-full pr-3">
-          <div class="flex flex-col gap-4 px-1 pt-1 pb-4 min-w-0">
-        <!-- 下载目标选择 -->
-        <div class="flex items-center gap-3 rounded-lg border bg-card px-3 py-2">
-          <div class="flex items-center gap-2 text-sm">
-            <Database class="size-4 text-muted-foreground" />
-            <span class="text-muted-foreground">下载到</span>
-          </div>
-          <Select v-model="downloadTarget">
-            <SelectTrigger class="h-7 w-36">
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="local">本地目录</SelectItem>
-              <SelectItem value="feiniu">飞牛曲库</SelectItem>
-            </SelectContent>
-          </Select>
-          <span class="text-xs text-muted-foreground">
-            {{ downloadTarget === 'local' ? '下载到本地目录（musicdl）' : '下载后自动上传到飞牛曲库（需已连接 NAS 文件服务）' }}
-          </span>
-        </div>
-        <!-- 搜索工具栏 -->
-        <div class="flex items-center gap-2">
-          <div class="flex-1 relative">
-            <Input
-              v-model="keyword"
-              placeholder="输入歌名 / 歌手 / 专辑关键词，如：海阔天空"
-              @keydown.enter="onKeywordEnter"
-              @focus="historyOpen = true"
-              @focusout="historyOpen = false"
-            />
-            <!-- 搜索历史下拉（聚焦时显示；mousedown.prevent 保证点选先于失焦） -->
-            <div
-              v-if="historyOpen && filteredHistory.length > 0"
-              class="absolute left-0 top-full z-50 mt-1 w-full rounded-lg border bg-popover p-1 shadow-md"
-              @mousedown.prevent
-            >
-              <div class="flex items-center justify-between px-2 py-1">
-                <span class="text-[10px] text-muted-foreground flex items-center gap-1">
-                  <History class="size-3" /> 搜索历史
-                </span>
-                <button class="text-[10px] text-muted-foreground hover:text-foreground" @click="clearHistory">
-                  清空
-                </button>
-              </div>
-              <button
-                v-for="h in filteredHistory"
-                :key="h"
-                class="flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left text-sm hover:bg-muted/50 truncate"
-                @mousedown.prevent="pickHistory(h)"
-              >
-                <History class="size-3.5 shrink-0 text-muted-foreground" />
-                <span class="truncate">{{ h }}</span>
+      <!-- ===== 发现音乐 ===== -->
+      <TabsContent value="discover" class="mt-4 min-h-0 flex-1 flex flex-col tab-animate">
+        <!-- 工具栏：搜索主操作留在首行 -->
+        <header class="flex shrink-0 items-center gap-2 border-b pb-3">
+        <div ref="searchBoxRef" class="relative min-w-0 flex-1 max-w-md" @focusin="historyOpen = true" @focusout="onHistoryFocusOut">
+          <Search class="pointer-events-none absolute left-2.5 top-1/2 size-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input
+            v-model="keyword"
+            class="h-9 pl-8"
+            placeholder="搜索歌名 / 歌手 / 专辑"
+            @keydown.enter="doSearch"
+          />
+          <div
+            v-if="historyOpen && filteredHistory.length > 0"
+            class="absolute left-0 top-full z-50 mt-1 w-full rounded-lg border bg-popover p-1 shadow-md"
+          >
+            <div class="flex items-center justify-between px-2 py-1">
+              <span class="flex items-center gap-1 text-[10px] text-muted-foreground">
+                <History class="size-3" /> 搜索历史
+              </span>
+              <button type="button" class="text-[10px] text-muted-foreground hover:text-foreground" @click="clearHistory">
+                清空
               </button>
             </div>
+            <button
+              v-for="h in filteredHistory"
+              :key="h"
+              type="button"
+              class="flex w-full items-center gap-2 truncate rounded-md px-2 py-1.5 text-left text-[13px] hover:bg-accent/60"
+              @click="pickHistory(h)"
+            >
+              <History class="size-3.5 shrink-0 text-muted-foreground" />
+              <span class="truncate">{{ h }}</span>
+            </button>
           </div>
-          <SourcePicker v-model="settingsSources" :options="sourceOptions" />
-          <Button v-if="selectedSongs.length > 0" size="sm" variant="secondary" @click="downloadSelected">
-            <Download class="size-4" />
+        </div>
+
+        <SourcePicker v-model="settingsSources" :options="sourceOptions" />
+
+        <Popover v-model:open="playlistLinkOpen">
+          <PopoverTrigger as-child>
+            <Button variant="outline" size="sm" class="h-9">
+              <Link2 class="size-3.5" />
+              <span class="ml-1.5">歌单链接</span>
+            </Button>
+          </PopoverTrigger>
+          <PopoverContent class="w-96 p-3" align="start">
+            <p class="mb-2 text-[12px] text-muted-foreground">
+              粘贴网易云 / QQ 音乐等歌单链接，解析后可直接批量试听与下载。
+            </p>
+            <div class="flex items-center gap-2">
+              <Input
+                v-model="playlistUrl"
+                class="h-8"
+                placeholder="https://music.163.com/playlist?id=..."
+                @keydown.enter="doParsePlaylist"
+              />
+              <Button size="sm" class="h-8 shrink-0" :disabled="parsingPlaylist" @click="doParsePlaylist">
+                <Loader2 v-if="parsingPlaylist" class="size-3.5 animate-spin" />
+                <span :class="parsingPlaylist ? 'ml-1.5' : ''">{{ parsingPlaylist ? '解析中' : '解析' }}</span>
+              </Button>
+            </div>
+          </PopoverContent>
+        </Popover>
+
+        <Button class="h-9" :disabled="store.searching" @click="doSearch">
+          <Loader2 v-if="store.searching" class="size-4 animate-spin" />
+          <Search v-else class="size-4" />
+          <span class="ml-1.5">{{ store.searching ? '搜索中' : '搜索' }}</span>
+        </Button>
+      </header>
+
+      <!-- 筛选条 -->
+      <div
+        v-if="flatResults.length > 0"
+        class="flex shrink-0 flex-wrap items-center gap-x-3 gap-y-2 border-b py-2 text-[12px] text-muted-foreground"
+      >
+        <label class="flex cursor-pointer items-center gap-1.5">
+          <Checkbox
+            :model-value="allSelected"
+            :aria-label="'全选当前结果'"
+            @update:model-value="toggleSelectAll"
+          />
+          全选
+        </label>
+        <span>
+          共 {{ store.resultTotal }} 条<template v-if="sourceFilter !== 'all' || qualityFilter !== 'all'">
+            （筛选后 {{ filteredResults.length }} 条）</template
+          >
+        </span>
+
+        <div class="ml-auto flex items-center gap-2">
+          <Select v-model="sourceFilter">
+            <SelectTrigger class="h-7 w-28 text-[12px]"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="all">全部来源</SelectItem>
+              <SelectItem v-for="s in availableResultSources" :key="s" :value="s">{{ sourceName(s) }}</SelectItem>
+            </SelectContent>
+          </Select>
+
+          <Select v-model="qualityFilter">
+            <SelectTrigger class="h-7 w-24 text-[12px]"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="all">全部音质</SelectItem>
+              <SelectItem value="lossless">仅无损</SelectItem>
+              <SelectItem value="mp3">仅 MP3</SelectItem>
+            </SelectContent>
+          </Select>
+
+          <Select v-model="downloadTarget">
+            <SelectTrigger class="h-7 w-28 text-[12px]"><SelectValue /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="local">下载到本地</SelectItem>
+              <SelectItem value="feiniu">下载到飞牛</SelectItem>
+            </SelectContent>
+          </Select>
+
+          <Button
+            v-if="selectedSongs.length > 0"
+            size="sm"
+            class="h-7"
+            variant="secondary"
+            @click="downloadSelected"
+          >
+            <Download class="size-3.5" />
             <span class="ml-1.5">下载所选 ({{ selectedSongs.length }})</span>
           </Button>
-          <Button size="sm" :disabled="store.searching" @click="doSearch">
-            <Loader2 v-if="store.searching" class="size-4 animate-spin" />
-            <Search v-else class="size-4" />
-            <span class="ml-1.5">{{ store.searching ? '搜索中' : '搜索' }}</span>
-          </Button>
         </div>
+      </div>
 
-        <!-- 歌单解析 -->
-        <div class="flex items-center gap-2 rounded-lg border bg-muted/30 px-2 py-1.5">
-          <ListMusic class="size-4 text-muted-foreground shrink-0" />
-          <Input
-            v-model="playlistUrl"
-            placeholder="粘贴歌单链接（网易云 / QQ 音乐等），回车解析全部歌曲"
-            class="h-8 flex-1 border-0 bg-transparent shadow-none focus-visible:ring-0"
-            @keydown.enter="doParsePlaylist"
-          />
-          <Button
-            size="sm"
-            variant="outline"
-            class="shrink-0"
-            :disabled="parsingPlaylist"
-            @click="doParsePlaylist"
-          >
-            <Loader2 v-if="parsingPlaylist" class="size-3.5 animate-spin" />
-            <ListMusic v-else class="size-3.5" />
-            <span class="ml-1.5">{{ parsingPlaylist ? '解析中' : '解析歌单' }}</span>
-          </Button>
-        </div>
-
-        <!-- 搜索结果 -->
-        <div v-if="store.searching" class="space-y-2">
-          <div v-for="i in 6" :key="i" class="h-12 rounded-lg bg-muted/40 animate-pulse" />
-        </div>
-
-        <Empty v-else-if="store.searchError" class="min-h-40">
-          <CircleAlert class="size-10 text-destructive" />
-          <p class="text-sm text-muted-foreground">搜索失败：{{ store.searchError }}</p>
-        </Empty>
-
-        <Empty v-else-if="store.resultTotal === 0 && store.searched" class="min-h-40">
-          <Info class="size-10 text-muted-foreground" />
-          <p class="text-sm text-muted-foreground">未找到相关歌曲，试试更换关键词或增加搜索源</p>
-        </Empty>
-
-        <template v-else-if="flatResults.length > 0">
-          <div class="flex items-center gap-2 text-sm text-muted-foreground">
-            <Checkbox
-              :model-value="allSelected"
-              class="align-middle"
-              aria-label="全选当前结果"
-              @update:model-value="toggleSelectAll"
-            />
-            <span>
-              共 {{ store.resultTotal }} 条结果
-              <template v-if="sourceFilter !== 'all' || qualityFilter !== 'all'">（筛选后 {{ filteredResults.length }} 条）</template>
-            </span>
-            <Select v-model="sourceFilter" class="w-32 ml-auto">
-              <SelectTrigger class="h-7 text-xs">
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="all">全部来源</SelectItem>
-                <SelectItem v-for="s in availableResultSources" :key="s" :value="s">
-                  {{ sourceName(s) }}
-                </SelectItem>
-              </SelectContent>
-            </Select>
-            <Select v-model="qualityFilter" class="w-28">
-              <SelectTrigger class="h-7 text-xs">
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="all">全部音质</SelectItem>
-                <SelectItem value="lossless">仅无损</SelectItem>
-                <SelectItem value="mp3">仅 MP3</SelectItem>
-              </SelectContent>
-            </Select>
+      <!-- 结果列表 -->
+      <ScrollArea class="min-h-0 flex-1">
+        <div class="pb-4">
+          <div v-if="store.searching" class="space-y-1.5 pt-3">
+            <div v-for="i in 8" :key="i" class="h-11 animate-pulse rounded-md bg-muted/40" />
           </div>
-          <div class="space-y-2 pb-4">
+
+          <Empty v-else-if="store.searchError">
+            <EmptyMedia><CircleAlert class="size-8 text-destructive" /></EmptyMedia>
+            <EmptyTitle>搜索失败</EmptyTitle>
+            <EmptyDescription>{{ store.searchError }}</EmptyDescription>
+          </Empty>
+
+          <Empty v-else-if="store.resultTotal === 0 && store.searched">
+            <EmptyMedia><Info class="size-8 text-muted-foreground" /></EmptyMedia>
+            <EmptyTitle>未找到相关歌曲</EmptyTitle>
+            <EmptyDescription>试试更换关键词，或在右上角增加搜索源。</EmptyDescription>
+          </Empty>
+
+          <Empty v-else-if="flatResults.length === 0">
+            <EmptyMedia><Music2 class="size-8 text-muted-foreground" /></EmptyMedia>
+            <EmptyTitle>搜索多个平台的音乐</EmptyTitle>
+            <EmptyDescription>
+              输入关键词后回车即可聚合搜索；也可以粘贴歌单链接批量导入。
+            </EmptyDescription>
+          </Empty>
+
+          <template v-else>
             <template v-for="d in visibleItems" :key="d.type === 'header' ? `h:${d.source}` : d.song!.key">
-              <!-- 源分组头：组级全选 -->
-              <div v-if="d.type === 'header'" class="flex items-center gap-2 pt-1.5 pb-0.5">
+              <!-- 分组头：不设底色/不吸顶，避免在浅色背景上出现白色横条 -->
+              <div
+                v-if="d.type === 'header'"
+                class="flex items-center gap-2 border-b border-border/60 px-2 py-1.5"
+              >
                 <Checkbox
-                  :model-value="groupAllSelected(d.source!)"
+                  :model-value="d.allSelected"
                   class="size-3.5"
                   :aria-label="`全选 ${sourceName(d.source!)} 结果`"
-                  @update:model-value="toggleSelectGroup(d.source!)"
+                  @update:model-value="toggleSelectGroup(d)"
                 />
-                <span class="text-xs font-semibold">{{ sourceName(d.source!) }}</span>
-                <span class="text-xs text-muted-foreground">{{ d.count }} 首</span>
+                <span class="text-[12px] font-medium">{{ sourceName(d.source!) }}</span>
+                <span class="text-[11.5px] text-muted-foreground">{{ d.count }} 首</span>
               </div>
+
               <!-- 歌曲行 -->
-              <div v-else class="flex items-center gap-3 rounded-lg border bg-card p-2.5">
+              <div
+                v-else
+                class="group grid h-11 items-center gap-3 rounded-md px-2 transition-colors hover:bg-accent/40"
+                :style="RESULT_GRID"
+              >
                 <Checkbox
                   :model-value="selectedKeys.has(d.song!.key)"
+                  class="size-3.5"
+                  :aria-label="`选择 ${d.song!.song.songName}`"
                   @update:model-value="toggleSelect(d.song!.key)"
-                  class="shrink-0"
                 />
+
                 <img
                   v-if="d.song!.song.coverUrl"
                   :src="d.song!.song.coverUrl"
-                  class="size-10 rounded-md object-cover shrink-0"
+                  class="size-9 rounded object-cover"
                   referrerpolicy="no-referrer"
                   loading="lazy"
                   alt=""
                   @error="($event.target as HTMLImageElement).style.display = 'none'"
                 />
-                <div v-else class="size-10 rounded-md bg-muted shrink-0" />
-                <div class="flex-1 min-w-0">
-                  <div class="flex items-center gap-2">
-                    <span class="text-sm font-medium truncate">{{ d.song!.song.songName }}</span>
-                    <!-- 懒解析歌多档位徽标（格式 + 大小 + 无损） -->
-                    <template v-if="d.song!.song.qualities?.length">
-                      <Badge
-                        v-for="(q, qi) in visibleTiers(d.song!.song.qualities)"
-                        :key="q.label ?? qi"
-                        variant="outline"
-                        :class="'shrink-0 text-[10px] ' + qualityTagClass(q)"
-                      >
-                        {{ q.label }}<span v-if="q.ext" class="uppercase"> {{ q.ext }}</span><span v-if="q.size" class="text-muted-foreground"> {{ q.size }}</span>
-                      </Badge>
-                      <Tooltip v-if="(d.song!.song.qualities?.length ?? 0) > maxTiers">
-                        <TooltipTrigger as-child>
-                          <Badge variant="outline" class="shrink-0 text-[10px] text-muted-foreground cursor-default">
-                            +{{ (d.song!.song.qualities?.length ?? 0) - maxTiers }}
-                          </Badge>
-                        </TooltipTrigger>
-                        <TooltipContent class="max-w-64 space-y-1">
-                          <div
-                            v-for="(q, qi) in d.song!.song.qualities"
-                            :key="q.label ?? qi"
-                            class="flex items-center justify-between gap-4 text-xs"
-                          >
-                            <span>{{ q.label }} {{ (q.ext || '').toUpperCase() }}</span>
-                            <span class="text-muted-foreground">{{ q.size || (q.bitrate ? q.bitrate + 'kbps' : '') }}</span>
-                          </div>
-                        </TooltipContent>
-                      </Tooltip>
-                    </template>
-                    <!-- 急切解析歌 / 无档位数据：单格式徽标 + lossless 兜底 -->
-                    <template v-else>
-                      <Badge v-if="d.song!.song.ext" variant="secondary" class="shrink-0 text-[10px]">{{ d.song!.song.ext }}</Badge>
-                      <Badge v-else-if="d.song!.song.lossless" variant="outline" class="shrink-0 text-[10px] text-muted-foreground">无损</Badge>
-                      <Badge v-else variant="outline" class="shrink-0 text-[10px] text-muted-foreground">未知</Badge>
-                      <Badge
-                        v-if="formatBitrate(d.song!.song.bitrate)"
-                        variant="outline"
-                        class="shrink-0 text-[10px] text-muted-foreground"
-                      >
-                        {{ formatBitrate(d.song!.song.bitrate) }}
-                      </Badge>
-                    </template>
-                  </div>
-                  <div class="text-xs text-muted-foreground truncate mt-0.5">
-                    {{ d.song!.song.singers || '未知歌手' }}
-                    <span v-if="d.song!.song.album"> · {{ d.song!.song.album }}</span>
+                <div v-else class="flex size-9 items-center justify-center rounded bg-muted text-muted-foreground">
+                  <Music2 class="size-4" />
+                </div>
+
+                <div class="min-w-0">
+                  <div class="truncate text-[13px]">{{ d.song!.song.songName || '未知歌名' }}</div>
+                  <div class="truncate text-[11.5px] text-muted-foreground">
+                    {{ d.song!.song.singers || '未知歌手'
+                    }}<template v-if="d.song!.song.album"> · {{ d.song!.song.album }}</template>
                   </div>
                 </div>
-                <div class="flex items-center gap-2 shrink-0">
-                  <span class="text-xs text-muted-foreground hidden sm:block">{{ formatDuration(d.song!.song.durationS, d.song!.song.duration) }}</span>
-                  <span v-if="!d.song!.song.qualities?.length" class="text-xs text-muted-foreground hidden sm:block">{{ d.song!.song.fileSize || '' }}</span>
-                  <Tooltip>
-                    <TooltipTrigger as-child>
-                      <Button
-                        size="icon"
-                        variant="ghost"
-                        class="size-8"
-                        :disabled="(!d.song!.song.downloadUrl && !d.song!.song.rawSearch) || resolvingKeys.has(d.song!.key)"
-                        @click="togglePlay(d.song!.song, d.song!.source, d.song!.index)"
+
+                <!-- 音质：单枚中性徽标，点击查看全部档位 -->
+                <div class="min-w-0">
+                  <Popover v-if="d.song!.song.qualities?.length">
+                    <PopoverTrigger as-child>
+                      <button
+                        type="button"
+                        class="inline-flex max-w-full items-center gap-1 rounded border border-border px-1.5 py-0.5 text-[10.5px] text-muted-foreground transition-colors hover:bg-accent"
                       >
-                        <Loader2 v-if="resolvingKeys.has(d.song!.key)" class="size-4 animate-spin" />
-                        <Play v-else-if="playingKey !== d.song!.key" class="size-4" />
-                        <Square v-else class="size-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>
-                      {{
-                        resolvingKeys.has(d.song!.key) ? '解析中...' :
-                        d.song!.song.downloadUrl ? (playingKey === d.song!.key ? '停止试听' : '在线试听') :
-                        d.song!.song.rawSearch ? '试听' : '付费/无播放源'
-                      }}
-                    </TooltipContent>
-                  </Tooltip>
-                  <Tooltip>
-                    <TooltipTrigger as-child>
-                      <Button
-                        size="icon"
-                        variant="ghost"
-                        class="size-8"
-                        :disabled="!d.song!.song.downloadUrl && !d.song!.song.rawSearch"
-                        @click="downloadOne(d.song!.song)"
-                      >
-                        <Download class="size-4" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>
-                      {{ d.song!.song.downloadUrl ? '下载' : d.song!.song.rawSearch ? '下载' : '付费/无下载源' }}
-                    </TooltipContent>
-                  </Tooltip>
+                        <span class="truncate">{{ qualitySummary(d.song!.song) }}</span>
+                        <span v-if="d.song!.song.qualities.length > 1" class="shrink-0">
+                          +{{ d.song!.song.qualities.length - 1 }}
+                        </span>
+                      </button>
+                    </PopoverTrigger>
+                    <PopoverContent class="w-60 p-2" align="start">
+                      <p class="px-1 pb-1.5 text-[11px] text-muted-foreground">可选音质档位</p>
+                      <div class="flex flex-col gap-0.5">
+                        <div
+                          v-for="(q, qi) in d.song!.song.qualities"
+                          :key="q.label ?? qi"
+                          class="flex items-center justify-between gap-3 rounded px-1.5 py-1 text-[12px]"
+                        >
+                          <span>{{ q.label || '未知' }}<span v-if="q.ext" class="ml-1 uppercase text-muted-foreground">{{ q.ext }}</span></span>
+                          <span class="shrink-0 text-[11px] tabular-nums text-muted-foreground">
+                            {{ q.size || formatBitrate(q.bitrate) }}
+                          </span>
+                        </div>
+                      </div>
+                    </PopoverContent>
+                  </Popover>
+                  <span v-else-if="qualitySummary(d.song!.song)" class="text-[11px] text-muted-foreground">
+                    {{ qualitySummary(d.song!.song) }}
+                  </span>
+                </div>
+
+                <span class="text-right text-[11.5px] tabular-nums text-muted-foreground">
+                  {{ formatDuration(d.song!.song.durationS, d.song!.song.duration) }}
+                </span>
+
+                <!-- 操作：悬停显现，保持行内干净 -->
+                <div class="flex items-center justify-end gap-0.5 opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100">
+                  <Button
+                    size="icon"
+                    variant="ghost"
+                    class="size-7"
+                    :disabled="(!d.song!.song.downloadUrl && !d.song!.song.rawSearch) || resolvingKeys.has(d.song!.key)"
+                    :title="
+                      resolvingKeys.has(d.song!.key)
+                        ? '解析中…'
+                        : previewKey === d.song!.key
+                          ? '停止试听'
+                          : d.song!.song.downloadUrl || d.song!.song.rawSearch
+                            ? '在线试听'
+                            : '无可用播放源'
+                    "
+                    @click="togglePreview(d.song!.song, d.song!.source, d.song!.index)"
+                  >
+                    <Loader2 v-if="resolvingKeys.has(d.song!.key)" class="size-3.5 animate-spin" />
+                    <Square v-else-if="previewKey === d.song!.key" class="size-3.5" />
+                    <Play v-else class="size-3.5" />
+                  </Button>
+                  <Button
+                    size="icon"
+                    variant="ghost"
+                    class="size-7"
+                    :disabled="!d.song!.song.downloadUrl && !d.song!.song.rawSearch"
+                    :title="d.song!.song.downloadUrl || d.song!.song.rawSearch ? '下载' : '无可用下载源'"
+                    @click="downloadOne(d.song!.song)"
+                  >
+                    <Download class="size-3.5" />
+                  </Button>
+                  <!-- 下载 + 上传飞牛一条龙（本地不留文件） -->
+                  <Button
+                    size="icon"
+                    variant="ghost"
+                    class="size-7"
+                    :disabled="(!d.song!.song.downloadUrl && !d.song!.song.rawSearch) || feiniuUploadingKeys.has(d.song!.key)"
+                    :title="
+                      feiniuUploadingKeys.has(d.song!.key)
+                        ? '正在上传到飞牛…'
+                        : !d.song!.song.downloadUrl && !d.song!.song.rawSearch
+                          ? '无可用下载源'
+                          : feiniu.webdavReady
+                            ? '下载并上传到飞牛曲库（不保留本地文件）'
+                            : '下载到飞牛（需先在设置中完成 WebDAV 配置）'
+                    "
+                    @click="downloadToFeiniu(d.song!.song, d.song!.source, d.song!.index)"
+                  >
+                    <Loader2 v-if="feiniuUploadingKeys.has(d.song!.key)" class="size-3.5 animate-spin" />
+                    <CloudUpload v-else class="size-3.5" />
+                  </Button>
                 </div>
               </div>
             </template>
-            <!-- 增量加载哨兵：进入视口自动追加下一批 -->
-            <div v-if="hasMore" ref="loadMoreRef" class="flex items-center justify-center gap-1.5 py-2 text-xs text-muted-foreground">
-              <Loader2 class="size-3.5 animate-spin" />
-              加载更多（{{ visibleItems.length }}/{{ displayItems.length }}）...
-            </div>
-          </div>
-        </template>
 
-        <Empty v-else class="min-h-40">
-          <Info class="size-10 text-muted-foreground" />
-          <p class="text-sm text-muted-foreground">输入关键词开始搜索，音乐将在多个平台聚合</p>
-        </Empty>
-          </div>
-        </ScrollArea>
+            <div
+              v-if="hasMore"
+              ref="loadMoreRef"
+              class="flex items-center justify-center gap-1.5 py-3 text-[11.5px] text-muted-foreground"
+            >
+              <Loader2 class="size-3.5 animate-spin" />
+              加载更多（{{ visibleItems.length }}/{{ displayItems.length }}）
+            </div>
+          </template>
+        </div>
+      </ScrollArea>
       </TabsContent>
 
-      <!-- ============ 下载任务页 ============ -->
-      <TabsContent value="tasks" class="flex-1 mt-4 min-h-0 tab-animate">
-        <ScrollArea class="h-full pr-3">
-          <div class="flex flex-col gap-3 pb-4 min-w-0">
-        <Empty v-if="store.tasks.length === 0" class="min-h-40">
-          <Download class="size-10 text-muted-foreground" />
-          <p class="text-sm text-muted-foreground">暂无下载任务，去「搜索」页选择歌曲下载</p>
-        </Empty>
-        <div v-else class="space-y-2">
-          <!-- py-0 覆盖 Card 根默认 py-6：紧凑列表卡片，内边距由 CardContent 的 py-2 提供 -->
-          <Card v-for="task in store.tasks" :key="task.taskId" class="gap-0 py-0">
-            <CardContent class="px-3 py-2 space-y-1.5">
-              <!-- 单行标题：状态Tag · 歌名 · 歌手 · 音质tag …… 已下载/总大小 [取消][打开文件夹][删除] -->
-              <div class="flex items-center gap-2 min-w-0">
-                <Badge :variant="taskStatusInfo(task).variant" :class="['shrink-0', taskStatusInfo(task).class]">
-                  {{ taskStatusInfo(task).label }}
-                </Badge>
-                <span class="flex-1 min-w-0 truncate text-sm">
-                  {{ taskHeadInfo(task).name }}<span v-if="taskHeadInfo(task).sub" class="text-xs text-muted-foreground"> · {{ taskHeadInfo(task).sub }}</span>
+      <!-- ===== 下载任务 ===== -->
+      <TabsContent value="tasks" class="mt-4 min-h-0 flex-1 tab-animate">
+        <ScrollArea class="h-full">
+          <div class="mx-auto flex w-full max-w-4xl flex-col gap-2 py-4">
+          <Empty v-if="store.tasks.length === 0">
+            <EmptyMedia><Download class="size-8 text-muted-foreground" /></EmptyMedia>
+            <EmptyTitle>暂无下载任务</EmptyTitle>
+            <EmptyDescription>到「发现音乐」搜索并选择歌曲下载，任务会显示在这里。</EmptyDescription>
+          </Empty>
+
+          <div
+            v-for="task in store.tasks"
+            :key="task.taskId"
+            class="rounded-lg border bg-card p-3"
+          >
+            <!-- 第一行：状态 · 标题 · 音质 · ⋯ -->
+            <div class="flex min-w-0 items-center gap-2">
+              <Badge :variant="taskStatusInfo(task).variant" :class="['shrink-0', taskStatusInfo(task).class]">
+                {{ taskStatusInfo(task).label }}
+              </Badge>
+              <span class="min-w-0 flex-1 truncate text-[13px]">
+                {{ taskHeadInfo(task).name }}
+                <span v-if="taskHeadInfo(task).sub" class="text-[11.5px] text-muted-foreground">
+                  · {{ taskHeadInfo(task).sub }}
                 </span>
-                <Badge
-                  v-if="taskQualityDisplay(task)"
-                  variant="outline"
-                  :class="['shrink-0 text-[10px]', qualityLabelClass(taskQualityDisplay(task))]"
-                >
-                  {{ taskQualityDisplay(task) }}
-                </Badge>
-                <span class="text-xs tabular-nums text-muted-foreground shrink-0">
-                  {{ formatBytes(taskAggDone(task)) }}<template v-if="taskAggTotal(task)"> / {{ formatBytes(taskAggTotal(task)) }}</template>
-                </span>
-                <div class="flex items-center gap-0.5 shrink-0">
-                  <Tooltip v-if="task.status === 'downloading' || task.status === 'cancelling'">
-                    <TooltipTrigger as-child>
-                      <Button
-                        variant="ghost"
-                        size="icon"
-                        class="size-7"
-                        :disabled="task.status === 'cancelling'"
-                        @click="store.cancelDownload(task.taskId)"
-                      >
-                        <X class="size-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>取消下载</TooltipContent>
-                  </Tooltip>
-                  <Tooltip v-if="task.savedir">
-                    <TooltipTrigger as-child>
-                      <Button variant="ghost" size="icon" class="size-7" @click="openDir(task.savedir)">
-                        <FolderOpen class="size-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>打开下载目录</TooltipContent>
-                  </Tooltip>
-                  <Tooltip v-if="task.status === 'done'">
-                    <TooltipTrigger as-child>
-                      <Button
-                        variant="ghost"
-                        size="icon"
-                        class="size-7"
-                        :disabled="feiniu.uploading"
-                        @click="uploadRecentToFeiniu"
-                      >
-                        <Upload class="size-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>上传到飞牛曲库</TooltipContent>
-                  </Tooltip>
-                  <Tooltip>
-                    <TooltipTrigger as-child>
-                      <Button variant="ghost" size="icon" class="size-7" @click="store.removeTask(task.taskId)">
-                        <Trash2 class="size-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>删除任务</TooltipContent>
-                  </Tooltip>
-                </div>
-              </div>
-              <!-- 单曲任务进度条（多首任务的进度在下方歌曲行内展示） -->
+              </span>
+              <span
+                v-if="taskQualityDisplay(task)"
+                class="shrink-0 rounded border border-border px-1.5 py-0.5 text-[10.5px] text-muted-foreground"
+              >
+                {{ taskQualityDisplay(task) }}
+              </span>
+              <Button
+                v-if="task.status === 'downloading' || task.status === 'cancelling'"
+                variant="ghost"
+                size="icon"
+                class="size-7 shrink-0"
+                :disabled="task.status === 'cancelling'"
+                title="取消下载"
+                @click="store.cancelDownload(task.taskId)"
+              >
+                <X class="size-3.5" />
+              </Button>
+              <Button
+                v-if="task.savedir"
+                variant="ghost"
+                size="icon"
+                class="size-7 shrink-0"
+                title="打开下载目录"
+                @click="openDir(task.savedir)"
+              >
+                <FolderOpen class="size-3.5" />
+              </Button>
+              <Button
+                v-if="task.status === 'done'"
+                variant="ghost"
+                size="icon"
+                class="size-7 shrink-0"
+                :disabled="feiniu.uploading"
+                title="上传到飞牛曲库"
+                @click="uploadRecentToFeiniu"
+              >
+                <Upload class="size-3.5" />
+              </Button>
+              <Button
+                variant="ghost"
+                size="icon"
+                class="size-7 shrink-0"
+                title="删除任务"
+                @click="store.removeTask(task.taskId)"
+              >
+                <Trash2 class="size-3.5" />
+              </Button>
+            </div>
+
+            <!-- 第二行：进度 -->
+            <div class="mt-1.5 flex items-center gap-3">
               <Progress
                 v-if="task.songs.length === 1 && task.songs[0].status === 'downloading' && task.songs[0].total > 0"
                 :model-value="songPercent(task.songs[0])"
-                class="h-1"
+                class="h-1 flex-1"
               />
-              <div v-if="['error', 'cancelled', 'interrupted'].includes(task.status) && task.songsData?.length" class="flex items-center gap-2">
-                <span class="text-[11px] text-muted-foreground">未全部完成</span>
-                <Button variant="ghost" size="sm" class="h-6 px-2 text-xs" @click="store.redownloadTask(task.taskId).catch((e) => toast.error(`重新下载失败：${e}`))">
-                  <RotateCw class="size-3" />
-                  <span class="ml-1">重新下载</span>
-                </Button>
-              </div>
-              <p v-if="task.errorMessage" class="text-xs text-destructive">{{ task.errorMessage }}</p>
-              <div v-if="task.songs.length > 1" class="space-y-0.5">
-                <div v-for="st in visibleSongs(task)" :key="st.key" class="flex items-center gap-2 py-0.5">
-                  <span class="w-12 shrink-0 text-[10px] text-muted-foreground">{{ songStatusLabel(st) }}</span>
-                  <span class="flex-1 min-w-0 truncate text-sm">
-                    {{ st.songName }}
-                    <span v-if="st.singers" class="text-xs text-muted-foreground"> · {{ st.singers }}</span>
-                  </span>
-                  <span class="text-xs text-muted-foreground shrink-0">
-                    {{ formatBytes(st.downloaded) }}<template v-if="st.total"> / {{ formatBytes(st.total) }}</template>
-                  </span>
-                  <Progress
-                    v-if="st.status === 'downloading' && st.total > 0"
-                    :model-value="songPercent(st)"
-                    class="h-1 w-14 shrink-0"
-                  />
-                  <span
-                    v-else-if="st.status === 'error' && st.message"
-                    class="text-[10px] text-destructive truncate max-w-28 shrink-0"
-                    :title="st.message"
-                  >
-                    {{ st.message }}
-                  </span>
-                </div>
-                <!-- 大歌单任务折叠：默认只渲染前 20 行 -->
-                <Button
-                  v-if="task.songs.length > TASK_SONGS_PREVIEW"
-                  variant="ghost"
-                  size="sm"
-                  class="w-full text-xs text-muted-foreground"
-                  @click="toggleTaskExpanded(task.taskId)"
+              <template v-else>
+                <Progress
+                  v-if="taskAggTotal(task) > 0"
+                  :model-value="Math.min(100, Math.round((taskAggDone(task) / taskAggTotal(task)) * 100))"
+                  class="h-1 flex-1"
+                />
+              </template>
+              <span class="shrink-0 text-[11.5px] tabular-nums text-muted-foreground">
+                {{ formatBytes(taskAggDone(task)) }}<template v-if="taskAggTotal(task)">
+                  / {{ formatBytes(taskAggTotal(task)) }}</template
                 >
-                  <component :is="expandedTasks.has(task.taskId) ? ChevronUp : ChevronDown" class="size-3.5" />
-                  {{ expandedTasks.has(task.taskId) ? '收起' : `展开全部 ${task.songs.length} 首` }}
-                </Button>
+              </span>
+              <Button
+                v-if="['error', 'cancelled', 'interrupted'].includes(task.status) && task.songsData?.length"
+                variant="ghost"
+                size="sm"
+                class="h-6 shrink-0 px-2 text-[11.5px]"
+                @click="store.redownloadTask(task.taskId).catch((e) => toast.error(`重新下载失败：${e}`))"
+              >
+                <RotateCw class="size-3" />
+                <span class="ml-1">重新下载</span>
+              </Button>
+            </div>
+
+            <p v-if="task.errorMessage" class="mt-1 text-[11.5px] text-destructive">{{ task.errorMessage }}</p>
+
+            <!-- 多曲目明细 -->
+            <div v-if="task.songs.length > 1" class="mt-2 flex flex-col gap-0.5 border-t pt-2">
+              <div v-for="st in visibleSongs(task)" :key="st.key" class="flex items-center gap-2">
+                <span class="w-11 shrink-0 text-[10.5px] text-muted-foreground">{{ songStatusLabel(st) }}</span>
+                <span class="min-w-0 flex-1 truncate text-[12.5px]">{{ st.songName }}</span>
+                <Progress
+                  v-if="st.status === 'downloading' && st.total > 0"
+                  :model-value="songPercent(st)"
+                  class="h-1 w-24 shrink-0"
+                />
+                <span
+                  v-else-if="st.status === 'error' && st.message"
+                  class="shrink-0 truncate text-[10.5px] text-destructive"
+                  style="max-width: 9rem"
+                  :title="st.message"
+                >
+                  {{ st.message }}
+                </span>
+                <span class="w-20 shrink-0 text-right text-[11px] tabular-nums text-muted-foreground">
+                  {{ formatBytes(st.downloaded) }}<template v-if="st.total">
+                    / {{ formatBytes(st.total) }}</template
+                  >
+                </span>
               </div>
-            </CardContent>
-          </Card>
-        </div>
+              <button
+                v-if="task.songs.length > TASK_SONGS_PREVIEW"
+                type="button"
+                class="mt-1 flex items-center justify-center gap-1 rounded-md py-1.5 text-[11.5px] text-muted-foreground hover:bg-accent/50"
+                @click="toggleTaskExpanded(task.taskId)"
+              >
+                <component :is="expandedTasks.has(task.taskId) ? ChevronUp : ChevronDown" class="size-3.5" />
+                {{ expandedTasks.has(task.taskId) ? '收起' : `展开全部 ${task.songs.length} 首` }}
+              </button>
+            </div>
           </div>
-        </ScrollArea>
+        </div>
+      </ScrollArea>
       </TabsContent>
 
-      <!-- ============ 设置页 ============ -->
-      <TabsContent value="settings" class="flex-1 mt-4 min-h-0 tab-animate">
+      <!-- ===== 设置（与其他模块一致的 Card 卡片式布局） ===== -->
+      <TabsContent value="settings" class="mt-4 min-h-0 flex-1 tab-animate">
         <ScrollArea class="h-full pr-3">
-          <div class="flex flex-col gap-4 pb-4 min-w-0 max-w-2xl">
-        <!-- 飞牛音乐连接 -->
-        <Card>
-          <CardHeader class="pb-2">
-            <CardTitle class="flex items-center gap-2">
-              飞牛音乐连接
-            </CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ConnectionsSettings />
-          </CardContent>
-        </Card>
+          <div class="flex max-w-2xl flex-col gap-4 pb-4">
+          <!-- 连接 -->
+          <Card>
+            <CardHeader>
+              <CardTitle class="flex items-center gap-2 text-base">
+                <Link2 class="size-4 text-primary" />
+                飞牛音乐连接
+              </CardTitle>
+            </CardHeader>
+            <CardContent class="flex flex-col gap-3">
+              <p class="text-xs text-muted-foreground">
+                曲库与播放来自飞牛 NAS，可配置局域网、frp 域名或 FnConnect 三种接入方式。
+              </p>
+              <ConnectionsSettings />
+            </CardContent>
+          </Card>
 
-        <!-- 播放缓存 -->
-        <Card>
-          <CardHeader class="pb-2">
-            <CardTitle class="flex items-center gap-2">
-              播放缓存
-            </CardTitle>
-          </CardHeader>
-          <CardContent>
-            <CacheSettings />
-          </CardContent>
-        </Card>
+          <!-- 存储与上传 -->
+          <Card>
+            <CardHeader>
+              <CardTitle class="flex items-center gap-2 text-base">
+                <HardDriveDownload class="size-4 text-primary" />
+                存储与上传
+              </CardTitle>
+            </CardHeader>
+            <CardContent class="flex flex-col gap-3">
+              <p class="text-xs text-muted-foreground">
+                本地下载目录用于保存搜索下载的歌曲；NAS 文件服务用于把本地曲目回传到飞牛曲库。
+              </p>
 
-        <!-- 上传到飞牛曲库 -->
-        <Card>
-          <CardHeader class="pb-2">
-            <CardTitle class="flex items-center gap-2">
-              上传到飞牛曲库
-            </CardTitle>
-          </CardHeader>
-          <CardContent class="space-y-3">
-            <div class="flex items-center justify-between">
-              <div>
-                <div class="text-sm">NAS 文件服务</div>
-                <div class="text-xs text-muted-foreground">
-                  {{ feiniu.fnosLoggedIn ? `已连接（${feiniu.activeConn?.username || ''}）` : '未连接' }}
-                </div>
+            <div class="flex flex-col gap-1.5">
+              <Label class="text-muted-foreground">本地下载目录</Label>
+              <div class="flex items-center gap-2">
+                <Input v-model="savedirModel" class="flex-1" />
+                <Button variant="ghost" size="icon" title="打开目录" @click="openDir()">
+                  <FolderOpen class="size-4" />
+                </Button>
+                <Button variant="outline" size="sm" @click="browseDir">选择…</Button>
               </div>
-              <Badge :variant="feiniu.fnosLoggedIn ? 'default' : 'secondary'">
-                {{ feiniu.fnosLoggedIn ? '已连接' : '未连接' }}
+            </div>
+
+            <div class="flex items-center justify-between gap-4">
+              <span class="text-[13px]">WebDAV 传输（下载到飞牛 / 上传 / 删除）</span>
+              <Badge :variant="feiniu.webdavReady ? 'default' : 'secondary'">
+                {{ feiniu.webdavReady ? '已配置' : '未配置' }}
               </Badge>
             </div>
-            <p class="text-xs text-muted-foreground">
-              在「飞牛音乐连接」卡片中点击云朵图标即可登录 NAS 文件服务（仅 http 局域网直连）。
-            </p>
-            <div class="space-y-1.5">
-              <Label class="text-muted-foreground">飞牛曲库目标目录（NAS 路径）</Label>
-              <Input
-                :model-value="feiniu.libraryNasPath"
-                placeholder="vol1/1000/Music"
-                @update:model-value="(v: unknown) => feiniu.setLibraryNasPath(String(v ?? ''))"
+
+            <!-- 已配置且未在编辑：隐藏账号/密码，只显示摘要 -->
+            <template v-if="feiniu.webdavReady && !webdavEditing">
+              <div class="flex flex-col gap-1.5 rounded-md border border-border/70 px-3 py-2 text-[12.5px]">
+                <div class="flex items-center justify-between gap-4">
+                  <span class="shrink-0 text-muted-foreground">服务地址</span>
+                  <span class="truncate font-mono text-[11.5px]">{{ feiniu.webdav.url }}</span>
+                </div>
+                <div class="flex items-center justify-between gap-4">
+                  <span class="shrink-0 text-muted-foreground">曲库目标目录</span>
+                  <span class="truncate font-mono text-[11.5px]">{{ feiniu.webdav.dir }}</span>
+                </div>
+                <div class="flex items-center justify-between gap-4">
+                  <span class="shrink-0 text-muted-foreground">账号 / 密码</span>
+                  <span class="text-[11.5px] text-muted-foreground">已保存（系统凭据管理器加密存储）</span>
+                </div>
+              </div>
+              <div class="flex items-center gap-2">
+                <Button variant="outline" size="sm" @click="webdavEditing = true">修改配置</Button>
+                <Button
+                  variant="outline"
+                  size="sm"
+                  :disabled="webdavTesting || !feiniu.webdav.url || !feiniu.webdav.dir"
+                  @click="testWebdav"
+                >
+                  <Loader2 v-if="webdavTesting" class="size-3.5 animate-spin" />
+                  <span :class="webdavTesting ? 'ml-1.5' : ''">
+                    {{ webdavTesting ? '测试中…' : '测试连接' }}
+                  </span>
+                </Button>
+              </div>
+            </template>
+
+            <!-- 未配置或编辑中：完整表单（密码输入框本身即为掩码显示） -->
+            <template v-else>
+            <div class="grid grid-cols-1 gap-3 md:grid-cols-2">
+              <div class="flex flex-col gap-1.5 md:col-span-2">
+                <Label class="text-muted-foreground">WebDAV 服务地址</Label>
+                <Input
+                  :model-value="feiniu.webdav.url"
+                  placeholder="http://192.168.110.100:5005"
+                  @update:model-value="(v: unknown) => feiniu.patchWebdav({ url: String(v ?? '') })"
+                />
+              </div>
+              <div class="flex flex-col gap-1.5">
+                <Label class="text-muted-foreground">账号</Label>
+                <Input
+                  :model-value="feiniu.webdav.username"
+                  placeholder="飞牛账号"
+                  @update:model-value="(v: unknown) => feiniu.patchWebdav({ username: String(v ?? '') })"
+                />
+              </div>
+              <div class="flex flex-col gap-1.5">
+                <Label class="text-muted-foreground">密码</Label>
+                <Input
+                  :model-value="feiniu.webdav.password"
+                  type="password"
+                  placeholder="飞牛登录密码"
+                  @update:model-value="(v: unknown) => feiniu.patchWebdav({ password: String(v ?? '') })"
+                />
+              </div>
+              <div class="flex flex-col gap-1.5 md:col-span-2">
+                <Label class="text-muted-foreground">曲库目标目录（相对 WebDAV 根）</Label>
+                <Input
+                  :model-value="feiniu.webdav.dir"
+                  placeholder="例如：Music 或 我的文件/Music"
+                  @update:model-value="(v: unknown) => feiniu.patchWebdav({ dir: String(v ?? '') })"
+                />
+              </div>
+            </div>
+            <div class="flex items-center gap-2">
+              <Button
+                variant="outline"
+                size="sm"
+                :disabled="webdavTesting || !feiniu.webdav.url || !feiniu.webdav.dir"
+                @click="testWebdav"
+              >
+                <Loader2 v-if="webdavTesting" class="size-3.5 animate-spin" />
+                <span :class="webdavTesting ? 'ml-1.5' : ''">
+                  {{ webdavTesting ? '测试中…' : '测试连接' }}
+                </span>
+              </Button>
+              <Button v-if="feiniu.webdavReady" variant="ghost" size="sm" @click="webdavEditing = false">
+                收起
+              </Button>
+            </div>
+            </template>
+            <details class="rounded-md border border-border/70 px-3 py-2">
+              <summary class="cursor-pointer text-[12px] font-medium text-muted-foreground">
+                飞牛 NAS 侧需要做什么？
+              </summary>
+              <ol class="mt-2 list-decimal space-y-1 pl-4 text-[11.5px] leading-relaxed text-muted-foreground">
+                <li>
+                  登录飞牛后台 → <strong class="font-medium">系统设置 → 文件服务（文件共享协议）→ WebDAV</strong>，
+                  开启 WebDAV 服务并记下端口（HTTP 默认 <code class="rounded bg-muted px-1">5005</code>、HTTPS 默认
+                  <code class="rounded bg-muted px-1">5006</code>）。
+                </li>
+                <li>
+                  在「可见文件夹范围」中勾选存放音乐的文件夹；<strong class="font-medium">团队文件夹</strong>需要在文件管理里编辑该文件夹，
+                  勾选「允许通过文件共享协议（SMB、WebDAV、FTP）挂载到其他设备上」。
+                </li>
+                <li>确保上面的账号对该文件夹有<strong class="font-medium">读写</strong>权限。</li>
+                <li>目标目录请填 WebDAV 根下的相对路径（登录 WebDAV 后看到的目录结构，不一定是 NAS 内部路径）。</li>
+              </ol>
+            </details>
+
+            <div class="flex items-center justify-between gap-4">
+              <span class="text-[13px]">下载完成后自动上传到飞牛曲库</span>
+              <Switch
+                :model-value="feiniu.autoUpload"
+                @update:model-value="(v: boolean) => feiniu.setAutoUpload(!!v)"
               />
             </div>
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">下载完成后自动上传</Label>
-              <Switch :model-value="feiniu.autoUpload" @update:model-value="(v: boolean) => feiniu.setAutoUpload(!!v)" />
-            </div>
+
             <div class="flex items-center gap-2">
               <Button variant="outline" size="sm" :disabled="feiniu.uploading" @click="uploadRecentToFeiniu">
                 <Loader2 v-if="feiniu.uploading" class="size-4 animate-spin" />
                 <Upload v-else class="size-4" />
                 上传最近下载
               </Button>
-              <span class="text-xs text-muted-foreground">上传最近 10 分钟下载到本地目录的音频</span>
+              <span class="text-[11.5px] text-muted-foreground">上传最近 10 分钟内下载到本地目录的音频</span>
             </div>
-          </CardContent>
-        </Card>
+            </CardContent>
+          </Card>
 
-        <!-- 环境检查 -->
-        <Card>
-          <CardHeader class="pb-2">
-            <CardTitle class="flex items-center gap-2">
-              环境检查
-              <Button
-                variant="ghost"
-                size="icon"
-                class="size-7"
-                :disabled="pinging"
-                @click="testBridge"
-              >
-                <RotateCw :class="pinging ? 'size-3.5 animate-spin' : 'size-3.5'" />
-              </Button>
-            </CardTitle>
-          </CardHeader>
-          <CardContent class="space-y-3">
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">Python 运行时</Label>
-              <div class="flex items-center gap-2">
-                <Badge :variant="store.env?.pythonSource === 'none' ? 'destructive' : 'secondary'">
-                  {{ store.env?.pythonSource === 'bundled' ? '便携版' : store.env?.pythonSource === 'system' ? '系统' : '未安装' }}
-                </Badge>
-                <span class="text-sm">{{ store.env?.python ?? '—' }}</span>
-              </div>
-            </div>
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">musicdl</Label>
-              <div class="flex items-center gap-2">
-                <Badge :variant="store.env?.musicdlInstalled ? 'default' : 'secondary'">
-                  {{ store.env?.musicdlInstalled ? '已安装' : '未安装' }}
-                </Badge>
-                <span class="text-sm">{{ store.env?.musicdlVersion ?? '—' }}</span>
-              </div>
-            </div>
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">FFmpeg（可选）</Label>
-              <div class="flex items-center gap-2">
-                <Badge variant="outline">{{ store.env?.ffmpeg ? '可用' : '未安装' }}</Badge>
-                <span class="text-sm text-muted-foreground">{{ store.env?.ffmpeg ?? '部分海外音源需要' }}</span>
-              </div>
-            </div>
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">桥接进程</Label>
-              <div class="flex items-center gap-2">
-                <Badge :variant="store.env?.bridgeRunning ? 'default' : 'outline'">
-                  {{ store.env?.bridgeRunning ? '运行中' : '已停止' }}
-                </Badge>
-              </div>
-            </div>
-            <div class="flex items-center justify-between">
-              <Label class="text-muted-foreground">运行时目录</Label>
-              <span class="text-sm text-muted-foreground font-mono truncate max-w-[60%]" :title="store.env?.runtimeDir">
-                {{ runtimeDisplay }}
-              </span>
-            </div>
-
-            <Separator />
-
-            <div v-if="store.installing" class="space-y-2">
-              <div class="flex items-center justify-between">
-                <span class="text-sm">{{ installMessage }}</span>
-                <span class="text-sm font-medium">{{ installPercent }}%</span>
-              </div>
-              <Progress :model-value="installPercent" class="h-2" />
+          <!-- 播放 -->
+          <Card>
+            <CardHeader>
+              <CardTitle class="flex items-center gap-2 text-base">
+                <Music2 class="size-4 text-primary" />
+                播放
+              </CardTitle>
+            </CardHeader>
+            <CardContent class="flex flex-col gap-3">
               <p class="text-xs text-muted-foreground">
-                下载与安装依赖需要几分钟，进度条在下载阶段推进、依赖安装阶段按步骤跳转，请耐心等待
+                播放控制常驻在标题栏，切走音乐模块也能继续控制播放。
               </p>
-              <Button variant="outline" size="sm" class="mt-1" @click="store.cancelInstall()">
-                取消安装
-              </Button>
-            </div>
-            <div v-else-if="!store.env?.musicdlInstalled" class="space-y-2">
-              <p v-if="store.installError" class="text-xs text-destructive break-all">
-                安装失败：{{ store.installError }}
+              <CacheSettings />
+            </CardContent>
+          </Card>
+
+          <!-- 搜索与下载 -->
+          <Card>
+            <CardHeader>
+              <CardTitle class="flex items-center gap-2 text-base">
+                <Download class="size-4 text-primary" />
+                搜索与下载
+              </CardTitle>
+            </CardHeader>
+            <CardContent class="flex flex-col gap-4">
+              <p class="text-xs text-muted-foreground">
+                搜索与下载会在选中的平台聚合；默认网易云 / QQ 音乐 / 酷狗。
               </p>
-              <div class="flex items-center gap-2">
-                <Button size="sm" @click="doInstall">
-                  安装便携版（Python + musicdl）
-                </Button>
-                <span class="text-xs text-muted-foreground">
-                  自动下载约 11MB 便携 Python 并安装 musicdl
-                </span>
-              </div>
-            </div>
-          </CardContent>
-        </Card>
 
-        <!-- 通用设置 -->
-        <Card>
-          <CardHeader class="pb-2">
-            <CardTitle>设置</CardTitle>
-          </CardHeader>
-          <CardContent class="space-y-4">
-            <div class="space-y-2">
-              <Label>下载保存目录</Label>
-              <div class="flex items-center gap-2">
-                <Input v-model="savedirModel" class="flex-1" />
-                <Tooltip>
-                  <TooltipTrigger as-child>
-                    <Button variant="ghost" size="icon" class="shrink-0" @click="openDir()">
-                      <FolderOpen class="size-4" />
-                    </Button>
-                  </TooltipTrigger>
-                  <TooltipContent>打开目录</TooltipContent>
-                </Tooltip>
-                <Button variant="outline" size="icon" class="shrink-0" @click="browseDir">
-                  <FolderOpen class="size-4" />
-                </Button>
-              </div>
-            </div>
-
-            <div class="space-y-2">
-              <Label>搜索源（可多选）</Label>
+            <div class="flex flex-col gap-1.5">
+              <Label class="text-muted-foreground">搜索源（可多选）</Label>
               <SourcePicker v-model="settingsSources" :options="sourceOptions" />
-              <p class="text-xs text-muted-foreground">
-                搜索与下载在选中的平台聚合；默认网易云 / QQ音乐 / 酷狗
-              </p>
             </div>
 
-            <div class="flex items-center justify-between">
-              <Label>同步下载歌词</Label>
-              <Switch v-model="lyricModel" />
-            </div>
-            <div class="flex items-center justify-between">
-              <Label>同步下载封面</Label>
-              <Switch v-model="coverModel" />
-            </div>
-            <div class="flex items-center justify-between">
-              <Label>搜索/下载走代理</Label>
-              <Switch v-model="proxyModel" />
-            </div>
-            <div class="flex items-center justify-between">
-              <span class="space-y-0.5">
-                <Label>下载时选择音质</Label>
-                <p class="text-xs text-muted-foreground">开启后点击下载会弹出音质选择</p>
-              </span>
-              <Switch v-model="selectQualityModel" />
-            </div>
-            <div class="space-y-2">
-              <Label>下载时默认音质</Label>
-              <Select v-model="defaultQualityModel">
-                <SelectTrigger class="w-64">
-                  <SelectValue placeholder="选择默认音质" />
-                </SelectTrigger>
-                <SelectContent>
-                  <SelectItem value="最高">最高</SelectItem>
-                  <SelectItem value="Hi-Res">Hi-Res</SelectItem>
-                  <SelectItem value="无损">无损</SelectItem>
-                  <SelectItem value="320K">320K</SelectItem>
-                  <SelectItem value="192K">192K</SelectItem>
-                  <SelectItem value="128K">128K</SelectItem>
-                </SelectContent>
-              </Select>
-              <p class="text-xs text-muted-foreground">
-                解析下载时取「≤ 所选」可用的最优音质；选中的档位不可用时自动降档
-              </p>
+            <div class="grid grid-cols-2 gap-x-6 gap-y-3">
+              <div class="flex items-center justify-between gap-4">
+                <Label class="text-muted-foreground">同步下载歌词</Label>
+                <Switch v-model="lyricModel" />
+              </div>
+              <div class="flex items-center justify-between gap-4">
+                <Label class="text-muted-foreground">同步下载封面</Label>
+                <Switch v-model="coverModel" />
+              </div>
+              <div class="flex items-center justify-between gap-4">
+                <Label class="text-muted-foreground">搜索 / 下载走代理</Label>
+                <Switch v-model="proxyModel" />
+              </div>
+              <div class="flex items-center justify-between gap-4">
+                <Label class="text-muted-foreground">下载时弹窗选择音质</Label>
+                <Switch v-model="selectQualityModel" />
+              </div>
             </div>
 
-            <div class="space-y-2">
-              <Label>最大并发下载数</Label>
-              <Input v-model="concurrentModel" type="number" min="1" max="16" class="w-32" />
+            <div class="grid grid-cols-2 gap-x-6 gap-y-3">
+              <div class="flex flex-col gap-1.5">
+                <Label class="text-muted-foreground">默认下载音质</Label>
+                <Select v-model="defaultQualityModel">
+                  <SelectTrigger><SelectValue placeholder="选择默认音质" /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="最高">最高</SelectItem>
+                    <SelectItem value="Hi-Res">Hi-Res</SelectItem>
+                    <SelectItem value="无损">无损</SelectItem>
+                    <SelectItem value="320K">320K</SelectItem>
+                    <SelectItem value="192K">192K</SelectItem>
+                    <SelectItem value="128K">128K</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <div class="flex flex-col gap-1.5">
+                <Label class="text-muted-foreground">最大并发下载数</Label>
+                <Input v-model="concurrentModel" type="number" min="1" max="16" />
+              </div>
             </div>
 
-            <div class="space-y-2">
-              <Label>下载引擎</Label>
+            <div class="flex flex-col gap-1.5">
+              <Label class="text-muted-foreground">下载引擎</Label>
               <Select v-model="engineModel">
-                <SelectTrigger class="w-80">
-                  <SelectValue placeholder="选择下载引擎" />
-                </SelectTrigger>
+                <SelectTrigger><SelectValue placeholder="选择下载引擎" /></SelectTrigger>
                 <SelectContent>
-                  <SelectItem value="musicdl">musicdl（推荐，支持歌词/封面/解密）</SelectItem>
+                  <SelectItem value="musicdl">musicdl（推荐：支持歌词 / 封面 / 解密）</SelectItem>
                   <SelectItem value="rust">Rust 引擎（任务在「下载器」模块）</SelectItem>
                 </SelectContent>
               </Select>
-              <p class="text-xs text-muted-foreground">
-                musicdl 引擎在本模块内管理任务与进度；Rust 引擎将下载交给「下载器」模块的 HTTP 引擎
+              <p class="text-[11.5px] text-muted-foreground">
+                musicdl 引擎的任务与进度在本模块内管理，并支持自动回传飞牛曲库；Rust 引擎把下载交给「下载器」模块，
+                该模式下「下载到飞牛」不可用。
               </p>
             </div>
-          </CardContent>
-        </Card>
-          </div>
-        </ScrollArea>
+            </CardContent>
+          </Card>
+
+          <!-- 环境与诊断 -->
+          <Card>
+            <CardHeader>
+              <button
+                type="button"
+                class="flex items-center gap-2 text-left"
+                @click="diagnosticsOpen = !diagnosticsOpen"
+              >
+                <Info class="size-4 text-primary" />
+                <span class="text-base font-semibold leading-none">环境与诊断</span>
+                <Badge :variant="store.env?.musicdlInstalled ? 'default' : 'secondary'" class="ml-1">
+                  {{ store.env?.musicdlInstalled ? '就绪' : '未安装' }}
+                </Badge>
+                <span class="ml-auto text-[11.5px] text-muted-foreground">
+                  Python {{ store.env?.python ?? '—' }}
+                </span>
+              </button>
+            </CardHeader>
+
+            <CardContent v-if="diagnosticsOpen" class="flex flex-col gap-2">
+                <div class="flex items-center justify-between gap-4">
+                  <Label class="text-muted-foreground">Python 运行时</Label>
+                  <div class="flex items-center gap-2">
+                    <Badge :variant="store.env?.pythonSource === 'none' ? 'destructive' : 'secondary'">
+                      {{
+                        store.env?.pythonSource === 'bundled'
+                          ? '便携版'
+                          : store.env?.pythonSource === 'system'
+                            ? '系统'
+                            : '未安装'
+                      }}
+                    </Badge>
+                    <span class="text-[12.5px]">{{ store.env?.python ?? '—' }}</span>
+                  </div>
+                </div>
+                <div class="flex items-center justify-between gap-4">
+                  <Label class="text-muted-foreground">musicdl</Label>
+                  <div class="flex items-center gap-2">
+                    <Badge :variant="store.env?.musicdlInstalled ? 'default' : 'secondary'">
+                      {{ store.env?.musicdlInstalled ? '已安装' : '未安装' }}
+                    </Badge>
+                    <span class="text-[12.5px]">{{ store.env?.musicdlVersion ?? '—' }}</span>
+                  </div>
+                </div>
+                <div class="flex items-center justify-between gap-4">
+                  <Label class="text-muted-foreground">FFmpeg（可选）</Label>
+                  <div class="flex items-center gap-2">
+                    <Badge variant="outline">{{ store.env?.ffmpeg ? '可用' : '未安装' }}</Badge>
+                    <span class="text-[12px] text-muted-foreground">{{ store.env?.ffmpeg ?? '部分海外音源需要' }}</span>
+                  </div>
+                </div>
+                <div class="flex items-center justify-between gap-4">
+                  <Label class="text-muted-foreground">桥接进程</Label>
+                  <div class="flex items-center gap-2">
+                    <Badge :variant="store.env?.bridgeRunning ? 'default' : 'outline'">
+                      {{ store.env?.bridgeRunning ? '运行中' : '已停止' }}
+                    </Badge>
+                    <Button variant="outline" size="sm" class="h-7" :disabled="pinging" @click="testBridge">
+                      <RotateCw :class="pinging ? 'size-3.5 animate-spin' : 'size-3.5'" />
+                      <span class="ml-1">自检</span>
+                    </Button>
+                  </div>
+                </div>
+                <div class="flex items-start justify-between gap-4">
+                  <Label class="shrink-0 text-muted-foreground">运行时目录</Label>
+                  <span class="truncate font-mono text-[11.5px] text-muted-foreground" :title="store.env?.runtimeDir">
+                    {{ runtimeDisplay || '—' }}
+                  </span>
+                </div>
+
+                <template v-if="store.installing">
+                  <Separator />
+                  <div class="flex items-center justify-between">
+                    <span class="text-[12.5px]">{{ installMessage }}</span>
+                    <span class="text-[12.5px] font-medium">{{ installPercent }}%</span>
+                  </div>
+                  <Progress :model-value="installPercent" />
+                  <p class="text-[11.5px] text-muted-foreground">
+                    下载与安装依赖需要几分钟：进度条在下载阶段推进，依赖安装阶段按步骤跳转。
+                  </p>
+                  <Button variant="outline" size="sm" @click="store.cancelInstall()">取消安装</Button>
+                </template>
+                <template v-else-if="!store.env?.musicdlInstalled">
+                  <Separator />
+                  <p v-if="store.installError" class="break-all text-[11.5px] text-destructive">
+                    安装失败：{{ store.installError }}
+                  </p>
+                  <div class="flex items-center gap-2">
+                    <Button size="sm" @click="doInstall">安装便携版（Python + musicdl）</Button>
+                    <span class="text-[11.5px] text-muted-foreground">自动下载约 11MB 便携 Python 并安装 musicdl</span>
+                  </div>
+                </template>
+            </CardContent>
+          </Card>
+        </div>
+      </ScrollArea>
       </TabsContent>
     </Tabs>
 
-    <!-- 音质选择下载弹窗 -->
+    <!-- 音质选择弹窗 -->
     <Dialog v-model:open="qualityDialogOpen">
       <DialogContent class="sm:max-w-sm">
         <DialogHeader>
           <DialogTitle>选择下载音质</DialogTitle>
           <DialogDescription>
-            将下载 {{
-              pendingQualitySongs.length > 1 ? `${pendingQualitySongs.length} 首歌曲` : pendingQualitySongs[0]?.songName || ''
-            }}；解析时取「≤ 所选」可用的最优音质，所选档位不可用时自动降档。
+            将下载
+            {{ pendingQualitySongs.length > 1 ? `${pendingQualitySongs.length} 首歌曲` : pendingQualitySongs[0]?.songName || '' }}；
+            解析时取「≤ 所选」可用的最优音质，所选档位不可用时自动降档。
           </DialogDescription>
         </DialogHeader>
         <div class="flex flex-col gap-1.5 py-1">
@@ -1390,11 +1715,11 @@ const installMessage = computed(() => store.installProgress?.message ?? '')
             v-for="opt in qualityOptionsFor(pendingQualitySongs)"
             :key="opt"
             type="button"
-            class="flex items-center justify-between rounded-md border px-3 py-2 text-sm transition-colors"
+            class="flex items-center justify-between rounded-md border px-3 py-2 text-[13px] transition-colors"
             :class="
               chosenQuality === opt
                 ? 'border-primary bg-primary/10 text-foreground'
-                : 'border-border hover:bg-muted/50'
+                : 'border-border hover:bg-accent/50'
             "
             @click="chosenQuality = opt"
           >
@@ -1408,14 +1733,5 @@ const installMessage = computed(() => store.installProgress?.message ?? '')
         </DialogFooter>
       </DialogContent>
     </Dialog>
-
-    <!-- 试听音频（单实例） -->
-    <audio ref="audioEl" class="hidden" @ended="onAudioEnded" />
-
-    <!-- 常驻底部播放条（跨所有 tab） -->
-    <PlayerBar />
-
-    <!-- Now-Playing 大屏 -->
-    <PlayerFull />
   </div>
 </template>
diff --git a/src/modules/music/SourcePicker.vue b/src/modules/music/SourcePicker.vue
index dee2c84..5178fa7 100644
--- a/src/modules/music/SourcePicker.vue
+++ b/src/modules/music/SourcePicker.vue
@@ -26,8 +26,11 @@ const toggle = (code: string) => {
   emit('update:model-value', [...next])
 }
 
+const selectAll = () => emit('update:model-value', [...props.options])
+const clearAll = () => emit('update:model-value', [])
+
 const label = computed(() => {
-  if (props.modelValue.length === 0) return '未选择'
+  if (props.modelValue.length === 0) return '选择搜索源'
   if (props.modelValue.length === 1) return sourceName(props.modelValue[0])
   return `已选 ${props.modelValue.length} 个源`
 })
@@ -36,34 +39,52 @@ const label = computed(() => {
 <template>
   <Popover v-model:open="open">
     <PopoverTrigger as-child>
-      <Button variant="outline" class="justify-between font-normal" size="sm">
+      <Button variant="outline" size="sm" class="h-9 max-w-56 justify-between font-normal">
         <span class="truncate">{{ label }}</span>
-        <ChevronDown class="size-3.5 opacity-50 shrink-0" />
+        <ChevronDown class="size-3.5 shrink-0 opacity-50" />
       </Button>
     </PopoverTrigger>
     <PopoverContent class="w-64 p-2" align="start">
-      <!-- ScrollArea 的 viewport h-full 需要 root 有确定高度才滚动；max-h 不生效，用固定 h-72 -->
+      <div class="mb-1 flex items-center justify-between px-1">
+        <span class="text-[11px] text-muted-foreground">搜索源</span>
+        <div class="flex items-center gap-2">
+          <button
+            type="button"
+            class="text-[11px] text-muted-foreground hover:text-foreground disabled:opacity-40"
+            :disabled="modelValue.length === options.length"
+            @click="selectAll"
+          >
+            全选
+          </button>
+          <button
+            type="button"
+            class="text-[11px] text-muted-foreground hover:text-foreground disabled:opacity-40"
+            :disabled="modelValue.length === 0"
+            @click="clearAll"
+          >
+            清空
+          </button>
+        </div>
+      </div>
+      <!-- ScrollArea 的 viewport 为 h-full，需要根节点有确定高度才能滚动 -->
       <ScrollArea class="h-72">
         <div class="space-y-0.5 pr-2">
           <label
             v-for="code in options"
             :key="code"
-            class="flex items-center gap-2 rounded-md px-2 py-1.5 cursor-pointer hover:bg-muted/50"
+            class="flex cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 hover:bg-accent/60"
           >
-            <Checkbox
-              :model-value="checked.has(code)"
-              @update:model-value="toggle(code)"
-            />
-            <Label class="text-sm cursor-pointer truncate">{{ sourceName(code) }}</Label>
+            <Checkbox :model-value="checked.has(code)" @update:model-value="toggle(code)" />
+            <Label class="cursor-pointer truncate text-[13px]">{{ sourceName(code) }}</Label>
           </label>
-          <p v-if="options.length === 0" class="px-2 py-3 text-xs text-muted-foreground">
-            未获取到可用源，请先安装环境
+          <p v-if="options.length === 0" class="px-2 py-3 text-[11.5px] text-muted-foreground">
+            未获取到可用源，请先在「设置 → 环境与诊断」安装运行时。
           </p>
         </div>
       </ScrollArea>
-      <div class="mt-1 border-t pt-1.5 px-1 flex items-center justify-between">
-        <span class="text-xs text-muted-foreground">{{ options.length }} 个可选源</span>
-        <span class="text-xs text-muted-foreground">已选 {{ props.modelValue.length }}</span>
+      <div class="mt-1 flex items-center justify-between border-t px-1 pt-1.5">
+        <span class="text-[11px] text-muted-foreground">{{ options.length }} 个可选源</span>
+        <span class="text-[11px] text-muted-foreground">已选 {{ modelValue.length }}</span>
       </div>
     </PopoverContent>
   </Popover>
diff --git a/src/modules/music/components/MyMusicLibrary.vue b/src/modules/music/components/MyMusicLibrary.vue
index 23d1d68..123ba32 100644
--- a/src/modules/music/components/MyMusicLibrary.vue
+++ b/src/modules/music/components/MyMusicLibrary.vue
@@ -1,269 +1,503 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import { toast } from 'vue-sonner'
-import { FolderOpen, Loader2, Music2, Plus, RefreshCw, Trash2 } from '@lucide/vue'
-import { useFeiniuStore, type Playlist } from '@/stores/feiniuStore'
+import {
+  Cloud,
+  FolderOpen,
+  HardDrive,
+  ListMusic,
+  ListPlus,
+  Loader2,
+  Music2,
+  Pencil,
+  Play,
+  Plus,
+  RefreshCw,
+  Search,
+  Trash2
+} from '@lucide/vue'
+import { useFeiniuStore } from '@/stores/feiniuStore'
 import TrackItem from './TrackItem.vue'
+import PlaylistEditorDialog from './PlaylistEditorDialog.vue'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
-import { Empty } from '@/components/ui/empty'
+import { Empty, EmptyDescription, EmptyMedia, EmptyTitle } from '@/components/ui/empty'
 import { ScrollArea } from '@/components/ui/scroll-area'
-import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from '@/components/ui/dialog'
 
 const store = useFeiniuStore()
 
-type SubTab = 'feiniu' | 'local' | 'playlists'
-const subTab = ref<SubTab>('feiniu')
+/** 曲库视图：飞牛 / 本地 / 歌单 */
+type LibraryView = 'feiniu' | 'local' | 'playlists'
+const view = ref<LibraryView>('feiniu')
 
-// 未登录（无激活连接且未登录）
 const needsLogin = computed(() => !store.config.loggedIn && !store.activeConn)
 
-const keywordInput = ref('')
-let searchTimer: ReturnType<typeof setTimeout> | undefined
+const sourceNav = computed(() => [
+  { value: 'feiniu' as const, label: '飞牛曲库', icon: Cloud, count: store.total || store.tracks.length },
+  { value: 'local' as const, label: '本地曲库', icon: HardDrive, count: store.localTracks.length },
+  { value: 'playlists' as const, label: '我的歌单', icon: ListMusic, count: store.playlists.length }
+])
 
+// ===== 飞牛曲库：搜索（直接绑定 store.searchKeyword，此前绑定的是孤立局部变量，导致搜索完全无效）=====
+let searchTimer: ReturnType<typeof setTimeout> | undefined
+let searchSeq = 0
 function onSearchInput() {
   clearTimeout(searchTimer)
-  searchTimer = setTimeout(() => {
-    store.loadTracks(1).catch((e) => toast.error(String(e)))
+  searchTimer = setTimeout(async () => {
+    const seq = ++searchSeq
+    try {
+      await store.loadTracks(1)
+    } catch (e) {
+      if (seq === searchSeq) toast.error(String(e))
+    }
   }, 400)
 }
 
 function refreshFeiniu() {
-  store.loadTracks(store.page).catch((e) => toast.error(String(e)))
+  store.loadTracks(1).catch((e) => toast.error(String(e)))
 }
-
 function refreshLocal() {
   store.scanLocal().catch((e) => toast.error(String(e)))
 }
 
-function playAll() {
-  const list =
-    subTab.value === 'feiniu' ? store.tracks : subTab.value === 'local' ? store.localTracks : []
-  if (list.length) store.playQueue(list, 0)
+function playFeiniu() {
+  if (store.tracks.length) store.playQueue(store.tracks, 0)
+}
+function playLocal() {
+  if (store.localTracks.length) store.playQueue(store.localTracks, 0)
+}
+function playActivePlaylist() {
+  if (activePlaylist.value?.items.length) store.playQueue(activePlaylist.value.items, 0)
 }
 
+// ===== 滚动加载更多（飞牛曲库分页）=====
+const loadMoreRef = ref<HTMLElement | null>(null)
+let loadMoreObserver: IntersectionObserver | null = null
+onMounted(() => {
+  loadMoreObserver = new IntersectionObserver(
+    (entries) => {
+      if (!entries.some((e) => e.isIntersecting)) return
+      store.loadMoreTracks().catch(() => {})
+    },
+    { rootMargin: '400px' }
+  )
+  watch(
+    loadMoreRef,
+    (el) => {
+      if (!loadMoreObserver) return
+      loadMoreObserver.disconnect()
+      if (el) loadMoreObserver.observe(el)
+    },
+    { immediate: true }
+  )
+})
+onBeforeUnmount(() => {
+  clearTimeout(searchTimer)
+  loadMoreObserver?.disconnect()
+})
+
 // ===== 歌单 =====
-const playlistName = ref('')
-const createOpen = ref(false)
 const activePlaylistId = ref('')
-const activePlaylist = computed<Playlist | null>(
-  () => store.playlists.find((p) => p.id === activePlaylistId.value) || null
+const activePlaylist = computed(() => store.playlists.find((p) => p.id === activePlaylistId.value) || null)
+
+const createOpen = ref(false)
+const newName = ref('')
+const renameOpen = ref(false)
+const renameValue = ref('')
+/** 编辑歌单音乐（勾选加入 / 批量移出） */
+const editorOpen = ref(false)
+
+// 切换歌单时关闭编辑器，避免对着已切换的目标继续编辑
+watch(activePlaylistId, () => (editorOpen.value = false))
+
+// 切到歌单视图时自动选中第一个
+watch(
+  [view, () => store.playlists.length],
+  () => {
+    if (view.value !== 'playlists') return
+    if (activePlaylistId.value && store.playlists.some((p) => p.id === activePlaylistId.value)) return
+    activePlaylistId.value = store.playlists[0]?.id ?? ''
+  },
+  { immediate: true }
 )
 
 function createPlaylist() {
-  if (!playlistName.value.trim()) {
+  const name = newName.value.trim()
+  if (!name) {
     toast.error('请输入歌单名称')
     return
   }
-  const id = store.createPlaylist(playlistName.value.trim())
-  activePlaylistId.value = id
-  playlistName.value = ''
+  activePlaylistId.value = store.createPlaylist(name)
+  newName.value = ''
   createOpen.value = false
+  view.value = 'playlists'
+}
+
+function openRename() {
+  if (!activePlaylist.value) return
+  renameValue.value = activePlaylist.value.name
+  renameOpen.value = true
+}
+function confirmRename() {
+  const name = renameValue.value.trim()
+  if (!name || !activePlaylist.value) return
+  store.renamePlaylist(activePlaylist.value.id, name)
+  renameOpen.value = false
+}
+
+function removePlaylist() {
+  if (!activePlaylist.value) return
+  store.deletePlaylist(activePlaylist.value.id)
+  activePlaylistId.value = ''
 }
 
 onMounted(async () => {
   await store.init()
-  if (store.config.loggedIn) {
-    store.loadTracks(1).catch(() => {})
+  if (store.config.loggedIn) store.loadTracks(1).catch(() => {})
+})
+
+/** 表格表头与 TrackItem 行保持同一条网格 */
+const GRID = { gridTemplateColumns: '28px 36px minmax(0,1fr) 74px 28px' }
+
+const listEmptyHint = computed(() => {
+  if (view.value === 'feiniu') {
+    if (store.searchKeyword.trim()) return '没有匹配「' + store.searchKeyword.trim() + '」的曲目'
+    return store.config.loggedIn ? '曲库为空，试试刷新或检查 NAS 曲库目录' : '请先在「设置 → 飞牛音乐连接」登录'
   }
+  return '暂无本地音乐，点击「扫描本地曲库」或先到「发现音乐」下载'
 })
 </script>
 
 <template>
-  <ScrollArea class="h-full pr-3">
-    <div class="flex flex-col gap-4 px-1 pt-1 pb-4 min-w-0">
-      <!-- 未登录态：引导配置连接 -->
-      <div v-if="needsLogin" class="flex flex-col items-center gap-3 py-16 text-center">
-        <Music2 class="size-10 text-muted-foreground" />
-        <p class="text-sm text-muted-foreground">
-          还没有可用的飞牛音乐连接。请到「设置 → 飞牛音乐连接」添加并登录，
-          <br />
-          或先到「发现音乐」下载歌曲到本地曲库。
-        </p>
-      </div>
+  <div class="flex h-full min-h-0">
+    <!-- ===== 左：来源导航 ===== -->
+    <aside class="flex w-[168px] shrink-0 flex-col border-r">
+      <ScrollArea class="min-h-0 flex-1">
+        <div class="flex flex-col p-2">
+          <p class="px-2 pb-1.5 pt-0.5 text-[11px] font-medium tracking-wide text-muted-foreground">曲库</p>
 
-      <template v-else>
-        <!-- 页头 + 子导航 -->
-        <div class="flex flex-col gap-3">
-          <div class="flex items-center justify-between">
-            <div class="flex items-center gap-1 rounded-lg border bg-card p-1">
-              <button
-                type="button"
-                class="rounded-md px-3 py-1 text-sm transition-colors"
-                :class="subTab === 'feiniu' ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:text-foreground'"
-                @click="subTab = 'feiniu'"
+          <!-- 来源：选中态与顶部 Tabs 一致（无容器底色，选中项为浮起胶囊） -->
+          <div class="flex flex-col gap-0.5">
+            <button
+              v-for="nav in sourceNav"
+              :key="nav.value"
+              type="button"
+              class="flex h-8 items-center gap-1.5 rounded-md px-2 text-[13px] transition-colors duration-150"
+              :class="
+                view === nav.value
+                  ? 'bg-background font-medium text-foreground shadow-sm ring-1 ring-border'
+                  : 'text-muted-foreground hover:bg-accent/60 hover:text-foreground'
+              "
+              @click="view = nav.value"
+            >
+              <component :is="nav.icon" class="size-3.5 shrink-0" />
+              <span class="min-w-0 flex-1 truncate">{{ nav.label }}</span>
+              <!-- 数量始终渲染（无歌曲时显示 0），并固定宽度右对齐，保证数字列竖向对齐 -->
+              <span
+                class="min-w-[3ch] shrink-0 text-right text-[10.5px] tabular-nums"
+                :class="view === nav.value ? 'text-muted-foreground' : 'text-muted-foreground/70'"
               >
-                飞牛曲库
-              </button>
-              <button
-                type="button"
-                class="rounded-md px-3 py-1 text-sm transition-colors"
-                :class="subTab === 'local' ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:text-foreground'"
-                @click="subTab = 'local'"
-              >
-                本地曲库
-              </button>
-              <button
-                type="button"
-                class="rounded-md px-3 py-1 text-sm transition-colors"
-                :class="subTab === 'playlists' ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:text-foreground'"
-                @click="subTab = 'playlists'"
-              >
-                我的歌单
-              </button>
-            </div>
-            <Button v-if="store.config.loggedIn" variant="outline" size="sm" @click="playAll">
-              ▶ 播放全部
-            </Button>
-          </div>
-        </div>
-
-        <!-- ===== 飞牛曲库 ===== -->
-        <template v-if="subTab === 'feiniu'">
-          <div class="flex items-center gap-2">
-            <div class="flex-1">
-              <Input v-model="keywordInput" placeholder="搜索飞牛曲库（歌名 / 歌手）" @input="onSearchInput" @keydown.enter="onSearchInput" />
-            </div>
-            <Button variant="outline" size="icon" :disabled="store.loading" @click="refreshFeiniu">
-              <RefreshCw :class="store.loading ? 'size-4 animate-spin' : 'size-4'" />
-            </Button>
-          </div>
-          <div class="flex flex-col gap-1.5">
-            <div v-if="store.loading" class="flex items-center justify-center gap-2 py-10 text-sm text-muted-foreground">
-              <Loader2 class="size-4 animate-spin" /> 加载曲库…
-            </div>
-            <Empty v-else-if="!store.tracks.length" class="min-h-40">
-              <Music2 class="size-10 text-muted-foreground" />
-              <p class="text-sm text-muted-foreground">
-                {{ store.config.loggedIn ? '曲库为空或未匹配到结果' : '请先在设置中登录飞牛音乐连接' }}
-              </p>
-            </Empty>
-            <template v-else>
-              <TrackItem
-                v-for="(t, i) in store.tracks"
-                :key="t.guid || i"
-                :item="t"
-                :active="store.current?.guid === t.guid"
-                @dblclick="store.playQueue(store.tracks, i)"
-              />
-            </template>
-          </div>
-        </template>
-
-        <!-- ===== 本地曲库 ===== -->
-        <template v-else-if="subTab === 'local'">
-          <div class="flex items-center gap-2">
-            <Button variant="outline" size="sm" :disabled="store.localScanBusy" @click="refreshLocal">
-              <Loader2 v-if="store.localScanBusy" class="size-4 animate-spin" />
-              <FolderOpen v-else class="size-4" />
-              扫描本地
-            </Button>
-            <span class="text-xs text-muted-foreground">{{ store.localTracks.length }} 首（目录：音乐下载目录 + 自定义）</span>
-          </div>
-          <div class="flex flex-col gap-1.5">
-            <Empty v-if="!store.localTracks.length && !store.localScanBusy" class="min-h-40">
-              <FolderOpen class="size-10 text-muted-foreground" />
-              <p class="text-sm text-muted-foreground">暂无本地音乐，点击「扫描本地」或先到发现音乐下载</p>
-            </Empty>
-            <template v-else>
-              <TrackItem
-                v-for="(t, i) in store.localTracks"
-                :key="t.guid || i"
-                :item="t"
-                :active="store.current?.guid === t.guid"
-                @dblclick="store.playQueue(store.localTracks, i)"
-              />
-            </template>
-          </div>
-        </template>
-
-        <!-- ===== 我的歌单 ===== -->
-        <template v-else>
-          <div class="flex items-center gap-2">
-            <Button variant="outline" size="sm" @click="createOpen = true">
-              <Plus class="size-4" /> 新建歌单
-            </Button>
+                {{ nav.count > 999 ? '999+' : nav.count }}
+              </span>
+            </button>
           </div>
 
-          <!-- 歌单列表（左） + 详情（右） -->
-          <div class="grid grid-cols-1 gap-4 md:grid-cols-[220px_1fr]">
-            <div class="flex flex-col gap-1 rounded-lg border bg-card p-2">
+          <!-- 歌单列表（选中「我的歌单」时展开） -->
+          <Transition name="pl-list">
+            <div v-if="view === 'playlists'" class="mt-1.5 ml-1.5 flex flex-col gap-0.5 border-l pl-1.5">
               <button
                 v-for="p in store.playlists"
                 :key="p.id"
                 type="button"
-                class="flex items-center justify-between rounded-md px-3 py-2 text-sm transition-colors"
-                :class="activePlaylistId === p.id ? 'bg-primary/10 text-foreground' : 'text-muted-foreground hover:bg-muted/40'"
+                class="flex h-7 items-center gap-1.5 rounded-md px-2 text-left text-[12.5px] transition-colors duration-150"
+                :class="
+                  activePlaylistId === p.id
+                    ? 'bg-background font-medium text-foreground shadow-sm ring-1 ring-border'
+                    : 'text-muted-foreground hover:bg-accent/60 hover:text-foreground'
+                "
                 @click="activePlaylistId = p.id"
               >
-                <span class="truncate">{{ p.name }}</span>
-                <span class="text-xs">{{ p.items.length }}</span>
+                <span class="min-w-0 flex-1 truncate">{{ p.name }}</span>
+                <span class="min-w-[3ch] shrink-0 text-right text-[10.5px] tabular-nums">
+                  {{ p.items.length > 999 ? '999+' : p.items.length }}
+                </span>
               </button>
-              <Empty v-if="!store.playlists.length" class="min-h-32">
-                <p class="text-sm text-muted-foreground">还没有歌单</p>
-              </Empty>
+              <button
+                type="button"
+                class="flex h-7 items-center gap-1.5 rounded-md px-2 text-[12.5px] text-muted-foreground transition-colors duration-150 hover:bg-accent/60 hover:text-foreground"
+                @click="createOpen = true"
+              >
+                <Plus class="size-3.5 shrink-0" />
+                <span class="min-w-0 flex-1 truncate">新建歌单</span>
+              </button>
+              <p v-if="!store.playlists.length" class="px-2 py-1 text-[11.5px] text-muted-foreground">
+                还没有歌单
+              </p>
+            </div>
+          </Transition>
+        </div>
+      </ScrollArea>
+    </aside>
+
+    <!-- ===== 右：内容（key 随来源变化，复用全局 tab-animate 切换动画） ===== -->
+    <section :key="view" class="tab-animate flex min-w-0 flex-1 flex-col">
+      <!-- 未登录态 -->
+      <div v-if="needsLogin" class="flex min-h-0 flex-1 items-center justify-center px-6">
+        <Empty>
+          <EmptyMedia>
+            <Music2 class="size-8 text-muted-foreground" />
+          </EmptyMedia>
+          <EmptyTitle>还没有可用的飞牛音乐连接</EmptyTitle>
+          <EmptyDescription>
+            到「设置 → 飞牛音乐连接」添加并登录，或先到「发现音乐」下载歌曲到本地曲库。
+          </EmptyDescription>
+        </Empty>
+      </div>
+
+      <template v-else>
+        <!-- 工具栏 -->
+        <header class="flex shrink-0 items-center gap-2 border-b px-4 py-2.5">
+          <template v-if="view === 'feiniu'">
+            <div class="relative w-full max-w-sm">
+              <Search class="pointer-events-none absolute left-2.5 top-1/2 size-3.5 -translate-y-1/2 text-muted-foreground" />
+              <Input
+                v-model="store.searchKeyword"
+                class="h-8 pl-8"
+                placeholder="搜索歌名 / 歌手 / 专辑"
+                @input="onSearchInput"
+                @keydown.enter="onSearchInput"
+              />
+            </div>
+            <Button variant="outline" size="sm" class="h-8" :disabled="store.loading" @click="refreshFeiniu">
+              <RefreshCw :class="store.loading ? 'size-3.5 animate-spin' : 'size-3.5'" />
+              刷新
+            </Button>
+            <span class="ml-1 text-[11.5px] text-muted-foreground">
+              {{ store.tracks.length }}<template v-if="store.total > store.tracks.length"> / {{ store.total }}</template> 首
+            </span>
+            <Button size="sm" class="ml-auto h-8" :disabled="!store.tracks.length" @click="playFeiniu">
+              <Play class="size-3.5" /> 播放全部
+            </Button>
+          </template>
+
+          <template v-else-if="view === 'local'">
+            <Button variant="outline" size="sm" class="h-8" :disabled="store.localScanBusy" @click="refreshLocal">
+              <Loader2 v-if="store.localScanBusy" class="size-3.5 animate-spin" />
+              <FolderOpen v-else class="size-3.5" />
+              扫描本地曲库
+            </Button>
+            <span class="text-[11.5px] text-muted-foreground">{{ store.localTracks.length }} 首</span>
+            <Button size="sm" class="ml-auto h-8" :disabled="!store.localTracks.length" @click="playLocal">
+              <Play class="size-3.5" /> 播放全部
+            </Button>
+          </template>
+
+          <template v-else>
+            <template v-if="activePlaylist">
+              <div class="min-w-0">
+                <div class="truncate text-[13px] font-medium">{{ activePlaylist.name }}</div>
+                <div class="text-[11.5px] text-muted-foreground">{{ activePlaylist.items.length }} 首</div>
+              </div>
+              <div class="ml-auto flex items-center gap-1.5">
+                <Button variant="outline" size="sm" class="h-8" @click="editorOpen = true">
+                  <ListPlus class="size-3.5" />
+                  编辑音乐
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  class="size-8"
+                  aria-label="重命名歌单"
+                  @click="openRename"
+                >
+                  <Pencil class="size-3.5" />
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  class="size-8 text-destructive hover:text-destructive"
+                  aria-label="删除歌单"
+                  @click="removePlaylist"
+                >
+                  <Trash2 class="size-3.5" />
+                </Button>
+                <Button size="sm" class="h-8" :disabled="!activePlaylist.items.length" @click="playActivePlaylist">
+                  <Play class="size-3.5" /> 播放全部
+                </Button>
+              </div>
+            </template>
+            <span v-else class="text-[12.5px] text-muted-foreground">选择左侧歌单查看内容</span>
+          </template>
+        </header>
+
+        <!-- 列表 -->
+        <ScrollArea class="min-h-0 flex-1">
+          <div class="px-2 pb-4">
+            <!-- 表头 -->
+            <div
+              v-if="
+                (view === 'feiniu' && store.tracks.length) ||
+                (view === 'local' && store.localTracks.length) ||
+                (view === 'playlists' && activePlaylist?.items.length)
+              "
+              class="grid h-8 items-center gap-3 px-2 text-[11px] text-muted-foreground"
+              :style="GRID"
+            >
+              <span class="text-center">#</span>
+              <span />
+              <span>标题</span>
+              <span class="text-right">时长</span>
+              <span />
             </div>
 
-            <div class="flex flex-col gap-2">
-              <div v-if="activePlaylist" class="flex items-center justify-between">
-                <div>
-                  <div class="text-base font-semibold">{{ activePlaylist.name }}</div>
-                  <div class="text-xs text-muted-foreground">{{ activePlaylist.items.length }} 首</div>
-                </div>
-                <div class="flex items-center gap-2">
-                  <Button variant="outline" size="sm" :disabled="!activePlaylist.items.length" @click="store.playQueue(activePlaylist.items, 0)">
-                    ▶ 播放全部
-                  </Button>
-                  <Button
-                    variant="ghost"
-                    size="icon"
-                    class="size-8 text-destructive"
-                    @click="store.deletePlaylist(activePlaylist.id); activePlaylistId = ''"
-                  >
-                    <Trash2 class="size-4" />
-                  </Button>
-                </div>
+            <!-- 飞牛曲库 -->
+            <template v-if="view === 'feiniu'">
+              <div v-if="store.loading" class="flex items-center justify-center gap-2 py-14 text-[12.5px] text-muted-foreground">
+                <Loader2 class="size-4 animate-spin" /> 加载曲库…
               </div>
-              <div v-if="activePlaylist" class="flex flex-col gap-1.5">
+              <Empty v-else-if="!store.tracks.length">
+                <EmptyMedia><Music2 class="size-8 text-muted-foreground" /></EmptyMedia>
+                <EmptyTitle>{{ store.searchKeyword.trim() ? '没有匹配的曲目' : '曲库为空' }}</EmptyTitle>
+                <EmptyDescription>{{ listEmptyHint }}</EmptyDescription>
+              </Empty>
+              <template v-else>
                 <TrackItem
-                  v-for="(t, i) in activePlaylist.items"
-                  :key="`${t.source}-${t.guid}-${i}`"
+                  v-for="(t, i) in store.tracks"
+                  :key="t.guid || i"
                   :item="t"
+                  :index="i"
+                  :context="store.tracks"
                   :active="store.current?.guid === t.guid"
                 />
-                <div class="mt-1 flex justify-end">
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    class="text-xs text-muted-foreground"
-                    @click="store.removeFromPlaylist(activePlaylist.id, activePlaylist.items.length - 1)"
-                  >
-                    移除最后一首
-                  </Button>
+                <div
+                  v-if="store.hasMoreTracks"
+                  ref="loadMoreRef"
+                  class="flex items-center justify-center gap-2 py-4 text-[12px] text-muted-foreground"
+                >
+                  <Loader2 v-if="store.loadingMore" class="size-3.5 animate-spin" />
+                  正在加载更多…
                 </div>
-              </div>
-              <Empty v-else class="min-h-40">
-                <p class="text-sm text-muted-foreground">选择左侧歌单查看内容</p>
-              </Empty>
-            </div>
-          </div>
-        </template>
-      </template>
-    </div>
-  </ScrollArea>
+              </template>
+            </template>
 
-  <!-- 新建歌单弹窗 -->
-  <Dialog v-model:open="createOpen">
-    <DialogContent class="sm:max-w-sm">
-      <DialogHeader>
-        <DialogTitle>新建歌单</DialogTitle>
-        <DialogDescription>歌单保存在本机，可混合飞牛 NAS 与本地曲目。</DialogDescription>
-      </DialogHeader>
-      <Input v-model="playlistName" placeholder="歌单名称" @keydown.enter="createPlaylist" />
-      <DialogFooter>
-        <Button variant="outline" @click="createOpen = false">取消</Button>
-        <Button @click="createPlaylist">创建</Button>
-      </DialogFooter>
-    </DialogContent>
-  </Dialog>
-</template>
\ No newline at end of file
+            <!-- 本地曲库 -->
+            <template v-else-if="view === 'local'">
+              <Empty v-if="!store.localTracks.length && !store.localScanBusy">
+                <EmptyMedia><HardDrive class="size-8 text-muted-foreground" /></EmptyMedia>
+                <EmptyTitle>暂无本地音乐</EmptyTitle>
+                <EmptyDescription>{{ listEmptyHint }}</EmptyDescription>
+              </Empty>
+              <template v-else>
+                <TrackItem
+                  v-for="(t, i) in store.localTracks"
+                  :key="t.guid || i"
+                  :item="t"
+                  :index="i"
+                  :context="store.localTracks"
+                  :active="store.current?.guid === t.guid"
+                />
+              </template>
+            </template>
+
+            <!-- 歌单详情 -->
+            <template v-else>
+              <template v-if="activePlaylist">
+                <Empty v-if="!activePlaylist.items.length">
+                  <EmptyMedia><ListMusic class="size-8 text-muted-foreground" /></EmptyMedia>
+                  <EmptyTitle>歌单还是空的</EmptyTitle>
+                  <EmptyDescription>
+                    点击「编辑音乐」从全部音乐里勾选加入，或在曲库列表中通过「⋯」菜单单首添加。
+                  </EmptyDescription>
+                  <Button size="sm" class="mt-1" @click="editorOpen = true">
+                    <ListPlus class="size-3.5" />
+                    编辑音乐
+                  </Button>
+                </Empty>
+                <TrackItem
+                  v-for="(t, i) in activePlaylist.items"
+                  :key="`${t.source}:${t.guid}:${i}`"
+                  :item="t"
+                  :index="i"
+                  :context="activePlaylist.items"
+                  :playlist-id="activePlaylist.id"
+                  :playlist-index="i"
+                  :active="store.current?.guid === t.guid"
+                  show-source
+                />
+              </template>
+              <Empty v-else>
+                <EmptyMedia><ListMusic class="size-8 text-muted-foreground" /></EmptyMedia>
+                <EmptyTitle>还没有歌单</EmptyTitle>
+                <EmptyDescription>点击左侧「新建歌单」开始整理你的收藏。</EmptyDescription>
+              </Empty>
+            </template>
+          </div>
+        </ScrollArea>
+      </template>
+    </section>
+
+    <!-- 新建歌单 -->
+    <Dialog v-model:open="createOpen">
+      <DialogContent class="sm:max-w-sm">
+        <DialogHeader>
+          <DialogTitle>新建歌单</DialogTitle>
+          <DialogDescription>歌单保存在本机，可混合飞牛 NAS 与本地曲目。</DialogDescription>
+        </DialogHeader>
+        <Input v-model="newName" placeholder="歌单名称" @keydown.enter="createPlaylist" />
+        <DialogFooter>
+          <Button variant="outline" @click="createOpen = false">取消</Button>
+          <Button @click="createPlaylist">创建</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <!-- 重命名歌单 -->
+    <Dialog v-model:open="renameOpen">
+      <DialogContent class="sm:max-w-sm">
+        <DialogHeader>
+          <DialogTitle>重命名歌单</DialogTitle>
+        </DialogHeader>
+        <Input v-model="renameValue" placeholder="歌单名称" @keydown.enter="confirmRename" />
+        <DialogFooter>
+          <Button variant="outline" @click="renameOpen = false">取消</Button>
+          <Button @click="confirmRename">保存</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <!-- 编辑歌单音乐：从全部音乐勾选加入 / 批量移出 -->
+    <PlaylistEditorDialog
+      v-if="activePlaylist"
+      v-model:open="editorOpen"
+      :playlist-id="activePlaylist.id"
+    />
+  </div>
+</template>
+
+<style scoped>
+/* 歌单子树展开 / 收起 */
+.pl-list-enter-active,
+.pl-list-leave-active {
+  transition: opacity 0.18s ease, transform 0.18s ease;
+}
+.pl-list-enter-from,
+.pl-list-leave-to {
+  opacity: 0;
+  transform: translateY(-6px);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .pl-list-enter-active,
+  .pl-list-leave-active {
+    transition: none;
+  }
+}
+</style>
diff --git a/src/modules/music/components/PlayerBar.vue b/src/modules/music/components/PlayerBar.vue
deleted file mode 100644
index dbfd3c3..0000000
--- a/src/modules/music/components/PlayerBar.vue
+++ /dev/null
@@ -1,142 +0,0 @@
-<script setup lang="ts">
-import { computed } from 'vue'
-import { ListMusic, Maximize2, Music2, Pause, Play, Repeat, Repeat1, Shuffle, SkipBack, SkipForward, Volume2 } from '@lucide/vue'
-import { useFeiniuStore } from '@/stores/feiniuStore'
-import { Slider } from '@/components/ui/slider'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
-
-const store = useFeiniuStore()
-
-const coverUrl = computed(() => {
-  const t = store.current
-  if (t?.source === 'feiniu' && t.coverId && store.mediaPrefix) {
-    return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(t.coverId)}&size=96`
-  }
-  return ''
-})
-
-function onProgress(v: number[] | undefined) {
-  store.seek(((v?.[0] ?? 0) / 100) * store.duration)
-}
-
-function onVolume(v: number[] | undefined) {
-  store.setVolume((v?.[0] ?? 0) / 100)
-}
-
-const modeIcon = computed(() => {
-  if (store.playMode === 'loopOne') return Repeat1
-  if (store.playMode === 'shuffle') return Shuffle
-  return Repeat
-})
-</script>
-
-<template>
-  <div
-    class="flex items-center gap-3 border-t bg-background/80 px-4 py-2.5 backdrop-blur"
-    data-slot="player-bar"
-  >
-    <!-- 封面 + 信息（点击开 Now-Playing） -->
-    <button
-      type="button"
-      class="flex min-w-0 items-center gap-3 text-left"
-      @click="store.nowPlayingOpen = true"
-    >
-      <img
-        v-if="coverUrl"
-        :src="coverUrl"
-        class="size-11 shrink-0 rounded-md object-cover shadow"
-        alt=""
-        @error="($event.target as HTMLImageElement).style.display = 'none'"
-      />
-      <div v-else class="flex size-11 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground">
-        <Music2 class="size-5" />
-      </div>
-      <div class="min-w-0 max-w-44">
-        <div class="truncate text-sm font-medium">{{ store.current?.title || '未播放' }}</div>
-        <div class="truncate text-xs text-muted-foreground">{{ store.current?.artistNames || '选择一首歌曲开始播放' }}</div>
-      </div>
-    </button>
-
-    <!-- 控制区 -->
-    <div class="flex flex-1 flex-col items-center gap-1">
-      <div class="flex items-center gap-3">
-        <Tooltip>
-          <TooltipTrigger as-child>
-            <button type="button" class="text-muted-foreground transition-colors hover:text-foreground" @click="store.togglePlayMode()">
-              <component :is="modeIcon" class="size-4" />
-            </button>
-          </TooltipTrigger>
-          <TooltipContent>
-            {{ store.playMode === 'loopAll' ? '列表循环' : store.playMode === 'loopOne' ? '单曲循环' : '随机播放' }}
-          </TooltipContent>
-        </Tooltip>
-        <button type="button" class="text-muted-foreground transition-colors hover:text-foreground" @click="store.prev()">
-          <SkipBack class="size-5" />
-        </button>
-        <button
-          type="button"
-          class="flex size-10 items-center justify-center rounded-full bg-primary text-primary-foreground transition-opacity hover:opacity-90"
-          :disabled="!store.current"
-          @click="store.toggle()"
-        >
-          <Pause v-if="store.playing" class="size-5" />
-          <Play v-else class="size-5 translate-x-[1px]" />
-        </button>
-        <button type="button" class="text-muted-foreground transition-colors hover:text-foreground" @click="store.next()">
-          <SkipForward class="size-5" />
-        </button>
-        <button
-          type="button"
-          class="relative text-muted-foreground transition-colors hover:text-foreground"
-          @click="store.queueVisible = !store.queueVisible"
-        >
-          <ListMusic class="size-4" />
-          <span
-            v-if="store.queue.length"
-            class="absolute -right-1.5 -top-1 flex size-3.5 items-center justify-center rounded-full bg-primary text-[8px] font-medium text-primary-foreground"
-          >
-            {{ store.queue.length }}
-          </span>
-        </button>
-      </div>
-      <div class="flex w-full max-w-lg items-center gap-2">
-        <span class="w-10 text-right text-[10px] tabular-nums text-muted-foreground">{{ store.fmtDuration(store.position) }}</span>
-        <Slider
-          :model-value="[store.progress]"
-          class="flex-1"
-          :max="100"
-          :step="0.5"
-          @update:model-value="onProgress"
-        />
-        <span class="w-10 text-[10px] tabular-nums text-muted-foreground">{{ store.fmtDuration(store.duration) }}</span>
-      </div>
-    </div>
-
-    <!-- 音量 + 歌词 + 最大化 -->
-    <div class="flex items-center gap-2">
-      <Volume2 class="size-4 text-muted-foreground" />
-      <Slider
-        :model-value="[store.volume * 100]"
-        class="w-20"
-        :max="100"
-        :step="1"
-        @update:model-value="onVolume"
-      />
-      <button
-        type="button"
-        class="text-muted-foreground transition-colors hover:text-foreground"
-        :class="{ 'text-primary': store.lyricVisible }"
-        @click="store.lyricVisible = !store.lyricVisible"
-      >
-        词
-      </button>
-      <button
-        type="button"
-        class="text-muted-foreground transition-colors hover:text-foreground"
-        @click="store.nowPlayingOpen = true"
-      >
-        <Maximize2 class="size-4" />
-      </button>
-    </div>
-  </div>
-</template>
\ No newline at end of file
diff --git a/src/modules/music/components/PlayerFull.vue b/src/modules/music/components/PlayerFull.vue
deleted file mode 100644
index 9966401..0000000
--- a/src/modules/music/components/PlayerFull.vue
+++ /dev/null
@@ -1,176 +0,0 @@
-<script setup lang="ts">
-import { computed, ref, watchEffect } from 'vue'
-import { ListMusic, Music2, Pause, Play, Repeat, Repeat1, Shuffle, SkipBack, SkipForward, X } from '@lucide/vue'
-import { useFeiniuStore } from '@/stores/feiniuStore'
-import { Slider } from '@/components/ui/slider'
-import { Dialog, DialogContent, DialogClose } from '@/components/ui/dialog'
-import { ScrollArea } from '@/components/ui/scroll-area'
-
-const store = useFeiniuStore()
-
-const coverUrl = computed(() => {
-  const t = store.current
-  if (t?.source === 'feiniu' && t.coverId && store.mediaPrefix) {
-    return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(t.coverId)}&size=400`
-  }
-  return ''
-})
-
-const currentLineIdx = computed(() => store.currentLine())
-
-function onProgress(v: number[] | undefined) {
-  store.seek(((v?.[0] ?? 0) / 100) * store.duration)
-}
-
-const modeIcon = computed(() => {
-  if (store.playMode === 'loopOne') return Repeat1
-  if (store.playMode === 'shuffle') return Shuffle
-  return Repeat
-})
-
-// 歌词滚动跟随
-const lyricScrollEl = ref<HTMLElement | null>(null)
-watchEffect(() => {
-  const idx = currentLineIdx.value
-  if (idx < 0 || !lyricScrollEl.value) return
-  const nodes = lyricScrollEl.value.querySelectorAll<HTMLElement>('[data-line]')
-  const node = nodes[idx]
-  if (node) node.scrollIntoView({ block: 'center', behavior: 'smooth' })
-})
-</script>
-
-<template>
-  <Dialog v-model:open="store.nowPlayingOpen">
-    <DialogContent
-      class="max-w-4xl overflow-hidden border-0 p-0 sm:max-w-5xl"
-      :show-close-button="false"
-    >
-      <div class="relative flex min-h-[70vh] flex-col">
-        <!-- 背景渐变 -->
-        <div class="pointer-events-none absolute inset-0">
-          <img v-if="coverUrl" :src="coverUrl" class="h-full w-full scale-110 object-cover blur-2xl opacity-30" alt="" />
-          <div class="absolute inset-0 bg-gradient-to-b from-background/60 via-background/85 to-background" />
-        </div>
-
-        <div class="relative flex min-h-0 flex-1">
-          <!-- 左：封面 + 控制 -->
-          <div class="flex w-1/2 flex-col items-center justify-center gap-5 p-8">
-            <img
-              v-if="coverUrl"
-              :src="coverUrl"
-              class="size-64 rounded-xl object-cover shadow-2xl ring-1 ring-border"
-              alt=""
-            />
-            <div v-else class="flex size-64 items-center justify-center rounded-xl bg-muted/40 text-muted-foreground shadow-2xl">
-              <Music2 class="size-20" />
-            </div>
-            <div class="text-center">
-              <div class="truncate text-2xl font-semibold">{{ store.current?.title || '未播放' }}</div>
-              <div class="mt-1 truncate text-sm text-muted-foreground">
-                {{ store.current?.artistNames || '—' }}<template v-if="store.current?.album"> · {{ store.current.album }}</template>
-              </div>
-            </div>
-
-            <div class="flex w-full max-w-sm flex-col gap-2">
-              <Slider
-                :model-value="[store.progress]"
-                :max="100"
-                :step="0.5"
-                @update:model-value="onProgress"
-              />
-              <div class="flex justify-between text-[11px] tabular-nums text-muted-foreground">
-                <span>{{ store.fmtDuration(store.position) }}</span>
-                <span>{{ store.fmtDuration(store.duration) }}</span>
-              </div>
-              <div class="mt-1 flex items-center justify-center gap-6">
-                <button type="button" class="text-muted-foreground hover:text-foreground" @click="store.togglePlayMode()">
-                  <component :is="modeIcon" class="size-5" />
-                </button>
-                <button type="button" class="text-muted-foreground hover:text-foreground" @click="store.prev()">
-                  <SkipBack class="size-7" />
-                </button>
-                <button
-                  type="button"
-                  class="flex size-16 items-center justify-center rounded-full bg-primary text-primary-foreground transition-opacity hover:opacity-90"
-                  :disabled="!store.current"
-                  @click="store.toggle()"
-                >
-                  <Pause v-if="store.playing" class="size-8" />
-                  <Play v-else class="size-8 translate-x-[1px]" />
-                </button>
-                <button type="button" class="text-muted-foreground hover:text-foreground" @click="store.next()">
-                  <SkipForward class="size-7" />
-                </button>
-                <button type="button" class="text-muted-foreground hover:text-foreground" @click="store.queueVisible = true">
-                  <ListMusic class="size-5" />
-                </button>
-              </div>
-            </div>
-          </div>
-
-          <!-- 右：歌词 / 队列 -->
-          <div class="flex w-1/2 flex-col border-l border-white/10 p-6">
-            <div class="mb-3 flex items-center justify-between">
-              <button
-                type="button"
-                class="text-sm"
-                :class="!store.queueVisible ? 'font-semibold text-foreground' : 'text-muted-foreground'"
-                @click="store.queueVisible = false"
-              >
-                歌词
-              </button>
-              <button
-                type="button"
-                class="text-sm"
-                :class="store.queueVisible ? 'font-semibold text-foreground' : 'text-muted-foreground'"
-                @click="store.queueVisible = true"
-              >
-                队列（{{ store.queue.length }}）
-              </button>
-            </div>
-            <ScrollArea class="min-h-0 flex-1 pr-3">
-              <div v-if="!store.queueVisible" ref="lyricScrollEl" class="flex flex-col gap-1 py-2">
-                <p v-if="!store.lyricLines.length" class="text-sm text-muted-foreground/60">
-                  {{ store.current?.source === 'local' ? '本地文件无歌词' : '暂无歌词' }}
-                </p>
-                <p
-                  v-for="(line, idx) in store.lyricLines"
-                  :key="idx"
-                  data-line
-                  class="cursor-pointer py-1 text-[15px] leading-7 transition-colors"
-                  :class="idx === currentLineIdx ? 'font-medium text-foreground' : 'text-muted-foreground/60'"
-                  @click="store.seek(line.t)"
-                >
-                  {{ line.text }}
-                </p>
-              </div>
-              <div v-else class="flex flex-col gap-1.5 py-1">
-                <p v-if="!store.queue.length" class="text-sm text-muted-foreground/60">队列为空</p>
-                <button
-                  v-for="(q, i) in store.queue"
-                  :key="i"
-                  type="button"
-                  class="flex items-center gap-3 rounded-md px-2 py-1.5 text-left transition-colors"
-                  :class="i === store.queueIndex ? 'bg-primary/10' : 'hover:bg-muted/40'"
-                  @click="store.queueIndex = i; store.playItem(q)"
-                >
-                  <span class="w-5 text-right text-xs tabular-nums text-muted-foreground">{{ i + 1 }}</span>
-                  <div class="min-w-0 flex-1">
-                    <div class="truncate text-sm" :class="i === store.queueIndex ? 'font-medium' : ''">{{ q.title }}</div>
-                    <div class="truncate text-xs text-muted-foreground">{{ q.artistNames }}</div>
-                  </div>
-                </button>
-              </div>
-            </ScrollArea>
-          </div>
-        </div>
-
-        <DialogClose as-child>
-          <button type="button" class="absolute right-4 top-4 z-10 rounded-md p-1.5 text-muted-foreground hover:bg-muted/40 hover:text-foreground">
-            <X class="size-5" />
-          </button>
-        </DialogClose>
-      </div>
-    </DialogContent>
-  </Dialog>
-</template>
\ No newline at end of file
diff --git a/src/modules/music/components/PlaylistEditorDialog.vue b/src/modules/music/components/PlaylistEditorDialog.vue
new file mode 100644
index 0000000..f9f8648
--- /dev/null
+++ b/src/modules/music/components/PlaylistEditorDialog.vue
@@ -0,0 +1,418 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { toast } from 'vue-sonner'
+import { Check, HardDrive, Loader2, Music2, Plus, FolderOpen, Minus } from '@lucide/vue'
+import { useFeiniuStore, type PlayableItem } from '@/stores/feiniuStore'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Checkbox } from '@/components/ui/checkbox'
+import { ScrollArea } from '@/components/ui/scroll-area'
+import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from '@/components/ui/dialog'
+
+const props = defineProps<{
+  open: boolean
+  playlistId: string
+}>()
+const emit = defineEmits<{ 'update:open': [value: boolean] }>()
+
+const store = useFeiniuStore()
+
+const playlist = computed(() => store.playlists.find((p) => p.id === props.playlistId) || null)
+const itemKey = (t: PlayableItem) => `${t.source}:${t.guid ?? ''}`
+
+/** 歌单已有曲目 key 集合 */
+const inPlaylistKeys = computed(() => new Set((playlist.value?.items ?? []).map(itemKey)))
+
+// ===== 状态 =====
+const tab = ref<'all' | 'inPlaylist'>('all')
+const sourceFilter = ref<'all' | 'feiniu' | 'local'>('all')
+const keyword = ref('')
+const checked = ref<Set<string>>(new Set())
+
+function resetState() {
+  tab.value = 'all'
+  sourceFilter.value = 'all'
+  keyword.value = ''
+  checked.value = new Set()
+  limit.value = LIMIT
+}
+
+// 打开时重置并确保曲库有数据可挑
+watch(
+  () => props.open,
+  async (open) => {
+    if (!open) return
+    resetState()
+    if (store.config.loggedIn && store.tracks.length === 0) {
+      store.loadTracks(1).catch((e) => toast.error(String(e)))
+    }
+  }
+)
+
+// 切 tab / 切来源时清空选择，避免"看不到的项仍被选中"造成数量对不上
+watch([tab, sourceFilter], () => {
+  checked.value = new Set()
+  limit.value = LIMIT
+})
+
+// ===== 数据源 =====
+const allTracks = computed<PlayableItem[]>(() => {
+  if (sourceFilter.value === 'feiniu') return store.tracks
+  if (sourceFilter.value === 'local') return store.localTracks
+  return [...store.tracks, ...store.localTracks]
+})
+
+const baseList = computed<PlayableItem[]>(() => {
+  const list = tab.value === 'inPlaylist' ? playlist.value?.items ?? [] : allTracks.value
+  const kw = keyword.value.trim().toLowerCase()
+  if (!kw) return list
+  return list.filter(
+    (t) =>
+      t.title.toLowerCase().includes(kw) ||
+      t.artistNames.toLowerCase().includes(kw) ||
+      (t.album ?? '').toLowerCase().includes(kw)
+  )
+})
+
+// 大列表增量渲染
+const LIMIT = 120
+const limit = ref(LIMIT)
+const visibleList = computed(() => baseList.value.slice(0, limit.value))
+const hasMore = computed(() => baseList.value.length > limit.value)
+watch(baseList, () => (limit.value = LIMIT))
+
+/** 已在歌单的曲目在「全部音乐」里不可重复勾选 */
+function isAlreadyIn(item: PlayableItem): boolean {
+  return tab.value === 'all' && inPlaylistKeys.value.has(itemKey(item))
+}
+function isSelectable(item: PlayableItem): boolean {
+  return !isAlreadyIn(item)
+}
+
+const selectableKeys = computed(() =>
+  baseList.value.filter((t) => isSelectable(t)).map(itemKey)
+)
+const allChecked = computed(
+  () => selectableKeys.value.length > 0 && selectableKeys.value.every((k) => checked.value.has(k))
+)
+
+function toggle(key: string) {
+  const next = new Set(checked.value)
+  if (next.has(key)) next.delete(key)
+  else next.add(key)
+  checked.value = next
+}
+function toggleAll() {
+  checked.value = allChecked.value ? new Set() : new Set(selectableKeys.value)
+}
+
+const selectedItems = computed(() => {
+  const map = new Map<string, PlayableItem>()
+  for (const t of baseList.value) map.set(itemKey(t), t)
+  for (const t of playlist.value?.items ?? []) map.set(itemKey(t), t)
+  const out: PlayableItem[] = []
+  for (const k of checked.value) {
+    const t = map.get(k)
+    if (t) out.push(t)
+  }
+  return out
+})
+
+const selectedCount = computed(() => checked.value.size)
+
+// ===== 执行 =====
+function apply() {
+  if (!playlist.value) return
+  const n = selectedCount.value
+  if (n === 0) return
+  if (tab.value === 'all') {
+    store.addToPlaylist(playlist.value.id, selectedItems.value)
+    toast.success(`已添加 ${n} 首到「${playlist.value.name}」`)
+  } else {
+    store.removeItemsFromPlaylist(playlist.value.id, [...checked.value])
+    toast.success(`已从「${playlist.value.name}」移除 ${n} 首`)
+  }
+  emit('update:open', false)
+}
+
+const localEmpty = computed(() => store.localTracks.length === 0)
+async function scanLocal() {
+  try {
+    await store.scanLocal()
+    toast.success(`已扫描到 ${store.localTracks.length} 首本地音乐`)
+  } catch (e) {
+    toast.error(String(e))
+  }
+}
+
+const durationText = (ms?: number) => (ms ? store.fmtDuration(ms / 1000) : '')
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="(v: boolean) => emit('update:open', v)">
+    <DialogContent class="flex max-h-[80vh] flex-col overflow-hidden sm:max-w-2xl">
+      <DialogHeader>
+        <DialogTitle>编辑歌单 · {{ playlist?.name || '' }}</DialogTitle>
+        <DialogDescription>
+          从全部音乐里勾选加入歌单，或切换到「已在歌单」批量移出。
+        </DialogDescription>
+      </DialogHeader>
+
+      <Tabs v-model="tab" class="flex flex-col">
+        <div class="flex items-center gap-2">
+          <TabsList class="grid w-[220px] shrink-0 grid-cols-2">
+            <TabsTrigger value="all" class="gap-1.5">
+              <Plus class="size-3.5" />全部音乐
+            </TabsTrigger>
+            <TabsTrigger value="inPlaylist" class="gap-1.5">
+              <Minus class="size-3.5" />已在歌单
+              <span class="text-xs text-muted-foreground">({{ playlist?.items.length ?? 0 }})</span>
+            </TabsTrigger>
+          </TabsList>
+
+          <Input
+            v-model="keyword"
+            class="h-8 max-w-56"
+            placeholder="搜索歌名 / 歌手 / 专辑"
+          />
+        </div>
+
+        <!-- ===== 全部音乐：来源筛选 ===== -->
+        <div v-if="tab === 'all'" class="mt-2 flex items-center gap-1.5">
+          <button
+            v-for="opt in (['all', 'feiniu', 'local'] as const)"
+            :key="opt"
+            type="button"
+            class="rounded-md border px-2 py-1 text-[11.5px] transition-colors"
+            :class="
+              sourceFilter === opt
+                ? 'border-primary bg-primary/10 text-foreground'
+                : 'border-border text-muted-foreground hover:bg-accent/50'
+            "
+            @click="sourceFilter = opt"
+          >
+            {{ opt === 'all' ? '全部来源' : opt === 'feiniu' ? '飞牛曲库' : '本地曲库' }}
+          </button>
+          <span class="ml-1 text-[11.5px] text-muted-foreground">{{ baseList.length }} 首</span>
+
+          <label class="ml-auto flex cursor-pointer items-center gap-1.5 text-[11.5px] text-muted-foreground">
+            <Checkbox
+              :model-value="allChecked"
+              :disabled="selectableKeys.length === 0"
+              aria-label="全选当前列表"
+              @update:model-value="toggleAll"
+            />
+            全选当前列表
+          </label>
+        </div>
+        <div v-else class="mt-2 flex items-center gap-2">
+          <span class="text-[11.5px] text-muted-foreground">{{ baseList.length }} 首</span>
+          <label class="ml-auto flex cursor-pointer items-center gap-1.5 text-[11.5px] text-muted-foreground">
+            <Checkbox
+              :model-value="allChecked"
+              :disabled="selectableKeys.length === 0"
+              aria-label="全选当前列表"
+              @update:model-value="toggleAll"
+            />
+            全选当前列表
+          </label>
+        </div>
+
+        <TabsContent value="all" class="mt-2">
+          <ScrollArea class="h-[min(320px,45vh)] rounded-md border">
+            <div class="flex flex-col gap-0.5 p-1">
+              <!-- 本地曲库未扫描 -->
+              <div
+                v-if="sourceFilter !== 'feiniu' && localEmpty"
+                class="flex items-center gap-2 rounded-md border border-dashed px-3 py-2.5"
+              >
+                <FolderOpen class="size-4 shrink-0 text-muted-foreground" />
+                <span class="text-[12px] text-muted-foreground">本地曲库尚未扫描，扫描后即可一起勾选。</span>
+                <Button
+                  size="sm"
+                  variant="outline"
+                  class="ml-auto h-7 shrink-0"
+                  :disabled="store.localScanBusy"
+                  @click="scanLocal"
+                >
+                  <Loader2 v-if="store.localScanBusy" class="size-3.5 animate-spin" />
+                  <span :class="store.localScanBusy ? 'ml-1.5' : ''">
+                    {{ store.localScanBusy ? '扫描中' : '扫描本地' }}
+                  </span>
+                </Button>
+              </div>
+
+              <div
+                v-if="store.loading && !store.tracks.length"
+                class="flex items-center justify-center gap-2 py-10 text-[12px] text-muted-foreground"
+              >
+                <Loader2 class="size-4 animate-spin" /> 加载曲库…
+              </div>
+
+              <p
+                v-else-if="baseList.length === 0"
+                class="py-10 text-center text-[12px] text-muted-foreground"
+              >
+                {{ keyword.trim() ? '没有匹配的曲目' : '没有可添加的曲目' }}
+              </p>
+
+              <button
+                v-for="item in visibleList"
+                :key="itemKey(item)"
+                type="button"
+                class="flex h-11 items-center gap-3 rounded-md px-2 text-left transition-colors"
+                :class="
+                  isSelectable(item)
+                    ? 'hover:bg-accent/50'
+                    : 'cursor-not-allowed opacity-55'
+                "
+                :disabled="!isSelectable(item)"
+                @click="toggle(itemKey(item))"
+              >
+                <span
+                  class="flex size-4 shrink-0 items-center justify-center rounded-[4px] border transition-colors"
+                  :class="
+                    checked.has(itemKey(item))
+                      ? 'border-primary bg-primary text-primary-foreground'
+                      : 'border-input'
+                  "
+                >
+                  <Check v-if="checked.has(itemKey(item))" class="size-3" />
+                </span>
+
+                <span class="flex size-8 shrink-0 items-center justify-center rounded bg-muted text-muted-foreground">
+                  <HardDrive v-if="item.source === 'local'" class="size-3.5" />
+                  <Music2 v-else class="size-3.5" />
+                </span>
+
+                <span class="min-w-0 flex-1">
+                  <span class="block truncate text-[13px]">{{ item.title }}</span>
+                  <span class="block truncate text-[11.5px] text-muted-foreground">
+                    {{ item.artistNames || '—' }}
+                  </span>
+                </span>
+
+                <span
+                  v-if="isAlreadyIn(item)"
+                  class="shrink-0 rounded border border-border px-1.5 py-0.5 text-[10.5px] text-muted-foreground"
+                >
+                  已加入
+                </span>
+                <span class="shrink-0 text-[11.5px] tabular-nums text-muted-foreground">
+                  {{ durationText(item.durationMs) }}
+                </span>
+              </button>
+
+              <div class="flex items-center justify-center gap-2 py-2">
+                <Button
+                  v-if="hasMore"
+                  size="sm"
+                  variant="ghost"
+                  class="text-[11.5px] text-muted-foreground"
+                  @click="limit += LIMIT"
+                >
+                  显示更多（还剩 {{ baseList.length - limit }} 首）
+                </Button>
+                <Button
+                  v-if="sourceFilter !== 'local' && store.hasMoreTracks"
+                  size="sm"
+                  variant="ghost"
+                  class="text-[11.5px] text-muted-foreground"
+                  :disabled="store.loadingMore"
+                  @click="store.loadMoreTracks()"
+                >
+                  <Loader2 v-if="store.loadingMore" class="size-3.5 animate-spin" />
+                  <span :class="store.loadingMore ? 'ml-1.5' : ''">
+                    {{ store.loadingMore ? '加载中' : '继续加载飞牛曲库' }}
+                  </span>
+                </Button>
+              </div>
+            </div>
+          </ScrollArea>
+        </TabsContent>
+
+        <!-- ===== 已在歌单：批量移出 ===== -->
+        <TabsContent value="inPlaylist" class="mt-2">
+          <ScrollArea class="h-[min(320px,45vh)] rounded-md border">
+            <div class="flex flex-col gap-0.5 p-1">
+              <p
+                v-if="baseList.length === 0"
+                class="py-10 text-center text-[12px] text-muted-foreground"
+              >
+                {{ keyword.trim() ? '没有匹配的曲目' : '这个歌单还没有歌曲' }}
+              </p>
+              <button
+                v-for="item in visibleList"
+                :key="itemKey(item)"
+                type="button"
+                class="flex h-11 items-center gap-3 rounded-md px-2 text-left transition-colors hover:bg-accent/50"
+                @click="toggle(itemKey(item))"
+              >
+                <span
+                  class="flex size-4 shrink-0 items-center justify-center rounded-[4px] border transition-colors"
+                  :class="
+                    checked.has(itemKey(item))
+                      ? 'border-destructive bg-destructive text-white'
+                      : 'border-input'
+                  "
+                >
+                  <Minus v-if="checked.has(itemKey(item))" class="size-3" />
+                </span>
+
+                <span class="flex size-8 shrink-0 items-center justify-center rounded bg-muted text-muted-foreground">
+                  <HardDrive v-if="item.source === 'local'" class="size-3.5" />
+                  <Music2 v-else class="size-3.5" />
+                </span>
+
+                <span class="min-w-0 flex-1">
+                  <span class="block truncate text-[13px]">{{ item.title }}</span>
+                  <span class="block truncate text-[11.5px] text-muted-foreground">
+                    {{ item.artistNames || '—' }}
+                  </span>
+                </span>
+                <span class="shrink-0 text-[11.5px] tabular-nums text-muted-foreground">
+                  {{ durationText(item.durationMs) }}
+                </span>
+              </button>
+
+              <div v-if="hasMore" class="flex justify-center py-2">
+                <Button
+                  size="sm"
+                  variant="ghost"
+                  class="text-[11.5px] text-muted-foreground"
+                  @click="limit += LIMIT"
+                >
+                  显示更多（还剩 {{ baseList.length - limit }} 首）
+                </Button>
+              </div>
+            </div>
+          </ScrollArea>
+        </TabsContent>
+      </Tabs>
+
+      <DialogFooter class="items-center gap-2 sm:justify-between">
+        <span class="text-[12px] text-muted-foreground">
+          已选 <span class="font-medium text-foreground">{{ selectedCount }}</span> 首
+        </span>
+        <div class="flex items-center gap-2">
+          <Button variant="outline" @click="emit('update:open', false)">取消</Button>
+          <Button
+            :variant="tab === 'inPlaylist' ? 'destructive' : 'default'"
+            :disabled="selectedCount === 0"
+            @click="apply"
+          >
+            {{ tab === 'inPlaylist' ? `移除 ${selectedCount} 首` : `添加 ${selectedCount} 首` }}
+          </Button>
+        </div>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/src/modules/music/components/TrackItem.vue b/src/modules/music/components/TrackItem.vue
index 5ba998f..8ba6a7f 100644
--- a/src/modules/music/components/TrackItem.vue
+++ b/src/modules/music/components/TrackItem.vue
@@ -1,7 +1,19 @@
 <script setup lang="ts">
-import { computed } from 'vue'
+import { computed, ref } from 'vue'
 import { toast } from 'vue-sonner'
-import { Cloud, Music2, MoreHorizontal, Play, Plus } from '@lucide/vue'
+import {
+  ArrowDown,
+  ArrowUp,
+  Cloud,
+  FolderOpen,
+  HardDrive,
+  ListPlus,
+  MoreHorizontal,
+  Music2,
+  Play,
+  Plus,
+  Trash2
+} from '@lucide/vue'
 import type { PlayableItem } from '@/stores/feiniuStore'
 import { useFeiniuStore } from '@/stores/feiniuStore'
 import { Button } from '@/components/ui/button'
@@ -17,10 +29,26 @@ import {
   DropdownMenuTrigger
 } from '@/components/ui/dropdown-menu'
 
-const props = defineProps<{
-  item: PlayableItem
-  active?: boolean
-}>()
+const props = withDefaults(
+  defineProps<{
+    item: PlayableItem
+    /** 是否为当前播放项 */
+    active?: boolean
+    /** 列表内序号（从 0 开始） */
+    index?: number
+    /** 播放上下文：点击播放时以该列表建立队列 */
+    context?: PlayableItem[]
+    /** 显示专辑列 */
+    showAlbum?: boolean
+    /** 显示来源标识（歌单等混排列表） */
+    showSource?: boolean
+    /** 所属歌单 id（提供时可从菜单移除 / 移动） */
+    playlistId?: string
+    /** 歌单内的序号（用于移除 / 移动） */
+    playlistIndex?: number
+  }>(),
+  { active: false, index: 0, showAlbum: false, showSource: false }
+)
 
 const store = useFeiniuStore()
 
@@ -28,10 +56,38 @@ const coverUrl = computed(() => {
   if (props.item.source === 'feiniu' && props.item.coverId && store.mediaPrefix) {
     return `${store.mediaPrefix}/cover?coverId=${encodeURIComponent(props.item.coverId)}&size=64`
   }
-  return ''
+  return props.item.coverUrl ?? ''
+})
+const coverFailed = ref(false)
+
+const durationText = computed(() =>
+  store.fmtDuration(props.item.durationMs ? props.item.durationMs / 1000 : undefined)
+)
+/** 本地文件没有时长信息时，退化为展示文件大小 */
+const fallbackText = computed(() => {
+  if (props.item.durationMs) return ''
+  const n = props.item.size
+  if (!n || n <= 0) return ''
+  if (n >= 1048576) return `${(n / 1048576).toFixed(1)} MB`
+  if (n >= 1024) return `${(n / 1024).toFixed(0)} KB`
+  return `${n} B`
 })
 
-const durationText = computed(() => store.fmtDuration(props.item.durationMs ? props.item.durationMs / 1000 : undefined))
+const isCurrent = computed(
+  () =>
+    props.active ||
+    (store.queueIndex >= 0 &&
+      store.nowPlaying?.guid === props.item.guid &&
+      store.nowPlaying?.source === props.item.source)
+)
+
+const playlistLength = computed(
+  () => (props.playlistId ? store.playlists.find((p) => p.id === props.playlistId)?.items.length ?? 1 : 1)
+)
+
+function play() {
+  store.playItem(props.item, props.context)
+}
 
 function addToPlaylist(playlistId: string) {
   store.addToPlaylist(playlistId, [props.item])
@@ -50,71 +106,150 @@ async function uploadToFeiniu() {
 
 <template>
   <div
-    class="group flex items-center gap-3 rounded-lg border px-3 py-2 transition-colors"
-    :class="active ? 'border-primary bg-primary/10' : 'border-border hover:bg-muted/40'"
+    class="group grid h-11 items-center gap-3 rounded-md px-2 outline-none transition-colors focus-visible:ring-2 focus-visible:ring-ring/50"
+    :class="[
+      showAlbum
+        ? 'grid-cols-[28px_36px_minmax(0,1fr)_minmax(0,0.75fr)_74px_28px]'
+        : 'grid-cols-[28px_36px_minmax(0,1fr)_74px_28px]',
+      isCurrent ? 'bg-accent/60' : 'hover:bg-accent/40'
+    ]"
+    role="button"
+    tabindex="0"
+    @dblclick="play"
+    @keydown.enter.prevent="play"
   >
+    <!-- 序号 / 播放态指示：悬停时原位切换，不占用固定的空白列 -->
+    <div class="flex size-7 items-center justify-center text-[11.5px] tabular-nums text-muted-foreground">
+      <span v-if="isCurrent" class="music-eq" :class="{ 'is-paused': !store.playing }"><i /><i /><i /></span>
+      <template v-else>
+        <span class="group-hover:hidden">{{ index + 1 }}</span>
+        <button
+          type="button"
+          class="hidden text-foreground group-hover:block"
+          :aria-label="'播放 ' + item.title"
+          @click.stop="play"
+        >
+          <Play class="size-3.5" />
+        </button>
+      </template>
+    </div>
+
+    <!-- 封面 -->
     <img
-      v-if="coverUrl"
+      v-if="coverUrl && !coverFailed"
       :src="coverUrl"
-      class="size-10 shrink-0 rounded-md object-cover"
+      class="size-9 rounded object-cover"
       alt=""
       loading="lazy"
-      @error="($event.target as HTMLImageElement).style.display = 'none'"
+      referrerpolicy="no-referrer"
+      @error="coverFailed = true"
     />
-    <div v-else class="flex size-10 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground">
+    <div v-else class="flex size-9 items-center justify-center rounded bg-muted text-muted-foreground">
       <Music2 class="size-4" />
     </div>
 
-    <button
-      type="button"
-      class="flex size-10 shrink-0 items-center justify-center rounded-full bg-primary text-primary-foreground opacity-0 transition-opacity group-hover:opacity-100"
-      :disabled="store.playing && store.current?.guid === item.guid"
-      @click="store.playItem(item)"
-    >
-      <Play class="size-4 translate-x-[1px]" />
-    </button>
-
-    <div class="min-w-0 flex-1">
-      <div class="truncate text-sm font-medium">{{ item.title }}</div>
-      <div class="truncate text-xs text-muted-foreground">
-        {{ item.artistNames }}<template v-if="item.artistNames && item.album"> · </template>{{ item.album }}
-        <span v-if="item.source === 'local'" class="ml-1 rounded bg-muted px-1 text-[10px]">本地</span>
+    <!-- 标题 + 元信息 -->
+    <div class="min-w-0">
+      <div class="flex items-center gap-1.5">
+        <span class="truncate text-[13px]" :class="isCurrent ? 'font-medium text-foreground' : ''">
+          {{ item.title }}
+        </span>
+        <span
+          v-if="showSource"
+          class="shrink-0 text-muted-foreground"
+          :title="item.source === 'local' ? '本地文件' : '飞牛 NAS'"
+        >
+          <HardDrive v-if="item.source === 'local'" class="size-3" />
+          <Cloud v-else class="size-3" />
+        </span>
       </div>
+      <div class="truncate text-[11.5px] text-muted-foreground">{{ item.artistNames || '—' }}</div>
     </div>
 
-    <span class="shrink-0 text-xs tabular-nums text-muted-foreground">{{ durationText }}</span>
+    <!-- 专辑 -->
+    <div v-if="showAlbum" class="truncate text-[11.5px] text-muted-foreground">
+      {{ item.album || '' }}
+    </div>
 
+    <!-- 时长（本地无时长时退化为文件大小） -->
+    <div class="text-right text-[11.5px] tabular-nums text-muted-foreground">
+      <span v-if="item.durationMs">{{ durationText }}</span>
+      <span v-else-if="fallbackText" class="text-[11px]">{{ fallbackText }}</span>
+      <span v-else>--:--</span>
+    </div>
+
+    <!-- 操作菜单 -->
     <DropdownMenu>
       <DropdownMenuTrigger as-child>
-        <Button size="icon" variant="ghost" class="size-8">
+        <Button
+          size="icon"
+          variant="ghost"
+          class="size-7 opacity-0 transition-opacity group-hover:opacity-100 data-[state=open]:opacity-100"
+          :aria-label="'更多操作：' + item.title"
+        >
           <MoreHorizontal class="size-4" />
         </Button>
       </DropdownMenuTrigger>
       <DropdownMenuContent align="end" class="w-48">
-        <DropdownMenuLabel>{{ item.title }}</DropdownMenuLabel>
+        <DropdownMenuLabel class="truncate">{{ item.title }}</DropdownMenuLabel>
         <DropdownMenuSeparator />
-        <DropdownMenuItem @click="store.playItem(item)">
+        <DropdownMenuItem @click="play">
           <Play class="size-4" /> 播放
         </DropdownMenuItem>
-        <DropdownMenuItem
-          v-if="item.source === 'local' && store.fnosLoggedIn && store.libraryNasPath"
-          :disabled="store.uploading"
-          @click="uploadToFeiniu"
-        >
-          <Cloud class="size-4" /> 上传到飞牛曲库
+        <DropdownMenuItem @click="store.playNext(item); toast.success('已加入下一首')">
+          <ListPlus class="size-4" /> 下一首播放
+        </DropdownMenuItem>
+        <DropdownMenuItem @click="store.addToQueue(item); toast.success('已加入队列')">
+          <Plus class="size-4" /> 加入队列
         </DropdownMenuItem>
         <DropdownMenuSub>
           <DropdownMenuSubTrigger>
             <Plus class="size-4" /> 加入歌单
           </DropdownMenuSubTrigger>
-          <DropdownMenuSubContent class="w-48 max-h-64 overflow-y-auto">
+          <DropdownMenuSubContent class="max-h-64 w-48 overflow-y-auto">
             <DropdownMenuItem v-if="store.playlists.length === 0" disabled>还没有歌单</DropdownMenuItem>
             <DropdownMenuItem v-for="p in store.playlists" :key="p.id" @click="addToPlaylist(p.id)">
               {{ p.name }}
             </DropdownMenuItem>
           </DropdownMenuSubContent>
         </DropdownMenuSub>
+
+        <template v-if="item.source === 'local'">
+          <DropdownMenuSeparator />
+          <DropdownMenuItem
+            v-if="store.webdavReady"
+            :disabled="store.uploading"
+            @click="uploadToFeiniu"
+          >
+            <Cloud class="size-4" /> 上传到飞牛曲库
+          </DropdownMenuItem>
+          <DropdownMenuItem disabled>
+            <FolderOpen class="size-4" /> {{ item.dir || '未知目录' }}
+          </DropdownMenuItem>
+        </template>
+
+        <template v-if="playlistId">
+          <DropdownMenuSeparator />
+          <DropdownMenuItem
+            :disabled="(playlistIndex ?? 0) <= 0"
+            @click="store.moveInPlaylist(playlistId, playlistIndex ?? 0, (playlistIndex ?? 0) - 1)"
+          >
+            <ArrowUp class="size-4" /> 上移
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            :disabled="(playlistIndex ?? 0) >= playlistLength - 1"
+            @click="store.moveInPlaylist(playlistId, playlistIndex ?? 0, (playlistIndex ?? 0) + 1)"
+          >
+            <ArrowDown class="size-4" /> 下移
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            class="text-destructive focus:text-destructive"
+            @click="store.removeFromPlaylist(playlistId, playlistIndex ?? 0)"
+          >
+            <Trash2 class="size-4" /> 从歌单移除
+          </DropdownMenuItem>
+        </template>
       </DropdownMenuContent>
     </DropdownMenu>
   </div>
-</template>
\ No newline at end of file
+</template>
diff --git a/src/modules/music/components/settings/CacheSettings.vue b/src/modules/music/components/settings/CacheSettings.vue
index 150edbb..379ad15 100644
--- a/src/modules/music/components/settings/CacheSettings.vue
+++ b/src/modules/music/components/settings/CacheSettings.vue
@@ -1,37 +1,29 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
+import { computed, onMounted } from 'vue'
 import { toast } from 'vue-sonner'
-import { HardDriveDownload, Trash2 } from '@lucide/vue'
+import { HardDriveDownload, Loader2, RefreshCw, Trash2 } from '@lucide/vue'
 import { useFeiniuStore } from '@/stores/feiniuStore'
 import { Button } from '@/components/ui/button'
 import { Label } from '@/components/ui/label'
 import { Switch } from '@/components/ui/switch'
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
 
 const store = useFeiniuStore()
 
-const cacheMax = ref(5)
-const cacheEnabled = ref(false)
-
-onMounted(async () => {
-  await store.init()
-  cacheMode.value = store.cacheMode
-  cacheMax.value = 5
+/** 开关状态直接由 store.cacheMode 派生，避免与此前一样出现「开关显示关闭但实际在缓存」 */
+const cacheEnabled = computed({
+  get: () => store.cacheMode === 'cache',
+  set: (v: boolean) => store.setCacheMode(v ? 'cache' : 'stream')
 })
 
-// 本地持久化缓存设置（后端 cache_fetch 用 settings.feiniu_cache_max_gb；这里给个默认）
-const cacheMode = ref<'stream' | 'cache'>(store.cacheMode)
+const usedMb = computed(() => Math.round((store.cacheStatus.usedMb ?? 0) * 10) / 10)
 
-function setMode(v: unknown) {
-  const mode = v === 'cache' ? 'cache' : 'stream'
-  cacheMode.value = mode
-  store.setCacheMode(mode)
-  toast.success(mode === 'cache' ? '已开启缓存后播放' : '已切换为直连流式播放')
-}
+onMounted(() => {
+  void store.ensureCacheStatus()
+})
 
-function setEnabled(v: boolean) {
-  cacheEnabled.value = v
-  if (!v) store.setCacheMode('stream')
+async function refresh() {
+  await store.ensureCacheStatus()
+  toast.success('缓存状态已刷新')
 }
 
 async function clearAll() {
@@ -41,43 +33,42 @@ async function clearAll() {
 </script>
 
 <template>
-  <div class="space-y-4">
-    <div class="flex items-center justify-between">
-      <div>
+  <div class="flex flex-col gap-3">
+    <div class="flex items-start justify-between gap-4">
+      <div class="min-w-0">
         <div class="flex items-center gap-2">
           <HardDriveDownload class="size-4 text-muted-foreground" />
-          <Label class="font-medium">播放缓存</Label>
+          <Label class="font-medium">缓存后播放</Label>
         </div>
-        <p class="mt-1 text-xs text-muted-foreground">
-          缓存后播放：把 NAS 音频缓存到本机（{{ store.cacheStatus.usedMb }} MB / {{ store.cacheStatus.count }} 首），
-          超出上限自动按 LRU 淘汰。直连流式则每次在线拉取。
+        <p class="mt-1 text-[11.5px] text-muted-foreground">
+          开启后先把 NAS 音频缓存到本机再播放（首播需要等待整首下载完成）；关闭则直连流式播放，
+          边下边播、拖动即时生效，但每次都要联网拉取。
         </p>
       </div>
-      <Switch v-model:model-value="cacheEnabled" @update:model-value="setEnabled" />
+      <Switch v-model="cacheEnabled" class="mt-0.5 shrink-0" />
     </div>
 
-    <template v-if="cacheEnabled">
-      <div class="flex items-center justify-between">
-        <Label class="text-muted-foreground">播放模式</Label>
-        <Select :model-value="cacheMode" @update:model-value="setMode">
-          <SelectTrigger class="w-44">
-            <SelectValue />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem value="stream">直连流式</SelectItem>
-            <SelectItem value="cache">缓存后播放</SelectItem>
-          </SelectContent>
-        </Select>
+    <div class="flex items-center justify-between gap-4 rounded-lg border bg-card px-3 py-2">
+      <div class="flex items-center gap-2 text-[12.5px]">
+        <span class="text-muted-foreground">当前占用</span>
+        <span class="tabular-nums">{{ usedMb }} MB</span>
+        <span class="text-muted-foreground">· {{ store.cacheStatus.count }} 首</span>
+        <span class="text-[11.5px] text-muted-foreground/80">（超出上限按 LRU 自动淘汰）</span>
       </div>
-
-      <div class="flex items-center justify-between">
-        <Label class="text-muted-foreground">当前占用</Label>
-        <span class="text-sm tabular-nums">{{ store.cacheStatus.usedMb }} MB（{{ store.cacheStatus.count }} 首）</span>
+      <div class="flex shrink-0 items-center gap-1.5">
+        <Button variant="ghost" size="icon" class="size-8" title="刷新" @click="refresh">
+          <RefreshCw class="size-3.5" />
+        </Button>
+        <Button variant="outline" size="sm" class="text-destructive" :disabled="!store.cacheStatus.count" @click="clearAll">
+          <Trash2 class="size-3.5" />
+          <span class="ml-1.5">清空缓存</span>
+        </Button>
       </div>
+    </div>
 
-      <Button variant="outline" size="sm" class="text-destructive" @click="clearAll">
-        <Trash2 class="size-4" /> 清空缓存
-      </Button>
-    </template>
+    <p class="flex items-center gap-1.5 text-[11.5px] text-muted-foreground">
+      <Loader2 class="size-3" />
+      切换缓存模式不会中断当前播放，下一首起按新模式取流。
+    </p>
   </div>
-</template>
\ No newline at end of file
+</template>
diff --git a/src/modules/music/components/settings/ConnectionsSettings.vue b/src/modules/music/components/settings/ConnectionsSettings.vue
index 612d11b..65a5c73 100644
--- a/src/modules/music/components/settings/ConnectionsSettings.vue
+++ b/src/modules/music/components/settings/ConnectionsSettings.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { onMounted, ref } from 'vue'
 import { toast } from 'vue-sonner'
-import { Check, Cloud, Loader2, Pencil, Plus, Power, Trash2 } from '@lucide/vue'
+import { Check, CircleCheck, Loader2, LogOut, Pencil, Plus, Trash2 } from '@lucide/vue'
 import { useFeiniuStore, type FeiniuConnection } from '@/stores/feiniuStore'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
@@ -22,10 +22,6 @@ const editing = ref<Partial<FeiniuConnection> | null>(null)
 const editOpen = ref(false)
 const password = ref('')
 const testing = ref(false)
-const fnosPassword = ref('')
-const fnosFormOpen = ref(false)
-/** 目标 fnOS 登录连接 */
-const fnosTarget = ref<FeiniuConnection | null>(null)
 
 function newForm() {
   editing.value = { name: '', kind: 'lan', baseUrl: '', username: '', accessCode: '', insecure: false, fnId: '' }
@@ -39,12 +35,6 @@ function editForm(c: FeiniuConnection) {
   editOpen.value = true
 }
 
-function openFnosLogin(c: FeiniuConnection) {
-  fnosTarget.value = c
-  fnosPassword.value = ''
-  fnosFormOpen.value = true
-}
-
 async function save() {
   if (!editing.value) return
   if (!editing.value.name?.trim() || !editing.value.baseUrl?.trim()) {
@@ -103,21 +93,6 @@ async function remove(c: FeiniuConnection) {
   toast.success('已删除')
 }
 
-async function fnosLogin() {
-  if (!fnosTarget.value) return
-  if (!fnosPassword.value) {
-    toast.error('请输入 NAS 密码')
-    return
-  }
-  try {
-    await store.fnosLogin(fnosTarget.value.username, fnosPassword.value)
-    fnosFormOpen.value = false
-    toast.success('NAS 文件服务已连接')
-  } catch (e) {
-    toast.error(String(e))
-  }
-}
-
 function kindLabel(k: string) {
   return k === 'lan' ? '局域网' : k === 'frp' ? 'frp 域名' : 'FnConnect'
 }
@@ -154,19 +129,39 @@ onMounted(() => store.refreshConnections())
           <span v-if="c.loggedIn" class="mr-1 flex items-center gap-1 text-xs text-emerald-600">
             <Check class="size-3.5" /> 已登录
           </span>
-          <Button v-if="store.activeId !== c.id" variant="ghost" size="icon" class="size-8" @click="activate(c)">
-            <Power class="size-4" />
+          <Button
+            v-if="store.activeId !== c.id"
+            variant="ghost"
+            size="icon"
+            class="size-8"
+            :title="`设为激活连接（${c.name}）`"
+            :aria-label="`设为激活连接 ${c.name}`"
+            @click="activate(c)"
+          >
+            <CircleCheck class="size-4" />
           </Button>
-          <Button v-if="store.activeId === c.id && !store.fnosLoggedIn" variant="ghost" size="icon" class="size-8" :title="`连接 NAS 文件服务（${c.username}）`" @click="openFnosLogin(c)">
-            <Cloud class="size-4" />
-          </Button>
-          <Button variant="ghost" size="icon" class="size-8" @click="editForm(c)">
+          <Button variant="ghost" size="icon" class="size-8" title="编辑连接" aria-label="编辑连接" @click="editForm(c)">
             <Pencil class="size-4" />
           </Button>
-          <Button v-if="c.loggedIn" variant="ghost" size="icon" class="size-8" @click="logout(c)">
-            <Power class="size-4" />
+          <Button
+            v-if="c.loggedIn"
+            variant="ghost"
+            size="icon"
+            class="size-8"
+            title="登出"
+            aria-label="登出"
+            @click="logout(c)"
+          >
+            <LogOut class="size-4" />
           </Button>
-          <Button variant="ghost" size="icon" class="size-8 text-destructive" @click="remove(c)">
+          <Button
+            variant="ghost"
+            size="icon"
+            class="size-8 text-destructive"
+            title="删除连接"
+            aria-label="删除连接"
+            @click="remove(c)"
+          >
             <Trash2 class="size-4" />
           </Button>
         </div>
@@ -234,24 +229,9 @@ onMounted(() => store.refreshConnections())
       </DialogContent>
     </Dialog>
 
-    <!-- fnOS 文件服务登录（上传到飞牛用） -->
-    <Dialog v-model:open="fnosFormOpen">
-      <DialogContent class="sm:max-w-sm">
-        <DialogHeader>
-          <DialogTitle>连接 NAS 文件服务</DialogTitle>
-        </DialogHeader>
-        <p class="text-xs text-muted-foreground">
-          账号：{{ fnosTarget?.username }}。连接后即可把本地音乐上传到飞牛曲库目录、从曲库删除音乐。
-        </p>
-        <div class="space-y-1.5">
-          <Label>NAS 密码</Label>
-          <Input v-model="fnosPassword" type="password" placeholder="NAS 登录密码" @keydown.enter="fnosLogin" />
-        </div>
-        <DialogFooter>
-          <Button variant="outline" @click="fnosFormOpen = false">取消</Button>
-          <Button @click="fnosLogin">连接</Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
+    <p class="text-xs text-muted-foreground">
+      提示：上传音乐到 NAS（「下载到飞牛」/ 上传 / 删除）已改用 <strong class="font-medium">WebDAV</strong>，
+      在「存储与上传」分组里配置，无需在此登录文件服务。
+    </p>
   </div>
 </template>
\ No newline at end of file
diff --git a/src/modules/music/index.ts b/src/modules/music/index.ts
index 7596e8e..26459dc 100644
--- a/src/modules/music/index.ts
+++ b/src/modules/music/index.ts
@@ -3,9 +3,9 @@ import type { SearchIndexItem } from '@/stores/searchIndex'
 
 const searchItems: SearchIndexItem[] = [
   {
-    title: '我的音乐',
-    description: '飞牛 NAS 曲库 / 本地曲库 / 自定义歌单与内嵌播放器',
-    keywords: ['音乐', 'music', '飞牛', 'NAS', '曲库', '歌单', '播放', '本地'],
+    title: '曲库',
+    description: '飞牛 NAS 曲库 / 本地曲库 / 自定义歌单，标题栏播放控制',
+    keywords: ['音乐', 'music', '曲库', '我的音乐', '飞牛', 'NAS', '歌单', '播放', '本地', '歌词', '队列'],
     tab: 'mymusic'
   },
   {
@@ -43,5 +43,6 @@ export const moduleConfig: ModuleConfig = {
         .catch(() => {})
     }
   },
-  order: 55
+  // 默认排在「代理」之后、整体第二位（proxy=10、clipboard=20）
+  order: 15
 }
diff --git a/src/stores/appStore.ts b/src/stores/appStore.ts
index 8c0137f..ee6f0b1 100644
--- a/src/stores/appStore.ts
+++ b/src/stores/appStore.ts
@@ -59,6 +59,8 @@ export const useAppStore = defineStore('app', () => {
   const isAutoStart = ref(false)
   const silentAutoStart = ref(false)
   const isInitialized = ref(false)
+  /** 模块排序一次性迁移标记（音乐 → 代理之后），随设置持久化 */
+  let musicOrderMigrated = false
   const modules = ref<ModuleInfo[]>(initModulesFromRegistry())
   const moduleOrder = ref<string[]>(initModuleOrder())
 
@@ -111,6 +113,19 @@ export const useAppStore = defineStore('app', () => {
           const known = savedOrder.filter(id => allUserIds.includes(id))
           const newlyAdded = allUserIds.filter(id => !savedOrder.includes(id))
           moduleOrder.value = [...known, ...newlyAdded]
+
+          // 一次性迁移：音乐模块默认排序调整为「代理之后、整体第二位」。
+          // 迁移后写入标记，尊重用户后续手动拖动的新排序。
+          if (!settings.musicOrderMigrated) {
+            const musicIdx = moduleOrder.value.indexOf('music')
+            if (musicIdx !== -1) {
+              moduleOrder.value.splice(musicIdx, 1)
+              const proxyIdx = moduleOrder.value.indexOf('proxy')
+              moduleOrder.value.splice(proxyIdx === -1 ? 0 : proxyIdx + 1, 0, 'music')
+            }
+            saveSettings()
+          }
+          musicOrderMigrated = true
         }
       }
     } catch {
@@ -132,7 +147,8 @@ export const useAppStore = defineStore('app', () => {
         isAutoStart: isAutoStart.value,
         silentAutoStart: silentAutoStart.value,
         modules: modulesData,
-        moduleOrder: moduleOrder.value
+        moduleOrder: moduleOrder.value,
+        musicOrderMigrated
       }))
     } catch {
       console.error('Failed to save settings to localStorage')
diff --git a/src/stores/feiniuStore.ts b/src/stores/feiniuStore.ts
index edd7786..830b297 100644
--- a/src/stores/feiniuStore.ts
+++ b/src/stores/feiniuStore.ts
@@ -5,20 +5,29 @@ import { createLogger } from '@/lib/logger'
 
 const logger = createLogger('feiniu')
 
-/** 可播条目（飞牛 NAS 或本地文件），是播放器/歌单的统一数据模型 */
+/**
+ * 可播条目（飞牛 NAS / 本地文件 / 发现页试听），是播放器与歌单的统一数据模型。
+ * `source === 'preview'` 表示「发现音乐」页的临时试听，不进入队列。
+ */
 export interface PlayableItem {
-  source: 'feiniu' | 'local'
-  /** feiniu 源：track guid；local 源：文件路径 */
+  source: 'feiniu' | 'local' | 'preview'
+  /** feiniu：track guid；local：文件路径；preview：列表行的稳定 key */
   guid?: string
   title: string
   artistNames: string
   album?: string
   durationMs?: number
   coverId?: string
+  /** 完整封面地址（preview 源直接使用，优先级高于 coverId） */
+  coverUrl?: string
   /** local 源文件大小（字节） */
   size?: number
   /** local 源所在目录 */
   dir?: string
+  /** preview 源：可直接播放的外部链接 */
+  url?: string
+  /** preview 源：格式后缀（展示用） */
+  ext?: string
 }
 
 export interface FeiniuConnection {
@@ -41,19 +50,61 @@ export interface Playlist {
 
 export type PlayMode = 'loopAll' | 'loopOne' | 'shuffle'
 
+/** WebDAV 连接配置（后端 webdav.rs 的镜像；dir 为曲库目标目录，相对 WebDAV 根） */
+export interface WebDavConfig {
+  url: string
+  username: string
+  password: string
+}
+
+/** Now-Playing 大屏右栏标签 */
+export type NowPlayingTab = 'lyric' | 'queue'
+
 interface LrcLine {
   t: number
   text: string
 }
 
-const PLAYERS_KEY = 'thing.music.playlists'
+const PLAYLISTS_KEY = 'thing.music.playlists'
 const QUEUE_KEY = 'thing.music.queue'
 const VOL_KEY = 'thing.music.volume'
+const MUTE_KEY = 'thing.music.muted'
+const MODE_KEY = 'thing.music.playmode'
+const CACHE_MODE_KEY = 'thing.music.cachemode'
+const WEBDAV_KEY = 'thing.music.feiniu.webdav'
+const AUTO_UPLOAD_KEY = 'thing.music.feiniu.autoupload'
+
+/** 曲库单页条数（滚动到底自动续拉） */
+const PAGE_SIZE = 200
 
 function uid(): string {
   return `p${Date.now().toString(36)}${Math.random().toString(36).slice(2, 7)}`
 }
 
+function readLS(key: string): string | null {
+  try {
+    return localStorage.getItem(key)
+  } catch {
+    return null
+  }
+}
+function writeLS(key: string, value: string) {
+  try {
+    localStorage.setItem(key, value)
+  } catch {
+    /* localStorage 不可用/超限时静默降级 */
+  }
+}
+
+/** 把浏览器抛出的播放异常翻译成可读文案 */
+function describePlayError(e: unknown): string {
+  const name = (e as { name?: string })?.name ?? ''
+  if (name === 'NotSupportedError') return '该音频无法播放：格式不支持或链接已失效'
+  if (name === 'NotAllowedError') return '播放被浏览器策略阻止，请再次点击播放'
+  if (name === 'AbortError') return '播放已中断'
+  return `播放失败：${e instanceof Error ? e.message : String(e)}`
+}
+
 export const useFeiniuStore = defineStore('feiniu', () => {
   // ===== 连接 =====
   const connections = ref<FeiniuConnection[]>([])
@@ -65,15 +116,25 @@ export const useFeiniuStore = defineStore('feiniu', () => {
   })
   const mediaPrefix = ref('')
   const connecting = ref(false)
-  // 缓存播放模式（'stream' 直连 | 'cache' 缓存后播放）
+  /** 缓存播放模式（'stream' 直连 | 'cache' 缓存后播放） */
   const cacheMode = ref<'stream' | 'cache'>('stream')
   const cacheStatus = ref<{ count: number; usedMb: number }>({ count: 0, usedMb: 0 })
 
-  // fnOS 文件服务（P6：上传到飞牛）
-  const fnosLoggedIn = ref(false)
-  const libraryNasPath = ref('')
+  // WebDAV 传输配置（下载到飞牛 / 曲库增删）。
+  // 无状态：Basic 认证随每个请求携带，没有会话、重启后也无需重新登录。
+  const webdav = ref<WebDavConfig & { dir: string }>({ url: '', username: '', password: '', dir: '' })
   const autoUpload = ref(false)
   const uploading = ref(false)
+  /** 四项配置齐备才允许上传/删除操作 */
+  const webdavReady = computed(
+    () =>
+      !!(
+        webdav.value.url.trim() &&
+        webdav.value.username.trim() &&
+        webdav.value.password.trim() &&
+        webdav.value.dir.trim()
+      )
+  )
 
   const activeConn = computed(() => connections.value.find((c) => c.id === activeId.value) || null)
 
@@ -82,51 +143,119 @@ export const useFeiniuStore = defineStore('feiniu', () => {
   const page = ref(1)
   const total = ref(0)
   const loading = ref(false)
-  const keyword = ref('')
+  const loadingMore = ref(false)
+  /** 飞牛曲库搜索关键词（与输入框双向绑定） */
+  const searchKeyword = ref('')
   const localTracks = ref<PlayableItem[]>([])
   const localScanBusy = ref(false)
 
+  const hasMoreTracks = computed(() => tracks.value.length < total.value)
+
   // ===== 歌单 =====
   const playlists = ref<Playlist[]>([])
 
   // ===== 播放器内核 =====
   const queue = ref<PlayableItem[]>([])
   const queueIndex = ref(-1)
+  /** 「发现音乐」页的临时试听（与队列播放互斥，共用同一个 audio 实例） */
+  const preview = ref<PlayableItem | null>(null)
   const playMode = ref<PlayMode>('loopAll')
   const volume = ref(0.8)
-  const current = computed(() => queue.value[queueIndex.value] ?? null)
+  const muted = ref(false)
+  const current = computed<PlayableItem | null>(() => queue.value[queueIndex.value] ?? null)
+  /** 播放条展示用的「当前条目」：试听优先，否则取队列当前项 */
+  const nowPlaying = computed<PlayableItem | null>(() => preview.value ?? current.value)
   const playing = ref(false)
   const loadingPlay = ref(false)
+  /** 播放失败原因（由 UI 层消费成 toast 后调用 clearPlayError 清空） */
+  const playError = ref('')
   const position = ref(0)
   const duration = ref(0)
+  /** 已缓冲比例 0~100（流式播放时展示缓冲进度层） */
+  const bufferedPercent = ref(0)
   const lyricLines = ref<LrcLine[]>([])
-  const lyricVisible = ref(false)
-  const queueVisible = ref(false)
   const nowPlayingOpen = ref(false)
+  const nowPlayingTab = ref<NowPlayingTab>('lyric')
+
   let lyricRaw = ''
   let audioEl: HTMLAudioElement | null = null
+  /** 歌词行索引缓存：歌词按时间升序，命中时只做邻近微调，避免每次 timeupdate 全量扫描 */
+  let lyricIdx = -1
+  /** shuffle 待播池与切歌历史栈 */
+  const shufflePool = ref<number[]>([])
+  const historyStack = ref<number[]>([])
+
+  function computeBuffered(a: HTMLAudioElement): number {
+    const d = a.duration
+    if (!isFinite(d) || d <= 0 || a.buffered.length === 0) return 0
+    try {
+      return Math.min(100, (a.buffered.end(a.buffered.length - 1) / d) * 100)
+    } catch {
+      return 0
+    }
+  }
 
   function ensureAudio(): HTMLAudioElement {
     if (!audioEl) {
       const a = new Audio()
       a.preload = 'auto'
       a.volume = volume.value
-      a.addEventListener('loadedmetadata', () => (duration.value = a.duration || 0))
+      a.muted = muted.value
+      a.addEventListener('loadedmetadata', () => {
+        duration.value = isFinite(a.duration) ? a.duration : 0
+        bufferedPercent.value = computeBuffered(a)
+      })
+      a.addEventListener('durationchange', () => {
+        duration.value = isFinite(a.duration) ? a.duration : 0
+      })
       a.addEventListener('timeupdate', () => (position.value = a.currentTime))
+      a.addEventListener('progress', () => (bufferedPercent.value = computeBuffered(a)))
+      a.addEventListener('waiting', () => (loadingPlay.value = true))
+      a.addEventListener('canplay', () => (loadingPlay.value = false))
+      a.addEventListener('playing', () => {
+        loadingPlay.value = false
+        playing.value = true
+      })
       a.addEventListener('play', () => (playing.value = true))
       a.addEventListener('pause', () => (playing.value = false))
       a.addEventListener('ended', () => onEnded())
       a.addEventListener('error', () => {
+        // 主动清空 src 时也会触发 error，此时不应报错
+        if (!a.getAttribute('src')) return
         loadingPlay.value = false
         playing.value = false
+        playError.value = '音频加载失败：网络不可达或链接已失效'
       })
       audioEl = a
     }
     return audioEl
   }
 
+  /** 清空 audio 的源并复位播放态（不影响队列） */
+  function resetAudio() {
+    playing.value = false
+    loadingPlay.value = false
+    position.value = 0
+    duration.value = 0
+    bufferedPercent.value = 0
+    if (audioEl) {
+      audioEl.pause()
+      audioEl.removeAttribute('src')
+      audioEl.load()
+    }
+  }
+
+  /** 由 UI 消费播放错误（toast）后调用 */
+  function clearPlayError() {
+    playError.value = ''
+  }
+
   // ===== 初始化 & 连接 =====
+  let inited = false
   async function init() {
+    // 幂等：多个视图挂载时重复调用不应重置队列 / 重复发起请求
+    if (inited) return
+    inited = true
     try {
       const r = await invoke<{ activeId: string; list: FeiniuConnection[] }>('feiniu_list_connections')
       connections.value = r?.list || []
@@ -139,73 +268,105 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     }
     loadPlaylists()
     restoreQueue()
+    // 本地偏好
+    const v = Number(readLS(VOL_KEY))
+    if (isFinite(v) && v >= 0 && v <= 1) volume.value = v
+    muted.value = readLS(MUTE_KEY) === '1'
+    const pm = readLS(MODE_KEY)
+    if (pm === 'loopAll' || pm === 'loopOne' || pm === 'shuffle') playMode.value = pm
+    const cm = readLS(CACHE_MODE_KEY)
+    if (cm === 'cache' || cm === 'stream') cacheMode.value = cm
+    // WebDAV：url/dir 明文存 localStorage；账号/密码存系统凭据管理器。
+    // 旧版本曾把账号/密码明文写进 localStorage，此处自动迁移到凭据管理器并清除明文。
+    let legacyCreds: { username: string; password: string } | null = null
     try {
-      volume.value = Number(localStorage.getItem(VOL_KEY)) || 0.8
-      const cm = localStorage.getItem('thing.music.cachemode')
-      if (cm === 'cache' || cm === 'stream') cacheMode.value = cm
+      const raw = readLS(WEBDAV_KEY)
+      if (raw) {
+        const parsed = JSON.parse(raw) as Partial<WebDavConfig & { dir: string }>
+        webdav.value = {
+          url: parsed.url || '',
+          username: parsed.username || '',
+          password: parsed.password || '',
+          dir: parsed.dir || ''
+        }
+        if (parsed.username || parsed.password) {
+          legacyCreds = { username: parsed.username || '', password: parsed.password || '' }
+          // 立即改写为不含凭据的版本
+          writeLS(WEBDAV_KEY, JSON.stringify({ url: webdav.value.url, dir: webdav.value.dir }))
+        }
+      }
     } catch {
-      /* ignore */
+      /* 损坏的配置按空处理 */
     }
+    let hasStoredSecret = false
+    try {
+      const s = await invoke<{ username: string | null; password: string | null }>('webdav_get_secret')
+      if (s?.username != null || s?.password != null) {
+        hasStoredSecret = true
+        if (s.username != null) webdav.value.username = s.username
+        if (s.password != null) webdav.value.password = s.password
+      }
+    } catch (e) {
+      logger.error(`读取 WebDAV 凭据失败: ${e}`)
+    }
+    // 旧明文凭据迁移进系统凭据管理器（凭据库里还没有时才写入）
+    if (!hasStoredSecret && legacyCreds && (legacyCreds.username || legacyCreds.password)) {
+      webdav.value.username = legacyCreds.username
+      webdav.value.password = legacyCreds.password
+      invoke('webdav_save_secret', { username: legacyCreds.username, password: legacyCreds.password }).catch(
+        (e) => logger.error(`迁移 WebDAV 凭据失败: ${e}`)
+      )
+    }
+    autoUpload.value = readLS(AUTO_UPLOAD_KEY) === '1'
+    const a = ensureAudio()
+    a.volume = volume.value
+    a.muted = muted.value
     await ensureCacheStatus()
-    try {
-      libraryNasPath.value = localStorage.getItem('thing.music.feiniu.naspath') || ''
-      autoUpload.value = localStorage.getItem('thing.music.feiniu.autoupload') === '1'
-    } catch {
-      /* ignore */
-    }
-    await refreshFnosStatus()
   }
 
-  async function refreshFnosStatus() {
-    if (!activeId.value) {
-      fnosLoggedIn.value = false
-      return
-    }
-    try {
-      const r = await invoke<{ loggedIn: boolean }>('feiniu_fnos_status', { connectionId: activeId.value })
-      fnosLoggedIn.value = !!r?.loggedIn
-    } catch {
-      fnosLoggedIn.value = false
-    }
-  }
-
-  async function fnosLogin(username: string, password: string) {
-    if (!activeId.value) throw new Error('请先激活一个连接')
-    await invoke('feiniu_fnos_login', { connectionId: activeId.value, username, password })
-    fnosLoggedIn.value = true
-  }
-
-  function fnosLogout() {
-    if (activeId.value) invoke('feiniu_fnos_logout', { connectionId: activeId.value }).catch(() => {})
-    fnosLoggedIn.value = false
-  }
-
-  function setLibraryNasPath(v: string) {
-    libraryNasPath.value = v
-    try {
-      localStorage.setItem('thing.music.feiniu.naspath', v)
-    } catch {
-      /* ignore */
+  /**
+   * 保存 WebDAV 配置（部分字段）。
+   * url/dir 明文持久化到 localStorage；账号/密码写入系统凭据管理器（Rust 侧加密存储），
+   * 绝不落明文。
+   */
+  function patchWebdav(patch: Partial<WebDavConfig & { dir: string }>) {
+    const touchesSecret = 'username' in patch || 'password' in patch
+    webdav.value = { ...webdav.value, ...patch }
+    writeLS(WEBDAV_KEY, JSON.stringify({ url: webdav.value.url, dir: webdav.value.dir }))
+    if (touchesSecret) {
+      invoke('webdav_save_secret', {
+        username: webdav.value.username,
+        password: webdav.value.password
+      }).catch((e) => logger.error(`保存 WebDAV 凭据失败: ${e}`))
     }
   }
 
   function setAutoUpload(v: boolean) {
     autoUpload.value = v
-    try {
-      localStorage.setItem('thing.music.feiniu.autoupload', v ? '1' : '0')
-    } catch {
-      /* ignore */
-    }
+    writeLS(AUTO_UPLOAD_KEY, v ? '1' : '0')
   }
 
-  /** 上传单个本地文件到飞牛曲库目录（激活连接）。 */
+  function davConfig() {
+    return { url: webdav.value.url.trim(), username: webdav.value.username, password: webdav.value.password }
+  }
+
+  /** 测试 WebDAV 连接与目标目录可达性，成功返回确认信息 */
+  async function testWebdav(): Promise<string> {
+    const r = await invoke<{ ok: boolean; message: string }>('webdav_test', {
+      config: davConfig(),
+      dir: webdav.value.dir.trim()
+    })
+    return r?.message || '连接成功'
+  }
+
+  /** 上传单个本地文件到飞牛曲库目录（WebDAV）。 */
   async function uploadToFeiniu(localPath: string, fileName: string): Promise<void> {
-    if (!fnosLoggedIn.value) throw new Error('请先登录 NAS 文件服务')
-    const base = libraryNasPath.value.replace(/[\\/]+$/, '')
-    const nasPath = base ? `${base}/${fileName}` : fileName
+    if (!webdavReady.value) throw new Error('请先在「设置 → 存储与上传」完成 WebDAV 配置')
+    const dir = webdav.value.dir.replace(/[\\/]+$/, '')
+    const remotePath = dir ? `${dir}/${fileName}` : fileName
     uploading.value = true
     try {
-      await invoke('feiniu_fnos_upload', { localPath, nasPath })
+      await invoke('webdav_upload', { config: davConfig(), localPath, remotePath })
     } finally {
       uploading.value = false
     }
@@ -218,14 +379,24 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     await uploadToFeiniu(item.guid, name)
   }
 
-  /** 把最近 N 分钟内新出现的本地音频批量上传到飞牛曲库。返回 { total, ok }。 */
-  async function uploadRecentToFeiniu(minutes = 10): Promise<{ total: number; ok: number }> {
-    if (!fnosLoggedIn.value) throw new Error('请先连接 NAS 文件服务（设置 → 飞牛连接）')
-    if (!libraryNasPath.value) throw new Error('请先填写飞牛曲库目录（设置 → 上传到飞牛）')
+  /**
+   * 扫描本地下载目录，把最近的音频批量上传到飞牛曲库。返回 { total, ok, deleted }。
+   * - 默认（无 opts）：上传最近 `minutes` 分钟内出现的文件（自动上传路径）。
+   * - `opts.since`：只上传该 Unix 秒之后出现的文件（单曲落地即传用，起点=任务创建时刻）。
+   * - `opts.deleteLocal`：上传成功后删除本地音频文件，并顺带清理同名的歌词/封面副本。
+   */
+  async function uploadRecentToFeiniu(
+    minutes = 10,
+    opts: { since?: number; deleteLocal?: boolean } = {}
+  ): Promise<{ total: number; ok: number; deleted: number }> {
+    if (!webdavReady.value) throw new Error('请先在「设置 → 存储与上传」完成 WebDAV 配置')
     const r = await invoke<{ items: any[] }>('feiniu_scan_local')
     const now = Date.now() / 1000
-    const recent = (r?.items || []).filter((f) => now - (f.mtim || 0) <= minutes * 60)
+    const lower = opts.since ?? 0
+    const upper = opts.since != null ? Infinity : now - minutes * 60
+    const recent = (r?.items || []).filter((f) => (f.mtim || 0) >= lower && (f.mtim || 0) <= upper)
     let ok = 0
+    let deleted = 0
     uploading.value = true
     try {
       for (const f of recent) {
@@ -234,6 +405,9 @@ export const useFeiniuStore = defineStore('feiniu', () => {
         try {
           await uploadToFeiniu(path, name)
           ok++
+          if (opts.deleteLocal) {
+            deleted += await deleteLocalMedia(path)
+          }
         } catch {
           /* 单文件失败继续 */
         }
@@ -241,12 +415,31 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     } finally {
       uploading.value = false
     }
-    return { total: recent.length, ok }
+    return { total: recent.length, ok, deleted }
   }
 
-  /** 删除 NAS 上的文件（激活连接）。 */
-  async function deleteFromFeiniu(nasPath: string): Promise<void> {
-    await invoke('feiniu_fnos_delete', { nasPath })
+  /** 删除本地媒体文件及同名歌词/封面副本。返回实际删除数。 */
+  async function deleteLocalMedia(audioPath: string): Promise<number> {
+    const dot = audioPath.lastIndexOf('.')
+    if (dot <= 0) return 0
+    const base = audioPath.slice(0, dot)
+    let n = 0
+    const targets = [audioPath, ...['lrc', 'jpg', 'jpeg', 'png', 'webp'].map((e) => `${base}.${e}`)]
+    for (const p of targets) {
+      try {
+        await invoke('feiniu_delete_local', { path: p })
+        n++
+      } catch {
+        /* 不存在或不允许删除都忽略 */
+      }
+    }
+    return n
+  }
+
+  /** 删除 NAS 上的文件（WebDAV）。 */
+  async function deleteFromFeiniu(remotePath: string): Promise<void> {
+    if (!webdavReady.value) throw new Error('请先在「设置 → 存储与上传」完成 WebDAV 配置')
+    await invoke('webdav_delete', { config: davConfig(), remotePath })
   }
 
   /** FnConnect：解析 fnId 得到可达 base_url。 */
@@ -263,20 +456,15 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     }
   }
 
+  /** 切换缓存模式：不中断当前播放，下一首按新模式取流 */
   function setCacheMode(mode: 'stream' | 'cache') {
     cacheMode.value = mode
-    try {
-      localStorage.setItem('thing.music.cachemode', mode)
-    } catch {
-      /* ignore */
-    }
-    if (mode === 'stream') clearPlayback()
+    writeLS(CACHE_MODE_KEY, mode)
   }
 
   async function clearCache() {
     await invoke('feiniu_cache_clear')
     await ensureCacheStatus()
-    clearPlayback()
   }
 
   async function refreshConnections() {
@@ -284,7 +472,6 @@ export const useFeiniuStore = defineStore('feiniu', () => {
       const r = await invoke<{ activeId: string; list: FeiniuConnection[] }>('feiniu_list_connections')
       connections.value = r?.list || []
       activeId.value = r?.activeId || ''
-      await refreshFnosStatus()
       const c = await invoke<{ baseUrl: string; username: string; loggedIn: boolean }>('feiniu_get_config')
       config.value = c
     } catch (e) {
@@ -292,7 +479,9 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     }
   }
 
-  async function saveConnection(conn: Partial<FeiniuConnection> & { name: string; baseUrl: string; kind: string }): Promise<string> {
+  async function saveConnection(
+    conn: Partial<FeiniuConnection> & { name: string; baseUrl: string; kind: string }
+  ): Promise<string> {
     const r = await invoke<{ ok: boolean }>('feiniu_save_connection', {
       connection: {
         id: conn.id || '',
@@ -321,7 +510,6 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     await invoke('feiniu_activate_connection', { id })
     await refreshConnections()
     if (config.value.loggedIn) await refreshMediaPrefix()
-    await refreshFnosStatus()
   }
 
   async function login(connectionId: string, username: string, password: string) {
@@ -372,26 +560,41 @@ export const useFeiniuStore = defineStore('feiniu', () => {
   }
 
   // ===== 飞牛曲库 =====
-  async function loadTracks(p: number = 1): Promise<void> {
-    loading.value = true
+  /** 拉取曲库；append=true 时追加到现有列表（滚动加载更多） */
+  async function loadTracks(p: number = 1, append = false): Promise<void> {
+    const first = !append
+    if (first) {
+      loading.value = true
+      tracks.value = []
+    } else {
+      loadingMore.value = true
+    }
     try {
       const data = await invoke<any>('feiniu_list_tracks', {
         page: p,
-        size: 50,
-        keyword: keyword.value.trim() || null
+        size: PAGE_SIZE,
+        keyword: searchKeyword.value.trim() || null
       })
       const list = Array.isArray(data) ? data : data?.list || data?.items || data?.tracks || []
-      tracks.value = (list as any[]).map((t) => normalizeTrack(t))
-      total.value = data?.total ?? data?.count ?? list.length
+      const mapped = (list as any[]).map((t) => normalizeTrack(t))
+      tracks.value = append ? [...tracks.value, ...mapped] : mapped
+      total.value = data?.total ?? data?.count ?? mapped.length
       page.value = p
     } catch (e) {
       logger.error(String(e))
       throw e
     } finally {
       loading.value = false
+      loadingMore.value = false
     }
   }
 
+  /** 加载下一页（列表滚动到底部时调用） */
+  async function loadMoreTracks(): Promise<void> {
+    if (loading.value || loadingMore.value || !hasMoreTracks.value) return
+    await loadTracks(page.value + 1, true)
+  }
+
   function normalizeTrack(t: any): PlayableItem {
     const artists = Array.isArray(t.artists) ? t.artists : []
     const album = typeof t.album === 'string' ? t.album : t.album?.name || t.albumName || ''
@@ -403,7 +606,10 @@ export const useFeiniuStore = defineStore('feiniu', () => {
       coverId: t.coverId || undefined,
       album,
       artistNames:
-        artists.map((a: { name?: string }) => a.name).filter(Boolean).join(' / ') ||
+        artists
+          .map((a: { name?: string }) => a.name)
+          .filter(Boolean)
+          .join(' / ') ||
         t.artist ||
         t.singers ||
         ''
@@ -434,20 +640,17 @@ export const useFeiniuStore = defineStore('feiniu', () => {
 
   // ===== 歌单 =====
   function loadPlaylists() {
+    const raw = readLS(PLAYLISTS_KEY)
+    if (!raw) return
     try {
-      const raw = localStorage.getItem(PLAYERS_KEY)
-      if (!raw) return
-      playlists.value = JSON.parse(raw)
+      const arr = JSON.parse(raw)
+      playlists.value = Array.isArray(arr) ? arr : []
     } catch {
       playlists.value = []
     }
   }
   function persistPlaylists() {
-    try {
-      localStorage.setItem(PLAYERS_KEY, JSON.stringify(playlists.value))
-    } catch {
-      /* ignore */
-    }
+    writeLS(PLAYLISTS_KEY, JSON.stringify(playlists.value))
   }
   function createPlaylist(name: string): string {
     const id = uid()
@@ -470,6 +673,7 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     const p = playlists.value.find((p) => p.id === playlistId)
     if (!p) return
     for (const it of items) {
+      if (it.source === 'preview') continue
       const dup = p.items.some((x) => x.guid === it.guid && x.source === it.source)
       if (!dup) p.items.push({ ...it })
     }
@@ -482,6 +686,14 @@ export const useFeiniuStore = defineStore('feiniu', () => {
       persistPlaylists()
     }
   }
+  /** 批量移除（key 形如 `${source}:${guid}`） */
+  function removeItemsFromPlaylist(playlistId: string, keys: string[]) {
+    const p = playlists.value.find((p) => p.id === playlistId)
+    if (!p) return
+    const set = new Set(keys)
+    p.items = p.items.filter((x) => !set.has(`${x.source}:${x.guid}`))
+    persistPlaylists()
+  }
   function moveInPlaylist(playlistId: string, from: number, to: number) {
     const p = playlists.value.find((p) => p.id === playlistId)
     if (!p || from < 0 || to < 0 || from >= p.items.length || to >= p.items.length) return
@@ -491,41 +703,128 @@ export const useFeiniuStore = defineStore('feiniu', () => {
   }
 
   // ===== 播放器 =====
+  function refillShufflePool() {
+    const n = queue.value.length
+    const pool: number[] = []
+    for (let i = 0; i < n; i++) if (i !== queueIndex.value) pool.push(i)
+    for (let i = pool.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1))
+      const tmp = pool[i]
+      pool[i] = pool[j]
+      pool[j] = tmp
+    }
+    shufflePool.value = pool
+  }
+
+  /** 建立新上下文时清掉试听与随机历史 */
+  function resetPlayState() {
+    preview.value = null
+    shufflePool.value = []
+    historyStack.value = []
+  }
+
   function playQueue(items: PlayableItem[], startIndex = 0) {
+    if (items.length === 0) return
     queue.value = items.map((i) => ({ ...i }))
     queueIndex.value = Math.min(Math.max(startIndex, 0), items.length - 1)
+    resetPlayState()
+    if (playMode.value === 'shuffle') refillShufflePool()
     playCurrent()
   }
 
-  function playItem(item: PlayableItem) {
-    // 若已在队列中，跳转到它；否则作为新队列播放
+  /**
+   * 播放单个条目。
+   * 传入 context（所在列表）时以该列表为播放上下文；未命中则以 context 建立队列。
+   * 不传 context 时退化为「单曲播放」（仅当该曲不在队列中）。
+   */
+  function playItem(item: PlayableItem, context?: PlayableItem[]) {
+    if (context && context.length > 0 && context !== queue.value) {
+      const i = context.findIndex((q) => q.guid === item.guid && q.source === item.source)
+      playQueue(context, i >= 0 ? i : 0)
+      return
+    }
     const i = queue.value.findIndex((q) => q.guid === item.guid && q.source === item.source)
     if (i >= 0) {
       queueIndex.value = i
+      resetPlayState()
       playCurrent()
     } else {
-      queue.value = [{ ...item }]
+      playQueue([item], 0)
+    }
+  }
+
+  /** 插入到当前曲目之后（下一首播放） */
+  function playNext(item: PlayableItem) {
+    if (item.source === 'preview') return
+    const existing = queue.value.findIndex((q) => q.guid === item.guid && q.source === item.source)
+    if (existing >= 0) removeFromQueue(existing)
+    const at = Math.min(queueIndex.value + 1, queue.value.length)
+    queue.value.splice(Math.max(at, 0), 0, { ...item })
+    if (queueIndex.value < 0) {
       queueIndex.value = 0
       playCurrent()
     }
+    persistQueue()
+  }
+
+  /** 追加到队列末尾 */
+  function addToQueue(item: PlayableItem) {
+    if (item.source === 'preview') return
+    if (queue.value.some((q) => q.guid === item.guid && q.source === item.source)) return
+    queue.value.push({ ...item })
+    if (queueIndex.value < 0) {
+      queueIndex.value = 0
+      playCurrent()
+    }
+    persistQueue()
+  }
+
+  function removeFromQueue(index: number) {
+    if (index < 0 || index >= queue.value.length) return
+    const removingCurrent = index === queueIndex.value
+    queue.value.splice(index, 1)
+    if (index < queueIndex.value) queueIndex.value--
+    else if (removingCurrent) {
+      if (queue.value.length === 0) {
+        clearPlayback()
+      } else {
+        queueIndex.value = Math.min(index, queue.value.length - 1)
+        playCurrent()
+      }
+    }
+    shufflePool.value = []
+    persistQueue()
+  }
+
+  /** 清空播放队列并停止播放 */
+  function clearQueue() {
+    clearPlayback()
   }
 
   function playCurrent() {
     const t = current.value
     if (!t) return
-    if (t.source === 'feiniu') loadLyric(t.guid)
-    else lyricLines.value = []
+    preview.value = null
+    if (t.source === 'feiniu') {
+      void loadLyric(t.guid)
+    } else {
+      lyricLines.value = []
+      lyricRaw = ''
+      lyricIdx = -1
+    }
     const a = ensureAudio()
     a.pause()
+    position.value = 0
+    duration.value = 0
+    bufferedPercent.value = 0
     if (t.source === 'feiniu' && cacheMode.value === 'cache') {
-      playCached(t, a)
+      void playCached(t, a)
       return
     }
     a.src =
       t.source === 'feiniu'
         ? `${mediaPrefix.value}/stream?guid=${encodeURIComponent(t.guid || '')}`
         : `file://${(t.guid || '').replace(/\\/g, '/')}`
-    a.currentTime = 0
     startPlayback(a)
   }
 
@@ -533,18 +832,19 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     loadingPlay.value = true
     try {
       const r = await invoke<{ path: string | null }>('feiniu_cache_fetch', { guid: t.guid || '' })
+      // 缓存期间用户可能已切歌：仅在仍是当前曲目时才接管播放
+      if (current.value?.guid !== t.guid) return
       if (r?.path) {
         a.src = `file://${(r.path as string).replace(/\\/g, '/')}`
-        a.currentTime = 0
         startPlayback(a)
         return
       }
     } catch {
       /* fall through to stream */
     }
+    if (current.value?.guid !== t.guid) return
     // 缓存失败（未登录/网络）→ 回退直连流
     a.src = `${mediaPrefix.value}/stream?guid=${encodeURIComponent(t.guid || '')}`
-    a.currentTime = 0
     startPlayback(a)
   }
 
@@ -555,123 +855,206 @@ export const useFeiniuStore = defineStore('feiniu', () => {
         loadingPlay.value = false
         persistQueue()
       })
-      .catch(() => {
+      .catch((e) => {
         loadingPlay.value = false
+        playing.value = false
+        playError.value = describePlayError(e)
         persistQueue()
       })
   }
 
-  function toggle() {
+  /**
+   * 播放「发现音乐」页的试听链接。
+   * 与队列播放共用同一个 audio 实例，因此天然互斥——不会再出现两路声音叠加。
+   */
+  function playPreview(item: PlayableItem) {
+    if (!item.url) return
     const a = ensureAudio()
-    if (a.paused) a.play().catch(() => {})
-    else a.pause()
+    a.pause()
+    preview.value = { ...item, source: 'preview' }
+    lyricLines.value = []
+    lyricRaw = ''
+    lyricIdx = -1
+    position.value = 0
+    duration.value = 0
+    bufferedPercent.value = 0
+    a.src = item.url
+    startPlayback(a)
   }
 
-  function next(manual = true) {
+  /** 关闭试听，回到队列上下文 */
+  function stopPreview() {
+    preview.value = null
+    resetAudio()
+  }
+
+  function toggle() {
+    const a = ensureAudio()
+    // 队列恢复后首次播放：audio 还没有 src，先按当前条目装载
+    if (!a.getAttribute('src')) {
+      if (preview.value?.url) {
+        a.src = preview.value.url
+        startPlayback(a)
+      } else if (current.value) {
+        playCurrent()
+      }
+      return
+    }
+    if (a.paused) {
+      loadingPlay.value = true
+      a.play().catch((e) => {
+        loadingPlay.value = false
+        playing.value = false
+        playError.value = describePlayError(e)
+      })
+    } else {
+      a.pause()
+    }
+  }
+
+  /** 切下一首（手动 / 自动均使用同一套逻辑：随机模式下自动切歌也会随机） */
+  function next() {
     const n = queue.value.length
     if (n === 0) return
-    if (manual && playMode.value === 'shuffle') {
-      let idx = queueIndex.value
-      while (idx === queueIndex.value && n > 1) idx = Math.floor(Math.random() * n)
-      queueIndex.value = idx
+    preview.value = null
+    if (playMode.value === 'shuffle') {
+      if (shufflePool.value.length === 0) refillShufflePool()
+      if (shufflePool.value.length === 0) return
+      historyStack.value.push(queueIndex.value)
+      queueIndex.value = shufflePool.value.shift() as number
     } else if (queueIndex.value < n - 1) {
+      historyStack.value.push(queueIndex.value)
       queueIndex.value++
-    } else if (playMode.value !== 'loopOne') {
-      queueIndex.value = 0
     } else {
-      // loopOne 且已到末尾：保持当前
+      // loopAll 到末尾回卷；loopOne 手动切歌也回到开头
+      historyStack.value.push(queueIndex.value)
       queueIndex.value = 0
     }
     playCurrent()
   }
 
   function onEnded() {
+    // 试听结束：回到队列上下文，不自动续播
+    if (preview.value) {
+      preview.value = null
+      resetAudio()
+      return
+    }
     if (playMode.value === 'loopOne') {
       const a = ensureAudio()
       a.currentTime = 0
       a.play().catch(() => {})
       return
     }
-    next(false)
+    next()
   }
 
   function prev() {
     const a = ensureAudio()
-    if (a.currentTime > 3) {
+    if (a.getAttribute('src') && a.currentTime > 3) {
       a.currentTime = 0
+      position.value = 0
       return
     }
-    if (queueIndex.value > 0) queueIndex.value--
-    else queueIndex.value = 0
+    if (queue.value.length === 0) return
+    preview.value = null
+    if (playMode.value === 'shuffle' && historyStack.value.length > 0) {
+      queueIndex.value = historyStack.value.pop() as number
+    } else if (queueIndex.value > 0) {
+      queueIndex.value--
+    } else {
+      queueIndex.value = queue.value.length - 1
+    }
     playCurrent()
   }
 
+  /** 跳转到指定秒数（时长未知时不动作，由 UI 提示） */
   function seek(sec: number) {
     const a = ensureAudio()
-    a.currentTime = Math.max(0, sec)
+    if (!a.getAttribute('src')) return
+    const d = a.duration
+    if (!isFinite(d) || d <= 0) {
+      playError.value = '该音频时长未知，暂不支持拖动跳转'
+      return
+    }
+    a.currentTime = Math.min(Math.max(0, sec), d)
     position.value = a.currentTime
   }
 
   function setVolume(v: number) {
-    volume.value = v
+    const nv = Math.min(1, Math.max(0, v))
+    volume.value = nv
+    if (nv > 0) muted.value = false
     const a = ensureAudio()
-    a.volume = v
-    try {
-      localStorage.setItem(VOL_KEY, String(v))
-    } catch {
-      /* ignore */
-    }
+    a.volume = nv
+    a.muted = muted.value
+    writeLS(VOL_KEY, String(nv))
+    writeLS(MUTE_KEY, muted.value ? '1' : '0')
+  }
+
+  function toggleMute() {
+    muted.value = !muted.value
+    const a = ensureAudio()
+    a.muted = muted.value
+    writeLS(MUTE_KEY, muted.value ? '1' : '0')
+  }
+
+  function setPlayMode(mode: PlayMode) {
+    playMode.value = mode
+    writeLS(MODE_KEY, mode)
+    historyStack.value = []
+    shufflePool.value = []
+    if (mode === 'shuffle') refillShufflePool()
   }
 
   function togglePlayMode() {
-    playMode.value = playMode.value === 'loopAll' ? 'loopOne' : playMode.value === 'loopOne' ? 'shuffle' : 'loopAll'
+    setPlayMode(playMode.value === 'loopAll' ? 'loopOne' : playMode.value === 'loopOne' ? 'shuffle' : 'loopAll')
   }
 
   function clearPlayback() {
+    preview.value = null
     queue.value = []
     queueIndex.value = -1
     lyricLines.value = []
-    position.value = 0
-    duration.value = 0
-    playing.value = false
-    if (audioEl) {
-      audioEl.pause()
-      audioEl.removeAttribute('src')
-      audioEl.load()
-    }
+    lyricRaw = ''
+    lyricIdx = -1
+    shufflePool.value = []
+    historyStack.value = []
+    resetAudio()
+    persistQueue()
   }
 
   function restoreQueue() {
+    const raw = readLS(QUEUE_KEY)
+    if (!raw) return
     try {
-      const raw = localStorage.getItem(QUEUE_KEY)
-      if (!raw) return
       const s = JSON.parse(raw)
-      if (!s?.queue || !Array.isArray(s.queue)) return
+      if (!s?.queue || !Array.isArray(s.queue) || s.queue.length === 0) return
       queue.value = s.queue
-      queueIndex.value = typeof s.index === 'number' ? s.index : -1
+      queueIndex.value =
+        typeof s.index === 'number' ? Math.min(Math.max(s.index, 0), s.queue.length - 1) : 0
     } catch {
       /* ignore */
     }
   }
 
   function persistQueue() {
-    try {
-      localStorage.setItem(QUEUE_KEY, JSON.stringify({ queue: queue.value, index: queueIndex.value }))
-    } catch {
-      /* ignore */
-    }
+    writeLS(QUEUE_KEY, JSON.stringify({ queue: queue.value, index: queueIndex.value }))
   }
 
   function fmtDuration(sec?: number): string {
-    if (sec == null || !isFinite(sec)) return '--:--'
+    if (sec == null || !isFinite(sec) || sec < 0) return '--:--'
     const s = Math.floor(sec)
-    const m = Math.floor(s / 60)
+    const h = Math.floor(s / 3600)
+    const m = Math.floor((s % 3600) / 60)
     const r = s % 60
+    if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${String(r).padStart(2, '0')}`
     return `${String(m).padStart(2, '0')}:${String(r).padStart(2, '0')}`
   }
 
   async function loadLyric(guid?: string) {
     lyricLines.value = []
+    lyricIdx = -1
     if (!guid) return
     try {
       const r = await invoke<{ lyric: string }>('feiniu_lyric', { guid })
@@ -707,18 +1090,45 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     return lines
   }
 
+  /**
+   * 当前歌词行索引。
+   * 歌词按时间升序，命中缓存时只做邻近微调；未命中（切歌/拖动）时二分定位。
+   * 避免每次 timeupdate（约 4Hz）都做一次 O(n) 全量扫描。
+   */
   function currentLine(): number {
-    let idx = -1
-    for (let k = 0; k < lyricLines.value.length; k++) {
-      if (lyricLines.value[k].t <= position.value) idx = k
-      else break
+    const lines = lyricLines.value
+    if (lines.length === 0) return -1
+    const pos = position.value
+    if (lyricIdx >= lines.length) lyricIdx = lines.length - 1
+    if (lyricIdx >= 0 && lines[lyricIdx].t <= pos) {
+      while (lyricIdx + 1 < lines.length && lines[lyricIdx + 1].t <= pos) lyricIdx++
+      return lyricIdx
     }
-    return idx
+    if (lyricIdx > 0 && lines[lyricIdx - 1].t > pos) {
+      while (lyricIdx > 0 && lines[lyricIdx - 1].t > pos) lyricIdx--
+      if (lyricIdx >= 0 && lines[lyricIdx].t > pos) lyricIdx--
+      return lyricIdx
+    }
+    let lo = 0
+    let hi = lines.length - 1
+    let found = -1
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1
+      if (lines[mid].t <= pos) {
+        found = mid
+        lo = mid + 1
+      } else {
+        hi = mid - 1
+      }
+    }
+    lyricIdx = found
+    return found
   }
 
   const progress = computed(() => (duration.value > 0 ? (position.value / duration.value) * 100 : 0))
 
   return {
+    // 连接
     connections,
     activeId,
     activeConn,
@@ -727,28 +1137,38 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     connecting,
     cacheMode,
     cacheStatus,
+    // 曲库
     tracks,
     page,
     total,
     loading,
-    keyword,
+    loadingMore,
+    hasMoreTracks,
+    searchKeyword,
     localTracks,
     localScanBusy,
+    // 歌单
     playlists,
+    // 播放
     queue,
     queueIndex,
+    preview,
+    nowPlaying,
     playMode,
     volume,
+    muted,
     current,
     playing,
     loadingPlay,
+    playError,
     position,
     duration,
+    bufferedPercent,
     lyricLines,
-    lyricVisible,
-    queueVisible,
     nowPlayingOpen,
+    nowPlayingTab,
     progress,
+    // 动作
     init,
     refreshConnections,
     saveConnection,
@@ -759,18 +1179,17 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     testConnection,
     refreshMediaPrefix,
     loadTracks,
+    loadMoreTracks,
     scanLocal,
     ensureCacheStatus,
     setCacheMode,
     clearCache,
-    fnosLoggedIn,
-    libraryNasPath,
+    webdav,
+    webdavReady,
     autoUpload,
     uploading,
-    refreshFnosStatus,
-    fnosLogin,
-    fnosLogout,
-    setLibraryNasPath,
+    patchWebdav,
+    testWebdav,
     setAutoUpload,
     uploadToFeiniu,
     uploadLocalTrack,
@@ -782,18 +1201,28 @@ export const useFeiniuStore = defineStore('feiniu', () => {
     deletePlaylist,
     addToPlaylist,
     removeFromPlaylist,
+    removeItemsFromPlaylist,
     moveInPlaylist,
     playQueue,
     playItem,
+    playNext,
+    addToQueue,
+    removeFromQueue,
+    clearQueue,
+    playPreview,
+    stopPreview,
     toggle,
     next,
     prev,
     seek,
     setVolume,
+    toggleMute,
     togglePlayMode,
+    setPlayMode,
     clearPlayback,
     persistQueue,
     fmtDuration,
-    currentLine
+    currentLine,
+    clearPlayError
   }
-})
\ No newline at end of file
+})
diff --git a/src/stores/musicStore.ts b/src/stores/musicStore.ts
index 9ecfddb..122d405 100644
--- a/src/stores/musicStore.ts
+++ b/src/stores/musicStore.ts
@@ -224,10 +224,27 @@ export const useMusicStore = defineStore('music', () => {
   // 任务历史持久化（localStorage，应用重启后保留记录；恢复时不尝试续传）
   const TASKS_KEY = 'thing.music.tasks'
   const MAX_TASKS = 30
+  /** 单次持久化的体积上限：超过则剥离 rawSearch（懒解析字段）后重试，避免撑爆 localStorage 配额 */
+  const MAX_PERSIST_CHARS = 1_500_000
   let persistTimer: ReturnType<typeof setTimeout> | null = null
+
+  /** 剥离仅解析期使用的重字段（只影响「重新下载」对懒解析歌曲的能力） */
+  function stripHeavy(s: MusicSong): MusicSong {
+    const { rawSearch, defaultDownloadHeaders, defaultDownloadCookies, ...rest } = s
+    void rawSearch
+    void defaultDownloadHeaders
+    void defaultDownloadCookies
+    return rest
+  }
+
   function persistTasks() {
+    const base = tasks.value.slice(0, MAX_TASKS)
     try {
-      localStorage.setItem(TASKS_KEY, JSON.stringify(tasks.value.slice(0, MAX_TASKS)))
+      let payload = JSON.stringify(base)
+      if (payload.length > MAX_PERSIST_CHARS) {
+        payload = JSON.stringify(base.map((t) => ({ ...t, songsData: t.songsData.map(stripHeavy) })))
+      }
+      localStorage.setItem(TASKS_KEY, payload)
     } catch {
       // localStorage 不可用/超限时静默降级（仅影响历史记录）
     }
@@ -314,10 +331,11 @@ export const useMusicStore = defineStore('music', () => {
     } else if (type === 'done') {
       const st = task.songs.find((s) => s.key === ev.key)
       if (st) {
+        // 幂等：重复的 done 事件（断点续传/重发）不再累加 doneCount
+        if (st.status !== 'done') task.doneCount++
         st.status = 'done'
         st.downloaded = st.total || st.downloaded
       }
-      task.doneCount++
     } else if (type === 'error') {
       const st = task.songs.find((s) => s.key === ev.key)
       if (st) {
@@ -350,14 +368,15 @@ export const useMusicStore = defineStore('music', () => {
     )
   }
 
-  /** 懒解析：解析单首歌曲的真实下载链接（试听前调用），成功后原地更新
-   *  搜索结果并返回带链接的最新歌曲对象；失败返回 null */
-  async function resolveSong(source: string, index: number): Promise<MusicSong | null> {
+  /** 懒解析：解析单首歌曲的真实下载链接（试听/上传前调用），成功后原地更新
+   *  搜索结果并返回带链接的最新歌曲对象；失败返回 null。
+   *  `quality` 为音质档位 label（"" = 最高），解析时按「≤所选最优档」封顶。 */
+  async function resolveSong(source: string, index: number, quality = ''): Promise<MusicSong | null> {
     const song = results.value[source]?.[index]
     if (!song) return null
     if (song.downloadUrl) return song
     if (!song.rawSearch) return null
-    const v = (await invoke('music_resolve', { song })) as {
+    const v = (await invoke('music_resolve', { song, quality })) as {
       songs: (MusicSong | null)[]
     }
     const resolved = v.songs?.[0]
@@ -369,8 +388,8 @@ export const useMusicStore = defineStore('music', () => {
     return resolved
   }
 
-  /** 启动下载。engine='rust' 时交给下载器模块（任务在其列表中管理），返回跳过的无链接歌曲数；
-   *  否则走 musicdl 桥接，返回 0 */
+  /** 启动下载。engine='rust' 时交给下载器模块（任务在其列表中管理）；
+   *  否则走 musicdl 桥接。返回实际使用的引擎与跳过的无链接歌曲数 */
   async function startDownload(
     songs: MusicSong[],
     opts: {
@@ -383,8 +402,8 @@ export const useMusicStore = defineStore('music', () => {
       /** 目标音质 label（"" 表示最高）；解析下载时按「≤所选最优档」封顶 */
       quality?: string
     }
-  ): Promise<number> {
-    if (songs.length === 0) return 0
+  ): Promise<{ engine: 'musicdl' | 'rust'; skipped: number; taskId?: string }> {
+    if (songs.length === 0) return { engine: 'musicdl', skipped: 0 }
     await ensureDownloadListener()
     const quality = opts.quality ?? ''
 
@@ -426,7 +445,7 @@ export const useMusicStore = defineStore('music', () => {
           throw e
         }
       }
-      return skipped
+      return { engine: 'rust', skipped }
     }
 
     const taskId = crypto.randomUUID()
@@ -468,7 +487,7 @@ export const useMusicStore = defineStore('music', () => {
       task.errorMessage = String(e)
       throw e
     }
-    return 0
+    return { engine: 'musicdl', skipped: 0, taskId }
   }
 
   async function cancelDownload(taskId: string) {
@@ -520,7 +539,8 @@ export const useMusicStore = defineStore('music', () => {
       proxyUrl: proxy,
       engine: s.downloadEngine,
       maxConcurrent: s.maxConcurrent,
-      quality: s.defaultDownloadQuality ?? ''
+      // 沿用原任务的目标音质（"最高" 存为空串），而不是当前默认音质
+      quality: task.quality ?? s.defaultDownloadQuality ?? ''
     })
   }
 
diff --git a/src/style.css b/src/style.css
index 009a895..26c8987 100644
--- a/src/style.css
+++ b/src/style.css
@@ -244,4 +244,41 @@ input, textarea, [contenteditable='true'] {
 @keyframes recordPulse {
   0%, 100% { opacity: 1; }
   50% { opacity: 0.6; }
+}
+
+/* 音乐：正在播放的跳动均衡器指示（列表行与播放队列共用） */
+.music-eq {
+  display: inline-flex;
+  align-items: flex-end;
+  gap: 2px;
+  height: 12px;
+}
+.music-eq > i {
+  display: block;
+  width: 2.5px;
+  border-radius: 1px;
+  background: var(--primary);
+  animation: musicEqBounce 0.9s ease-in-out infinite;
+}
+.music-eq > i:nth-child(1) {
+  height: 6px;
+  animation-delay: -0.2s;
+}
+.music-eq > i:nth-child(2) {
+  height: 12px;
+  animation-delay: -0.5s;
+}
+.music-eq > i:nth-child(3) {
+  height: 8px;
+  animation-delay: -0.35s;
+}
+.music-eq.is-paused > i {
+  animation-play-state: paused;
+}
+@keyframes musicEqBounce {
+  0%, 100% { transform: scaleY(0.45); }
+  50% { transform: scaleY(1); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .music-eq > i { animation: none; }
 }
\ No newline at end of file