chore(merge): 合并用户系统协议与播放改动

test(media): 按物理删除校验重转码清理
docs(api): 同步搜索协议播放与收藏契约
2026-10-23 12:34:26 +08:00 · 2026-10-23 12:34:13 +08:00 · 2026-10-23 12:34:13 +08:00 · 2026-10-23 12:34:13 +08:00 · 2026-10-23 12:34:13 +08:00 · 2026-10-23 12:34:13 +08:00
94 changed files with 3950 additions and 143 deletions
@@ -170,7 +170,7 @@ app.register.max-per-device-per-day
 | GET | `/app/feed?types=ANIME,LIVE&categoryId=7&cursor=&size=20` | 推荐流；支持内容类型与分类叠加过滤，游标翻页 |
 | GET | `/app/categories` | 分类列表 |
 | GET | `/app/dramas/{id}` | 详情（含剧集列表，免费集带**已签名**播放地址） |
-| GET | `/app/search?keyword=&pageIndex=&pageSize=` | 搜索已上线短剧：按标题/简介模糊匹配，分页返回卡片列表 |
+| GET | `/app/search?keyword=&pageIndex=&pageSize=` | **匿名**。搜索已上线短剧：按标题/简介模糊匹配，分页返回卡片列表 |

 > 卡片（`AppDramaCardVO`）统一新增 `language` 字段（取值如 `zh-CN` / `id`），
 > 首页、发现页、分类、收藏、搜索等所有下发卡片的场景都带该字段，客户端可据此做语言筛选。
@@ -264,7 +264,11 @@ app.register.max-per-device-per-day
    "accessible": true,
    "accessType": "FREE",
    "playUrl": "/files/episode/202610/xxx.mp4?e=1760000000&s=9f2c...",
-    "qualities": ["AUTO"],
+    "qualities": ["AUTO", "720p", "1080p"],
+    "tracks": [
+      {"quality": "AUTO", "playUrl": "/files/transcoded/88/master.m3u8?e=1760000000&s=9f2c..."},
+      {"quality": "720p", "playUrl": "/files/transcoded/88/720p/index.m3u8?e=1760000000&s=a1b2..."}
+    ],
    "thumbnailsUrl": "/files/transcoded/88/thumbnails/thumbnails.vtt?e=1760000000&s=8a1d...",
    "unlockCoin": 0,
    "previewSeconds": 0,
@@ -296,6 +300,7 @@ app.register.max-per-device-per-day
 | POST | `/app/favorites/toggle` | 收藏/取消收藏，返回切换后状态 |
 | GET | `/app/favorites` | 收藏分页；`pageIndex` 默认 1，`pageSize` 默认 20、上限 100 |
 | DELETE | `/app/favorites/{dramaId}` | 取消收藏 |
+| POST | `/app/favorites/remove` | 批量取消收藏，请求体 `{ "dramaIds": ["12", "15"] }` |

 进度合并规则：同一集内只前进不后退；换集直接采纳新集；`finished` 只在接近片尾或客户端显式上报时置位。
 这样用户换设备不会看到进度倒退。
@@ -354,6 +359,7 @@ app.register.max-per-device-per-day
      "dramaCover": "/files/drama_cover/12.jpg",
      "episodeNumber": 6,
      "totalEpisodes": 68,
+      "viewCount": "1800",
      "positionMs": "80000",
      "durationMs": "120000",
      "finished": false,
@@ -375,6 +381,7 @@ app.register.max-per-device-per-day
 | `dramaCover` | string / null | 短剧封面 |
 | `episodeNumber` | int / null | 当前续看集号 `ep_no` |
 | `totalEpisodes` | int / null | 短剧总集数 |
+| `viewCount` | Long（JSON 字符串）/ null | 短剧热度，取 `drama.view_count`。`playCount` 是用户自己的播放次数 |

 ### 1.6 离线下载（已实现）

@@ -543,6 +550,17 @@ GET /app/notices?pageIndex=1&pageSize=20
 `expire_at` 为空或未过期的公告；按 `publish_at desc, id desc` 排序。
 **表里没有数据时返回 `total=0, list=[]`（HTTP 与 code 都是成功），不是 404。**

