From d6cb68cf134a612d5d8e4f02d1fb5cc24278e809 Mon Sep 17 00:00:00 2001
From: suzmii <suzmii@qq.com>
Date: Thu, 13 Aug 2026 01:05:57 +0800
Subject: [PATCH] =?UTF-8?q?Spine=E5=BA=8F=E5=88=97=E5=B8=A7=E4=BF=AE?=
 =?UTF-8?q?=E5=A4=8D=E4=B8=8E=E5=8A=9F=E8=83=BD=E6=94=B6=E7=B4=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../shared-memory/decision-log.md             |    7 +
 ...‘ArtAgent多模æ€�Spineåº�列帧动画生æˆ�-2026-08-10.md |   58 +-
 ...‰²è§„范到多视角图集拆分与动画生æˆ�æµ�程-2026-08-12.md |   38 +-
 server-rs/crates/api-server/src/app.rs        |   23 +
 .../crates/api-server/src/asset_billing.rs    |    2 +-
 .../src/character_animation_assets.rs         | 1771 ++++++++++++++++-
 .../api-server/src/editor_agent/tool.rs       |    3 -
 .../api-server/src/editor_generation_queue.rs |    4 +
 .../crates/api-server/src/editor_project.rs   |  135 +-
 .../api-server/src/editor_project_icon.rs     |   51 +-
 .../src/editor_sequence_animation.rs          |  232 ++-
 .../api-server/src/external_editor_api.rs     |   23 +
 .../src/external_generation_worker.rs         |   66 +-
 .../src/modules/platform_support.rs           |   21 +-
 server-rs/crates/platform-oss/src/lib.rs      |   51 +
 .../crates/shared-contracts/src/assets.rs     |  155 ++
 .../src/editor_project_storage.rs             |   72 +-
 ...CanvasCharacterAnimationPanelView.test.tsx |    1 +
 ...asCharacterGenerationComposerView.test.tsx |   51 +-
 ...eCanvasCharacterGenerationComposerView.tsx |  126 +-
 .../ImageCanvasContextMenusView.test.tsx      |   20 +-
 .../ImageCanvasContextMenusView.tsx           |   26 -
 ...CanvasEditorGenerationIntegration.test.tsx |   35 +-
 .../ImageCanvasEditorModel.test.ts            |  191 ++
 .../image-editor/ImageCanvasEditorModel.ts    |   99 +-
 .../ImageCanvasEditorShellView.test.tsx       |    2 +-
 .../image-editor/ImageCanvasEditorTypes.ts    |   22 +-
 .../image-editor/ImageCanvasEditorView.tsx    |   15 +-
 .../image-editor/ImageCanvasExportModel.ts    |    2 +-
 ...ImageCanvasGenerationComposerView.test.tsx |  184 ++
 .../ImageCanvasGenerationComposerView.tsx     |  513 +++--
 .../ImageCanvasGenerationDialogModel.test.ts  |  166 +-
 .../ImageCanvasGenerationDialogModel.ts       |  213 +-
 .../ImageCanvasGenerationImageOptionsView.tsx |   35 +-
 .../ImageCanvasGenerationInputsModel.ts       |    2 +
 .../ImageCanvasGenerationLayerModel.test.ts   |   60 +-
 .../ImageCanvasGenerationLayerModel.ts        |   23 +-
 .../ImageCanvasGenerationModel.test.ts        |   85 +
 .../ImageCanvasGenerationModel.ts             |   75 +-
 ...ageCanvasGenerationSubmissionModel.test.ts |   31 +-
 .../ImageCanvasGenerationSubmissionModel.ts   |    9 +-
 .../image-editor/ImageCanvasReferenceSlot.tsx |   11 +-
 ...ageCanvasSelectedLayerToolbarView.test.tsx |   37 +-
 .../ImageCanvasSelectedLayerToolbarView.tsx   |  117 +-
 .../image-editor/ImageCanvasStageView.tsx     |   15 +-
 .../ImageCanvasUploadModel.test.ts            |   55 +
 .../image-editor/ImageCanvasUploadModel.ts    |   31 +-
 ...anvasGenerationSubmissionWorkflow.test.tsx |  169 ++
 ...ImageCanvasGenerationSubmissionWorkflow.ts |  170 +-
 .../useImageCanvasGenerationSurface.test.tsx  |   44 +-
 .../useImageCanvasGenerationSurface.tsx       |   23 +-
 .../useImageCanvasGenerationWorkflow.test.tsx |  101 +-
 .../useImageCanvasGenerationWorkflow.ts       |  155 +-
 src/index.css                                 |   82 +-
 .../image-editor/editorProjectClient.test.ts  |   61 +-
 .../image-editor/editorProjectClient.ts       |  148 +-
 56 files changed, 4995 insertions(+), 922 deletions(-)

diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index d6fa72fc3..1b4d69ebb 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -6948,3 +6948,10 @@
 - Windows �文件决策：����进程新建 `.agent/.manifest.json.lock` 时，Windows �能把 owner 设为 `Administrators`。仅在固定�路径已�得�共享独��柄并确认是普通�� reparse��链接文件�，��始化为当� `TokenUser`；���次�核�柄并执行原有 owner/DACL 校验，�放宽既有异常对象的安全规则。
 - Provider Schema 决策：`agent.route_manifest.missingAssetSlots` ��广告 OpenAI-compatible 代�拒�的 `uniqueItems`；Runtime 继续排�去�，Schema �集门�新增该关键字，真实 Provider smoke 必须在�布��明工具目录�被接�。
 - �行决策：Godot 项目�交给 Project Supervisor 时使用 `standard` Run Profile，��触� Web 专用 `game/index.html`�HTTP preview 与自主 Web 完�门。Godot 编辑器�动和内嵌�行预览�在本切片范围。
+
+## 2026-08-13 Spine �列帧多模�与视频直接转�
+
+- �一 Spine �列帧��固定分为“AI生�/改造�和“视频直接转��两个标签，旧项目默认�� AI。AI 视频以 `motion` 表示动作视频�`appearance` 表示�选角色外观图；上传�列帧 PNG �作为一张完整�考图，��网格识别。
+- 视频直接转�走内部 `editor_character_animation_video_conversion` durable job，FFprobe + FFmpeg 覆盖完整�时长，采样率最高 8 FPS�最低 1 FPS，产出 2–120 帧；480p/720p 是�缩�放的最大长边。该路径固定�费��留背景，�调用 Seedance 或 BgFilter，也��制�存�视频。
+- 直接转��� `character-animation` / `image-sequence`，�方 action 为 `character-animation.convert`，��槽�为 `source`；最多 120 帧时首帧 item �时承载最终 resource/asset。原�生�上�和角色动画拆帧上�扩为 120，但图标图集公开切片继续�� 64，既有 JSON 大�门��放宽。
+- `/api/external/v1` �开放上述内部字段或直接转�路由，�修改 OpenAPI；本次�改 SpacetimeDB 表结构��移或生� bindings。
diff --git a/docs/technical/�技术方案】ArtAgent多模�Spine�列帧动画生�-2026-08-10.md b/docs/technical/�技术方案】ArtAgent多模�Spine�列帧动画生�-2026-08-10.md
index 71e79dc82..f0a127682 100644
--- a/docs/technical/�技术方案】ArtAgent多模�Spine�列帧动画生�-2026-08-10.md
+++ b/docs/technical/�技术方案】ArtAgent多模�Spine�列帧动画生�-2026-08-10.md
@@ -1,7 +1,17 @@
 # Art Agent 多模� Spine �列帧动画生�方案
 
 状�：已实施，待�并
-更新时间：`2026-08-11`
+更新时间：`2026-08-13`
+
+## 2026-08-13 多模�输入与直接转�补充
+
+- �一��分为“AI生�/改造�和“视频直接转��两个标签，旧�方默认�� AI；两个标签独立�留�稿；标签为分段按钮样�（明显�点击�带选中�），���标题。
+- AI 视频以 `motion` 表示动作视频�`appearance` 表示�选角色外观图（�多张）；Provider 的 `reference_video` 负责动作�`reference_image` 负责外观。动作视频已选中�，外观图是�选的普通图片�考，��求画布图层标记为 `character`；上传�列帧 PNG 作为一张完整�考图，�识别网格或拆帧。
+- 直接转�使用内部 `/api/editor/character-animations/video-conversions` 与 durable job `editor_character_animation_video_conversion`，固定�费��留背景，�调用 Seedance�BgFilter 或其它去背景模型，也����存�视频。**去背景暂缓**：直接转�的�视频背景�纯色，本地键色抠图�适用，待确定方案���。
+- �视频仅接� owner-scoped MP4/MOV，�制 50MB�2–15 秒。FFprobe 读�旋转�的显示尺寸�精确时长与平� FPS；FFmpeg 覆盖完整时间轴，采样率为 `clamp(min(�平� FPS, 8), 1, 8)`，产出 2–120 帧。
+- 480p/720p 表示最大长边，�缩��放大。正� `imageSequenceDurationMs` 等于探测时长，播放器�普通 ZIP 与 Spine JSON 的�帧时长统一按 `imageSequenceDurationMs ÷ frameCount`。
+- 直接转��� `character-animation` / `image-sequence`，�方 action 为 `character-animation.convert`，��槽�为 `source`。最多 120 帧时第一帧�时承载最终 resource/asset；角色动画拆帧�许 120 项，图标图集公开切片继续�制 64 项，既有 512 KiB/2 MiB JSON 门��放宽。
+- `/api/external/v1` ��原图片模�，�暴露内部新增字段或直接转�接�，�修改 OpenAPI。
 
 ## 1. 文档目的
 
@@ -25,12 +35,13 @@
 2. **��新增新的�列帧媒体类型。**继续使用：
    - `assetKind = "character-animation"`ï¼›
    - `mediaType = "image-sequence"`ï¼›
-   - `generationInputs.action = "character-animation.generate"`。
+   - AI 生�使用 `generationInputs.action = "character-animation.generate"`；
+   - 视频直接转�使用 `generationInputs.action = "character-animation.convert"`。
 3. **扩展现有角色动作生�链路，而�是�写。**现有链路已�覆盖图片首帧驱动�Seedance 预览视频�抽帧��帧�明化�OSS�原��库�队列��和失败退款。
 4. **附件 ZIP 导出已�实现。**当� `buildSpineImageSequenceJson` 与 `useImageCanvasAssetExportWorkflow` 生�的目录�`metadata.json`�`skeleton.json`�`README.md` 和 `manifest.txt` 与附件示例一致，�需�回归验�和入�文案调整。
 5. **本期�应承诺“真正的 Spine 骨骼动画�。**UI 和文案应写“Spine �列帧动画�或“Spine JSON �列帧包�，��用户误认为会自动拆件和蒙皮。
 6. **1080p 暂�开放。**当��务端明确拒� `seedance2.0-fast + 1080p`；应等供应商能力��本和�帧处�资�验���开放。
-7. **关键需求�径已�冻结并完�实施。**视频模�采用“�考视频 + 文本生�新视频�抽帧�，默认 480p × 4 秒为 40 泥点，最终帧自动�明化，拆帧�进入素�库；完整决策�第 13�16 节。
+7. **关键需求�径已�冻结并完�实施。**AI 视频模�采用“动作视频 + �选角色外观图 + 文本�生�新视频�抽帧，按现有规格计费且最终帧自动�明化；视频直接转�固定�费��留背景；拆帧�进入素�库。完整决策�第 13�16 节。
 
 ### 2.2 为什么�是新玩法接入
 
@@ -82,7 +93,7 @@ manifest.txt
 
 现有角色动作能力已�包�：
 
-- 角色图片�键或浮动工具�“生�动画�；
+- 统一从底部工具�“Spine�列帧动画�进入；��从图层�键��或选中图层浮动工具�暴露独立入�；当�选中视频（或带预览视频的�列帧）时，底部入�默认打开“视频直接转��，其它情况默认打开“AI生�/改造�；
 - `character-animation` 生���框；
 - 动作�述；
 - 待机�行走�奔跑�跳跃�攻击��击�倒下预设；
@@ -509,10 +520,12 @@ flowchart TD
 
 `ImageCanvasBottomToolbarView.tsx`：
 
-- 在“生�视频��新增“Spine �列帧动画�；
-- 点击�在视�中心创建独立 `character-animation` generation dialog；
-- �在当���下方追加内容；
-- 移动端��横�滚动或现有工具�收纳规则。
+- 在“生�视频���留唯一的“Spine �列帧动画�入�；
+- 点击�在视�中心创建统一的 `character-animation` generation dialog；
+- 统一��内�时承载“AI生�/改造�和“视频直接转��两个标签；
+- 当�选中视频或带预览视频的�列帧时默认进入“视频直接转��，当�选中角色图时默认进入“AI生�/改造�，无适用选中图层时默认进入“AI生�/改造�；
+- �键��和选中图层浮动工具����供“生�动画�或“视频转�为Spine�列帧动画�平行入�；
+- �在当���下方追加内容；移动端��横�滚动或现有工具�收纳规则。
 
 `CanvasTool` 增加 `character-animation`，但�新增页�路由。
 
@@ -755,19 +768,20 @@ idle
 
 在 P0/P1 决策冻结�，本功能至少满足：
 
-1. 底部工具�最�侧出现“Spine �列帧动画�，与�一个工具之间�增加分割线。
-2. 无�考�角色图片�考�视频�考三��法�交都由�端��校验。
-3. 画布选择�角色图片时�示“请选择角色图�；上传图片规则按最终确认�径执行。
-4. 请求��带稳定对象引用，��带 Data URL / blob URL。
-5. 生�中刷新页��任务和��框���。
-6. 失败�产生残缺�列，且按现有 durable billing 规则退款。
-7. 完��项目 resource 和账� asset �为 `character-animation`，帧顺�稳定。
-8. �列图层�循环播放并显示当�帧/总帧数。
-9. 元数�展示类型�输入�Model�Resolution�Task。
-10. 改造���原输入模���考�动作�背景和规格，并生�新资�。
-11. 拆帧���上传已有 PNG。
-12. Spine ZIP 与附件目录结构一致，`skeleton.json` 能通过现有 validator。
-13. 存�角色动作项目�External v1 图片模�和普通视频生��回归。
+1. 底部工具�最�侧出现“Spine �列帧动画�，与�一个工具之间�增加分割线；Spine �列帧��从�键��或选中图层浮动工具��供平行入�。
+2. 点击底部入��，统一���时�供“AI生�/改造�和“视频直接转��；选中视频默认进入直接转�，选中角色图默认进入 AI，无适用选中图层时默认进入 AI。
+3. 无�考�角色图片�考�视频�考三��法�交都由�端��校验。
+4. 画布选择�角色图片时按当�多模��考规则处�；上传图片规则按最终确认�径执行。
+5. 请求��带稳定对象引用，��带 Data URL / blob URL。
+6. 生�中刷新页��任务和��框���。
+7. 失败�产生残缺�列，且按现有 durable billing 规则退款。
+8. 完��项目 resource 和账� asset �为 `character-animation`，帧顺�稳定。
+9. �列图层�循环播放并显示当�帧/总帧数。
+10. 元数�展示类型�输入�Model�Resolution�Task。
+11. 改造���原输入模���考�动作�背景和规格，并生�新资�。
+12. 拆帧���上传已有 PNG。
+13. Spine ZIP 与附件目录结构一致，`skeleton.json` 能通过现有 validator。
+14. 存�角色动作项目�External v1 图片模�和普通视频生��回归。
 
 ## 15. 验�命令建议
 
@@ -808,7 +822,7 @@ git diff --check
 
 本方案已按推� v1 �径�地：
 
-- 底部工具�已新增 `Spine�列帧动画` 入�；入�使用“播放器 + 帧格�图标，�于�一底�的最�侧，与�一个工具之间�增加分割线，也�使用独立按钮容器；画布中的�列帧生����片�用�一个图标组件，��显示旧的�人图标；底�桌�宽度按完整内容自适应，��因第�三个按钮出现横�滚动�，窄���横�滑动但�显示 scrollbar；
+- 底部工具��留唯一的 `Spine�列帧动画` 入�；选中视频或带预览视频的�列帧时默认进入“视频直接转��，选中角色图或无适用选中图层时默认进入“AI生�/改造�；�键��和选中图层浮动工具����供平行入�；入�使用“播放器 + 帧格�图标，�于�一底�的最�侧，与�一个工具之间�增加分割线，也�使用独立按钮容器；画布中的�列帧生����片�用�一个图标组件，��显示旧的�人图标；底�桌�宽度按完整内容自适应，��因第�三个按钮出现横�滚动�，窄���横�滑动但�显示 scrollbar；
 - 文本�角色图片��考视频三�模�统一使用 `character-animation` generation dialog；��考�制按当� dialog 语义判断而�是�赖工具� `activeTool`，上传��接收一个文件；图片�视频�音频�考的异步探测�OSS 上传��久化和回填�绑定�起时的 dialog 身份与分媒体容� reservation，切�����把结果写入新��；其他多�考生������原能力；
 - Seedance 2.0 Fast 支� 480p / 720p，�开放 1080p；
 - 背景键色冻结为白 `#FFFFFF`�绿 `#00FF00`�� `#0000FF`�紫 `#8000FF`，最终产物继续自动�明化；新独立��使用显�键色，旧角色图层“生�动画�入�继续由�端自动�色，�端在没有显�键色时��伪装�绿色已选；
diff --git a/docs/technical/�技术方案】角色规范到多视角图集拆分与动画生��程-2026-08-12.md b/docs/technical/�技术方案】角色规范到多视角图集拆分与动画生��程-2026-08-12.md
index 04114540d..fbf65a63d 100644
--- a/docs/technical/�技术方案】角色规范到多视角图集拆分与动画生��程-2026-08-12.md
+++ b/docs/technical/�技术方案】角色规范到多视角图集拆分与动画生��程-2026-08-12.md
@@ -3,7 +3,8 @@
 - 日期：2026-08-12
 - 状�：设计稿 v3（简化：唯一新增能力是"从角色设定生�多�角色图"，拆分与动画全走现有能力）
 - 实现状�：**核心已实现**（多�图生�：�端 `character-sheet` kind + �端角色��开关，2026-08-12）
-  - 拆分集�：角色多方�图（action=`character-sheet.generate`）�既有「拆分图集�切出的�视角切片按 `character` �库，�直接作为动画�考（`editor_spritesheet_slice_record_asset_kind`，`editor_project_icon.rs`）
+  - 方�固定为**八方�**（上�下�左�� + 四角，围绕一圈排布，3×3 �宫格中心留空）；�示�按八�围绕一圈约�排布，�低拆分粘连概率。
+  - 拆分：�用既有「拆分图集�的「连通�定� + 外接矩形截图�算法（`slice_generated_icon_spritesheet_all_by_connected_components`），�新增�素级连通�掩�；切出的�视角切片按 `icon` �库（`split_editor_icon_spritesheet`），�改 `character`。
 - 关�：`�技术方案】ArtAgent多模�Spine�列帧动画生�-2026-08-10.md`
 
 ## 1. 背景
@@ -14,11 +15,11 @@
 
 ## 2. 范围
 
-**唯一新增能力**：从角色设定（角色规范图 / 已有�视角角色图）生�一张**多方�角色图**（四视图默认）。
+**唯一新增能力**：从角色设定（角色规范图 / 已有�视角角色图）生�一张**多方�角色图**（八方�：上�下�左�� + 四角，围绕一圈排布）。
 
 **其余全部�用现有能力，���外�障：**
 - 图集类型：�用现有 `icon-spritesheet`（「图集�），�新增资产类型。
-- 拆分：�用现有「拆分图集�（连通�拆分，`split_editor_icon_spritesheet`），**手动触�**，�自动拆分。
+- 拆分：�用现有「拆分图集�（`split_editor_icon_spritesheet`，连通�定� + 外接矩形截图），**手动触�**，�自动拆分。
 - 方�/数�：**���**。生�错了用户�新抽�；方�标签用户自己看。
 - 动画：对拆分出的�视角图，按现有动画���个生�。
 
@@ -31,7 +32,7 @@
 �新增】生�多方�角色图 → 产出 icon-spritesheet 图集
    │
    â–¼
-�现有】用户手动「拆分图集�（连通�）→ N 张�视角图
+�现有】用户手动「拆分图集�→ N 张�视角图（按 icon �库）
    │
    â–¼
 �现有】选�视角图 → 图生视频 → 抽帧 → Spine�列帧
@@ -39,17 +40,18 @@
 
 ## 4. 新增能力：生�多方�角色图
 
-- 入�：在「生�角色形象���加一个按钮「生�多方�角色图�；或�用「生�图标素����切到角色多�模�。建议�者。
+- 入�：在「生�角色形象���底部，作为「多方�图��勾选项，与「�素艺术�并列；勾选�本次生�走 `character-sheet` 图集模�。
 - 链路：�用图集生�链路（`generate_editor_icon_spritesheet_for_owner`），模型 `nanobanana2`。
-- 输出：一张 `icon-spritesheet` 图集，四个方�（�/�/左/�），�一角色�方�之间纯色底间隔�彼此分离。
+- 输出：一张 `icon-spritesheet` 图集，八个方�（正������侧����背��左��左侧�左�），按 3×3 �宫格围绕一圈排布�中心留空，�一角色�方�之间纯色底充分间隔�彼此分离。
 - �示�是质�关键（�案）：
 
 ```
-根�角色设定生�游�角色的多方�视图图集。
-画�中�有�一个角色，按四个方�排布：正��背��左侧��侧，�个方�一个完整角色，方�之间相互分离�互����互�接触。
-四个方�必须是�一个角色，脸型��型��装��色�武器�头身比�体型全程一致，�止漂移��装��形。
-�个方�角色完整居中，��切头顶�手脚或武器；四个方�底部基线对�，画��比一致。
-背景为�一纯色（绿幕 #00FF00 / 白底 #FFFFFF），平整无纹��无���无阴影�无地��无�具；角色之间由纯色背景间隔，便于�续拆分。
+根�角色设定生�游�角色的八方�视图图集。
+画�中�有�一个角色，共八个方�：正������侧����背��左��左侧�左�，�个方�一个完整角色。
+八个方�必须是�一个角色，脸型��型��装��色�武器�头身比�体型全程一致，�止漂移��装��形。
+八个方�按三乘三�宫格围绕一圈排布：上�下�左��以�四个角��放一个方�，�宫格中心留空，�放置角色。
+�个方�角色完整居中，��切头顶�手脚或武器；�方�底部基线对�，画��比一致。
+背景为�一纯色（绿幕 #00FF00），平整无纹��无���无阴影�无地��无�具；角色之间由纯色背景充分间隔，互�接触�互���，便于�续拆分。
 �止�外角色�分身�宠物�文字�水��边框�编��网格线。
 角色设定：{}
 ```
@@ -65,7 +67,7 @@
 ## 6. 边界
 
 - 生�质���示�；图�对 → 用户�新抽�，**��数�/方�校验**。
-- 连通�若粘连（方�贴太近）→ 拆分数��对 → �新抽�或人工处�，�自动兜底。
+- 外接矩形若粘连（方�贴太近）→ 拆分数��对 → �新抽�或人工处�，�自动兜底；�示�以「围绕一圈 + 纯色背景充分间隔��低粘连概率。
 - �本：多�图一次图�生�；拆分 0 provider �本；�个方�动画�一次（现有计价）。
 - 旧链路（直接拿�视角角色图�动画）��。
 
@@ -77,12 +79,12 @@
 
 ## 8. 决策点（留给产�）
 
-- 四视图 vs 八方�（当�建议四视图：�/�/左/�）。
-- 入��置（「生�角色形象���按钮 vs �用图标图集��）。
-- 多�图背景色（绿幕/白底）。
+- 方�数已定**八方�**（上�下�左�� + 四角，围绕一圈；���供四视角选项）。
+- 入�已定：角色��底部「多方�图��勾选项，与「�素艺术�并列。
+- 多�图背景色（当�固定绿幕 #00FF00）。
 
 ## 9. 改动文件
 
-- �端：`ImageCanvasGenerationModel.ts`（多�图�示�/常�）�`ImageCanvasGenerationDialogModel.ts`�`ImageCanvasGenerationSubmissionModel.ts`�`ImageCanvasGenerationComposerView.tsx`（入�按钮）。
-- �端：`editor_project_icon.rs`（多�图生��示�分支）或 `editor_project.rs`；`shared-contracts`（如需 DTO 字段）。
-- 无需动拆分逻辑�动画逻辑�存储层。
+- �端：`ImageCanvasGenerationModel.ts`（多�图�示�/常�）�`ImageCanvasGenerationDialogModel.ts`�`ImageCanvasGenerationSubmissionModel.ts`�`ImageCanvasCharacterGenerationComposerView.tsx`（底部「多方�图�勾选项）�`ImageCanvasGenerationImageOptionsView.tsx`（`extraToggles` �槽）。
+- �端：`editor_project.rs`（`build_editor_character_multi_view_sheet_prompt` 八�围绕一圈�示�）。
+- 无需动拆分逻辑�动画逻辑�存储层；切片按 `icon` �库，�加 `character` 分支。
diff --git a/server-rs/crates/api-server/src/app.rs b/server-rs/crates/api-server/src/app.rs
index 510018922..7846a328b 100644
--- a/server-rs/crates/api-server/src/app.rs
+++ b/server-rs/crates/api-server/src/app.rs
@@ -1823,6 +1823,29 @@ mod tests {
         assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
     }
 
+    #[tokio::test]
+    async fn editor_character_animation_video_conversion_requires_bearer_auth() {
+        let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/api/editor/character-animations/video-conversions")
+                    .header("content-type", "application/json")
+                    .body(Body::from(
+                        serde_json::json!({
+                            "sourceVideoSrc": "users/owner/source.mp4",
+                            "resolution": "480p"
+                        })
+                        .to_string(),
+                    ))
+                    .expect("request should build"),
+            )
+            .await
+            .expect("request should succeed");
+        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+    }
+
     #[tokio::test]
     async fn editor_character_animation_frame_split_requires_bearer_auth() {
         let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
diff --git a/server-rs/crates/api-server/src/asset_billing.rs b/server-rs/crates/api-server/src/asset_billing.rs
index 11e7369eb..55410ec08 100644
--- a/server-rs/crates/api-server/src/asset_billing.rs
+++ b/server-rs/crates/api-server/src/asset_billing.rs
@@ -930,7 +930,7 @@ mod tests {
         for (source, expected_calls) in [
             (include_str!("editor_project.rs"), 4),
             (include_str!("editor_project_icon.rs"), 2),
-            (include_str!("character_animation_assets.rs"), 2),
+            (include_str!("character_animation_assets.rs"), 3),
             (
                 include_str!("vector_engine_audio_generation/generation.rs"),
                 2,
diff --git a/server-rs/crates/api-server/src/character_animation_assets.rs b/server-rs/crates/api-server/src/character_animation_assets.rs
index 65454fc86..cba181a48 100644
--- a/server-rs/crates/api-server/src/character_animation_assets.rs
+++ b/server-rs/crates/api-server/src/character_animation_assets.rs
@@ -29,8 +29,8 @@ use module_assets::{
     generate_asset_object_id,
 };
 use platform_oss::{
-    LegacyAssetPrefix, OssHeadObjectRequest, OssObjectAccess, OssPutObjectRequest,
-    OssRequestAttemptContext, OssSignedGetObjectUrlRequest,
+    LegacyAssetPrefix, OssDeleteObjectRequest, OssHeadObjectRequest, OssObjectAccess,
+    OssPutObjectRequest, OssRequestAttemptContext, OssSignedGetObjectUrlRequest,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
@@ -45,7 +45,9 @@ use shared_contracts::assets::{
     CharacterWorkflowCacheSaveRequest, CharacterWorkflowCacheSaveResponse,
     EditorCharacterAnimationFramePayload, EditorCharacterAnimationFrameSplitRequest,
     EditorCharacterAnimationFrameSplitResponse, EditorCharacterAnimationGenerateRequest,
-    EditorCharacterAnimationGenerateResponse, EditorVideoGenerateRequest,
+    EditorCharacterAnimationGenerateResponse, EditorCharacterAnimationBackgroundRemovalRequest,
+    EditorCharacterAnimationBackgroundRemovalResponse, EditorCharacterAnimationVideoConversionRequest,
+    EditorCharacterAnimationVideoConversionResponse, EditorVideoGenerateRequest,
     EditorVideoGenerateResponse,
 };
 #[cfg(any())]
@@ -75,7 +77,9 @@ use crate::{
     },
     editor_generation_config::EditorGenerationPricingConfig,
     editor_generation_queue::{
-        EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND, EDITOR_VIDEO_GENERATION_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND, EDITOR_VIDEO_GENERATION_JOB_KIND,
         EditorGenerationQueuedResponse, editor_generation_queue_state,
         editor_generation_source_entity_id, enqueue_editor_generation_job_for_caller,
     },
@@ -91,9 +95,10 @@ use crate::{
         normalize_editor_record_object_key, persist_editor_generation_result_atomically,
         preflight_editor_billable_generation_target, rebuild_editor_generation_input_references,
         remove_editor_generated_screen_background_with_bgfilter,
+        request_editor_background_removal_image_with_bgfilter_worker,
         resolve_editor_reference_object_key_for_owner, sanitize_editor_client_generation_inputs,
         serialize_editor_generation_inputs, serialize_editor_image_sequence_frames,
-        with_editor_media_duration_generation_input,
+        validate_editor_generation_operation_id, with_editor_media_duration_generation_input,
     },
     editor_screen_background_decision::{
         EditorScreenBackgroundDecisionInput, EditorScreenBackgroundDecisionKind,
@@ -105,8 +110,10 @@ use crate::{
         NormalizedEditorCharacterAnimationRequest,
         apply_editor_character_animation_authoritative_reference_dimensions,
         build_authoritative_editor_character_animation_generation_inputs,
-        build_editor_character_animation_frame_asset_label, editor_character_animation_bad_request,
-        editor_character_animation_source_asset_label,
+        build_authoritative_editor_character_animation_video_conversion_inputs,
+        build_editor_character_animation_frame_asset_label,
+        build_editor_character_animation_video_conversion_plan,
+        editor_character_animation_bad_request, editor_character_animation_source_asset_label,
         normalize_editor_character_animation_request_with_pricing,
         parse_editor_character_animation_background_color,
         resolve_editor_character_animation_asset_label,
@@ -631,6 +638,10 @@ pub async fn generate_editor_character_animation(
             .reference_src
             .as_deref()
             .is_some_and(matches_inline_media_source)
+        || payload
+            .appearance_reference_srcs
+            .iter()
+            .any(|source| matches_inline_media_source(source.as_str()))
     {
         return Err(character_animation_error_response(
             &request_context,
@@ -671,6 +682,58 @@ pub async fn generate_editor_character_animation(
     .await
 }
 
+pub async fn convert_editor_character_animation_video(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<EditorCharacterAnimationVideoConversionRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request(error.body_text()),
+        )
+    })?;
+    if matches_inline_media_source(payload.source_video_src.as_str()) {
+        return Err(character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("�视频必须先上传 OSS，并使用稳定媒体引用。"),
+        ));
+    }
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    if !state.config.external_generation_mode.is_inline() {
+        let queue_job = enqueue_editor_character_animation_video_conversion_for_owner(
+            &state,
+            &request_context,
+            owner_user_id.as_str(),
+            payload,
+        )
+        .await?;
+        return Ok(json_success_body(
+            Some(&request_context),
+            EditorGenerationQueuedResponse {
+                queue_state: editor_generation_queue_state(queue_job),
+            },
+        ));
+    }
+    let caller = editor_inline_generation_caller(
+        owner_user_id,
+        &request_context,
+        EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND,
+        &payload,
+    )
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    with_editor_generation_durable_billing_boundary(
+        convert_editor_character_animation_video_for_owner(
+            state,
+            request_context,
+            caller,
+            Ok(Json(payload)),
+        ),
+    )
+    .await
+}
+
 pub async fn split_editor_character_animation_frames(
     State(state): State<AppState>,
     Extension(request_context): Extension<RequestContext>,
@@ -747,11 +810,11 @@ pub async fn split_editor_character_animation_frames(
                 "message": "�列帧资�缺少完整的正�帧列表。",
             }))
         })?;
-    if frames.len() > 64 {
+    if frames.len() > 120 {
         return Err(
             AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY).with_details(json!({
                 "provider": "editor-character-animation-frame-split",
-                "message": "�次最多拆分64帧。",
+                "message": "�次最多拆分120帧。",
             })),
         );
     }
@@ -980,6 +1043,371 @@ pub async fn split_editor_character_animation_frames(
     ))
 }
 
+pub async fn remove_editor_character_animation_background(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(payload): Json<EditorCharacterAnimationBackgroundRemovalRequest>,
+) -> Result<Json<Value>, Response> {
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    if !state.config.external_generation_mode.is_inline() {
+        let queue_job = enqueue_editor_character_animation_background_removal_for_owner(
+            &state,
+            &request_context,
+            owner_user_id.as_str(),
+            payload,
+        )
+        .await?;
+        return Ok(json_success_body(
+            Some(&request_context),
+            EditorGenerationQueuedResponse {
+                queue_state: editor_generation_queue_state(queue_job),
+            },
+        ));
+    }
+    let caller = editor_inline_generation_caller(
+        owner_user_id,
+        &request_context,
+        EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND,
+        &payload,
+    )
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    with_editor_generation_durable_billing_boundary(
+        remove_editor_character_animation_background_for_owner(
+            state,
+            request_context,
+            caller,
+            Ok(Json(payload)),
+        ),
+    )
+    .await
+}
+
+pub(crate) async fn enqueue_editor_character_animation_background_removal_for_owner(
+    state: &AppState,
+    request_context: &RequestContext,
+    owner_user_id: &str,
+    mut payload: EditorCharacterAnimationBackgroundRemovalRequest,
+) -> Result<ExternalGenerationJobRecord, Response> {
+    let target = preflight_editor_billable_generation_target(
+        state,
+        owner_user_id,
+        Some(payload.project_id.clone()),
+        payload
+            .asset_folder_id
+            .clone()
+            .or_else(|| Some("project".to_string())),
+    )
+    .await
+    .map_err(|error| character_animation_error_response(request_context, error))?;
+    payload.project_id = target.project_id.unwrap_or(payload.project_id);
+    payload.asset_folder_id = target.asset_folder_id;
+    let source_entity_id = editor_generation_source_entity_id(
+        Some(payload.project_id.as_str()),
+        "character-animation-background-removal",
+    );
+    enqueue_editor_generation_job_for_caller(
+        state,
+        request_context,
+        owner_user_id,
+        EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND,
+        source_entity_id,
+        "Spine�列帧去背景",
+        0,
+        &payload,
+        None,
+    )
+    .await
+    .map_err(|error| error.into_response_with_context(Some(request_context)))
+}
+
+pub(crate) async fn remove_editor_character_animation_background_for_owner(
+    state: AppState,
+    request_context: RequestContext,
+    caller: EditorGenerationCaller,
+    payload: Result<Json<EditorCharacterAnimationBackgroundRemovalRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request(error.body_text()),
+        )
+    })?;
+    let owner_user_id = caller.owner_user_id.clone();
+    let project_id = payload.project_id.trim().to_string();
+    let source_layer_id = payload.source_layer_id.trim().to_string();
+    let source_resource_id = payload.source_resource_id.trim().to_string();
+    if project_id.is_empty() || source_layer_id.is_empty() || source_resource_id.is_empty() {
+        return Err(character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request(
+                "projectId�sourceLayerId 和 sourceResourceId �能为空。",
+            ),
+        ));
+    }
+    let project = state
+        .spacetime_client()
+        .get_editor_project(EditorProjectGetRecordInput {
+            project_id: project_id.clone(),
+            owner_user_id: owner_user_id.clone(),
+        })
+        .await
+        .map_err(map_editor_project_error)
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let source_resource = project
+        .resources
+        .iter()
+        .find(|resource| resource.resource_id == source_resource_id)
+        .cloned()
+        .ok_or_else(|| {
+            character_animation_error_response(
+                &request_context,
+                AppError::from_status(StatusCode::NOT_FOUND).with_details(json!({
+                    "provider": "editor-character-animation-background-removal",
+                    "message": "未找到�去背景的Spine�列帧资�。",
+                })),
+            )
+        })?;
+    if project.owner_user_id != owner_user_id
+        || source_resource.owner_user_id != owner_user_id
+        || source_resource.project_id != project_id
+    {
+        return Err(character_animation_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::FORBIDDEN).with_details(json!({
+                "provider": "editor-character-animation-background-removal",
+                "message": "�列帧资��属于当�账�或当�项目。",
+            })),
+        ));
+    }
+    if source_resource.asset_kind.as_deref()
+        != Some(EDITOR_CHARACTER_ANIMATION_RESOURCE_ASSET_KIND)
+    {
+        return Err(character_animation_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY).with_details(json!({
+                "provider": "editor-character-animation-background-removal",
+                "message": "�有Spine�列帧动画�以去除背景。",
+            })),
+        ));
+    }
+    let frames: Vec<EditorCharacterAnimationFramePayload> = source_resource
+        .image_sequence_frames
+        .clone()
+        .and_then(|value| serde_json::from_value(value).ok())
+        .filter(|frames: &Vec<EditorCharacterAnimationFramePayload>| !frames.is_empty())
+        .ok_or_else(|| {
+            character_animation_error_response(
+                &request_context,
+                editor_character_animation_bad_request("�列帧资�缺少完整的正�帧列表。"),
+            )
+        })?;
+    if frames.len() > 120 {
+        return Err(character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("�次最多处�120帧。"),
+        ));
+    }
+    let frame_width = source_resource.width;
+    let frame_height = source_resource.height;
+    let duration_ms = source_resource.image_sequence_duration_ms.unwrap_or(0);
+    let plan = crate::editor_sequence_animation::EditorCharacterAnimationVideoConversionPlan {
+        duration_seconds: duration_ms as f64 / 1000.0,
+        duration_ms,
+        source_fps: 0.0,
+        sampling_fps: 0.0,
+        frame_count: frames.len() as u32,
+        frame_width,
+        frame_height,
+    };
+    let asset_label =
+        resolve_editor_character_animation_asset_label(payload.asset_label.as_deref());
+    let operation = editor_generation_operation(&caller)
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let task_id = operation.operation_id.clone();
+    let storage_task_id = format!(
+        "{}-{}",
+        sanitize_storage_segment(owner_user_id.as_str(), "owner"),
+        operation.operation_fingerprint
+    );
+    if let Some(reporter) = caller.phase_reporter.as_ref() {
+        reporter
+            .report_processing(&state)
+            .await
+            .map_err(|error| character_animation_error_response(&request_context, error))?;
+    }
+    let matting_audit = crate::external_api_audit::ExternalApiAuditContext {
+        user_id: Some(owner_user_id.clone()),
+        profile_id: Some(project_id.clone()),
+        request_id: Some(request_context.request_id().to_string()),
+        external_call_deadline: request_context.external_call_deadline(),
+    };
+    let persisted_frames = extract_and_prepare_background_removal_frames(
+        &state,
+        &caller,
+        &storage_task_id,
+        &frames,
+        frame_width,
+        frame_height,
+        &matting_audit,
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let result_frames = persisted_frames.frames.clone();
+    let first_frame = result_frames.first().ok_or_else(|| {
+        character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("去背景没有产生�列帧。"),
+        )
+    })?;
+    let frame_payload_json = serde_json::to_value(&result_frames).map_err(|error| {
+        character_animation_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
+                "provider": "editor-character-animation",
+                "message": format!("�列化去背景帧失败：{error}"),
+            })),
+        )
+    })?;
+    let generation_inputs = rebuild_editor_generation_input_references(
+        &state,
+        owner_user_id.as_str(),
+        payload.generation_inputs.clone(),
+        vec![("��列帧".to_string(), source_resource_id.clone())],
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let completed_at_micros = current_utc_micros();
+    let prepared = match prepare_editor_character_animation_sequence_result(
+        &caller,
+        Some(project_id.as_str()),
+        payload.asset_folder_id.as_deref(),
+        asset_label.as_str(),
+        "BgFilter",
+        Some(source_resource_id.clone()),
+        generation_inputs,
+        plan,
+        &persisted_frames,
+        frame_payload_json,
+        completed_at_micros,
+    ) {
+        Ok(prepared) => prepared,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(
+                &state,
+                &persisted_frames.uploaded_object_keys,
+            )
+            .await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
+    let layer_id = format!("layer-editor-character-animation-{task_id}");
+    let canvas_item = payload.canvas_completion.as_ref().map(|completion| {
+        build_editor_character_animation_canvas_placement_item(
+            completion,
+            prepared.final_resource_id.as_str(),
+            first_frame.width,
+            first_frame.height,
+            layer_id.as_str(),
+        )
+    });
+    let canvas_layout_plan = EditorCanvasLayoutPlan::generation(
+        owner_user_id.as_str(),
+        Some(project_id.as_str()),
+        payload.canvas_completion.as_ref(),
+        canvas_item.into_iter().collect(),
+        Some(layer_id),
+    );
+    let final_candidate = prepared
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .ok_or_else(|| {
+            character_animation_error_response(
+                &request_context,
+                editor_character_animation_bad_request("去背景缺少最终候选记录。"),
+            )
+        })?;
+    let compact_resource = final_candidate
+        .project_resource
+        .as_ref()
+        .map(compact_editor_generation_candidate_resource);
+    let compact_asset = final_candidate
+        .asset
+        .as_ref()
+        .map(compact_editor_generation_candidate_asset);
+    let job_result_payload_json = editor_generation_job_result_payload_json(
+        &caller,
+        json!({
+            "ok": true,
+            "taskId": task_id,
+            "frames": &result_frames,
+            "frameCount": result_frames.len(),
+            "durationMs": duration_ms,
+            "frameWidth": frame_width,
+            "frameHeight": frame_height,
+            "priceMudPoints": 0,
+            "resource": compact_resource,
+            "asset": compact_asset,
+        }),
+    );
+    let persisted = match persist_editor_generation_result_atomically(
+        &state,
+        &caller,
+        prepared.items,
+        canvas_layout_plan,
+        job_result_payload_json,
+        completed_at_micros,
+    )
+    .await
+    {
+        Ok(persisted) => persisted,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(
+                &state,
+                &persisted_frames.uploaded_object_keys,
+            )
+            .await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
+    let final_resource = persisted
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .and_then(|item| item.project_resource.clone())
+        .map(editor_project_resource_payload_from_record)
+        .and_then(|resource| serde_json::to_value(resource).ok());
+    let final_asset = persisted
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .and_then(|item| item.asset.clone())
+        .map(editor_asset_payload_from_record)
+        .and_then(|asset| serde_json::to_value(asset).ok());
+    let completed_project = persisted
+        .project
+        .map(editor_project_payload_from_record)
+        .and_then(|project| serde_json::to_value(project).ok());
+    Ok(json_success_body(
+        Some(&request_context),
+        EditorCharacterAnimationBackgroundRemovalResponse {
+            ok: true,
+            task_id,
+            frames: result_frames,
+            frame_count: plan.frame_count,
+            duration_ms,
+            frame_width,
+            frame_height,
+            price_mud_points: 0,
+            project: completed_project,
+            resource: final_resource,
+            asset: final_asset,
+            queue_state: None,
+        },
+    ))
+}
+
 pub(crate) async fn enqueue_editor_character_animation_for_owner(
     state: &AppState,
     request_context: &RequestContext,
@@ -992,6 +1420,10 @@ pub(crate) async fn enqueue_editor_character_animation_for_owner(
             .reference_src
             .as_deref()
             .is_some_and(matches_inline_media_source)
+        || payload
+            .appearance_reference_srcs
+            .iter()
+            .any(|source| matches_inline_media_source(source.as_str()))
     {
         return Err(character_animation_error_response(
             request_context,
@@ -1051,6 +1483,54 @@ pub(crate) async fn enqueue_editor_character_animation_for_owner(
     .map_err(|error| error.into_response_with_context(Some(request_context)))
 }
 
+pub(crate) async fn enqueue_editor_character_animation_video_conversion_for_owner(
+    state: &AppState,
+    request_context: &RequestContext,
+    owner_user_id: &str,
+    mut payload: EditorCharacterAnimationVideoConversionRequest,
+) -> Result<ExternalGenerationJobRecord, Response> {
+    if matches_inline_media_source(payload.source_video_src.as_str()) {
+        return Err(character_animation_error_response(
+            request_context,
+            editor_character_animation_bad_request("�视频必须先上传 OSS，并使用稳定媒体引用。"),
+        ));
+    }
+    crate::editor_sequence_animation::normalize_editor_character_animation_video_conversion_resolution(
+        payload.resolution.as_str(),
+    )
+    .map_err(|error| character_animation_error_response(request_context, error))?;
+    let target = preflight_editor_billable_generation_target(
+        state,
+        owner_user_id,
+        payload.project_id.clone(),
+        payload
+            .asset_folder_id
+            .clone()
+            .or_else(|| Some("project".to_string())),
+    )
+    .await
+    .map_err(|error| character_animation_error_response(request_context, error))?;
+    payload.project_id = target.project_id;
+    payload.asset_folder_id = target.asset_folder_id;
+    let source_entity_id = editor_generation_source_entity_id(
+        payload.project_id.as_deref(),
+        "character-animation-video-conversion",
+    );
+    enqueue_editor_generation_job_for_caller(
+        state,
+        request_context,
+        owner_user_id,
+        EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND,
+        source_entity_id,
+        "视频直接转��列帧",
+        0,
+        &payload,
+        None,
+    )
+    .await
+    .map_err(|error| error.into_response_with_context(Some(request_context)))
+}
+
 pub(crate) async fn generate_editor_character_animation_for_owner(
     state: AppState,
     request_context: RequestContext,
@@ -1085,6 +1565,10 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
             .reference_src
             .as_deref()
             .is_some_and(matches_inline_media_source)
+        || payload
+            .appearance_reference_srcs
+            .iter()
+            .any(|source| matches_inline_media_source(source.as_str()))
     {
         return Err(character_animation_error_response(
             &request_context,
@@ -1214,6 +1698,39 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
             (Some(object_key), None)
         }
     };
+    let mut appearance_object_keys = Vec::new();
+    if !payload.appearance_reference_srcs.is_empty() {
+        if provisional_normalized.input_mode != EditorCharacterAnimationInputMode::Video {
+            return Err(character_animation_error_response(
+                &request_context,
+                editor_character_animation_bad_request("角色外观图仅支�视频模�。"),
+            ));
+        }
+        for appearance_src in &payload.appearance_reference_srcs {
+            let appearance_src = appearance_src.trim();
+            if appearance_src.is_empty() {
+                continue;
+            }
+            let object_key = resolve_editor_reference_object_key_for_owner(
+                &state,
+                owner_user_id.as_str(),
+                appearance_src,
+            )
+            .await
+            .map_err(|error| character_animation_error_response(&request_context, error))?;
+            // 先下载并解�图片完��� MIME�尺寸和内容校验；Provider 阶段必须继续使用
+            // 稳定 objectKey，由统一视频�考解�器签��访问 URL，�能把内部 data URL 传下去。
+            resolve_editor_character_animation_reference_image(
+                &state,
+                &source_resolve_client,
+                object_key.as_str(),
+                "appearanceReferenceSrcs",
+            )
+            .await
+            .map_err(|error| character_animation_error_response(&request_context, error))?;
+            appearance_object_keys.push(object_key);
+        }
+    }
     let priced = normalize_editor_character_animation_request_with_pricing(
         payload.clone(),
         &pricing,
@@ -1230,15 +1747,33 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
     )
     .await
     .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let mut appearance_source_resource_ids = Vec::with_capacity(appearance_object_keys.len());
+    for (index, appearance_object_key) in appearance_object_keys.iter().enumerate() {
+        let appearance_source_resource_id = validate_editor_character_animation_source_resource(
+            &state,
+            owner_user_id.as_str(),
+            project_id.as_deref(),
+            EditorCharacterAnimationInputMode::Image,
+            payload
+                .appearance_source_resource_ids
+                .get(index)
+                .map(String::as_str),
+            Some(appearance_object_key.as_str()),
+        )
+        .await
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+        appearance_source_resource_ids.push(appearance_source_resource_id);
+    }
     let authoritative_generation_inputs =
         build_authoritative_editor_character_animation_generation_inputs(
             client_generation_inputs,
             &payload,
             priced.input_mode,
             reference_object_key.as_deref(),
+            &appearance_object_keys,
         )
         .map_err(|error| character_animation_error_response(&request_context, error))?;
-    let generation_reference_sources = reference_object_key
+    let mut generation_reference_sources: Vec<(String, String)> = reference_object_key
         .as_ref()
         .map(|object_key| {
             (
@@ -1257,6 +1792,16 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
         })
         .into_iter()
         .collect();
+    for (index, object_key) in appearance_object_keys.iter().enumerate() {
+        generation_reference_sources.push((
+            "�考图片".to_string(),
+            appearance_source_resource_ids
+                .get(index)
+                .cloned()
+                .flatten()
+                .unwrap_or_else(|| object_key.clone()),
+        ));
+    }
     let generation_inputs = rebuild_editor_generation_input_references(
         &state,
         owner_user_id.as_str(),
@@ -1361,6 +1906,7 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
                         task_id.as_str(),
                         &normalized,
                         reference_object_key.as_deref(),
+                        &appearance_object_keys,
                     )
                     .await?
                 }
@@ -1371,32 +1917,71 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
             // 都走 execute_billable 的失败退款。数�库事实��与 canvas/job 一次性原��交。
             // 有别于角色生图 / 编辑器视频（provider 产物�交付物，provider �功�收�扣费）。
             if let Some(reporter) = caller.phase_reporter.as_ref() {
-                reporter.report_processing(&state).await?;
+                if let Err(error) = reporter.report_processing(&state).await {
+                    cleanup_generated_editor_character_animation_preview(
+                        &state,
+                        &generated,
+                        "editor_animation_preview_cleanup_failed",
+                    )
+                    .await;
+                    return Err(error);
+                }
             }
-            let persisted_frames = extract_and_prepare_editor_character_animation_frames(
-                &state,
-                &caller,
-                normalized.source_layer_id.as_str(),
-                task_id.as_str(),
-                generated.preview_video_path.as_str(),
-                &normalized,
-                &extraction_settings,
-                &matting_audit,
-            )
-            .await?;
+            let persisted_frames =
+                match extract_and_prepare_editor_character_animation_frames(
+                    &state,
+                    &caller,
+                    normalized.source_layer_id.as_str(),
+                    task_id.as_str(),
+                    generated.preview_video_path.as_str(),
+                    &normalized,
+                    &extraction_settings,
+                    &matting_audit,
+                )
+                .await
+                {
+                    Ok(persisted_frames) => persisted_frames,
+                    Err(error) => {
+                        cleanup_generated_editor_character_animation_preview(
+                            &state,
+                            &generated,
+                            "editor_animation_preview_cleanup_failed",
+                        )
+                        .await;
+                        return Err(error);
+                    }
+                };
             let frames = persisted_frames.frames.clone();
-            frames.first().ok_or_else(|| {
-                AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
-                    "provider": "editor-character-animation",
-                    "message": "角色动作抽帧完�但没有��存的�列帧。",
-                }))
-            })?;
-            let frame_payload_json = serde_json::to_value(&frames).map_err(|error| {
-                AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
-                    "provider": "editor-character-animation",
-                    "message": format!("角色动作�列帧无法�久化：{error}"),
-                }))
-            })?;
+            if frames.first().is_none() {
+                cleanup_generated_editor_character_animation_preview(
+                    &state,
+                    &generated,
+                    "editor_animation_preview_cleanup_failed",
+                )
+                .await;
+                return Err(AppError::from_status(StatusCode::BAD_GATEWAY).with_details(
+                    json!({
+                        "provider": "editor-character-animation",
+                        "message": "角色动作抽帧完�但没有��存的�列帧。",
+                    }),
+                ));
+            }
+            let frame_payload_json = match serde_json::to_value(&frames) {
+                Ok(frame_payload_json) => frame_payload_json,
+                Err(error) => {
+                    cleanup_generated_editor_character_animation_preview(
+                        &state,
+                        &generated,
+                        "editor_animation_preview_cleanup_failed",
+                    )
+                    .await;
+                    return Err(AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
+                        .with_details(json!({
+                            "provider": "editor-character-animation",
+                            "message": format!("角色动作�列帧无法�久化：{error}"),
+                        })));
+                }
+            };
             Ok::<_, AppError>((generated, frames, normalized, persisted_frames, frame_payload_json))
         },
     )
@@ -1414,7 +1999,7 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
         )
     })?;
     let completed_at_micros = current_utc_micros();
-    let prepared = prepare_editor_character_animation_result(
+    let prepared = match prepare_editor_character_animation_result(
         &caller,
         project_id.as_deref(),
         asset_folder_id.as_deref().or(Some("project")),
@@ -1426,8 +2011,17 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
         &persisted_frames,
         frame_payload_json,
         completed_at_micros,
-    )
-    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    ) {
+        Ok(prepared) => prepared,
+        Err(error) => {
+            let mut object_keys = persisted_frames.uploaded_object_keys.clone();
+            if let Some(preview_object_key) = generated.object_key.as_deref() {
+                object_keys.push(preview_object_key.to_string());
+            }
+            cleanup_uncommitted_character_animation_objects(&state, &object_keys).await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
     let layer_id = format!("layer-editor-character-animation-{task_id}");
     let canvas_item = canvas_completion.as_ref().map(|completion| {
         build_editor_character_animation_canvas_placement_item(
@@ -1485,7 +2079,7 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
             "asset": compact_asset,
         }),
     );
-    let persisted = persist_editor_generation_result_atomically(
+    let persisted = match persist_editor_generation_result_atomically(
         &state,
         &caller,
         prepared.items,
@@ -1494,7 +2088,17 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
         completed_at_micros,
     )
     .await
-    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    {
+        Ok(persisted) => persisted,
+        Err(error) => {
+            let mut object_keys = persisted_frames.uploaded_object_keys.clone();
+            if let Some(preview_object_key) = generated.object_key.as_deref() {
+                object_keys.push(preview_object_key.to_string());
+            }
+            cleanup_uncommitted_character_animation_objects(&state, &object_keys).await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
     let final_resource = persisted
         .items
         .iter()
@@ -1554,6 +2158,303 @@ pub(crate) async fn generate_editor_character_animation_for_owner(
     ))
 }
 
+pub(crate) async fn convert_editor_character_animation_video_for_owner(
+    state: AppState,
+    request_context: RequestContext,
+    caller: EditorGenerationCaller,
+    payload: Result<Json<EditorCharacterAnimationVideoConversionRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(mut payload) = payload.map_err(|error| {
+        character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request(error.body_text()),
+        )
+    })?;
+    if matches_inline_media_source(payload.source_video_src.as_str()) {
+        return Err(character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("�视频必须先上传 OSS，并使用稳定媒体引用。"),
+        ));
+    }
+    if payload.canvas_completion.is_some()
+        && payload
+            .project_id
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .is_none()
+    {
+        return Err(character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("视频直接转�画布完�需�有效的 projectId。"),
+        ));
+    }
+    let owner_user_id = caller.owner_user_id.clone();
+    let target = preflight_editor_billable_generation_target(
+        &state,
+        owner_user_id.as_str(),
+        payload.project_id.clone(),
+        payload
+            .asset_folder_id
+            .clone()
+            .or_else(|| Some("project".to_string())),
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    payload.project_id = target.project_id;
+    payload.asset_folder_id = target.asset_folder_id;
+    let project_id = payload.project_id.clone();
+    let canvas_completion = payload.canvas_completion.clone();
+    let asset_label =
+        resolve_editor_character_animation_asset_label(payload.asset_label.as_deref());
+    let source_client = build_upstream_http_client(SOURCE_IMAGE_RESOLVE_TIMEOUT_MS)
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let source_object_key = resolve_editor_reference_object_key_for_owner(
+        &state,
+        owner_user_id.as_str(),
+        payload.source_video_src.as_str(),
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let extraction_settings = resolve_backend_frame_extraction_settings(&state);
+    let metadata = validate_editor_character_animation_reference_video_object(
+        &state,
+        &source_client,
+        owner_user_id.as_str(),
+        source_object_key.as_str(),
+        "sourceVideoSrc",
+        &extraction_settings,
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let plan = build_editor_character_animation_video_conversion_plan(
+        metadata.duration_seconds,
+        metadata.source_fps,
+        metadata.width,
+        metadata.height,
+        payload.resolution.as_str(),
+    )
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let source_resource_id = validate_editor_character_animation_source_resource(
+        &state,
+        owner_user_id.as_str(),
+        project_id.as_deref(),
+        EditorCharacterAnimationInputMode::Video,
+        payload.source_resource_id.as_deref(),
+        Some(source_object_key.as_str()),
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let source_resource_id =
+        source_resource_id.or(resolve_editor_character_animation_source_asset_resource(
+            &state,
+            owner_user_id.as_str(),
+            project_id.as_deref(),
+            payload.generation_inputs.as_ref(),
+            source_object_key.as_str(),
+        )
+        .await
+        .map_err(|error| character_animation_error_response(&request_context, error))?);
+    let authoritative_inputs =
+        build_authoritative_editor_character_animation_video_conversion_inputs(
+            payload.generation_inputs.clone(),
+            &payload,
+            source_object_key.as_str(),
+            plan,
+        )
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let generation_inputs = rebuild_editor_generation_input_references(
+        &state,
+        owner_user_id.as_str(),
+        Some(authoritative_inputs),
+        vec![(
+            "�视频".to_string(),
+            source_resource_id
+                .clone()
+                .unwrap_or_else(|| source_object_key.clone()),
+        )],
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let operation = editor_generation_operation(&caller)
+        .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let task_id = operation.operation_id.clone();
+    // operation_id 用于�久化幂等；帧对象路径还绑定请求 fingerprint。相� request id
+    // 的��请求�会互相覆盖，�试�一请求�能�用路径。
+    let storage_task_id = format!(
+        "{}-{}",
+        sanitize_storage_segment(owner_user_id.as_str(), "owner"),
+        operation.operation_fingerprint
+    );
+    if let Some(reporter) = caller.phase_reporter.as_ref() {
+        reporter
+            .report_processing(&state)
+            .await
+            .map_err(|error| character_animation_error_response(&request_context, error))?;
+    }
+    let persisted_frames = extract_and_prepare_direct_video_conversion_frames(
+        &state,
+        &caller,
+        storage_task_id.as_str(),
+        source_object_key.as_str(),
+        plan,
+        &extraction_settings,
+    )
+    .await
+    .map_err(|error| character_animation_error_response(&request_context, error))?;
+    let frames = persisted_frames.frames.clone();
+    let first_frame = frames.first().ok_or_else(|| {
+        character_animation_error_response(
+            &request_context,
+            editor_character_animation_bad_request("视频直接转�没有产生�列帧。"),
+        )
+    })?;
+    let frame_payload_json = serde_json::to_value(&frames).map_err(|error| {
+        character_animation_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
+                "provider": "editor-character-animation",
+                "message": format!("�列化直接转�帧失败：{error}"),
+            })),
+        )
+    })?;
+    let completed_at_micros = current_utc_micros();
+    let prepared = match prepare_editor_character_animation_sequence_result(
+        &caller,
+        project_id.as_deref(),
+        payload.asset_folder_id.as_deref(),
+        asset_label.as_str(),
+        "FFmpeg",
+        source_resource_id,
+        generation_inputs,
+        plan,
+        &persisted_frames,
+        frame_payload_json,
+        completed_at_micros,
+    ) {
+        Ok(prepared) => prepared,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(
+                &state,
+                &persisted_frames.uploaded_object_keys,
+            )
+            .await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
+    let layer_id = format!("layer-editor-character-animation-{task_id}");
+    let canvas_item = canvas_completion.as_ref().map(|completion| {
+        build_editor_character_animation_canvas_placement_item(
+            completion,
+            prepared.final_resource_id.as_str(),
+            first_frame.width,
+            first_frame.height,
+            layer_id.as_str(),
+        )
+    });
+    let canvas_layout_plan = EditorCanvasLayoutPlan::generation(
+        owner_user_id.as_str(),
+        project_id.as_deref(),
+        canvas_completion.as_ref(),
+        canvas_item.into_iter().collect(),
+        Some(layer_id),
+    );
+    let final_candidate = prepared
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .ok_or_else(|| {
+            character_animation_error_response(
+                &request_context,
+                editor_character_animation_bad_request("视频直接转�缺少最终候选记录。"),
+            )
+        })?;
+    let compact_resource = final_candidate
+        .project_resource
+        .as_ref()
+        .map(compact_editor_generation_candidate_resource);
+    let compact_asset = final_candidate
+        .asset
+        .as_ref()
+        .map(compact_editor_generation_candidate_asset);
+    let job_result_payload_json = editor_generation_job_result_payload_json(
+        &caller,
+        json!({
+            "ok": true,
+            "taskId": task_id,
+            "processingMethod": "视频直接转�",
+            "frames": &frames,
+            "frameCount": frames.len(),
+            "durationMs": plan.duration_ms,
+            "frameWidth": plan.frame_width,
+            "frameHeight": plan.frame_height,
+            "sourceFps": plan.source_fps,
+            "samplingFps": plan.sampling_fps,
+            "priceMudPoints": 0,
+            "resource": compact_resource,
+            "asset": compact_asset,
+        }),
+    );
+    let persisted = match persist_editor_generation_result_atomically(
+        &state,
+        &caller,
+        prepared.items,
+        canvas_layout_plan,
+        job_result_payload_json,
+        completed_at_micros,
+    )
+    .await
+    {
+        Ok(persisted) => persisted,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(
+                &state,
+                &persisted_frames.uploaded_object_keys,
+            )
+            .await;
+            return Err(character_animation_error_response(&request_context, error));
+        }
+    };
+    let final_resource = persisted
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .and_then(|item| item.project_resource.clone())
+        .map(editor_project_resource_payload_from_record)
+        .and_then(|resource| serde_json::to_value(resource).ok());
+    let final_asset = persisted
+        .items
+        .iter()
+        .find(|item| item.slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .and_then(|item| item.asset.clone())
+        .map(editor_asset_payload_from_record)
+        .and_then(|asset| serde_json::to_value(asset).ok());
+    let completed_project = persisted
+        .project
+        .map(editor_project_payload_from_record)
+        .and_then(|project| serde_json::to_value(project).ok());
+    Ok(json_success_body(
+        Some(&request_context),
+        EditorCharacterAnimationVideoConversionResponse {
+            ok: true,
+            task_id,
+            processing_method: "视频直接转�".to_string(),
+            frames,
+            frame_count: plan.frame_count,
+            duration_ms: plan.duration_ms,
+            frame_width: plan.frame_width,
+            frame_height: plan.frame_height,
+            source_fps: plan.source_fps,
+            sampling_fps: plan.sampling_fps,
+            price_mud_points: 0,
+            project: completed_project,
+            resource: final_resource,
+            asset: final_asset,
+            queue_state: None,
+        },
+    ))
+}
+
 pub async fn generate_editor_video(
     State(state): State<AppState>,
     Extension(request_context): Extension<RequestContext>,
@@ -2338,6 +3239,87 @@ async fn resolve_media_source_as_data_url(
     Ok(media_payload_as_data_url(&payload))
 }
 
+async fn resolve_editor_character_animation_source_asset_resource(
+    state: &AppState,
+    owner_user_id: &str,
+    project_id: Option<&str>,
+    generation_inputs: Option<&Value>,
+    source_object_key: &str,
+) -> Result<Option<String>, AppError> {
+    let Some(reference) = generation_inputs
+        .and_then(Value::as_object)
+        .and_then(|inputs| inputs.get("references"))
+        .and_then(Value::as_array)
+        .and_then(|references| {
+            references.iter().find(|reference| {
+                reference.get("id").and_then(Value::as_str) == Some("source")
+                    || reference.get("id").and_then(Value::as_str) == Some("motion")
+            })
+        })
+    else {
+        return Ok(None);
+    };
+    if reference.get("refType").and_then(Value::as_str) != Some("asset") {
+        return Ok(None);
+    }
+    let Some(asset_id) = reference.get("refId").and_then(Value::as_str) else {
+        return Ok(None);
+    };
+    let library = state
+        .spacetime_client()
+        .get_editor_asset_library(owner_user_id.to_string(), current_utc_micros())
+        .await
+        .map_err(map_editor_project_error)?;
+    let Some(asset) = library
+        .assets
+        .iter()
+        .find(|asset| asset.asset_id.trim() == asset_id.trim())
+    else {
+        return Err(editor_character_animation_bad_request(
+            "�视频素��属于当�账�。",
+        ));
+    };
+    let asset_object_key = normalize_editor_record_object_key(
+        asset.object_key.as_deref(),
+        asset.image_src.as_str(),
+    )
+    .ok_or_else(|| editor_character_animation_bad_request("�视频素�缺少稳定 objectKey。"))?;
+    if asset_object_key != source_object_key.trim().trim_start_matches('/') {
+        return Err(editor_character_animation_bad_request(
+            "�视频素�与本次转�对象�一致。",
+        ));
+    }
+    let Some(source_resource_id) = asset.source_resource_id.as_deref() else {
+        return Ok(None);
+    };
+    let Some(project_id) = project_id.map(str::trim).filter(|id| !id.is_empty()) else {
+        return Ok(None);
+    };
+    let project = state
+        .spacetime_client()
+        .get_editor_project(EditorProjectGetRecordInput {
+            project_id: project_id.to_string(),
+            owner_user_id: owner_user_id.to_string(),
+        })
+        .await
+        .map_err(map_editor_project_error)?;
+    let resource = project
+        .resources
+        .iter()
+        .find(|resource| resource.resource_id.trim() == source_resource_id.trim())
+        .ok_or_else(|| {
+            editor_character_animation_bad_request("�视频素���资��属于当�画布项目。")
+        })?;
+    if resource.owner_user_id.trim() != owner_user_id.trim()
+        || resource.project_id.trim() != project_id
+    {
+        return Err(editor_character_animation_bad_request(
+            "�视频素���资��属于当�账�或当�画布项目。",
+        ));
+    }
+    Ok(Some(source_resource_id.trim().to_string()))
+}
+
 async fn validate_editor_character_animation_source_resource(
     state: &AppState,
     owner_user_id: &str,
@@ -2459,8 +3441,13 @@ async fn resolve_editor_character_animation_reference_image(
             "�考图片缺少�识别的媒体宽高。",
         ));
     }
+    // 数� URL 必须与声明的��宽高一致：带 EXIF 旋转（如手机竖�）的�图在
+    // apply_orientation �宽高已交�，若�返回原始字节，`ratio="same"` 会用声明尺寸
+    // 去算帧尺寸而 provider 实际拿到的是未旋转图�，导致 letterbox 与预览错�。
+    let data_url = encode_rgba_image_as_png_data_url(&decoded.to_rgba8())
+        .ok_or_else(|| editor_character_animation_bad_request("�考图片�新编�失败。"))?;
     Ok(ResolvedEditorCharacterAnimationReferenceImage {
-        data_url: media_payload_as_data_url(&payload),
+        data_url,
         width: decoded.width(),
         height: decoded.height(),
     })
@@ -2575,7 +3562,7 @@ fn probe_editor_character_animation_reference_video_metadata(
                 "-select_streams",
                 "v:0",
                 "-show_entries",
-                "stream=width,height:stream_tags=rotate:stream_side_data=rotation:format=duration",
+                "stream=width,height,avg_frame_rate,r_frame_rate:stream_tags=rotate:stream_side_data=rotation:format=duration",
                 "-of",
                 "json",
                 input_path.to_string_lossy().as_ref(),
@@ -2633,10 +3620,22 @@ fn parse_editor_character_animation_reference_video_probe(
     {
         std::mem::swap(&mut width, &mut height);
     }
+    let source_fps = stream
+        .get("avg_frame_rate")
+        .and_then(Value::as_str)
+        .and_then(crate::editor_sequence_animation::parse_editor_character_animation_ffprobe_frame_rate)
+        .or_else(|| {
+            stream
+                .get("r_frame_rate")
+                .and_then(Value::as_str)
+                .and_then(crate::editor_sequence_animation::parse_editor_character_animation_ffprobe_frame_rate)
+        })
+        .unwrap_or(1.0);
     Ok(EditorCharacterAnimationReferenceVideoMetadata {
         duration_seconds,
         width,
         height,
+        source_fps,
     })
 }
 
@@ -3007,14 +4006,26 @@ async fn put_generated_editor_character_animation_preview(
         ),
     )
     .await?;
-    let prepared_asset_object = prepare_editor_character_animation_source_asset_object(
+    let prepared_asset_object = match prepare_editor_character_animation_source_asset_object(
         state,
         caller,
         source_layer_id,
         put_result.object_key.clone(),
         content_type,
     )
-    .await?;
+    .await
+    {
+        Ok(prepared_asset_object) => prepared_asset_object,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_object(
+                state,
+                put_result.object_key.as_str(),
+                "editor_animation_preview_prepare_cleanup_failed",
+            )
+            .await;
+            return Err(error);
+        }
+    };
 
     Ok(PersistedEditorCharacterAnimationPreview {
         legacy_public_path: put_result.legacy_public_path,
@@ -3079,9 +4090,14 @@ async fn request_editor_sequence_animation_text_or_video_preview(
     task_id: &str,
     request: &NormalizedEditorCharacterAnimationRequest,
     reference_object_key: Option<&str>,
+    appearance_reference_srcs: &[String],
 ) -> Result<GeneratedAnimationPreview, AppError> {
-    let video_request =
-        build_editor_sequence_animation_video_request(settings, request, reference_object_key)?;
+    let video_request = build_editor_sequence_animation_video_request(
+        settings,
+        request,
+        reference_object_key,
+        appearance_reference_srcs,
+    )?;
     let video_settings = EditorVideoSettings {
         ark: settings.ark.clone(),
     };
@@ -3130,6 +4146,7 @@ fn build_editor_sequence_animation_video_request(
     settings: &EditorCharacterAnimationSettings,
     request: &NormalizedEditorCharacterAnimationRequest,
     reference_object_key: Option<&str>,
+    appearance_reference_srcs: &[String],
 ) -> Result<NormalizedEditorVideoRequest, AppError> {
     let reference_video_srcs = match request.input_mode {
         EditorCharacterAnimationInputMode::Text => Vec::new(),
@@ -3145,7 +4162,14 @@ fn build_editor_sequence_animation_video_request(
         }
     };
     Ok(NormalizedEditorVideoRequest {
-        prompt: request.prompt.clone(),
+        prompt: if !appearance_reference_srcs.is_empty() {
+            format!(
+                "{}\n严格使用�考视频的动作�节�与镜头；严格使用�考图片的角色外观��装和身份，�交�两��考的�责。",
+                request.prompt
+            )
+        } else {
+            request.prompt.clone()
+        },
         model: EDITOR_CHARACTER_ANIMATION_MODEL.to_string(),
         provider_model: settings.ark.model.clone(),
         aspect_ratio: request.ratio.clone(),
@@ -3155,7 +4179,7 @@ fn build_editor_sequence_animation_video_request(
         price_mud_points: request.price_mud_points,
         width: request.frame_width,
         height: request.frame_height,
-        reference_image_srcs: Vec::new(),
+        reference_image_srcs: appearance_reference_srcs.to_vec(),
         reference_video_srcs,
         reference_audio_srcs: Vec::new(),
     })
@@ -3532,6 +4556,11 @@ async fn extract_and_prepare_editor_character_animation_frames(
             error = %error,
             "editor_animation_frame_pipeline_failed_after_drain"
         );
+        let uploaded_object_keys = frame_payloads
+            .iter()
+            .map(|frame| frame.object_key.clone())
+            .collect::<Vec<_>>();
+        cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
         return Err(error);
     }
 
@@ -3554,9 +4583,14 @@ fn build_persisted_editor_character_animation_frame_set(
         .iter()
         .map(|frame| (frame.slot.clone(), frame.prepared_asset_object.clone()))
         .collect();
+    let uploaded_object_keys = frame_payloads
+        .iter()
+        .map(|frame| frame.object_key.clone())
+        .collect();
     Ok(PersistedEditorCharacterAnimationFrameSet {
         first_frame_object_key,
         prepared_asset_objects,
+        uploaded_object_keys,
         frames: frame_payloads
             .into_iter()
             .map(|frame| frame.payload)
@@ -3564,6 +4598,334 @@ fn build_persisted_editor_character_animation_frame_set(
     })
 }
 
+async fn cleanup_generated_editor_character_animation_preview(
+    state: &AppState,
+    generated: &GeneratedAnimationPreview,
+    reason: &'static str,
+) {
+    let Some(object_key) = generated.object_key.as_deref() else {
+        return;
+    };
+    cleanup_uncommitted_character_animation_object(state, object_key, reason).await;
+}
+
+async fn cleanup_uncommitted_character_animation_object(
+    state: &AppState,
+    object_key: &str,
+    reason: &'static str,
+) {
+    let Ok(oss_client) = require_oss_client(state) else {
+        return;
+    };
+    // 清��必须先查正� asset_object；首次�交�功但�应丢失�，�试失败�能把
+    // 已�交结果引用的对象删掉。查询失败时采� fail-closed，��留下孤儿对象，也�能
+    // 破�正�资产。
+    let registered = match state
+        .spacetime_client()
+        .get_asset_object_by_location(module_assets::AssetObjectLocationInput {
+            bucket: oss_client.config_bucket().to_string(),
+            object_key: object_key.to_string(),
+        })
+        .await
+    {
+        Ok(registered) => registered,
+        Err(error) => {
+            tracing::warn!(
+                object_key,
+                error = %error,
+                reason,
+                "character_animation_orphan_cleanup_registration_lookup_failed"
+            );
+            return;
+        }
+    };
+    if registered.is_some() {
+        tracing::debug!(
+            object_key,
+            reason,
+            "character_animation_orphan_cleanup_skipped_registered_object"
+        );
+        return;
+    }
+    if let Err(error) = oss_client
+        .delete_object(
+            state.character_animation_oss_http_client(),
+            OssDeleteObjectRequest {
+                object_key: object_key.to_string(),
+            },
+        )
+        .await
+    {
+        tracing::warn!(
+            object_key,
+            error = %error,
+            reason,
+            "character_animation_orphan_cleanup_failed"
+        );
+    }
+}
+
+async fn cleanup_uncommitted_character_animation_objects(state: &AppState, object_keys: &[String]) {
+    for object_key in object_keys {
+        cleanup_uncommitted_character_animation_object(
+            state,
+            object_key.as_str(),
+            "direct_video_conversion_orphan_cleanup_failed",
+        )
+        .await;
+    }
+}
+
+async fn extract_and_prepare_direct_video_conversion_frames(
+    state: &AppState,
+    caller: &EditorGenerationCaller,
+    task_id: &str,
+    source_object_key: &str,
+    plan: crate::editor_sequence_animation::EditorCharacterAnimationVideoConversionPlan,
+    extraction_settings: &BackendFrameExtractionSettings,
+) -> Result<PersistedEditorCharacterAnimationFrameSet, AppError> {
+    let payload = load_media_source_payload_with_client(
+        state,
+        state.character_animation_oss_http_client(),
+        source_object_key,
+        Some(EDITOR_CHARACTER_ANIMATION_REFERENCE_VIDEO_MAX_BYTES),
+    )
+    .await?;
+    let temp_dir = create_animation_temp_dir()?;
+    let input_path = temp_dir.join(format!("source.{}", payload.extension));
+    fs::write(&input_path, payload.bytes).map_err(|error| {
+        AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
+            "provider": "editor-character-animation",
+            "message": format!("写入直接转��视频失败：{error}"),
+        }))
+    })?;
+    let extraction = (|| {
+        let target_seconds = (0..plan.frame_count)
+            .map(|index| {
+                compute_sample_time_seconds(
+                    plan.duration_seconds,
+                    index,
+                    plan.frame_count,
+                    0.0,
+                    1.0,
+                    true,
+                )
+            })
+            .collect::<Vec<_>>();
+        let output_paths = (0..plan.frame_count)
+            .map(|index| temp_dir.join(format!("frame-{:03}.png", index + 1)))
+            .collect::<Vec<_>>();
+        extract_video_frames_to_png(
+            &input_path,
+            output_paths.as_slice(),
+            target_seconds.as_slice(),
+            extraction_settings,
+        )?;
+        output_paths
+            .into_iter()
+            .map(|path| {
+                let bytes = fs::read(path).map_err(|error| {
+                    AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                        "provider": "editor-character-animation",
+                        "message": format!("读�直接转�帧失败：{error}"),
+                    }))
+                })?;
+                finalize_animation_frame_payload(
+                    bytes.as_slice(),
+                    "image/png",
+                    plan.frame_width,
+                    plan.frame_height,
+                    false,
+                )
+            })
+            .collect::<Result<Vec<_>, _>>()
+    })();
+    let _ = fs::remove_dir_all(&temp_dir);
+    let frames = extraction?;
+    let mut processed = Vec::with_capacity(frames.len());
+    let mut uploaded_object_keys = Vec::with_capacity(frames.len());
+    for (frame_index, frame) in frames.into_iter().enumerate() {
+        let content_type = frame.mime_type.clone();
+        let put_result = match put_character_animation_frame_object(
+            state,
+            frame_index + 1,
+            "conversion_frame_put",
+            LegacyAssetPrefix::Animations,
+            vec![
+                "editor".to_string(),
+                "video-conversions".to_string(),
+                task_id.to_string(),
+            ],
+            format!("frame{:03}.png", frame_index + 1),
+            frame.mime_type,
+            frame.bytes,
+            build_asset_metadata(
+                EDITOR_CHARACTER_ANIMATION_ASSET_KIND,
+                caller.owner_user_id.as_str(),
+                "editor_video_conversion",
+                task_id,
+                "animation_frame",
+                "video-direct-conversion",
+            ),
+        )
+        .await
+        {
+            Ok(result) => result,
+            Err(error) => {
+                cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+                return Err(error);
+            }
+        };
+        uploaded_object_keys.push(put_result.object_key.clone());
+        let slot = editor_character_animation_frame_slot(frame_index);
+        let prepared_asset_object = match prepare_editor_character_animation_frame_asset_object(
+            state,
+            caller,
+            task_id,
+            slot.as_str(),
+            put_result.object_key.clone(),
+            content_type,
+            frame_index + 1,
+        )
+        .await
+        {
+            Ok(result) => result,
+            Err(error) => {
+                cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+                return Err(error);
+            }
+        };
+        processed.push(ProcessedEditorCharacterAnimationFrame {
+            frame_index,
+            payload: build_editor_character_animation_frame_payload(
+                put_result.legacy_public_path,
+                put_result.object_key.clone(),
+                prepared_asset_object.asset_object_id.clone(),
+                plan.frame_width,
+                plan.frame_height,
+            ),
+            object_key: put_result.object_key,
+            prepared_asset_object,
+            slot,
+        });
+    }
+    match build_persisted_editor_character_animation_frame_set(processed) {
+        Ok(result) => Ok(result),
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+            Err(error)
+        }
+    }
+}
+
+/// 对已有�列帧�帧�通用抠图（BgFilter complex，无键色），生��明�列帧对象。
+/// 输入是��列帧资�的稳定 objectKey 列表；任一帧失败�整批清�，��布残缺结果。
+async fn extract_and_prepare_background_removal_frames(
+    state: &AppState,
+    caller: &EditorGenerationCaller,
+    task_id: &str,
+    source_frames: &[EditorCharacterAnimationFramePayload],
+    frame_width: u32,
+    frame_height: u32,
+    audit: &crate::external_api_audit::ExternalApiAuditContext,
+) -> Result<PersistedEditorCharacterAnimationFrameSet, AppError> {
+    let mut processed = Vec::with_capacity(source_frames.len());
+    let mut uploaded_object_keys = Vec::with_capacity(source_frames.len());
+    for (frame_index, source_frame) in source_frames.iter().enumerate() {
+        let source_object_key = source_frame
+            .object_key
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .ok_or_else(|| {
+                editor_character_animation_bad_request("�列帧缺少稳定 objectKey，无法去背景。")
+            })?;
+        let removed = request_editor_background_removal_image_with_bgfilter_worker(
+            state,
+            source_object_key,
+            audit,
+        )
+        .await?;
+        let finalized = finalize_animation_frame_payload(
+            removed.image.bytes.as_slice(),
+            removed.image.mime_type.as_str(),
+            frame_width,
+            frame_height,
+            false,
+        )?;
+        let content_type = finalized.mime_type.clone();
+        let put_result = match put_character_animation_frame_object(
+            state,
+            frame_index + 1,
+            "background_removal_frame_put",
+            LegacyAssetPrefix::Animations,
+            vec![
+                "editor".to_string(),
+                "background-removals".to_string(),
+                task_id.to_string(),
+            ],
+            format!("frame{:03}.png", frame_index + 1),
+            finalized.mime_type,
+            finalized.bytes,
+            build_asset_metadata(
+                EDITOR_CHARACTER_ANIMATION_ASSET_KIND,
+                caller.owner_user_id.as_str(),
+                "editor_background_removal",
+                task_id,
+                "animation_frame",
+                "background-removal",
+            ),
+        )
+        .await
+        {
+            Ok(result) => result,
+            Err(error) => {
+                cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+                return Err(error);
+            }
+        };
+        uploaded_object_keys.push(put_result.object_key.clone());
+        let slot = editor_character_animation_frame_slot(frame_index);
+        let prepared_asset_object = match prepare_editor_character_animation_frame_asset_object(
+            state,
+            caller,
+            task_id,
+            slot.as_str(),
+            put_result.object_key.clone(),
+            content_type,
+            frame_index + 1,
+        )
+        .await
+        {
+            Ok(result) => result,
+            Err(error) => {
+                cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+                return Err(error);
+            }
+        };
+        processed.push(ProcessedEditorCharacterAnimationFrame {
+            frame_index,
+            payload: build_editor_character_animation_frame_payload(
+                put_result.legacy_public_path,
+                put_result.object_key.clone(),
+                prepared_asset_object.asset_object_id.clone(),
+                frame_width,
+                frame_height,
+            ),
+            object_key: put_result.object_key,
+            prepared_asset_object,
+            slot,
+        });
+    }
+    match build_persisted_editor_character_animation_frame_set(processed) {
+        Ok(result) => Ok(result),
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(state, &uploaded_object_keys).await;
+            Err(error)
+        }
+    }
+}
+
 async fn process_and_persist_editor_character_animation_frame(
     state: &AppState,
     caller: &EditorGenerationCaller,
@@ -3576,7 +4938,8 @@ async fn process_and_persist_editor_character_animation_frame(
     screen_color: EditorScreenBackgroundColor,
     audit: &crate::external_api_audit::ExternalApiAuditContext,
 ) -> Result<ProcessedEditorCharacterAnimationFrame, AppError> {
-    // 中文注释：�一帧��求自己的绿幕�图先� OSS，��等待整批�图全部上传完�。
+    // �一帧的绿幕�图仅作为 BgFilter 输入，�是正�产物；无论该帧�续哪一步失败，
+    // 都必须清�它。最终 PNG �有在整批原�登记�功���为正�资产对象。
     let source_put = put_character_animation_frame_object(
         state,
         frame_index + 1,
@@ -3604,10 +4967,9 @@ async fn process_and_persist_editor_character_animation_frame(
         ),
     )
     .await?;
+    let source_object_key = source_put.object_key.clone();
 
-    // 排队与调用预算由共享 helper 按 N/est 公�和父剩余预算派生，动画帧���带
-    // 任何按帧数放大的 timeout。
-    let removed = remove_editor_generated_screen_background_with_bgfilter(
+    let removed = match remove_editor_generated_screen_background_with_bgfilter(
         state,
         source_put.object_key.as_str(),
         screen_color,
@@ -3615,21 +4977,44 @@ async fn process_and_persist_editor_character_animation_frame(
         EDITOR_BGFILTER_CROSS_CHECK_ENABLED,
         audit,
     )
-    .await?;
+    .await
+    {
+        Ok(removed) => removed,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_object(
+                state,
+                source_object_key.as_str(),
+                "editor_animation_source_cleanup_failed",
+            )
+            .await;
+            return Err(error);
+        }
+    };
     tracing::debug!(
         frame_index,
         screen_color = screen_color.hex,
         "editor_animation_frame_background_removed"
     );
-    let finalized = finalize_animation_frame_payload(
+    let finalized = match finalize_animation_frame_payload(
         removed.image.bytes.as_slice(),
         removed.image.mime_type.as_str(),
         frame_width,
         frame_height,
         false,
-    )?;
+    ) {
+        Ok(finalized) => finalized,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_object(
+                state,
+                source_object_key.as_str(),
+                "editor_animation_source_cleanup_failed",
+            )
+            .await;
+            return Err(error);
+        }
+    };
     let content_type = finalized.mime_type.clone();
-    let put_result = put_character_animation_frame_object(
+    let put_result = match put_character_animation_frame_object(
         state,
         frame_index + 1,
         "final_put",
@@ -3651,9 +5036,21 @@ async fn process_and_persist_editor_character_animation_frame(
             "editor-character-animation",
         ),
     )
-    .await?;
+    .await
+    {
+        Ok(result) => result,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_object(
+                state,
+                source_object_key.as_str(),
+                "editor_animation_source_cleanup_failed",
+            )
+            .await;
+            return Err(error);
+        }
+    };
     let slot = editor_character_animation_frame_slot(frame_index);
-    let prepared_asset_object = prepare_editor_character_animation_frame_asset_object(
+    let prepared_asset_object = match prepare_editor_character_animation_frame_asset_object(
         state,
         caller,
         source_layer_id,
@@ -3662,7 +5059,24 @@ async fn process_and_persist_editor_character_animation_frame(
         content_type,
         frame_index + 1,
     )
-    .await?;
+    .await
+    {
+        Ok(result) => result,
+        Err(error) => {
+            cleanup_uncommitted_character_animation_objects(
+                state,
+                &[source_object_key.clone(), put_result.object_key.clone()],
+            )
+            .await;
+            return Err(error);
+        }
+    };
+    cleanup_uncommitted_character_animation_object(
+        state,
+        source_object_key.as_str(),
+        "editor_animation_source_cleanup_failed",
+    )
+    .await;
 
     Ok(ProcessedEditorCharacterAnimationFrame {
         frame_index,
@@ -4189,6 +5603,7 @@ fn editor_inline_generation_caller<T: Serialize>(
             "message": format!("�列化编辑器生�幂等请求失败：{error}"),
         }))
     })?;
+    let operation_id = validate_editor_generation_operation_id(request_context.request_id())?;
     Ok(EditorGenerationCaller {
         audit_subject_user_id: Some(owner_user_id.clone()),
         audit_project_id: None,
@@ -4196,7 +5611,7 @@ fn editor_inline_generation_caller<T: Serialize>(
         phase_reporter: None,
         operation: Some(EditorGenerationOperationContext {
             operation_kind: operation_kind.to_string(),
-            operation_id: request_context.request_id().trim().to_string(),
+            operation_id,
             operation_fingerprint: editor_generation_request_fingerprint(
                 operation_kind,
                 request_payload_json.as_str(),
@@ -4448,6 +5863,132 @@ fn prepare_editor_character_animation_result(
     })
 }
 
+#[allow(clippy::too_many_arguments)]
+fn prepare_editor_character_animation_sequence_result(
+    caller: &EditorGenerationCaller,
+    project_id: Option<&str>,
+    asset_folder_id: Option<&str>,
+    asset_label: &str,
+    provider: &str,
+    source_resource_id: Option<String>,
+    generation_inputs: Option<Value>,
+    plan: crate::editor_sequence_animation::EditorCharacterAnimationVideoConversionPlan,
+    frames: &PersistedEditorCharacterAnimationFrameSet,
+    frame_payload_json: Value,
+    completed_at_micros: i64,
+) -> Result<PreparedEditorCharacterAnimationResult, AppError> {
+    let operation = editor_generation_operation(caller)?;
+    let first_frame = frames.frames.first().ok_or_else(|| {
+        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": "editor-character-animation",
+            "message": "�列帧生�没有产生��存的帧。",
+        }))
+    })?;
+    let final_object = frames
+        .prepared_asset_objects
+        .iter()
+        .find(|(slot, _)| slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+        .map(|(_, object)| object.clone())
+        .ok_or_else(|| editor_character_animation_bad_request("�列帧生�缺少首帧对象。"))?;
+    let final_resource_id = editor_generation_stable_resource_id(
+        caller.owner_user_id.as_str(),
+        operation.operation_kind.as_str(),
+        operation.operation_id.as_str(),
+        EDITOR_CHARACTER_ANIMATION_FINAL_SLOT,
+    );
+    let generation_inputs_json = serialize_editor_generation_inputs(
+        Some(EDITOR_CHARACTER_ANIMATION_RESOURCE_ASSET_KIND),
+        sanitize_editor_client_generation_inputs(generation_inputs),
+    )?;
+    let image_sequence_frames_json =
+        serialize_editor_image_sequence_frames(Some(frame_payload_json))?;
+    let project_id = project_id
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string);
+    let final_resource =
+        project_id
+            .as_ref()
+            .map(|project_id| EditorProjectResourceCreateRecordInput {
+                resource_id: final_resource_id.clone(),
+                project_id: project_id.clone(),
+                owner_user_id: caller.owner_user_id.clone(),
+                asset_object_id: Some(final_object.asset_object_id.clone()),
+                image_src: first_frame.image_src.clone(),
+                object_key: Some(frames.first_frame_object_key.clone()),
+                width: first_frame.width,
+                height: first_frame.height,
+                source_type: "generated".to_string(),
+                prompt: None,
+                actual_prompt: None,
+                model: None,
+                provider: Some(provider.to_string()),
+                task_id: Some(operation.operation_id.clone()),
+                source_resource_id: source_resource_id.clone(),
+                asset_kind: Some(EDITOR_CHARACTER_ANIMATION_RESOURCE_ASSET_KIND.to_string()),
+                generation_inputs_json: generation_inputs_json.clone(),
+                updated_at_micros: completed_at_micros,
+                image_sequence_frames_json: image_sequence_frames_json.clone(),
+                image_sequence_duration_ms: Some(plan.duration_ms),
+            });
+    let final_asset = asset_folder_id
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(|folder_id| EditorAssetCreateRecordInput {
+            asset_id: editor_generation_stable_asset_id(
+                caller.owner_user_id.as_str(),
+                operation.operation_kind.as_str(),
+                operation.operation_id.as_str(),
+                EDITOR_CHARACTER_ANIMATION_FINAL_SLOT,
+            ),
+            owner_user_id: caller.owner_user_id.clone(),
+            folder_id: folder_id.to_string(),
+            label: asset_label.to_string(),
+            asset_object_id: Some(final_object.asset_object_id.clone()),
+            image_src: first_frame.image_src.clone(),
+            object_key: Some(frames.first_frame_object_key.clone()),
+            width: first_frame.width,
+            height: first_frame.height,
+            source_type: "generated".to_string(),
+            prompt: None,
+            actual_prompt: None,
+            model: None,
+            provider: Some(provider.to_string()),
+            task_id: Some(operation.operation_id.clone()),
+            asset_kind: Some(EDITOR_CHARACTER_ANIMATION_RESOURCE_ASSET_KIND.to_string()),
+            generation_inputs_json,
+            source_resource_id: final_resource
+                .as_ref()
+                .map(|resource| resource.resource_id.clone()),
+            now_micros: completed_at_micros,
+            thumbnail_src: Some(first_frame.image_src.clone()),
+            generation_cost_mud_points: 0,
+            group_task_id: None,
+            group_task_expected_asset_count: None,
+            image_sequence_frames_json,
+            image_sequence_duration_ms: Some(plan.duration_ms),
+        });
+    let items = frames
+        .prepared_asset_objects
+        .iter()
+        .map(|(slot, object)| PreparedEditorGenerationResultItem {
+            slot: slot.clone(),
+            asset_object: Some(object.clone()),
+            project_resource: (slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+                .then(|| final_resource.clone())
+                .flatten(),
+            asset: (slot == EDITOR_CHARACTER_ANIMATION_FINAL_SLOT)
+                .then(|| final_asset.clone())
+                .flatten(),
+            binding: None,
+        })
+        .collect();
+    Ok(PreparedEditorCharacterAnimationResult {
+        items,
+        final_resource_id,
+    })
+}
+
 #[allow(clippy::too_many_arguments)]
 fn prepare_editor_video_result(
     caller: &EditorGenerationCaller,
@@ -6206,7 +7747,11 @@ async fn load_media_source_payload_with_client(
         validate_media_payload_download_size(next_len, max_bytes)?;
         bytes.extend_from_slice(chunk.as_ref());
     }
-    if head.content_length != u64::try_from(bytes.len()).unwrap_or(u64::MAX) {
+    // 有界下载（视频�考）��严格的 HEAD/GET 长度一致性校验：视频路径�赖该一致性
+    // 拒�截断或异常�。旧图片路径（max_bytes=None）��求 HEAD 与 chunked GET 完全一致，
+    // �� OSS 编� / 缓存差异导致原本�用的图片被误判失败。
+    if max_bytes.is_some() && head.content_length != u64::try_from(bytes.len()).unwrap_or(u64::MAX)
+    {
         return Err(
             AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                 "provider": "aliyun-oss",
@@ -6254,6 +7799,25 @@ fn media_payload_as_data_url(payload: &MediaPayload) -> String {
     )
 }
 
+fn encode_rgba_image_as_png_data_url(rgba: &RgbaImage) -> Option<String> {
+    let mut bytes = Vec::new();
+    if PngEncoder::new(&mut bytes)
+        .write_image(
+            rgba.as_raw(),
+            rgba.width(),
+            rgba.height(),
+            ColorType::Rgba8.into(),
+        )
+        .is_err()
+    {
+        return None;
+    }
+    Some(format!(
+        "data:image/png;base64,{}",
+        encode_base64(bytes.as_slice())
+    ))
+}
+
 fn parse_media_data_url(value: &str) -> Option<MediaPayload> {
     let body = value.trim().strip_prefix("data:")?;
     let (mime_type, data) = body.split_once(";base64,")?;
@@ -7479,6 +9043,7 @@ struct PersistedEditorCharacterAnimationFrameSet {
     frames: Vec<EditorCharacterAnimationFramePayload>,
     first_frame_object_key: String,
     prepared_asset_objects: Vec<(String, AssetObjectUpsertInput)>,
+    uploaded_object_keys: Vec<String>,
 }
 
 struct ProcessedEditorCharacterAnimationFrame {
@@ -7513,6 +9078,7 @@ struct EditorCharacterAnimationReferenceVideoMetadata {
     duration_seconds: f64,
     width: u32,
     height: u32,
+    source_fps: f64,
 }
 
 // �布整套动作�，当�阶段�需�把旧�端�赖的 animationMap 返回出去。
@@ -7540,6 +9106,7 @@ mod tests {
             input_mode: None,
             reference_media_type: None,
             reference_src: None,
+            appearance_reference_srcs: Vec::new(),
             prompt_text: "待机呼�".to_string(),
             background_color: None,
             screen_color: None,
@@ -7552,6 +9119,7 @@ mod tests {
             canvas_completion: None,
             generation_inputs: None,
             source_resource_id: None,
+            appearance_source_resource_ids: Vec::new(),
             asset_folder_id: None,
             asset_label: None,
         }
@@ -7812,6 +9380,7 @@ mod tests {
                 input_mode: None,
                 reference_media_type: None,
                 reference_src: None,
+                appearance_reference_srcs: Vec::new(),
                 prompt_text: "待机呼�".to_string(),
                 background_color: None,
                 screen_color: None,
@@ -7824,6 +9393,7 @@ mod tests {
                 canvas_completion: None,
                 generation_inputs: None,
                 source_resource_id: None,
+                appearance_source_resource_ids: Vec::new(),
                 asset_folder_id: None,
                 asset_label: None,
             })
@@ -7844,6 +9414,7 @@ mod tests {
                 input_mode: Some("video".to_string()),
                 reference_media_type: Some("video".to_string()),
                 reference_src: Some("users/owner/reference/action.mp4".to_string()),
+                appearance_reference_srcs: Vec::new(),
                 prompt_text: "�刻�考视频的奔跑节�".to_string(),
                 background_color: Some("blue".to_string()),
                 ratio: "16:9".to_string(),
@@ -7864,6 +9435,7 @@ mod tests {
             &settings,
             &normalized,
             Some("users/owner/reference/action.mp4"),
+            &[],
         )
         .expect("video request should build");
 
@@ -7883,6 +9455,36 @@ mod tests {
         );
         assert!(video_request.reference_image_srcs.is_empty());
         assert!(video_request.reference_audio_srcs.is_empty());
+
+        let video_request_with_appearance = build_editor_sequence_animation_video_request(
+            &settings,
+            &normalized,
+            Some("users/owner/reference/action.mp4"),
+            &["generated-character-drafts/editor/seedance-references/image/appearance.png"
+                .to_string()],
+        )
+        .expect("video request with appearance reference should build");
+        assert_eq!(
+            video_request_with_appearance.reference_video_srcs,
+            vec!["users/owner/reference/action.mp4".to_string()]
+        );
+        assert_eq!(
+            video_request_with_appearance.reference_image_srcs,
+            vec![
+                "generated-character-drafts/editor/seedance-references/image/appearance.png"
+                    .to_string()
+            ]
+        );
+        assert!(
+            video_request_with_appearance
+                .reference_image_srcs
+                .iter()
+                .all(|source| !source.starts_with("data:"))
+        );
+
+        let prompt = video_request_with_appearance.prompt;
+        assert!(prompt.contains("�考视频的动作"));
+        assert!(prompt.contains("�考图片的角色外观"));
     }
 
     #[test]
@@ -8064,7 +9666,7 @@ mod tests {
             &[
                 "execute_billable_asset_operation_with_cost",
                 "request_editor_character_animation_preview",
-                "reporter.report_processing(&state).await?",
+                "reporter.report_processing(&state).await",
                 "extract_and_prepare_editor_character_animation_frames",
                 "Ok::<_, AppError>((",
                 "prepare_editor_character_animation_result",
@@ -8214,6 +9816,46 @@ mod tests {
         }
     }
 
+    #[test]
+    fn editor_character_animation_direct_video_conversion_bypasses_seedance_and_background_removal()
+    {
+        let source = include_str!("character_animation_assets.rs");
+        assert_function_contains_in_order(
+            source,
+            "pub(crate) async fn convert_editor_character_animation_video_for_owner",
+            "pub async fn generate_editor_video",
+            &[
+                "validate_editor_character_animation_reference_video_object",
+                "build_editor_character_animation_video_conversion_plan",
+                "extract_and_prepare_direct_video_conversion_frames",
+                "prepare_editor_character_animation_sequence_result",
+                "persist_editor_generation_result_atomically",
+            ],
+        );
+        let body = source
+            .split_once("pub(crate) async fn convert_editor_character_animation_video_for_owner")
+            .and_then(|(_, tail)| {
+                tail.split_once("pub async fn generate_editor_video")
+                    .map(|(body, _)| body)
+            })
+            .expect("direct conversion function should exist");
+        for forbidden in [
+            "create_ark_content_generation_task",
+            "request_seedance",
+            "remove_editor_generated_screen_background_with_bgfilter",
+            "execute_billable_asset_operation_with_cost",
+        ] {
+            assert!(
+                !body.contains(forbidden),
+                "direct conversion must not call {forbidden}"
+            );
+        }
+        assert!(body.contains("price_mud_points: 0"));
+        assert!(body.contains("let storage_task_id = format!"));
+        assert!(body.contains("storage_task_id.as_str(),"));
+        assert!(body.contains("cleanup_uncommitted_character_animation_objects"));
+    }
+
     #[test]
     fn editor_character_animation_frames_use_three_stage_matting_fallback() {
         let source = include_str!("character_animation_assets.rs");
@@ -8292,8 +9934,8 @@ mod tests {
             "pub(crate) async fn generate_editor_character_animation_for_owner",
             "pub async fn generate_editor_video",
             &[
-                "let persisted_frames = extract_and_prepare_editor_character_animation_frames",
-                "let frame_payload_json = serde_json::to_value(&frames)",
+                "extract_and_prepare_editor_character_animation_frames",
+                "serde_json::to_value(&frames)",
                 "prepare_editor_character_animation_result",
                 "persist_editor_generation_result_atomically",
                 "EDITOR_CHARACTER_ANIMATION_FINAL_SLOT",
@@ -8593,7 +10235,7 @@ mod tests {
     fn editor_character_animation_parses_authoritative_video_probe_metadata() {
         let metadata = parse_editor_character_animation_reference_video_probe(
             br#"{
-                "streams": [{"width": 1080, "height": 1920}],
+                "streams": [{"width": 1080, "height": 1920, "avg_frame_rate": "30000/1000"}],
                 "format": {"duration": "6.250000"}
             }"#,
         )
@@ -8605,6 +10247,7 @@ mod tests {
                 duration_seconds: 6.25,
                 width: 1080,
                 height: 1920,
+                source_fps: 30.0,
             }
         );
 
diff --git a/server-rs/crates/api-server/src/editor_agent/tool.rs b/server-rs/crates/api-server/src/editor_agent/tool.rs
index f94f1678b..cef77e705 100644
--- a/server-rs/crates/api-server/src/editor_agent/tool.rs
+++ b/server-rs/crates/api-server/src/editor_agent/tool.rs
@@ -371,7 +371,6 @@ impl EditorAgentTool for GenerateImageTool {
             seg_model: None,
             aspect_ratio: Some(args.aspect_ratio),
             image_size: Some(args.image_size),
-            character_sheet_views: None,
             reference_image_srcs: Some(reference_image_srcs),
             project_id: Some(context.conversation.project_id.clone()),
             asset_kind: Some("editor_agent_generated_image".to_string()),
@@ -480,7 +479,6 @@ impl EditorAgentTool for GenerateCharacterTool {
             seg_model: Some("birefnet".to_string()),
             aspect_ratio: Some(args.aspect_ratio),
             image_size: Some(args.image_size),
-            character_sheet_views: None,
             reference_image_srcs: Some(reference_image_srcs),
             project_id: Some(context.conversation.project_id.clone()),
             asset_kind: Some("character".to_string()),
@@ -591,7 +589,6 @@ impl EditorAgentTool for GenerateUiDesignTool {
             seg_model: None,
             aspect_ratio: Some(args.aspect_ratio),
             image_size: Some(args.image_size),
-            character_sheet_views: None,
             reference_image_srcs: Some(reference_image_srcs),
             project_id: Some(context.conversation.project_id.clone()),
             asset_kind: Some("ui-design".to_string()),
diff --git a/server-rs/crates/api-server/src/editor_generation_queue.rs b/server-rs/crates/api-server/src/editor_generation_queue.rs
index 3d0388147..06d2740c0 100644
--- a/server-rs/crates/api-server/src/editor_generation_queue.rs
+++ b/server-rs/crates/api-server/src/editor_generation_queue.rs
@@ -20,6 +20,10 @@ pub(crate) const EDITOR_UI_DESIGN_ASSET_EXTRACTION_JOB_KIND: &str =
     "editor_ui_design_asset_extraction";
 pub(crate) const EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND: &str =
     "editor_character_animation_generation";
+pub(crate) const EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND: &str =
+    "editor_character_animation_video_conversion";
+pub(crate) const EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND: &str =
+    "editor_character_animation_background_removal";
 pub(crate) const EDITOR_VIDEO_GENERATION_JOB_KIND: &str = "editor_video_generation";
 pub(crate) const EDITOR_SOUND_EFFECT_GENERATION_JOB_KIND: &str = "editor_sound_effect_generation";
 pub(crate) const EDITOR_BACKGROUND_MUSIC_GENERATION_JOB_KIND: &str =
diff --git a/server-rs/crates/api-server/src/editor_project.rs b/server-rs/crates/api-server/src/editor_project.rs
index 5828ec721..1a2fd889a 100644
--- a/server-rs/crates/api-server/src/editor_project.rs
+++ b/server-rs/crates/api-server/src/editor_project.rs
@@ -350,9 +350,6 @@ pub struct EditorImageGenerationRequest {
     pub(crate) seg_model: Option<String>,
     pub(crate) aspect_ratio: Option<String>,
     pub(crate) image_size: Option<String>,
-    /// 角色多方�图集的视角数：4 或 8；仅 kind=character-sheet 时生效，缺� 4。
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub(crate) character_sheet_views: Option<u32>,
     pub(crate) reference_image_srcs: Option<Vec<String>>,
     pub(crate) project_id: Option<String>,
     pub(crate) asset_kind: Option<String>,
@@ -491,6 +488,46 @@ pub struct EditorUiDesignAssetExtractionRequest {
     pub(crate) canvas_completion: Option<EditorCanvasGenerationCompletionRequest>,
 }
 
+const EDITOR_GENERATION_OPERATION_ID_MAX_BYTES: usize = 128;
+
+/// 将请求级 request id 收敛为��久化的编辑器 operation id。
+///
+/// request id 会进入 SpacetimeDB 幂等键�资产对象标识和画布层标识，�能把任�
+/// header 内容直接带入这些边界。这里��许客户端和队列实际使用的稳定 ID 字符集，
+/// 超�或包�路径/控制字符时拒�请求，而�是�默改写导致幂等键碰撞。
+pub(crate) fn validate_editor_generation_operation_id(
+    operation_id: &str,
+) -> Result<String, AppError> {
+    let operation_id = operation_id.trim();
+    if operation_id.is_empty() {
+        return Err(
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "editor-generation-operation",
+                "message": "编辑器生� request id �能为空。",
+            })),
+        );
+    }
+    if operation_id.len() > EDITOR_GENERATION_OPERATION_ID_MAX_BYTES {
+        return Err(AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+            "provider": "editor-generation-operation",
+            "message": format!(
+                "编辑器生� request id �能超过 {EDITOR_GENERATION_OPERATION_ID_MAX_BYTES} 个字节。"
+            ),
+        })));
+    }
+    if !operation_id.chars().all(|character| {
+        character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.' | ':')
+    }) {
+        return Err(
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "editor-generation-operation",
+                "message": "编辑器生� request id �有�支�的字符。",
+            })),
+        );
+    }
+    Ok(operation_id.to_string())
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct EditorGenerationOperationContext {
     pub(crate) operation_kind: String,
@@ -588,9 +625,10 @@ impl EditorGenerationCaller {
                 "message": format!("�列化编辑器生�幂等请求失败：{error}"),
             }))
         })?;
+        let operation_id = validate_editor_generation_operation_id(request_context.request_id())?;
         self.operation = Some(EditorGenerationOperationContext {
             operation_kind: operation_kind.to_string(),
-            operation_id: request_context.request_id().trim().to_string(),
+            operation_id,
             operation_fingerprint: editor_generation_request_fingerprint(
                 operation_kind,
                 request_payload_json.as_str(),
@@ -2521,7 +2559,6 @@ pub async fn generate_editor_scene(
         seg_model: None,
         aspect_ratio: Some(generation_options.aspect_ratio.to_string()),
         image_size: Some(generation_options.image_size.to_string()),
-        character_sheet_views: None,
         reference_image_srcs: (!payload.reference_image_srcs.is_empty())
             .then_some(payload.reference_image_srcs),
         project_id: payload.project_id,
@@ -2821,16 +2858,6 @@ where
     let normalized_kind = payload.kind.as_deref().map(str::trim);
     let is_character_generation = matches!(normalized_kind, Some("character"));
     let is_character_sheet_generation = matches!(normalized_kind, Some("character-sheet"));
-    if is_character_sheet_generation
-        && !matches!(payload.character_sheet_views.unwrap_or(4), 4 | 8)
-    {
-        return Err(
-            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                "provider": "editor-image-generation",
-                "message": "characterSheetViews �支� 4 或 8。",
-            })),
-        );
-    }
     let pixel_art_supported = matches!(normalized_kind, None | Some("") | Some("character"));
     let (image_style, mut generation_warning) =
         normalize_editor_image_generation_style(payload.style.as_deref(), pixel_art_supported);
@@ -3039,7 +3066,7 @@ where
                     screen_color.expect("character generation should have screen color"),
                 )
             } else if is_character_sheet_generation {
-                // 多方�图集以纯绿底间隔�方�，供连通�拆分；��与编辑器的背景自动选色。
+                // 多方�图集以纯绿底间隔�方�，便于�续拆分；��与编辑器的背景自动选色。
                 build_editor_character_multi_view_sheet_prompt(
                     role_setting.as_str(),
                     crate::editor_green_screen::EditorScreenBackgroundColor {
@@ -3049,7 +3076,6 @@ where
                         green: 255,
                         blue: 0,
                     },
-                    payload.character_sheet_views.unwrap_or(4),
                 )
             } else if is_ui_design_generation {
                 build_editor_ui_design_prompt(role_setting.as_str(), ui_has_references)
@@ -5919,10 +5945,10 @@ pub(crate) async fn remove_editor_image_background_for_owner(
     ))
 }
 
-struct EditorBackgroundRemovalImage {
-    image: DownloadedOpenAiImage,
-    width: u32,
-    height: u32,
+pub(crate) struct EditorBackgroundRemovalImage {
+    pub(crate) image: DownloadedOpenAiImage,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
 }
 
 fn validate_editor_pixel_art_snap_canvas_completion(
@@ -7022,7 +7048,7 @@ fn editor_bgfilter_flat_deadline_reserve(aliyun_timeout_ms: u64) -> Duration {
         .saturating_add(EDITOR_BGFILTER_PARENT_TRANSPORT_WINDOW)
 }
 
-async fn request_editor_background_removal_image_with_bgfilter_worker(
+pub(crate) async fn request_editor_background_removal_image_with_bgfilter_worker(
     state: &AppState,
     source_object_key: &str,
     audit: &crate::external_api_audit::ExternalApiAuditContext,
@@ -7833,7 +7859,6 @@ pub(crate) async fn extract_editor_ui_design_assets_for_owner(
                     ),
                     path_kind: "ui-design-assets",
                     asset_kind: EDITOR_UI_DESIGN_ASSET_IMAGE_KIND,
-                    record_asset_kind: "icon",
                     persistence_provider: "vector-engine",
                 },
             )
@@ -10894,17 +10919,16 @@ fn build_editor_character_image_prompt(
 fn build_editor_character_multi_view_sheet_prompt(
     role_setting: &str,
     screen_color: EditorScreenBackgroundColor,
-    view_count: u32,
 ) -> String {
-    let (view_count_text, view_layout) = match view_count {
-        8 => ("八", "正������侧����背��左��左侧�左�"),
-        _ => ("四", "正��背��左侧��侧"),
-    };
+    // 八方�围绕一圈：正������侧����背��左��左侧�左�，按 3×3 �宫格外圈
+    // 排布�中心留空，方�之间由纯色背景充分间隔，使�续外接矩形拆分�易粘连。
+    const VIEW_LAYOUT: &str = "正������侧����背��左��左侧�左�";
     vec![
         format!(
-            "根�角色设定生�游�角色的多方�视图图集。画�中�有�一个角色，按{view_count_text}个方�排布：{view_layout}，�个方�一个完整角色，方�之间相互分离�互����互�接触。\
-{view_count_text}个方�必须是�一个角色，脸型��型��装��色�武器�头身比�体型全程一致，�止漂移��装��形。\
-�个方�角色完整居中，��切头顶�手脚或武器；�方�底部基线对�，画��比一致。{}；角色之间由纯色背景间隔，便于�续拆分。\
+            "根�角色设定生�游�角色的八方�视图图集。画�中�有�一个角色，共八个方�：{VIEW_LAYOUT}，�个方�一个完整角色。\
+八个方�必须是�一个角色，脸型��型��装��色�武器�头身比�体型全程一致，�止漂移��装��形。\
+八个方�按三乘三�宫格围绕一圈排布：上�下�左��以�四个角��放一个方�，�宫格中心留空，�放置角色。\
+�个方�角色完整居中，��切头顶�手脚或武器；�方�底部基线对�，画��比一致。{}；角色之间由纯色背景充分间隔，互�接触�互���，便于�续拆分。\
 �止�外角色�分身�宠物�文字�水��边框�编��网格线。",
             editor_green_screen_character_prompt_clause(screen_color)
         ),
@@ -12351,6 +12375,25 @@ mod tests {
         thread,
     };
 
+    #[test]
+    fn editor_generation_operation_id_accepts_stable_request_id_characters() {
+        assert_eq!(
+            validate_editor_generation_operation_id(" web-abc_123.v1:retry ").unwrap(),
+            "web-abc_123.v1:retry"
+        );
+    }
+
+    #[test]
+    fn editor_generation_operation_id_rejects_unsafe_or_oversized_request_ids() {
+        for request_id in ["", "   ", "request/id", "request id", "request\n id"] {
+            assert!(
+                validate_editor_generation_operation_id(request_id).is_err(),
+                "request id should be rejected: {request_id:?}"
+            );
+        }
+        assert!(validate_editor_generation_operation_id(&"x".repeat(129)).is_err());
+    }
+
     #[test]
     fn ordinary_image_prompt_validation_stays_outside_prompt_builder_execution() {
         assert!(validate_editor_image_generation_prompt("生�森林场景").is_ok());
@@ -16618,38 +16661,20 @@ mod tests {
                 green: 255,
                 blue: 0,
             },
-            4,
         );
 
-        assert!(prompt.contains("多方�视图图集"));
-        assert!(prompt.contains("四个方�排布：正��背��左侧��侧"));
-        assert!(prompt.contains("方�之间相互分离�互����互�接触"));
+        assert!(prompt.contains("八方�视图图集"));
+        assert!(prompt.contains("共八个方�：正������侧����背��左��左侧�左�"));
+        assert!(prompt.contains("八个方�必须是�一个角色"));
+        assert!(prompt.contains("按三乘三�宫格围绕一圈排布"));
+        assert!(prompt.contains("�宫格中心留空"));
         assert!(prompt.contains("脸型��型��装��色�武器�头身比�体型全程一致"));
         assert!(prompt.contains("背景固定为�一纯色背景 纯绿色 #00FF00"));
-        assert!(prompt.contains("角色之间由纯色背景间隔，便于�续拆分"));
+        assert!(prompt.contains("角色之间由纯色背景充分间隔，互�接触�互���"));
         assert!(prompt.contains("�止�外角色�分身�宠物�文字�水��边框�编��网格线"));
         assert!(prompt.contains("角色设定：日系魔法少女"));
     }
 
-    #[test]
-    fn editor_character_multi_view_sheet_prompt_supports_eight_directions() {
-        let prompt = build_editor_character_multi_view_sheet_prompt(
-            "日系魔法少女",
-            crate::editor_green_screen::EditorScreenBackgroundColor {
-                label: "纯绿色",
-                hex: "#00FF00",
-                red: 0,
-                green: 255,
-                blue: 0,
-            },
-            8,
-        );
-
-        assert!(prompt.contains("八个方�排布：正������侧����背��左��左侧�左�"));
-        assert!(prompt.contains("八个方�必须是�一个角色"));
-        assert!(prompt.contains("�个方�角色完整居中"));
-    }
-
     #[test]
     fn editor_character_sheet_kind_routes_to_sheet_prompt_and_icon_spritesheet_asset_kind() {
         assert_eq!(
diff --git a/server-rs/crates/api-server/src/editor_project_icon.rs b/server-rs/crates/api-server/src/editor_project_icon.rs
index 5126d4b39..78aa5dd26 100644
--- a/server-rs/crates/api-server/src/editor_project_icon.rs
+++ b/server-rs/crates/api-server/src/editor_project_icon.rs
@@ -638,7 +638,6 @@ fn build_icon_spec_image_request(
         seg_model: None,
         aspect_ratio: Some(ICON_SPEC_ASPECT_RATIO.to_string()),
         image_size: Some(ICON_SPEC_IMAGE_SIZE.to_string()),
-        character_sheet_views: None,
         reference_image_srcs: payload.reference_id.map(|reference_id| vec![reference_id]),
         project_id: payload.project_id,
         asset_kind: Some("icon-spec".to_string()),
@@ -841,9 +840,6 @@ pub(crate) struct PersistEditorSpritesheetSlicesInput {
     pub(crate) generation_inputs: Option<Value>,
     pub(crate) path_kind: &'static str,
     pub(crate) asset_kind: &'static str,
-    /// 切片资�/素�记录的 asset_kind（�端�此判断素�语义）。图标图集默认 "icon"；
-    /// 角色多方�图集拆分传 "character"，使�视角切片�直接作为角色动画�考。
-    pub(crate) record_asset_kind: &'static str,
     pub(crate) persistence_provider: &'static str,
 }
 
@@ -964,7 +960,7 @@ pub(crate) async fn persist_editor_spritesheet_slices(
                     provider: Some(input.provider.clone()),
                     task_id: Some(input.task_id.clone()),
                     source_resource_id: normalize_optional_string(input.source_resource_id.clone()),
-                    asset_kind: Some(input.record_asset_kind.to_string()),
+                    asset_kind: Some("icon".to_string()),
                     generation_inputs_json: generation_inputs_json.clone(),
                     updated_at_micros: now_micros,
                     image_sequence_frames_json: None,
@@ -994,7 +990,7 @@ pub(crate) async fn persist_editor_spritesheet_slices(
                     model: Some(input.model.clone()),
                     provider: Some(input.provider.clone()),
                     task_id: Some(input.task_id.clone()),
-                    asset_kind: Some(input.record_asset_kind.to_string()),
+                    asset_kind: Some("icon".to_string()),
                     generation_inputs_json: generation_inputs_json.clone(),
                     source_resource_id: resource_id.clone(),
                     generation_cost_mud_points: 0,
@@ -1967,7 +1963,6 @@ pub(crate) async fn generate_editor_icon_spritesheet_for_owner(
                     ),
                     path_kind: "icon-spritesheet-assets",
                     asset_kind: EDITOR_ICON_SPRITESHEET_SLICE_ASSET_KIND,
-                    record_asset_kind: "icon",
                     persistence_provider: "vector-engine",
                 },
             )
@@ -2175,17 +2170,6 @@ pub(crate) fn resolve_editor_icon_spritesheet_source_layer_asset_kind<'a>(
     }
 }
 
-/// 图集切片记录 asset_kind：角色多方�图集（action=character-sheet.generate）拆出的
-/// �视角切片按 character �库（�直接作动画�考），其余图集按 icon。
-fn editor_spritesheet_slice_record_asset_kind(source_generation_inputs: Option<&Value>) -> &'static str {
-    source_generation_inputs
-        .and_then(|inputs| inputs.get("action"))
-        .and_then(Value::as_str)
-        .is_some_and(|action| action == "character-sheet.generate")
-        .then_some("character")
-        .unwrap_or("icon")
-}
-
 pub async fn split_editor_icon_spritesheet(
     State(state): State<AppState>,
     Extension(request_context): Extension<RequestContext>,
@@ -2325,10 +2309,6 @@ pub async fn split_editor_icon_spritesheet(
         .clone()
         .unwrap_or_else(|| "Genarrative".to_string());
     let generation_inputs = source_resource.generation_inputs.clone();
-    // 中文注释：角色多方�图集（action=character-sheet.generate）拆分出的�视角切片按
-    // character �库，使其�直接作为角色动画�考；普通图标图集�按 icon。
-    let slice_record_asset_kind =
-        editor_spritesheet_slice_record_asset_kind(source_resource.generation_inputs.as_ref());
     let icon_image_srcs = persist_editor_spritesheet_slices(
         &state,
         slices,
@@ -2348,7 +2328,6 @@ pub async fn split_editor_icon_spritesheet(
             generation_inputs,
             path_kind: "icon-spritesheet-slices",
             asset_kind: EDITOR_ICON_SPRITESHEET_SLICE_ASSET_KIND,
-            record_asset_kind: slice_record_asset_kind,
             persistence_provider: "genarrative",
         },
     )
@@ -2698,32 +2677,6 @@ pub(crate) fn validate_editor_icon_spritesheet_dimensions(
 mod tests {
     use super::*;
 
-    #[test]
-    fn sprite_slice_record_asset_kind_marks_character_sheet_slices_as_character() {
-        assert_eq!(
-            editor_spritesheet_slice_record_asset_kind(None),
-            "icon"
-        );
-        assert_eq!(
-            editor_spritesheet_slice_record_asset_kind(Some(&json!({
-                "action": "icon.generate"
-            }))),
-            "icon"
-        );
-        assert_eq!(
-            editor_spritesheet_slice_record_asset_kind(Some(&json!({
-                "action": "character-sheet.generate"
-            }))),
-            "character"
-        );
-        assert_eq!(
-            editor_spritesheet_slice_record_asset_kind(Some(&json!({
-                "version": 2
-            }))),
-            "icon"
-        );
-    }
-
     #[test]
     fn game_genre_serde_uses_chinese_slugs() {
         for genre in GameGenre::ALL {
diff --git a/server-rs/crates/api-server/src/editor_sequence_animation.rs b/server-rs/crates/api-server/src/editor_sequence_animation.rs
index ab72ddd32..dff23869a 100644
--- a/server-rs/crates/api-server/src/editor_sequence_animation.rs
+++ b/server-rs/crates/api-server/src/editor_sequence_animation.rs
@@ -2,6 +2,7 @@ use axum::http::StatusCode;
 use serde_json::{Value, json};
 use shared_contracts::assets::{
     EDITOR_ASSET_LABEL_MAX_CHARS, EditorCharacterAnimationGenerateRequest,
+    EditorCharacterAnimationVideoConversionRequest,
 };
 
 use crate::{
@@ -16,6 +17,131 @@ pub(crate) const EDITOR_CHARACTER_ANIMATION_MODEL: &str = "seedance2.0-fast";
 pub(crate) const EDITOR_CHARACTER_ANIMATION_REFERENCE_VIDEO_MAX_BYTES: u64 = 50 * 1024 * 1024;
 const EDITOR_CHARACTER_ANIMATION_REFERENCE_VIDEO_MIN_DURATION_SECONDS: f64 = 2.0;
 const EDITOR_CHARACTER_ANIMATION_REFERENCE_VIDEO_MAX_DURATION_SECONDS: f64 = 15.0;
+pub(crate) const EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_MAX_FRAMES: u32 = 120;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct EditorCharacterAnimationVideoConversionPlan {
+    pub(crate) duration_seconds: f64,
+    pub(crate) duration_ms: u64,
+    pub(crate) source_fps: f64,
+    pub(crate) sampling_fps: f64,
+    pub(crate) frame_count: u32,
+    pub(crate) frame_width: u32,
+    pub(crate) frame_height: u32,
+}
+
+pub(crate) fn normalize_editor_character_animation_video_conversion_resolution(
+    value: &str,
+) -> Result<&'static str, AppError> {
+    match value.trim() {
+        "480p" => Ok("480p"),
+        "720p" => Ok("720p"),
+        _ => Err(editor_character_animation_bad_request(
+            "resolution �支� 480p 或 720p。",
+        )),
+    }
+}
+
+pub(crate) fn build_editor_character_animation_video_conversion_plan(
+    duration_seconds: f64,
+    source_fps: f64,
+    source_width: u32,
+    source_height: u32,
+    resolution: &str,
+) -> Result<EditorCharacterAnimationVideoConversionPlan, AppError> {
+    validate_editor_character_animation_reference_video_duration(duration_seconds)?;
+    if !source_fps.is_finite() || source_fps <= 0.0 {
+        return Err(editor_character_animation_bad_request(
+            "�视频缺少有效平�帧率。",
+        ));
+    }
+    if source_width == 0 || source_height == 0 {
+        return Err(editor_character_animation_bad_request(
+            "�视频缺少有效显示尺寸。",
+        ));
+    }
+    let max_long_edge =
+        match normalize_editor_character_animation_video_conversion_resolution(resolution)? {
+            "480p" => 480_u32,
+            "720p" => 720_u32,
+            _ => unreachable!(),
+        };
+    let source_long_edge = source_width.max(source_height);
+    let scale = (f64::from(max_long_edge) / f64::from(source_long_edge)).min(1.0);
+    let frame_width = (f64::from(source_width) * scale).round().max(1.0) as u32;
+    let frame_height = (f64::from(source_height) * scale).round().max(1.0) as u32;
+    let sampling_fps = source_fps.min(8.0).max(1.0);
+    let frame_count = (duration_seconds * sampling_fps).round().clamp(
+        2.0,
+        f64::from(EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_MAX_FRAMES),
+    ) as u32;
+    Ok(EditorCharacterAnimationVideoConversionPlan {
+        duration_seconds,
+        duration_ms: (duration_seconds * 1_000.0).round().max(1.0) as u64,
+        source_fps,
+        sampling_fps,
+        frame_count,
+        frame_width,
+        frame_height,
+    })
+}
+
+pub(crate) fn parse_editor_character_animation_ffprobe_frame_rate(value: &str) -> Option<f64> {
+    let value = value.trim();
+    if let Some((numerator, denominator)) = value.split_once('/') {
+        let numerator = numerator.trim().parse::<f64>().ok()?;
+        let denominator = denominator.trim().parse::<f64>().ok()?;
+        return (numerator.is_finite()
+            && denominator.is_finite()
+            && numerator > 0.0
+            && denominator > 0.0)
+            .then_some(numerator / denominator);
+    }
+    value
+        .parse::<f64>()
+        .ok()
+        .filter(|value| value.is_finite() && *value > 0.0)
+}
+
+pub(crate) fn build_authoritative_editor_character_animation_video_conversion_inputs(
+    client_generation_inputs: Option<Value>,
+    payload: &EditorCharacterAnimationVideoConversionRequest,
+    source_object_key: &str,
+    plan: EditorCharacterAnimationVideoConversionPlan,
+) -> Result<Value, AppError> {
+    let resolution =
+        normalize_editor_character_animation_video_conversion_resolution(&payload.resolution)?;
+    let source_object_key = source_object_key.trim().trim_start_matches('/').to_string();
+    if source_object_key.is_empty() {
+        return Err(editor_character_animation_bad_request(
+            "�视频缺少稳定 objectKey。",
+        ));
+    }
+    let mut result = client_generation_inputs
+        .and_then(|value| value.as_object().cloned())
+        .unwrap_or_default();
+    result.insert("version".to_string(), json!(2));
+    result.insert("action".to_string(), json!("character-animation.convert"));
+    result.insert(
+        "fields".to_string(),
+        json!([
+            { "id": "sourceVideoSrc", "title": "�视频", "value": source_object_key },
+            { "id": "resolution", "title": "最大长边", "value": resolution },
+            { "id": "actualWidth", "title": "实际宽度", "value": plan.frame_width },
+            { "id": "actualHeight", "title": "实际高度", "value": plan.frame_height },
+            { "id": "sourceDurationMs", "title": "�时长", "value": plan.duration_ms },
+            { "id": "sourceFps", "title": "�帧率", "value": plan.source_fps },
+            { "id": "frameCount", "title": "实际帧数", "value": plan.frame_count },
+            { "id": "samplingFps", "title": "采样率", "value": plan.sampling_fps },
+            { "id": "processingMethod", "title": "处�方�", "value": "视频直接转�" }
+        ]),
+    );
+    result.insert(
+        "references".to_string(),
+        json!([{ "id": "source", "title": "�视频" }]),
+    );
+    Ok(Value::Object(result))
+}
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum EditorCharacterAnimationInputMode {
@@ -80,6 +206,10 @@ pub(crate) fn normalize_editor_character_animation_request_with_pricing(
     );
     let reference_src = trim_optional_text(payload.reference_src.as_deref())
         .or_else(|| trim_optional_text(Some(payload.source_image_src.as_str())));
+    let has_appearance_references = payload
+        .appearance_reference_srcs
+        .iter()
+        .any(|src| !src.trim().is_empty());
     if input_mode == EditorCharacterAnimationInputMode::Text && reference_src.is_some() {
         return Err(editor_character_animation_bad_request(
             "文本模��能�带�考素�。",
@@ -90,14 +220,21 @@ pub(crate) fn normalize_editor_character_animation_request_with_pricing(
             "图片或视频模�必须�供�考素�。",
         ));
     }
+    if has_appearance_references && input_mode != EditorCharacterAnimationInputMode::Video {
+        return Err(editor_character_animation_bad_request(
+            "appearanceReferenceSrcs 仅支�视频模�。",
+        ));
+    }
     let prompt_text = payload
         .prompt_text
         .trim()
         .chars()
         .take(4000)
         .collect::<String>();
-    if prompt_text.is_empty() {
-        return Err(editor_character_animation_bad_request("动画�述�能为空。"));
+    if prompt_text.is_empty() && reference_src.is_none() {
+        return Err(editor_character_animation_bad_request(
+            "动画�述和�考素��能�时为空。",
+        ));
     }
     let resolution = normalize_editor_character_animation_resolution(payload.resolution.as_str())?;
     let ratio = normalize_editor_character_animation_ratio(payload.ratio.as_str())?;
@@ -250,14 +387,18 @@ pub(crate) fn validate_editor_character_animation_reference_content_type(
         .to_ascii_lowercase();
     let matches = match expected_kind {
         EditorCharacterAnimationReferenceMediaKind::Image => normalized.starts_with("image/"),
-        EditorCharacterAnimationReferenceMediaKind::Video => normalized.starts_with("video/"),
+        EditorCharacterAnimationReferenceMediaKind::Video => {
+            normalized == "video/mp4" || normalized == "video/quicktime"
+        }
     };
     if matches {
         return Ok(());
     }
     let message = match expected_kind {
         EditorCharacterAnimationReferenceMediaKind::Image => "图片模��能使用真实图片素�。",
-        EditorCharacterAnimationReferenceMediaKind::Video => "视频模��能使用真实视频素�。",
+        EditorCharacterAnimationReferenceMediaKind::Video => {
+            "视频模��能使用真实 MP4 或 MOV 视频素�。"
+        }
     };
     Err(
         AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
@@ -324,13 +465,15 @@ pub(crate) fn build_authoritative_editor_character_animation_generation_inputs(
     payload: &EditorCharacterAnimationGenerateRequest,
     input_mode: EditorCharacterAnimationInputMode,
     reference_object_key: Option<&str>,
+    appearance_object_keys: &[String],
 ) -> Result<Value, AppError> {
-    const AUTHORITATIVE_FIELD_IDS: [&str; 11] = [
+    const AUTHORITATIVE_FIELD_IDS: [&str; 12] = [
         "inputMode",
         "referenceSrc",
         "referenceMediaType",
         "referenceWidth",
         "referenceHeight",
+        "appearanceReferenceSrc",
         "prompt",
         "backgroundColor",
         "resolution",
@@ -345,8 +488,10 @@ pub(crate) fn build_authoritative_editor_character_animation_generation_inputs(
         .chars()
         .take(4000)
         .collect::<String>();
-    if prompt.is_empty() {
-        return Err(editor_character_animation_bad_request("动画�述�能为空。"));
+    if prompt.is_empty() && reference_object_key.is_none() && appearance_object_keys.is_empty() {
+        return Err(editor_character_animation_bad_request(
+            "动画�述和�考素��能�时为空。",
+        ));
     }
     let resolution = normalize_editor_character_animation_resolution(payload.resolution.as_str())?;
     // generationInputs �存用户请求语义；same �能被 provider 使用的具体比例覆盖。
@@ -390,7 +535,30 @@ pub(crate) fn build_authoritative_editor_character_animation_generation_inputs(
             json!({ "id": "referenceWidth", "title": "�考宽度", "value": payload.source_width }),
             json!({ "id": "referenceHeight", "title": "�考高度", "value": payload.source_height }),
         ]);
-        reference_slots.push(json!({ "id": "source", "title": reference_title }));
+        reference_slots.push(json!({
+            "id": if input_mode == EditorCharacterAnimationInputMode::Video { "motion" } else { "source" },
+            "title": reference_title
+        }));
+    }
+    if !appearance_object_keys.is_empty() {
+        if input_mode != EditorCharacterAnimationInputMode::Video {
+            return Err(editor_character_animation_bad_request(
+                "角色外观图仅支�视频模�。",
+            ));
+        }
+        for appearance_object_key in appearance_object_keys {
+            let appearance_object_key =
+                appearance_object_key.trim().trim_start_matches('/');
+            if appearance_object_key.is_empty() {
+                continue;
+            }
+            fields.push(json!({
+                "id": "appearanceReferenceSrc",
+                "title": "角色外观",
+                "value": appearance_object_key,
+            }));
+            reference_slots.push(json!({ "id": "appearance", "title": "角色外观" }));
+        }
     }
     fields.push(json!({ "id": "prompt", "title": "动作�述", "value": prompt }));
 
@@ -705,6 +873,7 @@ mod tests {
             input_mode: None,
             reference_media_type: None,
             reference_src: None,
+            appearance_reference_srcs: Vec::new(),
             prompt_text: "待机呼�".to_string(),
             background_color: None,
             screen_color: None,
@@ -717,11 +886,52 @@ mod tests {
             canvas_completion: None,
             generation_inputs: None,
             source_resource_id: None,
+            appearance_source_resource_ids: Vec::new(),
             asset_folder_id: None,
             asset_label: None,
         }
     }
 
+    #[test]
+    fn video_conversion_plan_honors_fractional_fps_rotation_size_and_no_upscale() {
+        assert!(
+            (parse_editor_character_animation_ffprobe_frame_rate("24000/1001").unwrap() - 23.976)
+                .abs()
+                < 0.001
+        );
+        let plan = build_editor_character_animation_video_conversion_plan(
+            2.5,
+            24_000.0 / 1_001.0,
+            360,
+            640,
+            "720p",
+        )
+        .unwrap();
+        assert_eq!((plan.frame_width, plan.frame_height), (360, 640));
+        assert_eq!(plan.frame_count, 20);
+        assert_eq!(plan.duration_ms, 2_500);
+        assert_eq!(plan.sampling_fps, 8.0);
+    }
+
+    #[test]
+    fn video_conversion_plan_downscales_and_caps_at_120_frames() {
+        let plan =
+            build_editor_character_animation_video_conversion_plan(15.0, 60.0, 1920, 1080, "480p")
+                .unwrap();
+        assert_eq!((plan.frame_width, plan.frame_height), (480, 270));
+        assert_eq!(plan.frame_count, 120);
+        assert_eq!(plan.sampling_fps, 8.0);
+    }
+
+    #[test]
+    fn video_conversion_plan_uses_one_fps_floor_and_two_frame_minimum() {
+        let plan =
+            build_editor_character_animation_video_conversion_plan(2.0, 0.5, 320, 180, "480p")
+                .unwrap();
+        assert_eq!(plan.sampling_fps, 1.0);
+        assert_eq!(plan.frame_count, 2);
+    }
+
     fn generation_field<'a>(inputs: &'a Value, id: &str) -> Option<&'a Value> {
         inputs
             .get("fields")
@@ -893,7 +1103,7 @@ mod tests {
         assert!(
             video_error
                 .body_text()
-                .contains("视频模��能使用真实视频素�")
+                .contains("视频模��能使用真实 MP4 或 MOV 视频素�")
         );
 
         let image_error = validate_editor_character_animation_reference_content_type(
@@ -1017,6 +1227,7 @@ mod tests {
             &request,
             EditorCharacterAnimationInputMode::Text,
             None,
+            &[],
         )
         .expect("text request should always produce a recoverable recipe");
 
@@ -1072,6 +1283,7 @@ mod tests {
             &request,
             EditorCharacterAnimationInputMode::Image,
             Some("/users/owner/hero.png"),
+            &[],
         )
         .expect("authoritative image recipe should build");
 
@@ -1131,6 +1343,7 @@ mod tests {
             &request,
             EditorCharacterAnimationInputMode::Image,
             Some("users/owner/hero.png"),
+            &[],
         )
         .expect("legacy image recipe should preserve automatic background semantics");
 
@@ -1151,6 +1364,7 @@ mod tests {
             &video_request,
             EditorCharacterAnimationInputMode::Video,
             Some("users/owner/action.mp4"),
+            &[],
         )
         .expect("video recipe should persist the default green background");
         assert_eq!(
diff --git a/server-rs/crates/api-server/src/external_editor_api.rs b/server-rs/crates/api-server/src/external_editor_api.rs
index ac44a43ca..9ef70320c 100644
--- a/server-rs/crates/api-server/src/external_editor_api.rs
+++ b/server-rs/crates/api-server/src/external_editor_api.rs
@@ -152,6 +152,7 @@ impl From<ExternalEditorCharacterAnimationGenerateRequest>
             input_mode: None,
             reference_media_type: None,
             reference_src: None,
+            appearance_reference_srcs: Vec::new(),
             prompt_text: payload.prompt_text,
             background_color: None,
             screen_color: payload.screen_color,
@@ -164,6 +165,7 @@ impl From<ExternalEditorCharacterAnimationGenerateRequest>
             canvas_completion: payload.canvas_completion,
             generation_inputs: payload.generation_inputs,
             source_resource_id: payload.source_resource_id,
+            appearance_source_resource_ids: Vec::new(),
             asset_folder_id: payload.asset_folder_id,
             asset_label: payload.asset_label,
         }
@@ -1553,6 +1555,27 @@ mod tests {
             .expect_err("External v1 �应接收内部三模�扩展字段");
 
         assert!(error.to_string().contains("inputMode"));
+
+        let appearance_error =
+            serde_json::from_value::<ExternalEditorCharacterAnimationGenerateRequest>(json!({
+                "sourceLayerId": "layer-character",
+                "sourceImageSrc": "editor/uploads/character.png",
+                "sourceWidth": 512,
+                "sourceHeight": 512,
+                "promptText": "原地待机",
+                "resolution": "480p",
+                "ratio": "same",
+                "frameCount": 32,
+                "durationSeconds": 4,
+                "model": "seedance2.0-fast",
+                "appearanceReferenceSrc": "editor/uploads/appearance.png"
+            }))
+            .expect_err("External v1 �应接收内部角色外观字段");
+        assert!(
+            appearance_error
+                .to_string()
+                .contains("appearanceReferenceSrc")
+        );
     }
 
     #[test]
diff --git a/server-rs/crates/api-server/src/external_generation_worker.rs b/server-rs/crates/api-server/src/external_generation_worker.rs
index f46f9c314..97945d8f3 100644
--- a/server-rs/crates/api-server/src/external_generation_worker.rs
+++ b/server-rs/crates/api-server/src/external_generation_worker.rs
@@ -29,12 +29,16 @@ const EDITOR_GENERATION_WARNING_REDACTED_MESSAGE: &str =
 use crate::{
     asset_billing::with_external_generation_billing_attempt_context,
     character_animation_assets::{
+        convert_editor_character_animation_video_for_owner,
         generate_editor_character_animation_for_owner, generate_editor_video_for_owner,
+        remove_editor_character_animation_background_for_owner,
     },
     config::AppConfig,
     editor_generation_queue::{
         EDITOR_BACKGROUND_MUSIC_GENERATION_JOB_KIND, EDITOR_BACKGROUND_REMOVAL_JOB_KIND,
-        EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND, EDITOR_ICON_SPEC_GENERATION_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND,
+        EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND, EDITOR_ICON_SPEC_GENERATION_JOB_KIND,
         EDITOR_ICON_SPRITESHEET_GENERATION_JOB_KIND, EDITOR_IMAGE_EDIT_JOB_KIND,
         EDITOR_IMAGE_GENERATION_JOB_KIND, EDITOR_SOUND_EFFECT_GENERATION_JOB_KIND,
         EDITOR_UI_DESIGN_ASSET_EXTRACTION_JOB_KIND, EDITOR_VIDEO_GENERATION_JOB_KIND,
@@ -958,6 +962,64 @@ async fn process_external_generation_job_once(
                 }
             }
         }
+        EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND => {
+            let payload = match serde_json::from_str::<
+                shared_contracts::assets::EditorCharacterAnimationVideoConversionRequest,
+            >(job.request_payload_json.as_str())
+            {
+                Ok(payload) => payload,
+                Err(error) => {
+                    let message = format!("视频直接转�任务�数解�失败：{error}");
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    return Err(message);
+                }
+            };
+            let request_context = worker_request_context(&job, provider_deadline);
+            match convert_editor_character_animation_video_for_owner(
+                state.clone(),
+                request_context,
+                editor_generation_worker_caller(&worker_id, &job)?,
+                Ok(Json(payload)),
+            )
+            .await
+            {
+                Ok(_) => Ok(()),
+                Err(response) => {
+                    let message = response_error_message(response).await;
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    Err(message)
+                }
+            }
+        }
+        EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND => {
+            let payload = match serde_json::from_str::<
+                shared_contracts::assets::EditorCharacterAnimationBackgroundRemovalRequest,
+            >(job.request_payload_json.as_str())
+            {
+                Ok(payload) => payload,
+                Err(error) => {
+                    let message = format!("Spine�列帧去背景任务�数解�失败：{error}");
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    return Err(message);
+                }
+            };
+            let request_context = worker_request_context(&job, provider_deadline);
+            match remove_editor_character_animation_background_for_owner(
+                state.clone(),
+                request_context,
+                editor_generation_worker_caller(&worker_id, &job)?,
+                Ok(Json(payload)),
+            )
+            .await
+            {
+                Ok(_) => Ok(()),
+                Err(response) => {
+                    let message = response_error_message(response).await;
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    Err(message)
+                }
+            }
+        }
         EDITOR_VIDEO_GENERATION_JOB_KIND => {
             let payload = match serde_json::from_str::<
                 shared_contracts::assets::EditorVideoGenerateRequest,
@@ -1633,6 +1695,8 @@ fn external_generation_worker_job_timeout(config: &AppConfig, job_kind: &str) ->
         | EDITOR_ICON_SPRITESHEET_GENERATION_JOB_KIND
         | EDITOR_UI_DESIGN_ASSET_EXTRACTION_JOB_KIND
         | EDITOR_CHARACTER_ANIMATION_GENERATION_JOB_KIND
+        | EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_JOB_KIND
+        | EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_JOB_KIND
         | EDITOR_VIDEO_GENERATION_JOB_KIND => config.external_generation_worker_long_job_timeout,
         _ => config.external_generation_worker_job_timeout,
     }
diff --git a/server-rs/crates/api-server/src/modules/platform_support.rs b/server-rs/crates/api-server/src/modules/platform_support.rs
index 9b1d4d813..7777207dd 100644
--- a/server-rs/crates/api-server/src/modules/platform_support.rs
+++ b/server-rs/crates/api-server/src/modules/platform_support.rs
@@ -13,10 +13,11 @@ use crate::{
     assets::get_asset_history,
     auth::require_bearer_auth,
     character_animation_assets::{
-        generate_character_animation, generate_editor_character_animation, generate_editor_video,
-        get_character_animation_job, get_character_workflow_cache,
-        import_character_animation_video, list_character_animation_templates,
-        publish_character_animation, save_character_workflow_cache,
+        convert_editor_character_animation_video, generate_character_animation,
+        generate_editor_character_animation, generate_editor_video, get_character_animation_job,
+        get_character_workflow_cache, import_character_animation_video,
+        list_character_animation_templates, publish_character_animation,
+        remove_editor_character_animation_background, save_character_workflow_cache,
         split_editor_character_animation_frames,
     },
     character_visual_assets::{
@@ -129,12 +130,24 @@ pub fn router(state: AppState) -> Router<AppState> {
                 require_bearer_auth,
             )),
         )
+        .route(
+            "/api/editor/character-animations/video-conversions",
+            post(convert_editor_character_animation_video).route_layer(
+                middleware::from_fn_with_state(state.clone(), require_bearer_auth),
+            ),
+        )
         .route(
             "/api/editor/character-animations/frame-splits",
             post(split_editor_character_animation_frames).route_layer(
                 middleware::from_fn_with_state(state.clone(), require_bearer_auth),
             ),
         )
+        .route(
+            "/api/editor/character-animations/background-removals",
+            post(remove_editor_character_animation_background).route_layer(
+                middleware::from_fn_with_state(state.clone(), require_bearer_auth),
+            ),
+        )
         .route(
             "/api/editor/videos/generations",
             post(generate_editor_video).route_layer(middleware::from_fn_with_state(
diff --git a/server-rs/crates/platform-oss/src/lib.rs b/server-rs/crates/platform-oss/src/lib.rs
index c563ee158..15a1cea2b 100644
--- a/server-rs/crates/platform-oss/src/lib.rs
+++ b/server-rs/crates/platform-oss/src/lib.rs
@@ -104,6 +104,11 @@ pub struct OssHeadObjectRequest {
     pub object_key: String,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct OssDeleteObjectRequest {
+    pub object_key: String,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct OssPutObjectRequest {
     pub prefix: LegacyAssetPrefix,
@@ -218,6 +223,7 @@ pub struct OssClient {
 pub enum OssRequestOperation {
     Put,
     Head,
+    Delete,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -841,6 +847,51 @@ impl OssClient {
         result
     }
 
+    /// 删除�务端生�但尚未登记为正�资产的对象。404 视为幂等�功。
+    pub async fn delete_object(
+        &self,
+        client: &reqwest::Client,
+        request: OssDeleteObjectRequest,
+    ) -> Result<(), OssError> {
+        let started_at = Instant::now();
+        let object_key = normalize_object_key(&request.object_key)?;
+        let target_url = build_object_url(&self.config.bucket, &self.config.endpoint, &object_key)
+            .map_err(|error| {
+                request_error(
+                    OssRequestOperation::Delete,
+                    &format!("构造 OSS 对象 URL 失败：{error}"),
+                )
+            })?;
+        let response = send_signed_request(
+            client,
+            &self.config,
+            Method::DELETE,
+            Some(&object_key),
+            target_url,
+            OssRequestOperation::Delete,
+        )
+        .await?;
+        let status = response.status();
+        if !status.is_success() && status != reqwest::StatusCode::NOT_FOUND {
+            return Err(request_status_error(
+                OssRequestOperation::Delete,
+                status.as_u16(),
+                format!("OSS DeleteObject 失败，状��：{status}"),
+            ));
+        }
+        info!(
+            provider = OSS_PROVIDER,
+            operation = "delete_object",
+            bucket = %self.config.bucket(),
+            endpoint = %self.config.endpoint(),
+            object_key,
+            status = status.as_u16(),
+            elapsed_ms = elapsed_ms(started_at),
+            "OSS DeleteObject 删除完�"
+        );
+        Ok(())
+    }
+
     // AI 生�资�默认由�务端上传 OSS，Web 端�拿签�读地�，�直接�有写��。
     pub async fn put_object(
         &self,
diff --git a/server-rs/crates/shared-contracts/src/assets.rs b/server-rs/crates/shared-contracts/src/assets.rs
index 99827e657..2d0534012 100644
--- a/server-rs/crates/shared-contracts/src/assets.rs
+++ b/server-rs/crates/shared-contracts/src/assets.rs
@@ -325,6 +325,9 @@ pub struct EditorCharacterAnimationGenerateRequest {
     pub reference_media_type: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub reference_src: Option<String>,
+    /// 视频动作�考之外的�选角色外观图片。仅 inputMode=video 时�许，�多张。
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub appearance_reference_srcs: Vec<String>,
     pub prompt_text: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub background_color: Option<String>,
@@ -344,12 +347,57 @@ pub struct EditorCharacterAnimationGenerateRequest {
     pub generation_inputs: Option<Value>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub source_resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub appearance_source_resource_ids: Vec<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub asset_folder_id: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub asset_label: Option<String>,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorCharacterAnimationVideoConversionRequest {
+    pub source_video_src: String,
+    pub resolution: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub canvas_completion: Option<EditorCanvasGenerationCompletionPayload>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub generation_inputs: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset_folder_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset_label: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorCharacterAnimationVideoConversionResponse {
+    pub ok: bool,
+    pub task_id: String,
+    pub processing_method: String,
+    pub frames: Vec<EditorCharacterAnimationFramePayload>,
+    pub frame_count: u32,
+    pub duration_ms: u64,
+    pub frame_width: u32,
+    pub frame_height: u32,
+    pub source_fps: f64,
+    pub sampling_fps: f64,
+    pub price_mud_points: u32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub queue_state: Option<ExternalGenerationJobStatusRecord>,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct EditorCharacterAnimationFramePayload {
@@ -406,6 +454,43 @@ pub struct EditorCharacterAnimationFrameSplitResponse {
     pub assets: Vec<EditorAssetPayload>,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorCharacterAnimationBackgroundRemovalRequest {
+    pub project_id: String,
+    pub source_layer_id: String,
+    pub source_resource_id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset_folder_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset_label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub canvas_completion: Option<EditorCanvasGenerationCompletionPayload>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub generation_inputs: Option<Value>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorCharacterAnimationBackgroundRemovalResponse {
+    pub ok: bool,
+    pub task_id: String,
+    pub frames: Vec<EditorCharacterAnimationFramePayload>,
+    pub frame_count: u32,
+    pub duration_ms: u64,
+    pub frame_width: u32,
+    pub frame_height: u32,
+    pub price_mud_points: u32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub asset: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub queue_state: Option<ExternalGenerationJobStatusRecord>,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct EditorAssetPayload {
@@ -1376,6 +1461,7 @@ mod tests {
             input_mode: Some("video".to_string()),
             reference_media_type: Some("video".to_string()),
             reference_src: Some("generated/editor/reference.mp4".to_string()),
+            appearance_reference_srcs: vec!["generated/editor/appearance.png".to_string()],
             prompt_text: "待机呼�".to_string(),
             background_color: Some("purple".to_string()),
             screen_color: None,
@@ -1399,6 +1485,7 @@ mod tests {
             }),
             generation_inputs: None,
             source_resource_id: Some("resource-source".to_string()),
+            appearance_source_resource_ids: vec!["resource-appearance".to_string()],
             asset_folder_id: Some("project".to_string()),
             asset_label: Some("勇者奔跑".to_string()),
         })
@@ -1412,6 +1499,10 @@ mod tests {
             json!("generated/editor/reference.mp4")
         );
         assert_eq!(payload["backgroundColor"], json!("purple"));
+        assert_eq!(
+            payload["appearanceReferenceSrcs"],
+            json!(["generated/editor/appearance.png"])
+        );
         assert_eq!(
             payload["sourceImageSrc"],
             json!("/generated-characters/hero/master.png")
@@ -1421,6 +1512,10 @@ mod tests {
         assert_eq!(payload["projectId"], json!("editor-project-1"));
         assert_eq!(payload["canvasCompletion"]["dialogId"], json!("dialog-1"));
         assert_eq!(payload["sourceResourceId"], json!("resource-source"));
+        assert_eq!(
+            payload["appearanceSourceResourceIds"],
+            json!(["resource-appearance"])
+        );
         assert_eq!(payload["assetFolderId"], json!("project"));
         assert_eq!(payload["assetLabel"], json!("勇者奔跑"));
     }
@@ -1443,6 +1538,66 @@ mod tests {
         assert_eq!(payload["assetLabel"], json!("奔跑动作"));
     }
 
+    #[test]
+    fn editor_character_animation_video_conversion_uses_discriminated_shape() {
+        let payload = serde_json::to_value(EditorCharacterAnimationVideoConversionRequest {
+            source_video_src: "users/owner/source.mov".to_string(),
+            resolution: "720p".to_string(),
+            project_id: Some("project-1".to_string()),
+            canvas_completion: None,
+            generation_inputs: None,
+            source_resource_id: Some("resource-video".to_string()),
+            asset_folder_id: Some("project".to_string()),
+            asset_label: Some("跑步视频转�".to_string()),
+        })
+        .expect("request should serialize");
+        assert_eq!(payload["sourceVideoSrc"], "users/owner/source.mov");
+        assert_eq!(payload["resolution"], "720p");
+        assert!(payload.get("promptText").is_none());
+        assert!(payload.get("model").is_none());
+    }
+
+    #[test]
+    fn editor_character_animation_120_frame_response_stays_within_queue_json_gate() {
+        let frames = (0..120)
+            .map(|index| EditorCharacterAnimationFramePayload {
+                image_src: format!(
+                    "/generated-character-animations/editor/video-conversions/task/frame{:03}.png",
+                    index + 1
+                ),
+                object_key: Some(format!(
+                    "generated-character-animations/editor/video-conversions/task/frame{:03}.png",
+                    index + 1
+                )),
+                asset_object_id: Some(format!("assetobj_{:064}", index + 1)),
+                width: 720,
+                height: 405,
+            })
+            .collect();
+        let payload = EditorCharacterAnimationVideoConversionResponse {
+            ok: true,
+            task_id: "task-max-frames".to_string(),
+            processing_method: "视频直接转�".to_string(),
+            frames,
+            frame_count: 120,
+            duration_ms: 15_000,
+            frame_width: 720,
+            frame_height: 405,
+            source_fps: 29.970_029_97,
+            sampling_fps: 8.0,
+            price_mud_points: 0,
+            project: None,
+            resource: None,
+            asset: None,
+            queue_state: None,
+        };
+        let bytes = serde_json::to_vec(&payload).expect("response should serialize");
+        assert!(
+            bytes.len() < 512 * 1024,
+            "120 frame payload must fit queue gate"
+        );
+    }
+
     #[test]
     fn editor_character_animation_response_includes_frames_and_preview_video() {
         let payload = serde_json::to_value(EditorCharacterAnimationGenerateResponse {
diff --git a/server-rs/crates/spacetime-module/src/editor_project_storage.rs b/server-rs/crates/spacetime-module/src/editor_project_storage.rs
index 8c8e69e68..bc3dbe2bb 100644
--- a/server-rs/crates/spacetime-module/src/editor_project_storage.rs
+++ b/server-rs/crates/spacetime-module/src/editor_project_storage.rs
@@ -17,13 +17,14 @@ const EDITOR_CANVAS_LAYOUT_MIGRATION_STATUS_ACTIVE: &str = "active";
 const EDITOR_CANVAS_LAYOUT_MIGRATION_STATUS_ROLLED_BACK: &str = "rolled_back";
 const EDITOR_CANVAS_RESOURCE_REPAIR_MAX_ACTIONS: usize = 16;
 const EDITOR_SPRITESHEET_SLICE_BATCH_MAX_ITEMS: usize = 64;
+const EDITOR_CHARACTER_ANIMATION_SLICE_BATCH_MAX_ITEMS: usize = 120;
 const EDITOR_CANVAS_AUDIO_RESOURCE_WIDTH: u32 = 420;
 const EDITOR_CANVAS_AUDIO_RESOURCE_HEIGHT: u32 = 120;
 const EDITOR_CHARACTER_ANIMATION_NORMALIZATION_MAX_BATCH_SIZE: u32 = 25;
 const EDITOR_CHARACTER_ANIMATION_CANVAS_NORMALIZATION_MAX_BATCH_SIZE: u32 = 5;
-// �明图集最多产出 64 个切片，�有 provider 原图和�明整图两个正� item。
-const EDITOR_GENERATION_RESULT_MAX_ITEMS: usize = 66;
-const EDITOR_GENERATION_OPERATION_KINDS: [&str; 10] = [
+// 角色动画视频转�最多 120 帧，第一帧�时承载最终 resource/asset，事务正好 120 项。
+const EDITOR_GENERATION_RESULT_MAX_ITEMS: usize = 120;
+const EDITOR_GENERATION_OPERATION_KINDS: [&str; 11] = [
     "editor_image_generation",
     "editor_icon_spec_generation",
     "editor_image_edit",
@@ -31,6 +32,7 @@ const EDITOR_GENERATION_OPERATION_KINDS: [&str; 10] = [
     "editor_icon_spritesheet_generation",
     "editor_ui_design_asset_extraction",
     "editor_character_animation_generation",
+    "editor_character_animation_video_conversion",
     "editor_video_generation",
     "editor_sound_effect_generation",
     "editor_background_music_generation",
@@ -3449,7 +3451,9 @@ fn validate_editor_generation_result_shape(
         return Err("生�结果 completed_at_micros 必须为正数".to_string());
     }
     if !(1..=EDITOR_GENERATION_RESULT_MAX_ITEMS).contains(&input.items.len()) {
-        return Err("生�结果 item 数�必须在 1 到 66 之间".to_string());
+        return Err(format!(
+            "生�结果 item 数�必须在 1 到 {EDITOR_GENERATION_RESULT_MAX_ITEMS} 之间"
+        ));
     }
     let result_project_id = editor_generation_result_project_id(input)?;
     let mut slots = BTreeSet::new();
@@ -5103,8 +5107,19 @@ fn validate_editor_spritesheet_slice_batch(
     group_task_id: Option<&str>,
 ) -> Result<(), String> {
     let item_count = input.items.len();
-    if !(1..=EDITOR_SPRITESHEET_SLICE_BATCH_MAX_ITEMS).contains(&item_count) {
-        return Err("图集切片批次产物数�必须在 1 到 64 之间".to_string());
+    let is_character_animation_batch = input.items.iter().all(|item| {
+        matches!(
+            item.asset_object.asset_kind.trim(),
+            EDITOR_CHARACTER_ANIMATION_ASSET_KIND | EDITOR_CHARACTER_ANIMATION_OBJECT_KIND
+        )
+    });
+    let max_items = if is_character_animation_batch {
+        EDITOR_CHARACTER_ANIMATION_SLICE_BATCH_MAX_ITEMS
+    } else {
+        EDITOR_SPRITESHEET_SLICE_BATCH_MAX_ITEMS
+    };
+    if !(1..=max_items).contains(&item_count) {
+        return Err(format!("图集切片批次产物数�必须在 1 到 {max_items} 之间"));
     }
     if usize::try_from(input.expected_asset_count).ok() != Some(item_count) {
         return Err("图集切片批次产物数�与预期�一致".to_string());
@@ -14084,7 +14099,7 @@ mod tests {
     }
 
     #[test]
-    fn editor_generation_result_shape_accepts_sixty_four_slices_plus_two_source_items() {
+    fn editor_generation_result_shape_accepts_exactly_one_hundred_twenty_items() {
         let mut input = editor_generation_result_input();
         input.items.clear();
         for index in 0..EDITOR_GENERATION_RESULT_MAX_ITEMS {
@@ -14138,8 +14153,8 @@ mod tests {
                 "editor_image_generation",
                 "job-1",
             )
-            .expect_err("more than the full spritesheet bundle must fail")
-            .contains("1 到 66")
+            .expect_err("more than the maximum generation bundle must fail")
+            .contains("1 到 120")
         );
     }
 
@@ -15685,6 +15700,45 @@ mod tests {
             .expect("complete batch should pass before transaction writes");
     }
 
+    #[test]
+    fn character_animation_split_accepts_120_but_icon_split_remains_64() {
+        let mut character_batch = spritesheet_slice_batch();
+        character_batch.items = (0..120).map(spritesheet_slice_item).collect();
+        character_batch.expected_asset_count = 120;
+        for item in &mut character_batch.items {
+            item.asset_object.asset_kind = EDITOR_CHARACTER_ANIMATION_OBJECT_KIND.to_string();
+            let asset = item.asset.as_mut().expect("asset");
+            asset.group_task_expected_asset_count = Some(120);
+        }
+        validate_editor_spritesheet_slice_batch(
+            &character_batch,
+            "user-1",
+            "task-1",
+            Some("group-task-1"),
+        )
+        .expect("character animation should allow 120 frames");
+
+        let mut icon_batch = spritesheet_slice_batch();
+        icon_batch.items = (0..65).map(spritesheet_slice_item).collect();
+        icon_batch.expected_asset_count = 65;
+        for item in &mut icon_batch.items {
+            item.asset
+                .as_mut()
+                .expect("asset")
+                .group_task_expected_asset_count = Some(65);
+        }
+        assert!(
+            validate_editor_spritesheet_slice_batch(
+                &icon_batch,
+                "user-1",
+                "task-1",
+                Some("group-task-1"),
+            )
+            .expect_err("icon spritesheet must remain capped at 64")
+            .contains("1 到 64")
+        );
+    }
+
     #[test]
     fn spritesheet_slice_batch_accepts_reused_source_objects_under_split_operation() {
         let mut batch = spritesheet_slice_batch();
diff --git a/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.test.tsx b/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.test.tsx
index ddc7fd156..e51a10fd8 100644
--- a/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.test.tsx
+++ b/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.test.tsx
@@ -227,6 +227,7 @@ describe('ImageCanvasCharacterAnimationPanelView', () => {
 
   it('renders completed frame count and failed error state', () => {
     const result = {
+      resultType: 'ai' as const,
       taskId: 'task-a',
       model: 'seedance2.0-fast' as const,
       prompt: '行走动作',
diff --git a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.test.tsx b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.test.tsx
index f19664276..01bd849f2 100644
--- a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.test.tsx
+++ b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.test.tsx
@@ -93,9 +93,6 @@ function CharacterGenerationHarness({
       <output aria-label="当�多方�角色图">
         {String(dialog.characterSheetEnabled === true)}
       </output>
-      <output aria-label="当�多方�图视角数">
-        {dialog.characterSheetViewSet ?? '4'}
-      </output>
       <output aria-label="选择角色规范">{String(isPickingSpec)}</output>
       <output aria-label="选择常规�考图">{String(isPickingReference)}</output>
     </div>
@@ -135,57 +132,21 @@ describe('ImageCanvasCharacterGenerationComposerView', () => {
       />,
     );
 
-    const toggle = screen.getByRole('button', { name: '多方�角色图' });
-    expect(toggle.getAttribute('aria-pressed')).toBe('false');
+    const toggle = screen.getByRole('checkbox', { name: '多方�图' });
+    expect((toggle as HTMLInputElement).checked).toBe(false);
 
     fireEvent.click(toggle);
 
     expect(screen.getByLabelText('当�多方�角色图').textContent).toBe('true');
     expect(
-      screen.getByRole('button', { name: '多方�角色图' }).getAttribute(
-        'aria-pressed',
-      ),
-    ).toBe('true');
+      (screen.getByRole('checkbox', { name: '多方�图' }) as HTMLInputElement)
+        .checked,
+    ).toBe(true);
 
-    fireEvent.click(screen.getByRole('button', { name: '多方�角色图' }));
+    fireEvent.click(screen.getByRole('checkbox', { name: '多方�图' }));
     expect(screen.getByLabelText('当�多方�角色图').textContent).toBe('false');
   });
 
-  it('shows the view-set dropdown only while the sheet is enabled', () => {
-    render(
-      <CharacterGenerationHarness
-        initialDialog={createDialog({ characterSheetEnabled: false })}
-      />,
-    );
-
-    expect(screen.queryByRole('button', { name: /多方�图视角/ })).toBeNull();
-
-    fireEvent.click(screen.getByRole('button', { name: '多方�角色图' }));
-
-    expect(
-      screen.getByRole('button', { name: '多方�图视角 四方�' }),
-    ).toBeTruthy();
-  });
-
-  it('switches the character sheet view set between four and eight', () => {
-    render(
-      <CharacterGenerationHarness
-        initialDialog={createDialog({
-          characterSheetEnabled: true,
-          characterSheetViewSet: '4',
-        })}
-      />,
-    );
-
-    fireEvent.click(screen.getByRole('button', { name: '多方�图视角 四方�' }));
-    fireEvent.click(screen.getByRole('button', { name: '八方�' }));
-
-    expect(screen.getByLabelText('当�多方�图视角数').textContent).toBe('8');
-    expect(
-      screen.getByRole('button', { name: '多方�图视角 八方�' }),
-    ).toBeTruthy();
-  });
-
   it('updates character prompt, clears failed state and submits', () => {
     const submitCharacter = vi.fn();
     render(
diff --git a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
index b77d8ef1c..03e61c913 100644
--- a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
@@ -1,12 +1,10 @@
-import { ChevronDown, ClipboardList, ImagePlus, LayoutGrid } from 'lucide-react';
+import { ClipboardList, ImagePlus } from 'lucide-react';
 import {
   type CSSProperties,
   type Dispatch,
   type ReactNode,
   type RefObject,
   type SetStateAction,
-  useRef,
-  useState,
 } from 'react';
 
 import { AutoGrowTextArea } from '../common/AutoGrowTextArea';
@@ -14,7 +12,6 @@ import {
   PlatformFloatingMenu,
   PlatformFloatingMenuItem,
 } from '../common/PlatformFloatingMenu';
-import { PlatformInlineOptionButton } from '../common/PlatformInlineOptionButton';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
 import type {
   CharacterReferenceImage,
@@ -104,8 +101,6 @@ export function ImageCanvasCharacterGenerationComposerView({
   hasPendingImageReferenceUploads = false,
   onSubmit,
 }: ImageCanvasCharacterGenerationComposerViewProps) {
-  const [isViewSetMenuOpen, setIsViewSetMenuOpen] = useState(false);
-  const viewSetButtonRef = useRef<HTMLButtonElement | null>(null);
   useImageCanvasFloatingOptionDismiss({
     isOpen: isCharacterSpecMenuOpen || isCharacterReferenceMenuOpen,
     boundaryRefs: [characterSpecButtonRef, characterReferenceButtonRef],
@@ -114,25 +109,6 @@ export function ImageCanvasCharacterGenerationComposerView({
       setIsCharacterReferenceMenuOpen(false);
     },
   });
-  useImageCanvasFloatingOptionDismiss({
-    isOpen: isViewSetMenuOpen,
-    boundaryRefs: [viewSetButtonRef],
-    onDismiss: () => setIsViewSetMenuOpen(false),
-    restoreFocusRef: viewSetButtonRef,
-  });
-  const setViewSet = (value: '4' | '8') => {
-    setIsViewSetMenuOpen(false);
-    setGenerateDialog((currentDialog) =>
-      currentDialog?.mode === 'character'
-        ? {
-            ...resetFailedDialogStatus(currentDialog),
-            characterSheetViewSet: value,
-          }
-        : currentDialog,
-    );
-  };
-  const selectedViewSetLabel =
-    (dialog.characterSheetViewSet ?? '4') === '8' ? '八方�' : '四方�';
 
   return (
     <div
@@ -240,30 +216,6 @@ export function ImageCanvasCharacterGenerationComposerView({
           isAdd
           onClick={() => setIsCharacterReferenceMenuOpen((open) => !open)}
         />
-        <ImageCanvasReferenceSlot
-          tone="character-sheet"
-          icon={<LayoutGrid className="h-4 w-4" aria-hidden="true" />}
-          label="多方�图"
-          ariaLabel="多方�角色图"
-          title={
-            dialog.characterSheetEnabled === true
-              ? '多方�角色图（开�）'
-              : '多方�角色图'
-          }
-          disabled={dialog.status === 'generating'}
-          pressed={dialog.characterSheetEnabled === true}
-          onClick={() =>
-            setGenerateDialog((currentDialog) =>
-              currentDialog?.mode === 'character'
-                ? {
-                    ...resetFailedDialogStatus(currentDialog),
-                    characterSheetEnabled:
-                      currentDialog.characterSheetEnabled !== true,
-                  }
-                : currentDialog,
-            )
-          }
-        />
         {isCharacterReferenceMenuOpen
           ? renderEditorPortal(
               <PlatformFloatingMenu
@@ -351,64 +303,28 @@ export function ImageCanvasCharacterGenerationComposerView({
               onSubmit(dialog);
             }
           }}
+          extraToggles={
+            <label className="image-canvas-editor__image-style-toggle">
+              <input
+                type="checkbox"
+                checked={dialog.characterSheetEnabled === true}
+                disabled={dialog.status === 'generating'}
+                onChange={(event) =>
+                  setGenerateDialog((currentDialog) =>
+                    currentDialog?.mode === 'character'
+                      ? {
+                          ...resetFailedDialogStatus(currentDialog),
+                          characterSheetEnabled: event.target.checked,
+                        }
+                      : currentDialog,
+                  )
+                }
+              />
+              <span>多方�图</span>
+            </label>
+          }
           renderEditorPortal={renderEditorPortal}
           buildPortalMenuStyle={buildPortalMenuStyle}
-          styleControl={
-            dialog.characterSheetEnabled === true ? (
-              <div className="image-canvas-editor__option-popover-anchor">
-                <PlatformInlineOptionButton
-                  ref={viewSetButtonRef}
-                  className="image-canvas-editor__option-cluster image-canvas-editor__option-cluster--viewset"
-                  aria-label={`多方�图视角 ${selectedViewSetLabel}`}
-                  aria-expanded={isViewSetMenuOpen}
-                  disabled={dialog.status === 'generating'}
-                  trailingIcon={<ChevronDown className="h-3 w-3" />}
-                  onClick={() => setIsViewSetMenuOpen((open) => !open)}
-                >
-                  {selectedViewSetLabel}
-                </PlatformInlineOptionButton>
-                {isViewSetMenuOpen
-                  ? renderEditorPortal(
-                      <PlatformFloatingMenu
-                        className="image-canvas-editor__option-popover image-canvas-editor__portal-menu"
-                        label="多方�图视角数"
-                        placement="top-start"
-                        style={buildPortalMenuStyle(
-                          viewSetButtonRef.current,
-                          'above',
-                        )}
-                        onPointerDown={(event) => event.stopPropagation()}
-                        onClick={(event) => event.stopPropagation()}
-                      >
-                        <div className="image-canvas-editor__option-popover-sections">
-                          <div className="image-canvas-editor__option-popover-section">
-                            <span className="image-canvas-editor__option-popover-title">
-                              视角数
-                            </span>
-                            <div className="image-canvas-editor__option-popover-items">
-                              {(['4', '8'] as const).map((value) => (
-                                <button
-                                  key={value}
-                                  type="button"
-                                  className="image-canvas-editor__option-popover-choice"
-                                  aria-pressed={
-                                    (dialog.characterSheetViewSet ?? '4') ===
-                                    value
-                                  }
-                                  onClick={() => setViewSet(value)}
-                                >
-                                  {value === '4' ? '四方�' : '八方�'}
-                                </button>
-                              ))}
-                            </div>
-                          </div>
-                        </div>
-                      </PlatformFloatingMenu>,
-                    )
-                  : null}
-              </div>
-            ) : undefined
-          }
         />
       </div>
     </div>
diff --git a/src/components/image-editor/ImageCanvasContextMenusView.test.tsx b/src/components/image-editor/ImageCanvasContextMenusView.test.tsx
index eedc9fba6..d136ba461 100644
--- a/src/components/image-editor/ImageCanvasContextMenusView.test.tsx
+++ b/src/components/image-editor/ImageCanvasContextMenusView.test.tsx
@@ -56,7 +56,6 @@ function renderContextMenus(
     onFitLayers: vi.fn(),
     onOpenQuickEditPanel: vi.fn(),
     onOpenLayerMetadata: vi.fn(),
-    onOpenCharacterAnimationPanel: vi.fn(),
     ...overrides,
   };
 
@@ -160,7 +159,6 @@ describe('ImageCanvasContextMenusView', () => {
       screen.getByRole('menuitem', { name: 'Spine 导出（zip）' }),
     );
     fireEvent.click(screen.getByRole('menuitem', { name: '快速编辑' }));
-    fireEvent.click(screen.getByRole('menuitem', { name: '生�动画' }));
     fireEvent.click(screen.getByRole('menuitem', { name: '删除' }));
 
     expect(props.onCopyContextLayers).toHaveBeenNthCalledWith(1);
@@ -179,9 +177,8 @@ describe('ImageCanvasContextMenusView', () => {
       expect.objectContaining({ mode: 'spine-json' }),
     );
     expect(props.onOpenQuickEditPanel).toHaveBeenCalledWith(layer);
-    expect(props.onOpenCharacterAnimationPanel).toHaveBeenCalledWith(layer);
-    expect(props.onCloseContextMenu).toHaveBeenCalledTimes(2);
-    expect(props.onCloseImageContextMenu).toHaveBeenCalledTimes(2);
+    expect(props.onCloseContextMenu).toHaveBeenCalledTimes(1);
+    expect(props.onCloseImageContextMenu).toHaveBeenCalledTimes(1);
     expect(props.onDeleteContextLayers).toHaveBeenCalledTimes(1);
   });
 
@@ -319,19 +316,6 @@ describe('ImageCanvasContextMenusView', () => {
     }
   });
 
-  it('closes the standalone image menu after opening character animation', () => {
-    const layer = createLayer({ assetKind: 'character' });
-    const props = renderContextMenus({
-      imageContextMenu: { layerId: layer.id, x: 20, y: 22 },
-      imageContextMenuLayer: layer,
-    });
-
-    fireEvent.click(screen.getByRole('menuitem', { name: '生�动画' }));
-
-    expect(props.onOpenCharacterAnimationPanel).toHaveBeenCalledWith(layer);
-    expect(props.onCloseImageContextMenu).toHaveBeenCalledTimes(1);
-  });
-
   it('renders the image context menu when no canvas context menu is open', () => {
     const layer = createLayer({ assetKind: 'character' });
     const props = renderContextMenus({
diff --git a/src/components/image-editor/ImageCanvasContextMenusView.tsx b/src/components/image-editor/ImageCanvasContextMenusView.tsx
index e8702e976..da08d5aed 100644
--- a/src/components/image-editor/ImageCanvasContextMenusView.tsx
+++ b/src/components/image-editor/ImageCanvasContextMenusView.tsx
@@ -53,7 +53,6 @@ type ImageCanvasContextMenusViewProps = {
   onFitLayers: () => void;
   onOpenQuickEditPanel: (layer: CanvasLayer) => void;
   onOpenLayerMetadata: (layer: CanvasLayer) => void;
-  onOpenCharacterAnimationPanel: (layer: CanvasLayer) => void;
 };
 
 type MeasuredMenuLayout = {
@@ -94,7 +93,6 @@ export function ImageCanvasContextMenusView({
   onFitLayers,
   onOpenQuickEditPanel,
   onOpenLayerMetadata,
-  onOpenCharacterAnimationPanel,
 }: ImageCanvasContextMenusViewProps) {
   const isImageSequenceLayer = contextMenuLayer?.mediaType === 'image-sequence';
   const layerCopyBlockedTitle =
@@ -525,19 +523,6 @@ export function ImageCanvasContextMenusView({
                   >
                     查看图片信�
                   </button>
-                  {imageContextMenuLayer.assetKind === 'character' ? (
-                    <button
-                      type="button"
-                      role="menuitem"
-                      onClick={() => {
-                        onOpenCharacterAnimationPanel(imageContextMenuLayer);
-                        onCloseContextMenu();
-                        onCloseImageContextMenu();
-                      }}
-                    >
-                      生�动画
-                    </button>
-                  ) : null}
                   <hr />
                 </>
               ) : null}
@@ -585,17 +570,6 @@ export function ImageCanvasContextMenusView({
             >
               查看图片信�
             </PlatformFloatingMenuItem>
-            {imageContextMenuLayer.assetKind === 'character' ? (
-              <PlatformFloatingMenuItem
-                className="image-canvas-editor__context-menu-item"
-                onClick={() => {
-                  onOpenCharacterAnimationPanel(imageContextMenuLayer);
-                  onCloseImageContextMenu();
-                }}
-              >
-                生�动画
-              </PlatformFloatingMenuItem>
-            ) : null}
             <PlatformFloatingMenuItem
               className="image-canvas-editor__context-menu-item"
               onClick={() => onDeleteLayerById(imageContextMenuLayer.id)}
diff --git a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
index 9f28be8b8..1ab91da71 100644
--- a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
+++ b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
@@ -3452,20 +3452,14 @@ describe('ImageCanvasEditorView generation integration', () => {
     const characterLayer = await screen.findByAltText('画布图片：市场�妇人');
     fireEvent.click(characterLayer.closest('button')!);
     expect(screen.getByText('角色')).toBeTruthy();
-    expect(screen.getByRole('button', { name: '生�动画' })).toBeTruthy();
+    expect(screen.queryByRole('button', { name: '生�动画' })).toBeNull();
     expect(screen.queryByRole('dialog', { name: '�绘图片' })).toBeNull();
     expect(
       screen.queryByRole('dialog', { name: 'Spine�列帧动画生�' }),
     ).toBeNull();
-    fireEvent.contextMenu(characterLayer.closest('button')!, {
-      clientX: 260,
-      clientY: 220,
-    });
-    expect(screen.getByRole('menuitem', { name: '生�动画' })).toBeTruthy();
-
     expect(screen.queryByRole('dialog', { name: '�绘图片' })).toBeNull();
 
-    fireEvent.click(screen.getByRole('button', { name: '生�动画' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Spine�列帧动画' }));
     expect(
       screen.getByRole('button', { name: '角色动作生���图' }),
     ).toBeTruthy();
@@ -3540,21 +3534,24 @@ describe('ImageCanvasEditorView generation integration', () => {
       }),
     );
     fireEvent.click(
-      within(
-        screen.getByRole('group', { name: '�列帧�数选项' }),
-      ).getByRole('button', { name: '720p' }),
+      within(screen.getByRole('group', { name: '�列帧�数选项' })).getByRole(
+        'button',
+        { name: '720p' },
+      ),
     );
     fireEvent.click(
-      within(
-        screen.getByRole('group', { name: '�列帧�数选项' }),
-      ).getByRole('button', { name: '16:9' }),
+      within(screen.getByRole('group', { name: '�列帧�数选项' })).getByRole(
+        'button',
+        { name: '16:9' },
+      ),
     );
     fireEvent.click(
-      within(
-        screen.getByRole('group', { name: '�列帧�数选项' }),
-      ).getByRole('button', {
-        name: '48帧·6秒',
-      }),
+      within(screen.getByRole('group', { name: '�列帧�数选项' })).getByRole(
+        'button',
+        {
+          name: '48帧·6秒',
+        },
+      ),
     );
     const resizedPlaceholder = screen.getByRole('button', {
       name: '角色动作生���图',
diff --git a/src/components/image-editor/ImageCanvasEditorModel.test.ts b/src/components/image-editor/ImageCanvasEditorModel.test.ts
index 4f160f6c4..696ee5196 100644
--- a/src/components/image-editor/ImageCanvasEditorModel.test.ts
+++ b/src/components/image-editor/ImageCanvasEditorModel.test.ts
@@ -1339,6 +1339,103 @@ describe('ImageCanvasEditorModel', () => {
     });
   });
 
+  it('hydrates a character-animation preview video through its source resource', () => {
+    const frames = [
+      {
+        imageSrc: '/generated/sequence/frame-1.png',
+        objectKey: 'generated/sequence/frame-1.png',
+        width: 480,
+        height: 480,
+      },
+      {
+        imageSrc: '/generated/sequence/frame-2.png',
+        objectKey: 'generated/sequence/frame-2.png',
+        width: 480,
+        height: 480,
+      },
+    ];
+    const hydrated = hydrateLayer(
+      {
+        layerId: 'layer-sequence',
+        resourceId: 'resource-sequence',
+        title: '角色动作',
+        sourceType: 'generated',
+      },
+      new Map([
+        [
+          'resource-sequence',
+          {
+            resourceId: 'resource-sequence',
+            imageSrc: frames[0]!.imageSrc,
+            objectKey: frames[0]!.objectKey,
+            assetKind: 'character-animation',
+            imageSequenceFrames: frames,
+            imageSequenceDurationMs: 4_000,
+            taskId: 'animation-task-1',
+            sourceResourceId: 'resource-preview-video',
+          },
+        ],
+        [
+          'resource-preview-video',
+          {
+            resourceId: 'resource-preview-video',
+            imageSrc: '/generated/video/preview.mp4',
+            objectKey: 'generated/video/preview.mp4',
+            assetKind: 'video',
+            taskId: 'animation-task-1',
+          },
+        ],
+      ]),
+    );
+
+    expect(hydrated).toMatchObject({
+      assetKind: 'character-animation',
+      mediaType: 'image-sequence',
+      previewVideoPath: 'generated/video/preview.mp4',
+      imageSequenceFrames: frames,
+      imageSequenceDurationMs: 4_000,
+    });
+  });
+
+  it('does not hydrate an older action reference as a generated preview video', () => {
+    const frames = [
+      { imageSrc: '/generated/sequence/frame-1.png', width: 480, height: 480 },
+      { imageSrc: '/generated/sequence/frame-2.png', width: 480, height: 480 },
+    ];
+    const hydrated = hydrateLayer(
+      {
+        layerId: 'layer-sequence',
+        resourceId: 'resource-sequence',
+        title: '角色动作',
+        sourceType: 'generated',
+      },
+      new Map([
+        [
+          'resource-sequence',
+          {
+            imageSrc: frames[0]!.imageSrc,
+            assetKind: 'character-animation',
+            imageSequenceFrames: frames,
+            imageSequenceDurationMs: 4_000,
+            taskId: 'animation-task-2',
+            sourceResourceId: 'resource-action-video',
+          },
+        ],
+        [
+          'resource-action-video',
+          {
+            imageSrc: '/generated/source/action.mp4',
+            objectKey: 'generated/source/action.mp4',
+            assetKind: 'video',
+            taskId: 'source-task-1',
+          },
+        ],
+      ]),
+    );
+
+    expect(hydrated?.previewVideoPath).toBeNull();
+  });
+
   it('rejects an action layer when its project resource lacks formal sequence fields', () => {
     const frames = [
       {
@@ -1637,6 +1734,100 @@ describe('ImageCanvasEditorModel', () => {
     });
   });
 
+  it('round-trips independent character animation AI and conversion drafts', () => {
+    const dialog: CanvasGenerationDialogState = {
+      id: 'dialog-character-animation-drafts',
+      mode: 'character-animation',
+      prompt: '�留 AI �示�',
+      status: 'idle',
+      characterAnimationWorkflow: 'video-conversion',
+      characterAnimationBackgroundColor: 'green',
+      characterAnimationResolution: '480p',
+      characterAnimationConversionResolution: '720p',
+      generationReferences: [
+        {
+          id: 'motion',
+          label: '动作视频',
+          src: 'users/user-1/motion.mp4',
+          objectKey: 'users/user-1/motion.mp4',
+          mediaType: 'video',
+          resourceId: 'resource-motion',
+        },
+      ],
+      characterAnimationAppearanceReferences: [
+        {
+          id: 'appearance',
+          label: '角色外观',
+          src: 'users/user-1/appearance.png',
+          objectKey: 'users/user-1/appearance.png',
+          resourceId: 'resource-appearance',
+        },
+      ],
+      characterAnimationConversionVideoReference: {
+        id: 'conversion-source',
+        label: '直接转��视频',
+        src: 'users/user-1/source.mov',
+        objectKey: 'users/user-1/source.mov',
+        mediaType: 'video',
+        resourceId: 'resource-conversion-source',
+      },
+    };
+
+    const layout = serializeCanvasLayout({
+      layers: [],
+      canvasGenerationDialogs: [dialog],
+    });
+    const { generationDialogs } = splitCanvasLayoutItems(
+      layout,
+      new Map([
+        [
+          'resource-motion',
+          {
+            imageSrc: 'users/user-1/motion.mp4',
+            objectKey: 'users/user-1/motion.mp4',
+          },
+        ],
+        [
+          'resource-appearance',
+          {
+            imageSrc: 'users/user-1/appearance.png',
+            objectKey: 'users/user-1/appearance.png',
+          },
+        ],
+        [
+          'resource-conversion-source',
+          {
+            imageSrc: 'users/user-1/source.mov',
+            objectKey: 'users/user-1/source.mov',
+          },
+        ],
+      ]),
+    );
+
+    expect(generationDialogs[0]).toMatchObject({
+      prompt: '�留 AI �示�',
+      characterAnimationWorkflow: 'video-conversion',
+      characterAnimationBackgroundColor: 'green',
+      characterAnimationResolution: '480p',
+      characterAnimationConversionResolution: '720p',
+      generationReferences: [
+        expect.objectContaining({
+          objectKey: 'users/user-1/motion.mp4',
+          mediaType: 'video',
+        }),
+      ],
+      characterAnimationAppearanceReferences: [
+        expect.objectContaining({
+          objectKey: 'users/user-1/appearance.png',
+        }),
+      ],
+      characterAnimationConversionVideoReference: expect.objectContaining({
+        objectKey: 'users/user-1/source.mov',
+        mediaType: 'video',
+      }),
+    });
+  });
+
   it('keeps the operation ledger out of the layout and restores it from the local ledger', () => {
     const dialogId = 'dialog-perfect-pixel-round-trip';
     const operation = buildPerfectPixelOperation(dialogId);
diff --git a/src/components/image-editor/ImageCanvasEditorModel.ts b/src/components/image-editor/ImageCanvasEditorModel.ts
index d063fac44..a44fa39e4 100644
--- a/src/components/image-editor/ImageCanvasEditorModel.ts
+++ b/src/components/image-editor/ImageCanvasEditorModel.ts
@@ -7,7 +7,7 @@ import { isEditorSceneStylePreset } from '../../../packages/shared/src/contracts
 import type {
   EditorAssetGenerationInputs,
   EditorAssetLibrarySnapshot,
-  EditorCharacterAnimationGenerationResult,
+  EditorCharacterAnimationResult,
   EditorPixelArtSnapInput,
   EditorProjectLayerSnapshot,
   EditorProjectSnapshot,
@@ -722,6 +722,12 @@ function serializeDialogReferences(
     generationReferences: serializeGenerationReferences(
       dialog.generationReferences,
     ),
+    characterAnimationAppearanceReferences: serializeGenerationReferences(
+      dialog.characterAnimationAppearanceReferences,
+    ),
+    characterAnimationConversionVideoReference: serializeGenerationReference(
+      dialog.characterAnimationConversionVideoReference,
+    ),
     characterSpecReference: serializeGenerationReference(
       dialog.characterSpecReference,
     ),
@@ -1274,6 +1280,34 @@ export function hydrateCanvasGenerationDialog(
       typeof snapshot.videoWebSearchEnabled === 'boolean'
         ? snapshot.videoWebSearchEnabled
         : undefined,
+    characterAnimationWorkflow:
+      snapshot.characterAnimationWorkflow === 'video-conversion'
+        ? 'video-conversion'
+        : snapshot.characterAnimationWorkflow === 'ai'
+          ? 'ai'
+          : undefined,
+    characterAnimationAppearanceReferences: hydrateCharacterReferences(
+      snapshot.characterAnimationAppearanceReferences,
+      resourcesById,
+      currentUserId,
+    ),
+    characterAnimationConversionVideoReference: hydrateCharacterReference(
+      snapshot.characterAnimationConversionVideoReference,
+      resourcesById,
+      currentUserId,
+    ),
+    characterAnimationConversionResolution:
+      snapshot.characterAnimationConversionResolution === '480p' ||
+      snapshot.characterAnimationConversionResolution === '720p'
+        ? snapshot.characterAnimationConversionResolution
+        : undefined,
+    characterAnimationBackgroundColor:
+      snapshot.characterAnimationBackgroundColor === 'white' ||
+      snapshot.characterAnimationBackgroundColor === 'green' ||
+      snapshot.characterAnimationBackgroundColor === 'blue' ||
+      snapshot.characterAnimationBackgroundColor === 'purple'
+        ? snapshot.characterAnimationBackgroundColor
+        : undefined,
     characterAnimationResolution:
       snapshot.characterAnimationResolution === '480p' ||
       snapshot.characterAnimationResolution === '720p'
@@ -1409,6 +1443,33 @@ export function hydrateLayer(
   const src = isFormalCharacterAnimation
     ? firstSequenceFrame || resource?.imageSrc || ''
     : snapshotSrc || firstSequenceFrame || resource?.imageSrc || '';
+  const sequencePreviewVideoPath = isFormalCharacterAnimation
+    ? (() => {
+        const previewResourceId = stringOrNull(resource?.sourceResourceId);
+        const previewResource = previewResourceId
+          ? resourcesById.get(previewResourceId)
+          : undefined;
+        if (previewResource?.assetKind !== 'video') {
+          return undefined;
+        }
+        // 正��列帧的 sourceResourceId 应指��一次�作登记的预览视频。
+        // 如果它实际指�更早的动作�考视频，�能把�考视频当�生�结果播放；
+        // 这也��历�错误 lineage 在刷新�悄悄改�“底层视频�。
+        const animationTaskId = stringOrNull(resource?.taskId);
+        const previewTaskId = stringOrNull(previewResource.taskId);
+        if (
+          animationTaskId &&
+          previewTaskId &&
+          animationTaskId !== previewTaskId
+        ) {
+          return undefined;
+        }
+        return (
+          stringOrNull(previewResource.objectKey) ??
+          stringOrNull(previewResource.imageSrc)
+        );
+      })()
+    : undefined;
   const title =
     typeof snapshot.title === 'string' ? snapshot.title : '画布图片';
   if (!resourceId || !layerId || !src) {
@@ -1503,7 +1564,7 @@ export function hydrateLayer(
       ? imageSequenceFrames
       : undefined,
     previewVideoPath: isFormalCharacterAnimation
-      ? null
+      ? (sequencePreviewVideoPath ?? null)
       : stringOrNull(snapshot.previewVideoPath),
     prompt: isFormalCharacterAnimation
       ? stringOrNull(resource?.prompt)
@@ -2023,25 +2084,43 @@ function videoAspectRatioOrUndefined(value: unknown) {
 
 function hydrateCharacterAnimationResult(
   value: unknown,
-): EditorCharacterAnimationGenerationResult | undefined {
+): EditorCharacterAnimationResult | undefined {
   if (!value || typeof value !== 'object') {
     return undefined;
   }
-  const result = value as Partial<EditorCharacterAnimationGenerationResult>;
+  const result = value as Record<string, unknown> &
+    Partial<EditorCharacterAnimationResult>;
   if (
     typeof result.taskId !== 'string' ||
-    result.model !== 'seedance2.0-fast' ||
-    typeof result.prompt !== 'string' ||
-    typeof result.previewVideoPath !== 'string' ||
     !Array.isArray(result.frames) ||
     typeof result.frameCount !== 'number' ||
-    typeof result.durationSeconds !== 'number' ||
-    typeof result.fps !== 'number' ||
     typeof result.priceMudPoints !== 'number'
   ) {
     return undefined;
   }
-  return result as EditorCharacterAnimationGenerationResult;
+  if (result.resultType === 'video-conversion') {
+    return result.processingMethod === '视频直接转�' &&
+      typeof result.durationMs === 'number' &&
+      typeof result.frameWidth === 'number' &&
+      typeof result.frameHeight === 'number' &&
+      typeof result.sourceFps === 'number' &&
+      typeof result.samplingFps === 'number' &&
+      result.priceMudPoints === 0
+      ? (result as EditorCharacterAnimationResult)
+      : undefined;
+  }
+  // 旧项目在判别字段引入���久化 AI 结果；按原契约��并补上判别字段。
+  if (
+    (result.resultType === undefined || result.resultType === 'ai') &&
+    result.model === 'seedance2.0-fast' &&
+    typeof result.prompt === 'string' &&
+    typeof result.previewVideoPath === 'string' &&
+    typeof result.durationSeconds === 'number' &&
+    typeof result.fps === 'number'
+  ) {
+    return { ...result, resultType: 'ai' } as EditorCharacterAnimationResult;
+  }
+  return undefined;
 }
 
 function hydrateImageSequenceFrames(
diff --git a/src/components/image-editor/ImageCanvasEditorShellView.test.tsx b/src/components/image-editor/ImageCanvasEditorShellView.test.tsx
index 3d0602a4e..71b3671fd 100644
--- a/src/components/image-editor/ImageCanvasEditorShellView.test.tsx
+++ b/src/components/image-editor/ImageCanvasEditorShellView.test.tsx
@@ -221,6 +221,7 @@ function createStageProps(): ImageCanvasStageViewProps {
     onPerfectPixel: vi.fn(),
     onSplitIconSpritesheet: vi.fn(),
     onSplitCharacterAnimation: vi.fn(),
+    onRemoveCharacterAnimationBackground: vi.fn(),
     onExtractUiDesignAssets: vi.fn(),
     onUiAssetExtractionToolChange: vi.fn(),
     onUiAssetExtractionModelChange: vi.fn(),
@@ -234,7 +235,6 @@ function createStageProps(): ImageCanvasStageViewProps {
     onQuickEditSelectionPointerStart: vi.fn(),
     onQuickEditSelectionPointerMove: vi.fn(),
     onQuickEditSelectionPointerEnd: vi.fn(),
-    onOpenCharacterAnimationPanel: vi.fn(),
     onDownloadLayer: vi.fn(),
     onPasteCanvasClipboard: vi.fn(),
     onCopyContextLayers: vi.fn(),
diff --git a/src/components/image-editor/ImageCanvasEditorTypes.ts b/src/components/image-editor/ImageCanvasEditorTypes.ts
index 92bbb03e0..be70fb385 100644
--- a/src/components/image-editor/ImageCanvasEditorTypes.ts
+++ b/src/components/image-editor/ImageCanvasEditorTypes.ts
@@ -8,7 +8,7 @@ import type {
   EditorAssetSnapshot,
   EditorCharacterAnimationBackgroundColor,
   EditorCharacterAnimationFrameCount,
-  EditorCharacterAnimationGenerationResult,
+  EditorCharacterAnimationResult,
   EditorCharacterAnimationRatio,
   EditorCharacterAnimationResolution,
   EditorImageGenerationStyle,
@@ -90,6 +90,8 @@ export type CanvasGenerationAction =
   | 'audio.sound-effect.generate'
   | 'audio.background-music.generate'
   | 'character-animation.generate'
+  | 'character-animation.convert'
+  | 'character-animation.remove-background'
   | 'image.edit'
   | 'ui-design.extract-assets'
   | 'image.perfect-pixel'
@@ -219,6 +221,8 @@ export type CharacterReferenceImage = {
   label: string;
   src: string;
   mediaType?: CanvasMediaType;
+  /** �考��的画布资产类型；用于区分�列帧底层视频与独立�视频。 */
+  assetKind?: CanvasAssetKind | null;
   mimeType?: string;
   sizeBytes?: number;
   durationSeconds?: number;
@@ -279,11 +283,9 @@ export type GenerateDialogState = {
   generationReferences?: CharacterReferenceImage[];
   characterSpecReference?: CharacterReferenceImage | null;
   characterReferences?: CharacterReferenceImage[];
-  // 中文注释：角色��的"多方�角色图"开关——开�时生�一张四方�角色图集
+  // 中文注释：角色��的"多方�角色图"开关——开�时生�一张八方�角色图集
   // （�端 kind=character-sheet，产物按 icon-spritesheet �库，�走既有拆分图集）。
   characterSheetEnabled?: boolean;
-  // 中文注释：多方�角色图的视角数（4 或 8），仅 characterSheetEnabled 时生效。
-  characterSheetViewSet?: '4' | '8';
   iconSpecReference?: CharacterReferenceImage | null;
   iconDescriptions?: string[];
   publicationWorkflowId?: PublicationMaterialsWorkflowId;
@@ -306,7 +308,11 @@ export type GenerateDialogState = {
   characterAnimationFrameCount?: EditorCharacterAnimationFrameCount;
   characterAnimationDurationSeconds?: 4 | 5 | 6;
   characterAnimationBackgroundColor?: EditorCharacterAnimationBackgroundColor;
-  characterAnimationResult?: EditorCharacterAnimationGenerationResult;
+  characterAnimationWorkflow?: 'ai' | 'video-conversion';
+  characterAnimationAppearanceReferences?: CharacterReferenceImage[];
+  characterAnimationConversionVideoReference?: CharacterReferenceImage | null;
+  characterAnimationConversionResolution?: EditorCharacterAnimationResolution;
+  characterAnimationResult?: EditorCharacterAnimationResult;
   soundModel?: EditorSoundEffectModel | 'audio1.0';
   soundDurationMode?: EditorSoundEffectDurationMode;
   soundDurationSeconds?: number;
@@ -501,6 +507,10 @@ export type CropExpandResizeHandle =
 export type CharacterAnimationPanelState = {
   sourceLayerId?: string;
   references?: CharacterReferenceImage[];
+  workflow?: 'ai' | 'video-conversion';
+  appearanceReferences?: CharacterReferenceImage[];
+  conversionVideoReference?: CharacterReferenceImage | null;
+  conversionResolution?: EditorCharacterAnimationResolution;
   promptText: string;
   assetLabel?: string;
   backgroundColor?: EditorCharacterAnimationBackgroundColor;
@@ -510,7 +520,7 @@ export type CharacterAnimationPanelState = {
   durationSeconds: 4 | 5 | 6;
   status: 'idle' | 'generating' | 'completed' | 'failed';
   errorMessage?: string;
-  result?: EditorCharacterAnimationGenerationResult;
+  result?: EditorCharacterAnimationResult;
 };
 
 export type UploadTarget =
diff --git a/src/components/image-editor/ImageCanvasEditorView.tsx b/src/components/image-editor/ImageCanvasEditorView.tsx
index aa4403734..86d610b7f 100644
--- a/src/components/image-editor/ImageCanvasEditorView.tsx
+++ b/src/components/image-editor/ImageCanvasEditorView.tsx
@@ -236,7 +236,8 @@ function findSourceAnimationLayer(
   return (
     layers.find(
       (layer) =>
-        (layer.resourceId === sourceResourceId || layer.id === sourceResourceId) &&
+        (layer.resourceId === sourceResourceId ||
+          layer.id === sourceResourceId) &&
         layer.assetKind === 'character',
     ) ?? null
   );
@@ -1431,6 +1432,9 @@ export function ImageCanvasEditorView({
     pendingImageReferenceUploadCount;
   const generationSurface = useImageCanvasGenerationSurface({
     layers,
+    selectedLayer: selectedLayerId
+      ? (layers.find((layer) => layer.id === selectedLayerId) ?? null)
+      : null,
     canvasSize,
     viewport,
     setViewport,
@@ -1603,6 +1607,8 @@ export function ImageCanvasEditorView({
     splittingIconSpritesheetLayerIds,
     splitSelectedCharacterAnimationFrames,
     splittingCharacterAnimationLayerIds,
+    removeSelectedCharacterAnimationBackground,
+    removingBackgroundCharacterAnimationLayerIds,
     extractUiDesignAssets,
     pickCharacterSpecFromLayer,
     pickGenerationReferenceFromLayer,
@@ -2598,6 +2604,7 @@ export function ImageCanvasEditorView({
     pendingPerfectPixelLayerIds,
     splittingIconSpritesheetLayerIds,
     splittingCharacterAnimationLayerIds,
+    removingBackgroundCharacterAnimationLayerIds,
     uploadDropTarget,
     contextMenu,
     canvasClipboard,
@@ -2664,6 +2671,11 @@ export function ImageCanvasEditorView({
         splitSelectedCharacterAnimationFrames(layer),
       );
     },
+    onRemoveCharacterAnimationBackground: (layer: CanvasLayer) => {
+      void flushProjectPersistence().then(() =>
+        removeSelectedCharacterAnimationBackground(layer),
+      );
+    },
     onExtractUiDesignAssets: extractUiDesignAssets,
     onUiAssetExtractionToolChange: changeUiAssetExtractionTool,
     onUiAssetExtractionModelChange: changeUiAssetExtractionModel,
@@ -2679,7 +2691,6 @@ export function ImageCanvasEditorView({
     onQuickEditSelectionPointerStart: startQuickEditSelectionPointer,
     onQuickEditSelectionPointerMove: moveQuickEditSelectionPointer,
     onQuickEditSelectionPointerEnd: endQuickEditSelectionPointer,
-    onOpenCharacterAnimationPanel: openCharacterAnimationPanel,
     onDownloadLayer: exportLayerImage,
     onPasteCanvasClipboard: pasteCanvasOrSystemClipboard,
     onCopyContextLayers: copyContextLayers,
diff --git a/src/components/image-editor/ImageCanvasExportModel.ts b/src/components/image-editor/ImageCanvasExportModel.ts
index 020bb627f..c9e350877 100644
--- a/src/components/image-editor/ImageCanvasExportModel.ts
+++ b/src/components/image-editor/ImageCanvasExportModel.ts
@@ -456,7 +456,7 @@ export function buildSpineImageSequenceJson({
     skeleton: {
       spine: DEFAULT_SPINE_VERSION,
       images: './frames/',
-      fps: Math.max(1, Math.round(frames.length / durationSeconds)),
+      fps: Number((frames.length / durationSeconds).toFixed(6)),
       width: skeletonWidth,
       height: skeletonHeight,
     },
diff --git a/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx b/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
index 68b1bec1a..1a20c5d40 100644
--- a/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
@@ -2119,6 +2119,190 @@ describe('ImageCanvasGenerationComposerView', () => {
     ).toBeTruthy();
   });
 
+  it('AI 视频从画布选中外观图�展示已选�考并支�移除', () => {
+    renderComposer({
+      id: 'dialog-character-animation-video-appearance',
+      mode: 'character-animation',
+      prompt: '原地奔跑',
+      status: 'idle',
+      composerOpen: true,
+      generationReferences: [
+        {
+          id: 'motion-video',
+          label: '动作视频',
+          src: 'generated/motion.mp4',
+          mediaType: 'video',
+        },
+      ],
+      characterAnimationAppearanceReferences: [
+        {
+          id: 'appearance-image',
+          label: '骑士角色',
+          src: 'generated/knight.png',
+          mediaType: 'image',
+        },
+      ],
+      characterAnimationWorkflow: 'ai',
+    });
+
+    const panel = screen.getByRole('dialog', {
+      name: 'Spine�列帧动画生�',
+    });
+    expect(within(panel).getByText('骑士角色')).toBeTruthy();
+    expect(
+      within(panel).getByRole('button', { name: '删除骑士角色' }),
+    ).toBeTruthy();
+  });
+
+  it('删除动作视频�清空动作并�留外观图片�考', () => {
+    const dialog: GenerateDialogState = {
+      id: 'dialog-character-animation-video-remove-motion',
+      mode: 'character-animation',
+      prompt: '原地奔跑',
+      status: 'idle',
+      composerOpen: true,
+      generationReferences: [
+        {
+          id: 'motion-video',
+          label: '动作视频',
+          src: 'generated/motion.mp4',
+          mediaType: 'video',
+        },
+      ],
+      characterAnimationAppearanceReferences: [
+        {
+          id: 'appearance-image',
+          label: '骑士角色',
+          src: 'generated/knight.png',
+          mediaType: 'image',
+        },
+      ],
+      characterAnimationWorkflow: 'ai',
+    };
+    const setGenerateDialog = vi.fn();
+    renderComposer(dialog, { setGenerateDialog });
+
+    const panel = screen.getByRole('dialog', {
+      name: 'Spine�列帧动画生�',
+    });
+    fireEvent.click(
+      within(panel).getByRole('button', { name: '删除动作视频' }),
+    );
+
+    const updater = setGenerateDialog.mock.calls[0]?.[0] as (
+      currentDialog: GenerateDialogState | null,
+    ) => GenerateDialogState | null;
+    const nextDialog = updater(dialog);
+    expect(nextDialog?.generationReferences).toEqual([]);
+    expect(nextDialog?.characterAnimationAppearanceReferences).toEqual([
+      expect.objectContaining({ id: 'appearance-image', mediaType: 'image' }),
+    ]);
+  });
+
+  it('视频直接转�标签�展示 AI 外观图�稿', () => {
+    renderComposer({
+      id: 'dialog-character-animation-conversion-hidden-appearance',
+      mode: 'character-animation',
+      prompt: '',
+      status: 'idle',
+      composerOpen: true,
+      characterAnimationWorkflow: 'video-conversion',
+      characterAnimationConversionVideoReference: {
+        id: 'conversion-video',
+        label: '�视频',
+        src: 'generated/source.mp4',
+        mediaType: 'video',
+      },
+      generationReferences: [
+        {
+          id: 'motion-video',
+          label: '动作视频',
+          src: 'generated/motion.mp4',
+          mediaType: 'video',
+        },
+      ],
+      characterAnimationAppearanceReferences: [
+        {
+          id: 'appearance-image',
+          label: '骑士角色',
+          src: 'generated/knight.png',
+          mediaType: 'image',
+        },
+      ],
+    });
+
+    const panel = screen.getByRole('dialog', {
+      name: 'Spine�列帧动画生�',
+    });
+    expect(within(panel).queryByText('骑士角色')).toBeNull();
+    expect(within(panel).getAllByText('�视频')).toHaveLength(2);
+    expect(
+      within(panel).getByRole('button', { name: '删除�视频' }),
+    ).toBeTruthy();
+  });
+
+  it('视频作为 AI �考时�展示角色外观��符，但��留统一�考入�', () => {
+    renderComposer({
+      id: 'dialog-character-animation-video-reference',
+      mode: 'character-animation',
+      prompt: '原地奔跑',
+      status: 'idle',
+      composerOpen: true,
+      generationReferences: [
+        {
+          id: 'motion-video',
+          label: '动作视频',
+          src: 'generated/motion.mp4',
+          mediaType: 'video',
+        },
+      ],
+      characterAnimationWorkflow: 'ai',
+    });
+
+    const panel = screen.getByRole('dialog', {
+      name: 'Spine�列帧动画生�',
+    });
+    expect(within(panel).queryByText('角色外观')).toBeNull();
+    expect(
+      within(panel).getByRole('button', { name: '添加�列帧�考素�' }),
+    ).toBeTruthy();
+  });
+
+  it('defaults to AI workflow and keeps independent drafts while switching tabs', () => {
+    render(<CharacterAnimationParametersHarness backgroundColor="green" />);
+
+    const panel = screen.getByRole('dialog', {
+      name: 'Spine�列帧动画生�',
+    });
+    const aiTab = within(panel).getByRole('tab', { name: 'AI生�/改造' });
+    const conversionTab = within(panel).getByRole('tab', {
+      name: '视频直接转�',
+    });
+    expect(aiTab.getAttribute('aria-selected')).toBe('true');
+    expect(
+      within(panel).getByRole('textbox', { name: '动画�述' }).textContent,
+    ).toBe('原地奔跑');
+
+    fireEvent.click(conversionTab);
+    expect(conversionTab.getAttribute('aria-selected')).toBe('true');
+    expect(
+      within(panel).queryByRole('textbox', { name: '动画�述' }),
+    ).toBeNull();
+    expect(within(panel).getByText('�费转�')).toBeTruthy();
+    expect(
+      (
+        within(panel).getByRole('button', {
+          name: '�费转�为Spine�列帧动画',
+        }) as HTMLButtonElement
+      ).disabled,
+    ).toBe(true);
+
+    fireEvent.click(aiTab);
+    expect(
+      within(panel).getByRole('textbox', { name: '动画�述' }).textContent,
+    ).toBe('原地奔跑');
+  });
+
   it('�列帧背景�比例�帧数时长和清晰度�独立选中并�留其他�数', () => {
     render(<CharacterAnimationParametersHarness backgroundColor="green" />);
 
diff --git a/src/components/image-editor/ImageCanvasGenerationComposerView.tsx b/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
index b6a07d5dd..c9a848bd5 100644
--- a/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
@@ -417,6 +417,9 @@ function ImageCanvasSequenceAnimationComposerView({
   const pendingActionFocusIndexRef = useRef<number | null>(null);
   const pendingActionFocusTargetRef = useRef<HTMLButtonElement | null>(null);
   const reference = dialog.generationReferences?.[0];
+  const workflow = dialog.characterAnimationWorkflow ?? 'ai';
+  const conversionReference =
+    dialog.characterAnimationConversionVideoReference ?? null;
   const isGenerating = dialog.status === 'generating';
   const resolution = dialog.characterAnimationResolution ?? '480p';
   const ratio = dialog.characterAnimationRatio ?? '1:1';
@@ -480,179 +483,316 @@ function ImageCanvasSequenceAnimationComposerView({
         aria-label="Spine�列帧动画生�"
         onPointerDown={(event) => event.stopPropagation()}
       >
-        <div className="image-canvas-editor__reference-strip">
-          {reference ? (
-            <VideoReferenceChip
-              reference={reference}
-              index={0}
-              onRemove={() => {
-                // 仅当比例是“�图尺寸�时�回�到 1:1；用户显�选过 4:3/16:9 等
-                // 比例时移除�考应�留原选择。
-                const isSameRatio = dialog.characterAnimationRatio === 'same';
-                updateDialog({
-                  sourceLayerId: undefined,
-                  generationReferences: [],
-                  ...(isSameRatio ? { characterAnimationRatio: '1:1' } : {}),
-                });
-              }}
-            />
-          ) : null}
-          <ImageCanvasReferenceSlot
-            buttonRef={generationReferenceButtonRef}
-            tone="character"
-            icon={<ImageIcon className="h-4 w-4" aria-hidden="true" />}
-            label="�考"
-            ariaLabel="添加�列帧�考素�"
-            disabled={isGenerating}
-            isAdd
-            onClick={() => {
-              closeParameterMenu();
-              setIsGenerationReferenceMenuOpen((open) => !open);
-            }}
-          />
-        </div>
-        <AutoGrowTextArea
-          aria-label="动画�述"
-          value={dialog.prompt}
-          maxLength={4000}
-          disabled={isGenerating}
-          placeholder="请�述人物�����什么�如何�。比如：让人物�侧�原地�断快速奔跑。"
-          className="max-h-64 image-canvas-editor__generation-prompt image-canvas-editor__character-animation-textarea"
-          onValueChange={(prompt) => updateDialog({ prompt })}
-        />
         <div
-          className="image-canvas-editor__character-animation-backgrounds"
-          role="group"
-          aria-label="背景颜色"
+          role="tablist"
+          aria-label="�列帧处�方�"
+          className="image-canvas-editor__workflow-tabs"
         >
-          {CHARACTER_ANIMATION_BACKGROUND_OPTIONS.map((option) => (
-            <button
-              key={option.value}
-              type="button"
-              className={`image-canvas-editor__character-animation-color-button image-canvas-editor__character-animation-color-button--${option.value}`}
-              aria-label={`背景颜色 ${option.label}`}
-              aria-pressed={backgroundColor === option.value}
-              disabled={isGenerating}
-              onClick={() =>
-                updateDialog({
-                  characterAnimationBackgroundColor: option.value,
-                })
-              }
-            >
-              {option.label}
-            </button>
-          ))}
-        </div>
-        <div
-          className="image-canvas-editor__character-animation-presets"
-          aria-label="动作预设"
-          style={{
-            display: 'grid',
-            gridTemplateColumns: `repeat(${CHARACTER_ANIMATION_ACTIONS_PER_ROW}, minmax(0, 1fr))`,
-          }}
-        >
-          {CHARACTER_ANIMATION_ACTION_PROMPTS.map((preset) => (
-            <button
-              key={preset.label}
-              type="button"
-              className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
-              disabled={isGenerating}
-              onClick={() => applyActionPrompt(preset.label, preset.text)}
-            >
-              {preset.label}
-            </button>
-          ))}
-          {visibleMoreActions.map((label, index) => (
-            <button
-              key={label}
-              ref={(button) => {
-                if (index === pendingActionFocusIndexRef.current) {
-                  pendingActionFocusTargetRef.current = button;
-                }
-              }}
-              type="button"
-              className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
-              disabled={isGenerating}
-              onClick={() => applyActionPrompt(label)}
-            >
-              {label}
-            </button>
-          ))}
           <button
             type="button"
-            className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
+            role="tab"
+            className="image-canvas-editor__workflow-tab"
+            aria-selected={workflow === 'ai'}
             disabled={isGenerating}
-            aria-expanded={hasExpandedActions}
-            onClick={() => {
-              const nextCount = hasExpandedAllActions
-                ? 0
-                : Math.min(
-                    visibleMoreActionCount +
-                      CHARACTER_ANIMATION_ACTIONS_PER_ROW,
-                    CHARACTER_ANIMATION_MORE_ACTION_PROMPTS.length,
-                  );
-              pendingActionFocusIndexRef.current = hasExpandedAllActions
-                ? null
-                : visibleMoreActionCount;
-              setVisibleMoreActionCount(nextCount);
-              setActionPresetAnnouncement(
-                nextCount === 0
-                  ? '更多动作已收起'
-                  : nextCount >= CHARACTER_ANIMATION_MORE_ACTION_PROMPTS.length
-                    ? `已显示全部${nextCount}个更多动作`
-                    : `已显示${nextCount}个更多动作`,
-              );
-            }}
+            onClick={() => updateDialog({ characterAnimationWorkflow: 'ai' })}
           >
-            {hasExpandedAllActions ? '收起' : '更多'}
+            AI生�/改造
           </button>
-          <span
-            className="sr-only"
-            role="status"
-            aria-live="polite"
-            aria-atomic="true"
-          >
-            {actionPresetAnnouncement}
-          </span>
-        </div>
-        <div className="image-canvas-editor__character-animation-footer">
-          <PlatformInlineOptionButton
-            ref={parameterMenuButtonRef}
-            className="image-canvas-editor__character-animation-parameter-trigger"
-            aria-label={`�列帧�数 ${ratio === 'same' ? '�图尺寸' : ratio} · ${durationSeconds}秒 · ${resolution}`}
-            aria-expanded={isParameterMenuOpen}
-            disabled={isGenerating}
-            trailingIcon={<ChevronDown className="h-3 w-3" />}
-            onClick={() => {
-              setIsGenerationReferenceMenuOpen(false);
-              setIsParameterMenuOpen((open) => !open);
-            }}
-          >
-            {ratio === 'same' ? '�图尺寸' : ratio} · {durationSeconds}秒 ·{' '}
-            {resolution}
-          </PlatformInlineOptionButton>
-          <PlatformActionButton
-            className="image-canvas-editor__character-animation-submit"
+          <button
             type="button"
-            tone="secondary"
-            size="xs"
-            shape="pill"
-            disabled={isGenerating || !dialog.prompt.trim()}
-            aria-label="生�Spine�列帧动画"
-            onClick={() => {
-              if (!isGenerating) {
-                onSubmit();
-              }
-            }}
+            role="tab"
+            className="image-canvas-editor__workflow-tab"
+            aria-selected={workflow === 'video-conversion'}
+            disabled={isGenerating}
+            onClick={() =>
+              updateDialog({ characterAnimationWorkflow: 'video-conversion' })
+            }
           >
-            {isGenerating ? '生�中' : `生�${price}泥点`}
-          </PlatformActionButton>
+            视频直接转�
+          </button>
         </div>
-        {dialog.status === 'failed' ? (
-          <PlatformStatusMessage tone="error" surface="platform" size="xs">
-            {dialog.errorMessage ?? '生�Spine�列帧动画失败'}
-          </PlatformStatusMessage>
-        ) : null}
+        {workflow === 'video-conversion' ? (
+          <>
+            <div className="image-canvas-editor__reference-strip">
+              {conversionReference ? (
+                <VideoReferenceChip
+                  reference={conversionReference}
+                  index={0}
+                  onRemove={() =>
+                    updateDialog({
+                      characterAnimationConversionVideoReference: null,
+                    })
+                  }
+                />
+              ) : null}
+              <ImageCanvasReferenceSlot
+                buttonRef={generationReferenceButtonRef}
+                tone="character"
+                icon={<Film className="h-4 w-4" aria-hidden="true" />}
+                label="�视频"
+                ariaLabel="选择直接转��视频"
+                disabled={isGenerating}
+                isAdd
+                onClick={() => {
+                  closeParameterMenu();
+                  setIsGenerationReferenceMenuOpen((open) => !open);
+                }}
+              />
+            </div>
+            <div className="image-canvas-editor__character-animation-conversion-resolution-field">
+              <span className="image-canvas-editor__character-animation-menu-title">
+                清晰度
+              </span>
+              <div
+                className="image-canvas-editor__character-animation-menu-options"
+                role="group"
+                aria-label="直接转�清晰度"
+              >
+                {CHARACTER_ANIMATION_RESOLUTION_OPTIONS.map((value) => (
+                  <button
+                    key={value}
+                    type="button"
+                    className="image-canvas-editor__character-animation-menu-pill"
+                    aria-pressed={
+                      (dialog.characterAnimationConversionResolution ??
+                        '480p') === value
+                    }
+                    disabled={isGenerating}
+                    onClick={() =>
+                      updateDialog({
+                        characterAnimationConversionResolution: value,
+                      })
+                    }
+                  >
+                    {value}
+                  </button>
+                ))}
+              </div>
+            </div>
+            <PlatformActionButton
+              className="image-canvas-editor__character-animation-submit"
+              type="button"
+              tone="secondary"
+              size="xs"
+              shape="pill"
+              disabled={isGenerating || !conversionReference}
+              aria-label="�费转�为Spine�列帧动画"
+              onClick={() => !isGenerating && onSubmit()}
+            >
+              {isGenerating ? '转�中' : '�费转�'}
+            </PlatformActionButton>
+          </>
+        ) : (
+          <>
+            <div className="image-canvas-editor__reference-strip">
+              {reference ? (
+                <VideoReferenceChip
+                  reference={reference}
+                  index={0}
+                  onRemove={() => {
+                    // 仅当比例是“�图尺寸�时�回�到 1:1；用户显�选过 4:3/16:9 等
+                    // 比例时移除�考应�留原选择。
+                    const isSameRatio =
+                      dialog.characterAnimationRatio === 'same';
+                    updateDialog({
+                      sourceLayerId: undefined,
+                      generationReferences: [],
+                      ...(isSameRatio
+                        ? { characterAnimationRatio: '1:1' }
+                        : {}),
+                    });
+                  }}
+                />
+              ) : null}
+              {reference?.mediaType === 'video'
+                ? (dialog.characterAnimationAppearanceReferences ?? []).map(
+                    (appearanceReference, index) => (
+                      <VideoReferenceChip
+                        key={appearanceReference.id}
+                        reference={appearanceReference}
+                        index={index + 1}
+                        onRemove={() =>
+                          updateDialog({
+                            characterAnimationAppearanceReferences: (
+                              dialog.characterAnimationAppearanceReferences ?? []
+                            ).filter(
+                              (item) => item.id !== appearanceReference.id,
+                            ),
+                          })
+                        }
+                      />
+                    ),
+                  )
+                : null}
+              <ImageCanvasReferenceSlot
+                buttonRef={generationReferenceButtonRef}
+                tone="character"
+                icon={<ImageIcon className="h-4 w-4" aria-hidden="true" />}
+                label="�考"
+                ariaLabel="添加�列帧�考素�"
+                disabled={isGenerating}
+                isAdd
+                onClick={() => {
+                  closeParameterMenu();
+                  setIsGenerationReferenceMenuOpen((open) => !open);
+                }}
+              />
+            </div>
+            <AutoGrowTextArea
+              aria-label="动画�述"
+              value={dialog.prompt}
+              maxLength={4000}
+              disabled={isGenerating}
+              placeholder="请�述人物�����什么�如何�。比如：让人物�侧�原地�断快速奔跑。"
+              className="max-h-64 image-canvas-editor__generation-prompt image-canvas-editor__character-animation-textarea"
+              onValueChange={(prompt) => updateDialog({ prompt })}
+            />
+            <div className="image-canvas-editor__character-animation-background-field">
+              <span className="image-canvas-editor__character-animation-menu-title">
+                背景色
+              </span>
+              <div
+                className="image-canvas-editor__character-animation-backgrounds"
+                role="group"
+                aria-label="背景颜色"
+              >
+                {CHARACTER_ANIMATION_BACKGROUND_OPTIONS.map((option) => (
+                  <button
+                    key={option.value}
+                    type="button"
+                    className={`image-canvas-editor__character-animation-color-button image-canvas-editor__character-animation-color-button--${option.value}`}
+                    aria-label={`背景颜色 ${option.label}`}
+                    aria-pressed={backgroundColor === option.value}
+                    disabled={isGenerating}
+                    onClick={() =>
+                      updateDialog({
+                        characterAnimationBackgroundColor: option.value,
+                      })
+                    }
+                  >
+                    {option.label}
+                  </button>
+                ))}
+              </div>
+            </div>
+            <div className="image-canvas-editor__character-animation-presets-field">
+              <span className="image-canvas-editor__character-animation-menu-title">
+                动作
+              </span>
+              <div
+                className="image-canvas-editor__character-animation-presets"
+                aria-label="动作预设"
+                style={{
+                  display: 'grid',
+                  gridTemplateColumns: `repeat(${CHARACTER_ANIMATION_ACTIONS_PER_ROW}, minmax(0, 1fr))`,
+                }}
+              >
+                {CHARACTER_ANIMATION_ACTION_PROMPTS.map((preset) => (
+                  <button
+                    key={preset.label}
+                    type="button"
+                    className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
+                    disabled={isGenerating}
+                    onClick={() => applyActionPrompt(preset.label, preset.text)}
+                  >
+                    {preset.label}
+                  </button>
+                ))}
+                {visibleMoreActions.map((label, index) => (
+                  <button
+                    key={label}
+                    ref={(button) => {
+                      if (index === pendingActionFocusIndexRef.current) {
+                        pendingActionFocusTargetRef.current = button;
+                      }
+                    }}
+                    type="button"
+                    className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
+                    disabled={isGenerating}
+                    onClick={() => applyActionPrompt(label)}
+                  >
+                    {label}
+                  </button>
+                ))}
+                <button
+                  type="button"
+                  className="image-canvas-editor__character-animation-preset image-canvas-editor__character-animation-preset--action"
+                  disabled={isGenerating}
+                  aria-expanded={hasExpandedActions}
+                  onClick={() => {
+                    const nextCount = hasExpandedAllActions
+                      ? 0
+                      : Math.min(
+                          visibleMoreActionCount +
+                            CHARACTER_ANIMATION_ACTIONS_PER_ROW,
+                          CHARACTER_ANIMATION_MORE_ACTION_PROMPTS.length,
+                        );
+                    pendingActionFocusIndexRef.current = hasExpandedAllActions
+                      ? null
+                      : visibleMoreActionCount;
+                    setVisibleMoreActionCount(nextCount);
+                    setActionPresetAnnouncement(
+                      nextCount === 0
+                        ? '更多动作已收起'
+                        : nextCount >=
+                            CHARACTER_ANIMATION_MORE_ACTION_PROMPTS.length
+                          ? `已显示全部${nextCount}个更多动作`
+                          : `已显示${nextCount}个更多动作`,
+                    );
+                  }}
+                >
+                  {hasExpandedAllActions ? '收起' : '更多'}
+                </button>
+                <span
+                  className="sr-only"
+                  role="status"
+                  aria-live="polite"
+                  aria-atomic="true"
+                >
+                  {actionPresetAnnouncement}
+                </span>
+              </div>
+            </div>
+            <div className="image-canvas-editor__character-animation-footer">
+              <PlatformInlineOptionButton
+                ref={parameterMenuButtonRef}
+                className="image-canvas-editor__character-animation-parameter-trigger"
+                aria-label={`�列帧�数 ${ratio === 'same' ? '�图尺寸' : ratio} · ${durationSeconds}秒 · ${resolution}`}
+                aria-expanded={isParameterMenuOpen}
+                disabled={isGenerating}
+                trailingIcon={<ChevronDown className="h-3 w-3" />}
+                onClick={() => {
+                  setIsGenerationReferenceMenuOpen(false);
+                  setIsParameterMenuOpen((open) => !open);
+                }}
+              >
+                {ratio === 'same' ? '�图尺寸' : ratio} · {durationSeconds}秒 ·{' '}
+                {resolution}
+              </PlatformInlineOptionButton>
+              <PlatformActionButton
+                className="image-canvas-editor__character-animation-submit"
+                type="button"
+                tone="secondary"
+                size="xs"
+                shape="pill"
+                disabled={isGenerating || (!dialog.prompt.trim() && !reference)}
+                aria-label="生�Spine�列帧动画"
+                onClick={() => {
+                  if (!isGenerating) {
+                    onSubmit();
+                  }
+                }}
+              >
+                {isGenerating ? '生�中' : `生�${price}泥点`}
+              </PlatformActionButton>
+            </div>
+            {dialog.status === 'failed' ? (
+              <PlatformStatusMessage tone="error" surface="platform" size="xs">
+                {dialog.errorMessage ?? '生�Spine�列帧动画失败'}
+              </PlatformStatusMessage>
+            ) : null}
+          </>
+        )}
       </div>
       {isParameterMenuOpen
         ? renderEditorPortal(
@@ -781,24 +921,29 @@ function ImageCanvasSequenceAnimationComposerView({
               >
                 从画布中选择
               </PlatformFloatingMenuItem>
-              <PlatformFloatingMenuItem
-                onClick={() => {
-                  setIsGenerationReferenceMenuOpen(false);
-                  setIsPickingGenerationReferenceFromCanvas(false);
-                  onRequestUpload('video-reference-image');
-                }}
-              >
-                上传图片
-              </PlatformFloatingMenuItem>
-              <PlatformFloatingMenuItem
-                onClick={() => {
-                  setIsGenerationReferenceMenuOpen(false);
-                  setIsPickingGenerationReferenceFromCanvas(false);
-                  onRequestUpload('video-reference-video');
-                }}
-              >
-                上传视频
-              </PlatformFloatingMenuItem>
+              {workflow !== 'video-conversion' ? (
+                <PlatformFloatingMenuItem
+                  onClick={() => {
+                    setIsGenerationReferenceMenuOpen(false);
+                    setIsPickingGenerationReferenceFromCanvas(false);
+                    onRequestUpload('video-reference-image');
+                  }}
+                >
+                  上传图片
+                </PlatformFloatingMenuItem>
+              ) : null}
+              {workflow === 'video-conversion' ||
+              reference?.mediaType !== 'video' ? (
+                <PlatformFloatingMenuItem
+                  onClick={() => {
+                    setIsGenerationReferenceMenuOpen(false);
+                    setIsPickingGenerationReferenceFromCanvas(false);
+                    onRequestUpload('video-reference-video');
+                  }}
+                >
+                  上传视频
+                </PlatformFloatingMenuItem>
+              ) : null}
             </PlatformFloatingMenu>,
           )
         : null}
@@ -2224,7 +2369,11 @@ export function ImageCanvasGenerationComposerView({
       {isPickingGenerationReferenceFromCanvas ? (
         <div className="image-canvas-editor__canvas-pick-hint">
           {generateDialog?.mode === 'character-animation'
-            ? '请选择画布中的角色图或视频作为�考，按 Esc 退出'
+            ? generateDialog.characterAnimationWorkflow === 'video-conversion'
+              ? '请选择画布中的视频作为�视频，按 Esc 退出'
+              : generateDialog.generationReferences?.[0]?.mediaType === 'video'
+                ? '请选择画布中的图片作为外观�考，按 Esc 退出'
+                : '请选择画布中的角色图或视频作为�考，按 Esc 退出'
             : '请选择画布中的图片作为�考图，按 Esc 退出'}
         </div>
       ) : null}
diff --git a/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts b/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
index 962021fab..ad3a9f28e 100644
--- a/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
@@ -1242,7 +1242,6 @@ describe('ImageCanvasGenerationDialogModel', () => {
             fields: [
               { id: 'prompt', title: '角色设定', value: '日系魔法少女' },
               { id: 'model', title: '模型', value: 'nanobanana2' },
-              { id: 'viewSet', title: '视角集�', value: '八视图' },
               { id: 'aspectRatio', title: '比例', value: '1:1' },
               { id: 'imageSize', title: '尺寸', value: '1K' },
             ],
@@ -1259,7 +1258,6 @@ describe('ImageCanvasGenerationDialogModel', () => {
       sourceLayerId: 'layer-sheet-result',
       style: 'none',
       characterSheetEnabled: true,
-      characterSheetViewSet: '8',
     });
   });
 
@@ -1484,6 +1482,136 @@ describe('ImageCanvasGenerationDialogModel', () => {
     });
   });
 
+  it('restores video AI motion and appearance from named reference slots', () => {
+    const motionLayer = createLayer({
+      id: 'layer-motion',
+      resourceId: 'resource-motion',
+      title: '奔跑动作',
+      mediaType: 'video',
+      assetKind: 'video',
+      src: '/media/motion.mp4',
+    });
+    const appearanceLayer = createLayer({
+      id: 'layer-appearance',
+      resourceId: 'resource-appearance',
+      title: '骑士外观',
+      assetKind: 'character',
+      src: '/images/appearance.png',
+    });
+    const draft = createSameSourceGenerationDialogDraft({
+      sourceLayer: createLayer({
+        id: 'layer-animation-result',
+        sourceType: 'generated',
+        assetKind: 'character-animation',
+        generationInputs: {
+          version: 2,
+          action: 'character-animation.generate',
+          fields: [
+            { id: 'inputMode', title: '输入模�', value: 'video' },
+            { id: 'prompt', title: '动作�述', value: '�刻奔跑节�' },
+            {
+              id: 'referenceSrc',
+              title: '�考素�',
+              value: 'users/user-1/motion.mp4',
+            },
+            {
+              id: 'referenceMediaType',
+              title: '�考类型',
+              value: 'video',
+            },
+            {
+              id: 'appearanceReferenceSrc',
+              title: '角色外观',
+              value: 'users/user-1/appearance.png',
+            },
+          ],
+          references: [
+            {
+              id: 'motion',
+              title: '动作视频',
+              refType: 'project-resource',
+              refId: 'resource-motion',
+            },
+            {
+              id: 'appearance',
+              title: '角色外观',
+              refType: 'project-resource',
+              refId: 'resource-appearance',
+            },
+          ],
+        },
+      }),
+      canvasSize: { width: 960, height: 720 },
+      viewport: { x: 0, y: 0, scale: 1 },
+      mode: 'redraw',
+      availableLayers: [motionLayer, appearanceLayer],
+    });
+
+    expect(draft).toMatchObject({
+      mode: 'character-animation',
+      characterAnimationWorkflow: 'ai',
+      generationReferences: [
+        expect.objectContaining({
+          resourceId: 'resource-motion',
+          mediaType: 'video',
+        }),
+      ],
+      characterAnimationAppearanceReferences: [
+        expect.objectContaining({
+          resourceId: 'resource-appearance',
+          label: '骑士外观',
+        }),
+      ],
+    });
+  });
+
+  it('restores video conversion results to the conversion workflow', () => {
+    const draft = createSameSourceGenerationDialogDraft({
+      sourceLayer: createLayer({
+        id: 'layer-converted-animation',
+        sourceType: 'generated',
+        assetKind: 'character-animation',
+        generationInputs: {
+          version: 2,
+          action: 'character-animation.convert',
+          fields: [
+            {
+              id: 'sourceVideoSrc',
+              title: '�视频',
+              value: 'users/user-1/source.mov',
+            },
+            { id: 'resolution', title: '最大长边', value: '720p' },
+          ],
+          references: [
+            {
+              id: 'source',
+              title: '�视频',
+              label: '�动作.mov',
+              refType: 'asset',
+              refId: 'asset-source-video',
+            },
+          ],
+        },
+      }),
+      canvasSize: { width: 960, height: 720 },
+      viewport: { x: 0, y: 0, scale: 1 },
+      mode: 'redraw',
+      availableLayers: [],
+    });
+
+    expect(draft).toMatchObject({
+      mode: 'character-animation',
+      characterAnimationWorkflow: 'video-conversion',
+      characterAnimationConversionResolution: '720p',
+      characterAnimationConversionVideoReference: {
+        label: '�动作.mov',
+        src: 'users/user-1/source.mov',
+        sourceAssetId: 'asset-source-video',
+        mediaType: 'video',
+      },
+    });
+  });
+
   it('does not restore a project resource id that is unavailable in the current canvas', () => {
     const draft = createSameSourceGenerationDialogDraft({
       sourceLayer: createLayer({
@@ -1875,6 +2003,40 @@ describe('ImageCanvasGenerationDialogModel', () => {
     });
   });
 
+  it('allows an ordinary canvas image as appearance after a video motion reference', () => {
+    const dialog: GenerateDialogState = {
+      mode: 'character-animation',
+      prompt: '原地奔跑',
+      status: 'idle',
+      characterAnimationWorkflow: 'ai',
+      generationReferences: [
+        {
+          id: 'motion',
+          label: '动作视频',
+          src: 'generated/motion.mp4',
+          mediaType: 'video',
+        },
+      ],
+    };
+    const ordinaryImage = createLayer({
+      id: 'asset-image',
+      title: '素�1',
+      src: 'generated/asset-1.png',
+    });
+
+    expect(appendGenerationReference(dialog, ordinaryImage)).toMatchObject({
+      generationReferences: [
+        expect.objectContaining({ label: '动作视频', mediaType: 'video' }),
+      ],
+      characterAnimationAppearanceReferences: [
+        {
+          label: '素�1',
+          src: 'generated/asset-1.png',
+        },
+      ],
+    });
+  });
+
   it('caps image references before a sixth reference can enter submission state', () => {
     const existingReferences = Array.from({ length: 5 }, (_, index) => ({
       id: `reference-${index}`,
diff --git a/src/components/image-editor/ImageCanvasGenerationDialogModel.ts b/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
index 51ef28256..51d484269 100644
--- a/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
@@ -116,6 +116,12 @@ function getReferenceMediaType(layer: CanvasLayer) {
     : 'image';
 }
 
+function hasCharacterAnimationVideoReference(layer: CanvasLayer) {
+  return Boolean(
+    layer.assetKind === 'character-animation' && layer.previewVideoPath?.trim(),
+  );
+}
+
 export function isIconSpecReferenceLayer(layer: CanvasLayer) {
   if (layer.assetKind === 'icon-spec') {
     return true;
@@ -317,7 +323,6 @@ export function createCharacterGenerationDialogDraft({
     characterSpecReference: null,
     characterReferences: [],
     characterSheetEnabled: false,
-    characterSheetViewSet: '4',
     imageModel: normalizedImageModel,
     aspectRatio: dimensionDefaults.aspectRatio,
     imageSize: dimensionDefaults.imageSize,
@@ -861,6 +866,14 @@ function getNormalizedString(
   return typeof value === 'string' ? value : fallback;
 }
 
+function getNormalizedStringArray(sourceLayer: CanvasLayer, id: string) {
+  return (sourceLayer.generationInputs?.fields ?? [])
+    .filter((field) => field.id === id)
+    .flatMap((field) =>
+      typeof field.value === 'string' ? [field.value] : [],
+    );
+}
+
 function getNormalizedNumber(
   sourceLayer: CanvasLayer,
   id: string,
@@ -1064,7 +1077,7 @@ function createNormalizedGenerationDialogDraft({
   }
 
   if (inputs.action === 'character-sheet.generate') {
-    // 多方�角色图回弹到角色��并��图集模�与视角数。
+    // 多方�角色图回弹到角色��并��图集模�（固定八方�）。
     return placeDraftBesideSourceLayer(
       resizeGenerationPlaceholderToImageSelection({
         ...createCharacterGenerationDialogDraft({
@@ -1082,10 +1095,6 @@ function createNormalizedGenerationDialogDraft({
         aspectRatio: getNormalizedString(sourceLayer, 'aspectRatio', '1:1'),
         imageSize: getNormalizedString(sourceLayer, 'imageSize', '1K'),
         characterSheetEnabled: true,
-        characterSheetViewSet:
-          getNormalizedString(sourceLayer, 'viewSet') === '八视图'
-            ? '8'
-            : '4',
         characterSpecReference:
           resolveNormalizedReferences(
             sourceLayer,
@@ -1302,12 +1311,19 @@ function createNormalizedGenerationDialogDraft({
   }
 
   if (inputs.action === 'character-animation.generate') {
-    const canvasReferences = resolveNormalizedReferences(
-      sourceLayer,
-      'source',
-      availableLayers,
-    );
     const inputMode = getNormalizedString(sourceLayer, 'inputMode', 'image');
+    const primaryReferenceSlot = inputMode === 'video' ? 'motion' : 'source';
+    const canvasReferences = [
+      ...resolveNormalizedReferences(
+        sourceLayer,
+        primaryReferenceSlot,
+        availableLayers,
+      ),
+      // 新槽�上线�视频 AI 也使用 source；仅在 motion 缺失时兼容旧�方。
+      ...(inputMode === 'video' && primaryReferenceSlot === 'motion'
+        ? resolveNormalizedReferences(sourceLayer, 'source', availableLayers)
+        : []),
+    ];
     const storedReferenceSrc = getNormalizedString(
       sourceLayer,
       'referenceSrc',
@@ -1318,7 +1334,9 @@ function createNormalizedGenerationDialogDraft({
       inputMode === 'video' ? 'video' : 'image',
     );
     const storedReferenceInput = sourceLayer.generationInputs?.references.find(
-      (reference) => reference.id === 'source',
+      (reference) =>
+        reference.id === primaryReferenceSlot ||
+        (inputMode === 'video' && reference.id === 'source'),
     );
     const storedReferenceWidth = getNormalizedNumber(
       sourceLayer,
@@ -1337,7 +1355,7 @@ function createNormalizedGenerationDialogDraft({
             id: `restored-character-animation-reference:${sourceLayer.id}`,
             label:
               storedReferenceInput?.label ??
-              (storedReferenceMediaType === 'video' ? '�考视频' : '角色图片'),
+              (storedReferenceMediaType === 'video' ? '动作视频' : '角色图片'),
             src: storedReferenceSrc,
             objectKey: storedReferenceSrc,
             ...(storedReferenceInput?.refType === 'asset'
@@ -1355,6 +1373,33 @@ function createNormalizedGenerationDialogDraft({
                 : ('image' as const),
           }
         : undefined);
+    const appearanceCanvasReferences = resolveNormalizedReferences(
+      sourceLayer,
+      'appearance',
+      availableLayers,
+    );
+    const storedAppearanceSrcs = getNormalizedStringArray(
+      sourceLayer,
+      'appearanceReferenceSrc',
+    )
+      .map((src) => src.trim())
+      .filter((src) => src.length > 0);
+    const storedAppearanceInput = sourceLayer.generationInputs?.references.find(
+      (reference) => reference.id === 'appearance',
+    );
+    const restoredAppearanceReferences =
+      appearanceCanvasReferences.length > 0
+        ? appearanceCanvasReferences
+        : storedAppearanceSrcs.map((storedAppearanceSrc, index) => ({
+            id: `restored-character-animation-appearance:${sourceLayer.id}:${index}`,
+            label: storedAppearanceInput?.label ?? '�考图',
+            src: storedAppearanceSrc,
+            objectKey: storedAppearanceSrc,
+            mediaType: 'image' as const,
+            ...(storedAppearanceInput?.refType === 'asset'
+              ? { sourceAssetId: storedAppearanceInput.refId }
+              : {}),
+          }));
     const animationSource = restoredReference
       ? (availableLayers ?? []).find(
           (layer) =>
@@ -1373,7 +1418,11 @@ function createNormalizedGenerationDialogDraft({
     });
     // 帧数/时长必须匹��法�对（32/4�40/5�48/6），�则 UI 会�时高亮
     // 冲�的选项而�交被�端拒�。这里按�法�对校验，��数�回退到默认 32/4。
-    const restoredFrameCount = getNormalizedNumber(sourceLayer, 'frameCount', 32);
+    const restoredFrameCount = getNormalizedNumber(
+      sourceLayer,
+      'frameCount',
+      32,
+    );
     const restoredDurationSeconds = getNormalizedNumber(
       sourceLayer,
       'durationSeconds',
@@ -1395,6 +1444,10 @@ function createNormalizedGenerationDialogDraft({
             prompt,
             sourceLayerId: animationSource?.id,
             generationReferences: restoredReference ? [restoredReference] : [],
+            characterAnimationAppearanceReferences:
+              restoredAppearanceReferences.length
+                ? restoredAppearanceReferences
+                : undefined,
             characterAnimationBackgroundColor: (getNormalizedString(
               sourceLayer,
               'backgroundColor',
@@ -1410,14 +1463,68 @@ function createNormalizedGenerationDialogDraft({
               'ratio',
               animationSource ? 'same' : '1:1',
             ) as GenerateDialogState['characterAnimationRatio'],
-            characterAnimationFrameCount: pairedFrameCount as GenerateDialogState['characterAnimationFrameCount'],
-            characterAnimationDurationSeconds: pairedDurationSeconds as GenerateDialogState['characterAnimationDurationSeconds'],
+            characterAnimationFrameCount:
+              pairedFrameCount as GenerateDialogState['characterAnimationFrameCount'],
+            characterAnimationDurationSeconds:
+              pairedDurationSeconds as GenerateDialogState['characterAnimationDurationSeconds'],
           }),
           sourceLayer,
         )
       : null;
   }
 
+  if (inputs.action === 'character-animation.convert') {
+    const sourceReferences = resolveNormalizedReferences(
+      sourceLayer,
+      'source',
+      availableLayers,
+    );
+    const storedSource = getNormalizedString(
+      sourceLayer,
+      'sourceVideoSrc',
+    ).trim();
+    const storedReferenceInput = sourceLayer.generationInputs?.references.find(
+      (reference) => reference.id === 'source',
+    );
+    const restoredSource =
+      sourceReferences[0] ??
+      (storedSource
+        ? {
+            id: `restored-character-animation-conversion:${sourceLayer.id}`,
+            label: storedReferenceInput?.label ?? '�视频',
+            src: storedSource,
+            objectKey: storedSource,
+            mediaType: 'video' as const,
+            ...(storedReferenceInput?.refType === 'asset'
+              ? { sourceAssetId: storedReferenceInput.refId }
+              : {}),
+          }
+        : undefined);
+    if (!restoredSource) {
+      return null;
+    }
+    const draft = createCharacterAnimationGenerationDialogDraft({
+      canvasSize,
+      viewport,
+    });
+    return draft
+      ? placeDraftBesideSourceLayer(
+          {
+            ...draft,
+            sourceLayerId: undefined,
+            characterAnimationWorkflow: 'video-conversion',
+            characterAnimationConversionVideoReference: restoredSource,
+            characterAnimationConversionResolution: getNormalizedString(
+              sourceLayer,
+              'resolution',
+              '480p',
+            ) as GenerateDialogState['characterAnimationConversionResolution'],
+          },
+          sourceLayer,
+        )
+      : null;
+  }
+
   return null;
 }
 
@@ -2136,24 +2243,52 @@ export function createCharacterAnimationGenerationDialogDraft({
   canvasSize,
   viewport,
   layer,
+  workflow = 'ai',
 }: {
   canvasSize: CanvasSize;
   viewport: CanvasViewport;
   layer?: CanvasLayer;
+  workflow?: 'ai' | 'video-conversion';
 }): Omit<CanvasGenerationDialogState, 'id'> | null {
-  if (layer && layer.assetKind !== 'character') {
+  if (
+    layer &&
+    (workflow === 'video-conversion'
+      ? layer.mediaType !== 'video' &&
+        !(
+          layer.assetKind === 'character-animation' &&
+          Boolean(layer.previewVideoPath?.trim())
+        )
+      : layer.assetKind !== 'character')
+  ) {
     return null;
   }
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
   const draft: Omit<CanvasGenerationDialogState, 'id'> = {
     mode: 'character-animation',
     ...(layer ? { sourceLayerId: layer.id } : {}),
-    generationReferences: layer ? [createCanvasLayerReference(layer)] : [],
+    generationReferences:
+      layer && workflow === 'ai'
+        ? [
+            createCanvasLayerReference(layer, {
+              preferSequenceVideo: true,
+            }),
+          ]
+        : [],
+    ...(layer && workflow === 'video-conversion'
+      ? {
+          characterAnimationConversionVideoReference:
+            createCanvasLayerReference(layer, {
+              preferSequenceVideo: true,
+            }),
+        }
+      : {}),
     prompt: '',
     status: 'idle',
     composerOpen: true,
     characterAnimationResolution: '480p',
-    characterAnimationRatio: layer ? 'same' : '1:1',
+    characterAnimationWorkflow: workflow,
+    characterAnimationConversionResolution: '480p',
+    characterAnimationRatio: layer && workflow === 'ai' ? 'same' : '1:1',
     ...(layer ? {} : { characterAnimationBackgroundColor: 'green' as const }),
     characterAnimationFrameCount: 32,
     characterAnimationDurationSeconds: 4,
@@ -2220,18 +2355,42 @@ export function appendGenerationReference(
   }
   if (dialog?.mode === 'character-animation') {
     const mediaType = getReferenceMediaType(layer);
-    if (
-      mediaType === 'audio' ||
-      (mediaType === 'image' &&
-        layer.assetKind !== 'character' &&
-        layer.assetKind !== 'character-animation')
-    ) {
+    if (dialog.characterAnimationWorkflow === 'video-conversion') {
+      return mediaType === 'video' || hasCharacterAnimationVideoReference(layer)
+        ? {
+            ...resetFailedGenerationDialog(dialog),
+            sourceLayerId: layer.id,
+            characterAnimationConversionVideoReference:
+              createCanvasLayerReference(layer, {
+                preferSequenceVideo: true,
+              }),
+            composerOpen: true,
+          }
+        : dialog;
+    }
+    const hasVideoMotionReference =
+      dialog.generationReferences?.[0]?.mediaType === 'video';
+    if (mediaType === 'audio') {
       return dialog;
     }
     return resizeGenerationPlaceholderToCharacterAnimationSelection({
       ...resetFailedGenerationDialog(dialog),
-      sourceLayerId: layer.id,
-      generationReferences: [createCanvasLayerReference(layer)],
+      ...(mediaType === 'image' &&
+      dialog.generationReferences?.[0]?.mediaType === 'video'
+        ? {
+            characterAnimationAppearanceReferences: [
+              ...(dialog.characterAnimationAppearanceReferences ?? []),
+              createCanvasLayerReference(layer),
+            ],
+          }
+        : {
+            sourceLayerId: layer.id,
+            generationReferences: [
+              createCanvasLayerReference(layer, {
+                preferSequenceVideo: true,
+              }),
+            ],
+          }),
       composerOpen: true,
     });
   }
diff --git a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
index 800eef79a..48459717c 100644
--- a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
@@ -44,6 +44,7 @@ type ImageCanvasGenerationImageOptionsViewProps = {
   onSubmitRequest: () => void;
   lockedModel?: string;
   styleControl?: ReactNode;
+  extraToggles?: ReactNode;
   renderEditorPortal?: (node: ReactNode) => ReactNode;
   buildPortalMenuStyle?: (
     anchor: HTMLElement | null,
@@ -138,6 +139,7 @@ export function ImageCanvasGenerationImageOptionsView({
   onSubmitRequest,
   lockedModel,
   styleControl,
+  extraToggles,
   renderEditorPortal = (node) => node,
   buildPortalMenuStyle = () => ({}),
 }: ImageCanvasGenerationImageOptionsViewProps) {
@@ -331,20 +333,25 @@ export function ImageCanvasGenerationImageOptionsView({
         </div>
       ) : null}
       {styleControl ??
-        (supportsImageStyle ? (
-          <label className="image-canvas-editor__image-style-toggle">
-            <input
-              type="checkbox"
-              checked={dialog.style === 'pixelArt'}
-              disabled={isGenerating}
-              onChange={(event) =>
-                updateDialog({
-                  style: event.target.checked ? 'pixelArt' : 'none',
-                })
-              }
-            />
-            <span>�素艺术</span>
-          </label>
+        (supportsImageStyle || extraToggles ? (
+          <div className="image-canvas-editor__generation-toggles">
+            {supportsImageStyle ? (
+              <label className="image-canvas-editor__image-style-toggle">
+                <input
+                  type="checkbox"
+                  checked={dialog.style === 'pixelArt'}
+                  disabled={isGenerating}
+                  onChange={(event) =>
+                    updateDialog({
+                      style: event.target.checked ? 'pixelArt' : 'none',
+                    })
+                  }
+                />
+                <span>�素艺术</span>
+              </label>
+            ) : null}
+            {extraToggles}
+          </div>
         ) : null)}
       {includeModel ? (
         <div
diff --git a/src/components/image-editor/ImageCanvasGenerationInputsModel.ts b/src/components/image-editor/ImageCanvasGenerationInputsModel.ts
index f992ef982..e702dd991 100644
--- a/src/components/image-editor/ImageCanvasGenerationInputsModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationInputsModel.ts
@@ -25,6 +25,7 @@ export const CANVAS_GENERATION_ACTIONS = [
   'audio.sound-effect.generate',
   'audio.background-music.generate',
   'character-animation.generate',
+  'character-animation.convert',
   'image.edit',
   'ui-design.extract-assets',
   'image.perfect-pixel',
@@ -46,6 +47,7 @@ const REMIXABLE_CANVAS_GENERATION_ACTIONS = new Set<CanvasGenerationAction>([
   'audio.sound-effect.generate',
   'audio.background-music.generate',
   'character-animation.generate',
+  'character-animation.convert',
   'ui-design.extract-assets',
 ]);
 
diff --git a/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts b/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
index 9d5e8a4ef..39eba3382 100644
--- a/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
@@ -558,6 +558,7 @@ describe('ImageCanvasGenerationLayerModel', () => {
     ];
     const layer = createCharacterAnimationResultLayer({
       generated: {
+        resultType: 'ai',
         taskId: 'character-animation-task-1',
         model: 'seedance2.0-fast',
         prompt: '待机动作',
@@ -605,7 +606,7 @@ describe('ImageCanvasGenerationLayerModel', () => {
       mediaType: 'image-sequence',
       thumbnailSrc: '/generated-character-drafts/editor/frame1.png',
       imageSequenceFrames: frames,
-      previewVideoPath: null,
+      previewVideoPath: '/generated-character-drafts/editor/preview.mp4',
       x: -222,
       y: -242,
       width: 1024,
@@ -625,6 +626,61 @@ describe('ImageCanvasGenerationLayerModel', () => {
     expect(layer?.provider).toBeUndefined();
   });
 
+  it('creates direct video conversion layers without fake prompt or model metadata', () => {
+    const frames = [
+      { imageSrc: '/converted/frame-1.png', width: 640, height: 360 },
+      { imageSrc: '/converted/frame-2.png', width: 640, height: 360 },
+    ];
+    const layer = createCharacterAnimationResultLayer({
+      generated: {
+        resultType: 'video-conversion',
+        taskId: 'conversion-task-1',
+        processingMethod: '视频直接转�',
+        frames,
+        frameCount: 2,
+        durationMs: 2_500,
+        frameWidth: 640,
+        frameHeight: 360,
+        sourceFps: 29.97,
+        samplingFps: 0.8,
+        priceMudPoints: 0,
+        resource: {
+          resourceId: 'resource-converted-animation',
+          projectId: 'project-1',
+          imageSrc: frames[0]!.imageSrc,
+          width: 640,
+          height: 360,
+          sourceType: 'generated',
+          assetKind: 'character-animation',
+          imageSequenceFrames: frames,
+          imageSequenceDurationMs: 2_500,
+        },
+      },
+      generatedIndex: 18,
+      title: '视频转��列帧',
+      canvasSize: { width: 900, height: 640 },
+      viewport: { x: 0, y: 0, scale: 1 },
+      generationInputs: {
+        version: 2,
+        action: 'character-animation.convert',
+        fields: [],
+        references: [],
+      },
+    });
+
+    expect(layer).toMatchObject({
+      mediaType: 'image-sequence',
+      assetKind: 'character-animation',
+      taskId: 'conversion-task-1',
+      provider: 'FFmpeg',
+      imageSequenceDurationMs: 2_500,
+    });
+    expect(layer?.prompt).toBeUndefined();
+    expect(layer?.actualPrompt).toBeUndefined();
+    expect(layer?.model).toBeUndefined();
+    expect(layer?.previewVideoPath).toBeNull();
+  });
+
   it('links a character animation result layer to its persisted project resource', () => {
     const frames = [
       {
@@ -644,6 +700,7 @@ describe('ImageCanvasGenerationLayerModel', () => {
     ];
     const layer = createCharacterAnimationResultLayer({
       generated: {
+        resultType: 'ai',
         taskId: 'character-animation-task-persisted',
         model: 'seedance2.0-fast',
         prompt: '奔跑动作',
@@ -704,6 +761,7 @@ describe('ImageCanvasGenerationLayerModel', () => {
     ];
     const layer = createCharacterAnimationResultLayer({
       generated: {
+        resultType: 'ai',
         taskId: 'character-animation-task-asset-only',
         model: 'seedance2.0-fast',
         prompt: '跳跃动作',
diff --git a/src/components/image-editor/ImageCanvasGenerationLayerModel.ts b/src/components/image-editor/ImageCanvasGenerationLayerModel.ts
index 5dc1e1a31..9302447e5 100644
--- a/src/components/image-editor/ImageCanvasGenerationLayerModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationLayerModel.ts
@@ -1,6 +1,6 @@
 import type {
   EditorAudioGenerationResult,
-  EditorCharacterAnimationGenerationResult,
+  EditorCharacterAnimationResult,
   EditorIconSpritesheetGenerationResult,
   EditorIconSpritesheetIconResult,
   EditorImageGenerationResult,
@@ -66,7 +66,7 @@ type AudioResultLayerOptions = {
 };
 
 type CharacterAnimationResultLayerOptions = {
-  generated: EditorCharacterAnimationGenerationResult;
+  generated: EditorCharacterAnimationResult;
   generatedIndex: number;
   title: string;
   canvasSize: CanvasSize;
@@ -497,7 +497,16 @@ export function createCharacterAnimationResultLayer({
     mediaType: 'image-sequence',
     thumbnailSrc: previewFrame.imageSrc,
     imageSequenceFrames,
-    previewVideoPath: null,
+    previewVideoPath:
+      generated.resultType === 'ai'
+        ? generated.previewVideoPath
+        : sourceLayer?.mediaType === 'video'
+          ? sourceLayer.objectKey?.trim() ||
+            sourceLayer.previewVideoPath ||
+            sourceLayer.src
+          : sourceLayer?.assetKind === 'character-animation'
+            ? (sourceLayer.previewVideoPath ?? null)
+            : null,
     x: frameX ?? worldCenter.x - width / 2,
     y: frameY ?? worldCenter.y - height / 2,
     width,
@@ -506,9 +515,11 @@ export function createCharacterAnimationResultLayer({
     originalHeight,
     zIndex: generatedIndex + 10,
     sourceType: 'generated',
-    prompt: generated.prompt,
-    actualPrompt: generated.prompt,
-    model: generated.model,
+    prompt: generated.resultType === 'ai' ? generated.prompt : undefined,
+    actualPrompt: generated.resultType === 'ai' ? generated.prompt : undefined,
+    model: generated.resultType === 'ai' ? generated.model : undefined,
+    provider:
+      generated.resultType === 'video-conversion' ? 'FFmpeg' : undefined,
     taskId: generated.taskId,
     assetKind: 'character-animation',
     imageSequenceDurationMs,
diff --git a/src/components/image-editor/ImageCanvasGenerationModel.test.ts b/src/components/image-editor/ImageCanvasGenerationModel.test.ts
index a7e77c300..f7219d1e9 100644
--- a/src/components/image-editor/ImageCanvasGenerationModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationModel.test.ts
@@ -31,6 +31,7 @@ import {
   calculateEditorUiDesignPrice,
   calculateEditorVideoPrice,
   canOpenRedrawPanel,
+  createCanvasLayerReference,
   CANVAS_GENERATION_PARAMETER_FALLBACK_WARNING,
   CHARACTER_ANIMATION_MODEL,
   decodeCanvasGenerationInputs,
@@ -64,6 +65,37 @@ import {
 } from './ImageCanvasGenerationModel';
 
 describe('ImageCanvasGenerationModel', () => {
+  it('uses a character animation preview video when a video reference is requested', () => {
+    const reference = createCanvasLayerReference(
+      {
+        id: 'layer-sequence',
+        resourceId: 'resource-sequence',
+        sourceResourceId: 'resource-motion-video',
+        title: '�列帧动作',
+        src: '/frames/frame-001.png',
+        previewVideoPath: '/motion/preview.mp4',
+        mediaType: 'image-sequence',
+        assetKind: 'character-animation',
+        x: 0,
+        y: 0,
+        width: 480,
+        height: 480,
+        originalWidth: 480,
+        originalHeight: 480,
+        zIndex: 1,
+        sourceType: 'generated',
+      },
+      { preferSequenceVideo: true },
+    );
+
+    expect(reference).toMatchObject({
+      mediaType: 'video',
+      src: '/motion/preview.mp4',
+      objectKey: '/motion/preview.mp4',
+      resourceId: 'resource-motion-video',
+    });
+  });
+
   it('resolves character animation pixel and display sizes from ratio and resolution', () => {
     expect(
       resolveEditorCharacterAnimationFramePixelSize({
@@ -117,6 +149,59 @@ describe('ImageCanvasGenerationModel', () => {
     ).toBeUndefined();
   });
 
+  it('persists motion and appearance slots for video-guided character animation', () => {
+    const inputs = buildCharacterAnimationGenerationInputs(
+      '�刻动作并替�外观',
+      null,
+      {
+        id: 'motion-video',
+        label: '奔跑动作.mov',
+        src: 'users/user-1/motion.mov',
+        mediaType: 'video',
+        resourceId: 'resource-motion',
+        width: 1920,
+        height: 1080,
+      },
+      {
+        referenceSrc: 'users/user-1/motion.mov',
+        referenceMediaType: 'video',
+        appearanceReferences: [
+          {
+            id: 'appearance-image',
+            label: '骑士外观.png',
+            src: 'users/user-1/appearance.png',
+            mediaType: 'image',
+            sourceAssetId: 'asset-appearance',
+          },
+        ],
+        appearanceReferenceSrcs: ['users/user-1/appearance.png'],
+      },
+    );
+
+    expect(inputs.references).toEqual([
+      expect.objectContaining({
+        id: 'motion',
+        refType: 'project-resource',
+        refId: 'resource-motion',
+      }),
+      expect.objectContaining({
+        id: 'appearance',
+        refType: 'asset',
+        refId: 'asset-appearance',
+      }),
+    ]);
+    expect(inputs.fields).toEqual(
+      expect.arrayContaining([
+        { id: 'inputMode', title: '输入模�', value: 'video' },
+        {
+          id: 'appearanceReferenceSrc',
+          title: '�考图',
+          value: 'users/user-1/appearance.png',
+        },
+      ]),
+    );
+  });
+
   afterEach(() => {
     applyEditorGenerationPricingConfig({
       models: EDITOR_MODEL_MUD_POINT_CONFIG,
diff --git a/src/components/image-editor/ImageCanvasGenerationModel.ts b/src/components/image-editor/ImageCanvasGenerationModel.ts
index 0edba945b..381b84022 100644
--- a/src/components/image-editor/ImageCanvasGenerationModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationModel.ts
@@ -913,6 +913,8 @@ export function buildCharacterAnimationGenerationInputs(
     backgroundColor?: string;
     referenceSrc?: string;
     referenceMediaType?: 'image' | 'video';
+    appearanceReferences?: CharacterReferenceImage[];
+    appearanceReferenceSrcs?: string[];
   } = {},
 ): CanvasGenerationInputs {
   const inputMode =
@@ -967,6 +969,15 @@ export function buildCharacterAnimationGenerationInputs(
             'referenceHeight',
           )
         : []),
+      ...(options.appearanceReferenceSrcs?.length
+        ? options.appearanceReferenceSrcs.flatMap((src) =>
+            createGenerationInputField(
+              '�考图',
+              src,
+              'appearanceReferenceSrc',
+            ),
+          )
+        : []),
       ...createGenerationInputField('动作�述', promptText, 'prompt'),
       ...(options.backgroundColor
         ? createGenerationInputField(
@@ -992,19 +1003,28 @@ export function buildCharacterAnimationGenerationInputs(
         'durationSeconds',
       ),
     ],
-    references: sourceLayer
-      ? createLayerGenerationInputReference(
-          reference?.mediaType === 'video' ? '�考视频' : '角色图片',
-          sourceLayer,
-          { id: 'source' },
-        )
-      : reference
+    references: [
+      ...(reference
         ? createGenerationInputReference(
-            reference.mediaType === 'video' ? '�考视频' : '角色图片',
+            reference.mediaType === 'video' ? '�考视频' : '�考图片',
             reference,
-            { id: 'source' },
+            { id: reference.mediaType === 'video' ? 'motion' : 'source' },
           )
-        : [],
+        : sourceLayer
+          ? createLayerGenerationInputReference('角色图片', sourceLayer, {
+              id: 'source',
+            })
+          : []),
+      ...(options.appearanceReferences?.length
+        ? options.appearanceReferences.flatMap((appearanceReference) =>
+            createGenerationInputReference(
+              '�考图',
+              appearanceReference,
+              { id: 'appearance' },
+            ),
+          )
+        : []),
+    ],
   };
 }
 
@@ -1264,19 +1284,33 @@ export function resolveCharacterAnimationSourceImageSrc(layer: CanvasLayer) {
 
 export function createCanvasLayerReference(
   layer: CanvasLayer,
+  options: { preferSequenceVideo?: boolean } = {},
 ): CharacterReferenceImage {
-  const mediaType =
-    layer.mediaType === 'video' || layer.mediaType === 'audio'
-      ? layer.mediaType
+  // 正��列帧资�的 PNG 是最终交付物；在动作视频/直接转�槽�中，若��留底层视频，
+  // 则沿用视频引用。未指定时��旧的整张�列帧图片语义。
+  const sequenceVideoSrc =
+    options.preferSequenceVideo && layer.assetKind === 'character-animation'
+      ? layer.previewVideoPath?.trim()
       : undefined;
+  const isVideoReference =
+    Boolean(sequenceVideoSrc) || layer.mediaType === 'video';
+  const mediaType = isVideoReference
+    ? 'video'
+    : layer.mediaType === 'audio'
+      ? 'audio'
+      : undefined;
+  const src = sequenceVideoSrc || layer.objectKey?.trim() || layer.src;
   return {
     id: `canvas-${layer.id}`,
     label: layer.title,
-    src: layer.objectKey?.trim() || layer.src,
+    src,
     ...(mediaType ? { mediaType } : {}),
-    objectKey: layer.objectKey ?? undefined,
+    assetKind: layer.assetKind ?? null,
+    objectKey: sequenceVideoSrc || (layer.objectKey ?? undefined),
     assetObjectId: layer.assetObjectId ?? undefined,
-    resourceId: layer.resourceId,
+    resourceId: sequenceVideoSrc
+      ? (layer.sourceResourceId ?? layer.resourceId)
+      : layer.resourceId,
     sourceAssetId: layer.sourceAssetId ?? undefined,
     width: layer.originalWidth,
     height: layer.originalHeight,
@@ -1340,7 +1374,8 @@ export function buildDeterministicGenerationInputs(
     | 'image.perfect-pixel'
     | 'spritesheet.split'
     | 'image.remove-background'
-    | 'image.crop-expand',
+    | 'image.crop-expand'
+    | 'character-animation.remove-background',
   sourceLayer: CanvasLayer,
   sourceTitle = '原图',
 ): CanvasGenerationInputs {
@@ -2182,7 +2217,6 @@ export function buildCharacterSheetGenerationInputs(
     model?: string;
     aspectRatio?: string;
     imageSize?: string;
-    viewSet?: '4' | '8';
   } = {},
 ): CanvasGenerationInputs {
   return {
@@ -2195,11 +2229,6 @@ export function buildCharacterSheetGenerationInputs(
         options.model ?? DEFAULT_IMAGE_MODEL,
         'model',
       ),
-      ...createGenerationInputField(
-        '视角集�',
-        options.viewSet === '8' ? '八视图' : '四视图',
-        'viewSet',
-      ),
       ...createGenerationInputField(
         '比例',
         options.aspectRatio ?? '1:1',
diff --git a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
index bcd432090..53cbcb1ec 100644
--- a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
@@ -680,12 +680,12 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         action: 'character-sheet.generate',
         fields: expect.arrayContaining([
           { id: 'prompt', title: '角色设定', value: '日系魔法少女' },
-          { id: 'viewSet', title: '视角集�', value: '四视图' },
         ]),
       }),
     );
     expect(plan.kind === 'image' ? plan.input : null).toMatchObject({
-      characterSheetViews: 4,
+      kind: 'character-sheet',
+      assetKind: 'icon-spritesheet',
     });
     // 图集���素化��去背景，screenColor/segModel ��带。
     expect(plan.kind === 'image' ? plan.input : null).not.toHaveProperty(
@@ -696,33 +696,6 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
     );
   });
 
-  it('builds eight-direction character-sheet plans when view set is eight', () => {
-    const plan = buildImageGenerationSubmissionPlan({
-      dialog: {
-        mode: 'character',
-        prompt: '日系魔法少女',
-        status: 'idle',
-        characterSheetEnabled: true,
-        characterSheetViewSet: '8',
-      },
-      layers: [],
-      nextGeneratedIndex: 4,
-    });
-
-    expect(plan.kind === 'image' ? plan.input : null).toMatchObject({
-      kind: 'character-sheet',
-      characterSheetViews: 8,
-    });
-    expect(plan.kind === 'image' ? plan.result.generationInputs : null).toEqual(
-      expect.objectContaining({
-        action: 'character-sheet.generate',
-        fields: expect.arrayContaining([
-          { id: 'viewSet', title: '视角集�', value: '八视图' },
-        ]),
-      }),
-    );
-  });
-
   it('locks UI design generation submissions to gpt-image-2', () => {
     const plan = buildImageGenerationSubmissionPlan({
       dialog: {
diff --git a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
index a825ef917..73a8f3be7 100644
--- a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
@@ -802,8 +802,7 @@ export function buildImageGenerationSubmissionPlan({
     const screenColor = DEFAULT_EDITOR_GENERATION_BACKGROUND_COLOR;
     const segModel = DEFAULT_EDITOR_BGFILTER_SEG_MODEL;
     const sheetEnabled = dialog.characterSheetEnabled === true;
-    const sheetViewSet = dialog.characterSheetViewSet ?? '4';
-    // 中文注释：多方�角色图走�端 kind=character-sheet（绿色间隔底，便于连通�拆分），
+    // 中文注释：多方�角色图走�端 kind=character-sheet（绿色间隔底，便于�续拆分），
     // 产物按 icon-spritesheet �库，�用既有「拆分图集�能力；���素化��去背景。
     return {
       kind: 'image',
@@ -823,7 +822,6 @@ export function buildImageGenerationSubmissionPlan({
         ...(sheetEnabled
           ? {
               assetKind: 'icon-spritesheet',
-              characterSheetViews: sheetViewSet === '8' ? 8 : 4,
             }
           : {}),
         ...(referenceImageSrcs.length ? { referenceImageSrcs } : {}),
@@ -845,7 +843,6 @@ export function buildImageGenerationSubmissionPlan({
                 model: imageModel,
                 aspectRatio: dialog.aspectRatio ?? '1:1',
                 imageSize: dialog.imageSize ?? '1K',
-                viewSet: sheetViewSet,
               },
             )
           : buildCharacterGenerationInputs(
@@ -1183,8 +1180,8 @@ export function buildCharacterAnimationSubmissionPlan({
 }): CharacterAnimationSubmissionPlan {
   const promptText = panel.promptText.trim();
   const resultTitle = resolveGenerationAssetLabel(panel.assetLabel, '角色动作');
-  if (!promptText) {
-    throw new Error('动画�述�能为空。');
+  if (!promptText && !reference && !sourceLayer) {
+    throw new Error('动画�述和�考素��能�时为空。');
   }
   const inputMode =
     reference?.mediaType === 'video'
diff --git a/src/components/image-editor/ImageCanvasReferenceSlot.tsx b/src/components/image-editor/ImageCanvasReferenceSlot.tsx
index 849f48311..f0304f6e2 100644
--- a/src/components/image-editor/ImageCanvasReferenceSlot.tsx
+++ b/src/components/image-editor/ImageCanvasReferenceSlot.tsx
@@ -11,8 +11,7 @@ type ImageCanvasReferenceSlotTone =
   | 'character'
   | 'quick-edit'
   | 'video'
-  | 'audio'
-  | 'character-sheet';
+  | 'audio';
 
 type ImageCanvasReferenceSlotProps = {
   buttonRef?: RefObject<HTMLButtonElement | null>;
@@ -26,8 +25,6 @@ type ImageCanvasReferenceSlotProps = {
   objectKey?: string | null;
   disabled?: boolean;
   isAdd?: boolean;
-  /** 选中�（用于模�开关类入�）：置�时高亮边框并带 aria-pressed。 */
-  pressed?: boolean;
   onClick?: () => void;
   onRemove?: () => void;
   removeLabel?: string;
@@ -45,7 +42,6 @@ export function ImageCanvasReferenceSlot({
   objectKey,
   disabled = false,
   isAdd = false,
-  pressed,
   onClick,
   onRemove,
   removeLabel,
@@ -58,11 +54,11 @@ export function ImageCanvasReferenceSlot({
       ? 'image-canvas-editor__reference-chip--has-image'
       : 'image-canvas-editor__reference-chip--icon-only',
     isAdd ? 'image-canvas-editor__reference-chip--upload' : null,
-    pressed ? 'image-canvas-editor__reference-chip--active' : null,
     className,
   ]
     .filter(Boolean)
-    .join(' ');  const slotContent = (
+    .join(' ');
+  const slotContent = (
     <>
       <span className="image-canvas-editor__reference-chip-icon">
         {hasPreviewImage ? (
@@ -93,7 +89,6 @@ export function ImageCanvasReferenceSlot({
           className={slotClassName}
           disabled={disabled}
           aria-label={ariaLabel}
-          aria-pressed={pressed === undefined ? undefined : pressed}
           title={title ?? ariaLabel}
           onClick={onClick}
         >
diff --git a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
index 35f08ecec..5cd3caa5c 100644
--- a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
+++ b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
@@ -54,11 +54,12 @@ function renderSelectedToolbar(
     isPerfectPixelPendingConfirmation: false,
     isSplittingIconSpritesheet: false,
     isSplittingCharacterAnimation: false,
+    isRemovingCharacterAnimationBackground: false,
     isPersistingAssetKind: false,
     onSplitIconSpritesheet: vi.fn(),
     onSplitCharacterAnimation: vi.fn(),
+    onRemoveCharacterAnimationBackground: vi.fn(),
     onExtractUiDesignAssets: vi.fn(),
-    onOpenCharacterAnimationPanel: vi.fn(),
     onDownloadLayer: vi.fn(),
     ...overrides,
   };
@@ -478,8 +479,10 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
       within(actionToolbar)
         .getAllByRole('button')
         .map((button) => button.getAttribute('aria-label')),
-    ).toEqual(['拆帧', '改造', '下载按钮']);
-    fireEvent.click(within(actionToolbar).getByRole('button', { name: '拆帧' }));
+    ).toEqual(['改造', '去背景', '拆帧', '下载按钮']);
+    fireEvent.click(
+      within(actionToolbar).getByRole('button', { name: '拆帧' }),
+    );
     expect(props.onSplitCharacterAnimation).toHaveBeenCalledWith(
       expect.objectContaining({ assetKind: 'character-animation' }),
     );
@@ -557,28 +560,6 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
     expect(uiProps.onOpenRedrawPanel).toHaveBeenCalledWith(uiDesignLayer);
   });
 
-  it('renders character animation only for character layers', () => {
-    const layer = createLayer({
-      sourceType: 'generated',
-      assetKind: 'character',
-    });
-    const props = renderSelectedToolbar({ selectedLayer: layer });
-    const animationButton = screen.getByRole('button', { name: '生�动画' });
-
-    expect(animationButton.textContent).toContain('生�动画');
-    expect(
-      animationButton.querySelector('.lucide-person-standing'),
-    ).toBeTruthy();
-
-    fireEvent.click(animationButton);
-
-    expect(props.onOpenCharacterAnimationPanel).toHaveBeenCalledWith(layer);
-
-    cleanup();
-    renderSelectedToolbar({ selectedLayer: createLayer({ id: 'layer-2' }) });
-    expect(screen.queryByRole('button', { name: '生�动画' })).toBeNull();
-  });
-
   it('hides quick edit only for individual icon assets', () => {
     renderSelectedToolbar({
       selectedLayer: createLayer({ assetKind: 'icon' }),
@@ -618,11 +599,12 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
         isPerfectPixelPendingConfirmation={false}
         isSplittingIconSpritesheet={false}
         isSplittingCharacterAnimation={false}
+        isRemovingCharacterAnimationBackground={false}
         isPersistingAssetKind={false}
         onSplitIconSpritesheet={vi.fn()}
         onSplitCharacterAnimation={vi.fn()}
+        onRemoveCharacterAnimationBackground={vi.fn()}
         onExtractUiDesignAssets={vi.fn()}
-        onOpenCharacterAnimationPanel={vi.fn()}
         onDownloadLayer={vi.fn()}
       />,
     );
@@ -642,11 +624,12 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
         isPerfectPixelPendingConfirmation={false}
         isSplittingIconSpritesheet={false}
         isSplittingCharacterAnimation={false}
+        isRemovingCharacterAnimationBackground={false}
         isPersistingAssetKind={false}
         onSplitIconSpritesheet={vi.fn()}
         onSplitCharacterAnimation={vi.fn()}
+        onRemoveCharacterAnimationBackground={vi.fn()}
         onExtractUiDesignAssets={vi.fn()}
-        onOpenCharacterAnimationPanel={vi.fn()}
         onDownloadLayer={vi.fn()}
       />,
     );
diff --git a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
index 63bde75c4..352731275 100644
--- a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
+++ b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
@@ -4,7 +4,6 @@ import {
   Grid2X2,
   ImageOff,
   Loader2,
-  PersonStanding,
   Scissors,
   Sparkles,
   WandSparkles,
@@ -32,11 +31,12 @@ type ImageCanvasSelectedLayerToolbarViewProps = {
   isPerfectPixelPendingConfirmation: boolean;
   isSplittingIconSpritesheet: boolean;
   isSplittingCharacterAnimation: boolean;
+  isRemovingCharacterAnimationBackground: boolean;
   isPersistingAssetKind: boolean;
   onSplitIconSpritesheet: (layer: CanvasLayer) => void;
   onSplitCharacterAnimation: (layer: CanvasLayer) => void;
+  onRemoveCharacterAnimationBackground: (layer: CanvasLayer) => void;
   onExtractUiDesignAssets: (layer: CanvasLayer) => void;
-  onOpenCharacterAnimationPanel: (layer: CanvasLayer) => void;
   onDownloadLayer: (layer: CanvasLayer) => void;
 };
 
@@ -52,11 +52,12 @@ export function ImageCanvasSelectedLayerToolbarView({
   isPerfectPixelPendingConfirmation,
   isSplittingIconSpritesheet,
   isSplittingCharacterAnimation,
+  isRemovingCharacterAnimationBackground,
   isPersistingAssetKind,
   onSplitIconSpritesheet,
   onSplitCharacterAnimation,
+  onRemoveCharacterAnimationBackground,
   onExtractUiDesignAssets,
-  onOpenCharacterAnimationPanel,
   onDownloadLayer,
 }: ImageCanvasSelectedLayerToolbarViewProps) {
   if (!selectedLayer || !selectedToolbarStyle) {
@@ -157,7 +158,7 @@ export function ImageCanvasSelectedLayerToolbarView({
                   ? '完美�素处�中'
                   : isPerfectPixelPendingConfirmation
                     ? '完美�素结果待确认'
-                  : '完美�素'
+                    : '完美�素'
             }
             title={
               isPersistingAssetKind
@@ -166,7 +167,7 @@ export function ImageCanvasSelectedLayerToolbarView({
                   ? '完美�素处�中'
                   : isPerfectPixelPendingConfirmation
                     ? '结果待确认，�击原��继续核对或�试'
-                  : '自动识别并规整�素网格'
+                    : '自动识别并规整�素网格'
             }
             icon={
               isPersistingAssetKind || isPerfectPixelProcessing ? (
@@ -194,7 +195,7 @@ export function ImageCanvasSelectedLayerToolbarView({
                   ? '处�中'
                   : isPerfectPixelPendingConfirmation
                     ? '待确认'
-                  : '完美�素'}
+                    : '完美�素'}
             </span>
           </PlatformIconButton>
         </>
@@ -247,55 +248,71 @@ export function ImageCanvasSelectedLayerToolbarView({
           <span>��素�</span>
         </PlatformIconButton>
       ) : null}
-      {selectedLayer.assetKind === 'character-animation' ? (
-        <PlatformIconButton
-          className="image-canvas-editor__floating-toolbar-text-button"
-          label={characterAnimationSplitLabel}
-          title={characterAnimationSplitLabel}
-          icon={
-            isCharacterAnimationResourcePending ||
-            isSplittingCharacterAnimation ? (
-              <Loader2 className="h-4 w-4 animate-spin" />
-            ) : (
-              <Scissors className="h-4 w-4" />
-            )
-          }
-          disabled={
-            isCharacterAnimationResourcePending || isSplittingCharacterAnimation
-          }
-          aria-busy={
-            isCharacterAnimationResourcePending || isSplittingCharacterAnimation
-          }
-          onClick={() => onSplitCharacterAnimation(selectedLayer)}
-        >
-          <span>{characterAnimationSplitLabel}</span>
-        </PlatformIconButton>
-      ) : null}
-      {selectedLayer.assetKind === 'character' ? (
-        <PlatformIconButton
-          className="image-canvas-editor__floating-toolbar-text-button"
-          label="生�动画"
-          title="生�动画"
-          icon={<PersonStanding className="h-4 w-4" />}
-          onClick={() => onOpenCharacterAnimationPanel(selectedLayer)}
-        >
-          <span>生�动画</span>
-        </PlatformIconButton>
-      ) : null}
       {canRedraw ? (
+        <PlatformIconButton
+          className="image-canvas-editor__floating-toolbar-text-button"
+          label="改造"
+          title="改造"
+          icon={<WandSparkles className="h-4 w-4" />}
+          onClick={() => onOpenRedrawPanel(selectedLayer)}
+        >
+          <span>改造</span>
+        </PlatformIconButton>
+      ) : null}
+      {selectedLayer.assetKind === 'character-animation' ? (
         <>
-          <span
-            aria-hidden="true"
-            className="image-canvas-editor__floating-toolbar-divider"
-          />
           <PlatformIconButton
             className="image-canvas-editor__floating-toolbar-text-button"
-            label="改造"
-            title="改造"
-            icon={<WandSparkles className="h-4 w-4" />}
-            onClick={() => onOpenRedrawPanel(selectedLayer)}
+            label={
+              isRemovingCharacterAnimationBackground ? '去背景中' : '去背景'
+            }
+            title={
+              isRemovingCharacterAnimationBackground ? '去背景中' : '去背景'
+            }
+            icon={
+              isRemovingCharacterAnimationBackground ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <ImageOff className="h-4 w-4" />
+              )
+            }
+            disabled={
+              isCharacterAnimationResourcePending ||
+              isRemovingCharacterAnimationBackground
+            }
+            aria-busy={
+              isCharacterAnimationResourcePending ||
+              isRemovingCharacterAnimationBackground
+            }
+            onClick={() => onRemoveCharacterAnimationBackground(selectedLayer)}
           >
-            <span>改造</span>
+            <span>
+              {isRemovingCharacterAnimationBackground ? '去背景中' : '去背景'}
+            </span>
+          </PlatformIconButton>
+          <PlatformIconButton
+            className="image-canvas-editor__floating-toolbar-text-button"
+            label={characterAnimationSplitLabel}
+            title={characterAnimationSplitLabel}
+            icon={
+              isCharacterAnimationResourcePending ||
+              isSplittingCharacterAnimation ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Scissors className="h-4 w-4" />
+              )
+            }
+            disabled={
+              isCharacterAnimationResourcePending ||
+              isSplittingCharacterAnimation
+            }
+            aria-busy={
+              isCharacterAnimationResourcePending ||
+              isSplittingCharacterAnimation
+            }
+            onClick={() => onSplitCharacterAnimation(selectedLayer)}
+          >
+            <span>{characterAnimationSplitLabel}</span>
           </PlatformIconButton>
         </>
       ) : null}
diff --git a/src/components/image-editor/ImageCanvasStageView.tsx b/src/components/image-editor/ImageCanvasStageView.tsx
index 033a77339..93d3eff1e 100644
--- a/src/components/image-editor/ImageCanvasStageView.tsx
+++ b/src/components/image-editor/ImageCanvasStageView.tsx
@@ -81,6 +81,7 @@ export type ImageCanvasStageViewProps = {
   selectedToolbarStyle: CSSProperties | null;
   splittingIconSpritesheetLayerIds?: ReadonlySet<string>;
   splittingCharacterAnimationLayerIds?: ReadonlySet<string>;
+  removingBackgroundCharacterAnimationLayerIds?: ReadonlySet<string>;
   perfectPixelLayerIds?: ReadonlySet<string>;
   pendingPerfectPixelLayerIds?: ReadonlySet<string>;
   persistingAssetKindLayerIds?: ReadonlySet<string>;
@@ -157,6 +158,7 @@ export type ImageCanvasStageViewProps = {
   onPerfectPixel: (layer: CanvasLayer) => void;
   onSplitIconSpritesheet: (layer: CanvasLayer) => void;
   onSplitCharacterAnimation: (layer: CanvasLayer) => void;
+  onRemoveCharacterAnimationBackground: (layer: CanvasLayer) => void;
   onExtractUiDesignAssets: (layer: CanvasLayer) => void;
   onUiAssetExtractionToolChange: (tool: UiAssetExtractionTool | null) => void;
   onUiAssetExtractionModelChange: (model: string) => void;
@@ -170,7 +172,6 @@ export type ImageCanvasStageViewProps = {
   onQuickEditSelectionPointerStart: (point: { x: number; y: number }) => void;
   onQuickEditSelectionPointerMove: (point: { x: number; y: number }) => void;
   onQuickEditSelectionPointerEnd: () => void;
-  onOpenCharacterAnimationPanel: (layer: CanvasLayer) => void;
   onDownloadLayer: (layer: CanvasLayer) => void;
   onPasteCanvasClipboard: (canvasPoint?: { x: number; y: number }) => void;
   onCopyContextLayers: (options?: { cut?: boolean }) => void;
@@ -245,6 +246,7 @@ export function ImageCanvasStageView({
   selectedToolbarStyle,
   splittingIconSpritesheetLayerIds = EMPTY_LAYER_ID_SET,
   splittingCharacterAnimationLayerIds = EMPTY_LAYER_ID_SET,
+  removingBackgroundCharacterAnimationLayerIds = EMPTY_LAYER_ID_SET,
   perfectPixelLayerIds = EMPTY_LAYER_ID_SET,
   pendingPerfectPixelLayerIds = EMPTY_LAYER_ID_SET,
   persistingAssetKindLayerIds = EMPTY_LAYER_ID_SET,
@@ -300,6 +302,7 @@ export function ImageCanvasStageView({
   onPerfectPixel,
   onSplitIconSpritesheet,
   onSplitCharacterAnimation,
+  onRemoveCharacterAnimationBackground,
   onExtractUiDesignAssets,
   onUiAssetExtractionToolChange,
   onUiAssetExtractionModelChange,
@@ -313,7 +316,6 @@ export function ImageCanvasStageView({
   onQuickEditSelectionPointerStart,
   onQuickEditSelectionPointerMove,
   onQuickEditSelectionPointerEnd,
-  onOpenCharacterAnimationPanel,
   onDownloadLayer,
   onPasteCanvasClipboard,
   onCopyContextLayers,
@@ -424,6 +426,10 @@ export function ImageCanvasStageView({
           selectedLayer &&
             splittingCharacterAnimationLayerIds.has(selectedLayer.id),
         )}
+        isRemovingCharacterAnimationBackground={Boolean(
+          selectedLayer &&
+            removingBackgroundCharacterAnimationLayerIds.has(selectedLayer.id),
+        )}
         isPersistingAssetKind={Boolean(
           selectedLayer && persistingAssetKindLayerIds.has(selectedLayer.id),
         )}
@@ -440,8 +446,10 @@ export function ImageCanvasStageView({
         onPerfectPixel={onPerfectPixel}
         onSplitIconSpritesheet={onSplitIconSpritesheet}
         onSplitCharacterAnimation={onSplitCharacterAnimation}
+        onRemoveCharacterAnimationBackground={
+          onRemoveCharacterAnimationBackground
+        }
         onExtractUiDesignAssets={onExtractUiDesignAssets}
-        onOpenCharacterAnimationPanel={onOpenCharacterAnimationPanel}
         onDownloadLayer={onDownloadLayer}
       />
 
@@ -502,7 +510,6 @@ export function ImageCanvasStageView({
         onFitLayers={onFitLayers}
         onOpenQuickEditPanel={onOpenQuickEditPanel}
         onOpenLayerMetadata={onOpenLayerMetadata}
-        onOpenCharacterAnimationPanel={onOpenCharacterAnimationPanel}
       />
 
       <ImageCanvasPanelDockView
diff --git a/src/components/image-editor/ImageCanvasUploadModel.test.ts b/src/components/image-editor/ImageCanvasUploadModel.test.ts
index 19448362d..410795565 100644
--- a/src/components/image-editor/ImageCanvasUploadModel.test.ts
+++ b/src/components/image-editor/ImageCanvasUploadModel.test.ts
@@ -482,6 +482,61 @@ describe('ImageCanvasUploadModel', () => {
     });
   });
 
+  it('keeps direct-conversion uploads and AI appearance uploads in independent slots', () => {
+    const motionReference = {
+      id: 'motion-video',
+      label: '动作视频',
+      src: 'users/user-1/motion.mp4',
+      mediaType: 'video' as const,
+    };
+    const appearanceReference = {
+      id: 'appearance-image',
+      label: '角色外观',
+      src: 'users/user-1/appearance.png',
+      mediaType: 'image' as const,
+    };
+    const conversionReference = {
+      id: 'conversion-video',
+      label: '直接转��视频',
+      src: 'users/user-1/source.mov',
+      mediaType: 'video' as const,
+    };
+
+    expect(
+      applyGenerationReferenceUpload({
+        dialog: createDialog({
+          mode: 'character-animation',
+          characterAnimationWorkflow: 'ai',
+          generationReferences: [motionReference],
+        }),
+        target: 'video-reference-image',
+        references: [appearanceReference],
+      }),
+    ).toMatchObject({
+      generationReferences: [motionReference],
+      characterAnimationAppearanceReferences: [appearanceReference],
+    });
+
+    expect(
+      applyGenerationReferenceUpload({
+        dialog: createDialog({
+          mode: 'character-animation',
+          characterAnimationWorkflow: 'video-conversion',
+          prompt: 'AI �稿�应丢失',
+          generationReferences: [motionReference],
+          characterAnimationAppearanceReferences: [appearanceReference],
+        }),
+        target: 'video-reference-video',
+        references: [conversionReference],
+      }),
+    ).toMatchObject({
+      prompt: 'AI �稿�应丢失',
+      generationReferences: [motionReference],
+      characterAnimationAppearanceReferences: [appearanceReference],
+      characterAnimationConversionVideoReference: conversionReference,
+    });
+  });
+
   it('resizes a same-ratio character animation placeholder for an uploaded reference', () => {
     const dialog = createDialog({
       mode: 'character-animation',
diff --git a/src/components/image-editor/ImageCanvasUploadModel.ts b/src/components/image-editor/ImageCanvasUploadModel.ts
index 3c217f643..ac7711803 100644
--- a/src/components/image-editor/ImageCanvasUploadModel.ts
+++ b/src/components/image-editor/ImageCanvasUploadModel.ts
@@ -264,12 +264,31 @@ export function applyGenerationReferenceUpload({
     return dialog?.mode === 'video' ||
       (dialog?.mode === 'character-animation' && mediaType !== 'audio')
       ? dialog.mode === 'character-animation'
-        ? resizeGenerationPlaceholderToCharacterAnimationSelection({
-            ...setFailedGenerationIdle(dialog),
-            sourceLayerId: undefined,
-            generationReferences: [firstReference],
-            composerOpen: true,
-          })
+        ? resizeGenerationPlaceholderToCharacterAnimationSelection(
+            dialog.characterAnimationWorkflow === 'video-conversion' &&
+              mediaType === 'video'
+              ? {
+                  ...setFailedGenerationIdle(dialog),
+                  characterAnimationConversionVideoReference: firstReference,
+                  composerOpen: true,
+                }
+              : mediaType === 'image' &&
+                  dialog.generationReferences?.[0]?.mediaType === 'video'
+                ? {
+                    ...setFailedGenerationIdle(dialog),
+                    characterAnimationAppearanceReferences: [
+                      ...(dialog.characterAnimationAppearanceReferences ?? []),
+                      firstReference,
+                    ],
+                    composerOpen: true,
+                  }
+                : {
+                    ...setFailedGenerationIdle(dialog),
+                    sourceLayerId: undefined,
+                    generationReferences: [firstReference],
+                    composerOpen: true,
+                  },
+          )
         : {
             ...setFailedGenerationIdle(dialog),
             sourceLayerId: dialog.sourceLayerId,
diff --git a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
index a7c2620a5..3b381fd90 100644
--- a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
@@ -42,6 +42,7 @@ const uploadEditorMediaAssetFileMock = vi.hoisted(() => vi.fn());
 const editEditorImageMock = vi.hoisted(() => vi.fn());
 const extractEditorUiDesignAssetsMock = vi.hoisted(() => vi.fn());
 const renderUiDesignAssetExtractionMarkedImageMock = vi.hoisted(() => vi.fn());
+const convertEditorCharacterAnimationVideoMock = vi.hoisted(() => vi.fn());
 const generateEditorCharacterAnimationMock = vi.hoisted(() => vi.fn());
 const generateEditorIconSpecMock = vi.hoisted(() => vi.fn());
 const generateEditorIconSpritesheetMock = vi.hoisted(() => vi.fn());
@@ -67,6 +68,8 @@ vi.mock('../../services/image-editor/editorProjectClient', async () => {
     ...actual,
     editEditorImage: editEditorImageMock,
     extractEditorUiDesignAssets: extractEditorUiDesignAssetsMock,
+    convertEditorCharacterAnimationVideo:
+      convertEditorCharacterAnimationVideoMock,
     generateEditorCharacterAnimation: generateEditorCharacterAnimationMock,
     generateEditorIconSpec: generateEditorIconSpecMock,
     generateEditorIconSpritesheet: generateEditorIconSpritesheetMock,
@@ -615,6 +618,7 @@ describe('useImageCanvasGenerationSubmissionWorkflow', () => {
     editEditorImageMock.mockReset();
     extractEditorUiDesignAssetsMock.mockReset();
     renderUiDesignAssetExtractionMarkedImageMock.mockReset();
+    convertEditorCharacterAnimationVideoMock.mockReset();
     generateEditorCharacterAnimationMock.mockReset();
     generateEditorIconSpecMock.mockReset();
     generateEditorIconSpritesheetMock.mockReset();
@@ -4435,6 +4439,171 @@ describe('useImageCanvasGenerationSubmissionWorkflow', () => {
     );
   });
 
+  it('submits direct video conversion without prompt or model compatibility fields', async () => {
+    const appendedLayers = vi.fn();
+    const frames = [
+      { imageSrc: '/converted/frame-1.png', width: 640, height: 360 },
+      { imageSrc: '/converted/frame-2.png', width: 640, height: 360 },
+    ];
+    convertEditorCharacterAnimationVideoMock.mockResolvedValueOnce({
+      resultType: 'video-conversion',
+      taskId: 'conversion-task-1',
+      processingMethod: '视频直接转�',
+      frames,
+      frameCount: 2,
+      durationMs: 2_500,
+      frameWidth: 640,
+      frameHeight: 360,
+      sourceFps: 29.97,
+      samplingFps: 0.8,
+      priceMudPoints: 0,
+      resource: {
+        resourceId: 'resource-converted-animation',
+        projectId: 'editor-project-1',
+        imageSrc: frames[0]!.imageSrc,
+        width: 640,
+        height: 360,
+        sourceType: 'generated',
+        assetKind: 'character-animation',
+        imageSequenceFrames: frames,
+        imageSequenceDurationMs: 2_500,
+      },
+    });
+    const sourceReference = {
+      id: 'conversion-source',
+      label: '动作�视频.mov',
+      src: 'users/user-1/source.mov',
+      objectKey: 'users/user-1/source.mov',
+      mediaType: 'video' as const,
+      resourceId: 'resource-source-video',
+    };
+
+    render(
+      <SubmissionWorkflowHarness
+        projectId="editor-project-1"
+        onAppendCanvasLayers={appendedLayers}
+        initialDialog={{
+          id: 'dialog-video-conversion',
+          mode: 'character-animation',
+          prompt: 'AI �稿应�留但��交',
+          status: 'idle',
+          composerOpen: true,
+          characterAnimationWorkflow: 'video-conversion',
+          characterAnimationConversionVideoReference: sourceReference,
+          characterAnimationConversionResolution: '720p',
+          placeholder: {
+            x: 80,
+            y: 60,
+            width: 420,
+            height: 420,
+            originalWidth: 640,
+            originalHeight: 360,
+          },
+        }}
+        initialCharacterAnimationPanel={{
+          workflow: 'video-conversion',
+          conversionVideoReference: sourceReference,
+          conversionResolution: '720p',
+          promptText: 'AI �稿应�留但��交',
+          resolution: '480p',
+          ratio: '1:1',
+          frameCount: 32,
+          durationSeconds: 4,
+          status: 'idle',
+        }}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: '设置�始对�' }));
+    fireEvent.click(screen.getByRole('button', { name: '�交角色动画' }));
+
+    await waitFor(() => {
+      expect(convertEditorCharacterAnimationVideoMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sourceVideoSrc: 'users/user-1/source.mov',
+          resolution: '720p',
+          sourceResourceId: 'resource-source-video',
+          generationInputs: expect.objectContaining({
+            action: 'character-animation.convert',
+          }),
+        }),
+      );
+    });
+    const request = convertEditorCharacterAnimationVideoMock.mock.calls[0]?.[0];
+    expect(request).not.toHaveProperty('prompt');
+    expect(request).not.toHaveProperty('promptText');
+    expect(request).not.toHaveProperty('model');
+    await waitFor(() => expect(appendedLayers).toHaveBeenCalledTimes(1));
+    const layer = appendedLayers.mock.calls[0]?.[0]?.[0];
+    expect(layer).toMatchObject({
+      taskId: 'conversion-task-1',
+      provider: 'FFmpeg',
+      imageSequenceDurationMs: 2_500,
+      assetKind: 'character-animation',
+      mediaType: 'image-sequence',
+    });
+    expect(layer.prompt).toBeUndefined();
+    expect(layer.actualPrompt).toBeUndefined();
+    expect(layer.model).toBeUndefined();
+  });
+
+  it('does not reuse animation lineage as the direct conversion source resource', async () => {
+    const sourceReference = {
+      id: 'sequence-source',
+      label: '已生�动作',
+      src: '/generated-character-drafts/editor/preview.mp4',
+      objectKey: 'generated-character-drafts/editor/preview.mp4',
+      mediaType: 'video' as const,
+      assetKind: 'character-animation' as const,
+      resourceId: 'resource-original-motion',
+    };
+    convertEditorCharacterAnimationVideoMock.mockResolvedValueOnce({
+      resultType: 'video-conversion',
+      taskId: 'conversion-from-sequence',
+      processingMethod: '视频直接转�',
+      frames: [
+        { imageSrc: '/converted/frame-1.png', width: 640, height: 360 },
+        { imageSrc: '/converted/frame-2.png', width: 640, height: 360 },
+      ],
+      frameCount: 2,
+      durationMs: 2_500,
+      frameWidth: 640,
+      frameHeight: 360,
+      sourceFps: 24,
+      samplingFps: 8,
+      priceMudPoints: 0,
+    });
+
+    render(
+      <SubmissionWorkflowHarness
+        projectId="editor-project-1"
+        initialCharacterAnimationPanel={{
+          workflow: 'video-conversion',
+          conversionVideoReference: sourceReference,
+          conversionResolution: '480p',
+          promptText: '',
+          resolution: '480p',
+          ratio: '1:1',
+          frameCount: 32,
+          durationSeconds: 4,
+          status: 'idle',
+        }}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: '�交角色动画' }));
+
+    await waitFor(() => {
+      expect(convertEditorCharacterAnimationVideoMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sourceVideoSrc: 'generated-character-drafts/editor/preview.mp4',
+          sourceResourceId: undefined,
+          generationInputs: expect.objectContaining({ references: [] }),
+        }),
+      );
+    });
+  });
+
   it('moves character animation panels from generating to completed', async () => {
     generateEditorCharacterAnimationMock.mockResolvedValueOnce({
       frames: [{ imageSrc: 'data:image/png;base64,frame' }],
diff --git a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.ts b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.ts
index 414600ccd..565af53d6 100644
--- a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.ts
+++ b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.ts
@@ -22,6 +22,7 @@ import type {
 } from '../../services/image-editor/editorProjectClient';
 import {
   editEditorImage,
+  convertEditorCharacterAnimationVideo,
   extractEditorUiDesignAssets,
   generateEditorBackgroundMusic,
   generateEditorCharacterAnimation,
@@ -1110,7 +1111,9 @@ export function useImageCanvasGenerationSubmissionWorkflow({
       // 置为 generating，若这里��失败分支，�试会被 generating 守�永久阻断。抛错交给
       // submitCharacterAnimation 的 catch 统一走 failed + composerOpen ��。
       if (!nextLayer) {
-        throw new Error('角色动作生�结果缺少�用的正��列帧，无法放置到画布。');
+        throw new Error(
+          '角色动作生�结果缺少�用的正��列帧，无法放置到画布。',
+        );
       }
       addGeneratedLayersToCanvas([nextLayer]);
       selectSingleLayer(nextLayer.id);
@@ -2700,6 +2703,144 @@ export function useImageCanvasGenerationSubmissionWorkflow({
     }
     const canvasDialog = characterAnimationDialog;
     try {
+      if ((characterAnimationPanel.workflow ?? 'ai') === 'video-conversion') {
+        const source = characterAnimationPanel.conversionVideoReference;
+        if (!source || source.mediaType !== 'video') {
+          throw new Error('请选择一个 MP4 或 MOV �视频。');
+        }
+        const canvasCompletionPlaceholder = canvasDialog
+          ? getGeneratingDialogPlaceholder(canvasDialog)
+          : undefined;
+        if (canvasDialog?.mode === 'character-animation') {
+          updateCanvasGenerationDialogById(
+            canvasDialog.id,
+            (currentDialog) => ({
+              ...currentDialog,
+              status: 'generating',
+              composerOpen: false,
+              errorMessage: undefined,
+            }),
+          );
+        }
+        const stableSource = await resolveEditorGenerationMediaReference(
+          source,
+          'video',
+          projectId,
+          { allowRegisteredIds: false },
+        );
+        const resultTitle = resolveGenerationAssetLabel(
+          characterAnimationPanel.assetLabel,
+          '视频转��列帧',
+        );
+        // �列帧层的 previewVideoPath 是生�结果视频，而 sourceResourceId 通常是
+        // 动作/外观�考链上的资� id；把两者一起�交会触��端 objectKey 一致性校验，
+        // 使“�列帧 -> 直接转��稳定返回 400。直接转��需�已校验的 sourceVideoSrc；
+        // �端会用它�建 source 槽�，�能把原动画的 lineage id 冒充�视频资�。
+        const sourceResourceId =
+          source.assetKind === 'character-animation'
+            ? undefined
+            : resolveRegisteredProjectResourceId(source.resourceId);
+        const sourceReferences =
+          source.assetKind === 'character-animation'
+            ? []
+            : source.resourceId
+              ? [
+                  {
+                    id: 'source',
+                    title: '�视频',
+                    label: '�视频',
+                    refType: 'project-resource' as const,
+                    refId: source.resourceId,
+                  },
+                ]
+              : source.sourceAssetId
+                ? [
+                    {
+                      id: 'source',
+                      title: '�视频',
+                      label: '�视频',
+                      refType: 'asset' as const,
+                      refId: source.sourceAssetId,
+                    },
+                  ]
+                : [];
+        const generationInputs: CanvasGenerationInputs = {
+          version: 2,
+          action: 'character-animation.convert',
+          fields: [
+            { id: 'sourceVideoSrc', title: '�视频', value: stableSource },
+            {
+              id: 'resolution',
+              title: '最大长边',
+              value: characterAnimationPanel.conversionResolution ?? '480p',
+            },
+            {
+              id: 'processingMethod',
+              title: '处�方�',
+              value: '视频直接转�',
+            },
+          ],
+          references: sourceReferences,
+        };
+        const result = await runEditorGenerationWithWalletRefresh(
+          convertEditorCharacterAnimationVideo({
+            sourceVideoSrc: stableSource,
+            resolution: characterAnimationPanel.conversionResolution ?? '480p',
+            projectId,
+            generationInputs,
+            sourceResourceId,
+            assetFolderId,
+            assetLabel: resultTitle,
+            ...(canvasDialog && projectId && canvasCompletionPlaceholder
+              ? {
+                  canvasCompletion: {
+                    dialogId: canvasDialog.id,
+                    title: resultTitle,
+                    placeholder: canvasCompletionPlaceholder,
+                  },
+                }
+              : {}),
+          }),
+        );
+        if (
+          await applyQueuedEditorGenerationProject(
+            result,
+            projectId,
+            applyProjectSnapshot,
+            onQueuedGenerationTask,
+            onWalletBalanceMayHaveChanged,
+            onGenerationWarning,
+            canvasDialog?.id,
+          )
+        ) {
+          setCharacterAnimationPanel((currentPanel) =>
+            currentPanel
+              ? { ...currentPanel, status: 'completed' }
+              : currentPanel,
+          );
+          return;
+        }
+        if (canvasDialog) {
+          addCharacterAnimationResultLayer(
+            result,
+            resultTitle,
+            generationInputs,
+            canvasCompletionPlaceholder,
+            canvasDialog.id,
+            {
+              ...(characterAnimationSourceLayer
+                ? { sourceLayer: characterAnimationSourceLayer }
+                : {}),
+            },
+          );
+        }
+        setCharacterAnimationPanel((currentPanel) =>
+          currentPanel
+            ? { ...currentPanel, status: 'completed', result }
+            : currentPanel,
+        );
+        return;
+      }
       const submissionPlan = buildCharacterAnimationSubmissionPlan({
         panel: characterAnimationPanel,
         sourceLayer: characterAnimationSourceLayer,
@@ -2736,6 +2877,8 @@ export function useImageCanvasGenerationSubmissionWorkflow({
         ? getGeneratingDialogPlaceholder(canvasDialog)
         : undefined;
       const selectedReference = characterAnimationPanel.references?.[0];
+      const appearanceReferences =
+        characterAnimationPanel.appearanceReferences ?? [];
       const referenceMediaType =
         selectedReference?.mediaType === 'video' ? 'video' : 'image';
       const stableReferenceSrc = selectedReference
@@ -2759,6 +2902,18 @@ export function useImageCanvasGenerationSubmissionWorkflow({
               },
             )
           : undefined;
+      const stableAppearanceSrcs = (
+        await Promise.all(
+          appearanceReferences.map((appearanceReference) =>
+            resolveEditorGenerationMediaReference(
+              appearanceReference,
+              'image',
+              projectId,
+              { allowRegisteredIds: false, requireImageObjectReference: true },
+            ),
+          ),
+        )
+      ).filter((src): src is string => Boolean(src));
       const generationInputs = buildCharacterAnimationGenerationInputs(
         submissionPlan.promptText,
         characterAnimationSourceLayer,
@@ -2771,6 +2926,8 @@ export function useImageCanvasGenerationSubmissionWorkflow({
           backgroundColor: characterAnimationPanel.backgroundColor,
           referenceSrc: stableReferenceSrc,
           referenceMediaType,
+          appearanceReferences,
+          appearanceReferenceSrcs: stableAppearanceSrcs,
         },
       );
       const result = await runEditorGenerationWithWalletRefresh(
@@ -2784,12 +2941,23 @@ export function useImageCanvasGenerationSubmissionWorkflow({
                   : {}),
               }
             : {}),
+          ...(stableAppearanceSrcs.length
+            ? { appearanceReferenceSrcs: stableAppearanceSrcs }
+            : {}),
           projectId,
           generationInputs,
           sourceResourceId: resolveRegisteredProjectResourceId(
             selectedReference?.resourceId ??
               characterAnimationSourceLayer?.resourceId,
           ),
+          appearanceSourceResourceIds: appearanceReferences.flatMap(
+            (appearanceReference) => {
+              const resourceId = resolveRegisteredProjectResourceId(
+                appearanceReference?.resourceId,
+              );
+              return resourceId ? [resourceId] : [];
+            },
+          ),
           assetFolderId,
           ...(canvasDialog && projectId && canvasCompletionPlaceholder
             ? {
diff --git a/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx b/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
index e853cc749..2c94d5c47 100644
--- a/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
@@ -109,6 +109,7 @@ function createLayer(overrides: Partial<CanvasLayer> = {}): CanvasLayer {
 
 function GenerationSurfaceHarness() {
   const [layers, setLayers] = useState<CanvasLayer[]>([createLayer()]);
+  const [selectedLayer, setSelectedLayer] = useState<CanvasLayer | null>(null);
   const [activeTool, setActiveTool] = useState<CanvasTool>('select');
   const [activeSidebarPanel, setActiveSidebarPanel] =
     useState<SidebarPanel | null>('assets');
@@ -133,6 +134,7 @@ function GenerationSurfaceHarness() {
       : null;
   const surface = useImageCanvasGenerationSurface({
     layers,
+    selectedLayer,
     canvasSize: { width: 900, height: 640 },
     viewport,
     setViewport,
@@ -217,6 +219,20 @@ function GenerationSurfaceHarness() {
       >
         切�Spine�列帧
       </button>
+      <button
+        type="button"
+        onClick={() => {
+          const videoLayer = createLayer({
+            id: 'selected-video',
+            mediaType: 'video',
+            src: 'editor/videos/action.mp4',
+            objectKey: 'editor/videos/action.mp4',
+          });
+          setSelectedLayer(videoLayer);
+        }}
+      >
+        选中视频
+      </button>
       <button
         type="button"
         onClick={() => surface.switchGenerationTool('music')}
@@ -296,9 +312,7 @@ describe('useImageCanvasGenerationSurface', () => {
     expect(screen.getByRole('dialog', { name: '生�图片' })).toBeTruthy();
 
     fireEvent.click(screen.getByRole('button', { name: '切�Spine�列帧' }));
-    expect(screen.getByTestId('tool').textContent).toBe(
-      'character-animation',
-    );
+    expect(screen.getByTestId('tool').textContent).toBe('character-animation');
     expect(screen.getByTestId('dialog').textContent).toBe(
       'character-animation:open:placeholder',
     );
@@ -307,15 +321,29 @@ describe('useImageCanvasGenerationSurface', () => {
     ).toBeTruthy();
   });
 
+  it('uses the direct-conversion tab when the selected layer is a video', () => {
+    render(<GenerationSurfaceHarness />);
+
+    fireEvent.click(screen.getByRole('button', { name: '选中视频' }));
+    fireEvent.click(screen.getByRole('button', { name: '切�Spine�列帧' }));
+
+    expect(
+      screen
+        .getByRole('tab', { name: '视频直接转�' })
+        .getAttribute('aria-selected'),
+    ).toBe('true');
+    expect(
+      screen.getByRole('button', { name: '选择直接转��视频' }),
+    ).toBeTruthy();
+  });
+
   it('derives composer position without rendering a standalone close button', () => {
     render(<GenerationSurfaceHarness />);
 
     fireEvent.click(screen.getByRole('button', { name: '切�生�' }));
     expect(screen.getByTestId('composer-left').textContent).toBe('450');
     expect(screen.getByTestId('composer-top').textContent).toBe('1354');
-    expect(
-      screen.queryByRole('button', { name: '关闭生�图片' }),
-    ).toBeNull();
+    expect(screen.queryByRole('button', { name: '关闭生�图片' })).toBeNull();
     expect(screen.getByTestId('dialog').textContent).toBe(
       'generate:open:placeholder',
     );
@@ -445,9 +473,7 @@ describe('useImageCanvasGenerationSurface', () => {
     expect(screen.getByRole('dialog', { name: '生�游�音效' })).toBeTruthy();
 
     fireEvent.click(screen.getByRole('button', { name: '切�音�' }));
-    fireEvent.click(
-      screen.getByRole('menuitem', { name: '生�游�背景音�' }),
-    );
+    fireEvent.click(screen.getByRole('menuitem', { name: '生�游�背景音�' }));
     expect(screen.getByTestId('dialog').textContent).toBe(
       'audio-background-music:open:placeholder',
     );
diff --git a/src/components/image-editor/useImageCanvasGenerationSurface.tsx b/src/components/image-editor/useImageCanvasGenerationSurface.tsx
index 783de49df..7aed9d762 100644
--- a/src/components/image-editor/useImageCanvasGenerationSurface.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationSurface.tsx
@@ -53,6 +53,7 @@ type ToolbarOptionTool = Extract<CanvasTool, 'music' | 'spec' | 'publication'>;
 
 type ImageCanvasGenerationSurfaceOptions = {
   layers: CanvasLayer[];
+  selectedLayer?: CanvasLayer | null;
   canvasSize: { width: number; height: number };
   viewport: CanvasViewport;
   setViewport: Dispatch<SetStateAction<CanvasViewport>>;
@@ -157,6 +158,7 @@ const TOOLBAR_OPTION_CLOSE_DELAY_MS = 160;
 
 export function useImageCanvasGenerationSurface({
   layers,
+  selectedLayer = null,
   canvasSize,
   viewport,
   setViewport,
@@ -344,7 +346,24 @@ export function useImageCanvasGenerationSurface({
         return true;
       }
       if (tool === 'character-animation') {
-        generationWorkflow.openCharacterAnimationPanel();
+        const selectedWorkflow =
+          selectedLayer?.mediaType === 'video' ||
+          (selectedLayer?.assetKind === 'character-animation' &&
+            Boolean(selectedLayer.previewVideoPath?.trim()))
+            ? 'video-conversion'
+            : 'ai';
+        const selectedSourceLayer =
+          (selectedWorkflow === 'video-conversion' &&
+            (selectedLayer?.mediaType === 'video' ||
+              (selectedLayer?.assetKind === 'character-animation' &&
+                Boolean(selectedLayer.previewVideoPath?.trim())))) ||
+          (selectedWorkflow === 'ai' &&
+            selectedLayer?.assetKind === 'character')
+            ? selectedLayer
+            : undefined;
+        generationWorkflow.openCharacterAnimationPanel(selectedSourceLayer, {
+          workflow: selectedWorkflow,
+        });
         return true;
       }
       if (tool === 'music') {
@@ -376,7 +395,7 @@ export function useImageCanvasGenerationSurface({
       }
       return false;
     },
-    [generationWorkflow, openToolbarOptionMenu, setActiveTool],
+    [generationWorkflow, openToolbarOptionMenu, selectedLayer, setActiveTool],
   );
 
   const generationComposerNode = (
diff --git a/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx b/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
index 036b787be..69fbd3723 100644
--- a/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
@@ -552,6 +552,11 @@ function GenerationWorkflowHarness({
           ?.map((reference) => reference.label)
           .join('|') ?? '-'}
       </span>
+      <span data-testid="character-animation-appearance-reference">
+        {activeDialog?.characterAnimationAppearanceReferences
+          ?.map((reference) => reference.label)
+          .join('|') ?? '-'}
+      </span>
       <span data-testid="character-spec-reference">
         {activeDialog?.characterSpecReference?.label ?? '-'}
       </span>
@@ -986,6 +991,42 @@ function GenerationWorkflowHarness({
       >
         对当�图层生�动作
       </button>
+      <button
+        type="button"
+        onClick={() => workflow.openCharacterAnimationPanel()}
+      >
+        打开视频动画
+      </button>
+      <button
+        type="button"
+        onClick={() =>
+          workflow.pickGenerationReferenceFromLayer(
+            createLayer({
+              id: 'layer-motion-video',
+              title: '动作视频',
+              mediaType: 'video',
+              assetKind: 'video',
+              src: 'generated/motion.mp4',
+            }),
+          )
+        }
+      >
+        选择动作视频
+      </button>
+      <button
+        type="button"
+        onClick={() =>
+          workflow.pickGenerationReferenceFromLayer(
+            createLayer({
+              id: 'layer-ordinary-appearance',
+              title: '普通外观图',
+              src: 'generated/appearance.png',
+            }),
+          )
+        }
+      >
+        选择普通外观图
+      </button>
       <button
         type="button"
         onClick={() =>
@@ -3356,7 +3397,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       );
     });
     const firstRequest = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     const firstDialogList =
       screen.getByTestId('generation-dialogs').textContent;
     const firstOperation = JSON.parse(
@@ -3374,7 +3416,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     });
 
     const retryRequest = snapImageToPerfectPixelsMock.mock.calls[1]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     expect(JSON.stringify(retryRequest)).toBe(firstRequestBytes);
     expect(retryRequest).toEqual(firstOperation.request);
     expect(retryRequest?.canvasCompletion.dialogId).toBe(
@@ -3510,7 +3553,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
         });
       loadEditorProjectMock.mockImplementation(async () => {
         const request = snapImageToPerfectPixelsMock.mock.calls.at(-1)?.[0] as
-          EditorPixelArtSnapInput | undefined;
+          | EditorPixelArtSnapInput
+          | undefined;
         return createConflictingPerfectPixelProject(
           request!.canvasCompletion.dialogId,
         );
@@ -3563,7 +3607,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       expect(retried!.reconcileUntil - retried!.submittedAt).toBe(75_000);
       expect(retried?.taskId).toBe(beforeRetry.taskId);
       const firstRequest = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-        EditorPixelArtSnapInput | undefined;
+        | EditorPixelArtSnapInput
+        | undefined;
       expect(JSON.stringify(requestAtRetryPost)).toBe(
         JSON.stringify(firstRequest),
       );
@@ -3589,7 +3634,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       );
     loadEditorProjectMock.mockImplementation(async () => {
       const request = snapImageToPerfectPixelsMock.mock.calls.at(-1)?.[0] as
-        EditorPixelArtSnapInput | undefined;
+        | EditorPixelArtSnapInput
+        | undefined;
       return createConflictingPerfectPixelProject(
         request!.canvasCompletion.dialogId,
       );
@@ -3616,7 +3662,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     });
 
     const firstRequest = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     const firstRequestBytes = JSON.stringify(firstRequest);
     const operation = JSON.parse(
       screen.getByTestId('perfect-pixel-operation').textContent!,
@@ -3649,7 +3696,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     });
 
     const retryRequest = snapImageToPerfectPixelsMock.mock.calls[1]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     expect(uploadEditorMediaAssetObjectFileMock).toHaveBeenCalledTimes(1);
     expect(JSON.stringify(retryRequest)).toBe(firstRequestBytes);
     expect(retryRequest?.canvasCompletion.dialogId).toBe(operation.operationId);
@@ -3670,7 +3718,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       .mockImplementationOnce(() => retryResult.promise);
     loadEditorProjectMock.mockImplementation(async () => {
       const request = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-        EditorPixelArtSnapInput | undefined;
+        | EditorPixelArtSnapInput
+        | undefined;
       return createConflictingPerfectPixelProject(
         request!.canvasCompletion.dialogId,
       );
@@ -3707,7 +3756,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       expect(snapImageToPerfectPixelsMock).toHaveBeenCalledTimes(2);
     });
     const retryRequest = snapImageToPerfectPixelsMock.mock.calls[1]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     expect(retryRequest).toBeDefined();
 
     rerender(
@@ -3743,7 +3793,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     );
     loadEditorProjectMock.mockImplementation(async () => {
       const request = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-        EditorPixelArtSnapInput | undefined;
+        | EditorPixelArtSnapInput
+        | undefined;
       return createConflictingPerfectPixelProject(
         request!.canvasCompletion.dialogId,
       );
@@ -3817,7 +3868,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     );
     loadEditorProjectMock.mockImplementationOnce(async () => {
       const request = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-        EditorPixelArtSnapInput | undefined;
+        | EditorPixelArtSnapInput
+        | undefined;
       return createConflictingPerfectPixelProject(
         request!.canvasCompletion.dialogId,
       );
@@ -3866,7 +3918,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       `pixel-art-snap-${postedOperation.operationId}`,
     );
     const postedRequest = snapImageToPerfectPixelsMock.mock.calls[0]?.[0] as
-      EditorPixelArtSnapInput | undefined;
+      | EditorPixelArtSnapInput
+      | undefined;
     expect(JSON.stringify(postedRequest)).toBe(
       JSON.stringify(postedOperation.request),
     );
@@ -4817,7 +4870,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
       }),
     );
     const readOptions = loadEditorProjectMock.mock.calls[0]?.[1] as
-      { deadlineAt?: number } | undefined;
+      | { deadlineAt?: number }
+      | undefined;
     expect(readOptions?.deadlineAt).toBeLessThanOrEqual(Date.now() + 10_000);
     expect(readOptions?.deadlineAt).toBeLessThanOrEqual(
       hydratedDialog.perfectPixelOperation!.reconcileUntil,
@@ -4889,7 +4943,8 @@ describe('useImageCanvasGenerationWorkflow', () => {
     });
     expect(loadEditorProjectMock).toHaveBeenCalledTimes(1);
     const readOptions = loadEditorProjectMock.mock.calls[0]?.[1] as
-      { deadlineAt?: number } | undefined;
+      | { deadlineAt?: number }
+      | undefined;
     expect(readOptions?.deadlineAt).toBeGreaterThanOrEqual(readStartedAt);
     expect(readOptions?.deadlineAt).toBeLessThanOrEqual(Date.now() + 10_000);
     expect(snapImageToPerfectPixelsMock).not.toHaveBeenCalled();
@@ -5126,6 +5181,24 @@ describe('useImageCanvasGenerationWorkflow', () => {
     expect(screen.getByTestId('dialog').textContent).toBe('-');
   });
 
+  it('allows an ordinary canvas image as optional appearance for video AI animation', () => {
+    render(<GenerationWorkflowHarness />);
+
+    fireEvent.click(screen.getByRole('button', { name: '打开视频动画' }));
+    fireEvent.click(screen.getByRole('button', { name: '选择动作视频' }));
+    expect(screen.getByTestId('generation-references').textContent).toBe(
+      '动作视频',
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: '选择普通外观图' }));
+
+    expect(
+      screen.getByTestId('character-animation-appearance-reference')
+        .textContent,
+    ).toBe('普通外观图');
+    expect(screen.getByTestId('reference-pick-warning').textContent).toBe('-');
+  });
+
   it('creates a placed character action generation dialog for character layers', () => {
     render(<GenerationWorkflowHarness />);
 
diff --git a/src/components/image-editor/useImageCanvasGenerationWorkflow.ts b/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
index 3c35a3cc3..71a5afb2f 100644
--- a/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
+++ b/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
@@ -25,6 +25,7 @@ import {
   type EditorProjectResourceSnapshot,
   type EditorProjectSnapshot,
   loadEditorProject,
+  removeEditorCharacterAnimationBackground,
   splitEditorCharacterAnimationFrames,
   splitEditorIconSpritesheet,
 } from '../../services/image-editor/editorProjectClient';
@@ -733,7 +734,8 @@ function findSourceAnimationLayer(
   return (
     layers.find(
       (layer) =>
-        (layer.resourceId === sourceResourceId || layer.id === sourceResourceId) &&
+        (layer.resourceId === sourceResourceId ||
+          layer.id === sourceResourceId) &&
         layer.assetKind === 'character',
     ) ?? null
   );
@@ -954,6 +956,11 @@ function createCharacterAnimationPanelFromDialog(
   return {
     sourceLayerId: dialog.sourceLayerId,
     references: dialog.generationReferences ?? [],
+    workflow: dialog.characterAnimationWorkflow ?? 'ai',
+    appearanceReferences: dialog.characterAnimationAppearanceReferences ?? [],
+    conversionVideoReference: dialog.characterAnimationConversionVideoReference,
+    conversionResolution:
+      dialog.characterAnimationConversionResolution ?? '480p',
     promptText: dialog.prompt,
     assetLabel: dialog.assetLabel,
     backgroundColor: dialog.characterAnimationBackgroundColor,
@@ -995,6 +1002,11 @@ function applyCharacterAnimationPanelToDialog(
     assetLabel: panel.assetLabel,
     sourceLayerId: panel.sourceLayerId,
     generationReferences: panel.references,
+    characterAnimationWorkflow: panel.workflow ?? 'ai',
+    characterAnimationAppearanceReferences: panel.appearanceReferences ?? [],
+    characterAnimationConversionVideoReference: panel.conversionVideoReference,
+    characterAnimationConversionResolution:
+      panel.conversionResolution ?? '480p',
     characterAnimationBackgroundColor: panel.backgroundColor,
     characterAnimationResolution: panel.resolution,
     characterAnimationRatio: panel.ratio,
@@ -1145,6 +1157,13 @@ export function useImageCanvasGenerationWorkflow({
     splittingCharacterAnimationLayerIds,
     setSplittingCharacterAnimationLayerIds,
   ] = useState<Set<string>>(() => new Set());
+  const removingBackgroundCharacterAnimationLayerIdsRef = useRef(
+    new Set<string>(),
+  );
+  const [
+    removingBackgroundCharacterAnimationLayerIds,
+    setRemovingBackgroundCharacterAnimationLayerIds,
+  ] = useState<Set<string>>(() => new Set());
   const perfectPixelLayerIdsRef = useRef(new Set<string>());
   // 中文注释：本会��在执行的 inline �� id。到期清��该针对**别人**留下的孤儿，
   // 而它无法从 dialog 状�区分「已死会�留下的�和「本会�正在跑的�——两者都是
@@ -1623,11 +1642,15 @@ export function useImageCanvasGenerationWorkflow({
   );
 
   const openCharacterAnimationPanel = useCallback(
-    (layer?: CanvasLayer) => {
+    (
+      layer?: CanvasLayer,
+      options?: { workflow?: 'ai' | 'video-conversion' },
+    ) => {
       const draft = createCharacterAnimationGenerationDialogDraft({
         canvasSize,
         viewport,
         layer,
+        workflow: options?.workflow,
       });
       if (!draft) {
         return;
@@ -1892,10 +1915,10 @@ export function useImageCanvasGenerationWorkflow({
       );
       const hasInvalidVersionedGenerationInputs = Boolean(
         sourceLayer.generationInputsHydrationState === 'invalid-versioned' ||
-        (sourceLayer.generationInputs &&
-          (sourceLayer.generationInputs.version !== undefined ||
-            sourceLayer.generationInputs.action !== undefined) &&
-          !decodedGenerationInputs.ok),
+          (sourceLayer.generationInputs &&
+            (sourceLayer.generationInputs.version !== undefined ||
+              sourceLayer.generationInputs.action !== undefined) &&
+            !decodedGenerationInputs.ok),
       );
       if (hasInvalidVersionedGenerationInputs) {
         showGenerationWarning(
@@ -3608,6 +3631,91 @@ export function useImageCanvasGenerationWorkflow({
     ],
   );
 
+  const removeSelectedCharacterAnimationBackground = useCallback(
+    async (sourceLayer: CanvasLayer) => {
+      if (
+        !canSplitCharacterAnimationFrames(sourceLayer) ||
+        !projectId ||
+        removingBackgroundCharacterAnimationLayerIdsRef.current.has(
+          sourceLayer.id,
+        )
+      ) {
+        return;
+      }
+      removingBackgroundCharacterAnimationLayerIdsRef.current.add(
+        sourceLayer.id,
+      );
+      setRemovingBackgroundCharacterAnimationLayerIds((currentLayerIds) => {
+        const nextLayerIds = new Set(currentLayerIds);
+        nextLayerIds.add(sourceLayer.id);
+        return nextLayerIds;
+      });
+      closeGenerationTransientState();
+      setImageContextMenu(null);
+      setMetadataLayer(null);
+      setCropExpandPanel(null);
+      setQuickEditPanel(null);
+      try {
+        const result = await removeEditorCharacterAnimationBackground({
+          projectId,
+          sourceLayerId: sourceLayer.id,
+          sourceResourceId: sourceLayer.resourceId,
+          assetFolderId,
+          assetLabel: `${sourceLayer.title} 去背景`,
+          generationInputs: buildDeterministicGenerationInputs(
+            'character-animation.remove-background',
+            sourceLayer,
+          ),
+        });
+        await applyQueuedEditorGenerationProject(
+          result,
+          projectId,
+          applyProjectSnapshot,
+          refreshTaskListForQueuedGeneration,
+          onWalletBalanceMayHaveChanged,
+          showGenerationWarning,
+        );
+        try {
+          await Promise.resolve(refreshAssetLibrary?.());
+        } catch {
+          // �务端已原��库�功；列表刷新失败�能把�功事实伪装�去背景失败。
+        }
+      } catch (error) {
+        window.alert(
+          error instanceof Error && error.message.trim()
+            ? error.message
+            : '去除�列帧背景失败',
+        );
+      } finally {
+        removingBackgroundCharacterAnimationLayerIdsRef.current.delete(
+          sourceLayer.id,
+        );
+        setRemovingBackgroundCharacterAnimationLayerIds((currentLayerIds) => {
+          if (!currentLayerIds.has(sourceLayer.id)) {
+            return currentLayerIds;
+          }
+          const nextLayerIds = new Set(currentLayerIds);
+          nextLayerIds.delete(sourceLayer.id);
+          return nextLayerIds;
+        });
+      }
+    },
+    [
+      applyProjectSnapshot,
+      assetFolderId,
+      closeGenerationTransientState,
+      onWalletBalanceMayHaveChanged,
+      projectId,
+      refreshAssetLibrary,
+      refreshTaskListForQueuedGeneration,
+      setCropExpandPanel,
+      setImageContextMenu,
+      setMetadataLayer,
+      setQuickEditPanel,
+      showGenerationWarning,
+    ],
+  );
+
   const rejectReferenceMutationWhileUploadPending = useCallback(() => {
     if (!hasPendingImageReferenceUploads) {
       return false;
@@ -3674,16 +3782,25 @@ export function useImageCanvasGenerationWorkflow({
         return;
       }
       let rejectedLimit: number | null = null;
-      let rejectedCharacterReference = false;
+      let rejectedCharacterReference: 'video' | 'character' | null = null;
       setGenerateDialog((currentDialog) => {
-        if (
-          currentDialog?.mode === 'character-animation' &&
-          layer.mediaType !== 'video' &&
-          layer.assetKind !== 'character' &&
-          layer.assetKind !== 'character-animation'
-        ) {
-          rejectedCharacterReference = true;
-          return currentDialog;
+        if (currentDialog?.mode === 'character-animation') {
+          const isVideoAppearanceReference =
+            currentDialog.characterAnimationWorkflow !== 'video-conversion' &&
+            currentDialog.generationReferences?.[0]?.mediaType === 'video';
+          const isAllowedCharacterAnimationReference =
+            currentDialog.characterAnimationWorkflow === 'video-conversion'
+              ? layer.mediaType === 'video' ||
+                (layer.assetKind === 'character-animation' &&
+                  Boolean(layer.previewVideoPath?.trim()))
+              : layer.mediaType !== 'audio';
+          if (!isAllowedCharacterAnimationReference) {
+            rejectedCharacterReference =
+              currentDialog.characterAnimationWorkflow === 'video-conversion'
+                ? 'video'
+                : 'character';
+            return currentDialog;
+          }
         }
         if (
           currentDialog &&
@@ -3702,7 +3819,11 @@ export function useImageCanvasGenerationWorkflow({
         return appendGenerationReference(currentDialog, layer);
       });
       if (rejectedCharacterReference) {
-        showGenerationWarning('请选择角色图');
+        showGenerationWarning(
+          rejectedCharacterReference === 'video'
+            ? '请选择视频'
+            : '请选择图片�视频或�列帧动画',
+        );
         return;
       }
       if (rejectedLimit !== null) {
@@ -4673,6 +4794,8 @@ export function useImageCanvasGenerationWorkflow({
       splittingIconSpritesheetLayerIds,
       splitSelectedCharacterAnimationFrames,
       splittingCharacterAnimationLayerIds,
+      removeSelectedCharacterAnimationBackground,
+      removingBackgroundCharacterAnimationLayerIds,
       taskListRefreshKey,
       refreshTaskList,
       isTaskSidebarOpen,
diff --git a/src/index.css b/src/index.css
index c778e0dac..8b4c379aa 100644
--- a/src/index.css
+++ b/src/index.css
@@ -6841,6 +6841,55 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
   padding: 1rem 1rem 0.78rem;
 }
 
+.image-canvas-editor__workflow-tabs {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.28rem;
+  grid-column: 1 / -1;
+  border: 1px solid rgba(15, 23, 42, 0.08);
+  border-radius: 0.72rem;
+  background: #f1f5f9;
+  padding: 0.28rem;
+}
+
+.image-canvas-editor__workflow-tab {
+  display: inline-flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: center;
+  gap: 0.35rem;
+  border: 1px solid transparent;
+  border-radius: 0.52rem;
+  background: transparent;
+  padding: 0.5rem 0.6rem;
+  color: #64748b;
+  font: inherit;
+  font-size: 0.8rem;
+  font-weight: 700;
+  cursor: pointer;
+  transition:
+    background-color 160ms ease,
+    color 160ms ease,
+    border-color 160ms ease,
+    box-shadow 160ms ease;
+}
+
+.image-canvas-editor__workflow-tab:hover {
+  color: #0f172a;
+}
+
+.image-canvas-editor__workflow-tab[aria-selected='true'] {
+  border-color: var(--image-canvas-brand-border);
+  background: #ffffff;
+  color: var(--image-canvas-brand-accent-strong);
+  box-shadow: 0 1px 2px rgba(15, 23, 42, 0.08);
+}
+
+.image-canvas-editor__workflow-tab:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
 .image-canvas-editor__generation-ref {
   display: flex;
   width: auto;
@@ -7249,12 +7298,18 @@ button.image-canvas-editor__reference-chip:disabled {
   width: 8.5rem;
 }
 
-.image-canvas-editor__image-style-toggle {
+.image-canvas-editor__generation-toggles {
   grid-column: 3;
+  display: inline-flex;
+  align-items: center;
+  justify-self: end;
+  gap: 0.65rem;
+}
+
+.image-canvas-editor__image-style-toggle {
   display: inline-flex;
   min-height: 2.25rem;
   align-items: center;
-  justify-self: end;
   gap: 0.38rem;
   padding: 0 0.5rem;
   color: #475569;
@@ -7725,22 +7780,6 @@ button.image-canvas-editor__reference-chip:disabled {
   grid-column: 1 / -1;
 }
 
-.image-canvas-editor__reference-chip--character-sheet
-  .image-canvas-editor__reference-chip-icon {
-  color: #db2777;
-}
-
-.image-canvas-editor__reference-chip--active {
-  border-color: #a5b4fc;
-  background: #eef2ff;
-  color: #3730a3;
-}
-
-button.image-canvas-editor__reference-chip--active:hover:not(:disabled) {
-  border-color: #a5b4fc;
-  background: #e0e7ff;
-}
-
 .image-canvas-editor__publication-composer {
   grid-template-rows: auto auto auto;
 }
@@ -8826,6 +8865,13 @@ button.image-canvas-editor__reference-chip--active:hover:not(:disabled) {
   --auto-grow-editor-max-height: 16rem;
 }
 
+.image-canvas-editor__character-animation-presets-field,
+.image-canvas-editor__character-animation-conversion-resolution-field {
+  display: grid;
+  grid-column: 1 / -1;
+  gap: 0.5rem;
+}
+
 .image-canvas-editor__character-animation-presets {
   display: flex;
   grid-column: 1 / -1;
diff --git a/src/services/image-editor/editorProjectClient.test.ts b/src/services/image-editor/editorProjectClient.test.ts
index f1dbd6f5f..82db62cd1 100644
--- a/src/services/image-editor/editorProjectClient.test.ts
+++ b/src/services/image-editor/editorProjectClient.test.ts
@@ -19,6 +19,7 @@ import {
   EDITOR_SOUND_EFFECT_PROMPT_OPTIMIZE_TIMEOUT_MS,
   extractEditorUiDesignAssets,
   generateEditorBackgroundMusic,
+  convertEditorCharacterAnimationVideo,
   generateEditorCharacterAnimation,
   generateEditorIconSpec,
   generateEditorIconSpritesheet,
@@ -1824,7 +1825,10 @@ describe('editorProjectClient', () => {
       assetLabel: '勇者待机',
     });
 
-    expect(result.taskId).toBe('character-animation-1');
+    expect(result).toMatchObject({
+      resultType: 'ai',
+      taskId: 'character-animation-1',
+    });
     expect(requestJsonMock).toHaveBeenCalledWith(
       '/api/editor/character-animations/generations',
       expect.objectContaining({
@@ -1852,6 +1856,61 @@ describe('editorProjectClient', () => {
     );
   });
 
+  it('converts editor videos without adding AI compatibility fields', async () => {
+    requestJsonMock.mockResolvedValueOnce({
+      taskId: 'video-conversion-1',
+      processingMethod: '视频直接转�',
+      frames: [
+        {
+          imageSrc: '/converted/frame-1.png',
+          width: 640,
+          height: 360,
+        },
+        {
+          imageSrc: '/converted/frame-2.png',
+          width: 640,
+          height: 360,
+        },
+      ],
+      frameCount: 2,
+      durationMs: 2_500,
+      frameWidth: 640,
+      frameHeight: 360,
+      sourceFps: 29.97,
+      samplingFps: 0.8,
+      priceMudPoints: 0,
+    });
+
+    const result = await convertEditorCharacterAnimationVideo({
+      sourceVideoSrc: 'users/user-1/source.mov',
+      resolution: '720p',
+      assetLabel: '视频转��列帧',
+    });
+
+    expect(result).toMatchObject({
+      resultType: 'video-conversion',
+      processingMethod: '视频直接转�',
+      priceMudPoints: 0,
+    });
+    expect(result).not.toHaveProperty('model');
+    expect(result).not.toHaveProperty('prompt');
+    expect(requestJsonMock).toHaveBeenCalledWith(
+      '/api/editor/character-animations/video-conversions',
+      expect.objectContaining({
+        body: JSON.stringify({
+          sourceVideoSrc: 'users/user-1/source.mov',
+          resolution: '720p',
+          assetLabel: '视频转��列帧',
+        }),
+      }),
+      '视频直接转��列帧失败',
+      expect.objectContaining({
+        timeoutMs: 1_200_000,
+        retry: editorRetryOptionsExpectation,
+      }),
+    );
+  });
+
   it('generates editor videos through the backend BFF', async () => {
     requestJsonMock.mockResolvedValueOnce({
       videoSrc: '/generated-editor-videos/video-task-1/preview.mp4',
diff --git a/src/services/image-editor/editorProjectClient.ts b/src/services/image-editor/editorProjectClient.ts
index ecde35534..d83f7850a 100644
--- a/src/services/image-editor/editorProjectClient.ts
+++ b/src/services/image-editor/editorProjectClient.ts
@@ -45,8 +45,12 @@ const EDITOR_UI_DESIGN_ASSET_EXTRACTION_API =
   '/api/editor/ui-designs/assets/extractions';
 const EDITOR_CHARACTER_ANIMATION_GENERATION_API =
   '/api/editor/character-animations/generations';
+const EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_API =
+  '/api/editor/character-animations/video-conversions';
 const EDITOR_CHARACTER_ANIMATION_FRAME_SPLIT_API =
   '/api/editor/character-animations/frame-splits';
+const EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_API =
+  '/api/editor/character-animations/background-removals';
 const EDITOR_VIDEO_GENERATION_API = '/api/editor/videos/generations';
 const EDITOR_SOUND_EFFECT_GENERATION_API =
   '/api/editor/audios/sound-effects/generations';
@@ -213,6 +217,8 @@ export type EditorAssetGenerationInputs = {
     | 'audio.sound-effect.generate'
     | 'audio.background-music.generate'
     | 'character-animation.generate'
+    | 'character-animation.convert'
+    | 'character-animation.remove-background'
     | 'image.edit'
     | 'ui-design.extract-assets'
     | 'image.perfect-pixel'
@@ -226,7 +232,9 @@ export type EditorAssetGenerationInputs = {
 };
 
 export type EditorProjectResourceSourceType =
-  'uploaded' | 'generated' | 'mock_generated';
+  | 'uploaded'
+  | 'generated'
+  | 'mock_generated';
 
 export type EditorProjectResourceSnapshot = {
   resourceId: string;
@@ -342,7 +350,6 @@ export type EditorImageGenerationInput = {
   style?: EditorImageGenerationStyle;
   aspectRatio?: string;
   imageSize?: string;
-  characterSheetViews?: 4 | 8;
   referenceImageSrcs?: string[];
   projectId?: string | null;
   assetKind?: string | null;
@@ -549,7 +556,12 @@ export type EditorCharacterAnimationBackgroundColor =
   | 'purple';
 
 export type EditorCharacterAnimationRatio =
-  'same' | '1:1' | '4:3' | '16:9' | '9:16' | '3:4';
+  | 'same'
+  | '1:1'
+  | '4:3'
+  | '16:9'
+  | '9:16'
+  | '3:4';
 
 export type EditorCharacterAnimationFrameCount = 32 | 40 | 48;
 
@@ -563,6 +575,7 @@ export type EditorCharacterAnimationGenerationInput = {
   sourceHeight?: number;
   referenceMediaType?: 'image' | 'video';
   referenceSrc?: string;
+  appearanceReferenceSrcs?: string[];
   promptText: string;
   backgroundColor?: EditorCharacterAnimationBackgroundColor;
   /** 纯色抠�背景色（hex 或 'auto'），继承生图的背景色选项行为。 */
@@ -576,10 +589,40 @@ export type EditorCharacterAnimationGenerationInput = {
   canvasCompletion?: EditorCanvasGenerationCompletionInput | null;
   generationInputs?: EditorAssetGenerationInputs | null;
   sourceResourceId?: string | null;
+  appearanceSourceResourceIds?: string[];
   assetFolderId?: string | null;
   assetLabel?: string | null;
 };
 
+export type EditorCharacterAnimationVideoConversionInput = {
+  sourceVideoSrc: string;
+  resolution: EditorCharacterAnimationResolution;
+  projectId?: string | null;
+  canvasCompletion?: EditorCanvasGenerationCompletionInput | null;
+  generationInputs?: EditorAssetGenerationInputs | null;
+  sourceResourceId?: string | null;
+  assetFolderId?: string | null;
+  assetLabel?: string | null;
+};
+
+export type EditorCharacterAnimationVideoConversionResult = {
+  resultType: 'video-conversion';
+  taskId: string;
+  processingMethod: '视频直接转�';
+  frames: EditorImageSequenceFrameResult[];
+  frameCount: number;
+  durationMs: number;
+  frameWidth: number;
+  frameHeight: number;
+  sourceFps: number;
+  samplingFps: number;
+  priceMudPoints: 0;
+  project?: EditorProjectSnapshot | null;
+  resource?: EditorProjectResourceSnapshot | null;
+  asset?: EditorAssetSnapshot | null;
+  queueState?: ExternalGenerationJobStatusRecord | null;
+};
+
 export type EditorImageSequenceFrameResult = {
   imageSrc: string;
   objectKey?: string | null;
@@ -588,7 +631,32 @@ export type EditorImageSequenceFrameResult = {
   height: number;
 };
 
+export type EditorCharacterAnimationBackgroundRemovalInput = {
+  projectId: string;
+  sourceLayerId: string;
+  sourceResourceId: string;
+  assetFolderId?: string | null;
+  assetLabel?: string | null;
+  canvasCompletion?: EditorCanvasGenerationCompletionInput | null;
+  generationInputs?: EditorAssetGenerationInputs | null;
+};
+
+export type EditorCharacterAnimationBackgroundRemovalResult = {
+  taskId: string;
+  frames: EditorImageSequenceFrameResult[];
+  frameCount: number;
+  durationMs: number;
+  frameWidth: number;
+  frameHeight: number;
+  priceMudPoints: number;
+  project?: EditorProjectSnapshot | null;
+  resource?: EditorProjectResourceSnapshot | null;
+  asset?: EditorAssetSnapshot | null;
+  queueState?: ExternalGenerationJobStatusRecord | null;
+};
+
 export type EditorCharacterAnimationGenerationResult = {
+  resultType: 'ai';
   taskId: string;
   model: 'seedance2.0-fast';
   prompt: string;
@@ -604,6 +672,10 @@ export type EditorCharacterAnimationGenerationResult = {
   queueState?: ExternalGenerationJobStatusRecord | null;
 };
 
+export type EditorCharacterAnimationResult =
+  | EditorCharacterAnimationGenerationResult
+  | EditorCharacterAnimationVideoConversionResult;
+
 export type EditorCharacterAnimationFrameSplitInput =
   SharedEditorCharacterAnimationFrameSplitInput;
 
@@ -621,7 +693,12 @@ export type EditorVideoModel =
 export type EditorVideoResolution = '480p' | '720p' | '1080p';
 export type EditorVideoSoundMode = 'on' | 'off';
 export type EditorVideoAspectRatio =
-  '16:9' | '9:16' | '1:1' | '4:3' | '3:4' | '21:9';
+  | '16:9'
+  | '9:16'
+  | '1:1'
+  | '4:3'
+  | '3:4'
+  | '21:9';
 
 export type EditorVideoGenerationInput = {
   prompt: string;
@@ -1201,9 +1278,6 @@ export async function generateEditorImage(input: EditorImageGenerationInput) {
       ...(input.style ? { style: input.style } : {}),
       ...(input.aspectRatio ? { aspectRatio: input.aspectRatio } : {}),
       ...(input.imageSize ? { imageSize: input.imageSize } : {}),
-      ...(input.characterSheetViews
-        ? { characterSheetViews: input.characterSheetViews }
-        : {}),
       ...(input.referenceImageSrcs?.length
         ? { referenceImageSrcs: input.referenceImageSrcs }
         : {}),
@@ -1512,7 +1586,17 @@ export async function generateEditorCharacterAnimation(
   if (input.sourceImageSrc) {
     assertStableEditorMediaReference(input.sourceImageSrc, '角色动画�图');
   }
-  return requestJson<EditorCharacterAnimationGenerationResult>(
+  if (input.appearanceReferenceSrcs?.length) {
+    for (const appearanceReferenceSrc of input.appearanceReferenceSrcs) {
+      assertStableEditorMediaReference(
+        appearanceReferenceSrc,
+        '角色外观�考图',
+      );
+    }
+  }
+  const result = await requestJson<
+    Omit<EditorCharacterAnimationGenerationResult, 'resultType'>
+  >(
     EDITOR_CHARACTER_ANIMATION_GENERATION_API,
     jsonRequest('POST', {
       ...input,
@@ -1526,6 +1610,9 @@ export async function generateEditorCharacterAnimation(
       ...(input.sourceResourceId
         ? { sourceResourceId: input.sourceResourceId }
         : {}),
+      ...(input.appearanceSourceResourceIds?.length
+        ? { appearanceSourceResourceIds: input.appearanceSourceResourceIds }
+        : {}),
     }),
     '生�角色动画失败',
     {
@@ -1533,6 +1620,25 @@ export async function generateEditorCharacterAnimation(
       retry: EDITOR_GENERATION_REQUEST_RETRY_OPTIONS,
     },
   );
+  return { ...result, resultType: 'ai' as const };
+}
+
+export async function convertEditorCharacterAnimationVideo(
+  input: EditorCharacterAnimationVideoConversionInput,
+) {
+  assertStableEditorMediaReference(input.sourceVideoSrc, '直接转��视频');
+  const result = await requestJson<
+    Omit<EditorCharacterAnimationVideoConversionResult, 'resultType'>
+  >(
+    EDITOR_CHARACTER_ANIMATION_VIDEO_CONVERSION_API,
+    jsonRequest('POST', input),
+    '视频直接转��列帧失败',
+    {
+      timeoutMs: 1_200_000,
+      retry: EDITOR_GENERATION_REQUEST_RETRY_OPTIONS,
+    },
+  );
+  return { ...result, resultType: 'video-conversion' as const };
 }
 
 export async function splitEditorCharacterAnimationFrames(
@@ -1546,6 +1652,32 @@ export async function splitEditorCharacterAnimationFrames(
   );
 }
 
+export async function removeEditorCharacterAnimationBackground(
+  input: EditorCharacterAnimationBackgroundRemovalInput,
+) {
+  return requestJson<EditorCharacterAnimationBackgroundRemovalResult>(
+    EDITOR_CHARACTER_ANIMATION_BACKGROUND_REMOVAL_API,
+    jsonRequest('POST', {
+      projectId: input.projectId,
+      sourceLayerId: input.sourceLayerId,
+      sourceResourceId: input.sourceResourceId,
+      ...(input.assetFolderId ? { assetFolderId: input.assetFolderId } : {}),
+      ...(input.assetLabel ? { assetLabel: input.assetLabel } : {}),
+      ...(input.canvasCompletion
+        ? { canvasCompletion: input.canvasCompletion }
+        : {}),
+      ...(input.generationInputs
+        ? { generationInputs: input.generationInputs }
+        : {}),
+    }),
+    '去除�列帧背景失败',
+    {
+      timeoutMs: 1_200_000,
+      retry: EDITOR_GENERATION_REQUEST_RETRY_OPTIONS,
+    },
+  );
+}
+
 export async function generateEditorVideo(input: EditorVideoGenerationInput) {
   assertStableEditorVideoReferences(input);
   return requestJson<EditorVideoGenerationResponse>(