+#### 1.9.2a 协议公开页（匿名 HTML）
+
+客户端按当前界面语言打开，不走 `{code,message,data}` 包装。正文在后台「协议设置」用 Markdown 维护，页面不另加标题。
+
+| 方法 | 路径 | 说明 |
+| --- | --- | --- |
+| GET | `/privacy/{lang}` | 隐私协议。`lang` 为 `zh` / `en` / `id` |
+| GET | `/terms/{lang}` | 服务条款。语言同上 |
+
+响应 `Content-Type: text/html;charset=UTF-8`。语言或路径不在上表时 HTTP 404。库里还没有该语言时返回内置缺省文案，不返回空页。
+
 #### 1.9.3 `POST /app/creator/apply`（登录）

 ```json
@@ -604,6 +622,8 @@ GET /app/notices?pageIndex=1&pageSize=20
 | 角色分类 | PUT · DELETE | `/admin/role-categories/{id}` | `system:role-category` |
 | 系统配置 | GET | `/admin/configs` | `system:role` / `system:menu` |
 | 系统配置 | PUT | `/admin/configs` | `system:role` |
+| 协议 | GET | `/admin/legal-documents` | `system:role` / `system:menu` |
+| 协议 | PUT | `/admin/legal-documents` | `system:role` |
 | 操作日志 | GET | `/admin/operation-logs/page` · `/{id}` | `log:list` |
 | 字典 | GET | `/admin/dicts/drama-category` · `/content-status` | `drama:list` |

@@ -1074,6 +1094,194 @@ GET /app/notices?pageIndex=1&pageSize=20
 **筛选与错误码**：`title` 必填（1–128）；`content` 最长 2000；公告不存在 → `200002 公告不存在`；
 `status` 只接受 0/1，其他值 → `400`。

+### 2.13 运营分类管理（已实现）
+
+> 「分类」是运营自定义的分组，与短剧**类型**（`/admin/drama-categories`，写 `drama_category`）是两套独立概念。
+> 分类存在 `drama_classification`，通过 `drama_classification_drama` 关联任意多部短剧。
+> 后台页面：菜单 **分类管理**（`/content/category-dramas` → `CategoryDramaView.vue`）。
+
+**接口清单**（前缀 `/admin/drama-classifications`）
+
+| 方法 | 路径 | 权限点 | 说明 |
+| --- | --- | --- | --- |
+| GET | `/admin/drama-classifications` | `drama:list` | 分类列表（带关联短剧数量） |
+| POST | `/admin/drama-classifications` | `drama:create` | 新建分类，返回新分类 id |
+| PUT | `/admin/drama-classifications/{id}` | `drama:update` | 编辑分类 |
+| DELETE | `/admin/drama-classifications/{id}` | `drama:delete` | 删除分类（级联删关联，短剧本身保留） |
+| GET | `/admin/drama-classifications/{id}/dramas` | `drama:list` | 分类下已关联的短剧（分页） |
+| GET | `/admin/drama-classifications/{id}/dramas/candidates` | `drama:list` | 尚未关联到该分类的短剧（分页，供多选） |
+| POST | `/admin/drama-classifications/{id}/dramas` | `drama:update` | 批量关联短剧，返回实际新增数量 |
+| DELETE | `/admin/drama-classifications/{id}/dramas/{dramaId}` | `drama:update` | 从分类移出短剧（幂等） |
+
+**列表响应**
+
+```json
+{
+  "code": 0,
+  "message": "ok",
+  "data": [
+    {
+      "id": "2112807182243336193",
+      "name": "本周必看",
+      "sort": 1,
+      "status": 1,
+      "dramaCount": 12,
+      "updatedAt": "2026-10-22T19:41:02"
+    }
+  ]
+}
+```
+
+排序规则固定为 `sort asc, id desc`；`dramaCount` 是关联表按分类聚合的实时数量。
+时间字段为 `LocalDateTime` 的 ISO 字符串（`yyyy-MM-ddTHH:mm:ss`，秒级），前端按需替换 `T` 为空格。
+
+**新建 / 编辑请求体**
+
+```json
+{ "name": "本周必看", "sort": 1, "status": 1 }
+```
+
+| 字段 | 必填 | 说明 |
+| --- | --- | --- |
+| `name` | 是 | 去首尾空格后保存，全局唯一；`@NotBlank` 提示「请填写分类名称」 |
+| `sort` | 否 | 新建不传时取 `现有条数 + 1`；编辑不传（null）时保持原值 |
+| `status` | 否 | `1` 启用 / `0` 停用；新建默认 `1`，编辑不传保持原值 |
+
+**关联短剧**
+
+```json
+POST /admin/drama-classifications/2112807182243336193/dramas
+{ "dramaIds": ["2112807182243336194", "2112807182243336195"] }
+```
+
+返回 `data` 为实际新增条数（整数）。已关联的、以及不存在的 `dramaId` 会被静默跳过，不报错；
+全部跳过时返回 `0`。`dramaIds` 为空数组 → `400 请选择短剧`。
+
+**短剧列表项（`GET /{id}/dramas` 与 `/dramas/candidates` 共用）**
+
+```json
+{
+  "total": 12,
+  "list": [
+    {
+      "id": "2112807182243336194",
+      "title": "闪婚后首富老公竟是我老板",
+      "cover": "https://.../cover.jpg",
+      "status": "published",
+      "totalEpisodes": 80,
+      "sort": 100,
+      "updatedAt": "2026-10-22T18:00:00"
+    }
+  ]
+}
+```
+
+- 查询参数：`keyword`（按 `title` 模糊匹配，可空）、`pageIndex`（默认 1）、`pageSize`（默认 10，上限 100）
+- 排序：`sort desc, id desc`
+- `status` 取值：`draft` 草稿 / `reviewing` 审核中 / `approved` 待发布 / `published` 已上线 / `offline` 已下线
+- `cover` 取自短剧 `cover_url`
+
+**错误码**
+
+| 场景 | 返回 |
+| --- | --- |
+| 分类名称重复（新建或改名撞已有） | `200001 分类名称已存在` |
+| 分类 id 不存在（编辑/删除/查询/关联/移出） | `200002 分类不存在` |
+| `name` 为空 | `400 请填写分类名称` |
+| `dramaIds` 为空 | `400 请选择短剧` |
+
+> 所有写操作带 `@OperationLog(module = "内容管理")` 操作日志。ID 下发口径见 **§0**。
+
+### 2.14 剧单管理（已实现）
+
+> 剧单使用**自己的一套分类**（`drama_playlist_category`），与「分类管理」和「类型」都没有关系。
+> **没有「剧单」这一层实体**：分类直接挂短剧，关联表 `drama_playlist_category_drama(category_id, drama_id)`。
+> 后台页面：菜单 **剧单管理**（`/content/drama-playlists` → `DramaPlaylistView.vue`）。
+
+**接口清单**（前缀 `/admin/drama-playlist-categories`）
+
+| 方法 | 路径 | 权限点 | 说明 |
+| --- | --- | --- | --- |
+| GET | `/admin/drama-playlist-categories` | `drama:list` | 剧单分类列表（带短剧数量） |
+| POST | `/admin/drama-playlist-categories` | `drama:create` | 新建剧单分类，返回新分类 id |
+| PUT | `/admin/drama-playlist-categories/{id}` | `drama:update` | 编辑剧单分类 |
+| DELETE | `/admin/drama-playlist-categories/{id}` | `drama:delete` | 删除剧单分类（级联删关联，短剧本身保留） |
+| GET | `/admin/drama-playlist-categories/{id}/dramas` | `drama:list` | 分类下已关联的短剧（分页） |
+| GET | `/admin/drama-playlist-categories/{id}/dramas/candidates` | `drama:list` | 尚未关联到该分类的短剧（分页，供多选） |
+| POST | `/admin/drama-playlist-categories/{id}/dramas` | `drama:update` | 批量把短剧加入分类，返回实际新增数量 |
+| DELETE | `/admin/drama-playlist-categories/{id}/dramas/{dramaId}` | `drama:update` | 从分类移出短剧（幂等） |
+
+**列表响应**
+
+```json
+{
+  "code": 0,
+  "message": "ok",
+  "data": [
+    {
+      "id": "2112807182243336196",
+      "name": "高甜先婚后爱",
+      "description": "站内投放位使用，按周更新",
+      "sort": 1,
+      "status": 1,
+      "dramaCount": 8
+    }
+  ]
+}
+```
+
+排序规则 `sort asc, id desc`；`dramaCount` 为该分类下已关联短剧数量。
+
+**新建 / 编辑请求体**
+
+```json
+{
+  "name": "高甜先婚后爱",
+  "description": "站内投放位使用，按周更新",
+  "sort": 1,
+  "status": 1
+}
+```
+
+| 字段 | 必填 | 说明 |
+| --- | --- | --- |
+| `name` | 是 | 去首尾空格后保存，全局唯一；`@NotBlank` 提示「请填写剧单分类名称」 |
+| `description` | 否 | 最长 255 字符（超长 → `400 描述最多 255 个字符`）；新建不传存空串，编辑不传保持原值 |
+| `sort` | 否 | 新建不传取 `现有条数 + 1`；编辑不传保持原值 |
+| `status` | 否 | `1` 启用 / `0` 停用；新建默认 `1` |
+
+**关联短剧**
+
+```json
+POST /admin/drama-playlist-categories/2112807182243336196/dramas
+{ "dramaIds": ["2112807182243336194"] }
+```
+
+返回实际新增条数；已关联或不存在的短剧自动跳过；`dramaIds` 为空 → `400 请选择短剧`。
+`GET /{id}/dramas` 与 `GET /{id}/dramas/candidates` 的查询参数和响应结构与 **§2.13** 完全一致
+（`keyword` / `pageIndex` / `pageSize`，响应 `{ total, list }`，列表项含
+`id` / `title` / `cover` / `status` / `totalEpisodes` / `sort` / `updatedAt`）。
+
+**错误码**
+
+| 场景 | 返回 |
+| --- | --- |
+| 剧单分类名称重复 | `200001 剧单分类名称已存在` |
+| 剧单分类 id 不存在 | `200002 剧单分类不存在` |
+| `name` 为空 | `400 请填写剧单分类名称` |
+| `description` 超过 255 | `400 描述最多 255 个字符` |
+| `dramaIds` 为空 | `400 请选择短剧` |
+
+**与「分类管理」的差异**
+
+| 项 | 运营分类（2.13） | 剧单分类（2.14） |
+| --- | --- | --- |
+| 数据表 | `drama_classification` + `drama_classification_drama` | `drama_playlist_category` + `drama_playlist_category_drama` |
+| 描述字段 | 无 | 有（`description`，≤255） |
+| 列表返回 | 含 `updatedAt` | 含 `description`，不含 `updatedAt` |
+| 菜单 | 分类管理（`/content/category-dramas`） | 剧单管理（`/content/drama-playlists`） |
+| 用途 | 内容侧分组 | 运营侧投放/剧单位分组 |
+
 ## 3. 契约与实现状态对照

 > 最后更新：2026-10-16（`develop` 分支）。未完成项汇总见仓库根 `README.md`「尚未完成」。
@@ -0,0 +1,24 @@
+# 转码任务认领与媒资 ID 校验
+
+## 现场结论
+
+- `media_asset.id=21` 确实存在，source_url 对应分集 id=13。
+- 分集 13 的 video_asset_id=0，旧手动触发只拿媒资，不知道分集绑定，
+  因而创建了 media_asset_id=21、episode_id=0 的 QUEUED 任务。
+- claim 只筛选 episode_id>0，因此该任务永久跳过且没有原因日志。
+
+## 修复
+
+1. POST /admin/media/{id}/transcode 严格只按 media_asset.id 查询；
+   不再把候选 id 当分集 id 兜底或补登记。
+2. 媒资存在时按 source_url 反查分集；找到后绑定 drama_id/episode_id。
+3. 找不到分集时拒绝建任务，避免生成永远无法认领的 episode_id=0 记录。
+4. claim 增加 media_asset_id/source_url 条件，并记录被跳过任务 id 与原因。
+5. RUNNING 无更新阈值收敛到 5 分钟，覆盖 worker 重启后的孤儿任务。
+6. 一次性 patch 将 media_asset_id 不存在且 episode_id=0 的 QUEUED/RUNNING 标记 FAILED。
+
+## 验证
+
+- 非法 media id 拒绝、未绑定分集拒绝、合法 URL 自动绑定。
+- claim 跳过原因、进度更新、僵尸任务恢复。
+- `mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test`。
@@ -0,0 +1,28 @@
+# 转码媒资 ID 精度与存量兜底修复
+
+## 取证
+
+- 示例分集 `2113150431755636737` 的 `video_asset_id` 为
+  `2113150398670966786`，与 `media_asset.id` 完全一致。
+- JS `Number('2113150398670966786')` 序列化为 `2113150398670966800`，
+  超出安全整数后发生精度丢失，导致手动转码查询了错误 ID。
+
+## 修复
+
+1. 聚合响应的 episodeId/mediaAssetId/taskId 使用字符串。
+2. 手动转码仍由后端 Long 接收精确路径 ID。
+3. 媒资不存在时通过 content 模块的端口按候选 ID 查找分集：
+   - 分集 id；
+   - video_asset_id；
+   - transcode_task.id。
+4. 找到分集后按 video_url/source_url/objectKey 反查媒资；
+   文件存在但媒资缺失时补登记并回填分集 video_asset_id。
+5. 无可用视频时保持明确空态/错误语义。
+
+## 验证
+
+- 超 2^53 ID 字符串契约。
+- 聚合无媒资空态。
+- video_url 反查命中。
+- 文件存在时补登记。
+- `mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test`。
@@ -0,0 +1,27 @@
+# 转码保持原始宽高比
+
+## 目标
+
+- 横屏源按档位短边作为高度，竖屏源按档位短边作为宽度。
+- 源短边小于档位短边时按源短边输出，不放大。
+- 输出宽高均为偶数，SAR 固定为 1。
+- rendition 的 width/height 使用 ffprobe 探测到的实际值。
+
+## 实施
+
+1. ffprobe 读取源显示方向尺寸，旋转 90/270 度时交换宽高。
+2. `effectiveShort = min(sourceShort, rungShort)` 并向下取偶数。
+3. 横屏使用 `scale=-2:<effectiveShort>:flags=lanczos,setsar=1`；
+   竖屏使用 `scale=<effectiveShort>:-2:flags=lanczos,setsar=1`。
+4. 转码完成后 ffprobe variant playlist，写入实际输出尺寸。
+5. master playlist 的 RESOLUTION 同步使用实际尺寸。
+
+## 不放大策略
+
+选用“用源尺寸输出”：高于源短边的档位仍保留原 quality 标识和码率，
+但分辨率封顶到源短边，避免所有档位都被跳过导致无产物。
+
+## 验证
+
+- 先补横屏、竖屏、小源码片、偶数、SAR=1 与实际尺寸回写测试。
+- 门禁：`mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test`。
@@ -0,0 +1,29 @@
+# 转码错误截断与进度上报
+
+## 问题
+
+- ffmpeg 错误输出超过 `error_msg varchar(500)`，失败回写 UPDATE 再次失败，
+  任务停在 RUNNING/0。
+- worker 未解析 ffmpeg progress，前端只能看到 0。
+- 缺少 RUNNING 超时收口。
+
+## 修复
+
+1. SQL patch 将 transcode_task/media_thumbnail 的 error_msg 改为 TEXT，可重复执行。
+2. 新增统一错误消息截断，最多保留 500 字符并附总长度；即使补丁尚未执行，
+   也不会超过旧 varchar(500) 限制。
+3. ffmpeg 使用 `-progress` 临时文件，worker 节流为约 1 秒写 transcode_task.progress。
+4. rendition 阶段映射 0-90%，封面/缩略图 90-99%，成功后 100。
+5. 失败保留最后进度；RUNNING 超过 10 分钟无 updated_at 变化标记 FAILED。
+6. 手动重转复用最新任务，SUCCESS/FAILED/CANCELED 原地重置为 QUEUED、progress=0。
+7. 成功写 rendition 前替换同媒资旧产物，避免重复重转唯一键冲突。
+
+## 风险
+
+- 进度写入只允许 RUNNING 状态，避免覆盖已完成/失败状态。
+- 历史僵尸任务由 worker 下一轮自动收口，无需手工 SQL。
+
+## 验证
+
+- 错误截断、进度更新、僵尸重置、重复触发幂等测试。
+- `mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test`。
@@ -0,0 +1,24 @@
+# 转码 rendition 幂等与失败落库
+
+## 根因
+
+- 成功事务只按 media_asset_id 删除旧 rendition。
+- 同一分集替换视频后 media_asset_id 改变、episode_id 不变，
+  旧行未被删除，触发 uk_rendition(episode_id, quality, format)。
+- rendition 插入异常后任务未被可靠置为 FAILED。
+
+## 修复
+
+1. 成功事务删除条件分组为：
+   `media_asset_id = 本次媒体 OR (episode_id > 0 AND episode_id = 本次分集)`。
+2. 缩略图登记按 episode_id 删除旧行后重新插入。
+3. 主流程异常调用 failFinal，直接写 FAILED、错误、finished_at，保留 progress。
+4. failFinal 自身异常在 worker 中 catch 并打印 ERROR，不静默。
+5. error 截断同时保留头部与尾部，长度仍 <= 500。
+
+## 验证
+
+- 不同 media_asset_id、同 episode_id 的重复转码清理条件。
+- thumbnail 旧行替换。
+- 失败落库字段与尾段错误保留。
+- `mvn -q -DskipTests=false test -pl ... -am`。
@@ -25390,3 +25390,514 @@ $ mvn test
 解读：admin 51、app 109、worker 32 个测试均通过，P1 入队/重转与 worker
 链路未回归。

+## 2026-10-22 转码保持原始宽高比
+
+- 分支：`feature/transcode-preserve-aspect`
+- 基线：`develop` / `origin/develop` = `40a884c`
+- 隔离工作树：`/private/tmp/fruitserver-preserve-aspect`
+- 计划：`docs/plans/2026-10-22-transcode-preserve-aspect.md`
+
+按 TDD 先扩展真实 ffmpeg smoke，覆盖横屏、竖屏、源码短边小于档位、
+输出偶数尺寸、SAR=1、ffprobe 实际尺寸与 master RESOLUTION。
+生产代码暂不修改，下一步记录红测输出。
+
+### TDD 红测
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=FfmpegTranscodeRunnerSmokeTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[ERROR] should_keep_portrait_orientation_and_even_dimensions:
+expected: 202
+ but was: 640
+[ERROR] should_not_upscale_when_source_short_edge_is_below_rung:
+expected: "1:1"
+ but was: "1280:1281"
+[ERROR] Tests run: 4, Failures: 2, Errors: 0, Skipped: 0
+[INFO] BUILD FAILURE
+```
+
+解读：竖屏实际输出为 202x360，却把名义 640x360 回写到 rendition；
+小源码片仍被放大，且未固定 SAR。横屏基础尺寸用例已通过，说明测试片生成、
+ffprobe 探测与 HLS 链路本身正常。
+
+### 实现
+
+- ffprobe 读取源视频 width/height；存在 90/270 度旋转元数据时按最终显示方向交换宽高。
+- 每档短边值取 `min(档位 width/height, 源显示短边)`，再向下取偶数。
+- 横屏使用 `scale=-2:<short>:flags=lanczos,setsar=1`；
+  竖屏使用 `scale=<short>:-2:flags=lanczos,setsar=1`，只等比缩放。
+- 不放大策略统一为“高于源短边的档位仍保留 quality 与码率，分辨率封顶到源短边”，
+  因而不会出现全部档位被跳过、无 rendition 可播的情况。
+- 每档完成后 ffprobe 读取 variant HLS 的实际 width/height，写入
+  `ProducedRendition`，worker 继续原样回写 `media_rendition`；
+  master playlist 的 RESOLUTION 也使用实际尺寸。
+
+### 定向测试
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=FfmpegTranscodeRunnerSmokeTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+解读：横屏、竖屏、不放大、偶数尺寸、SAR=1、ffprobe 实际尺寸与
+master RESOLUTION 均通过真实 ffmpeg 验证。
+
+### 最终门禁
+
+```text
+$ mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test
+[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 35, Failures: 0, Errors: 0, Skipped: 0
+[INFO] fruitshorts-module-media ........................... SUCCESS
+[INFO] fruitshorts-transcode-worker ....................... SUCCESS
+[INFO] BUILD SUCCESS
+```
+
+解读：P2 查询测试、worker 入队/失败回写测试和新增宽高比 smoke 全部通过。
+未启停服务、未执行数据库变更、未改前端/App/specs 或 P2 接口字段。
+
+## 2026-10-22 转码媒资 ID 精度与存量兜底
+
+- 分支：`feature/transcode-media-id-fix`
+- 基线：`develop` / `origin/develop` = `a35b02d`
+
+### 现场取证
+
+数据库只读查询确认：
+
+```text
+drama_episode.id             = 2113150431755636737
+drama_episode.video_asset_id = 2113150398670966786
+media_asset.id               = 2113150398670966786
+transcode_task.media_asset_id= 2113150398670966786
+```
+
+JS 精度复现：
+
+```text
+raw:              2113150398670966786
+Number(raw):      2113150398670966800
+serialized:       2113150398670966800
+same:             false
+```
+
+解读：错误来自前端 Number 转换后的 Snowflake ID 精度丢失；后端兜底仍需覆盖
+存量分集 video_asset_id 为空或误传分集/任务 ID 的情况。
+
+### TDD 红测
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=MediaServiceTranscodePipelineTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[ERROR] 找不到符号: 类 EpisodeVideoSourcePort
+[INFO] BUILD FAILURE
+
+$ mvn -pl fruitshorts-admin-api -am \
+  -Dtest=EpisodeTranscodeAdminServiceTest,EpisodeTranscodeContractTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[ERROR] String 无法转换为 Long
+[ERROR] 找不到符号: 方法 mediaAssetExists(Long)
+[INFO] BUILD FAILURE
+```
+
+解读：红测先锁定字符串契约和跨域分集来源端口，生产代码尚未实现。
+
+### 实现
+
+- `EpisodeVideoSourcePort` 由 content 域 `EpisodeService` 实现，可按分集 id 或
+  `video_asset_id` 找到分集来源，并回填 `video_asset_id`。
+- 手动转码先按 media_asset.id 锁定；未命中时通过端口找到分集，
+  按 video_url → source_url/objectKey 反查媒资。
+- 仍缺失但本地文件真实存在时自动补登记 `media_asset`，再调用原转码入队。
+- 聚合接口先按 video_url 解析媒资，失败才校验 `video_asset_id`；
+  episodeId/mediaAssetId/taskId 均显式转字符串。
+- 无媒资空态返回 `NO_MEDIA_ASSET` 和可读 errorMsg。
+
+### 定向测试
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=MediaServiceTranscodePipelineTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 6, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+
+$ mvn -pl fruitshorts-admin-api -am \
+  -Dtest=EpisodeTranscodeAdminServiceTest,EpisodeTranscodeContractTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 6, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+### 最终门禁
+
+```text
+$ mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test
+[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 37, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+
+$ mvn -pl fruitshorts-admin-api -am test
+[INFO] Tests run: 53, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+解读：精度字符串、空态、video_url 反查命中、文件存在补登记及原有转码链全部通过。
+
+## 2026-10-22 转码错误截断与进度上报
+
+- 分支：`feature/transcode-progress-fix`
+- 基线：`develop` / `origin/develop` = `f9bc6ee`
+- 计划：`docs/plans/2026-10-22-transcode-progress-fix.md`
+
+现场根因已确认：ffmpeg 错误信息超过 error_msg varchar(500)，回写失败使任务
+停留在 RUNNING/0；同时现有 runner 未解析 ffmpeg progress，缺少 RUNNING 超时自愈。
+
+### TDD 红测
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=TranscodeServiceTriggerTest,TranscodeWorkerTest,FfmpegTranscodeRunnerSmokeTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[ERROR] TranscodeRequest 找不到 progressListener
+[ERROR] 找不到符号: 方法 updateProgress(Long,int)
+[ERROR] 找不到符号: 方法 recoverStaleRunningTasks()
+[INFO] BUILD FAILURE
+```
+
+解读：红测先锁定进度回调、进度落库和僵尸自愈接口，生产代码尚未实现。
+
+### 实现
+
+- error_msg 写库前统一截断为最多 500 字符，附 `truncated,total=...`；
+  即使数据库补丁尚未执行，也不会超过旧 varchar(500)。
+- ffmpeg 使用临时 `-progress` 文件，每 500ms 解析 out_time，
+  worker 最多每秒写一次 transcode_task.progress；只更新 RUNNING 状态。
+- rendition 阶段映射 0-90%，封面/缩略图 90-99%，成功事务置 100；
+  失败保留最后进度。
+- RUNNING 且 updated_at 超过 10 分钟未变化时自动标记 FAILED。
+- 手动重转复用最新任务，SUCCESS/FAILED/CANCELED 均原任务重置为 QUEUED、progress=0。
+- 成功写 rendition 前删除同媒资旧产物，避免重复重转唯一键冲突。
+- 聚合 VO 和任务 VO 增加 updatedAt，供前端展示最近更新时间。
+
+### SQL 补丁
+
+文件：`sql/patch-2026-10-22-transcode-error-msg.sql`
+
+PM 按项目现有 patch 方式执行（本任务未执行数据库变更），例如使用项目当前
+PostgreSQL 连接串：
+
+```text
+$ psql "$DB_URL" -f sql/patch-2026-10-22-transcode-error-msg.sql
+```
+
+脚本只将 `transcode_task.error_msg` 与 `media_thumbnail.error_msg`
+改为 TEXT，可重复执行。
+
+### 定向测试
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=TranscodeServiceTriggerTest,TranscodeWorkerTest,FfmpegTranscodeRunnerSmokeTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 16, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+### 最终门禁
+
+```text
+$ mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test
+[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 39, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+
+$ mvn -pl fruitshorts-admin-api -am test
+[INFO] Tests run: 53, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+解读：真实 ffmpeg smoke 已有进度回调且达到 90% 阶段点；长错误截断、
+进度更新、僵尸任务收口、重复触发复用均通过。
+
+## 2026-10-22 转码任务认领与媒资 ID 校验
+
+- 分支：`feature/transcode-claim-fix`
+- 基线：`develop` / `origin/develop` = `08eddc9`
+- 计划：`docs/plans/2026-10-22-transcode-claim-fix.md`
+
+### 现场补充取证
+
+```text
+transcode_task id=2113167358829924354
+  media_asset_id=21, episode_id=0, status=QUEUED,
+  source_url=/files/episode/202610/f1b105e185f2405d838c1066313a7ff9.mp4
+
+media_asset id=21 存在且 source_url 相同
+drama_episode id=13 使用同一 video_url，但 video_asset_id=0
+```
+
+解读：21 不是不存在的媒资，而是未绑定分集的合法媒资；旧手动触发生成的
+episode_id=0 任务被 claim 条件静默跳过。
+
+### TDD 红测
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=MediaServiceTranscodePipelineTest,TranscodeClaimAndStorageTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[ERROR] 找不到符号: resolveByVideoUrl(String)
+[ERROR] trigger(Long,String,Long,Long) 不存在
+[INFO] BUILD FAILURE
+```
+
+解读：红测先锁定“按视频 URL 绑定分集”与严格媒资 id 触发接口。
+
+### 实现
+
+- POST /admin/media/{id}/transcode 只按 `media_asset.id` 查询，不再把路径 id
+  当成分集 id 兜底，也不再自动生成替代媒资。
+- 媒资存在后按 source_url 查找使用该视频的分集；未找到直接返回
+  `BAD_REQUEST: 媒资未绑定分集视频`，不创建 episode_id=0 任务。
+- 找到分集后先回填 video_asset_id，再向 TranscodeService 传
+  mediaAssetId/dramaId/episodeId/sourceUrl。
+- QUEUED/RUNNING 任务复用时会补齐 drama/episode 绑定，避免历史零绑任务继续卡住。
+- claim 查询增加 media_asset_id>0、episode_id>0、source_url 非空条件；
+  对不可认领任务按 id 去重打印一次 WARN 和具体原因。
+- RUNNING 无 updated_at 变化阈值从 10 分钟收紧到 5 分钟，覆盖 worker 重启遗留。
+- 认领、每档完成、整体成功/失败均有明确日志；ffmpeg 进度仍每秒节流写库。
+
+### 数据修复脚本
+
+文件：`sql/patch-2026-10-22-transcode-task-id-fix.sql`
+
+脚本将 QUEUED/RUNNING 且 `episode_id=0` 或 media_asset_id 不存在于
+media_asset 的任务标记 FAILED 并写明原因，可重复执行。本任务未执行数据库变更。
+
+### 定向测试
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=MediaServiceTranscodePipelineTest,TranscodeClaimAndStorageTest,TranscodeServiceTriggerTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 22, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+### 最终门禁
+
+```text
+$ mvn -pl fruitshorts-module-media,fruitshorts-transcode-worker test
+[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 39, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+
+$ mvn -pl fruitshorts-admin-api -am test
+[INFO] Tests run: 53, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+解读：非法/未绑定媒资拒绝、合法 URL 自动绑定、claim 跳过日志、
+进度上报、重复触发幂等与重启僵尸收口全部通过。
+
+## 2026-10-22 rendition 唯一键冲突与失败落库
+
+- 分支：`feature/fix-transcode-rendition-upsert`
+- 基线：`develop` / `origin/develop` = `5d1a157`
+- 计划：`docs/plans/2026-10-22-transcode-rendition-upsert.md`
+
+运行时证据显示同分集复用新媒资时旧 rendition 未删除，触发
+`uk_rendition(episode_id, quality, format)`；异常后任务停留在 RUNNING。
+
+### 实现
+
+- `TranscodeService.succeed` 在同一事务内删除：
+  `(media_asset_id = 本次媒体 OR episode_id = 本次分集)` 的旧 rendition，
+  再插入本次产物。
+- `media_thumbnail` 表没有 media_asset_id 列，因此按 episode_id 删除旧行后重新插入；
+  覆盖 sprite/VTT 时间轴记录，避免同集唯一键冲突。
+- 新增 `failFinal`：主流程异常立即写 status=FAILED、截断后的 error_msg、
+  finished_at，不修改 progress。
+- worker 对 failFinal 与媒资失败状态写入分别 catch，失败时打印 ERROR 堆栈，不让异常逃逸。
+- 错误截断同时保留头部和尾部关键信息，长度 <= 500。
+
+### 测试
+
+```text
+$ mvn -pl fruitshorts-transcode-worker -am \
+  -Dtest=TranscodeClaimAndStorageTest,TranscodeServiceTriggerTest,TranscodeWorkerTest \
+  -Dsurefire.failIfNoSpecifiedTests=false test
+[INFO] Tests run: 13, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0
+[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0
+[INFO] BUILD SUCCESS
+```
+
+### 最终门禁
+
+```text
+$ mvn -q -DskipTests=false test \
+  -pl fruitshorts-module-media,fruitshorts-transcode-worker,fruitshorts-admin-api -am
+（退出码 0，BUILD SUCCESS）
+```
+
+解读：同分集不同 media_asset_id 的旧 rendition 会被清理，thumbnail 不重复，
+插入异常后任务最终 FAILED 且错误非空；现有认领、worker 与查询测试全部通过。
+
+提交：`91b621f fix(media): 清理旧 rendition 并确保失败状态落库`。
+
+## 2026-10-22 ReelShort 客户端四 Tab 底部导航
+
+- 仓库：ReelShort Flutter 客户端
+- 分支：`feature/client-bottom-nav-4tabs`
+- 基线：`develop` / `origin/develop` = `ec3cb8f`
+- 计划：客户端仓库 `docs/plans/2026-10-22-client-bottom-nav-4tabs.md`
+- 实现提交：`91e869d feat(nav): 底部导航改为首页推荐追剧我的`
+- 留痕提交：`729c226 docs(nav): 回填四 Tab 底部导航记录`
+- 客户端合并：`667fdc5 merge: 合并四 Tab 底部导航`
+
+### 问题
+
+原底栏为首页 / 剧场 / 创作 / 我的，选中态使用品牌橙；追剧若通过 push 收藏页，
+会叠加第二层底栏并产生返回栈。
+
+### 改动文件
+
+- 导航基础：`lib/core/widgets/app_root_tab.dart`、
+  `lib/core/widgets/app_bottom_nav.dart`、`lib/core/theme/app_colors.dart`、
+  `app_dimens.dart`、`app_theme.dart`。
+- 根页面：`home_view.dart`、`home_logic.dart`、`discover_view.dart`、
+  `discover_types.dart`、`mine_view.dart`、`mine_types.dart`、
+  `player_logic.dart`。
+- 收藏嵌入：`favorites_page.dart` 抽出 `FavoritesContent`；独立
+  `FavoritesPage` 保留 Scaffold，首页 `IndexedStack` 第三槽直接嵌入内容。
+- 文案：三份 ARB 与重新生成的 `app_localizations*.dart`。
+- 测试：导航、发现、我的、播放器及主题相关测试。
+
+首页、推荐、追剧、我的均使用同一根 `IndexedStack` 和同一底栏。追剧内容内嵌，
+无返回按钮、无嵌套 Scaffold、无第二层导航且 `Navigator.canPop == false`；
+创作从底栏移除，但“我的”页 `mine-creator-center` 入口保留。
+底栏纯黑，选中图标和文字均纯白 `#FFFFFF`，未选中 `#8A8A8E`。
+
+### 门禁命令与原始输出
+
+```text
+$ dart analyze lib test
+Analyzing lib, test...
+No issues found!
+```
+
+```text
+$ flutter test --no-pub
+04:38 +644: All tests passed!
+```
+
+解读：四 Tab 顺序与文案、追剧当前页切换、单一底栏、无返回栈、创作入口保留
+均有测试覆盖；全量 644 项通过。`pubspec.lock` 未提交，未启动或停止服务，
+未操作真机。
+
+## 2026-10-22 ReelShort 客户端底栏布局补充修复
+
+- 分支：`feature/client-bottom-nav-layout`
+- 基线：`develop` / `origin/develop` = `667fdc5`
+- 实现提交：`81787dc style(nav): 对齐四 Tab 底栏布局规格`
+- 留痕提交：`5362f97 docs(nav): 回填底栏布局规格记录`
+- 客户端合并：`6dea9d4 merge: 对齐四 Tab 底栏布局规格`
+
+补充收敛 `AppRootBottomNav`，四个根 tab 不再由页面各自拼装 item。
+内容高度 56 + SafeArea，图标 26，图标/文字间距 4，文字 11、字距 0，
+选中 w600、未选中 w400；纯黑背景无分割线，选中 `#FFFFFF`，
+未选中修正为 `#8E8E93`。四列均为 `Expanded` 等分。
+
+```text
+$ flutter analyze
+Analyzing reelshort-bottom-nav...
+No issues found! (ran in 5.2s)
+
+$ flutter test
+04:43 +645: All tests passed!
+```
+
+解读：底栏尺寸、安全区、颜色、无分割线和共享导航实例均有测试覆盖。
+`pubspec.lock` 未提交，未操作真机。
+
+## 2026-10-22 ReelShort 客户端首页三列网格
+
+- 分支：`feature/home-grid-layout`
+- 基线：`develop` / `origin/develop` = `6dea9d4`
+- 实现提交：`dd96792 feat(home): 首页改为三列探索网格`
+- 留痕提交：`1bb227e docs(home): 回填首页网格改版记录`
+- 客户端合并：`47bf645 merge: 首页切换三列探索网格`
+
+### 参考图对照
+
+- 顶部：深灰搜索框 + 皇冠 VIP + 礼物钱包入口；钱包角标仅使用真实余额。
+- 一级分类顺序：精选、新剧、分类、榜单；古装/社群仅在 `/app/categories`
+  名称匹配时追加，匹配不到隐藏。
+- 二级标签：热门、爽剧、甜宠、打脸虐渣、虐恋；按分类/题材可用性显示，
+  右侧三横线进入现有 `FilterPage`。
+- 内容：三列、间距 8、封面 5:6、圆角 8；卡片包含热剧/新剧/漫剧角标、
+  播放量、两行标题和最多两个题材标签。
+- 分页继续使用 `HomeFeedController` 的 10 条游标分页、下拉刷新和底部加载。
+- 原 `PlayerPage(homeMode: true)` 保留并迁到推荐 tab，播放器代码与测试未删除。
+
+### 改动文件
+
+`home_view.dart`、`widgets/home_grid_header.dart`、`widgets/home_feed_grid.dart`、
+`widgets/home_feed_card.dart`、`widgets/home_drama_classification.dart`、
+`widgets/home_failure_view.dart`、`Drama` 模型、`AppColors/AppDimens`、三语 ARB
+及对应生成的 l10n 文件、首页/导航/发现/播放器测试。
+
+```text
+$ flutter analyze
+Analyzing reelshort-bottom-nav...
+No issues found! (ran in 2.7s)
+
+$ flutter test
+02:32 +651: All tests passed!
+```
+
+解读：三列网格、分类顺序、动态隐藏、角标、卡片元数据、分页大小、
+下一页追加、搜索入口和卡片播放均有测试覆盖。`home_view.dart` 为 478 行，
+其余新增组件均低于 500 行。`pubspec.lock` 未提交，未操作真机。
+
+## 2026-10-22 ReelShort 客户端「我的」视觉统一
+
+- 分支：`feature/mine-visual-style`
+- 基线：`develop` / `origin/develop` = `47bf645`
+- 实现提交：`83129ac feat(mine): 统一我的页深色视觉风格`
+- 留痕提交：`e40f477 docs(mine): 回填我的页视觉统一记录`
+- 客户端合并：`0ef2438 merge: 统一我的页深色视觉风格`
+
+### Token 说明
+
+- 复用首页：`appBackground #000000`、`contentCard #171717`、
+  `contentSurface #1C1C1E`、`contentBorder rgba(255,255,255,0.10)`。
+- 新增：`textPrimary #FFFFFF`、`textSecondary #8E8E93`、
+  `mineCardRadius 16`、`mineRowHeight 52`、页头标题 21、区块标题 15。
+- 橙色仅保留充值、加入 VIP 等主操作。
+
+### 改动与行为
+
+`mine_view.dart`、`widgets/mine_header.dart`、`widgets/mine_menu.dart` 及公共
+`AppColors/AppDimens`、测试完成视觉收敛。页面底色纯黑，头像卡、三宫格、
+金币卡、会员卡、菜单统一深灰 16 圆角、1px 描边、无阴影/渐变/发光；
+菜单 52 行高且仅行间分割。区块顺序、全部入口、跳转和交互保持不变。
+
+```text
+$ flutter analyze
+Analyzing reelshort-bottom-nav...
+No issues found!
+
+$ flutter test
+00:56 +651: All tests passed!
+```
+
+解读：背景、卡片 token、描边/圆角、三宫格等宽、菜单行高、入口保留及收藏页
+跳转均有测试覆盖。`pubspec.lock` 未提交，未操作真机。
+
@@ -4,6 +4,7 @@ package com.fruitshorts.admin.controller;

 import com.fruitshorts.common.pojo.PageResult;
 import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.admin.service.AppSessionSystemService;
 import com.fruitshorts.admin.vo.AppUserWatchHistoryVO;
 import com.fruitshorts.content.dal.entity.Drama;
 import com.fruitshorts.content.dal.entity.DramaEpisode;
@@ -13,6 +14,7 @@ import com.fruitshorts.content.service.EpisodeService;
 import com.fruitshorts.framework.log.OperationLog;
 import com.fruitshorts.framework.security.SecurityUtils;
 import com.fruitshorts.playback.dal.entity.WatchHistory;
+import com.fruitshorts.user.dal.entity.AppUserSession;
 import com.fruitshorts.playback.service.WatchProgressService;
 import com.fruitshorts.user.dal.entity.AppUserBanRecord;
 import com.fruitshorts.user.service.AppUserAdminService;
@@ -44,6 +46,7 @@ public class AppUserAdminController {
    private final WatchProgressService watchProgressService;
    private final DramaService dramaService;
    private final EpisodeService episodeService;
+    private final AppSessionSystemService sessionSystem;

    @Operation(summary = "App 用户分页查询")
    @GetMapping("/page")
@@ -83,11 +86,15 @@ public class AppUserAdminController {
        Map<Long, DramaEpisode> episodes = episodeService
                .listByIds(rows.stream().map(WatchHistory::getEpisodeId).distinct().toList())
                .stream().collect(Collectors.toMap(DramaEpisode::getId, item -> item, (a, b) -> a));
-        return Result.ok(rows.stream().map(row -> toVo(row, dramas, episodes)).toList());
+        List<AppUserSession> sessions = sessionSystem.groupByUser(List.of(id))
+                .getOrDefault(id, List.of());
+        return Result.ok(rows.stream()
+                .map(row -> toVo(row, dramas, episodes, sessionSystem.match(sessions, row.getDeviceId())))
+                .toList());
    }

    private AppUserWatchHistoryVO toVo(WatchHistory row, Map<Long, Drama> dramas,
-                                       Map<Long, DramaEpisode> episodes) {
+                                       Map<Long, DramaEpisode> episodes, AppUserSession session) {
        AppUserWatchHistoryVO vo = new AppUserWatchHistoryVO();
        vo.setId(row.getId());
        vo.setDramaId(row.getDramaId());
@@ -100,6 +107,10 @@ public class AppUserAdminController {
        long position = row.getPositionMs() == null ? 0L : row.getPositionMs();
        long duration = row.getDurationMs() == null ? 0L : row.getDurationMs();
        vo.setFinished(duration > 0 && position + 1000L >= duration);
+        if (session != null) {
+            vo.setPlatform(session.getPlatform());
+            vo.setOsVersion(session.getOsVersion());
+        }
        Drama drama = dramas.get(row.getDramaId());
        if (drama != null) {
            vo.setDramaTitle(drama.getTitle());
@@ -0,0 +1,115 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.controller;
+
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.content.service.DramaClassificationService;
+import com.fruitshorts.content.vo.DramaBriefVO;
+import com.fruitshorts.content.vo.DramaClassificationRespVO;
+import com.fruitshorts.content.vo.DramaClassificationSaveReqVO;
+import com.fruitshorts.content.vo.DramaIdsReqVO;
+import com.fruitshorts.framework.log.OperationLog;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * 运营分类管理。分类与短剧类型（drama-categories）是两套独立概念，
+ * 分类可自定义增删，并关联任意多部短剧。
+ */
+@Tag(name = "后台-运营分类")
+@RestController
+@RequestMapping("/admin/drama-classifications")
+@RequiredArgsConstructor
+public class DramaClassificationController {
+
+    private final DramaClassificationService classificationService;
+
+    @Operation(summary = "分类列表（带关联数量）")
+    @GetMapping
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<List<DramaClassificationRespVO>> list() {
+        return Result.ok(classificationService.list());
+    }
+
+    @Operation(summary = "新建分类")
+    @PostMapping
+    @PreAuthorize("@ss.hasPermission('drama:create')")
+    @OperationLog(module = "内容管理", action = "新增分类")
+    public Result<Long> create(@Valid @RequestBody DramaClassificationSaveReqVO req) {
+        return Result.ok(classificationService.create(req));
+    }
+
+    @Operation(summary = "编辑分类")
+    @PutMapping("/{id}")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "编辑分类")
+    public Result<Void> update(@PathVariable Long id,
+                               @Valid @RequestBody DramaClassificationSaveReqVO req) {
+        classificationService.update(id, req);
+        return Result.ok();
+    }
+
+    @Operation(summary = "删除分类")
+    @DeleteMapping("/{id}")
+    @PreAuthorize("@ss.hasPermission('drama:delete')")
+    @OperationLog(module = "内容管理", action = "删除分类")
+    public Result<Void> delete(@PathVariable Long id) {
+        classificationService.delete(id);
+        return Result.ok();
+    }
+
+    @Operation(summary = "分类下已关联的短剧")
+    @GetMapping("/{id}/dramas")
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<PageResult<DramaBriefVO>> dramas(
+            @PathVariable Long id,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(defaultValue = "1") int pageIndex,
+            @RequestParam(defaultValue = "10") int pageSize) {
+        return Result.ok(classificationService.pageDramas(id, keyword, pageIndex, pageSize));
+    }
+
+    @Operation(summary = "尚未关联到该分类的短剧")
+    @GetMapping("/{id}/dramas/candidates")
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<PageResult<DramaBriefVO>> candidates(
+            @PathVariable Long id,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(defaultValue = "1") int pageIndex,
+            @RequestParam(defaultValue = "10") int pageSize) {
+        return Result.ok(classificationService.pageCandidates(id, keyword, pageIndex, pageSize));
+    }
+
+    @Operation(summary = "批量关联短剧")
+    @PostMapping("/{id}/dramas")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "分类关联短剧")
+    public Result<Integer> bindDramas(@PathVariable Long id,
+                                      @Valid @RequestBody DramaIdsReqVO req) {
+        return Result.ok(classificationService.bindDramas(id, req.getDramaIds()));
+    }
+
+    @Operation(summary = "移除分类下的短剧")
+    @DeleteMapping("/{id}/dramas/{dramaId}")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "分类移除短剧")
+    public Result<Void> unbindDrama(@PathVariable Long id, @PathVariable Long dramaId) {
+        classificationService.unbindDrama(id, dramaId);
+        return Result.ok();
+    }
+}
@@ -0,0 +1,115 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.controller;
+
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.content.service.DramaPlaylistCategoryService;
+import com.fruitshorts.content.vo.DramaBriefVO;
+import com.fruitshorts.content.vo.DramaIdsReqVO;
+import com.fruitshorts.content.vo.DramaPlaylistCategoryRespVO;
+import com.fruitshorts.content.vo.DramaPlaylistCategorySaveReqVO;
+import com.fruitshorts.framework.log.OperationLog;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * 剧单分类管理：分类直接关联短剧，没有「剧单」这一层。
+ * 与「类型」「分类管理」均无关。
+ */
+@Tag(name = "后台-剧单分类")
+@RestController
+@RequestMapping("/admin/drama-playlist-categories")
+@RequiredArgsConstructor
+public class DramaPlaylistCategoryController {
+
+    private final DramaPlaylistCategoryService categoryService;
+
+    @Operation(summary = "剧单分类列表")
+    @GetMapping
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<List<DramaPlaylistCategoryRespVO>> list() {
+        return Result.ok(categoryService.list());
+    }
+
+    @Operation(summary = "新建剧单分类")
+    @PostMapping
+    @PreAuthorize("@ss.hasPermission('drama:create')")
+    @OperationLog(module = "内容管理", action = "新增剧单分类")
+    public Result<Long> create(@Valid @RequestBody DramaPlaylistCategorySaveReqVO req) {
+        return Result.ok(categoryService.create(req));
+    }
+
+    @Operation(summary = "编辑剧单分类")
+    @PutMapping("/{id}")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "编辑剧单分类")
+    public Result<Void> update(@PathVariable Long id,
+                               @Valid @RequestBody DramaPlaylistCategorySaveReqVO req) {
+        categoryService.update(id, req);
+        return Result.ok();
+    }
+
+    @Operation(summary = "删除剧单分类")
+    @DeleteMapping("/{id}")
+    @PreAuthorize("@ss.hasPermission('drama:delete')")
+    @OperationLog(module = "内容管理", action = "删除剧单分类")
+    public Result<Void> delete(@PathVariable Long id) {
+        categoryService.delete(id);
+        return Result.ok();
+    }
+
+    @Operation(summary = "分类下已关联的短剧")
+    @GetMapping("/{id}/dramas")
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<PageResult<DramaBriefVO>> dramas(
+            @PathVariable Long id,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(defaultValue = "1") int pageIndex,
+            @RequestParam(defaultValue = "10") int pageSize) {
+        return Result.ok(categoryService.pageDramas(id, keyword, pageIndex, pageSize));
+    }
+
+    @Operation(summary = "尚未关联到该分类的短剧")
+    @GetMapping("/{id}/dramas/candidates")
+    @PreAuthorize("@ss.hasPermission('drama:list')")
+    public Result<PageResult<DramaBriefVO>> candidates(
+            @PathVariable Long id,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(defaultValue = "1") int pageIndex,
+            @RequestParam(defaultValue = "10") int pageSize) {
+        return Result.ok(categoryService.pageCandidates(id, keyword, pageIndex, pageSize));
+    }
+
+    @Operation(summary = "批量关联短剧")
+    @PostMapping("/{id}/dramas")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "剧单分类关联短剧")
+    public Result<Integer> bindDramas(@PathVariable Long id,
+                                      @Valid @RequestBody DramaIdsReqVO req) {
+        return Result.ok(categoryService.bindDramas(id, req.getDramaIds()));
+    }
+
+    @Operation(summary = "移除分类下的短剧")
+    @DeleteMapping("/{id}/dramas/{dramaId}")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "剧单分类移除短剧")
+    public Result<Void> unbindDrama(@PathVariable Long id, @PathVariable Long dramaId) {
+        categoryService.unbindDrama(id, dramaId);
+        return Result.ok();
+    }
+}
@@ -0,0 +1,47 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.controller;
+
+import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.framework.log.OperationLog;
+import com.fruitshorts.system.service.LegalDocumentService;
+import com.fruitshorts.system.vo.LegalDocumentVO;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * 后台维护服务条款和隐私协议。公开页面由客户端服务按语言输出。
+ */
+@Tag(name = "后台-协议")
+@RestController
+@RequestMapping("/admin/legal-documents")
+@RequiredArgsConstructor
+public class LegalDocumentAdminController {
+
+    private final LegalDocumentService legalDocumentService;
+
+    @Operation(summary = "协议列表（服务条款、隐私协议，各含中英印尼语）")
+    @GetMapping
+    @PreAuthorize("@ss.hasAnyPermission('system:role','system:menu')")
+    public Result<List<LegalDocumentVO>> list() {
+        return Result.ok(legalDocumentService.list());
+    }
+
+    @Operation(summary = "保存协议")
+    @PutMapping
+    @PreAuthorize("@ss.hasPermission('system:role')")
+    @OperationLog(module = "后台管理", action = "修改服务条款或隐私协议")
+    public Result<Void> save(@RequestBody List<LegalDocumentVO> items) {
+        legalDocumentService.save(items);
+        return Result.ok();
+    }
+}
@@ -0,0 +1,62 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.service;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.fruitshorts.user.dal.entity.AppUserSession;
+import com.fruitshorts.user.dal.mapper.AppUserSessionMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 按用户最近会话解析系统。同一设备优先，否则用仍有效的最近一次登录。
+ */
+@Service
+@RequiredArgsConstructor
+public class AppSessionSystemService {
+
+    private final AppUserSessionMapper sessionMapper;
+
+    /** 按用户分组，组内按最近活跃倒序。 */
+    public Map<Long, List<AppUserSession>> groupByUser(Collection<Long> userIds) {
+        Map<Long, List<AppUserSession>> grouped = new HashMap<>();
+        if (userIds == null || userIds.isEmpty()) {
+            return grouped;
+        }
+        List<AppUserSession> sessions = sessionMapper.selectList(Wrappers.<AppUserSession>lambdaQuery()
+                .in(AppUserSession::getUserId, userIds)
+                .orderByDesc(AppUserSession::getLastActiveAt)
+                .orderByDesc(AppUserSession::getId));
+        for (AppUserSession session : sessions) {
+            grouped.computeIfAbsent(session.getUserId(), key -> new ArrayList<>()).add(session);
+        }
+        return grouped;
+    }
+
+    /** 观看记录优先匹配同一设备，其次取未吊销会话。 */
+    public AppUserSession match(List<AppUserSession> sessions, String deviceId) {
+        if (sessions == null || sessions.isEmpty()) {
+            return null;
+        }
+        if (StringUtils.hasText(deviceId)) {
+            for (AppUserSession session : sessions) {
+                if (deviceId.equals(session.getDeviceId())) {
+                    return session;
+                }
+            }
+        }
+        for (AppUserSession session : sessions) {
+            if (session.getRevokedAt() == null) {
+                return session;
+            }
+        }
+        return sessions.get(0);
+    }
+}
@@ -24,6 +24,9 @@ public class EpisodeTranscodeAdminService {
    private static final String STATUS_NO_VIDEO = "NO_VIDEO";
    private static final String STATUS_NO_MEDIA_ASSET = "NO_MEDIA_ASSET";
    private static final String STATUS_NO_TASK = "NO_TASK";
+    private static final String REASON_EPISODE_NOT_FOUND = "分集不存在或已删除";
+    private static final String REASON_NO_VIDEO = "分集未配置视频";
+    private static final String REASON_NO_MEDIA_ASSET = "未找到分集视频对应的媒资";
    private static final int THUMBNAIL_PAGE_INDEX = 1;
    private static final int THUMBNAIL_PAGE_SIZE = 100;

@@ -33,22 +36,25 @@ public class EpisodeTranscodeAdminService {
    public EpisodeTranscodeRespVO detail(Long episodeId) {
        DramaEpisode episode = episodeId == null ? null : episodeMapper.selectById(episodeId);
        if (episode == null) {
-            return empty(episodeId, STATUS_EPISODE_NOT_FOUND);
+            return empty(episodeId, STATUS_EPISODE_NOT_FOUND, REASON_EPISODE_NOT_FOUND);
        }
        boolean hasVideoAsset = episode.getVideoAssetId() != null
                && episode.getVideoAssetId() > 0;
        if (!StringUtils.hasText(episode.getVideoUrl()) && !hasVideoAsset) {
-            return empty(episodeId, STATUS_NO_VIDEO);
+            return empty(episodeId, STATUS_NO_VIDEO, REASON_NO_VIDEO);
        }
-        Long mediaAssetId = hasVideoAsset
-                ? episode.getVideoAssetId() : outputService.resolveMediaAssetId(episode.getVideoUrl());
-        if (mediaAssetId == null) {
-            return empty(episodeId, STATUS_NO_MEDIA_ASSET);
+        Long mediaAssetId = outputService.resolveMediaAssetId(episode.getVideoUrl());
+        if ((mediaAssetId == null || mediaAssetId <= 0) && hasVideoAsset
+                && outputService.mediaAssetExists(episode.getVideoAssetId())) {
+            mediaAssetId = episode.getVideoAssetId();
+        }
+        if (mediaAssetId == null || mediaAssetId <= 0) {
+            return empty(episodeId, STATUS_NO_MEDIA_ASSET, REASON_NO_MEDIA_ASSET);
        }

        EpisodeTranscodeRespVO result = new EpisodeTranscodeRespVO();
-        result.setEpisodeId(episodeId);
-        result.setMediaAssetId(mediaAssetId);
+        result.setEpisodeId(idString(episodeId));
+        result.setMediaAssetId(idString(mediaAssetId));
        result.setRenditions(outputService.renditionsForMediaAssetId(mediaAssetId));
        result.setThumbnails(outputService.thumbnailForEpisode(
                episodeId, mediaAssetId, THUMBNAIL_PAGE_INDEX, THUMBNAIL_PAGE_SIZE));
@@ -59,23 +65,25 @@ public class EpisodeTranscodeAdminService {
            result.setProgress(0);
            result.setRetryCount(0);
            result.setErrorMsg("");
+            result.setUpdatedAt(episode.getUpdatedAt());
            return result;
        }
-        result.setTaskId(task.getId());
+        result.setTaskId(idString(task.getId()));
        result.setStatus(task.getStatus());
        result.setProgress(task.getProgress());
        result.setRetryCount(task.getRetryCount());
        result.setErrorMsg(task.getErrorMsg());
+        result.setUpdatedAt(task.getUpdatedAt());
        return result;
    }

-    private EpisodeTranscodeRespVO empty(Long episodeId, String status) {
+    private EpisodeTranscodeRespVO empty(Long episodeId, String status, String reason) {
        EpisodeTranscodeRespVO result = new EpisodeTranscodeRespVO();
-        result.setEpisodeId(episodeId);
+        result.setEpisodeId(idString(episodeId));
        result.setStatus(status);
        result.setProgress(0);
        result.setRetryCount(0);
-        result.setErrorMsg("");
+        result.setErrorMsg(reason);
        result.setRenditions(List.of());
        result.setThumbnails(MediaThumbnailRespVO.empty(
                null, episodeId, MediaThumbnailRespVO.STATUS_EMPTY,
@@ -83,6 +91,10 @@ public class EpisodeTranscodeAdminService {
        return result;
    }

+    private String idString(Long id) {
+        return id == null ? null : String.valueOf(id);
+    }
+
    private String taskStatusOf(DramaEpisode episode) {
        return StringUtils.hasText(episode.getTranscodeStatus())
                ? episode.getTranscodeStatus().toUpperCase(Locale.ROOT)
@@ -17,6 +17,7 @@ import com.fruitshorts.content.enums.ContentStatus;
 import com.fruitshorts.playback.dal.entity.WatchHistory;
 import com.fruitshorts.playback.dal.mapper.WatchHistoryMapper;
 import com.fruitshorts.user.dal.entity.AppUser;
+import com.fruitshorts.user.dal.entity.AppUserSession;
 import com.fruitshorts.user.dal.mapper.AppUserMapper;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -46,6 +47,7 @@ public class WatchHistoryAdminService {
    private final AppUserMapper appUserMapper;
    private final DramaMapper dramaMapper;
    private final DramaEpisodeMapper dramaEpisodeMapper;
+    private final AppSessionSystemService sessionSystem;

    /** 按后台筛选条件分页查询观看记录。 */
    public PageResult<AdminWatchHistoryVO> page(WatchHistoryQueryReqVO req) {
@@ -125,10 +127,13 @@ public class WatchHistoryAdminService {
        Map<Long, AppUser> users = loadUsers(rows);
        Map<Long, Drama> dramas = loadDramas(rows);
        Map<Long, DramaEpisode> episodes = loadEpisodes(rows);
+        Map<Long, List<AppUserSession>> sessions = sessionSystem.groupByUser(
+                rows.stream().map(WatchHistory::getUserId).distinct().toList());
        List<AdminWatchHistoryVO> list = new ArrayList<>(rows.size());
        for (WatchHistory row : rows) {
            list.add(toVo(row, users.get(row.getUserId()), dramas.get(row.getDramaId()),
-                    episodes.get(row.getEpisodeId())));
+                    episodes.get(row.getEpisodeId()),
+                    sessionSystem.match(sessions.get(row.getUserId()), row.getDeviceId())));
        }
        return list;
    }
@@ -161,7 +166,7 @@ public class WatchHistoryAdminService {
    }

    private AdminWatchHistoryVO toVo(WatchHistory row, AppUser user, Drama drama,
-                                     DramaEpisode episode) {
+                                     DramaEpisode episode, AppUserSession session) {
        AdminWatchHistoryVO vo = new AdminWatchHistoryVO();
        vo.setId(row.getId());
        vo.setUserId(row.getUserId());
@@ -172,6 +177,10 @@ public class WatchHistoryAdminService {
        vo.setSource(row.getSource());
        vo.setDeviceId(row.getDeviceId());
        vo.setWatchedAt(row.getWatchedAt());
+        if (session != null) {
+            vo.setPlatform(session.getPlatform());
+            vo.setOsVersion(session.getOsVersion());
+        }
        long position = row.getPositionMs() == null ? 0L : row.getPositionMs();
        long duration = row.getDurationMs() == null ? 0L : row.getDurationMs();
        vo.setFinished(duration > 0L && position + FINISHED_TOLERANCE_MS >= duration);
@@ -29,5 +29,9 @@ public class AdminWatchHistoryVO {
    private Boolean finished;
    private String source;
    private String deviceId;
+    /** ANDROID / IOS / WEB，来自该次设备的登录会话。 */
+    private String platform;
+    /** 系统版本，例如 Android 16。 */
+    private String osVersion;
    private LocalDateTime watchedAt;
 }
@@ -28,5 +28,9 @@ public class AppUserWatchHistoryVO {
    private Boolean finished;
    private String source;
    private String deviceId;
+    /** ANDROID / IOS / WEB，来自该次设备的登录会话。 */
+    private String platform;
+    /** 系统版本。 */
+    private String osVersion;
    private LocalDateTime watchedAt;
 }
@@ -7,6 +7,7 @@ import com.fruitshorts.media.vo.MediaThumbnailRespVO;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;

+import java.time.LocalDateTime;
 import java.util.List;

 /** 后台剧集编辑页一次性获取的转码状态。 */
@@ -14,13 +15,14 @@ import java.util.List;
@Schema(description = "分集转码聚合信息")
 public class EpisodeTranscodeRespVO {

-    private Long episodeId;
-    private Long mediaAssetId;
-    private Long taskId;
+    private String episodeId;
+    private String mediaAssetId;
+    private String taskId;
    private String status;
    private Integer progress;
    private Integer retryCount;
    private String errorMsg;
+    private LocalDateTime updatedAt;
    private List<MediaRenditionRespVO> renditions = List.of();
    private MediaThumbnailRespVO thumbnails;
 }
@@ -9,6 +9,8 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.test.web.servlet.MockMvc;

+import java.time.LocalDateTime;
+
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
@@ -29,27 +31,33 @@ class EpisodeTranscodeContractTest {

    @Test
    void should_return_aggregated_episode_transcode_state() throws Exception {
+        String episodeId = "2113150431755636737";
+        String mediaAssetId = "2113150398670966786";
+        String taskId = "2113150398935207938";
        EpisodeTranscodeRespVO vo = new EpisodeTranscodeRespVO();
-        vo.setEpisodeId(31L);
-        vo.setMediaAssetId(88L);
-        vo.setTaskId(8L);
+        vo.setEpisodeId(episodeId);
+        vo.setMediaAssetId(mediaAssetId);
+        vo.setTaskId(taskId);
        vo.setStatus("SUCCESS");
        vo.setProgress(100);
-        given(service.detail(31L)).willReturn(vo);
+        vo.setUpdatedAt(LocalDateTime.of(2026, 10, 22, 15, 10));
+        given(service.detail(Long.parseLong(episodeId))).willReturn(vo);

-        mockMvc.perform(get("/admin/episodes/31/transcode"))
+        mockMvc.perform(get("/admin/episodes/" + episodeId + "/transcode"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(0))
-                .andExpect(jsonPath("$.data.episodeId").value("31"))
-                .andExpect(jsonPath("$.data.mediaAssetId").value("88"))
+                .andExpect(jsonPath("$.data.episodeId").value(episodeId))
+                .andExpect(jsonPath("$.data.mediaAssetId").value(mediaAssetId))
+                .andExpect(jsonPath("$.data.taskId").value(taskId))
                .andExpect(jsonPath("$.data.status").value("SUCCESS"))
-                .andExpect(jsonPath("$.data.progress").value(100));
+                .andExpect(jsonPath("$.data.progress").value(100))
+                .andExpect(jsonPath("$.data.updatedAt").value("2026-10-22T15:10:00"));
    }

    @Test
    void should_return_explicit_empty_state_when_episode_has_no_video() throws Exception {
        EpisodeTranscodeRespVO vo = new EpisodeTranscodeRespVO();
-        vo.setEpisodeId(31L);
+        vo.setEpisodeId("31");
        vo.setStatus("NO_VIDEO");
        given(service.detail(31L)).willReturn(vo);

@@ -0,0 +1,48 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.service;
+
+import com.fruitshorts.user.dal.entity.AppUserSession;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** 观看记录匹配登录系统。 */
+class AppSessionSystemServiceTest {
+
+    private final AppSessionSystemService service = new AppSessionSystemService(null);
+
+    @Test
+    void should_use_same_device_session_when_watch_history_has_device() {
+        AppUserSession older = session("device-1", "ANDROID", "14", null);
+        AppUserSession newer = session("device-2", "IOS", "18", null);
+
+        AppUserSession matched = service.match(List.of(newer, older), "device-1");
+
+        assertThat(matched.getPlatform()).isEqualTo("ANDROID");
+        assertThat(matched.getOsVersion()).isEqualTo("14");
+    }
+
+    @Test
+    void should_use_active_session_when_device_does_not_match() {
+        AppUserSession revoked = session("device-9", "WEB", "1", LocalDateTime.now());
+        AppUserSession active = session("device-2", "IOS", "18", null);
+
+        AppUserSession matched = service.match(List.of(revoked, active), "missing");
+
+        assertThat(matched.getPlatform()).isEqualTo("IOS");
+    }
+
+    private AppUserSession session(String deviceId, String platform, String osVersion,
+                                   LocalDateTime revokedAt) {
+        AppUserSession session = new AppUserSession();
+        session.setDeviceId(deviceId);
+        session.setPlatform(platform);
+        session.setOsVersion(osVersion);
+        session.setRevokedAt(revokedAt);
+        return session;
+    }
+}
@@ -5,9 +5,14 @@ package com.fruitshorts.admin.service;
 import com.fruitshorts.content.dal.entity.DramaEpisode;
 import com.fruitshorts.content.dal.mapper.DramaEpisodeMapper;
 import com.fruitshorts.media.service.MediaTranscodeOutputService;
+import com.fruitshorts.media.vo.MediaThumbnailRespVO;
+import com.fruitshorts.media.vo.TranscodeTaskRespVO;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

+import java.util.List;
+import java.time.LocalDateTime;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
@@ -15,6 +20,10 @@ import static org.mockito.Mockito.verifyNoInteractions;

 class EpisodeTranscodeAdminServiceTest {

+    private static final Long EPISODE_ID = 2113150431755636737L;
+    private static final Long MEDIA_ASSET_ID = 2113150398670966786L;
+    private static final Long TASK_ID = 2113150398935207938L;
+
    private DramaEpisodeMapper episodeMapper;
    private MediaTranscodeOutputService outputService;
    private EpisodeTranscodeAdminService service;
@@ -33,7 +42,7 @@ class EpisodeTranscodeAdminServiceTest {
        var result = service.detail(404L);

        assertThat(result.getStatus()).isEqualTo("EPISODE_NOT_FOUND");
-        assertThat(result.getEpisodeId()).isEqualTo(404L);
+        assertThat(result.getEpisodeId()).isEqualTo("404");
        assertThat(result.getRenditions()).isEmpty();
        verifyNoInteractions(outputService);
    }
@@ -51,4 +60,57 @@ class EpisodeTranscodeAdminServiceTest {
        assertThat(result.getRenditions()).isEmpty();
        verifyNoInteractions(outputService);
    }
+
+    @Test
+    void should_return_exact_snowflake_media_asset_id_as_string() {
+        DramaEpisode episode = episode(MEDIA_ASSET_ID);
+        given(episodeMapper.selectById(EPISODE_ID)).willReturn(episode);
+        given(outputService.resolveMediaAssetId(episode.getVideoUrl())).willReturn(null);
+        given(outputService.mediaAssetExists(MEDIA_ASSET_ID)).willReturn(true);
+        given(outputService.renditionsForMediaAssetId(MEDIA_ASSET_ID)).willReturn(List.of());
+        given(outputService.thumbnailForEpisode(
+                EPISODE_ID, MEDIA_ASSET_ID, 1, 100))
+                .willReturn(MediaThumbnailRespVO.empty(
+                        MEDIA_ASSET_ID, EPISODE_ID,
+                        MediaThumbnailRespVO.STATUS_EMPTY, 1, 100));
+        TranscodeTaskRespVO task = new TranscodeTaskRespVO();
+        task.setId(TASK_ID);
+        task.setMediaAssetId(MEDIA_ASSET_ID);
+        task.setStatus("SUCCESS");
+        task.setProgress(100);
+        task.setUpdatedAt(LocalDateTime.of(2026, 10, 22, 15, 10));
+        given(outputService.latestTask(MEDIA_ASSET_ID)).willReturn(task);
+
+        var result = service.detail(EPISODE_ID);
+
+        assertThat(result.getEpisodeId()).isEqualTo("2113150431755636737");
+        assertThat(result.getMediaAssetId()).isEqualTo("2113150398670966786");
+        assertThat(result.getTaskId()).isEqualTo("2113150398935207938");
+        assertThat(result.getUpdatedAt()).isEqualTo(task.getUpdatedAt());
+    }
+
+    @Test
+    void should_return_explicit_empty_state_when_episode_media_is_missing() {
+        DramaEpisode episode = episode(MEDIA_ASSET_ID);
+        given(episodeMapper.selectById(EPISODE_ID)).willReturn(episode);
+        given(outputService.mediaAssetExists(MEDIA_ASSET_ID)).willReturn(false);
+        given(outputService.resolveMediaAssetId(episode.getVideoUrl())).willReturn(null);
+
+        var result = service.detail(EPISODE_ID);
+
+        assertThat(result.getMediaAssetId()).isNull();
+        assertThat(result.getStatus()).isEqualTo("NO_MEDIA_ASSET");
+        assertThat(result.getErrorMsg()).isNotBlank();
+        assertThat(result.getRenditions()).isEmpty();
+    }
+
+    private DramaEpisode episode(Long videoAssetId) {
+        DramaEpisode episode = new DramaEpisode();
+        episode.setId(EPISODE_ID);
+        episode.setDramaId(7L);
+        episode.setDurationSec(120);
+        episode.setVideoAssetId(videoAssetId);
+        episode.setVideoUrl("/files/episode/202610/video.mp4");
+        return episode;
+    }
 }
@@ -58,7 +58,7 @@ class WatchHistoryAdminServiceTest {
        dramaMapper = mock(DramaMapper.class);
        dramaEpisodeMapper = mock(DramaEpisodeMapper.class);
        service = new WatchHistoryAdminService(watchHistoryMapper, appUserMapper, dramaMapper,
-                dramaEpisodeMapper);
+                dramaEpisodeMapper, mock(AppSessionSystemService.class));
    }

    @Test
@@ -68,7 +68,7 @@ public class AppAuthController {
    @Operation(summary = "刷新令牌（旧 refresh token 立即失效）")
    @PostMapping("/refresh")
    public Result<TokenRespVO> refresh(@Valid @RequestBody RefreshReqVO req) {
-        return Result.ok(authService.refresh(req.getRefreshToken()));
+        return Result.ok(authService.refresh(req.getRefreshToken(), req.getPlatform(), req.getOsVersion()));
    }

    /** 登出：默认只吊销当前设备的会话，allDevices=true 时吊销全部。 */
@@ -9,6 +9,7 @@ import com.fruitshorts.common.pojo.Result;
 import com.fruitshorts.content.dal.entity.Drama;
 import com.fruitshorts.framework.security.SecurityUtils;
 import com.fruitshorts.playback.service.FavoriteService;
+import com.fruitshorts.playback.vo.FavoriteRemoveReqVO;
 import com.fruitshorts.playback.vo.FavoriteToggleReqVO;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -14,7 +14,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;

-/** 客户端搜索：按标题或简介模糊匹配已上线短剧。 */
+/** 客户端搜索：按标题或简介模糊匹配已上线短剧。不需要登录。 */
@Tag(name = "客户端-搜索")
@RestController
@RequestMapping("/app")
@@ -0,0 +1,44 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.controller;
+
+import com.fruitshorts.system.service.LegalDocumentService;
+import com.fruitshorts.system.service.LegalPages;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 协议公开页。客户端按当前语言打开 /privacy/zh 或 /terms/en，不需要登录。
+ */
+@RestController
+@RequiredArgsConstructor
+public class LegalPageController {
+
+    private static final MediaType HTML = MediaType.parseMediaType("text/html;charset=UTF-8");
+
+    private final LegalDocumentService legalDocumentService;
+
+    /** 隐私协议。语言只接受 zh、en、id。 */
+    @GetMapping("/" + LegalPages.PATH_PRIVACY + "/{lang}")
+    public ResponseEntity<String> privacy(@PathVariable String lang) {
+        return page(LegalPages.PATH_PRIVACY, lang);
+    }
+
+    /** 服务条款。语言只接受 zh、en、id。 */
+    @GetMapping("/" + LegalPages.PATH_TERMS + "/{lang}")
+    public ResponseEntity<String> terms(@PathVariable String lang) {
+        return page(LegalPages.PATH_TERMS, lang);
+    }
+
+    private ResponseEntity<String> page(String path, String lang) {
+        String html = legalDocumentService.render(path, lang);
+        if (html == null) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok().contentType(HTML).body(html);
+    }
+}
@@ -0,0 +1,33 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.service;
+
+import com.fruitshorts.system.service.LegalPageHtml;
+import com.fruitshorts.system.service.LegalPages;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class LegalPageHtmlTest {
+
+    @Test
+    void should_render_markdown_without_an_extra_title() {
+        String html = LegalPageHtml.render("zh", "第一行\n\n<script>alert(1)</script>\n\n**粗体**");
+
+        assertTrue(html.contains("<html lang=\"zh\">"));
+        assertFalse(html.contains("<h1>"));
+        assertTrue(html.contains("<p>第一行</p>"));
+        assertTrue(html.contains("&lt;script&gt;"));
+        assertTrue(html.contains("<strong>粗体</strong>"));
+    }
+
+    @Test
+    void should_map_public_paths_to_document_codes() {
+        assertEquals(LegalPages.PRIVACY, LegalPages.docCodeOfPath("privacy"));
+        assertEquals(LegalPages.TERMS, LegalPages.docCodeOfPath("terms"));
+        assertNull(LegalPages.docCodeOfPath("other"));
+    }
+}
@@ -5,6 +5,7 @@ import com.fruitshorts.content.dal.entity.Drama;
 import com.fruitshorts.content.dal.entity.DramaEpisode;
 import com.fruitshorts.content.service.DramaService;
 import com.fruitshorts.content.service.EpisodeService;
+import com.fruitshorts.media.dal.entity.MediaRendition;
 import com.fruitshorts.media.service.PlaybackSigner;
 import com.fruitshorts.media.service.ThumbnailUrlResolver;
 import com.fruitshorts.media.service.TranscodeService;
@@ -147,6 +148,30 @@ class PlaybackServiceTest {
        verify(signer).sign("/files/episode/15/master.m3u8");
    }

+    @Test
+    void should_sign_each_ready_rendition_when_episode_has_multiple_qualities() {
+        DramaEpisode episode = episode(16L, 1, 0, "/files/episode/origin.mp4");
+        episode.setHlsUrl("/files/transcoded/16/master.m3u8");
+        given(episodeService.getPublished(16L)).willReturn(episode);
+        given(signer.sign(anyString())).willAnswer(invocation -> invocation.getArgument(0) + "?s=1");
+        MediaRendition ready = new MediaRendition();
+        ready.setQuality("720p");
+        ready.setPlayUrl("/files/transcoded/16/720p/index.m3u8");
+        ready.setStatus("ready");
+        MediaRendition failed = new MediaRendition();
+        failed.setQuality("1080p");
+        failed.setPlayUrl("/files/transcoded/16/1080p/index.m3u8");
+        failed.setStatus("failed");
+        given(transcodeService.listRenditions(16L)).willReturn(List.of(ready, failed));
+
+        PlayRespVO resp = playbackService.play(null, 16L, "device-9", "203.0.113.8");
+
+        assertThat(resp.getTracks()).extracting(track -> track.getQuality())
+                .containsExactly("AUTO", "720p");
+        assertThat(resp.getTracks().get(1).getPlayUrl())
+                .isEqualTo("/files/transcoded/16/720p/index.m3u8?s=1");
+    }
+
    private DramaEpisode episode(Long id, int isFree, int unlockCoin, String videoUrl) {
        DramaEpisode episode = new DramaEpisode();
        episode.setId(id);
@@ -15,6 +15,7 @@ import com.fruitshorts.playback.dal.entity.WatchProgress;
 import com.fruitshorts.playback.dal.mapper.WatchHistoryMapper;
 import com.fruitshorts.playback.dal.mapper.WatchProgressMapper;
 import com.fruitshorts.playback.vo.ProgressRespVO;
+import com.fruitshorts.playback.vo.ProgressSaveReqVO;
 import org.apache.ibatis.builder.MapperBuilderAssistant;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -28,6 +29,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

@@ -108,6 +110,30 @@ class WatchProgressServiceTest {
        return progress;
    }

+    @Test
+    void should_revive_deleted_progress_when_same_drama_is_reported_again() {
+        DramaEpisode episode = episode(88L, 1);
+        episode.setDramaId(5L);
+        given(episodeService.getPublished(88L)).willReturn(episode);
+        given(dramaService.getPublished(5L)).willReturn(drama(5L, "剧名", 10));
+        WatchProgress hidden = progress(5L, 88L);
+        hidden.setId(9L);
+        hidden.setUserId(7L);
+        hidden.setDeleted(1);
+        given(progressMapper.selectAny(7L, 5L)).willReturn(hidden);
+        given(progressMapper.selectById(9L)).willReturn(hidden);
+        ProgressSaveReqVO req = new ProgressSaveReqVO();
+        req.setEpisodeId(88L);
+        req.setPositionMs(1_000L);
+        req.setDurationMs(2_000L);
+
+        progressService.save(7L, req);
+
+        verify(progressMapper, never()).insert(any(WatchProgress.class));
+        verify(progressMapper).updateAny(hidden);
+        assertThat(hidden.getDeleted()).isZero();
+    }
+
    private Drama drama(Long id, String title, int totalEpisodes) {
        Drama drama = new Drama();
        drama.setId(id);
@@ -40,11 +40,15 @@ public class SecurityConfig {
            "/app/categories/**",
            "/app/banners/**",
            "/app/dramas/**",
+            "/app/search",
            "/app/episodes/*/play",
            "/app/config/**",
            /* 启动配置与公告：客户端登录前就要拿（POST /app/creator/apply 等仍要登录） */
            "/app/config",
            "/app/notices",
+            /* 服务条款与隐私协议：登录前就要能打开，按语言返回 HTML */
+            "/privacy/**",
+            "/terms/**",
            /* 埋点上报：游客浏览也要记录，匿名可访问 */
            "/app/events",
            /* 媒资：封面与视频用 <img>/<video> 直接访问，无法带请求头。
@@ -0,0 +1,24 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 运营分类：与短剧类型（drama_category）是两套独立概念。 */
+@Data
+@TableName("drama_classification")
+public class DramaClassification {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private String name;
+    private Integer sort;
+    private Integer status;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,22 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 分类与短剧的关联关系（多对多）。 */
+@Data
+@TableName("drama_classification_drama")
+public class DramaClassificationDrama {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long classificationId;
+    private Long dramaId;
+    private LocalDateTime createdAt;
+}
@@ -0,0 +1,26 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 剧单专属分类：只服务于剧单分组，与运营分类（drama_classification）无关。 */
+@Data
+@TableName("drama_playlist_category")
+public class DramaPlaylistCategory {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private String name;
+    /** 分类描述，便于运营说明该分类的用途 */
+    private String description;
+    private Integer sort;
+    private Integer status;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,22 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 剧单分类与短剧的关联关系（分类直接挂短剧，没有剧单层）。 */
+@Data
+@TableName("drama_playlist_category_drama")
+public class DramaPlaylistCategoryDrama {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long categoryId;
+    private Long dramaId;
+    private LocalDateTime createdAt;
+}
@@ -0,0 +1,9 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.content.dal.entity.DramaClassificationDrama;
+
+public interface DramaClassificationDramaMapper extends BaseMapper<DramaClassificationDrama> {
+}
@@ -0,0 +1,9 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.content.dal.entity.DramaClassification;
+
+public interface DramaClassificationMapper extends BaseMapper<DramaClassification> {
+}
@@ -0,0 +1,9 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.content.dal.entity.DramaPlaylistCategoryDrama;
+
+public interface DramaPlaylistCategoryDramaMapper extends BaseMapper<DramaPlaylistCategoryDrama> {
+}
@@ -0,0 +1,9 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.content.dal.entity.DramaPlaylistCategory;
+
+public interface DramaPlaylistCategoryMapper extends BaseMapper<DramaPlaylistCategory> {
+}
@@ -0,0 +1,204 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.content.dal.entity.Drama;
+import com.fruitshorts.content.dal.entity.DramaClassification;
+import com.fruitshorts.content.dal.entity.DramaClassificationDrama;
+import com.fruitshorts.content.dal.mapper.DramaClassificationDramaMapper;
+import com.fruitshorts.content.dal.mapper.DramaClassificationMapper;
+import com.fruitshorts.content.dal.mapper.DramaMapper;
+import com.fruitshorts.content.vo.DramaBriefVO;
+import com.fruitshorts.content.vo.DramaClassificationRespVO;
+import com.fruitshorts.content.vo.DramaClassificationSaveReqVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 运营分类服务。分类是独立于「短剧类型（drama_category）」的一套概念，
+ * 由运营自定义增删，并通过关联表挂载任意多部短剧。
+ */
+@Service
+@RequiredArgsConstructor
+public class DramaClassificationService {
+
+    private final DramaClassificationMapper classificationMapper;
+    private final DramaClassificationDramaMapper classificationDramaMapper;
+    private final DramaMapper dramaMapper;
+
+    public List<DramaClassificationRespVO> list() {
+        Map<Long, Integer> counts = countDramas();
+        return classificationMapper.selectList(Wrappers.<DramaClassification>lambdaQuery()
+                        .orderByAsc(DramaClassification::getSort)
+                        .orderByDesc(DramaClassification::getId))
+                .stream().map(item -> {
+                    DramaClassificationRespVO vo = new DramaClassificationRespVO();
+                    vo.setId(item.getId());
+                    vo.setName(item.getName());
+                    vo.setSort(item.getSort());
+                    vo.setStatus(item.getStatus());
+                    vo.setUpdatedAt(item.getUpdatedAt());
+                    vo.setDramaCount(counts.getOrDefault(item.getId(), 0));
+                    return vo;
+                }).toList();
+    }
+
+    public Long create(DramaClassificationSaveReqVO req) {
+        ensureNameAvailable(req.getName(), null);
+        DramaClassification entity = new DramaClassification();
+        entity.setName(req.getName().trim());
+        Long count = classificationMapper.selectCount(null);
+        entity.setSort(req.getSort() == null
+                ? (count == null ? 0 : count.intValue()) + 1
+                : req.getSort());
+        entity.setStatus(req.getStatus() == null ? 1 : req.getStatus());
+        classificationMapper.insert(entity);
+        return entity.getId();
+    }
+
+    public void update(Long id, DramaClassificationSaveReqVO req) {
+        DramaClassification entity = getExisting(id);
+        ensureNameAvailable(req.getName(), id);
+        entity.setName(req.getName().trim());
+        if (req.getSort() != null) {
+            entity.setSort(req.getSort());
+        }
+        if (req.getStatus() != null) {
+            entity.setStatus(req.getStatus());
+        }
+        classificationMapper.updateById(entity);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long id) {
+        getExisting(id);
+        classificationDramaMapper.delete(Wrappers.<DramaClassificationDrama>lambdaQuery()
+                .eq(DramaClassificationDrama::getClassificationId, id));
+        classificationMapper.deleteById(id);
+    }
+
+    /** 分类下已关联的短剧（分页）。 */
+    public PageResult<DramaBriefVO> pageDramas(Long id, String keyword,
+                                               int pageIndex, int pageSize) {
+        return pageDramas(id, keyword, pageIndex, pageSize, true);
+    }
+
+    /** 尚未关联到该分类的短剧（分页），供「添加短剧」多选。 */
+    public PageResult<DramaBriefVO> pageCandidates(Long id, String keyword,
+                                                   int pageIndex, int pageSize) {
+        return pageDramas(id, keyword, pageIndex, pageSize, false);
+    }
+
+    /** 批量关联短剧；已关联的自动跳过。 */
+    @Transactional(rollbackFor = Exception.class)
+    public int bindDramas(Long id, List<Long> dramaIds) {
+        getExisting(id);
+        if (dramaIds == null || dramaIds.isEmpty()) {
+            return 0;
+        }
+        int added = 0;
+        for (Long dramaId : dramaIds) {
+            if (dramaId == null || dramaMapper.selectById(dramaId) == null) {
+                continue;
+            }
+            Long exists = classificationDramaMapper.selectCount(
+                    Wrappers.<DramaClassificationDrama>lambdaQuery()
+                            .eq(DramaClassificationDrama::getClassificationId, id)
+                            .eq(DramaClassificationDrama::getDramaId, dramaId));
+            if (exists != null && exists > 0) {
+                continue;
+            }
+            DramaClassificationDrama relation = new DramaClassificationDrama();
+            relation.setClassificationId(id);
+            relation.setDramaId(dramaId);
+            classificationDramaMapper.insert(relation);
+            added++;
+        }
+        return added;
+    }
+
+    /** 移出分类；短剧本身不受影响。 */
+    public void unbindDrama(Long id, Long dramaId) {
+        getExisting(id);
+        classificationDramaMapper.delete(Wrappers.<DramaClassificationDrama>lambdaQuery()
+                .eq(DramaClassificationDrama::getClassificationId, id)
+                .eq(DramaClassificationDrama::getDramaId, dramaId));
+    }
+
+    private PageResult<DramaBriefVO> pageDramas(Long id, String keyword,
+                                                int pageIndex, int pageSize, boolean bound) {
+        getExisting(id);
+        Page<Drama> page = new Page<>(Math.max(1, pageIndex), Math.max(1, Math.min(pageSize, 100)));
+        LambdaQueryWrapper<Drama> wrapper = Wrappers.<Drama>lambdaQuery()
+                .like(StringUtils.hasText(keyword), Drama::getTitle, keyword)
+                .orderByDesc(Drama::getSort)
+                .orderByDesc(Drama::getId);
+        String subQuery = "SELECT drama_id FROM drama_classification_drama WHERE classification_id = " + id;
+        if (bound) {
+            wrapper.inSql(Drama::getId, subQuery);
+        } else {
+            wrapper.notInSql(Drama::getId, subQuery);
+        }
+        IPage<Drama> result = dramaMapper.selectPage(page, wrapper);
+        return new PageResult<>(result.getTotal(),
+                result.getRecords().stream().map(this::toBrief).toList());
+    }
+
+    private Map<Long, Integer> countDramas() {
+        Map<Long, Integer> counts = new HashMap<>();
+        classificationDramaMapper.selectMaps(new QueryWrapper<DramaClassificationDrama>()
+                        .select("classification_id AS cid", "COUNT(*) AS cnt")
+                        .groupBy("classification_id"))
+                .forEach(row -> {
+                    Object cid = row.get("cid");
+                    Object cnt = row.get("cnt");
+                    if (cid instanceof Number c && cnt instanceof Number n) {
+                        counts.put(c.longValue(), n.intValue());
+                    }
+                });
+        return counts;
+    }
+
+    private DramaClassification getExisting(Long id) {
+        DramaClassification entity = id == null ? null : classificationMapper.selectById(id);
+        if (entity == null) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "分类不存在");
+        }
+        return entity;
+    }
+
+    private void ensureNameAvailable(String name, Long excludeId) {
+        Long count = classificationMapper.selectCount(Wrappers.<DramaClassification>lambdaQuery()
+                .eq(DramaClassification::getName, name.trim())
+                .ne(excludeId != null, DramaClassification::getId, excludeId));
+        if (count != null && count > 0) {
+            throw new ServiceException(ErrorCode.DATA_EXISTS, "分类名称已存在");
+        }
+    }
+
+    private DramaBriefVO toBrief(Drama drama) {
+        DramaBriefVO vo = new DramaBriefVO();
+        vo.setId(drama.getId());
+        vo.setTitle(drama.getTitle());
+        vo.setCover(drama.getCoverUrl());
+        vo.setStatus(drama.getStatus());
+        vo.setTotalEpisodes(drama.getTotalEpisodes());
+        vo.setSort(drama.getSort());
+        vo.setUpdatedAt(drama.getUpdatedAt());
+        return vo;
+    }
+}
@@ -0,0 +1,208 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.content.dal.entity.Drama;
+import com.fruitshorts.content.dal.entity.DramaPlaylistCategory;
+import com.fruitshorts.content.dal.entity.DramaPlaylistCategoryDrama;
+import com.fruitshorts.content.dal.mapper.DramaMapper;
+import com.fruitshorts.content.dal.mapper.DramaPlaylistCategoryDramaMapper;
+import com.fruitshorts.content.dal.mapper.DramaPlaylistCategoryMapper;
+import com.fruitshorts.content.vo.DramaBriefVO;
+import com.fruitshorts.content.vo.DramaPlaylistCategoryRespVO;
+import com.fruitshorts.content.vo.DramaPlaylistCategorySaveReqVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 剧单分类服务：分类直接关联短剧，没有「剧单」这一层。
+ * 这套分类与「类型」「分类管理」都不是同一套数据。
+ */
+@Service
+@RequiredArgsConstructor
+public class DramaPlaylistCategoryService {
+
+    private final DramaPlaylistCategoryMapper categoryMapper;
+    private final DramaPlaylistCategoryDramaMapper categoryDramaMapper;
+    private final DramaMapper dramaMapper;
+
+    public List<DramaPlaylistCategoryRespVO> list() {
+        Map<Long, Integer> counts = countDramas();
+        return categoryMapper.selectList(Wrappers.<DramaPlaylistCategory>lambdaQuery()
+                        .orderByAsc(DramaPlaylistCategory::getSort)
+                        .orderByDesc(DramaPlaylistCategory::getId))
+                .stream().map(item -> {
+                    DramaPlaylistCategoryRespVO vo = new DramaPlaylistCategoryRespVO();
+                    vo.setId(item.getId());
+                    vo.setName(item.getName());
+                    vo.setDescription(item.getDescription());
+                    vo.setSort(item.getSort());
+                    vo.setStatus(item.getStatus());
+                    vo.setDramaCount(counts.getOrDefault(item.getId(), 0));
+                    return vo;
+                }).toList();
+    }
+
+    public Long create(DramaPlaylistCategorySaveReqVO req) {
+        ensureNameAvailable(req.getName(), null);
+        DramaPlaylistCategory entity = new DramaPlaylistCategory();
+        entity.setName(req.getName().trim());
+        entity.setDescription(req.getDescription() == null ? "" : req.getDescription().trim());
+        Long count = categoryMapper.selectCount(null);
+        entity.setSort(req.getSort() == null
+                ? (count == null ? 0 : count.intValue()) + 1
+                : req.getSort());
+        entity.setStatus(req.getStatus() == null ? 1 : req.getStatus());
+        categoryMapper.insert(entity);
+        return entity.getId();
+    }
+
+    public void update(Long id, DramaPlaylistCategorySaveReqVO req) {
+        DramaPlaylistCategory entity = getExisting(id);
+        ensureNameAvailable(req.getName(), id);
+        entity.setName(req.getName().trim());
+        if (req.getDescription() != null) {
+            entity.setDescription(req.getDescription().trim());
+        }
+        if (req.getSort() != null) {
+            entity.setSort(req.getSort());
+        }
+        if (req.getStatus() != null) {
+            entity.setStatus(req.getStatus());
+        }
+        categoryMapper.updateById(entity);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long id) {
+        getExisting(id);
+        categoryDramaMapper.delete(Wrappers.<DramaPlaylistCategoryDrama>lambdaQuery()
+                .eq(DramaPlaylistCategoryDrama::getCategoryId, id));
+        categoryMapper.deleteById(id);
+    }
+
+    /** 分类下已关联的短剧（分页）。 */
+    public PageResult<DramaBriefVO> pageDramas(Long id, String keyword,
+                                               int pageIndex, int pageSize) {
+        return pageDramas(id, keyword, pageIndex, pageSize, true);
+    }
+
+    /** 尚未关联到该分类的短剧（分页），供「选择短剧」多选。 */
+    public PageResult<DramaBriefVO> pageCandidates(Long id, String keyword,
+                                                   int pageIndex, int pageSize) {
+        return pageDramas(id, keyword, pageIndex, pageSize, false);
+    }
+
+    /** 批量把短剧加入分类；已关联的自动跳过。 */
+    @Transactional(rollbackFor = Exception.class)
+    public int bindDramas(Long id, List<Long> dramaIds) {
+        getExisting(id);
+        if (dramaIds == null || dramaIds.isEmpty()) {
+            return 0;
+        }
+        int added = 0;
+        for (Long dramaId : dramaIds) {
+            if (dramaId == null || dramaMapper.selectById(dramaId) == null) {
+                continue;
+            }
+            Long exists = categoryDramaMapper.selectCount(
+                    Wrappers.<DramaPlaylistCategoryDrama>lambdaQuery()
+                            .eq(DramaPlaylistCategoryDrama::getCategoryId, id)
+                            .eq(DramaPlaylistCategoryDrama::getDramaId, dramaId));
+            if (exists != null && exists > 0) {
+                continue;
+            }
+            DramaPlaylistCategoryDrama relation = new DramaPlaylistCategoryDrama();
+            relation.setCategoryId(id);
+            relation.setDramaId(dramaId);
+            categoryDramaMapper.insert(relation);
+            added++;
+        }
+        return added;
+    }
+
+    /** 把短剧移出分类；短剧本身不受影响。 */
+    public void unbindDrama(Long id, Long dramaId) {
+        getExisting(id);
+        categoryDramaMapper.delete(Wrappers.<DramaPlaylistCategoryDrama>lambdaQuery()
+                .eq(DramaPlaylistCategoryDrama::getCategoryId, id)
+                .eq(DramaPlaylistCategoryDrama::getDramaId, dramaId));
+    }
+
+    private PageResult<DramaBriefVO> pageDramas(Long id, String keyword,
+                                                int pageIndex, int pageSize, boolean bound) {
+        getExisting(id);
+        Page<Drama> page = new Page<>(Math.max(1, pageIndex), Math.max(1, Math.min(pageSize, 100)));
+        LambdaQueryWrapper<Drama> wrapper = Wrappers.<Drama>lambdaQuery()
+                .like(StringUtils.hasText(keyword), Drama::getTitle, keyword)
+                .orderByDesc(Drama::getSort)
+                .orderByDesc(Drama::getId);
+        String subQuery = "SELECT drama_id FROM drama_playlist_category_drama WHERE category_id = " + id;
+        if (bound) {
+            wrapper.inSql(Drama::getId, subQuery);
+        } else {
+            wrapper.notInSql(Drama::getId, subQuery);
+        }
+        IPage<Drama> result = dramaMapper.selectPage(page, wrapper);
+        return new PageResult<>(result.getTotal(),
+                result.getRecords().stream().map(this::toBrief).toList());
+    }
+
+    private Map<Long, Integer> countDramas() {
+        Map<Long, Integer> counts = new HashMap<>();
+        categoryDramaMapper.selectMaps(new QueryWrapper<DramaPlaylistCategoryDrama>()
+                        .select("category_id AS cid", "COUNT(*) AS cnt")
+                        .groupBy("category_id"))
+                .forEach(row -> {
+                    Object cid = row.get("cid");
+                    Object cnt = row.get("cnt");
+                    if (cid instanceof Number c && cnt instanceof Number n) {
+                        counts.put(c.longValue(), n.intValue());
+                    }
+                });
+        return counts;
+    }
+
+    private DramaPlaylistCategory getExisting(Long id) {
+        DramaPlaylistCategory entity = id == null ? null : categoryMapper.selectById(id);
+        if (entity == null) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "剧单分类不存在");
+        }
+        return entity;
+    }
+
+    private void ensureNameAvailable(String name, Long excludeId) {
+        Long count = categoryMapper.selectCount(Wrappers.<DramaPlaylistCategory>lambdaQuery()
+                .eq(DramaPlaylistCategory::getName, name.trim())
+                .ne(excludeId != null, DramaPlaylistCategory::getId, excludeId));
+        if (count != null && count > 0) {
+            throw new ServiceException(ErrorCode.DATA_EXISTS, "剧单分类名称已存在");
+        }
+    }
+
+    private DramaBriefVO toBrief(Drama drama) {
+        DramaBriefVO vo = new DramaBriefVO();
+        vo.setId(drama.getId());
+        vo.setTitle(drama.getTitle());
+        vo.setCover(drama.getCoverUrl());
+        vo.setStatus(drama.getStatus());
+        vo.setTotalEpisodes(drama.getTotalEpisodes());
+        vo.setSort(drama.getSort());
+        vo.setUpdatedAt(drama.getUpdatedAt());
+        return vo;
+    }
+}
@@ -17,6 +17,7 @@ import com.fruitshorts.content.vo.EpisodeRespVO;
 import com.fruitshorts.content.vo.EpisodeSaveReqVO;
 import com.fruitshorts.media.service.EpisodeTranscodeBindingService;
 import com.fruitshorts.media.service.EpisodeTranscodeCompletionPort;
+import com.fruitshorts.media.service.EpisodeVideoSourcePort;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -31,7 +32,7 @@ import java.util.Objects;

@Service
@RequiredArgsConstructor
-public class EpisodeService implements EpisodeTranscodeCompletionPort {
+public class EpisodeService implements EpisodeTranscodeCompletionPort, EpisodeVideoSourcePort {

    private static final int DEFAULT_PAGE_INDEX = 1;
    private static final int DEFAULT_PAGE_SIZE = 100;
@@ -41,6 +42,36 @@ public class EpisodeService implements EpisodeTranscodeCompletionPort {
    private final DramaService dramaService;
    private final EpisodeTranscodeBindingService transcodeBindingService;

+    @Override
+    public java.util.Optional<EpisodeVideoSource> resolveByVideoUrl(String videoUrl) {
+        if (!StringUtils.hasText(videoUrl)) {
+            return java.util.Optional.empty();
+        }
+        DramaEpisode episode = dramaEpisodeMapper.selectOne(Wrappers.<DramaEpisode>lambdaQuery()
+                .eq(DramaEpisode::getVideoUrl, videoUrl)
+                .last("limit 1"));
+        return episode == null
+                ? java.util.Optional.empty()
+                : java.util.Optional.of(toVideoSource(episode));
+    }
+
+    private EpisodeVideoSource toVideoSource(DramaEpisode episode) {
+        return new EpisodeVideoSource(
+                episode.getId(), episode.getDramaId(), episode.getVideoAssetId(),
+                episode.getVideoUrl(), episode.getDurationSec());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void link(Long episodeId, Long mediaAssetId) {
+        if (episodeId == null || episodeId <= 0 || mediaAssetId == null || mediaAssetId <= 0) {
+            return;
+        }
+        dramaEpisodeMapper.update(null, Wrappers.<DramaEpisode>lambdaUpdate()
+                .eq(DramaEpisode::getId, episodeId)
+                .set(DramaEpisode::getVideoAssetId, mediaAssetId));
+    }
+
    /** 后台：按短剧分页查询分集，status 在 SQL 层过滤；排序稳定（sort、ep_no）。 */
    public PageResult<EpisodeRespVO> pageByDrama(Long dramaId, String status,
                                                 Integer pageIndex, Integer pageSize) {
@@ -0,0 +1,20 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 短剧精简信息：分类关联页列表用。 */
+@Data
+public class DramaBriefVO {
+
+    private Long id;
+    private String title;
+    private String cover;
+    private String status;
+    private Integer totalEpisodes;
+    private Integer sort;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,19 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 分类列表项：带关联短剧数量。 */
+@Data
+public class DramaClassificationRespVO {
+
+    private Long id;
+    private String name;
+    private Integer sort;
+    private Integer status;
+    private Integer dramaCount;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,17 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/** 分类新增/编辑请求体。 */
+@Data
+public class DramaClassificationSaveReqVO {
+
+    @NotBlank(message = "请填写分类名称")
+    private String name;
+
+    private Integer sort;
+    private Integer status;
+}
@@ -0,0 +1,16 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Data;
+
+import java.util.List;
+
+/** 批量操作短剧 id 的通用请求体。 */
+@Data
+public class DramaIdsReqVO {
+
+    @NotEmpty(message = "请选择短剧")
+    private List<Long> dramaIds;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import lombok.Data;
+
+/** 剧单分类列表项：带该分类下的短剧数量。 */
+@Data
+public class DramaPlaylistCategoryRespVO {
+
+    private Long id;
+    private String name;
+    private String description;
+    private Integer sort;
+    private Integer status;
+    /** 该分类下已关联的短剧数量 */
+    private Integer dramaCount;
+}
@@ -0,0 +1,21 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+/** 剧单分类新增/编辑请求体。 */
+@Data
+public class DramaPlaylistCategorySaveReqVO {
+
+    @NotBlank(message = "请填写剧单分类名称")
+    private String name;
+
+    @Size(max = 255, message = "描述最多 255 个字符")
+    private String description;
+
+    private Integer sort;
+    private Integer status;
+}
@@ -4,6 +4,17 @@ package com.fruitshorts.media.dal.mapper;

 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.fruitshorts.media.dal.entity.MediaRendition;
+import org.apache.ibatis.annotations.Delete;
+import org.apache.ibatis.annotations.Param;

 public interface MediaRenditionMapper extends BaseMapper<MediaRendition> {
+
+    /**
+     * 物理删除旧产物。唯一索引 uk_rendition(media_asset_id, quality, format) 不含 deleted，
+     * 逻辑删除的旧行会继续占着唯一键，重转时插入必然冲突，所以这里必须绕过 @TableLogic 真删。
+     */
+    @Delete("<script>DELETE FROM media_rendition WHERE media_asset_id = #{mediaAssetId}"
+            + "<if test='episodeId != null and episodeId > 0'> OR episode_id = #{episodeId}</if>"
+            + "</script>")
+    int deletePhysically(@Param("mediaAssetId") Long mediaAssetId, @Param("episodeId") Long episodeId);
 }
@@ -0,0 +1,25 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.media.service;
+
+import java.util.Optional;
+
+/**
+ * 媒资域读取分集视频来源的跨域端口，由 content 域实现。
+ */
+public interface EpisodeVideoSourcePort {
+
+    /** 按视频播放地址查找分集，用于把未回填 video_asset_id 的媒资绑定到分集。 */
+    Optional<EpisodeVideoSource> resolveByVideoUrl(String videoUrl);
+
+    /** 回填分集的 video_asset_id。 */
+    void link(Long episodeId, Long mediaAssetId);
+
+    record EpisodeVideoSource(
+            Long episodeId,
+            Long dramaId,
+            Long videoAssetId,
+            String videoUrl,
+            Integer durationSec) {
+    }
+}
@@ -42,6 +42,7 @@ public class MediaService {
    private final MediaAssetMapper mediaAssetMapper;
    private final MediaUploadTaskMapper mediaUploadTaskMapper;
    private final TranscodeService transcodeService;
+    private final EpisodeVideoSourcePort episodeVideoSourcePort;

    public UploadInitRespVO init(UploadInitReqVO req, Long userId) {
        if (req.getFileSize() > properties.getMaxFileSize()) {
@@ -203,13 +204,21 @@ public class MediaService {
    /** 后台手动触发/重转：锁住媒资行，保证同一媒体的重复请求串行判定任务状态。 */
    @Transactional(rollbackFor = Exception.class)
    public TranscodeTriggerRespVO triggerTranscode(Long id) {
-        MediaAsset asset = id == null ? null : mediaAssetMapper.selectOne(
-                Wrappers.<MediaAsset>lambdaQuery()
-                        .eq(MediaAsset::getId, id)
-                        .last("for update"));
+        MediaAsset asset = lockAsset(id);
        if (asset == null) {
            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "媒资不存在");
        }
+        return triggerAsset(asset);
+    }
+
+    private MediaAsset lockAsset(Long id) {
+        return id == null ? null : mediaAssetMapper.selectOne(
+                Wrappers.<MediaAsset>lambdaQuery()
+                        .eq(MediaAsset::getId, id)
+                        .last("for update"));
+    }
+
+    private TranscodeTriggerRespVO triggerAsset(MediaAsset asset) {
        if (isImage(asset.getFileName())) {
            throw new ServiceException(ErrorCode.BAD_REQUEST, "图片媒资无需转码");
        }
@@ -217,7 +226,13 @@ public class MediaService {
        if (sourceUrl == null || sourceUrl.isBlank()) {
            sourceUrl = asset.getMp4Url();
        }
-        TranscodeTriggerRespVO result = transcodeService.trigger(asset.getId(), sourceUrl);
+        EpisodeVideoSourcePort.EpisodeVideoSource episode = episodeVideoSourcePort
+                .resolveByVideoUrl(sourceUrl)
+                .orElseThrow(() -> new ServiceException(
+                        ErrorCode.BAD_REQUEST, "媒资未绑定分集视频"));
+        episodeVideoSourcePort.link(episode.episodeId(), asset.getId());
+        TranscodeTriggerRespVO result = transcodeService.trigger(
+                asset.getId(), sourceUrl, episode.dramaId(), episode.episodeId());
        asset.setStatus(STATUS_TRANSCODING);
        asset.setTranscodeStatus(result.getStatus());
        mediaAssetMapper.updateById(asset);
@@ -106,6 +106,10 @@ public class MediaTranscodeOutputService {
                transcodeService.findLatestTaskByMediaAssetId(mediaAssetId));
    }

+    public boolean mediaAssetExists(Long mediaAssetId) {
+        return mediaAssetId != null && mediaAssetMapper.selectById(mediaAssetId) != null;
+    }
+
    public Long resolveMediaAssetId(String videoUrl) {
        if (!StringUtils.hasText(videoUrl)) {
            return null;
@@ -115,7 +119,8 @@ public class MediaTranscodeOutputService {
            return null;
        }
        MediaAsset asset = mediaAssetMapper.selectOne(Wrappers.<MediaAsset>lambdaQuery()
-                .eq(MediaAsset::getObjectKey, objectKey)
+                .and(wrapper -> wrapper.eq(MediaAsset::getSourceUrl, videoUrl)
+                        .or().eq(MediaAsset::getObjectKey, objectKey))
                .last("limit 1"));
        return asset == null ? null : asset.getId();
    }
@@ -27,17 +27,12 @@ public class ThumbnailRecordService {
        if (episodeId == null || episodeId <= 0) {
            return;
        }
-        MediaThumbnail existing = mediaThumbnailMapper.selectOne(
-                Wrappers.<MediaThumbnail>lambdaQuery()
-                        .eq(MediaThumbnail::getEpisodeId, episodeId)
-                        .last("limit 1"));
        thumbnail.setDramaId(task.getDramaId() == null ? 0L : task.getDramaId());
        thumbnail.setEpisodeId(episodeId);
-        if (existing == null) {
-            mediaThumbnailMapper.insert(thumbnail);
-            return;
-        }
-        thumbnail.setId(existing.getId());
-        mediaThumbnailMapper.updateById(thumbnail);
+        thumbnail.setErrorMsg(TranscodeErrorTruncator.truncate(thumbnail.getErrorMsg()));
+        thumbnail.setId(null);
+        mediaThumbnailMapper.delete(Wrappers.<MediaThumbnail>lambdaQuery()
+                .eq(MediaThumbnail::getEpisodeId, episodeId));
+        mediaThumbnailMapper.insert(thumbnail);
    }
 }
@@ -0,0 +1,26 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.media.service;
+
+/** 转码错误消息统一截断，避免数据库写入失败。 */
+public final class TranscodeErrorTruncator {
+
+    public static final int MAX_ERROR_CHARS = 500;
+    private static final String EMPTY = "";
+    private static final String TRUNCATED_TEMPLATE = "…(truncated, total=%d chars)…";
+
+    private TranscodeErrorTruncator() {
+    }
+
+    public static String truncate(String message) {
+        if (message == null || message.isEmpty() || message.length() <= MAX_ERROR_CHARS) {
+            return message == null ? EMPTY : message;
+        }
+        String suffix = String.format(TRUNCATED_TEMPLATE, message.length());
+        int remain = Math.max(0, MAX_ERROR_CHARS - suffix.length());
+        int prefixLength = remain / 2;
+        int tailLength = remain - prefixLength;
+        return message.substring(0, prefixLength)
+                + suffix + message.substring(message.length() - tailLength);
+    }
+}
@@ -23,6 +23,8 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;

 /**
 * 转码任务编排。
@@ -42,11 +44,17 @@ public class TranscodeService {
    public static final String STATUS_FAILED = "FAILED";
    /** 失败重试上限（`backend-design-phase1.md` §7.2：失败重试 3 次并记录原因）。 */
    public static final int MAX_RETRY = 3;
+    public static final int STALE_RUNNING_MINUTES = 5;
+    private static final int MAX_RUNNING_PROGRESS = 99;
+    private static final int CLAIM_SKIP_LOG_LIMIT = 20;
+    private static final String STALE_RUNNING_REASON =
+            "任务 RUNNING 超过 5 分钟无进度更新，已自动标记失败，请重新转码";

    private final TranscodeTaskMapper transcodeTaskMapper;
    private final MediaRenditionMapper mediaRenditionMapper;
    private final MediaThumbnailMapper mediaThumbnailMapper;
    private final ThumbnailRecordService thumbnailRecordService;
+    private final Set<Long> loggedSkipTaskIds = ConcurrentHashMap.newKeySet();

    /** 上传完成后入队；同一媒资重复入队时复用未完成的任务，避免重复转码。 */
    @Transactional(rollbackFor = Exception.class)
@@ -78,20 +86,27 @@ public class TranscodeService {
     */
    @Transactional(rollbackFor = Exception.class)
    public TranscodeTriggerRespVO trigger(Long mediaAssetId, String sourceUrl) {
+        return trigger(mediaAssetId, sourceUrl, 0L, 0L);
+    }
+
+    /** 手动重转时同时补齐分集绑定，禁止创建 episode_id=0 的不可认领任务。 */
+    @Transactional(rollbackFor = Exception.class)
+    public TranscodeTriggerRespVO trigger(
+            Long mediaAssetId, String sourceUrl, Long dramaId, Long episodeId) {
        TranscodeTask latest = findLatestTaskByMediaAssetId(mediaAssetId);
        if (latest != null && isActive(latest.getStatus())) {
+            updateTaskBinding(latest, dramaId, episodeId, sourceUrl);
            return response(latest.getId(), latest.getStatus());
        }
        if (latest != null && isRetryable(latest.getStatus())) {
-            resetFailedTask(latest, sourceUrl);
+            resetTaskForRetry(latest, dramaId, episodeId, sourceUrl);
            return response(latest.getId(), STATUS_QUEUED);
        }

-        Long dramaId = latest == null ? 0L : latest.getDramaId();
-        Long episodeId = latest == null ? 0L : latest.getEpisodeId();
        String retrySource = latest == null || latest.getSourceUrl() == null
                || latest.getSourceUrl().isBlank() ? sourceUrl : latest.getSourceUrl();
-        Long taskId = enqueue(mediaAssetId, dramaId, episodeId, retrySource);
+        Long taskId = enqueue(mediaAssetId, nonPositiveToZero(dramaId),
+                nonPositiveToZero(episodeId), retrySource);
        return response(taskId, STATUS_QUEUED);
    }

@@ -135,9 +150,13 @@ public class TranscodeService {

    /** worker 认领任务。并发下依赖状态条件更新，抢不到返回 null。 */
    public TranscodeTask claimNext() {
+        logSkippedQueuedTasks();
        TranscodeTask candidate = transcodeTaskMapper.selectOne(Wrappers.<TranscodeTask>lambdaQuery()
                .eq(TranscodeTask::getStatus, STATUS_QUEUED)
+                .gt(TranscodeTask::getMediaAssetId, 0)
                .gt(TranscodeTask::getEpisodeId, 0)
+                .isNotNull(TranscodeTask::getSourceUrl)
+                .ne(TranscodeTask::getSourceUrl, "")
                .orderByAsc(TranscodeTask::getId)
                .last("limit 1"));
        if (candidate == null) {
@@ -146,12 +165,48 @@ public class TranscodeService {
        int updated = transcodeTaskMapper.update(null, Wrappers.<TranscodeTask>lambdaUpdate()
                .eq(TranscodeTask::getId, candidate.getId())
                .eq(TranscodeTask::getStatus, STATUS_QUEUED)
+                .gt(TranscodeTask::getMediaAssetId, 0)
                .gt(TranscodeTask::getEpisodeId, 0)
+                .isNotNull(TranscodeTask::getSourceUrl)
+                .ne(TranscodeTask::getSourceUrl, "")
                .set(TranscodeTask::getStatus, STATUS_RUNNING)
                .set(TranscodeTask::getStartedAt, LocalDateTime.now()));
        return updated == 1 ? candidate : null;
    }

+    private void logSkippedQueuedTasks() {
+        List<TranscodeTask> skipped = transcodeTaskMapper.selectList(
+                Wrappers.<TranscodeTask>lambdaQuery()
+                        .eq(TranscodeTask::getStatus, STATUS_QUEUED)
+                        .and(wrapper -> wrapper
+                                .isNull(TranscodeTask::getMediaAssetId)
+                                .or().le(TranscodeTask::getMediaAssetId, 0)
+                                .or().isNull(TranscodeTask::getEpisodeId)
+                                .or().le(TranscodeTask::getEpisodeId, 0)
+                                .or().isNull(TranscodeTask::getSourceUrl)
+                                .or().eq(TranscodeTask::getSourceUrl, ""))
+                        .orderByAsc(TranscodeTask::getId)
+                        .last("limit " + CLAIM_SKIP_LOG_LIMIT));
+        for (TranscodeTask task : skipped) {
+            if (task.getId() != null && loggedSkipTaskIds.add(task.getId())) {
+                log.warn("跳过转码任务 {}：{}", task.getId(), claimSkipReason(task));
+            }
+        }
+    }
+
+    private String claimSkipReason(TranscodeTask task) {
+        if (task.getMediaAssetId() == null || task.getMediaAssetId() <= 0) {
+            return "media_asset_id 无效";
+        }
+        if (task.getEpisodeId() == null || task.getEpisodeId() <= 0) {
+            return "episode_id 未绑定";
+        }
+        if (task.getSourceUrl() == null || task.getSourceUrl().isBlank()) {
+            return "source_url 为空";
+        }
+        return "未知原因";
+    }
+
    @Transactional(rollbackFor = Exception.class)
    public void succeed(Long taskId, List<MediaRendition> renditions) {
        succeed(taskId, renditions, null);
@@ -162,6 +217,8 @@ public class TranscodeService {
    public void succeed(Long taskId, List<MediaRendition> renditions,
                        MediaThumbnail thumbnail) {
        TranscodeTask task = getExisting(taskId);
+        // 唯一索引不含 deleted，旧产物必须物理删除，否则重转时插入会撞 uk_rendition
+        mediaRenditionMapper.deletePhysically(task.getMediaAssetId(), task.getEpisodeId());
        for (MediaRendition rendition : renditions) {
            rendition.setMediaAssetId(task.getMediaAssetId());
            rendition.setDramaId(task.getDramaId());
@@ -173,10 +230,10 @@ public class TranscodeService {
        if (thumbnail != null) {
            try {
                thumbnailRecordService.upsert(task, thumbnail);
-                thumbnailError = thumbnail.getErrorMsg() == null
-                        ? "" : thumbnail.getErrorMsg();
+                thumbnailError = TranscodeErrorTruncator.truncate(thumbnail.getErrorMsg());
            } catch (Exception ex) {
-                thumbnailError = "缩略图登记失败：" + exceptionMessage(ex);
+                thumbnailError = TranscodeErrorTruncator.truncate(
+                        "缩略图登记失败：" + exceptionMessage(ex));
                log.warn("缩略图登记失败 task={}：{}", taskId, ex.getMessage());
            }
        }
@@ -202,12 +259,52 @@ public class TranscodeService {
            task.setStatus(STATUS_QUEUED);
        }
        task.setRetryCount(retry + 1);
-        task.setErrorMsg(errorMessage == null ? "" : errorMessage);
+        task.setErrorMsg(TranscodeErrorTruncator.truncate(errorMessage));
        task.setFinishedAt(LocalDateTime.now());
        transcodeTaskMapper.updateById(task);
        return task.getStatus();
    }

+    /** worker 实时上报 RUNNING 任务进度，最多到 99，100 由成功事务统一写入。 */
+    public void updateProgress(Long taskId, int progress) {
+        if (taskId == null) {
+            return;
+        }
+        int safeProgress = Math.min(MAX_RUNNING_PROGRESS, Math.max(0, progress));
+        transcodeTaskMapper.update(null, Wrappers.<TranscodeTask>lambdaUpdate()
+                .eq(TranscodeTask::getId, taskId)
+                .eq(TranscodeTask::getStatus, STATUS_RUNNING)
+                .set(TranscodeTask::getProgress, safeProgress));
+    }
+
+    /** 主流程异常时立即终止任务，保留最后进度并写入截断后的错误。 */
+    public int failFinal(Long taskId, String errorMessage) {
+        if (taskId == null) {
+            return 0;
+        }
+        int updated = transcodeTaskMapper.update(null, Wrappers.<TranscodeTask>lambdaUpdate()
+                .eq(TranscodeTask::getId, taskId)
+                .set(TranscodeTask::getStatus, STATUS_FAILED)
+                .set(TranscodeTask::getErrorMsg,
+                        TranscodeErrorTruncator.truncate(errorMessage))
+                .set(TranscodeTask::getFinishedAt, LocalDateTime.now()));
+        if (updated == 0) {
+            log.error("转码任务失败状态落库失败：task={} 不存在或未更新", taskId);
+        }
+        return updated;
+    }
+
+    /** RUNNING 超过阈值且 updated_at 长期未变时自动收口，避免僵尸任务永久占位。 */
+    public int recoverStaleRunningTasks() {
+        LocalDateTime now = LocalDateTime.now();
+        return transcodeTaskMapper.update(null, Wrappers.<TranscodeTask>lambdaUpdate()
+                .eq(TranscodeTask::getStatus, STATUS_RUNNING)
+                .lt(TranscodeTask::getUpdatedAt, now.minusMinutes(STALE_RUNNING_MINUTES))
+                .set(TranscodeTask::getStatus, STATUS_FAILED)
+                .set(TranscodeTask::getErrorMsg, STALE_RUNNING_REASON)
+                .set(TranscodeTask::getFinishedAt, now));
+    }
+
    public List<MediaRendition> listRenditions(Long episodeId) {
        return mediaRenditionMapper.selectList(Wrappers.<MediaRendition>lambdaQuery()
                .eq(MediaRendition::getEpisodeId, episodeId)
@@ -314,23 +411,34 @@ public class TranscodeService {
    }

    private boolean isRetryable(String status) {
-        return STATUS_FAILED.equals(status) || "CANCELED".equals(status);
+        return STATUS_SUCCESS.equals(status)
+                || STATUS_FAILED.equals(status) || "CANCELED".equals(status);
    }

-    private void resetFailedTask(TranscodeTask task, String sourceUrl) {
+    private void resetTaskForRetry(
+            TranscodeTask task, Long dramaId, Long episodeId, String sourceUrl) {
        boolean hasSource = sourceUrl != null && !sourceUrl.isBlank();
+        boolean hasDrama = dramaId != null && dramaId > 0;
+        boolean hasEpisode = episodeId != null && episodeId > 0;
        transcodeTaskMapper.update(null, Wrappers.<TranscodeTask>lambdaUpdate()
                .eq(TranscodeTask::getId, task.getId())
-                .in(TranscodeTask::getStatus, List.of(STATUS_FAILED, "CANCELED"))
+                .in(TranscodeTask::getStatus,
+                        List.of(STATUS_SUCCESS, STATUS_FAILED, "CANCELED"))
                .set(TranscodeTask::getStatus, STATUS_QUEUED)
                .set(TranscodeTask::getProgress, 0)
                .set(TranscodeTask::getRetryCount, 0)
                .set(TranscodeTask::getErrorMsg, "")
                .set(TranscodeTask::getStartedAt, null)
                .set(TranscodeTask::getFinishedAt, null)
+                .set(hasDrama, TranscodeTask::getDramaId, dramaId)
+                .set(hasEpisode, TranscodeTask::getEpisodeId, episodeId)
                .set(hasSource, TranscodeTask::getSourceUrl, sourceUrl));
    }

+    private long nonPositiveToZero(Long value) {
+        return value == null || value <= 0 ? 0L : value;
+    }
+
    private TranscodeTriggerRespVO response(Long taskId, String status) {
        return new TranscodeTriggerRespVO(taskId, status);
    }
@@ -0,0 +1,105 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.media.service.transcode;
+
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntConsumer;
+
+/** 解析 ffmpeg -progress 临时文件并节流上报。 */
+final class FfmpegProgressMonitor {
+
+    private static final long MICROS_PER_SECOND = 1_000_000L;
+
+    private FfmpegProgressMonitor() {
+    }
+
+    static Path createTempFile() {
+        try {
+            return Files.createTempFile("fruitshorts-ffmpeg-progress-", ".log");
+        } catch (IOException ex) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "创建 ffmpeg 进度文件失败：" + ex.getMessage());
+        }
+    }
+
+    static void report(
+            Path progressFile, int durationSec,
+            AtomicInteger lastReported, IntConsumer listener) {
+        if (!Files.isRegularFile(progressFile)) {
+            return;
+        }
+        String content;
+        try {
+            content = Files.readString(progressFile, StandardCharsets.UTF_8);
+        } catch (IOException ex) {
+            return;
+        }
+        long microseconds = extractOutTimeMicros(content);
+        if (microseconds < 0) {
+            return;
+        }
+        int percent = durationSec <= 0 ? 0
+                : (int) Math.min(100, microseconds * 100 / (durationSec * MICROS_PER_SECOND));
+        if (percent > lastReported.get()) {
+            lastReported.set(percent);
+            listener.accept(percent);
+        }
+    }
+
+    static void deleteQuietly(Path path) {
+        if (path == null) {
+            return;
+        }
+        try {
+            Files.deleteIfExists(path);
+        } catch (IOException ignored) {
+            // 临时进度文件删不掉不影响业务结果
+        }
+    }
+
+    private static long extractOutTimeMicros(String content) {
+        long result = -1L;
+        for (String line : content.split("\\R")) {
+            String[] pair = line.trim().split("=", 2);
+            if (pair.length != 2) {
+                continue;
+            }
+            if ("out_time_us".equals(pair[0]) || "out_time_ms".equals(pair[0])) {
+                result = Math.max(result, parseLong(pair[1]));
+            } else if ("out_time".equals(pair[0])) {
+                result = Math.max(result, parseTimestampMicros(pair[1]));
+            }
+        }
+        return result;
+    }
+
+    private static long parseTimestampMicros(String timestamp) {
+        String[] parts = timestamp.trim().split(":");
+        if (parts.length != 3) {
+            return -1L;
+        }
+        try {
+            double seconds = Integer.parseInt(parts[0]) * 3600.0
+                    + Integer.parseInt(parts[1]) * 60.0
+                    + Double.parseDouble(parts[2]);
+            return Math.round(seconds * MICROS_PER_SECOND);
+        } catch (NumberFormatException ex) {
+            return -1L;
+        }
+    }
+
+    private static long parseLong(String value) {
+        try {
+            return Long.parseLong(value.trim());
+        } catch (NumberFormatException ex) {
+            return -1L;
+        }
+    }
+}
@@ -15,6 +15,8 @@ import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntConsumer;
 import java.util.stream.Stream;

 /**
@@ -35,6 +37,11 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
    private static final String VARIANT_PLAYLIST = "index.m3u8";
    private static final String POSTER_FILE = "poster.jpg";
    private static final int STDERR_TAIL = 800;
+    private static final int TRANSCODE_PROGRESS_END = 90;
+    private static final int POSTER_PROGRESS_START = 92;
+    private static final int POSTER_PROGRESS_END = 95;
+    private static final int THUMBNAIL_PROGRESS_END = 99;
+    private static final long PROCESS_POLL_MILLIS = 500;
    private final FfmpegThumbnailGenerator thumbnailGenerator = new FfmpegThumbnailGenerator();

    @Override
@@ -45,14 +52,29 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
        }
        createDirectories(request.outputDir());
        int durationSec = probeDuration(request);
+        SourceDimensions source = probeSourceDimensions(request);
+        reportProgress(request.progressListener(), 1);

        List<ProducedRendition> renditions = new ArrayList<>(request.ladder().size());
-        for (LadderRung rung : request.ladder()) {
-            renditions.add(transcodeRung(request, rung));
+        int totalRungs = Math.max(1, request.ladder().size());
+        for (int index = 0; index < request.ladder().size(); index++) {
+            int start = index * TRANSCODE_PROGRESS_END / totalRungs;
+            int end = (index + 1) * TRANSCODE_PROGRESS_END / totalRungs;
+            LadderRung rung = request.ladder().get(index);
+            ProducedRendition produced = transcodeRung(
+                    request, rung, source, durationSec, start, end);
+            renditions.add(produced);
+            log.info("档位完成 task={} quality={} 实际={}x{} 进度={}%",
+                    request.taskId(), rung.quality(),
+                    produced.width(), produced.height(), end);
        }
+        reportProgress(request.progressListener(), POSTER_PROGRESS_START);
        writeMasterPlaylist(request, renditions);
        ProducedRendition poster = extractPoster(request);
+        reportProgress(request.progressListener(), POSTER_PROGRESS_END);
+        reportProgress(request.progressListener(), 96);
        ProducedThumbnail thumbnail = thumbnailGenerator.generate(request, durationSec);
+        reportProgress(request.progressListener(), THUMBNAIL_PROGRESS_END);
        log.info("转码完成 task={}：{} 档 HLS + 封面 + 缩略图状态={}，时长 {}s",
                request.taskId(), renditions.size(),
                thumbnail == null ? "DISABLED" : thumbnail.status(), durationSec);
@@ -60,17 +82,23 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
                poster.objectKey(), durationSec, thumbnail);
    }

-    private ProducedRendition transcodeRung(TranscodeRequest request, LadderRung rung) {
+    private ProducedRendition transcodeRung(
+            TranscodeRequest request, LadderRung rung, SourceDimensions source,
+            int durationSec, int progressStart, int progressEnd) {
        String relativeDir = rung.quality() + "/";
        Path rungDir = request.outputDir().resolve(rung.quality());
        createDirectories(rungDir);
+        int shortEdge = effectiveShortEdge(rung, source);
+        String scaleFilter = source.landscape()
+                ? "scale=-2:" + shortEdge + ":flags=lanczos,setsar=1"
+                : "scale=" + shortEdge + ":-2:flags=lanczos,setsar=1";
+        Path progressFile = FfmpegProgressMonitor.createTempFile();
        List<String> command = List.of(
                request.ffmpegPath(), "-y",
+                "-progress", progressFile.toString(), "-nostats",
                "-i", request.sourceFile().toString(),
-                // 等比缩放到目标档位（不拉伸）。force_divisible_by=2 不能省：
-                // 640x360 的源在 854x480 档会算出 853x480 这种奇数宽度，libx264 直接拒绝（width not divisible by 2）
-                "-vf", "scale=" + rung.width() + ":" + rung.height()
-                        + ":force_original_aspect_ratio=decrease:force_divisible_by=2",
+                // 按源方向只用短边定档；-2 保证自动推导的一边为偶数，setsar=1 避免播放器再次拉伸
+                "-vf", scaleFilter,
                "-c:v", "libx264", "-preset", "veryfast",
                "-b:v", rung.videoBitrateKbps() + "k",
                // 强制在每个分片边界插关键帧：只写 -hls_time 的话，片源关键帧间隔大于分片时长时
@@ -81,19 +109,45 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
                "-hls_playlist_type", "vod",
                "-hls_segment_filename", rungDir.resolve("seg_%03d.ts").toString(),
                rungDir.resolve(VARIANT_PLAYLIST).toString());
-        runProcess(command, request.timeoutSeconds(), "转码 " + rung.quality() + " 失败");
+        try {
+            runProcessWithProgress(command, request.timeoutSeconds(),
+                    "转码 " + rung.quality() + " 失败", progressFile, durationSec,
+                    rawProgress -> reportProgress(request.progressListener(),
+                            mapProgress(rawProgress, progressStart, progressEnd)));
+            reportProgress(request.progressListener(), progressEnd);
+        } finally {
+            FfmpegProgressMonitor.deleteQuietly(progressFile);
+        }

        Path playlist = rungDir.resolve(VARIANT_PLAYLIST);
        if (!Files.exists(playlist)) {
            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
                    "ffmpeg 未产出播放列表：" + playlist);
        }
-        return new ProducedRendition(rung.quality(), rung.width(), rung.height(),
+        Dimensions output = probeOutputDimensions(request, playlist);
+        return new ProducedRendition(rung.quality(), output.width(), output.height(),
                rung.videoBitrateKbps(), rung.audioBitrateKbps(),
                joinKey(request.objectKeyPrefix(), relativeDir + VARIANT_PLAYLIST),
                sizeOf(rungDir), countSegments(rungDir));
    }

+    private int mapProgress(int rawProgress, int start, int end) {
+        int safe = Math.min(100, Math.max(0, rawProgress));
+        return start + (end - start) * safe / 100;
+    }
+
+    private void reportProgress(IntConsumer listener, int progress) {
+        if (listener != null) {
+            listener.accept(Math.min(99, Math.max(0, progress)));
+        }
+    }
+
+    private int effectiveShortEdge(LadderRung rung, SourceDimensions source) {
+        int rungShortEdge = Math.min(rung.width(), rung.height());
+        int capped = Math.min(rungShortEdge, source.shortEdge());
+        return Math.max(2, capped - capped % 2);
+    }
+
    /** 手写 master.m3u8：按带宽升序，把每档的 index.m3u8 串起来。 */
    private void writeMasterPlaylist(TranscodeRequest request, List<ProducedRendition> renditions) {
        StringBuilder body = new StringBuilder("#EXTM3U\n#EXT-X-VERSION:3\n");
@@ -151,6 +205,132 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
        }
    }

+    /**
+     * ffprobe 同时读取编码尺寸和旋转信息；旋转 90/270 度时按最终显示方向交换宽高。
+     */
+    private SourceDimensions probeSourceDimensions(TranscodeRequest request) {
+        String output = runProcess(List.of(
+                request.ffprobePath(), "-v", "error",
+                "-select_streams", "v:0",
+                "-show_entries",
+                "stream=width,height:stream_side_data=rotation:stream_tags=rotate",
+                "-of", "default=noprint_wrappers=1",
+                request.sourceFile().toString()), 60, "探测视频尺寸失败");
+        int width = 0;
+        int height = 0;
+        Double sideRotation = null;
+        Double tagRotation = null;
+        for (String line : output.split("\\R")) {
+            String[] pair = line.trim().split("=", 2);
+            if (pair.length != 2) {
+                continue;
+            }
+            String key = pair[0];
+            String value = pair[1];
+            if ("width".equals(key)) {
+                width = parseInt(value);
+            } else if ("height".equals(key)) {
+                height = parseInt(value);
+            } else if ("rotation".equals(key)) {
+                sideRotation = parseDouble(value);
+            } else if ("TAG:rotate".equals(key)) {
+                tagRotation = parseDouble(value);
+            }
+        }
+        if (width <= 0 || height <= 0) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "ffprobe 未返回有效视频尺寸：" + width + "x" + height);
+        }
+        double rotation = sideRotation != null
+                ? sideRotation : tagRotation == null ? 0 : tagRotation;
+        boolean quarterTurn = Math.abs(Math.round(rotation)) % 180 == 90;
+        return new SourceDimensions(
+                quarterTurn ? height : width,
+                quarterTurn ? width : height);
+    }
+
+    /** rendition 必须记录真实产物尺寸，不能沿用档位名义宽高。 */
+    private Dimensions probeOutputDimensions(TranscodeRequest request, Path playlist) {
+        String output = runProcess(List.of(
+                request.ffprobePath(), "-v", "error",
+                "-select_streams", "v:0",
+                "-show_entries", "stream=width,height",
+                "-of", "csv=s=x:p=0",
+                playlist.toString()), 60, "探测转码产物尺寸失败");
+        String first = output.lines().findFirst().orElse("").trim();
+        String[] pair = first.split("x");
+        if (pair.length != 2) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "ffprobe 返回了无法解析的产物尺寸：" + first);
+        }
+        int width = parseInt(pair[0]);
+        int height = parseInt(pair[1]);
+        if (width <= 0 || height <= 0 || width % 2 != 0 || height % 2 != 0) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "转码产物尺寸非法：" + width + "x" + height);
+        }
+        return new Dimensions(width, height);
+    }
+
+    private int parseInt(String value) {
+        try {
+            return Integer.parseInt(value.trim());
+        } catch (NumberFormatException ex) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "ffprobe 返回了非法数字：" + value);
+        }
+    }
+
+    private double parseDouble(String value) {
+        try {
+            return Double.parseDouble(value.trim());
+        } catch (NumberFormatException ex) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    "ffprobe 返回了非法旋转角度：" + value);
+        }
+    }
+
+    /** 运行 ffmpeg 并轮询 -progress 文件，把 out_time 映射成 0-100。 */
+    private String runProcessWithProgress(
+            List<String> command, int timeoutSeconds, String errorPrefix,
+            Path progressFile, int durationSec, IntConsumer listener) {
+        Path logFile = null;
+        try {
+            logFile = Files.createTempFile("fruitshorts-ffmpeg-", ".log");
+            Process process = new ProcessBuilder(command)
+                    .redirectErrorStream(true)
+                    .redirectOutput(logFile.toFile())
+                    .start();
+            AtomicInteger lastReported = new AtomicInteger(-1);
+            long deadline = System.currentTimeMillis() + timeoutSeconds * 1000L;
+            while (!process.waitFor(PROCESS_POLL_MILLIS, TimeUnit.MILLISECONDS)) {
+                FfmpegProgressMonitor.report(progressFile, durationSec, lastReported, listener);
+                if (System.currentTimeMillis() > deadline) {
+                    process.destroyForcibly();
+                    throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                            errorPrefix + "：超时（" + timeoutSeconds + "s）");
+                }
+            }
+            FfmpegProgressMonitor.report(progressFile, durationSec, lastReported, listener);
+            String output = Files.readString(logFile, StandardCharsets.UTF_8);
+            if (process.exitValue() != 0) {
+                throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                        errorPrefix + "：" + tail(output));
+            }
+            return output;
+        } catch (ServiceException ex) {
+            throw ex;
+        } catch (IOException ex) {
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR,
+                    errorPrefix + "：无法执行 ffmpeg（" + ex.getMessage() + "）");
+        } catch (InterruptedException ex) {
+            Thread.currentThread().interrupt();
+            throw new ServiceException(ErrorCode.INTERNAL_ERROR, errorPrefix + "：被中断");
+        } finally {
+            FfmpegProgressMonitor.deleteQuietly(logFile);
+        }
+    }
+
    /**
     * 起进程并等结果；非 0 退出把输出尾部带进异常，方便定位是片源问题还是参数问题。
     *
@@ -235,4 +415,17 @@ public class FfmpegTranscodeRunner implements TranscodeRunner {
        String cleanPrefix = prefix == null ? "" : prefix.replaceAll("/+$", "");
        return cleanPrefix.isEmpty() ? relative : cleanPrefix + "/" + relative;
    }
+
+    private record SourceDimensions(int width, int height) {
+        private boolean landscape() {
+            return width >= height;
+        }
+
+        private int shortEdge() {
+            return Math.min(width, height);
+        }
+    }
+
+    private record Dimensions(int width, int height) {
+    }
 }
@@ -4,6 +4,7 @@ package com.fruitshorts.media.service.transcode;

 import java.nio.file.Path;
 import java.util.List;
+import java.util.function.IntConsumer;

 /**
 * 转码执行端口：把"调 ffmpeg 出多码率 HLS + 封面"封在一层后面。
@@ -30,14 +31,25 @@ public interface TranscodeRunner {
    record TranscodeRequest(Long taskId, Path sourceFile, Path outputDir, String objectKeyPrefix,
                            List<LadderRung> ladder, String ffmpegPath, String ffprobePath,
                            int segmentSeconds, int posterSecond, int timeoutSeconds,
-                            SpriteOptions sprite) {
+                            SpriteOptions sprite, IntConsumer progressListener) {
+
+        public TranscodeRequest(Long taskId, Path sourceFile, Path outputDir, String objectKeyPrefix,
+                                List<LadderRung> ladder, String ffmpegPath, String ffprobePath,
+                                int segmentSeconds, int posterSecond, int timeoutSeconds,
+                                SpriteOptions sprite) {
+            this(taskId, sourceFile, outputDir, objectKeyPrefix, ladder, ffmpegPath, ffprobePath,
+                    segmentSeconds, posterSecond, timeoutSeconds, sprite, ignored -> {
+                    });
+        }

        /** 兼容未启用缩略图的既有调用。 */
        public TranscodeRequest(Long taskId, Path sourceFile, Path outputDir, String objectKeyPrefix,
                                List<LadderRung> ladder, String ffmpegPath, String ffprobePath,
                                int segmentSeconds, int posterSecond, int timeoutSeconds) {
            this(taskId, sourceFile, outputDir, objectKeyPrefix, ladder, ffmpegPath, ffprobePath,
-                    segmentSeconds, posterSecond, timeoutSeconds, SpriteOptions.disabled());
+                    segmentSeconds, posterSecond, timeoutSeconds, SpriteOptions.disabled(),
+                    ignored -> {
+                    });
        }
    }

@@ -9,6 +9,7 @@ import com.fruitshorts.media.service.MediaService;
 import com.fruitshorts.media.service.MediaStorageService;
 import com.fruitshorts.media.service.MediaTranscodeProfileService;
 import com.fruitshorts.media.service.EpisodeTranscodeCompletionPort;
+import com.fruitshorts.media.service.TranscodeErrorTruncator;
 import com.fruitshorts.media.service.TranscodeService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -19,6 +20,8 @@ import org.springframework.stereotype.Component;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.IntConsumer;

 /**
 * 转码 worker：消费 `transcode_task`，产出多码率 HLS + 封面。
@@ -38,6 +41,8 @@ import java.util.List;
@ConditionalOnProperty(name = "fruitshorts.media.transcode.worker-enabled", havingValue = "true")
 public class TranscodeWorker {

+    private static final long PROGRESS_WRITE_INTERVAL_MS = 1000L;
+
    private final TranscodeService transcodeService;
    private final MediaService mediaService;
    private final MediaStorageService storageService;
@@ -49,6 +54,10 @@ public class TranscodeWorker {
    @Scheduled(fixedDelayString = "${fruitshorts.media.transcode.poll-delay-ms:5000}")
    public void poll() {
        try {
+            int recovered = transcodeService.recoverStaleRunningTasks();
+            if (recovered > 0) {
+                log.warn("已自动收口 {} 个超时 RUNNING 转码任务", recovered);
+            }
            processOne();
        } catch (Exception ex) {
            // 轮询里不能让异常逃出去，否则调度线程会被取消，整个 worker 静默停摆
@@ -66,6 +75,8 @@ public class TranscodeWorker {
        if (task == null) {
            return false;
        }
+        log.info("开始处理转码任务 task={} asset={} episode={}",
+                task.getId(), task.getMediaAssetId(), task.getEpisodeId());
        process(task);
        return true;
    }
@@ -82,7 +93,8 @@ public class TranscodeWorker {
                    task.getId(), sourceFile, outputDir, objectKeyPrefix, ladder(profile),
                    profileService.ffmpegPath(), profileService.ffprobePath(),
                    profile.getSegmentSeconds(), profileService.posterSecond(),
-                    profileService.timeoutSeconds(), spriteOptions(profile)));
+                    profileService.timeoutSeconds(), spriteOptions(profile),
+                    progressListener(task.getId())));

            transcodeService.succeed(task.getId(), toRenditions(result),
                    toThumbnail(task, result.thumbnail()));
@@ -104,15 +116,23 @@ public class TranscodeWorker {
            logThumbnailResult(result.thumbnail());
        } catch (Exception ex) {
            String reason = ex.getMessage() == null ? ex.getClass().getSimpleName() : ex.getMessage();
-            int attempt = (task.getRetryCount() == null ? 0 : task.getRetryCount()) + 1;
-            String status = transcodeService.fail(task.getId(), reason);
-            if (TranscodeService.STATUS_FAILED.equals(status)
-                    && task.getMediaAssetId() != null && task.getMediaAssetId() > 0) {
-                mediaService.markFailed(task.getMediaAssetId(), reason);
+            try {
+                transcodeService.failFinal(task.getId(), reason);
+            } catch (Exception persistError) {
+                log.error("转码任务失败状态落库失败 task={} 原因={}",
+                        task.getId(), persistError.getMessage(), persistError);
            }
-            log.error("转码失败 task={} 第 {}/{} 次尝试 耗时={}ms 结果={} 原因={}",
-                    task.getId(), attempt, TranscodeService.MAX_RETRY, System.currentTimeMillis() - startedAt,
-                    status, reason);
+            if (task.getMediaAssetId() != null && task.getMediaAssetId() > 0) {
+                try {
+                    mediaService.markFailed(task.getMediaAssetId(), reason);
+                } catch (Exception mediaError) {
+                    log.error("媒资失败状态落库失败 asset={} 原因={}",
+                            task.getMediaAssetId(), mediaError.getMessage(), mediaError);
+                }
+            }
+            log.error("转码失败 task={} 耗时={}ms 结果=FAILED 原因={}",
+                    task.getId(), System.currentTimeMillis() - startedAt,
+                    TranscodeErrorTruncator.truncate(reason));
        }
    }

@@ -140,6 +160,17 @@ public class TranscodeWorker {
                sprite.getColumns(), sprite.getThumbWidth());
    }

+    private IntConsumer progressListener(Long taskId) {
+        AtomicLong lastWriteAt = new AtomicLong(0L);
+        return progress -> {
+            long now = System.currentTimeMillis();
+            if (now - lastWriteAt.get() >= PROGRESS_WRITE_INTERVAL_MS || progress >= 99) {
+                lastWriteAt.set(now);
+                transcodeService.updateProgress(taskId, progress);
+            }
+        };
+    }
+
    private MediaThumbnail toThumbnail(
            TranscodeTask task, TranscodeRunner.ProducedThumbnail produced) {
        if (produced == null) {
@@ -159,7 +190,7 @@ public class TranscodeWorker {
        thumbnail.setDurationSec(produced.durationSec());
        thumbnail.setSizeBytes(produced.sizeBytes());
        thumbnail.setStatus(produced.status());
-        thumbnail.setErrorMsg(produced.errorMessage());
+        thumbnail.setErrorMsg(TranscodeErrorTruncator.truncate(produced.errorMessage()));
        return thumbnail;
    }

@@ -169,7 +200,8 @@ public class TranscodeWorker {
            return;
        }
        if (MediaThumbnail.STATUS_FAILED.equals(thumbnail.status())) {
-            log.warn("主转码成功但缩略图失败：{}", thumbnail.errorMessage());
+            log.warn("主转码成功但缩略图失败：{}",
+                    TranscodeErrorTruncator.truncate(thumbnail.errorMessage()));
            return;
        }
        log.info("缩略图完成：{} 帧，{}x{}", thumbnail.frameCount(),
@@ -26,6 +26,7 @@ public class TranscodeTaskRespVO {
    private LocalDateTime startedAt;
    private LocalDateTime finishedAt;
    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;

    public static TranscodeTaskRespVO from(TranscodeTask task) {
        if (task == null) {
@@ -45,6 +46,7 @@ public class TranscodeTaskRespVO {
        vo.setStartedAt(task.getStartedAt());
        vo.setFinishedAt(task.getFinishedAt());
        vo.setCreatedAt(task.getCreatedAt());
+        vo.setUpdatedAt(task.getUpdatedAt());
        return vo;
    }
 }
@@ -4,6 +4,32 @@ package com.fruitshorts.playback.dal.mapper;

 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.fruitshorts.playback.dal.entity.WatchProgress;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;

 public interface WatchProgressMapper extends BaseMapper<WatchProgress> {
+
+    /** 含逻辑删除行。唯一索引不区分 deleted，再看同一部剧必须能找回旧行。 */
+    @Select("""
+            SELECT * FROM watch_progress
+            WHERE user_id = #{userId} AND drama_id = #{dramaId}
+            LIMIT 1
+            """)
+    WatchProgress selectAny(@Param("userId") Long userId, @Param("dramaId") Long dramaId);
+
+    /** 恢复并更新。手写 SQL 不带 deleted=0 条件，逻辑删除行也能写回。 */
+    @Update("""
+            UPDATE watch_progress SET
+              deleted = 0,
+              episode_id = #{episodeId},
+              position_ms = #{positionMs},
+              duration_ms = #{durationMs},
+              finished = #{finished},
+              play_count = #{playCount},
+              device_id = #{deviceId},
+              source = #{source}
+            WHERE id = #{id}
+            """)
+    int updateAny(WatchProgress progress);
 }
@@ -13,6 +13,7 @@ import com.fruitshorts.media.service.TranscodeService;
 import com.fruitshorts.playback.dal.entity.PlaybackTicket;
 import com.fruitshorts.playback.dal.mapper.PlaybackTicketMapper;
 import com.fruitshorts.playback.vo.PlayRespVO;
+import com.fruitshorts.playback.vo.PlayTrackVO;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -87,6 +88,7 @@ public class PlaybackService {
        vo.setAccessible(true);
        vo.setAccessType(entitled && !free ? ACCESS_ENTITLED : ACCESS_FREE);
        vo.setPlayUrl(signedUrl);
+        vo.setTracks(tracksOf(episode.getId(), signedUrl));

        if (userId != null) {
            recordTicket(userId, drama.getId(), episode.getId(), signedUrl, deviceId, clientIp);
@@ -115,6 +117,29 @@ public class PlaybackService {
        return qualities;
    }

+    /** AUTO 用主列表，其余档位用各自的 index.m3u8，地址都签名。 */
+    private List<PlayTrackVO> tracksOf(Long episodeId, String signedAuto) {
+        List<PlayTrackVO> tracks = new ArrayList<>();
+        tracks.add(track("AUTO", signedAuto));
+        for (MediaRendition rendition : transcodeService.listRenditions(episodeId)) {
+            if (!StringUtils.hasText(rendition.getPlayUrl())) {
+                continue;
+            }
+            if (!"ready".equalsIgnoreCase(rendition.getStatus())) {
+                continue;
+            }
+            tracks.add(track(rendition.getQuality(), signer.sign(rendition.getPlayUrl())));
+        }
+        return tracks;
+    }
+
+    private PlayTrackVO track(String quality, String playUrl) {
+        PlayTrackVO track = new PlayTrackVO();
+        track.setQuality(quality);
+        track.setPlayUrl(playUrl);
+        return track;
+    }
+
    private void recordTicket(Long userId, Long dramaId, Long episodeId, String playUrl,
                              String deviceId, String clientIp) {
        PlaybackTicket ticket = new PlaybackTicket();
@@ -17,6 +17,7 @@ import com.fruitshorts.playback.dal.mapper.WatchProgressMapper;
 import com.fruitshorts.playback.vo.ProgressRespVO;
 import com.fruitshorts.playback.vo.ProgressSaveReqVO;
 import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

@@ -58,30 +59,23 @@ public class WatchProgressService {
        boolean finished = Boolean.TRUE.equals(req.getFinished())
                || (duration > 0 && position + FINISH_THRESHOLD_MS >= duration);

-        WatchProgress existing = progressMapper.selectOne(Wrappers.<WatchProgress>lambdaQuery()
-                .eq(WatchProgress::getUserId, userId)
-                .eq(WatchProgress::getDramaId, drama.getId())
-                .last("limit 1"));
-        if (existing == null) {
-            WatchProgress progress = new WatchProgress();
-            progress.setUserId(userId);
-            progress.setDramaId(drama.getId());
-            progress.setEpisodeId(episode.getId());
-            progress.setPositionMs(position);
-            progress.setDurationMs(duration);
-            progress.setFinished(finished ? 1 : 0);
-            progress.setPlayCount(1);
-            progress.setDeviceId(req.getDeviceId() == null ? "" : req.getDeviceId());
-            progress.setSource(req.getSource() == null ? "" : req.getSource());
-            progressMapper.insert(progress);
+        LoadedProgress loaded = loadForSave(userId, drama.getId(), episode, position, duration,
+                finished, req);
+        WatchProgress existing = loaded.progress();
+        if (loaded.created()) {
            appendHistory(userId, drama.getId(), episode.getId(), position, duration,
-                    progress.getSource(), progress.getDeviceId());
-            // updated_at 由触发器维护，回读一次，保证响应与后续 recent 列表口径一致
-            return toResp(progressMapper.selectById(progress.getId()));
+                    existing.getSource(), existing.getDeviceId());
+            return toResp(progressMapper.selectById(existing.getId()));
        }

+        boolean hidden = existing.getDeleted() != null && existing.getDeleted() != 0;
        boolean sameEpisode = existing.getEpisodeId() != null
                && existing.getEpisodeId().equals(episode.getId());
+        if (hidden && sameEpisode) {
+            existing.setPlayCount((existing.getPlayCount() == null ? 0 : existing.getPlayCount()) + 1);
+            appendHistory(userId, drama.getId(), episode.getId(), position, duration,
+                    req.getSource(), existing.getDeviceId());
+        }
        if (!sameEpisode) {
            // 换集：直接采纳新集与新的播放位置
            existing.setEpisodeId(episode.getId());
@@ -103,10 +97,52 @@ public class WatchProgressService {
        }
        existing.setDeviceId(req.getDeviceId() == null ? "" : req.getDeviceId());
        existing.setSource(req.getSource() == null ? "" : req.getSource());
-        progressMapper.updateById(existing);
+        if (hidden) {
+            existing.setDeleted(0);
+            progressMapper.updateAny(existing);
+        } else {
+            progressMapper.updateById(existing);
+        }
        return toResp(progressMapper.selectById(existing.getId()));
    }

+    private LoadedProgress loadForSave(Long userId, Long dramaId, DramaEpisode episode, long position,
+                                       long duration, boolean finished, ProgressSaveReqVO req) {
+        WatchProgress existing = progressMapper.selectAny(userId, dramaId);
+        if (existing != null) {
+            return new LoadedProgress(existing, false);
+        }
+        WatchProgress created = newProgress(userId, dramaId, episode, position, duration, finished, req);
+        try {
+            progressMapper.insert(created);
+            return new LoadedProgress(created, true);
+        } catch (DuplicateKeyException ex) {
+            WatchProgress raced = progressMapper.selectAny(userId, dramaId);
+            if (raced == null) {
+                throw ex;
+            }
+            return new LoadedProgress(raced, false);
+        }
+    }
+
+    private WatchProgress newProgress(Long userId, Long dramaId, DramaEpisode episode, long position,
+                                      long duration, boolean finished, ProgressSaveReqVO req) {
+        WatchProgress progress = new WatchProgress();
+        progress.setUserId(userId);
+        progress.setDramaId(dramaId);
+        progress.setEpisodeId(episode.getId());
+        progress.setPositionMs(position);
+        progress.setDurationMs(duration);
+        progress.setFinished(finished ? 1 : 0);
+        progress.setPlayCount(1);
+        progress.setDeviceId(req.getDeviceId() == null ? "" : req.getDeviceId());
+        progress.setSource(req.getSource() == null ? "" : req.getSource());
+        return progress;
+    }
+
+    private record LoadedProgress(WatchProgress progress, boolean created) {
+    }
+
    public ProgressRespVO ofDrama(Long userId, Long dramaId) {
        WatchProgress progress = progressMapper.selectOne(Wrappers.<WatchProgress>lambdaQuery()
                .eq(WatchProgress::getUserId, userId)
@@ -185,6 +221,7 @@ public class WatchProgressService {
                vo.setDramaTitle(drama.getTitle());
                vo.setDramaCover(drama.getCoverUrl());
                vo.setTotalEpisodes(drama.getTotalEpisodes());
+                vo.setViewCount(drama.getViewCount());
            }
            DramaEpisode episode = episodeById.get(progress.getEpisodeId());
            if (episode != null) {
@@ -0,0 +1,16 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.playback.vo;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import java.util.List;
+import lombok.Data;
+
+/** 批量取消收藏。 */
+@Data
+public class FavoriteRemoveReqVO {
+
+    @NotEmpty(message = "缺少 dramaIds")
+    private List<@NotNull Long> dramaIds;
+}
@@ -23,6 +23,8 @@ public class PlayRespVO {
    private String playUrl;
    /** 可用的清晰度档位 */
    private List<String> qualities;
+    /** 各档签名地址。AUTO 是主播放列表，其余是单档 HLS。 */
+    private List<PlayTrackVO> tracks;
    /** 雪碧图 WebVTT 时间轴地址；没有产物时为 null */
    private String thumbnailsUrl;
    /** 需要多少金币解锁 */
@@ -0,0 +1,16 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.playback.vo;
+
+import lombok.Data;
+
+/** 一档可切换的清晰度及其签名播放地址。 */
+@Data
+public class PlayTrackVO {
+
+    /** AUTO 或 360p/480p/720p/1080p。 */
+    private String quality;
+
+    /** 签名后的播放地址，客户端原样使用。 */
+    private String playUrl;
+}
@@ -20,6 +20,8 @@ public class ProgressRespVO {
    private Integer episodeNumber;
    /** 短剧总集数；短剧不存在时为空。 */
    private Integer totalEpisodes;
+    /** 短剧热度，取 drama.view_count。不是用户自己的播放次数。 */
+    private Long viewCount;
    private Long positionMs;
    private Long durationMs;
    private Boolean finished;
@@ -21,5 +21,10 @@
            <groupId>com.fruitshorts</groupId>
            <artifactId>fruitshorts-framework</artifactId>
        </dependency>
+        <dependency>
+            <groupId>org.commonmark</groupId>
+            <artifactId>commonmark</artifactId>
+            <version>0.22.0</version>
+        </dependency>
    </dependencies>
 </project>
@@ -0,0 +1,31 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 服务条款与隐私协议。每种文档按语言各存一份。
+ */
+@Data
+@TableName("legal_document")
+public class LegalDocument {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+
+    /** terms 或 privacy。 */
+    private String docCode;
+
+    /** zh、en、id。 */
+    private String lang;
+
+    private String title;
+    private String content;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.system.dal.entity.LegalDocument;
+
+/** 协议正文。 */
+public interface LegalDocumentMapper extends BaseMapper<LegalDocument> {
+}
@@ -0,0 +1,125 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.service;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.system.dal.entity.LegalDocument;
+import com.fruitshorts.system.dal.mapper.LegalDocumentMapper;
+import com.fruitshorts.system.vo.LegalDocumentVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 服务条款与隐私协议：后台保存三语文案，公开页按路径和语言输出 HTML。
+ */
+@Service
+@RequiredArgsConstructor
+public class LegalDocumentService {
+
+    private final LegalDocumentMapper legalDocumentMapper;
+
+    /** 六份协议。库里没有的语言用缺省文案补齐，方便后台第一次打开就能编辑。 */
+    public List<LegalDocumentVO> list() {
+        Map<String, LegalDocument> stored = index(legalDocumentMapper.selectList(null));
+        List<LegalDocumentVO> result = new ArrayList<>();
+        for (String code : LegalPages.DOC_CODES) {
+            for (String lang : LegalPages.LANGS) {
+                result.add(toView(code, lang, stored.get(LegalPages.key(code, lang))));
+            }
+        }
+        return result;
+    }
+
+    /** 按文档和语言覆盖保存。未知种类或语言直接拒绝。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void save(List<LegalDocumentVO> items) {
+        if (items == null || items.isEmpty()) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "请提交协议内容");
+        }
+        for (LegalDocumentVO item : items) {
+            upsert(item);
+        }
+    }
+
+    /**
+     * 公开页面。路径只能是 privacy 或 terms，语言只能是 zh、en、id。
+     * 不合法时返回 null，由控制器回 404。
+     */
+    public String render(String path, String lang) {
+        String code = LegalPages.docCodeOfPath(path);
+        if (code == null || !LegalPages.LANGS.contains(lang)) {
+            return null;
+        }
+        return LegalPageHtml.render(lang, contentOf(code, lang, find(code, lang)));
+    }
+
+    private void upsert(LegalDocumentVO item) {
+        String code = item == null ? null : item.getDocCode();
+        String lang = item == null ? null : item.getLang();
+        if (!LegalPages.DOC_CODES.contains(code) || !LegalPages.LANGS.contains(lang)) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "协议种类或语言不正确");
+        }
+        String title = item.getTitle() == null ? "" : item.getTitle().trim();
+        String content = item.getContent() == null ? "" : item.getContent();
+        if (title.length() > LegalPages.TITLE_MAX || content.length() > LegalPages.CONTENT_MAX) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "协议标题或正文过长");
+        }
+        LegalDocument row = find(code, lang);
+        if (row == null) {
+            row = new LegalDocument();
+            row.setDocCode(code);
+            row.setLang(lang);
+        }
+        row.setTitle(title);
+        row.setContent(content);
+        row.setUpdatedAt(LocalDateTime.now());
+        if (row.getId() == null) {
+            legalDocumentMapper.insert(row);
+        } else {
+            legalDocumentMapper.updateById(row);
+        }
+    }
+
+    private LegalDocument find(String code, String lang) {
+        return legalDocumentMapper.selectOne(Wrappers.<LegalDocument>lambdaQuery()
+                .eq(LegalDocument::getDocCode, code)
+                .eq(LegalDocument::getLang, lang)
+                .last("limit 1"));
+    }
+
+    private Map<String, LegalDocument> index(List<LegalDocument> rows) {
+        Map<String, LegalDocument> stored = new HashMap<>();
+        if (rows == null) {
+            return stored;
+        }
+        for (LegalDocument row : rows) {
+            stored.put(LegalPages.key(row.getDocCode(), row.getLang()), row);
+        }
+        return stored;
+    }
+
+    private LegalDocumentVO toView(String code, String lang, LegalDocument row) {
+        LegalDocumentVO view = new LegalDocumentVO();
+        view.setDocCode(code);
+        view.setLang(lang);
+        view.setTitle("");
+        view.setContent(row == null ? LegalPages.defaultContent(lang) : row.getContent());
+        return view;
+    }
+
+    private String contentOf(String code, String lang, LegalDocument row) {
+        if (row != null && row.getContent() != null) {
+            return row.getContent();
+        }
+        return LegalPages.defaultContent(lang);
+    }
+}
@@ -0,0 +1,56 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.service;
+
+import org.commonmark.parser.Parser;
+import org.commonmark.renderer.html.HtmlRenderer;
+
+/**
+ * 把协议 Markdown 包成手机上可读的 HTML。不另加标题，原文里的 HTML 会转义。
+ */
+public final class LegalPageHtml {
+
+    private static final Parser PARSER = Parser.builder().build();
+    private static final HtmlRenderer RENDERER = HtmlRenderer.builder().escapeHtml(true).build();
+
+    private LegalPageHtml() {
+    }
+
+    /** 生成完整页面。语言只用于 html lang 属性。 */
+    public static String render(String lang, String markdown) {
+        String body = RENDERER.render(PARSER.parse(markdown == null ? "" : markdown));
+        return """
+                <!DOCTYPE html>
+                <html lang="%s">
+                <head>
+                <meta charset="utf-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1">
+                <title></title>
+                <style>
+                body{margin:0;background:#111;color:#f4f4f5;font:16px/1.7 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+                main{max-width:720px;margin:0 auto;padding:28px 20px 48px}
+                article>*:first-child{margin-top:0}
+                article p{margin:0 0 12px}
+                article h1,article h2,article h3{font-size:18px;line-height:1.4;margin:20px 0 8px}
+                article a{color:#ff6b2c}
+                article ul,article ol{margin:0 0 12px;padding-left:1.2em}
+                article code{font-family:ui-monospace,monospace}
+                article pre{overflow:auto;padding:12px;background:#1c1c1e;border-radius:8px}
+                </style>
+                </head>
+                <body><main><article>%s</article></main></body>
+                </html>
+                """.formatted(escape(lang), body);
+    }
+
+    /** 转义 HTML 特殊字符。 */
+    public static String escape(String raw) {
+        if (raw == null || raw.isEmpty()) {
+            return "";
+        }
+        return raw.replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("\"", "&quot;");
+    }
+}
@@ -0,0 +1,47 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.service;
+
+import java.util.List;
+
+/**
+ * 协议种类、公开路径和缺省文案。路径按语言区分，例如 /privacy/zh、/terms/en。
+ */
+public final class LegalPages {
+
+    public static final String TERMS = "terms";
+    public static final String PRIVACY = "privacy";
+    public static final String PATH_TERMS = "terms";
+    public static final String PATH_PRIVACY = "privacy";
+    public static final List<String> DOC_CODES = List.of(TERMS, PRIVACY);
+    public static final List<String> LANGS = List.of("zh", "en", "id");
+    public static final int TITLE_MAX = 80;
+    public static final int CONTENT_MAX = 100000;
+
+    private LegalPages() {
+    }
+
+    /** 公开路径对应的文档编码。无法识别时返回 null。 */
+    public static String docCodeOfPath(String path) {
+        if (PATH_PRIVACY.equals(path)) {
+            return PRIVACY;
+        }
+        if (PATH_TERMS.equals(path)) {
+            return TERMS;
+        }
+        return null;
+    }
+
+    /** 后台还没保存时页面上使用的 Markdown 正文。 */
+    public static String defaultContent(String lang) {
+        return switch (lang) {
+            case "en" -> "This page is published by FruitShorts and can be edited as Markdown in the admin console.";
+            case "id" -> "Halaman ini dipublikasikan oleh FruitShorts dan dapat diubah sebagai Markdown di konsol admin.";
+            default -> "本页由水果短剧发布，可在管理后台用 Markdown 修改。";
+        };
+    }
+
+    public static String key(String docCode, String lang) {
+        return docCode + ":" + lang;
+    }
+}
@@ -0,0 +1,21 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.system.vo;
+
+import lombok.Data;
+
+/**
+ * 后台读写的一份协议。公开页面不走这个结构，直接返回 HTML。
+ */
+@Data
+public class LegalDocumentVO {
+
+    /** terms 或 privacy。 */
+    private String docCode;
+
+    /** zh、en、id。 */
+    private String lang;
+
+    private String title;
+    private String content;
+}
@@ -294,6 +294,12 @@ public class AppAuthService {
    /** 刷新令牌：轮换 refresh token，旧的立即失效。 */
    @Transactional(rollbackFor = Exception.class)
    public TokenRespVO refresh(String refreshToken) {
+        return refresh(refreshToken, null, null);
+    }
+
+    /** 刷新令牌，并在客户端带上系统信息时更新最近一次使用的系统。 */
+    @Transactional(rollbackFor = Exception.class)
+    public TokenRespVO refresh(String refreshToken, String platform, String osVersion) {
        AppUserSession session = sessionMapper.selectOne(Wrappers.<AppUserSession>lambdaQuery()
                .eq(AppUserSession::getRefreshTokenHash, hasher.sha256(refreshToken))
                .last("limit 1"));
@@ -313,6 +319,12 @@ public class AppAuthService {

        String nextRefreshToken = hasher.newRefreshToken();
        session.setRefreshTokenHash(hasher.sha256(nextRefreshToken));
+        if (StringUtils.hasText(platform)) {
+            session.setPlatform(platform);
+        }
+        if (StringUtils.hasText(osVersion)) {
+            session.setOsVersion(osVersion);
+        }
        session.setLastActiveAt(now);
        session.setExpireAt(now.plus(tokenProvider.appRefreshTtl()));
        sessionMapper.updateById(session);
@@ -11,9 +11,11 @@ import com.fruitshorts.common.pojo.PageResult;
 import com.fruitshorts.user.dal.entity.AppUser;
 import com.fruitshorts.user.dal.entity.AppUserBanRecord;
 import com.fruitshorts.user.dal.entity.AppUserCredential;
+import com.fruitshorts.user.dal.entity.AppUserSession;
 import com.fruitshorts.user.dal.mapper.AppUserBanRecordMapper;
 import com.fruitshorts.user.dal.mapper.AppUserCredentialMapper;
 import com.fruitshorts.user.dal.mapper.AppUserMapper;
+import com.fruitshorts.user.dal.mapper.AppUserSessionMapper;
 import com.fruitshorts.user.enums.AppUserStatus;
 import com.fruitshorts.user.vo.AppUserQueryReqVO;
 import com.fruitshorts.user.vo.AppUserAdminRespVO;
@@ -26,7 +28,9 @@ import org.springframework.util.StringUtils;

 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;

 /**
 * 后台用户管理：检索、详情、状态处置。
@@ -40,6 +44,7 @@ public class AppUserAdminService {
    private final AppUserMapper appUserMapper;
    private final AppUserCredentialMapper credentialMapper;
    private final AppUserBanRecordMapper banRecordMapper;
+    private final AppUserSessionMapper sessionMapper;
    private final AppAuthService authService;

    public PageResult<AppUserAdminRespVO> page(AppUserQueryReqVO req) {
@@ -74,7 +79,9 @@ public class AppUserAdminService {
                            req.getRegisterSource())
                    .orderByDesc(AppUser::getId));
        }
-        return new PageResult<>(result.getTotal(), toRespList(result.getRecords()));
+        List<AppUserAdminRespVO> list = toRespList(result.getRecords());
+        fillLatestSystem(list);
+        return new PageResult<>(result.getTotal(), list);
    }

    public AppUserAdminRespVO detail(Long id) {
@@ -82,7 +89,9 @@ public class AppUserAdminService {
        if (user == null) {
            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "用户不存在");
        }
-        return toAdminResp(user);
+        AppUserAdminRespVO vo = toAdminResp(user);
+        fillLatestSystem(List.of(vo));
+        return vo;
    }

    /** 修改账号状态。封禁/注销会立即踢下线。 */
@@ -154,4 +163,37 @@ public class AppUserAdminService {
        vo.setId(user.getId());
        return vo;
    }
+
+    /** 用最近一次未吊销会话上的系统信息，供后台用户列表展示。 */
+    private void fillLatestSystem(List<AppUserAdminRespVO> list) {
+        if (list.isEmpty()) {
+            return;
+        }
+        List<Long> ids = new ArrayList<>(list.size());
+        for (AppUserAdminRespVO vo : list) {
+            if (vo.getId() != null) {
+                ids.add(vo.getId());
+            }
+        }
+        if (ids.isEmpty()) {
+            return;
+        }
+        List<AppUserSession> sessions = sessionMapper.selectList(Wrappers.<AppUserSession>lambdaQuery()
+                .in(AppUserSession::getUserId, ids)
+                .isNull(AppUserSession::getRevokedAt)
+                .orderByDesc(AppUserSession::getLastActiveAt)
+                .orderByDesc(AppUserSession::getId));
+        Map<Long, AppUserSession> latest = new HashMap<>();
+        for (AppUserSession session : sessions) {
+            latest.putIfAbsent(session.getUserId(), session);
+        }
+        for (AppUserAdminRespVO vo : list) {
+            AppUserSession session = latest.get(vo.getId());
+            if (session == null) {
+                continue;
+            }
+            vo.setPlatform(session.getPlatform());
+            vo.setOsVersion(session.getOsVersion());
+        }
+    }
 }
@@ -16,4 +16,10 @@ import lombok.EqualsAndHashCode;
 public class AppUserAdminRespVO extends AppUserRespVO {

    private Long id;
+
+    /** 最近一次登录的系统：ANDROID / IOS / WEB。 */
+    private String platform;
+
+    /** 最近一次登录的系统版本。 */
+    private String osVersion;
 }
@@ -11,4 +11,10 @@ public class RefreshReqVO {

    @NotBlank(message = "缺少 refreshToken")
    private String refreshToken;
+
+    /** 客户端系统：ANDROID / IOS / WEB。刷新时顺带更新，避免必须重新登录才有记录。 */
+    private String platform;
+
+    /** 系统版本，例如 Android 16。 */
+    private String osVersion;
 }
@@ -12,6 +12,7 @@ import java.nio.file.Path;
 import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Stream;

 import static org.assertj.core.api.Assertions.assertThat;
@@ -40,13 +41,15 @@ class FfmpegTranscodeRunnerSmokeTest {

            Path output = work.resolve("out");
            TranscodeRunner runner = new FfmpegTranscodeRunner();
+            AtomicInteger maxProgress = new AtomicInteger();
            // 只跑两档（360p/480p）保持秒级；四档阶梯的逻辑在 TranscodeWorkerTest 里断言
            TranscodeRunner.TranscodeResult result = runner.run(new TranscodeRunner.TranscodeRequest(
                    1L, sample, output, "transcoded/smoke",
                    List.of(new TranscodeRunner.LadderRung("360p", 640, 360, 400, 64),
                            new TranscodeRunner.LadderRung("480p", 854, 480, 800, 64)),
                    ffmpeg, ffprobe, 2, 1, 120,
-                    new TranscodeRunner.SpriteOptions(true, 1, 10, 160)));
+                    new TranscodeRunner.SpriteOptions(true, 1, 10, 160),
+                    value -> maxProgress.accumulateAndGet(value, Math::max)));

            assertThat(Files.exists(output.resolve("master.m3u8"))).isTrue();
            assertThat(Files.exists(output.resolve("poster.jpg"))).isTrue();
@@ -60,6 +63,7 @@ class FfmpegTranscodeRunnerSmokeTest {
                assertThat(rendition.sizeBytes()).isGreaterThan(0L);
            }
            assertThat(result.durationSec()).isBetween(1, 5);
+            assertThat(maxProgress.get()).isGreaterThanOrEqualTo(90);
            assertThat(result.thumbnail()).isNotNull();
            assertThat(result.thumbnail().status()).isEqualTo("READY");
            assertThat(result.thumbnail().thumbWidth()).isEqualTo(160);
@@ -74,9 +78,58 @@ class FfmpegTranscodeRunnerSmokeTest {
        }
    }

+    @Test
+    void should_keep_landscape_aspect_and_write_actual_dimensions() throws Exception {
+        String ffmpeg = binaryPath("ffmpeg");
+        String ffprobe = binaryPath("ffprobe");
+        assumeTrue(ffmpeg != null && ffprobe != null,
+                "本机没有 ffmpeg/ffprobe，跳过真实转码 smoke");
+
+        TranscodeRunner.TranscodeResult result = transcodeOneRung(
+                ffmpeg, ffprobe, 1024, 576,
+                new TranscodeRunner.LadderRung("360p", 640, 360, 400, 64));
+
+        assertRenditionDimensions(result, 0, 640, 360);
+        assertNoUpscaleOrDistortion(result, 1024, 576, 640, 360);
+    }
+
+    @Test
+    void should_keep_portrait_orientation_and_even_dimensions() throws Exception {
+        String ffmpeg = binaryPath("ffmpeg");
+        String ffprobe = binaryPath("ffprobe");
+        assumeTrue(ffmpeg != null && ffprobe != null,
+                "本机没有 ffmpeg/ffprobe，跳过真实转码 smoke");
+
+        TranscodeRunner.TranscodeResult result = transcodeOneRung(
+                ffmpeg, ffprobe, 720, 1280,
+                new TranscodeRunner.LadderRung("360p", 640, 360, 400, 64));
+
+        assertRenditionDimensions(result, 0, 360, 640);
+        assertNoUpscaleOrDistortion(result, 720, 1280, 360, 640);
+    }
+
+    @Test
+    void should_not_upscale_when_source_short_edge_is_below_rung() throws Exception {
+        String ffmpeg = binaryPath("ffmpeg");
+        String ffprobe = binaryPath("ffprobe");
+        assumeTrue(ffmpeg != null && ffprobe != null,
+                "本机没有 ffmpeg/ffprobe，跳过真实转码 smoke");
+
+        TranscodeRunner.TranscodeResult result = transcodeOneRung(
+                ffmpeg, ffprobe, 640, 360,
+                new TranscodeRunner.LadderRung("480p", 854, 480, 800, 64));
+
+        assertRenditionDimensions(result, 0, 640, 360);
+        assertNoUpscaleOrDistortion(result, 640, 360, 640, 360);
+    }
+
    private void generateSample(String ffmpeg, Path sample) throws Exception {
+        generateSample(ffmpeg, sample, 640, 360);
+    }
+
+    private void generateSample(String ffmpeg, Path sample, int width, int height) throws Exception {
        Process process = new ProcessBuilder(ffmpeg, "-y",
-                "-f", "lavfi", "-i", "testsrc=size=640x360:rate=15",
+                "-f", "lavfi", "-i", "testsrc=size=" + width + "x" + height + ":rate=15",
                "-f", "lavfi", "-i", "sine=frequency=440:duration=2",
                "-shortest", "-t", "2",
                "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac",
@@ -87,6 +140,84 @@ class FfmpegTranscodeRunnerSmokeTest {
        assertThat(process.exitValue()).as("生成测试片失败").isZero();
    }

+    private TranscodeRunner.TranscodeResult transcodeOneRung(
+            String ffmpeg, String ffprobe, int width, int height,
+            TranscodeRunner.LadderRung rung) throws Exception {
+        Path work = Files.createTempDirectory("fruitshorts-aspect-smoke");
+        try {
+            Path sample = work.resolve("sample-" + width + "x" + height + ".mp4");
+            generateSample(ffmpeg, sample, width, height);
+            Path output = work.resolve("out");
+            TranscodeRunner.TranscodeResult result = new FfmpegTranscodeRunner().run(
+                    new TranscodeRunner.TranscodeRequest(
+                            2L, sample, output, "transcoded/aspect",
+                            List.of(rung), ffmpeg, ffprobe, 2, 1, 120,
+                            new TranscodeRunner.SpriteOptions(false, 1, 10, 160)));
+
+            Path playlist = output.resolve(rung.quality()).resolve("index.m3u8");
+            Dimensions probed = probeDimensions(ffprobe, playlist);
+            assertThat(result.renditions()).hasSize(1);
+            assertThat(result.renditions().get(0).width()).isEqualTo(probed.width());
+            assertThat(result.renditions().get(0).height()).isEqualTo(probed.height());
+            assertThat(probeSampleAspectRatio(ffprobe, playlist)).isEqualTo("1:1");
+            assertThat(readLines(output.resolve("master.m3u8")))
+                    .anyMatch(line -> line.contains("RESOLUTION="
+                            + probed.width() + "x" + probed.height()));
+            return result;
+        } finally {
+            deleteRecursively(work);
+        }
+    }
+
+    private void assertRenditionDimensions(
+            TranscodeRunner.TranscodeResult result, int index, int width, int height) {
+        TranscodeRunner.ProducedRendition rendition = result.renditions().get(index);
+        assertThat(rendition.width()).isEqualTo(width);
+        assertThat(rendition.height()).isEqualTo(height);
+    }
+
+    private void assertNoUpscaleOrDistortion(
+            TranscodeRunner.TranscodeResult result,
+            int sourceWidth, int sourceHeight, int width, int height) {
+        TranscodeRunner.ProducedRendition rendition = result.renditions().get(0);
+        assertThat(rendition.width() % 2).isZero();
+        assertThat(rendition.height() % 2).isZero();
+        assertThat(rendition.width()).isLessThanOrEqualTo(sourceWidth);
+        assertThat(rendition.height()).isLessThanOrEqualTo(sourceHeight);
+        double sourceRatio = sourceWidth / (double) sourceHeight;
+        double outputRatio = rendition.width() / (double) rendition.height();
+        assertThat(Math.abs(sourceRatio - outputRatio)).isLessThan(0.01);
+        assertThat(rendition.width()).isEqualTo(width);
+        assertThat(rendition.height()).isEqualTo(height);
+    }
+
+    private Dimensions probeDimensions(String ffprobe, Path playlist) throws Exception {
+        String output = runAndRead(List.of(
+                ffprobe, "-v", "error", "-select_streams", "v:0",
+                "-show_entries", "stream=width,height",
+                "-of", "csv=s=x:p=0", playlist.toString()));
+        String[] parts = output.lines().findFirst().orElse("").split("x");
+        assertThat(parts).hasSize(2);
+        return new Dimensions(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
+    }
+
+    private String probeSampleAspectRatio(String ffprobe, Path playlist) throws Exception {
+        String output = runAndRead(List.of(
+                ffprobe, "-v", "error", "-select_streams", "v:0",
+                "-show_entries", "stream=sample_aspect_ratio",
+                "-of", "default=noprint_wrappers=1:nokey=1",
+                playlist.toString()));
+        return output.lines().findFirst().orElse("").trim();
+    }
+
+    private String runAndRead(List<String> command) throws Exception {
+        Process process = new ProcessBuilder(command).redirectErrorStream(true).start();
+        String output = new String(process.getInputStream().readAllBytes()).trim();
+        assertThat(process.waitFor(30, TimeUnit.SECONDS)).as("ffprobe 超时").isTrue();
+        assertThat(process.exitValue()).as("ffprobe 失败：%s", output).isZero();
+        return output;
+    }
+
    /** 在 PATH 里找可执行文件；找不到返回 null（由调用方 assume）。 */
    private String binaryPath(String name) {
        try {
@@ -122,4 +253,7 @@ class FfmpegTranscodeRunnerSmokeTest {
            // 同上
        }
    }
+
+    private record Dimensions(int width, int height) {
+    }
 }
@@ -9,6 +9,7 @@ import com.fruitshorts.media.dal.mapper.MediaAssetMapper;
 import com.fruitshorts.media.dal.mapper.MediaUploadTaskMapper;
 import com.fruitshorts.media.service.MediaService;
 import com.fruitshorts.media.service.MediaStorageService;
+import com.fruitshorts.media.service.EpisodeVideoSourcePort;
 import com.fruitshorts.media.service.TranscodeService;
 import com.fruitshorts.media.vo.TranscodeTriggerRespVO;
 import com.fruitshorts.media.vo.UploadCompleteReqVO;
@@ -16,6 +17,7 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

 import java.nio.file.Path;
+import java.util.Optional;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -33,12 +35,15 @@ import static org.mockito.Mockito.verify;
 class MediaServiceTranscodePipelineTest {

    private static final Long ASSET_ID = 88L;
+    private static final Long EPISODE_ID = 31L;
+    private static final Long DRAMA_ID = 7L;
    private static final String SOURCE_URL = "/files/episode/202610/video.mp4";

    private MediaAssetMapper mediaAssetMapper;
    private MediaUploadTaskMapper uploadTaskMapper;
    private MediaStorageService storageService;
    private TranscodeService transcodeService;
+    private EpisodeVideoSourcePort episodeVideoSourcePort;
    private MediaService mediaService;

    @BeforeEach
@@ -47,9 +52,10 @@ class MediaServiceTranscodePipelineTest {
        uploadTaskMapper = mock(MediaUploadTaskMapper.class);
        storageService = mock(MediaStorageService.class);
        transcodeService = mock(TranscodeService.class);
+        episodeVideoSourcePort = mock(EpisodeVideoSourcePort.class);
        mediaService = new MediaService(
                new MediaProperties(), storageService, mediaAssetMapper,
-                uploadTaskMapper, transcodeService);
+                uploadTaskMapper, transcodeService, episodeVideoSourcePort);
    }

    @Test
@@ -91,25 +97,44 @@ class MediaServiceTranscodePipelineTest {
        assertThatThrownBy(() -> mediaService.triggerTranscode(404L))
                .isInstanceOf(com.fruitshorts.common.exception.ServiceException.class)
                .hasMessage("媒资不存在");
-        verify(transcodeService, never()).trigger(any(), anyString());
+        verify(transcodeService, never()).trigger(
+                any(), anyString(), any(), any());
+        verify(episodeVideoSourcePort, never()).resolveByVideoUrl(anyString());
    }

    @Test
-    void should_trigger_transcode_and_mark_asset_queued() {
+    void should_bind_episode_by_video_url_before_triggering_transcode() {
        MediaAsset asset = asset("video.mp4");
        given(mediaAssetMapper.selectOne(any())).willReturn(asset);
-        given(transcodeService.trigger(ASSET_ID, SOURCE_URL))
+        given(episodeVideoSourcePort.resolveByVideoUrl(SOURCE_URL))
+                .willReturn(Optional.of(episodeSource()));
+        given(transcodeService.trigger(ASSET_ID, SOURCE_URL, DRAMA_ID, EPISODE_ID))
                .willReturn(new TranscodeTriggerRespVO(100L, TranscodeService.STATUS_QUEUED));

        TranscodeTriggerRespVO result = mediaService.triggerTranscode(ASSET_ID);

        assertThat(result.getTaskId()).isEqualTo(100L);
        assertThat(result.getStatus()).isEqualTo(TranscodeService.STATUS_QUEUED);
+        verify(episodeVideoSourcePort).link(EPISODE_ID, ASSET_ID);
        assertThat(asset.getStatus()).isEqualTo("transcoding");
        assertThat(asset.getTranscodeStatus()).isEqualTo(TranscodeService.STATUS_QUEUED);
        verify(mediaAssetMapper).updateById(asset);
    }

+    @Test
+    void should_reject_existing_media_when_no_episode_uses_video_url() {
+        MediaAsset asset = asset("video.mp4");
+        given(mediaAssetMapper.selectOne(any())).willReturn(asset);
+        given(episodeVideoSourcePort.resolveByVideoUrl(SOURCE_URL))
+                .willReturn(Optional.empty());
+
+        assertThatThrownBy(() -> mediaService.triggerTranscode(ASSET_ID))
+                .isInstanceOf(com.fruitshorts.common.exception.ServiceException.class)
+                .hasMessage("媒资未绑定分集视频");
+        verify(transcodeService, never()).trigger(
+                any(), anyString(), any(), any());
+    }
+
    private void givenCompletedUpload(String fileName) {
        String objectKey = "episode/202610/" + fileName;
        MediaUploadTask task = new MediaUploadTask();
@@ -143,4 +168,9 @@ class MediaServiceTranscodePipelineTest {
        asset.setStatus("uploaded");
        return asset;
    }
+
+    private EpisodeVideoSourcePort.EpisodeVideoSource episodeSource() {
+        return new EpisodeVideoSourcePort.EpisodeVideoSource(
+                EPISODE_ID, DRAMA_ID, ASSET_ID, SOURCE_URL, 120);
+    }
 }
@@ -20,7 +20,10 @@ import org.apache.ibatis.builder.MapperBuilderAssistant;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;

 import java.nio.file.Path;

@@ -38,6 +41,7 @@ import static org.mockito.Mockito.verify;
 * ① 认领任务靠状态条件更新，抢不到就是 null（多进程同时跑也只有一个能转）；
 * ② objectKey → 本地路径要挡住目录穿越。
 */
+@ExtendWith(OutputCaptureExtension.class)
 class TranscodeClaimAndStorageTest {

    /**
@@ -98,6 +102,10 @@ class TranscodeClaimAndStorageTest {

    @Test
    void should_exclude_unbound_queued_task_from_claim_query() {
+        TranscodeTask unbound = task(3L);
+        unbound.setMediaAssetId(88L);
+        unbound.setEpisodeId(0L);
+        given(transcodeTaskMapper.selectList(any())).willReturn(java.util.List.of(unbound));
        given(transcodeTaskMapper.selectOne(any())).willReturn(null);

        assertThat(transcodeService.claimNext()).isNull();
@@ -105,7 +113,23 @@ class TranscodeClaimAndStorageTest {
        @SuppressWarnings("unchecked")
        ArgumentCaptor<Wrapper<TranscodeTask>> captor = ArgumentCaptor.forClass(Wrapper.class);
        verify(transcodeTaskMapper).selectOne(captor.capture());
-        assertThat(captor.getValue().getSqlSegment()).contains("episode_id >");
+        assertThat(captor.getValue().getSqlSegment())
+                .contains("episode_id >")
+                .contains("media_asset_id >")
+                .contains("source_url");
+    }
+
+    @Test
+    void should_log_skip_reason_when_queued_task_has_no_episode(CapturedOutput output) {
+        TranscodeTask unbound = task(9L);
+        unbound.setMediaAssetId(88L);
+        unbound.setEpisodeId(0L);
+        given(transcodeTaskMapper.selectList(any())).willReturn(java.util.List.of(unbound));
+        given(transcodeTaskMapper.selectOne(any())).willReturn(null);
+
+        assertThat(transcodeService.claimNext()).isNull();
+
+        assertThat(output).contains("跳过转码任务 9").contains("episode_id");
    }

    @Test
@@ -175,6 +199,45 @@ class TranscodeClaimAndStorageTest {
        verify(transcodeTaskMapper).updateById(task);
    }

+    @Test
+    void should_delete_old_renditions_by_media_or_episode_before_insert() {
+        TranscodeTask task = task(6L);
+        task.setMediaAssetId(99L);
+        task.setEpisodeId(31L);
+        given(transcodeTaskMapper.selectById(6L)).willReturn(task);
+        MediaRendition rendition = new MediaRendition();
+        rendition.setQuality("360p");
+        rendition.setFormat("HLS");
+
+        transcodeService.succeed(6L, java.util.List.of(rendition));
+
+        verify(mediaRenditionMapper).deletePhysically(99L, 31L);
+        verify(mediaRenditionMapper).insert(rendition);
+    }
+
+    @Test
+    void should_replace_existing_thumbnail_by_episode_id() {
+        TranscodeTask task = task(7L);
+        task.setDramaId(7L);
+        task.setEpisodeId(31L);
+        MediaThumbnail existing = new MediaThumbnail();
+        existing.setId(70L);
+        existing.setEpisodeId(31L);
+        given(mediaThumbnailMapper.selectOne(any())).willReturn(existing);
+        MediaThumbnail thumbnail = new MediaThumbnail();
+        thumbnail.setEpisodeId(31L);
+        thumbnail.setStatus(MediaThumbnail.STATUS_READY);
+        ThumbnailRecordService recordService = new ThumbnailRecordService(mediaThumbnailMapper);
+
+        recordService.upsert(task, thumbnail);
+
+        @SuppressWarnings("unchecked")
+        ArgumentCaptor<Wrapper<MediaThumbnail>> captor = ArgumentCaptor.forClass(Wrapper.class);
+        verify(mediaThumbnailMapper).delete(captor.capture());
+        assertThat(captor.getValue().getSqlSegment()).containsIgnoringCase("episode_id");
+        verify(mediaThumbnailMapper).insert(thumbnail);
+    }
+
    @Test
    void should_reject_object_key_that_escapes_the_storage_root() {
        assertThatThrownBy(() -> storageService.fileFor("../../etc/passwd"))
@@ -3,6 +3,7 @@
 package com.fruitshorts.worker;

 import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
 import com.fruitshorts.media.dal.entity.MediaRendition;
 import com.fruitshorts.media.dal.entity.MediaThumbnail;
@@ -17,11 +18,14 @@ import org.apache.ibatis.builder.MapperBuilderAssistant;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Map;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -54,24 +58,22 @@ class TranscodeServiceTriggerTest {
    }

    @Test
-    void should_create_once_and_reuse_queued_task_when_retrying_successful_asset() {
+    void should_reset_completed_task_in_place_and_reuse_it_when_triggered_again() {
        TranscodeTask success = task(10L, TranscodeService.STATUS_SUCCESS);
        TranscodeTask queued = task(100L, TranscodeService.STATUS_QUEUED);
-        given(taskMapper.selectOne(any())).willReturn(success, null, queued);
-        doAnswer(invocation -> {
-            TranscodeTask inserted = invocation.getArgument(0);
-            inserted.setId(100L);
-            return 1;
-        }).when(taskMapper).insert(any(TranscodeTask.class));
+        queued.setId(10L);
+        given(taskMapper.selectOne(any())).willReturn(success, queued);
+        given(taskMapper.update(any(), any())).willReturn(1);

        TranscodeTriggerRespVO first = transcodeService.trigger(ASSET_ID, "/files/video.mp4");
        TranscodeTriggerRespVO second = transcodeService.trigger(ASSET_ID, "/files/video.mp4");

-        assertThat(first.getTaskId()).isEqualTo(100L);
+        assertThat(first.getTaskId()).isEqualTo(10L);
        assertThat(first.getStatus()).isEqualTo(TranscodeService.STATUS_QUEUED);
-        assertThat(second.getTaskId()).isEqualTo(100L);
+        assertThat(second.getTaskId()).isEqualTo(10L);
        assertThat(second.getStatus()).isEqualTo(TranscodeService.STATUS_QUEUED);
-        verify(taskMapper).insert(any(TranscodeTask.class));
+        verify(taskMapper, never()).insert(any(TranscodeTask.class));
+        verify(taskMapper, atLeastOnce()).update(any(), any());
    }

    @Test
@@ -111,17 +113,65 @@ class TranscodeServiceTriggerTest {
        TranscodeTask running = task(41L, TranscodeService.STATUS_RUNNING);
        running.setRetryCount(2);
        given(taskMapper.selectById(41L)).willReturn(running);
+        String longReason = "ffmpeg 输出异常：" + "x".repeat(5000);

-        String status = transcodeService.fail(
-                41L, "ffmpeg 退出码 1：Invalid data found");
+        String status = transcodeService.fail(41L, longReason);

        assertThat(status).isEqualTo(TranscodeService.STATUS_FAILED);
        assertThat(running.getStatus()).isEqualTo(TranscodeService.STATUS_FAILED);
        assertThat(running.getRetryCount()).isEqualTo(3);
-        assertThat(running.getErrorMsg()).contains("Invalid data found");
+        assertThat(running.getErrorMsg()).contains("ffmpeg 输出异常");
+        assertThat(running.getErrorMsg()).contains("truncated");
+        assertThat(running.getErrorMsg()).contains("total=" + longReason.length());
+        assertThat(running.getErrorMsg().length()).isLessThanOrEqualTo(500);
        verify(taskMapper).updateById(running);
    }

+    @Test
+    void should_update_progress_only_for_running_task() {
+        given(taskMapper.update(any(), any())).willReturn(1);
+
+        transcodeService.updateProgress(51L, 46);
+
+        verify(taskMapper).update(any(), any());
+    }
+
+    @Test
+    void should_mark_stale_running_task_failed() {
+        given(taskMapper.update(any(), any())).willReturn(2);
+
+        int recovered = transcodeService.recoverStaleRunningTasks();
+
+        assertThat(recovered).isEqualTo(2);
+        verify(taskMapper).update(any(), any());
+    }
+
+    @Test
+    void should_persist_failed_status_and_tail_when_fail_final_is_called() {
+        given(taskMapper.update(any(), any())).willReturn(1);
+        String reason = "ffmpeg output head: " + "x".repeat(1000)
+                + " UNIQUE_TAIL_DUPLICATE_KEY";
+
+        transcodeService.failFinal(61L, reason);
+
+        @SuppressWarnings("unchecked")
+        ArgumentCaptor<com.baomidou.mybatisplus.core.conditions.Wrapper<TranscodeTask>>
+                captor = ArgumentCaptor.forClass(
+                        com.baomidou.mybatisplus.core.conditions.Wrapper.class);
+        verify(taskMapper).update(any(), captor.capture());
+        @SuppressWarnings("unchecked")
+        LambdaUpdateWrapper<TranscodeTask> wrapper =
+                (LambdaUpdateWrapper<TranscodeTask>) captor.getValue();
+        assertThat(wrapper.getSqlSet())
+                .containsIgnoringCase("status")
+                .containsIgnoringCase("error_msg")
+                .containsIgnoringCase("finished_at");
+        Map<String, Object> params = wrapper.getParamNameValuePairs();
+        assertThat(params.values()).contains("FAILED");
+        assertThat(params.values())
+                .anyMatch(value -> String.valueOf(value).contains("UNIQUE_TAIL_DUPLICATE_KEY"));
+    }
+
    private TranscodeTask task(Long id, String status) {
        TranscodeTask task = new TranscodeTask();
        task.setId(id);
@@ -15,7 +15,10 @@ import com.fruitshorts.media.service.transcode.TranscodeRunner;
 import com.fruitshorts.media.service.transcode.TranscodeWorker;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;

 import java.nio.file.Paths;
 import java.util.List;
@@ -28,6 +31,7 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.verify;

 /**
@@ -35,6 +39,7 @@ import static org.mockito.Mockito.verify;
 *
 * <p>用替身 `TranscodeRunner`，所以**不依赖 ffmpeg**；真实 ffmpeg 的验证在 ffmpeg smoke 测试里。
 */
+@ExtendWith(OutputCaptureExtension.class)
 class TranscodeWorkerTest {

    private static final Long TASK_ID = 88L;
@@ -72,6 +77,7 @@ class TranscodeWorkerTest {
    @Test
    void should_register_renditions_and_mark_asset_ready_when_transcode_succeeds() {
        given(transcodeService.claimNext()).willReturn(queuedTask());
+        runner.progress = 45;

        assertThat(worker.processOne()).isTrue();

@@ -92,6 +98,7 @@ class TranscodeWorkerTest {
                eq("/files/transcoded/88/poster.jpg"), eq(120));
        verify(episodeCompletionPort).markEpisodeReady(
                12L, "/files/transcoded/88/master.m3u8", 120);
+        verify(transcodeService).updateProgress(TASK_ID, 45);
        verify(transcodeService, never()).fail(any(), anyString());
    }

@@ -110,11 +117,12 @@ class TranscodeWorkerTest {
    @Test
    void should_keep_main_transcode_successful_when_thumbnail_generation_fails() {
        given(transcodeService.claimNext()).willReturn(queuedTask());
+        String thumbnailError = "tile 滤镜失败：" + "x".repeat(5000);
        runner.thumbnail = new TranscodeRunner.ProducedThumbnail(
                "transcoded/88/thumbnails/thumbnails.vtt",
                "transcoded/88/thumbnails/sprite_",
                1, 10, 1, 160, 0, 120, 120, 0L,
-                MediaThumbnail.STATUS_FAILED, "tile 滤镜失败");
+                MediaThumbnail.STATUS_FAILED, thumbnailError);

        worker.processOne();

@@ -128,38 +136,50 @@ class TranscodeWorkerTest {
        assertThat(thumbnail.getValue().getStatus())
                .isEqualTo(MediaThumbnail.STATUS_FAILED);
        assertThat(thumbnail.getValue().getErrorMsg()).contains("tile");
+        assertThat(thumbnail.getValue().getErrorMsg()).contains("truncated");
+        assertThat(thumbnail.getValue().getErrorMsg().length()).isLessThanOrEqualTo(500);
        verify(mediaService).markReady(eq(ASSET_ID), anyString(), anyString(), eq(120));
        verify(transcodeService, never()).fail(any(), anyString());
    }

    @Test
-    void should_keep_task_queued_and_record_reason_when_transcode_fails_before_max_retry() {
+    void should_mark_task_failed_immediately_when_transcode_fails() {
        TranscodeTask task = queuedTask();
        task.setRetryCount(1);
        given(transcodeService.claimNext()).willReturn(task);
-        given(transcodeService.fail(eq(TASK_ID), anyString())).willReturn(TranscodeService.STATUS_QUEUED);
        runner.failure = new IllegalStateException("ffmpeg 退出码 1：Invalid data found");

        worker.processOne();

-        verify(transcodeService).fail(eq(TASK_ID), contains("Invalid data found"));
-        // 还会重试，所以媒资不能置 failed（仍期待下一次成功）
-        verify(mediaService, never()).markFailed(any(), anyString());
+        verify(transcodeService).failFinal(eq(TASK_ID), contains("Invalid data found"));
+        verify(mediaService).markFailed(eq(ASSET_ID), contains("Invalid data found"));
        verify(mediaService, never()).markReady(any(), anyString(), anyString(), any());
    }

    @Test
-    void should_mark_asset_failed_when_retries_are_exhausted() {
+    void should_mark_asset_failed_when_rendition_write_throws_duplicate_key() {
        TranscodeTask task = queuedTask();
-        task.setRetryCount(2);
        given(transcodeService.claimNext()).willReturn(task);
-        given(transcodeService.fail(eq(TASK_ID), anyString())).willReturn(TranscodeService.STATUS_FAILED);
-        runner.failure = new IllegalStateException("ffmpeg 未产出播放列表");
+        doThrow(new IllegalStateException(
+                "duplicate key uk_rendition"))
+                .when(transcodeService).succeed(eq(TASK_ID), any(), any());

        worker.processOne();

-        verify(transcodeService).fail(eq(TASK_ID), contains("未产出播放列表"));
-        verify(mediaService).markFailed(eq(ASSET_ID), contains("未产出播放列表"));
+        verify(transcodeService).failFinal(eq(TASK_ID), contains("uk_rendition"));
+        verify(mediaService).markFailed(eq(ASSET_ID), contains("uk_rendition"));
+    }
+
+    @Test
+    void should_log_error_without_escaping_when_failure_persistence_throws(CapturedOutput output) {
+        given(transcodeService.claimNext()).willReturn(queuedTask());
+        runner.failure = new IllegalStateException("ffmpeg failed");
+        doThrow(new IllegalStateException("database unavailable"))
+                .when(transcodeService).failFinal(eq(TASK_ID), anyString());
+
+        worker.processOne();
+
+        assertThat(output).contains("失败状态落库失败").contains("database unavailable");
    }

    @Test
@@ -170,7 +190,7 @@ class TranscodeWorkerTest {
        assertThat(worker.processOne()).isFalse();
        assertThat(runner.called).isFalse();
        verify(transcodeService, never()).succeed(any(), any());
-        verify(transcodeService, never()).fail(any(), anyString());
+        verify(transcodeService, never()).failFinal(any(), anyString());
    }

    private TranscodeTask queuedTask() {
@@ -190,12 +210,16 @@ class TranscodeWorkerTest {
        private TranscodeRequest request;
        private RuntimeException failure;
        private ProducedThumbnail thumbnail;
+        private Integer progress;
        private boolean called;

        @Override
        public TranscodeResult run(TranscodeRequest request) {
            this.request = request;
            this.called = true;
+            if (progress != null) {
+                request.progressListener().accept(progress);
+            }
            if (failure != null) {
                throw failure;
            }
@@ -57,6 +57,8 @@ INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, r
  (5,  3, '剧集管理',      'episodes',   'episodes',    'views/contentManagement/EpisodeManagementView', '',                 '',                            'episode:list',     'MENU',    0, 0, 2),
  (12, 3, '轮播图管理',    'banners',    'banners',     'views/contentManagement/BannerManagementView',  '',                 '',                            'banner:list',      'MENU',    0, 0, 3),
  (13, 3, '类型管理',      'categories', 'categories',  'views/contentManagement/CategoryManagementView','',                 '',                            'drama:list',       'MENU',    0, 0, 4),
+  (36, 3, '分类管理',      'category-dramas','category-dramas','views/contentManagement/CategoryDramaView', '',                 '',                            'drama:list',       'MENU',    0, 0, 5),
+  (37, 3, '剧单管理',      'drama-playlists','drama-playlists','views/contentManagement/DramaPlaylistView', '',                 '',                            'drama:list',       'MENU',    0, 0, 6),
  (6,  0, '后台管理',      '/system',    'System',      '#',                                            '/system/access',   'material-symbols:settings-rounded', 'system:role',      'CATALOG', 1, 0, 3),
  (7,  6, '角色权限配置',  'access',     'access',      'views/permission/RoleManagementView',           '',                 '',                            'system:role',      'MENU',    0, 0, 1),
  (8,  6, '管理员用户列表','admin-users','admin-users', 'views/userManagement/AdminUsersView',           '',                 '',                            'system:admin-user','MENU',    0, 0, 2),
@@ -77,9 +79,17 @@ ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.
  redirect = EXCLUDED.redirect, icon = EXCLUDED.icon, permission_code = EXCLUDED.permission_code,
  type = EXCLUDED.type, always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;

+-- 转码设置菜单（挂在后台管理下，仅超级管理员可见）
+INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, redirect, icon,
+                      permission_code, type, always_show, affix, sort) VALUES
+  (35, 6, '转码设置', 'transcode-settings', 'transcode-settings', 'views/systemManagement/TranscodeSettingsView', '', '', 'episode:upload', 'MENU', 0, 0, 7)
+ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.title,
+  route_path = EXCLUDED.route_path, route_name = EXCLUDED.route_name, component = EXCLUDED.component,
+  redirect = EXCLUDED.redirect, icon = EXCLUDED.icon, permission_code = EXCLUDED.permission_code,
+  type = EXCLUDED.type, always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;
+
 -- K23：二级菜单统一只显示文字，历史图标值也一并清空。
 UPDATE sys_menu SET icon = '' WHERE type = 'MENU';
-
 -- ---------- 角色-权限 ----------
 INSERT INTO sys_role_permission (id, role_id, permission_id)
 SELECT r.id * 1000000 + p.id, r.id, p.id FROM sys_role r CROSS JOIN sys_permission p WHERE r.code = 'super_admin'
@@ -112,7 +122,7 @@ ON CONFLICT DO NOTHING;

 INSERT INTO sys_role_menu (id, role_id, menu_id)
 SELECT r.id * 1000000 + m.id, r.id, m.id FROM sys_role r CROSS JOIN sys_menu m
-WHERE r.code IN ('content_operator','content_reviewer','data_analyst') AND m.id IN (1,2,3,4,5,12,13)
+WHERE r.code IN ('content_operator','content_reviewer','data_analyst') AND m.id IN (1,2,3,4,5,12,13,36,37)
 ON CONFLICT DO NOTHING;

 -- ---------- 管理员（密码均为 admin123） ----------
@@ -0,0 +1,21 @@
+-- Author: fruit.com.cn
+-- 后台「分类管理」菜单与分类-短剧关联页（幂等，仅提交文件，由发布流程执行）
+
+INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, redirect, icon,
+                      permission_code, type, always_show, affix, sort) VALUES
+  (36, 3, '分类管理', 'category-dramas', 'category-dramas',
+   'views/contentManagement/CategoryDramaView', '', '',
+   'drama:list', 'MENU', 0, 0, 5)
+ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.title,
+  route_path = EXCLUDED.route_path, route_name = EXCLUDED.route_name,
+  component = EXCLUDED.component, redirect = EXCLUDED.redirect, icon = EXCLUDED.icon,
+  permission_code = EXCLUDED.permission_code, type = EXCLUDED.type,
+  always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;
+
+INSERT INTO sys_role_menu (id, role_id, menu_id)
+SELECT r.id * 1000000 + m.id, r.id, m.id
+FROM sys_role r
+CROSS JOIN sys_menu m
+WHERE r.code IN ('super_admin', 'content_operator', 'content_reviewer', 'data_analyst')
+  AND m.id = 36
+ON CONFLICT DO NOTHING;
@@ -0,0 +1,31 @@
+-- Author: fruit.com.cn
+-- 运营分类（与「类型」drama_category 是两个概念）：分类可自定义增删，并关联多部短剧
+-- 幂等，仅提交文件，由发布流程执行
+
+CREATE TABLE IF NOT EXISTS drama_classification (
+  id         BIGINT PRIMARY KEY,
+  name       VARCHAR(64) NOT NULL,
+  sort       INTEGER     NOT NULL DEFAULT 0,
+  status     SMALLINT    NOT NULL DEFAULT 1,
+  created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_drama_classification_name ON drama_classification (name);
+COMMENT ON TABLE drama_classification IS '运营分类；与短剧类型(drama_category)相互独立';
+
+CREATE TABLE IF NOT EXISTS drama_classification_drama (
+  id                BIGINT PRIMARY KEY,
+  classification_id BIGINT NOT NULL,
+  drama_id          BIGINT NOT NULL,
+  created_at        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_classification_drama
+  ON drama_classification_drama (classification_id, drama_id);
+CREATE INDEX IF NOT EXISTS idx_classification_drama_drama
+  ON drama_classification_drama (drama_id);
+COMMENT ON TABLE drama_classification_drama IS '分类与短剧的关联关系';
+
+DROP TRIGGER IF EXISTS trg_drama_classification_updated_at ON drama_classification;
+CREATE TRIGGER trg_drama_classification_updated_at
+  BEFORE UPDATE ON drama_classification
+  FOR EACH ROW EXECUTE FUNCTION set_updated_at();
@@ -0,0 +1,21 @@
+-- Author: fruit.com.cn
+-- 后台「剧单管理」菜单（幂等，仅提交文件，由发布流程执行）
+
+INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, redirect, icon,
+                      permission_code, type, always_show, affix, sort) VALUES
+  (37, 3, '剧单管理', 'drama-playlists', 'drama-playlists',
+   'views/contentManagement/DramaPlaylistView', '', '',
+   'drama:list', 'MENU', 0, 0, 6)
+ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.title,
+  route_path = EXCLUDED.route_path, route_name = EXCLUDED.route_name,
+  component = EXCLUDED.component, redirect = EXCLUDED.redirect, icon = EXCLUDED.icon,
+  permission_code = EXCLUDED.permission_code, type = EXCLUDED.type,
+  always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;
+
+INSERT INTO sys_role_menu (id, role_id, menu_id)
+SELECT r.id * 1000000 + m.id, r.id, m.id
+FROM sys_role r
+CROSS JOIN sys_menu m
+WHERE r.code IN ('super_admin', 'content_operator', 'content_reviewer', 'data_analyst')
+  AND m.id = 37
+ON CONFLICT DO NOTHING;
@@ -0,0 +1,31 @@
+-- Author: fruit.com.cn
+-- 剧单：运营编排的短剧集合，归属某个分类，并可关联多部短剧
+-- 幂等，仅提交文件，由发布流程执行
+
+CREATE TABLE IF NOT EXISTS drama_playlist (
+  id                BIGINT PRIMARY KEY,
+  classification_id BIGINT      NOT NULL DEFAULT 0,
+  name              VARCHAR(64) NOT NULL,
+  sort              INTEGER     NOT NULL DEFAULT 0,
+  status            SMALLINT    NOT NULL DEFAULT 1,
+  created_at        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_drama_playlist_name ON drama_playlist (name);
+CREATE INDEX IF NOT EXISTS idx_drama_playlist_classification ON drama_playlist (classification_id);
+COMMENT ON TABLE drama_playlist IS '剧单；归属分类，可关联多部短剧';
+
+CREATE TABLE IF NOT EXISTS drama_playlist_drama (
+  id          BIGINT PRIMARY KEY,
+  playlist_id BIGINT NOT NULL,
+  drama_id    BIGINT NOT NULL,
+  created_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_playlist_drama ON drama_playlist_drama (playlist_id, drama_id);
+CREATE INDEX IF NOT EXISTS idx_playlist_drama_drama ON drama_playlist_drama (drama_id);
+COMMENT ON TABLE drama_playlist_drama IS '剧单与短剧的关联关系';
+
+DROP TRIGGER IF EXISTS trg_drama_playlist_updated_at ON drama_playlist;
+CREATE TRIGGER trg_drama_playlist_updated_at
+  BEFORE UPDATE ON drama_playlist
+  FOR EACH ROW EXECUTE FUNCTION set_updated_at();
@@ -0,0 +1,18 @@
+-- Author: fruit.com.cn
+-- 剧单分类直接关联短剧（不再有「剧单」这一层）
+-- 幂等，仅提交文件，由发布流程执行
+
+CREATE TABLE IF NOT EXISTS drama_playlist_category_drama (
+  id          BIGINT PRIMARY KEY,
+  category_id BIGINT NOT NULL,
+  drama_id    BIGINT NOT NULL,
+  created_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_playlist_category_drama
+  ON drama_playlist_category_drama (category_id, drama_id);
+CREATE INDEX IF NOT EXISTS idx_playlist_category_drama_drama
+  ON drama_playlist_category_drama (drama_id);
+COMMENT ON TABLE drama_playlist_category_drama IS '剧单分类与短剧的关联关系';
+
+DROP TABLE IF EXISTS drama_playlist_drama;
+DROP TABLE IF EXISTS drama_playlist;
@@ -0,0 +1,31 @@
+-- Author: fruit.com.cn
+-- 剧单专属分类（与「分类管理」的运营分类无关），并调整剧单归属字段
+-- 幂等，仅提交文件，由发布流程执行
+
+CREATE TABLE IF NOT EXISTS drama_playlist_category (
+  id         BIGINT PRIMARY KEY,
+  name       VARCHAR(64) NOT NULL,
+  sort       INTEGER     NOT NULL DEFAULT 0,
+  status     SMALLINT    NOT NULL DEFAULT 1,
+  created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_drama_playlist_category_name
+  ON drama_playlist_category (name);
+COMMENT ON TABLE drama_playlist_category IS '剧单专属分类；与运营分类(drama_classification)相互独立';
+
+ALTER TABLE drama_playlist DROP COLUMN IF EXISTS classification_id;
+ALTER TABLE drama_playlist ADD COLUMN IF NOT EXISTS playlist_category_id BIGINT NOT NULL DEFAULT 0;
+CREATE INDEX IF NOT EXISTS idx_drama_playlist_category
+  ON drama_playlist (playlist_category_id);
+COMMENT ON COLUMN drama_playlist.playlist_category_id IS '剧单分类；0 表示未分类';
+
+DROP TRIGGER IF EXISTS trg_drama_playlist_category_updated_at ON drama_playlist_category;
+CREATE TRIGGER trg_drama_playlist_category_updated_at
+  BEFORE UPDATE ON drama_playlist_category
+  FOR EACH ROW EXECUTE FUNCTION set_updated_at();
+-- Author: fruit.com.cn
+-- 剧单分类增加描述字段（幂等）
+
+ALTER TABLE drama_playlist_category ADD COLUMN IF NOT EXISTS description VARCHAR(255) NOT NULL DEFAULT '';
+COMMENT ON COLUMN drama_playlist_category.description IS '分类描述';
@@ -0,0 +1,12 @@
+-- Author: fruit.com.cn
+-- 扩展转码错误信息列，允许保留 ffmpeg / ffprobe 关键错误上下文（可重复执行）
+
+BEGIN;
+
+ALTER TABLE IF EXISTS transcode_task
+  ALTER COLUMN error_msg TYPE TEXT USING error_msg::TEXT;
+
+ALTER TABLE IF EXISTS media_thumbnail
+  ALTER COLUMN error_msg TYPE TEXT USING error_msg::TEXT;
+
+COMMIT;
@@ -0,0 +1,20 @@
+-- Author: fruit.com.cn
+-- 后台「转码设置」独立菜单（幂等，仅提交文件，由发布流程执行）
+
+INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, redirect, icon,
+                      permission_code, type, always_show, affix, sort) VALUES
+  (35, 6, '转码设置', 'transcode-settings', 'transcode-settings',
+   'views/systemManagement/TranscodeSettingsView', '', '',
+   'episode:upload', 'MENU', 0, 0, 7)
+ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.title,
+  route_path = EXCLUDED.route_path, route_name = EXCLUDED.route_name,
+  component = EXCLUDED.component, redirect = EXCLUDED.redirect, icon = EXCLUDED.icon,
+  permission_code = EXCLUDED.permission_code, type = EXCLUDED.type,
+  always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;
+
+INSERT INTO sys_role_menu (id, role_id, menu_id)
+SELECT r.id * 1000000 + m.id, r.id, m.id
+FROM sys_role r
+CROSS JOIN sys_menu m
+WHERE r.code = 'super_admin' AND m.id = 35
+ON CONFLICT DO NOTHING;
@@ -0,0 +1,22 @@
+-- Author: fruit.com.cn
+-- 收口未绑定分集或媒资不存在的僵尸转码任务（可重复执行）
+
+BEGIN;
+
+UPDATE transcode_task t
+SET status = 'FAILED',
+    error_msg = '历史任务无效：episode_id=0 或 media_asset_id 指向不存在的媒资，请从有视频的分集重新转码',
+    finished_at = CURRENT_TIMESTAMP
+WHERE t.deleted = 0
+  AND t.status IN ('QUEUED', 'RUNNING')
+  AND (
+    t.episode_id = 0
+    OR NOT EXISTS (
+      SELECT 1
+      FROM media_asset a
+      WHERE a.id = t.media_asset_id
+        AND a.deleted = 0
+    )
+  );
+
+COMMIT;
@@ -0,0 +1,40 @@
+-- Author: fruit.com.cn
+-- 服务条款与隐私协议：三语正文 + 后台菜单
+
+CREATE TABLE IF NOT EXISTS legal_document (
+  id         BIGINT PRIMARY KEY,
+  doc_code   VARCHAR(16)  NOT NULL,
+  lang       VARCHAR(8)   NOT NULL,
+  title      VARCHAR(128) NOT NULL DEFAULT '',
+  content    TEXT         NOT NULL DEFAULT '',
+  updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_legal_document_code_lang ON legal_document (doc_code, lang);
+COMMENT ON TABLE legal_document IS '服务条款与隐私协议';
+
+INSERT INTO legal_document (id, doc_code, lang, title, content) VALUES
+  (910001, 'terms', 'zh', '', '本页由水果短剧发布，可在管理后台用 Markdown 修改。'),
+  (910002, 'terms', 'en', '', 'This page is published by FruitShorts and can be edited as Markdown in the admin console.'),
+  (910003, 'terms', 'id', '', 'Halaman ini dipublikasikan oleh FruitShorts dan dapat diubah sebagai Markdown di konsol admin.'),
+  (910004, 'privacy', 'zh', '', '本页由水果短剧发布，可在管理后台用 Markdown 修改。'),
+  (910005, 'privacy', 'en', '', 'This page is published by FruitShorts and can be edited as Markdown in the admin console.'),
+  (910006, 'privacy', 'id', '', 'Halaman ini dipublikasikan oleh FruitShorts dan dapat diubah sebagai Markdown di konsol admin.')
+ON CONFLICT (doc_code, lang) DO NOTHING;
+
+INSERT INTO sys_menu (id, parent_id, title, route_path, route_name, component, redirect, icon,
+                      permission_code, type, always_show, affix, sort) VALUES
+  (38, 6, '协议设置', 'legal-documents', 'legal-documents',
+   'views/systemManagement/LegalDocumentView', '', '',
+   'system:role', 'MENU', 0, 0, 8)
+ON CONFLICT (id) DO UPDATE SET parent_id = EXCLUDED.parent_id, title = EXCLUDED.title,
+  route_path = EXCLUDED.route_path, route_name = EXCLUDED.route_name,
+  component = EXCLUDED.component, redirect = EXCLUDED.redirect, icon = EXCLUDED.icon,
+  permission_code = EXCLUDED.permission_code, type = EXCLUDED.type,
+  always_show = EXCLUDED.always_show, affix = EXCLUDED.affix, sort = EXCLUDED.sort;
+
+INSERT INTO sys_role_menu (id, role_id, menu_id)
+SELECT r.id * 1000000 + m.id, r.id, m.id
+FROM sys_role r
+CROSS JOIN sys_menu m
+WHERE r.code = 'super_admin' AND m.id = 38
+ON CONFLICT DO NOTHING;
@@ -869,9 +869,64 @@ CREATE INDEX IF NOT EXISTS idx_audit_log_biz ON audit_log (biz_type, biz_id, cre
 COMMENT ON TABLE audit_log IS '业务对象变更审计（支付、权益、定价等敏感操作）';

 -- ============================================================
-- 九、updated_at 触发器（与已有表保持一致）
+-- 八之二、运营分类（与短剧类型 drama_category 相互独立）
 -- ============================================================

+CREATE TABLE IF NOT EXISTS drama_classification (
+  id         BIGINT PRIMARY KEY,
+  name       VARCHAR(64) NOT NULL,
+  sort       INTEGER     NOT NULL DEFAULT 0,
+  status     SMALLINT    NOT NULL DEFAULT 1,
+  created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_drama_classification_name ON drama_classification (name);
+COMMENT ON TABLE drama_classification IS '运营分类；与短剧类型(drama_category)相互独立';
+
+CREATE TABLE IF NOT EXISTS drama_classification_drama (
+  id                BIGINT PRIMARY KEY,
+  classification_id BIGINT NOT NULL,
+  drama_id          BIGINT NOT NULL,
+  created_at        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_classification_drama
+  ON drama_classification_drama (classification_id, drama_id);
+CREATE INDEX IF NOT EXISTS idx_classification_drama_drama
+  ON drama_classification_drama (drama_id);
+COMMENT ON TABLE drama_classification_drama IS '分类与短剧的关联关系';
+
+-- ============================================================
+-- 八之三、剧单（剧单有自己的一套分类，与运营分类无关）
+-- ============================================================
+
+CREATE TABLE IF NOT EXISTS drama_playlist_category (
+  id          BIGINT PRIMARY KEY,
+  name        VARCHAR(64)  NOT NULL,
+  description VARCHAR(255) NOT NULL DEFAULT '',
+  sort        INTEGER      NOT NULL DEFAULT 0,
+  status      SMALLINT     NOT NULL DEFAULT 1,
+  created_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_drama_playlist_category_name
+  ON drama_playlist_category (name);
+COMMENT ON TABLE drama_playlist_category IS '剧单专属分类；与运营分类(drama_classification)相互独立';
+
+CREATE TABLE IF NOT EXISTS drama_playlist_category_drama (
+  id          BIGINT PRIMARY KEY,
+  category_id BIGINT NOT NULL,
+  drama_id    BIGINT NOT NULL,
+  created_at  TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_playlist_category_drama
+  ON drama_playlist_category_drama (category_id, drama_id);
+CREATE INDEX IF NOT EXISTS idx_playlist_category_drama_drama
+  ON drama_playlist_category_drama (drama_id);
+COMMENT ON TABLE drama_playlist_category_drama IS '剧单分类与短剧的关联关系';
+
+-- ============================================================
+-- 九、updated_at 触发器（与已有表保持一致）
+-- ============================================================
 DO $$
 DECLARE
  t TEXT;
@@ -885,6 +940,8 @@ BEGIN
    'reconcile_task', 'creator', 'creator_document', 'content_submission',
    'creator_stat_daily', 'creator_settlement',
    'transcode_task', 'media_rendition', 'media_thumbnail',
+    'drama_classification',
+    'drama_playlist_category',
    'ops_notice', 'ops_daily_stat'
  ]
  LOOP
@@ -127,6 +127,17 @@ CREATE TABLE IF NOT EXISTS sys_config (
 CREATE UNIQUE INDEX IF NOT EXISTS uk_sys_config_key ON sys_config (config_key);
 COMMENT ON TABLE sys_config IS '系统配置';

+CREATE TABLE IF NOT EXISTS legal_document (
+  id         BIGINT PRIMARY KEY,
+  doc_code   VARCHAR(16)  NOT NULL,              -- terms / privacy
+  lang       VARCHAR(8)   NOT NULL,              -- zh / en / id
+  title      VARCHAR(128) NOT NULL DEFAULT '',
+  content    TEXT         NOT NULL DEFAULT '',
+  updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_legal_document_code_lang ON legal_document (doc_code, lang);
+COMMENT ON TABLE legal_document IS '服务条款与隐私协议';
+
 CREATE TABLE IF NOT EXISTS sys_operation_log (
  id            BIGINT PRIMARY KEY,
  admin_user_id BIGINT       NOT NULL DEFAULT 0,
Author	SHA1	Message	Date
Zhou Weidong	df2da25833	chore(merge): 合并用户系统协议与播放改动	2026-10-23 12:34:26 +08:00
Zhou Weidong	1ea4cfeba3	test(media): 按物理删除校验重转码清理	2026-10-23 12:34:13 +08:00
Zhou Weidong	ce6e3ef70a	docs(api): 同步搜索协议播放与收藏契约	2026-10-23 12:34:13 +08:00
Zhou Weidong	87e20c31a9	feat(security): 允许匿名搜索与打开协议页	2026-10-23 12:34:13 +08:00
Zhou Weidong	22edf34ff1	feat(system): 支持后台维护三语协议	2026-10-23 12:34:13 +08:00
Zhou Weidong	16ba79a336	feat(interaction): 支持批量取消收藏	2026-10-23 12:34:13 +08:00
Zhou Weidong	9c25b1b397	fix(playback): 恢复已删除的观看进度	2026-10-23 12:34:13 +08:00
Zhou Weidong	5a80e6693f	feat(playback): 播放票据返回各清晰度地址	2026-10-23 12:34:13 +08:00
Zhou Weidong	ab58641bbe	feat(user): 展示用户最近使用的系统	2026-10-23 12:34:13 +08:00
Zhou Weidong	45e3d84f59	docs(api): 补充分类与剧单管理接口文档	2026-10-22 22:17:58 +08:00
Zhou Weidong	a3ff636e45	chore(sql): 补充转码设置菜单初始化补丁	2026-10-22 22:17:58 +08:00
Zhou Weidong	7b360ddccd	feat(content): 新增运营分类与剧单分类管理	2026-10-22 22:17:58 +08:00
Zhou Weidong	758c7521bb	Merge remote-tracking branch 'origin/develop' into develop	2026-10-22 18:21:05 +08:00
Zhou Weidong	e730cfaa7d	fix(media): 重转码物理清理旧产物避免唯一键冲突	2026-10-22 18:21:00 +08:00
Zhou Weidong	60a87a8d15	docs(client): 回填首页与我的视觉改版记录	2026-10-22 17:08:05 +08:00
Zhou Weidong	0b519b8ca1	docs(nav): 回填客户端四 Tab 导航记录	2026-10-22 16:22:07 +08:00
Zhou Weidong	e6b4a747ce	merge: 修复转码 rendition 幂等与失败落库	2026-10-22 15:37:01 +08:00
Zhou Weidong	f009f75c03	docs(media): 回填转码修复记录	2026-10-22 15:36:51 +08:00
Zhou Weidong	91b621fe75	fix(media): 清理旧 rendition 并确保失败状态落库	2026-10-22 15:36:35 +08:00
Zhou Weidong	5d1a157085	merge: 修复转码任务认领与媒资校验	2026-10-22 15:27:58 +08:00
Zhou Weidong	5552caa6c1	fix(media): 修正转码任务认领与媒资 id 校验	2026-10-22 15:27:51 +08:00
Zhou Weidong	ad84704d28	test(media): 覆盖转码认领与非法媒资 id	2026-10-22 15:27:37 +08:00
Zhou Weidong	08eddc9ed2	merge: 修复转码错误截断与进度上报	2026-10-22 15:13:50 +08:00
Zhou Weidong	660afaf66d	fix(media): 转码错误信息截断并上报进度	2026-10-22 15:12:05 +08:00
Zhou Weidong	f9bc6eee6d	merge: 修复转码媒资 id 精度与存量兜底	2026-10-22 14:59:46 +08:00
Zhou Weidong	5ef5dd8eaf	fix(media): 修正转码媒资 id 解析与存量分集补登记	2026-10-22 14:59:16 +08:00
Zhou Weidong	a35b02dd18	merge: 修复转码保持原始宽高比	2026-10-22 14:31:30 +08:00
Zhou Weidong	04d25cd23d	fix(media): 转码按短边等比定档并回写实际尺寸	2026-10-22 14:31:22 +08:00
Zhou Weidong	217ff24f1c	test(media): 覆盖转码保持原始宽高比	2026-10-22 14:30:08 +08:00