diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 10c4f2756..7fb0ad280 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -2367,10 +2367,10 @@
 - 验证方式：`npm run test -- src/components/image-editor/ImageCanvasEditorModel.test.ts src/components/image-editor/useCanvasGenerationDialogs.test.tsx src/components/image-editor/useImageCanvasProjectPersistence.test.tsx src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx src/components/image-editor/ImageCanvasWorldView.test.tsx src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx`、`npm run typecheck`、`npm run check:encoding`、`git diff --check`、浏览器刷新 smoke。
 - 关联文档：`docs/【编辑器】生成类面板Lovart统一改造方案-2026-06-17.md`、`docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md`。
 
-## 2026-06-18 编辑器画板音效参数与待生成占位类型化
+## 2026-06-18 编辑器画板音效待生成占位类型化
 
 - 背景：`/editor/canvas` 新建视频、角色形象、音效和背景音乐待生成对象时沿用图片占位 icon，音效面板仍把 `type` 与 `tempo` 分成两个旧字符串选项，不符合 Lovart 式简洁参数按钮和 BPM 输入需求。
-- 决策：画布待生成占位按生成器模式渲染专属空白样式、icon 与右上角标签：视频、角色、音效、背景音乐不再统一使用图片 icon；角标继续按 viewport 反向缩放。编辑器音效请求契约改为 `type: "one-shot" | "loop"` 与 `tempo: number | null`，BPM 范围 `1-300`，默认 `null`；前端底部只保留一个无标题音效参数按钮，组合显示如 `单次·120BPM`。
+- 决策：画布待生成占位按生成器模式渲染专属空白样式、icon 与右上角标签：视频、角色、音效、背景音乐不再统一使用图片 icon；角标继续按 viewport 反向缩放。原计划中的 `type + tempo/BPM` 音效参数已在 2026-06-19 被 Vidu `prompt + duration` 契约替代，后续不要再恢复 `单次·120BPM` 入口。
 - 影响范围：`src/components/image-editor/ImageCanvasWorldView.tsx`、`ImageCanvasGenerationComposerView.tsx`、`ImageCanvasEditorTypes.ts`、`ImageCanvasGenerationSubmissionModel.ts`、`src/services/image-editor/editorProjectClient.ts`、`server-rs/crates/shared-contracts/src/assets.rs`、`server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs`、`server-rs/crates/platform-audio/src/request.rs`。
 - 验证方式：`npx vitest run src/components/image-editor/ImageCanvasWorldView.test.tsx src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts src/components/image-editor/ImageCanvasEditorModel.test.ts src/components/image-editor/ImageCanvasGenerationModel.test.ts src/services/image-editor/editorProjectClient.test.ts --reporter verbose`、`cargo test -p shared-contracts --manifest-path server-rs/Cargo.toml`、`cargo test -p platform-audio --manifest-path server-rs/Cargo.toml`、`cargo test -p api-server editor_sound_effect --manifest-path server-rs/Cargo.toml`。
 
@@ -2380,3 +2380,10 @@
 - 决策：点击已生成角色图只选中图层并显示浮动工具栏，不自动弹出重绘、快速编辑或角色动画面板。点击工具栏或右键菜单的 `生成动画` 后，创建 `mode="character-animation"` 的画布 generation dialog，占位走统一避让落点与视口居中；占位使用角色动作 icon、橙色动作配色和右上角 `动作` 标签。角色动画参数面板复用原内容，但作为统一 generation composer 跟随占位底部，宽度对齐图片生成面板。提交成功后以首帧创建 `assetKind="character-animation"` 的角色动作图片图层，右上角标签显示 `动作`。
 - 影响范围：`src/components/image-editor/useImageCanvasGenerationWorkflow.ts`、`useImageCanvasGenerationSurface.tsx`、`ImageCanvasCharacterAnimationPanelView.tsx`、`ImageCanvasWorldView.tsx`、`ImageCanvasGenerationLayerModel.ts`、`useImageCanvasGenerationSubmissionWorkflow.ts`、`src/index.css`。
 - 验证方式：`npx vitest run src/components/image-editor/ImageCanvasWorldView.test.tsx src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx --reporter=dot`、`npx vitest run src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx -t "character animation" --reporter=dot`。
+
+## 2026-06-19 编辑器游戏音效默认改用 Vidu 文生音频
+
+- 背景：VectorEngine Apifox `创建文生音频任务` 文档明确 Vidu `/ent/v2/text2audio` 请求体使用 `model: "audio1.0"`、`prompt`、`duration` 和可选 `seed`；编辑器此前把游戏音效提交到 Suno `task: "sound"`，与当前游戏音效默认模型要求不一致。
+- 决策：`/editor/canvas` 的 `生成游戏音效` 入口继续保留，但默认且暂时唯一可用模型为 Vidu `audio1.0`，前端请求固定发送 `prompt`、`model: "audio1.0"`、`duration` 和 `priceMudPoints`，面板只显示 `Vidu` 与 `2-10` 秒时长选项，默认 `5` 秒；不再发送或展示 `sound`、`type`、`tempo`、BPM 或 Suno 文生音效入口。后端 `/api/editor/audios/sound-effects/generations` 只接受空模型或 `audio1.0`，拒绝 Suno / `chirp-*`；提交和轮询改走 Vidu `/ent/v2/text2audio` 与 `/ent/v2/tasks/{taskId}/creations`。背景音乐仍保留 Suno `/suno/submit/music`、`/suno/fetch/{taskId}` 和 wav clip 兜底逻辑。
+- 影响范围：`server-rs/crates/platform-audio`、`server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs`、`server-rs/crates/shared-contracts/src/assets.rs`、`src/services/image-editor/editorProjectClient.ts`、`src/components/image-editor/ImageCanvasGeneration*`。
+- 验证方式：`cargo test -p platform-audio --manifest-path server-rs/Cargo.toml --test vector_engine_audio`、`cargo test -p api-server --manifest-path server-rs/Cargo.toml editor_sound_effect`、`cargo test -p shared-contracts --manifest-path server-rs/Cargo.toml editor_audio_requests_and_response_use_canvas_audio_shape`、`npx vitest run src/services/image-editor/editorProjectClient.test.ts src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx src/components/image-editor/ImageCanvasGenerationModel.test.ts --reporter=dot`。
diff --git a/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md b/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
index 3b9088964..300e045dd 100644
--- a/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
+++ b/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
@@ -2,7 +2,7 @@
 
 ## 目标
 
-在 Web 图片画布编辑器底部工具栏新增 `宣发素材` 分组入口，用于生成游戏发布物料。点击具体工作流后，不打开说明弹窗，而是在画布内创建一个可拖拽的宣发素材生成卡片；卡片包含游戏名、游戏分类、一句话描述游戏三个输入框、参考图控件、尺寸信息和生成按钮。点击生成后走图片画布现有生图 BFF，自动扣 5 泥点，生成成功后把成品图片放回画布。
+在 Web 图片画布编辑器底部工具栏新增 `宣发素材` 分组入口，用于生成游戏发布物料。点击具体工作流后，不打开说明弹窗，而是在画布内创建一个可拖拽的宣发素材生成卡片；卡片包含游戏名、游戏分类、一句话描述游戏三个输入框、参考图控件、尺寸信息和生成按钮。点击生成后走图片画布现有生图 BFF，按当前图片模型计费方案自动扣泥点，生成成功后把成品图片放回画布。
 
 Prompt 输入摘要与 Prompt 约束只作为内部生成契约维护，不在 UI 中默认暴露；真实生图请求会把结构化游戏输入和对应工作流约束合并为内部 Prompt。
 
@@ -12,8 +12,9 @@ Prompt 输入摘要与 Prompt 约束只作为内部生成契约维护，不在 U
 
 - 页面：`/editor/canvas`
 - 位置：底部 AI 画布工具栏
-- 工具：`宣发素材`
+- 工具：`宣发素材`，位于底部工具栏 `生成UI设计图` 按钮右侧。
 - 交互：点击工具后弹出独立浮层菜单，菜单项包括 `游戏首图`、`详情五图`、`运营海报`；点击菜单项后在画布中心创建对应工作流的生成占位卡片，卡片可拖拽，设置面板锚定在占位卡片下方。
+- 设置面板：三个工作流统一对齐生成角色面板结构，顶部为参考图横向槽，主体为游戏名、游戏分类、一句话描述游戏输入区，底部复用生成类面板的模型选择与生成按钮；生成按钮内显示当前模型对应泥点。
 - 标题：画布占位卡片左上角使用英文功能名，例如 `Home Image Generator`、`Detail Gallery Generator`、`Promo Poster Generator`，与其它生成卡片保持一致。
 
 ## 三条独立工作流
@@ -42,8 +43,8 @@ Prompt 输入摘要与 Prompt 约束只作为内部生成契约维护，不在 U
 本功能边界只负责图片编辑器里的宣发素材生成：
 
 - 可以维护：工作流框架、Prompt 约束、参考图解析约束、图片后处理验收约束。
-- 已落地：画布内生成占位卡片、游戏名 / 游戏分类 / 一句话描述游戏结构化输入、参考图上传 / 从画布选择、尺寸标识、真实生图、5 泥点扣费、成品回画布。
-- 详情五图：当前 UI 只有一个生成卡片，一次生成 1 张 `720 x 1280` 竖版详情图，单次扣 5 泥点；需要五图时连续生成并复用同一游戏输入和参考图。
+- 已落地：画布内生成占位卡片、游戏名 / 游戏分类 / 一句话描述游戏结构化输入、参考图上传 / 从画布选择、尺寸标识、真实生图、按图片模型计费、成品回画布。
+- 详情五图：当前 UI 只有一个生成卡片，一次生成 1 张 `720 x 1280` 竖版详情图，单次按当前图片模型计费；需要五图时连续生成并复用同一游戏输入和参考图。
 - 不在 UI 暴露：Prompt 输入摘要、Prompt 约束预览、内部提示词拼接过程。
 - 暂不实现：作品发布状态、审核、分享渠道、远程 Genarrative 接口、作品架或广场能力。
 - 不修改：SpacetimeDB schema、前端发布页、作品发布系统。
@@ -51,7 +52,7 @@ Prompt 输入摘要与 Prompt 约束只作为内部生成契约维护，不在 U
 ## 生成与计费
 
 - 前端生成请求统一通过 `/api/editor/images/generations`。
-- 宣发素材请求携带 `kind: publication-material`，后端仅对这个 kind 扣 5 泥点。
+- 宣发素材请求携带 `kind: publication-material` 与当前图片模型，后端对这个 kind 按归一后的图片模型计费方案扣泥点，不再使用固定价格。
 - `publication-detail-gallery` 不再携带 `candidateCount: 5`；后端仍兼容多候选请求，但当前宣发素材入口不主动批量生成。
 - 尺寸请求必须使用明确像素值：游戏首图 `720x540`、详情图 `720x1280`、运营海报 `1280x720`。VectorEngine 适配层对明确像素值保持原样透传；只有 `16:9`、`9:16`、`2k` 等比例 / 档位别名才走 provider 预设映射。
 - 参考图在提交 `/api/editor/images/generations` 前由前端压缩成适合生成理解的图片 Data URL，避免原图 Data URL 撑爆 JSON 请求体；后端该路由保留 `12MB` body limit 作为兼容兜底。
diff --git a/docs/【编辑器】生成类面板Lovart统一改造方案-2026-06-17.md b/docs/【编辑器】生成类面板Lovart统一改造方案-2026-06-17.md
index e14040adf..a7a88bf1b 100644
--- a/docs/【编辑器】生成类面板Lovart统一改造方案-2026-06-17.md
+++ b/docs/【编辑器】生成类面板Lovart统一改造方案-2026-06-17.md
@@ -85,6 +85,10 @@
 - 入口状态：新入口打开后设置对应 activeTool，清空画布选中、右键菜单、快速编辑、角色动画和其它生成来源选择状态；只切换当前面板，不删除已有生成占位。
 - 生成中的占位图允许通过键盘 `Delete` / `Backspace` 删除；不额外增加画布上的可见删除按钮。用户删除后，后续异步成功或失败回写不得重新创建该生成对象。
 - 待生成占位的空白样式按生成类型区分：视频使用视频图标和视频角标，角色形象使用角色图标和角色角标，角色动作使用角色动作图标和动作角标，音效使用音效图标和音效角标，背景音乐使用音乐图标和背景音乐角标。
+- 待生成占位的图标语义必须与底部入口或触发入口保持一致：生成图片用图片图标，生成规范用规范图标，生成角色形象用角色图标，生成图标素材用图标网格，生成 UI 设计图用应用窗口，宣发素材用宣发图标，快速编辑用闪光图标，不能默认全部回退为图片图标。
+- 图片类待生成占位尺寸必须与面板当前比例和尺寸同步：普通图片、角色形象、图标素材、UI 设计图按当前 `aspectRatio + imageSize` 计算像素尺寸；生成规范固定为 `16:9 · 2K`，占位为 `2048 x 1152`；宣发素材按 workflow 输出尺寸创建占位。
+- 视频待生成占位必须与面板当前比例和清晰度同步：默认 `16:9 · 480p` 为 `854 x 480`，切换到 `720p` 后同步为 `1280 x 720`；调整参数时保持占位中心点不变。
+- 面板中用户修改比例、尺寸或清晰度后，已有空白待生成占位立即同步更新 `width / height / originalWidth / originalHeight`，且保持中心点不跳动。
 - 快速编辑点击生成后不在原图上播放生成中遮罩，而是立即创建独立 `Quick Edit Generator` 画布生成占位并播放生成中动画；生成成功后结果落在该占位框位置，失败时占位标记失败并恢复快速编辑面板。
 
 ## 画布悬浮信息
@@ -162,6 +166,7 @@
 - 生成中的占位图聚焦后可用 `Delete` / `Backspace` 删除；删除后异步结果不再落回画布，也不显示额外删除 UI。
 - 快速编辑生成中的占位图同样只支持键盘 `Delete` / `Backspace` 删除，不新增 UI 删除按钮；删除后异步结果不得再落回画布。
 - 生成视频 / 角色形象 / 角色动作 / 音效 / 背景音乐新建后，画布占位空白样式和右上角标签均与对应生成类型一致，不再统一使用图片占位 icon。
+- 新建空白待生成占位的尺寸必须和面板参数一致；图片类修改比例 / 尺寸、视频修改清晰度后，画布空白占位同步变更且保持中心点。
 - 点击角色图只选中图层并显示工具栏，不自动弹出重绘、快速编辑或角色动画面板；点击工具栏或右键菜单中的 `生成动画` 才创建角色动作占位和面板。
 - 点击 UI 设计图只选中图层并显示工具栏；工具栏在 `去除背景按钮` 后显示 `提取素材`，点击后固定用 `gpt-image-2` 和提示词 `提取画面中的所有独立并整理成spritesheet` 生成 spritesheet，再复用图标素材拆分流程，把 spritesheet 图集和拆分素材都放到画布。
 - 生成游戏音效面板底部不显示 `type` / `tempo` 字段标题，只有一个音效参数按钮；type 只支持 `one-shot` / `loop`，BPM 为 `1-300` 的数字或 `null`，选择后按钮显示 `单次·120BPM` 这类组合值。
diff --git a/docs/【编辑器】画板音乐生成入口设计-2026-06-18.md b/docs/【编辑器】画板音乐生成入口设计-2026-06-18.md
index 5997df3b1..777ba88f0 100644
--- a/docs/【编辑器】画板音乐生成入口设计-2026-06-18.md
+++ b/docs/【编辑器】画板音乐生成入口设计-2026-06-18.md
@@ -20,11 +20,10 @@
 
 ### 生成游戏音效
 
-- `sound`：用户输入的音效提示词。
-- `type`：合成选项，只支持 `one-shot` / `loop`；UI 显示为 `单次` / `循环`，不展示字段标题。
-- `tempo`：可空 BPM 数值；默认不填为 `null`，用户可通过拖拉条或数字输入设置，范围 `1-300`。
-- `type` 与 `tempo` 合并为一个 Lovart 式底部参数按钮；无 BPM 时按钮显示 `单次` / `循环`，有 BPM 时显示 `单次·120BPM` 这类组合值。
-- 提交到 VectorEngine 时映射为 Suno 音效模式字段：`mv`、`task: "sound"`、`metadata_params.sound`、`metadata_params.type`、`metadata_params.tempo`、`metadata_params.key: null`。`mv` 后端固定使用默认 Suno 模型，不在 UI 中展示。
+- `prompt`：用户输入的音效提示词，直接作为 Vidu 文生音频请求的 `prompt` 字段。
+- `model`：固定默认 `audio1.0`，UI 显示为 `Vidu`；暂不展示 Suno 文生音效模型入口。
+- `duration`：Vidu 音频时长，UI 以一个无标题参数按钮展示，选项范围 `2-10` 秒，默认 `5` 秒。
+- 提交到 VectorEngine 时映射为 Vidu 文生音频字段：`model: "audio1.0"`、`prompt`、`duration`、可选 `seed`。当前编辑器音效固定使用 Vidu `audio1.0`，不再走 Suno `task: "sound"` / `metadata_params` 文生音效契约。
 
 ### 生成游戏背景音乐
 
@@ -43,12 +42,14 @@
 - 新增素材类型：
   - `assetKind="sound-effect"`
   - `assetKind="background-music"`
-- 音频结果以小型音频卡加入画布，卡片内使用 `<audio controls>` 播放；音频结果当前只保存为画布资源，不进入图片素材库。
-- 音频结果卡片显示用户提示词和 `时长 mm:ss`；如果上游暂未返回时长，先显示 `时长 --:--`，并在 `<audio>` 元数据加载后用真实 duration 兜底。
+- 音频结果以小型音频卡加入画布，卡片底部使用 `<audio controls>` 播放；音频结果当前只保存为画布资源，不进入图片素材库。
+- 音频结果卡片底部显示用户提示词与播放控件，不在卡片左下角或悬停左上角展示时长。
+- 音频卡片中央播放区按状态切换：未悬停且未播放时显示音效 / 背景音乐图标，悬停且未播放时显示播放按钮，播放中始终显示暂停按钮。
 - generated 私有音频资源播放前必须通过 `/api/assets/read-url` 换签；画布卡片不得直接把 `/generated-*` 或 generated OSS 私有地址交给 `<audio>` 裸请求。
-- 音频卡片、音频生成占位和元数据弹窗都使用 `时长`，不使用图片 / 视频的分辨率语义。
+- 音频元数据弹窗使用 `时长`，不使用图片 / 视频的分辨率语义；音频生成占位不显示分辨率或时长角标。
 - 音频图层右上角标签显示在信息按钮左侧，和其他素材卡右上角信息区保持一致。
 - 元数据弹窗按音频显示 `音频信息` / `音频类型` / `时长`，生成输入快照只展示用户面板字段。
+- 音频图层上方浮动工具栏只保留 `改造` 和 `下载按钮`。点击 `改造` 后打开对应的音效或背景音乐生成面板，不展示参考图组件；面板底部模型与参数位置和原生成入口一致，并允许继续修改后再次生成，新结果落在原音频旁边。
 
 ## 前端提交契约
 
@@ -57,9 +58,9 @@
 ```ts
 POST /api/editor/audios/sound-effects/generations
 {
-  sound: string,
-  type: "one-shot" | "loop",
-  tempo: number | null,
+  prompt: string,
+  model: "audio1.0",
+  duration: number,
   priceMudPoints: 10
 }
 ```
@@ -99,10 +100,9 @@ POST /api/editor/audios/background-music/generations
 - 在 `platform-audio` 增加编辑器专用 body builder 和 submit 函数：
   - 背景音乐 body 使用 `mv`、`gpt_description_prompt`、`make_instrumental`。
   - Suno 音乐接口路径固定为 `/suno/submit/music`；`VECTOR_ENGINE_BASE_URL` 即使配置为带 `/v1` 的图片接口根，也要在 `platform-audio` 中归一为根路径后再拼接，避免误请求 `/v1/suno/submit/music`。
-  - 音效 body 使用 Suno 音效契约：`mv`、`task: "sound"`、`metadata_params`，其中 `metadata_params.tempo` 是 `1-300` 的 BPM 或 `null`，`metadata_params.key` 固定 `null`。
-  - 编辑器音效提交和轮询都使用 Suno 路径，提交 `/suno/submit/music`，查询 `/suno/fetch/{taskId}`；旧 Vidu `/ent/v2/text2audio` 仅保留给历史视觉小说音效链路。
-  - Suno 提交成功后的任务 ID 兼容从 `data` 字符串、`data.task_id`、`data.taskId`、`data.id`、`task_id`、`taskId`、`id` 中读取，避免音效接口只返回 `data` 时误报“上游未返回任务 ID”。
-  - Suno 查询结果可能不直接返回音频 URL，而是在 `data` 中返回歌曲 / 音效 clip id；后端必须兼容 `data` 字符串、对象或数组中的 `id` / `clip_id` / `audioId` / `songId`，再调用 `/suno/act/wav/{clipId}` 提取 `wav_file_url` 等可下载地址。若已拿到 clip id 但 wav 地址仍未就绪，或 wav 子请求临时返回上游错误，继续按 `processing` 轮询，不要直接报“尚未返回可下载地址”或“获取 Suno 音效 wav 失败”。
+  - 音效 body 使用 Vidu 文生音频契约：提交 `/ent/v2/text2audio`，请求体包含 `model: "audio1.0"`、`prompt`、`duration` 和可选 `seed`；`model` 和 `prompt` 为必填，`prompt` 最长 1500 字符，`duration` 按 Vidu 文档限制在 `2-10` 秒。
+  - 编辑器音效轮询使用 Vidu 路径 `/ent/v2/tasks/{taskId}/creations`，不再使用 Suno `/suno/fetch/{taskId}`；Suno 文生音效 `task: "sound"` 暂不从编辑器入口暴露。
+  - Suno 提交成功后的任务 ID 兼容与 wav clip 轮询逻辑只保留给背景音乐链路，避免误伤 `/api/editor/audios/background-music/generations`。
   - VectorEngine 音频响应的 `code` 需要兼容 `"success"`、`"ok"`、`"0"`、`"200"` 以及数字 `0` / `200`；HTTP 非 2xx 时后端错误信息应透出安全的上游状态和短响应摘要，避免前端只显示笼统提交失败。
 - 在 `api-server` 增加编辑器音频 BFF：
   - `/api/editor/audios/sound-effects/generations`
@@ -113,11 +113,14 @@ POST /api/editor/audios/background-music/generations
 
 - 底部工具栏显示 `生成音乐`。
 - 点击 `生成音乐` 只出现选项框，不立刻创建占位。
-- 点击 `生成游戏音效` 后出现音效面板，文本字段为 `sound`；底部只有一个无标题音效参数按钮，内部合并 `type` 和 BPM。
-- 音效参数只提供 `单次(one-shot)`、`循环(loop)`，BPM 支持拖拉条和数字输入，范围 `1-300`，不填时提交 `tempo: null`。
+- 点击 `生成游戏音效` 后出现音效面板，文本字段为 `prompt`；底部只有一个无标题时长参数按钮。
+- 音效时长只提供 `2-10` 秒选项，默认 `5` 秒，提交到 BFF 的字段为 `duration`。
+- 音效面板模型显示 `Vidu`，提交 `model: "audio1.0"`；不显示 Suno 文生音效模型或 Suno 音效入口。
 - 点击 `生成游戏背景音乐` 后出现背景音乐面板，字段为 `gpt_description_prompt`，不展示 `make_instrumental`。
 - 音效提交到 `/api/editor/audios/sound-effects/generations`，背景音乐提交到 `/api/editor/audios/background-music/generations`。
 - 成功后画布新增音频卡，能通过 `<audio controls>` 播放。
-- 成功后的音频卡展示提示词；卡片、悬停角标、信息弹窗和待生成占位均显示时长。
+- 成功后的音频卡展示提示词；卡片中央按未悬停图标、悬停播放、播放中暂停切换，播放控件固定在卡片底部。
+- 音频卡片、悬停角标和待生成占位不显示时长；信息弹窗显示时长。
+- 音频素材浮动工具栏只显示 `改造` 与 `下载按钮`，`改造` 复用对应生成面板且没有参考图组件。
 - 私有 generated 音频能先换签再预览播放，不出现播放条一直为 `0:00` 的裸路径失败状态。
 - 刷新后 layout 能恢复音频生成器和音频图层。
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 28e98167a..faf24d2d9 100644
--- a/server-rs/crates/api-server/src/character_animation_assets.rs
+++ b/server-rs/crates/api-server/src/character_animation_assets.rs
@@ -2312,10 +2312,12 @@ fn normalize_editor_character_animation_request(
     let frame_count = normalize_editor_character_animation_frame_count(payload.frame_count)?;
     let duration_seconds =
         normalize_editor_character_animation_duration(payload.duration_seconds, frame_count)?;
-    let expected_price = crate::editor_generation_config::editor_character_animation_mud_points(
-        resolution,
-        duration_seconds,
-    );
+    let expected_price =
+        crate::editor_generation_config::editor_character_animation_model_mud_points(
+            Some(payload.model.as_str()),
+            resolution,
+            duration_seconds,
+        );
     if payload.price_mud_points != expected_price {
         return Err(editor_character_animation_bad_request(format!(
             "priceMudPoints 与分辨率和时长不一致，应为 {expected_price}。"
@@ -2413,7 +2415,8 @@ fn normalize_editor_video_request(
     if payload.sound.trim() != "off" {
         return Err(editor_video_bad_request("sound 只支持 off。"));
     }
-    let expected_price = crate::editor_generation_config::editor_video_generation_mud_points(
+    let expected_price = crate::editor_generation_config::editor_video_model_generation_mud_points(
+        Some(model),
         resolution,
         duration_seconds,
     );
diff --git a/server-rs/crates/api-server/src/editor_generation_config.rs b/server-rs/crates/api-server/src/editor_generation_config.rs
index e16c7deb2..e84fc5382 100644
--- a/server-rs/crates/api-server/src/editor_generation_config.rs
+++ b/server-rs/crates/api-server/src/editor_generation_config.rs
@@ -2,12 +2,10 @@
 ///
 /// 中文注释：先用 api-server 静态配置收口价格事实源，避免继续把价格散落在
 /// 前端常量和具体 handler 内；后续若接后台配置，可只替换本模块读取来源。
-const EDITOR_IMAGE_GENERATION_MUD_POINTS: u32 = 12;
-const EDITOR_SPEC_GENERATION_MUD_POINTS: u32 = 5;
-const EDITOR_CHARACTER_IMAGE_GENERATION_MUD_POINTS: u32 = 12;
-const EDITOR_ICON_SPRITESHEET_GENERATION_MUD_POINTS: u32 = 12;
-const EDITOR_UI_DESIGN_GENERATION_MUD_POINTS: u32 = 12;
-const EDITOR_PUBLICATION_MATERIAL_GENERATION_MUD_POINTS: u32 = 5;
+const EDITOR_IMAGE_MODEL_GPT_IMAGE_2: &str = "gpt-image-2";
+const EDITOR_IMAGE_MODEL_NANOBANANA2: &str = "gemini-3.1-flash-image-preview";
+const EDITOR_IMAGE_MODEL_GENERATION_MUD_POINTS: u32 = 12;
+const EDITOR_SPEC_MODEL_GPT_IMAGE_2_MUD_POINTS: u32 = 5;
 
 pub(crate) const EDITOR_VIDEO_GENERATION_480P_MUD_POINTS_PER_SECOND: u32 = 10;
 pub(crate) const EDITOR_VIDEO_GENERATION_720P_MUD_POINTS_PER_SECOND: u32 = 20;
@@ -15,23 +13,98 @@ pub(crate) const EDITOR_VIDEO_GENERATION_720P_MUD_POINTS_PER_SECOND: u32 = 20;
 pub(crate) const EDITOR_CHARACTER_ANIMATION_480P_MUD_POINTS_PER_SECOND: u32 = 10;
 pub(crate) const EDITOR_CHARACTER_ANIMATION_720P_MUD_POINTS_PER_SECOND: u32 = 20;
 
-pub(crate) fn editor_image_generation_mud_points(kind: Option<&str>) -> u32 {
-    match kind.map(str::trim) {
-        Some("spec") => EDITOR_SPEC_GENERATION_MUD_POINTS,
-        Some("character") => EDITOR_CHARACTER_IMAGE_GENERATION_MUD_POINTS,
-        Some("icon") => EDITOR_ICON_SPRITESHEET_GENERATION_MUD_POINTS,
-        Some("ui-design") => EDITOR_UI_DESIGN_GENERATION_MUD_POINTS,
-        Some("publication-material") => EDITOR_PUBLICATION_MATERIAL_GENERATION_MUD_POINTS,
-        _ => EDITOR_IMAGE_GENERATION_MUD_POINTS,
+const EDITOR_VIDEO_MODEL_SEEDANCE_2: &str = "seedance2.0";
+const EDITOR_VIDEO_MODEL_SEEDANCE_2_FAST: &str = "seedance2.0-fast";
+const EDITOR_VIDEO_MODEL_KLING_3: &str = "kling3.0";
+const EDITOR_VIDEO_MODEL_KLING_3_OMNI: &str = "kling3.0-omni";
+const EDITOR_VIDEO_MODEL_VEO_3_1: &str = "veo3.1";
+const EDITOR_VIDEO_MODEL_VEO_3_1_FAST: &str = "veo3.1-fast";
+const EDITOR_CHARACTER_ANIMATION_MODEL_SEEDANCE_2_FAST: &str = "seedance2.0-fast";
+pub(crate) const EDITOR_SOUND_EFFECT_MODEL_VIDU: &str = "audio1.0";
+pub(crate) const EDITOR_BACKGROUND_MUSIC_MODEL_SUNO: &str = "chirp-v5";
+const EDITOR_SOUND_EFFECT_MODEL_VIDU_MUD_POINTS: u32 = 10;
+const EDITOR_BACKGROUND_MUSIC_MODEL_SUNO_MUD_POINTS: u32 = 5;
+
+pub(crate) fn editor_image_model_generation_mud_points(model: Option<&str>) -> u32 {
+    match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(EDITOR_IMAGE_MODEL_GPT_IMAGE_2) | Some(EDITOR_IMAGE_MODEL_NANOBANANA2) => {
+            EDITOR_IMAGE_MODEL_GENERATION_MUD_POINTS
+        }
+        _ => EDITOR_IMAGE_MODEL_GENERATION_MUD_POINTS,
     }
 }
 
-pub(crate) fn editor_video_generation_mud_points(resolution: &str, duration_seconds: u32) -> u32 {
+pub(crate) fn editor_spec_model_generation_mud_points(model: Option<&str>) -> u32 {
+    match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(EDITOR_IMAGE_MODEL_GPT_IMAGE_2) => EDITOR_SPEC_MODEL_GPT_IMAGE_2_MUD_POINTS,
+        _ => EDITOR_SPEC_MODEL_GPT_IMAGE_2_MUD_POINTS,
+    }
+}
+
+pub(crate) fn editor_image_generation_mud_points(kind: Option<&str>, model: Option<&str>) -> u32 {
+    match kind.map(str::trim) {
+        Some("spec") => editor_spec_model_generation_mud_points(model),
+        Some("character" | "icon" | "ui-design" | "publication-material") => {
+            editor_image_model_generation_mud_points(model)
+        }
+        _ => editor_image_model_generation_mud_points(model),
+    }
+}
+
+fn editor_video_model_resolution_mud_points_per_second(
+    model: Option<&str>,
+    resolution: &str,
+) -> u32 {
+    let _normalized_model = match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(
+            EDITOR_VIDEO_MODEL_SEEDANCE_2
+            | EDITOR_VIDEO_MODEL_SEEDANCE_2_FAST
+            | EDITOR_VIDEO_MODEL_KLING_3
+            | EDITOR_VIDEO_MODEL_KLING_3_OMNI
+            | EDITOR_VIDEO_MODEL_VEO_3_1
+            | EDITOR_VIDEO_MODEL_VEO_3_1_FAST,
+        ) => model.unwrap_or_default().trim(),
+        _ => EDITOR_VIDEO_MODEL_SEEDANCE_2_FAST,
+    };
     let per_second = if resolution == "720p" {
         EDITOR_VIDEO_GENERATION_720P_MUD_POINTS_PER_SECOND
     } else {
         EDITOR_VIDEO_GENERATION_480P_MUD_POINTS_PER_SECOND
     };
+    per_second
+}
+
+pub(crate) fn editor_video_model_generation_mud_points(
+    model: Option<&str>,
+    resolution: &str,
+    duration_seconds: u32,
+) -> u32 {
+    let per_second = editor_video_model_resolution_mud_points_per_second(model, resolution);
+    per_second * duration_seconds
+}
+
+pub(crate) fn editor_video_generation_mud_points(resolution: &str, duration_seconds: u32) -> u32 {
+    let per_second =
+        editor_video_model_resolution_mud_points_per_second(None, resolution);
+    per_second * duration_seconds
+}
+
+pub(crate) fn editor_character_animation_model_mud_points(
+    model: Option<&str>,
+    resolution: &str,
+    duration_seconds: u32,
+) -> u32 {
+    let _normalized_model = match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(EDITOR_CHARACTER_ANIMATION_MODEL_SEEDANCE_2_FAST) => {
+            EDITOR_CHARACTER_ANIMATION_MODEL_SEEDANCE_2_FAST
+        }
+        _ => EDITOR_CHARACTER_ANIMATION_MODEL_SEEDANCE_2_FAST,
+    };
+    let per_second = if resolution == "720p" {
+        EDITOR_CHARACTER_ANIMATION_720P_MUD_POINTS_PER_SECOND
+    } else {
+        EDITOR_CHARACTER_ANIMATION_480P_MUD_POINTS_PER_SECOND
+    };
     per_second * duration_seconds
 }
 
@@ -39,12 +112,23 @@ pub(crate) fn editor_character_animation_mud_points(
     resolution: &str,
     duration_seconds: u32,
 ) -> u32 {
-    let per_second = if resolution == "720p" {
-        EDITOR_CHARACTER_ANIMATION_720P_MUD_POINTS_PER_SECOND
-    } else {
-        EDITOR_CHARACTER_ANIMATION_480P_MUD_POINTS_PER_SECOND
-    };
-    per_second * duration_seconds
+    editor_character_animation_model_mud_points(None, resolution, duration_seconds)
+}
+
+pub(crate) fn editor_sound_effect_model_generation_mud_points(model: Option<&str>) -> u32 {
+    match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(EDITOR_SOUND_EFFECT_MODEL_VIDU) => EDITOR_SOUND_EFFECT_MODEL_VIDU_MUD_POINTS,
+        _ => EDITOR_SOUND_EFFECT_MODEL_VIDU_MUD_POINTS,
+    }
+}
+
+pub(crate) fn editor_background_music_model_generation_mud_points(model: Option<&str>) -> u32 {
+    match model.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(EDITOR_BACKGROUND_MUSIC_MODEL_SUNO) => {
+            EDITOR_BACKGROUND_MUSIC_MODEL_SUNO_MUD_POINTS
+        }
+        _ => EDITOR_BACKGROUND_MUSIC_MODEL_SUNO_MUD_POINTS,
+    }
 }
 
 #[cfg(test)]
@@ -64,15 +148,68 @@ mod tests {
     }
 
     #[test]
-    fn editor_image_generation_price_uses_configured_kind_rates() {
-        assert_eq!(editor_image_generation_mud_points(None), 12);
-        assert_eq!(editor_image_generation_mud_points(Some("spec")), 5);
-        assert_eq!(editor_image_generation_mud_points(Some("character")), 12);
-        assert_eq!(editor_image_generation_mud_points(Some("icon")), 12);
-        assert_eq!(editor_image_generation_mud_points(Some("ui-design")), 12);
+    fn editor_video_generation_price_uses_configured_model_rates() {
         assert_eq!(
-            editor_image_generation_mud_points(Some("publication-material")),
+            editor_video_model_generation_mud_points(Some("seedance2.0-fast"), "480p", 4),
+            40
+        );
+        assert_eq!(
+            editor_video_model_generation_mud_points(Some("seedance2.0"), "720p", 5),
+            100
+        );
+        assert_eq!(
+            editor_video_model_generation_mud_points(Some("kling3.0"), "480p", 5),
+            50
+        );
+        assert_eq!(
+            editor_video_model_generation_mud_points(Some("kling3.0-omni"), "720p", 4),
+            80
+        );
+        assert_eq!(
+            editor_video_model_generation_mud_points(Some("veo3.1"), "480p", 4),
+            40
+        );
+        assert_eq!(
+            editor_video_model_generation_mud_points(Some("veo3.1-fast"), "720p", 4),
+            80
+        );
+    }
+
+    #[test]
+    fn editor_audio_generation_price_uses_configured_model_rates() {
+        assert_eq!(
+            editor_sound_effect_model_generation_mud_points(Some("audio1.0")),
+            10
+        );
+        assert_eq!(
+            editor_background_music_model_generation_mud_points(Some("chirp-v5")),
             5
         );
     }
+
+    #[test]
+    fn editor_image_generation_price_uses_configured_kind_rates() {
+        assert_eq!(editor_image_generation_mud_points(None, None), 12);
+        assert_eq!(editor_image_generation_mud_points(Some("spec"), None), 5);
+        assert_eq!(
+            editor_image_generation_mud_points(Some("character"), None),
+            12
+        );
+        assert_eq!(editor_image_generation_mud_points(Some("icon"), None), 12);
+        assert_eq!(
+            editor_image_generation_mud_points(Some("ui-design"), None),
+            12
+        );
+        assert_eq!(
+            editor_image_generation_mud_points(
+                Some("publication-material"),
+                Some("gemini-3.1-flash-image-preview")
+            ),
+            12
+        );
+        assert_eq!(
+            editor_image_generation_mud_points(Some("publication-material"), Some("gpt-image-2")),
+            12
+        );
+    }
 }
diff --git a/server-rs/crates/api-server/src/editor_project.rs b/server-rs/crates/api-server/src/editor_project.rs
index 0c1309a02..983fa044e 100644
--- a/server-rs/crates/api-server/src/editor_project.rs
+++ b/server-rs/crates/api-server/src/editor_project.rs
@@ -786,8 +786,6 @@ pub async fn generate_editor_image(
         legacy_size
     };
     let normalized_kind = payload.kind.as_deref().map(str::trim);
-    let configured_price_mud_points =
-        crate::editor_generation_config::editor_image_generation_mud_points(normalized_kind);
     let is_character_generation = matches!(normalized_kind, Some("character"));
     let is_ui_design_generation = matches!(normalized_kind, Some("ui-design"));
     let is_publication_material_generation =
@@ -857,6 +855,11 @@ pub async fn generate_editor_image(
     } else {
         image_size
     };
+    let configured_price_mud_points =
+        crate::editor_generation_config::editor_image_generation_mud_points(
+            normalized_kind,
+            Some(generation_options.model),
+        );
     let generate_operation = async {
         if generation_options.model == EDITOR_IMAGE_MODEL_NANOBANANA2 {
             create_openai_nanobanana_generate_content(
@@ -1154,8 +1157,6 @@ pub async fn generate_editor_icon_spritesheet(
     Extension(authenticated): Extension<AuthenticatedAccessToken>,
     Json(payload): Json<EditorIconSpritesheetGenerationRequest>,
 ) -> Result<Json<Value>, AppError> {
-    let expected_price_mud_points =
-        validate_editor_icon_spritesheet_price(payload.price_mud_points)?;
     let icon_descriptions = normalize_icon_descriptions(payload.icon_descriptions)?;
     let reference_image = parse_editor_reference_image(payload.reference_image_src.as_str())
         .map_err(|error| {
@@ -1170,6 +1171,10 @@ pub async fn generate_editor_icon_spritesheet(
         payload.aspect_ratio.as_deref(),
         payload.image_size.as_deref(),
     );
+    let expected_price_mud_points = validate_editor_icon_spritesheet_price(
+        payload.price_mud_points,
+        Some(generation_options.model),
+    )?;
     let size = generation_options.size.as_str();
     let prompt = build_editor_icon_spritesheet_prompt(&icon_descriptions);
 
@@ -1328,6 +1333,7 @@ pub async fn extract_editor_ui_design_assets(
             task_id: generated.task_id,
             price_mud_points: crate::editor_generation_config::editor_image_generation_mud_points(
                 Some("icon"),
+                Some(GPT_IMAGE_2_MODEL),
             ),
         },
     ))
@@ -1530,9 +1536,12 @@ fn editor_icon_spritesheet_bad_request(message: impl Into<String>) -> AppError {
     }))
 }
 
-fn validate_editor_icon_spritesheet_price(price_mud_points: u32) -> Result<u32, AppError> {
+fn validate_editor_icon_spritesheet_price(
+    price_mud_points: u32,
+    model: Option<&str>,
+) -> Result<u32, AppError> {
     let expected_price_mud_points =
-        crate::editor_generation_config::editor_image_generation_mud_points(Some("icon"));
+        crate::editor_generation_config::editor_image_generation_mud_points(Some("icon"), model);
     if price_mud_points != expected_price_mud_points {
         return Err(editor_icon_spritesheet_bad_request(format!(
             "priceMudPoints 与素材生成计费配置不一致，应为 {expected_price_mud_points}。"
@@ -2032,8 +2041,19 @@ mod tests {
 
     #[test]
     fn editor_icon_spritesheet_request_price_uses_generation_config() {
-        assert_eq!(validate_editor_icon_spritesheet_price(12).unwrap(), 12);
-        let error = validate_editor_icon_spritesheet_price(5)
+        assert_eq!(
+            validate_editor_icon_spritesheet_price(
+                12,
+                Some("gemini-3.1-flash-image-preview")
+            )
+            .unwrap(),
+            12
+        );
+        assert_eq!(
+            validate_editor_icon_spritesheet_price(12, Some("gpt-image-2")).unwrap(),
+            12
+        );
+        let error = validate_editor_icon_spritesheet_price(5, Some("gpt-image-2"))
             .expect_err("wrong icon spritesheet price should fail");
         assert!(error.body_text().contains("priceMudPoints"));
         let response = EditorIconSpritesheetGenerationResponse {
@@ -2053,6 +2073,7 @@ mod tests {
             task_id: "task-icons".to_string(),
             price_mud_points: crate::editor_generation_config::editor_image_generation_mud_points(
                 Some("icon"),
+                None,
             ),
         };
         let payload = serde_json::to_value(response).expect("response should serialize");
diff --git a/server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs b/server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs
index 174611a45..4d8d999ad 100644
--- a/server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs
+++ b/server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs
@@ -25,16 +25,14 @@ use super::{
     types::{AudioAssetBindingTarget, AudioAssetSlot, GeneratedCreationAudioTarget},
 };
 
-const EDITOR_SOUND_EFFECT_POINTS_COST: u32 = 10;
-const EDITOR_BACKGROUND_MUSIC_POINTS_COST: u32 = 5;
 const EDITOR_AUDIO_WIDTH: u32 = 420;
 const EDITOR_AUDIO_HEIGHT: u32 = 120;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(super) struct NormalizedEditorSoundEffectRequest {
-    pub(super) sound: String,
-    pub(super) sound_type: String,
-    pub(super) tempo: Option<u16>,
+    pub(super) prompt: String,
+    pub(super) model: String,
+    pub(super) duration: u8,
     pub(super) price_mud_points: u32,
 }
 
@@ -48,46 +46,58 @@ pub(super) struct NormalizedEditorBackgroundMusicRequest {
 pub(super) fn normalize_editor_sound_effect_request(
     payload: assets::EditorSoundEffectGenerateRequest,
 ) -> Result<NormalizedEditorSoundEffectRequest, AppError> {
-    if payload.price_mud_points != EDITOR_SOUND_EFFECT_POINTS_COST {
-        return Err(editor_audio_bad_request("音效生成泥点消耗不匹配"));
+    let model = normalize_editor_sound_model(payload.model.as_deref())?;
+    let expected_price_mud_points =
+        crate::editor_generation_config::editor_sound_effect_model_generation_mud_points(Some(
+            model.as_str(),
+        ));
+    if payload.price_mud_points != expected_price_mud_points {
+        return Err(editor_audio_bad_request(format!(
+            "音效生成泥点消耗不匹配，应为 {expected_price_mud_points}"
+        )));
     }
     Ok(NormalizedEditorSoundEffectRequest {
-        sound: platform_audio::normalize_limited_text(
-            &payload.sound,
-            "sound",
+        prompt: platform_audio::normalize_limited_text(
+            &payload.prompt,
+            "prompt",
             platform_audio::VIDU_PROMPT_MAX_CHARS,
         )
         .map_err(map_platform_audio_error)?,
-        sound_type: normalize_editor_sound_type(&payload.sound_type)?,
-        tempo: normalize_editor_sound_tempo(payload.tempo)?,
-        price_mud_points: payload.price_mud_points,
+        model,
+        duration: normalize_editor_sound_duration(payload.duration)?,
+        price_mud_points: expected_price_mud_points,
     })
 }
 
-fn normalize_editor_sound_type(value: &str) -> Result<String, AppError> {
-    let sound_type = platform_audio::normalize_limited_text(value, "type", 80)
-        .map_err(map_platform_audio_error)?;
-    if sound_type == "one-shot" || sound_type == "loop" {
-        return Ok(sound_type);
+fn normalize_editor_sound_model(value: Option<&str>) -> Result<String, AppError> {
+    let model = platform_audio::normalize_optional_text(value)
+        .unwrap_or_else(|| platform_audio::VIDU_AUDIO_MODEL.to_string());
+    if model == platform_audio::VIDU_AUDIO_MODEL {
+        return Ok(model);
     }
     Err(editor_audio_bad_request(
-        "音效 type 只支持 one-shot 或 loop",
+        "编辑器音效暂只支持 Vidu audio1.0 模型",
     ))
 }
 
-fn normalize_editor_sound_tempo(value: Option<u16>) -> Result<Option<u16>, AppError> {
-    match value {
-        Some(tempo) if (1..=300).contains(&tempo) => Ok(Some(tempo)),
-        Some(_) => Err(editor_audio_bad_request("音效 tempo BPM 必须在 1-300 之间")),
-        None => Ok(None),
+fn normalize_editor_sound_duration(value: u8) -> Result<u8, AppError> {
+    if (2..=10).contains(&value) {
+        return Ok(value);
     }
+    Err(editor_audio_bad_request("音效 duration 必须在 2-10 秒之间"))
 }
 
 pub(super) fn normalize_editor_background_music_request(
     payload: assets::EditorBackgroundMusicGenerateRequest,
 ) -> Result<NormalizedEditorBackgroundMusicRequest, AppError> {
-    if payload.price_mud_points != EDITOR_BACKGROUND_MUSIC_POINTS_COST {
-        return Err(editor_audio_bad_request("背景音乐生成泥点消耗不匹配"));
+    let expected_price_mud_points =
+        crate::editor_generation_config::editor_background_music_model_generation_mud_points(Some(
+            platform_audio::SUNO_DEFAULT_MODEL,
+        ));
+    if payload.price_mud_points != expected_price_mud_points {
+        return Err(editor_audio_bad_request(format!(
+            "背景音乐生成泥点消耗不匹配，应为 {expected_price_mud_points}"
+        )));
     }
     Ok(NormalizedEditorBackgroundMusicRequest {
         gpt_description_prompt: platform_audio::normalize_limited_text(
@@ -97,7 +107,7 @@ pub(super) fn normalize_editor_background_music_request(
         )
         .map_err(map_platform_audio_error)?,
         make_instrumental: true,
-        price_mud_points: payload.price_mud_points,
+        price_mud_points: expected_price_mud_points,
     })
 }
 
@@ -119,10 +129,10 @@ pub async fn generate_editor_sound_effect(
         &http_client,
         &settings,
         platform_audio::EditorSoundEffectTaskRequest {
-            sound: normalized.sound.clone(),
-            sound_type: normalized.sound_type.clone(),
-            tempo: normalized.tempo,
-            model: None,
+            prompt: normalized.prompt.clone(),
+            duration: normalized.duration,
+            seed: None,
+            model: Some(normalized.model.clone()),
         },
     )
     .await
@@ -151,9 +161,9 @@ pub async fn generate_editor_sound_effect(
             width: EDITOR_AUDIO_WIDTH,
             height: EDITOR_AUDIO_HEIGHT,
             source_type: "generated".to_string(),
-            prompt: normalized.sound.clone(),
-            actual_prompt: Some(normalized.sound),
-            model: platform_audio::SUNO_DEFAULT_MODEL.to_string(),
+            prompt: normalized.prompt.clone(),
+            actual_prompt: Some(normalized.prompt),
+            model: normalized.model,
             provider: generated.provider,
             task_id: generated.task_id,
             price_mud_points: normalized.price_mud_points,
diff --git a/server-rs/crates/api-server/src/vector_engine_audio_generation/tests.rs b/server-rs/crates/api-server/src/vector_engine_audio_generation/tests.rs
index b8430b759..4270ec6b6 100644
--- a/server-rs/crates/api-server/src/vector_engine_audio_generation/tests.rs
+++ b/server-rs/crates/api-server/src/vector_engine_audio_generation/tests.rs
@@ -82,58 +82,59 @@ fn disabled_creation_audio_targets_return_gone_including_wooden_fish_sound_effec
 }
 
 #[test]
-fn editor_sound_effect_request_normalizes_sound_type_tempo_and_price() {
+fn editor_sound_effect_request_normalizes_prompt_duration_and_price() {
     let normalized =
         normalize_editor_sound_effect_request(assets::EditorSoundEffectGenerateRequest {
-            sound: "  金币掉落叮当声  ".to_string(),
-            sound_type: " one-shot ".to_string(),
-            tempo: Some(120),
+            prompt: "  金币掉落叮当声  ".to_string(),
+            model: None,
+            duration: 7,
             price_mud_points: 10,
         })
         .expect("editor sound effect request should normalize");
 
-    assert_eq!(normalized.sound, "金币掉落叮当声");
-    assert_eq!(normalized.sound_type, "one-shot");
-    assert_eq!(normalized.tempo, Some(120));
+    assert_eq!(normalized.prompt, "金币掉落叮当声");
+    assert_eq!(normalized.model, platform_audio::VIDU_AUDIO_MODEL);
+    assert_eq!(normalized.duration, 7);
     assert_eq!(normalized.price_mud_points, 10);
 }
 
 #[test]
-fn editor_sound_effect_request_accepts_null_tempo_and_rejects_invalid_type() {
+fn editor_sound_effect_request_accepts_only_vidu_audio_model() {
     let normalized =
         normalize_editor_sound_effect_request(assets::EditorSoundEffectGenerateRequest {
-            sound: "按钮点击".to_string(),
-            sound_type: "loop".to_string(),
-            tempo: None,
+            prompt: "金币掉落叮当声".to_string(),
+            model: Some(" audio1.0 ".to_string()),
+            duration: 5,
             price_mud_points: 10,
         })
-        .expect("null BPM should keep tempo unset");
-    assert_eq!(normalized.sound_type, "loop");
-    assert_eq!(normalized.tempo, None);
+        .expect("Vidu audio model should be accepted");
+
+    assert_eq!(normalized.model, platform_audio::VIDU_AUDIO_MODEL);
 
     let error = normalize_editor_sound_effect_request(assets::EditorSoundEffectGenerateRequest {
-        sound: "按钮点击".to_string(),
-        sound_type: "ui".to_string(),
-        tempo: Some(120),
+        prompt: "金币掉落叮当声".to_string(),
+        model: Some(platform_audio::SUNO_DEFAULT_MODEL.to_string()),
+        duration: 5,
         price_mud_points: 10,
     })
-    .expect_err("unsupported sound type should fail");
-    assert!(error.to_string().contains("one-shot"));
+    .expect_err("Suno text-to-sound should be disabled for editor sound effects");
+
+    assert!(error.to_string().contains("Vidu"));
 }
 
 #[test]
-fn editor_sound_effect_request_rejects_bpm_outside_documented_range() {
-    for tempo in [0, 301] {
+fn editor_sound_effect_request_rejects_duration_outside_vidu_range() {
+    for duration in [1, 11] {
         let error =
             normalize_editor_sound_effect_request(assets::EditorSoundEffectGenerateRequest {
-                sound: "按钮点击".to_string(),
-                sound_type: "one-shot".to_string(),
-                tempo: Some(tempo),
+                prompt: "按钮点击".to_string(),
+                model: None,
+                duration,
                 price_mud_points: 10,
             })
-            .expect_err("BPM outside 1-300 should fail");
+            .expect_err("duration outside 2-10 seconds should fail");
 
-        assert!(error.to_string().contains("1-300"));
+        assert!(error.to_string().contains("2-10"));
     }
 }
 
@@ -168,9 +169,9 @@ fn editor_background_music_request_rejects_prompt_over_documented_limit() {
 #[test]
 fn editor_audio_rejects_price_mismatch() {
     let error = normalize_editor_sound_effect_request(assets::EditorSoundEffectGenerateRequest {
-        sound: "点击按钮".to_string(),
-        sound_type: "one-shot".to_string(),
-        tempo: Some(120),
+        prompt: "点击按钮".to_string(),
+        model: None,
+        duration: 5,
         price_mud_points: 5,
     })
     .expect_err("wrong sound effect price should fail");
diff --git a/server-rs/crates/platform-audio/src/client.rs b/server-rs/crates/platform-audio/src/client.rs
index 8b2a57bf9..d993d1005 100644
--- a/server-rs/crates/platform-audio/src/client.rs
+++ b/server-rs/crates/platform-audio/src/client.rs
@@ -117,7 +117,7 @@ pub async fn submit_editor_sound_effect_task(
     let response = post_vector_engine_json(
         http_client,
         settings,
-        AudioTaskKind::SunoSoundEffect.submit_path(),
+        AudioTaskKind::SoundEffect.submit_path(),
         body,
         "提交编辑器音效任务失败",
     )
@@ -127,9 +127,9 @@ pub async fn submit_editor_sound_effect_task(
     let status = find_first_string_by_key(&response, "state").unwrap_or_else(|| "created".into());
 
     Ok(AudioTaskResponse {
-        kind: AudioTaskKind::SunoSoundEffect,
+        kind: AudioTaskKind::SoundEffect,
         task_id,
-        provider: AudioTaskKind::SunoSoundEffect.provider().to_string(),
+        provider: AudioTaskKind::SoundEffect.provider().to_string(),
         status,
     })
 }
diff --git a/server-rs/crates/platform-audio/src/request.rs b/server-rs/crates/platform-audio/src/request.rs
index 2d3471f32..f3ae56f52 100644
--- a/server-rs/crates/platform-audio/src/request.rs
+++ b/server-rs/crates/platform-audio/src/request.rs
@@ -39,14 +39,16 @@ pub fn build_background_music_task_body(
 
 pub fn build_sound_effect_task_body(request: SoundEffectTaskRequest) -> Result<Value, AudioError> {
     let prompt = normalize_limited_text(&request.prompt, "prompt", VIDU_PROMPT_MAX_CHARS)?;
-    let duration = request.duration.clamp(2, 10);
+    if !(2..=10).contains(&request.duration) {
+        return Err(AudioError::invalid_request("duration 必须在 2-10 秒之间"));
+    }
     let mut body = Map::from_iter([
         (
             "model".to_string(),
             Value::String(VIDU_AUDIO_MODEL.to_string()),
         ),
         ("prompt".to_string(), Value::String(prompt)),
-        ("duration".to_string(), json!(duration)),
+        ("duration".to_string(), json!(request.duration)),
     ]);
     if let Some(seed) = request.seed {
         body.insert("seed".to_string(), json!(seed));
@@ -74,28 +76,26 @@ pub fn build_editor_background_music_task_body(
 pub fn build_editor_sound_effect_task_body(
     request: EditorSoundEffectTaskRequest,
 ) -> Result<Value, AudioError> {
-    let sound = normalize_limited_text(&request.sound, "sound", VIDU_PROMPT_MAX_CHARS)?;
-    let sound_type = normalize_limited_text(&request.sound_type, "type", 80)?;
-    if sound_type != "one-shot" && sound_type != "loop" {
-        return Err(AudioError::invalid_request("type 只支持 one-shot 或 loop"));
-    }
-    if let Some(tempo) = request.tempo {
-        if !(1..=300).contains(&tempo) {
-            return Err(AudioError::invalid_request("tempo BPM 必须在 1-300 之间"));
-        }
+    let prompt = normalize_limited_text(&request.prompt, "prompt", VIDU_PROMPT_MAX_CHARS)?;
+    if !(2..=10).contains(&request.duration) {
+        return Err(AudioError::invalid_request("duration 必须在 2-10 秒之间"));
     }
     let model = normalize_optional_text(request.model.as_deref())
-        .unwrap_or_else(|| SUNO_DEFAULT_MODEL.to_string());
-    Ok(json!({
-        "mv": model,
-        "task": "sound",
-        "metadata_params": {
-            "sound": sound,
-            "type": sound_type,
-            "tempo": request.tempo,
-            "key": null,
-        },
-    }))
+        .unwrap_or_else(|| VIDU_AUDIO_MODEL.to_string());
+    if model != VIDU_AUDIO_MODEL {
+        return Err(AudioError::invalid_request(
+            "编辑器音效暂只支持 Vidu audio1.0 模型",
+        ));
+    }
+    let mut body = Map::from_iter([
+        ("model".to_string(), Value::String(model)),
+        ("prompt".to_string(), Value::String(prompt)),
+        ("duration".to_string(), json!(request.duration)),
+    ]);
+    if let Some(seed) = request.seed {
+        body.insert("seed".to_string(), json!(seed));
+    }
+    Ok(Value::Object(body))
 }
 
 pub fn normalize_limited_text(
diff --git a/server-rs/crates/platform-audio/src/types.rs b/server-rs/crates/platform-audio/src/types.rs
index a9085d24f..18760894c 100644
--- a/server-rs/crates/platform-audio/src/types.rs
+++ b/server-rs/crates/platform-audio/src/types.rs
@@ -66,9 +66,9 @@ pub struct EditorBackgroundMusicTaskRequest {
 
 #[derive(Clone, Debug)]
 pub struct EditorSoundEffectTaskRequest {
-    pub sound: String,
-    pub sound_type: String,
-    pub tempo: Option<u16>,
+    pub prompt: String,
+    pub duration: u8,
+    pub seed: Option<u64>,
     pub model: Option<String>,
 }
 
diff --git a/server-rs/crates/platform-audio/tests/vector_engine_audio.rs b/server-rs/crates/platform-audio/tests/vector_engine_audio.rs
index 2d77095fe..b31dd2cd6 100644
--- a/server-rs/crates/platform-audio/tests/vector_engine_audio.rs
+++ b/server-rs/crates/platform-audio/tests/vector_engine_audio.rs
@@ -1,6 +1,6 @@
 use platform_audio::{
-    AudioTaskKind, BackgroundMusicTaskRequest, EditorBackgroundMusicTaskRequest,
-    EditorSoundEffectTaskRequest, SUNO_DEFAULT_MODEL, VIDU_PROMPT_MAX_CHARS,
+    AudioTaskKind, BackgroundMusicTaskRequest, EditorBackgroundMusicTaskRequest, SUNO_DEFAULT_MODEL,
+    EditorSoundEffectTaskRequest, VIDU_AUDIO_MODEL, VIDU_PROMPT_MAX_CHARS,
     audio_mime_to_extension, build_background_music_task_body,
     build_editor_background_music_task_body, build_editor_sound_effect_task_body,
     build_sound_effect_task_body, extract_audio_urls, is_failed_task_status,
@@ -127,58 +127,78 @@ fn editor_background_music_request_body_rejects_overlong_gpt_description_prompt(
 }
 
 #[test]
-fn editor_sound_effect_request_body_uses_sound_type_and_tempo() {
-    let body = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
-        sound: "  金币掉落叮当声  ".to_string(),
-        sound_type: " one-shot ".to_string(),
-        tempo: Some(120),
-        model: None,
+fn vidu_sound_effect_request_body_uses_text2audio_contract() {
+    let body = build_sound_effect_task_body(platform_audio::SoundEffectTaskRequest {
+        prompt: "  金币掉落叮当声  ".to_string(),
+        duration: 5,
+        seed: None,
     })
-    .expect("editor sound effect body should be valid");
+    .expect("Vidu sound effect body should be valid");
 
-    assert_eq!(body["mv"], SUNO_DEFAULT_MODEL);
-    assert_eq!(body["task"], "sound");
-    assert_eq!(body["metadata_params"]["sound"], "金币掉落叮当声");
-    assert_eq!(body["metadata_params"]["type"], "one-shot");
-    assert_eq!(body["metadata_params"]["tempo"], 120);
-    assert_eq!(body["metadata_params"]["key"], serde_json::Value::Null);
-    assert!(body.get("prompt").is_none());
+    assert_eq!(AudioTaskKind::SoundEffect.submit_path(), "/ent/v2/text2audio");
+    assert_eq!(AudioTaskKind::SoundEffect.provider(), "vector-engine-vidu");
+    assert_eq!(body["model"], VIDU_AUDIO_MODEL);
+    assert_eq!(body["prompt"], "金币掉落叮当声");
+    assert_eq!(body["duration"], 5);
+    assert!(body.get("mv").is_none());
+    assert!(body.get("task").is_none());
+    assert!(body.get("metadata_params").is_none());
 }
 
 #[test]
-fn editor_sound_effect_request_body_keeps_null_tempo() {
-    let body = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
-        sound: "按钮确认短促音".to_string(),
-        sound_type: "loop".to_string(),
-        tempo: None,
-        model: Some(" chirp-v5-5 ".to_string()),
+fn vidu_sound_effect_request_body_rejects_duration_outside_vidu_range_and_keeps_seed() {
+    let body = build_sound_effect_task_body(platform_audio::SoundEffectTaskRequest {
+        prompt: "按钮确认短促音".to_string(),
+        duration: 2,
+        seed: Some(42),
     })
-    .expect("unset BPM should serialize as null");
+    .expect("Vidu 2 second duration should be accepted");
+    assert_eq!(body["duration"], 2);
+    assert_eq!(body["seed"], 42);
 
-    assert_eq!(body["mv"], "chirp-v5-5");
-    assert_eq!(body["metadata_params"]["type"], "loop");
-    assert_eq!(body["metadata_params"]["tempo"], serde_json::Value::Null);
-}
-
-#[test]
-fn editor_sound_effect_request_body_rejects_invalid_type_and_tempo() {
-    let invalid_type = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
-        sound: "按钮确认短促音".to_string(),
-        sound_type: "ambient".to_string(),
-        tempo: Some(120),
-        model: None,
-    })
-    .expect_err("platform layer should reject unsupported sound type");
-    assert!(invalid_type.message().contains("one-shot"));
-
-    for tempo in [0, 301] {
-        let invalid_tempo = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
-            sound: "按钮确认短促音".to_string(),
-            sound_type: "one-shot".to_string(),
-            tempo: Some(tempo),
-            model: None,
+    for duration in [1, 11] {
+        let error = build_sound_effect_task_body(platform_audio::SoundEffectTaskRequest {
+            prompt: "循环环境音".to_string(),
+            duration,
+            seed: None,
         })
-        .expect_err("platform layer should reject BPM outside 1-300");
-        assert!(invalid_tempo.message().contains("1-300"));
+        .expect_err("duration outside Vidu 2-10 seconds should fail");
+        assert!(error.message().contains("duration"));
+    }
+}
+
+#[test]
+fn editor_sound_effect_request_body_uses_vidu_text2audio_contract() {
+    let body = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
+        prompt: "  金币掉落叮当声  ".to_string(),
+        duration: 7,
+        seed: Some(42),
+        model: Some(VIDU_AUDIO_MODEL.to_string()),
+    })
+    .expect("editor sound effect should use Vidu body");
+
+    assert_eq!(body["model"], VIDU_AUDIO_MODEL);
+    assert_eq!(body["prompt"], "金币掉落叮当声");
+    assert_eq!(body["duration"], 7);
+    assert_eq!(body["seed"], 42);
+    assert!(body.get("mv").is_none());
+    assert!(body.get("task").is_none());
+    assert!(body.get("metadata_params").is_none());
+    assert!(body.get("type").is_none());
+    assert!(body.get("tempo").is_none());
+}
+
+#[test]
+fn editor_sound_effect_request_body_rejects_duration_outside_vidu_range() {
+    for duration in [1, 11] {
+        let error = build_editor_sound_effect_task_body(EditorSoundEffectTaskRequest {
+            prompt: "按钮确认短促音".to_string(),
+            duration,
+            seed: None,
+            model: None,
+        })
+        .expect_err("duration outside Vidu 2-10 seconds should fail");
+
+        assert!(error.message().contains("duration"));
     }
 }
diff --git a/server-rs/crates/shared-contracts/src/assets.rs b/server-rs/crates/shared-contracts/src/assets.rs
index d47f5514a..8cc4bb80d 100644
--- a/server-rs/crates/shared-contracts/src/assets.rs
+++ b/server-rs/crates/shared-contracts/src/assets.rs
@@ -426,10 +426,10 @@ pub struct EditorIconSpritesheetGenerateResponse {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct EditorSoundEffectGenerateRequest {
-    pub sound: String,
-    #[serde(rename = "type")]
-    pub sound_type: String,
-    pub tempo: Option<u16>,
+    pub prompt: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    pub duration: u8,
     pub price_mud_points: u32,
 }
 
@@ -1160,32 +1160,35 @@ mod tests {
     #[test]
     fn editor_audio_requests_and_response_use_canvas_audio_shape() {
         let sound_payload = serde_json::to_value(EditorSoundEffectGenerateRequest {
-            sound: "金币掉落叮当声".to_string(),
-            sound_type: "one-shot".to_string(),
-            tempo: Some(120),
+            prompt: "金币掉落叮当声".to_string(),
+            model: Some("audio1.0".to_string()),
+            duration: 7,
             price_mud_points: 10,
         })
         .expect("sound request should serialize");
-        assert_eq!(sound_payload["sound"], json!("金币掉落叮当声"));
-        assert_eq!(sound_payload["type"], json!("one-shot"));
-        assert_eq!(sound_payload["tempo"], json!(120));
+        assert_eq!(sound_payload["prompt"], json!("金币掉落叮当声"));
+        assert_eq!(sound_payload["model"], json!("audio1.0"));
+        assert_eq!(sound_payload["duration"], json!(7));
         assert_eq!(sound_payload["priceMudPoints"], json!(10));
+        assert!(sound_payload.get("sound").is_none());
+        assert!(sound_payload.get("type").is_none());
+        assert!(sound_payload.get("tempo").is_none());
 
-        let unset_tempo_payload = serde_json::to_value(EditorSoundEffectGenerateRequest {
-            sound: "按钮确认短促音".to_string(),
-            sound_type: "loop".to_string(),
-            tempo: None,
+        let parsed_sound_payload: EditorSoundEffectGenerateRequest =
+            serde_json::from_value(sound_payload)
+                .expect("sound request with duration should deserialize");
+        assert_eq!(parsed_sound_payload.prompt, "金币掉落叮当声");
+        assert_eq!(parsed_sound_payload.duration, 7);
+
+        let unset_model_payload = serde_json::to_value(EditorSoundEffectGenerateRequest {
+            prompt: "按钮确认短促音".to_string(),
+            model: None,
+            duration: 5,
             price_mud_points: 10,
         })
-        .expect("sound request with unset tempo should serialize");
-        assert_eq!(unset_tempo_payload["type"], json!("loop"));
-        assert_eq!(unset_tempo_payload["tempo"], json!(null));
-
-        let parsed_unset_tempo: EditorSoundEffectGenerateRequest =
-            serde_json::from_value(unset_tempo_payload)
-                .expect("sound request with null tempo should deserialize");
-        assert_eq!(parsed_unset_tempo.sound_type, "loop");
-        assert_eq!(parsed_unset_tempo.tempo, None);
+        .expect("sound request with unset model should serialize");
+        assert!(unset_model_payload.get("model").is_none());
+        assert_eq!(unset_model_payload["duration"], json!(5));
 
         let music_payload = serde_json::to_value(EditorBackgroundMusicGenerateRequest {
             gpt_description_prompt: "森林冒险背景音乐".to_string(),
diff --git a/src/components/image-editor/ImageCanvasBasicGenerationComposerView.tsx b/src/components/image-editor/ImageCanvasBasicGenerationComposerView.tsx
index 05eb11709..24a996b18 100644
--- a/src/components/image-editor/ImageCanvasBasicGenerationComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasBasicGenerationComposerView.tsx
@@ -21,7 +21,7 @@ import type {
 import { ImageCanvasGenerationImageOptionsView } from './ImageCanvasGenerationImageOptionsView';
 import { ImageCanvasReferenceSlot } from './ImageCanvasReferenceSlot';
 import {
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
+  calculateEditorImageGenerationPrice,
 } from './ImageCanvasGenerationModel';
 import { useImageCanvasFloatingOptionDismiss } from './useImageCanvasFloatingOptionDismiss';
 
@@ -172,7 +172,9 @@ export function ImageCanvasBasicGenerationComposerView({
           includeDimensions
           onRememberImageModel={onRememberImageModel}
           optionLabelPrefix="生成图片"
-          cost={EDITOR_GENERATION_MUD_POINT_CONFIG.image}
+          cost={calculateEditorImageGenerationPrice({
+            model: dialog.imageModel,
+          })}
           submitLabel="生成"
           submitAriaLabel="生成"
           renderEditorPortal={renderEditorPortal}
diff --git a/src/components/image-editor/ImageCanvasBottomToolbarView.test.tsx b/src/components/image-editor/ImageCanvasBottomToolbarView.test.tsx
index 984653d16..d891e7fa9 100644
--- a/src/components/image-editor/ImageCanvasBottomToolbarView.test.tsx
+++ b/src/components/image-editor/ImageCanvasBottomToolbarView.test.tsx
@@ -114,6 +114,43 @@ describe('ImageCanvasBottomToolbarView', () => {
     }
   });
 
+  it('把宣发素材入口放在生成UI设计图右侧', () => {
+    const specToolWrapRef = createRef<HTMLSpanElement>();
+    const musicToolWrapRef = createRef<HTMLSpanElement>();
+    const publicationToolWrapRef = createRef<HTMLSpanElement>();
+    render(
+      <ImageCanvasBottomToolbarView
+        specToolWrapRef={specToolWrapRef}
+        musicToolWrapRef={musicToolWrapRef}
+        publicationToolWrapRef={publicationToolWrapRef}
+        effectiveTool="select"
+        onSwitchTool={vi.fn()}
+        onOpenToolOptions={vi.fn()}
+        onCloseToolOptions={vi.fn()}
+      />,
+    );
+
+    const toolNames = within(
+      screen.getByRole('toolbar', { name: 'AI画布工具栏' }),
+    )
+      .getAllByRole('button')
+      .map((button) => button.getAttribute('aria-label'));
+
+    expect(toolNames).toEqual([
+      '选择工具',
+      '抓手工具',
+      '上传工具',
+      '生成图片',
+      '生成视频',
+      '生成音乐',
+      '生成规范',
+      '生成角色形象',
+      '生成图标素材',
+      '生成UI设计图',
+      '宣发素材',
+    ]);
+  });
+
   it('opens and closes bottom option tools on hover', () => {
     const openToolOptions = vi.fn();
     const closeToolOptions = vi.fn();
diff --git a/src/components/image-editor/ImageCanvasBottomToolbarView.tsx b/src/components/image-editor/ImageCanvasBottomToolbarView.tsx
index 6dcb19b24..cce356f53 100644
--- a/src/components/image-editor/ImageCanvasBottomToolbarView.tsx
+++ b/src/components/image-editor/ImageCanvasBottomToolbarView.tsx
@@ -45,7 +45,6 @@ const canvasTools: Array<{
   },
   { id: 'video', label: '生成视频', icon: Clapperboard },
   { id: 'music', label: '生成音乐', icon: Music },
-  { id: 'publication', label: '宣发素材', icon: Megaphone },
   {
     id: 'spec',
     label: '生成规范',
@@ -55,6 +54,7 @@ const canvasTools: Array<{
   { id: 'character', label: '生成角色形象', icon: UserRound },
   { id: 'icon', label: '生成图标素材', icon: Grid2X2 },
   { id: 'ui-design', label: '生成UI设计图', icon: AppWindow },
+  { id: 'publication', label: '宣发素材', icon: Megaphone },
 ];
 
 function isToolbarOptionTool(tool: CanvasTool): tool is ToolbarOptionTool {
diff --git a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
index 623f3d9e0..b132d6a21 100644
--- a/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasCharacterGenerationComposerView.tsx
@@ -21,7 +21,7 @@ import type {
   UploadTarget,
 } from './ImageCanvasEditorTypes';
 import { ImageCanvasGenerationImageOptionsView } from './ImageCanvasGenerationImageOptionsView';
-import { EDITOR_GENERATION_MUD_POINT_CONFIG } from './ImageCanvasGenerationModel';
+import { calculateEditorImageGenerationPrice } from './ImageCanvasGenerationModel';
 import { useImageCanvasFloatingOptionDismiss } from './useImageCanvasFloatingOptionDismiss';
 
 type ImageCanvasCharacterGenerationComposerViewProps = {
@@ -291,7 +291,10 @@ export function ImageCanvasCharacterGenerationComposerView({
           includeDimensions
           onRememberImageModel={onRememberImageModel}
           optionLabelPrefix="生成图片"
-          cost={EDITOR_GENERATION_MUD_POINT_CONFIG.character}
+          cost={calculateEditorImageGenerationPrice({
+            kind: 'character',
+            model: dialog.imageModel,
+          })}
           submitLabel="生成"
           submitAriaLabel="生成"
           renderEditorPortal={renderEditorPortal}
diff --git a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
index 295af772b..34d19c373 100644
--- a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
+++ b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
@@ -2818,7 +2818,7 @@ describe('ImageCanvasEditorView generation integration', () => {
     expect(within(metadataDialog).getByText('Resolution')).toBeTruthy();
     expect(within(metadataDialog).getByText('1024 x 1024 px')).toBeTruthy();
 
-    fireEvent.click(screen.getByRole('button', { name: '重绘' }));
+    fireEvent.click(screen.getByRole('button', { name: '改造' }));
     const editDialog = screen.getByRole('dialog', { name: '重绘图片' });
     expect(editDialog).toBeTruthy();
     const editPrompt = within(editDialog).getByLabelText('重绘提示词');
@@ -2914,7 +2914,7 @@ describe('ImageCanvasEditorView generation integration', () => {
       clientX: 180,
       clientY: 180,
     });
-    fireEvent.click(screen.getByRole('button', { name: '重绘' }));
+    fireEvent.click(screen.getByRole('button', { name: '改造' }));
     const editDialog = screen.getByRole('dialog', { name: '重绘图片' });
     fireEvent.change(within(editDialog).getByLabelText('重绘提示词'), {
       target: { value: '改成雨夜灯光' },
diff --git a/src/components/image-editor/ImageCanvasEditorModel.test.ts b/src/components/image-editor/ImageCanvasEditorModel.test.ts
index b2a0a8ec6..0bcb5f4c8 100644
--- a/src/components/image-editor/ImageCanvasEditorModel.test.ts
+++ b/src/components/image-editor/ImageCanvasEditorModel.test.ts
@@ -173,8 +173,7 @@ describe('ImageCanvasEditorModel', () => {
       prompt: '金币掉落叮当声',
       status: 'idle',
       composerOpen: true,
-      soundType: 'loop',
-      soundTempo: 120,
+      soundDurationSeconds: 8,
       generatedLayerId: 'layer-audio',
       placeholder: {
         x: 100,
@@ -198,8 +197,7 @@ describe('ImageCanvasEditorModel', () => {
       id: 'generation-dialog-audio',
       mode: 'audio-sound-effect',
       prompt: '金币掉落叮当声',
-      soundType: 'loop',
-      soundTempo: 120,
+      soundDurationSeconds: 8,
       generatedLayerId: 'layer-audio',
     });
   });
diff --git a/src/components/image-editor/ImageCanvasEditorModel.ts b/src/components/image-editor/ImageCanvasEditorModel.ts
index 9fb7f505c..3c55776fd 100644
--- a/src/components/image-editor/ImageCanvasEditorModel.ts
+++ b/src/components/image-editor/ImageCanvasEditorModel.ts
@@ -337,11 +337,11 @@ export function hydrateCanvasGenerationDialog(
     characterAnimationResult: hydrateCharacterAnimationResult(
       snapshot.characterAnimationResult,
     ),
-    soundType:
-      snapshot.soundType === 'loop' || snapshot.soundType === 'one-shot'
-        ? snapshot.soundType
-        : undefined,
-    soundTempo: bpmOrNull(snapshot.soundTempo),
+    soundModel: snapshot.soundModel === 'audio1.0' ? 'audio1.0' : undefined,
+    soundDurationSeconds: soundDurationOrDefault(
+      snapshot.soundDurationSeconds,
+      snapshot.audioDurationSeconds,
+    ),
     makeInstrumental:
       typeof snapshot.makeInstrumental === 'boolean'
         ? snapshot.makeInstrumental
@@ -511,6 +511,17 @@ export function bpmOrNull(value: unknown) {
   return roundedValue >= 1 && roundedValue <= 300 ? roundedValue : undefined;
 }
 
+export function soundDurationOrDefault(
+  value: unknown,
+  fallbackValue?: unknown,
+) {
+  const resolvedValue = audioDurationOrNull(value) ?? audioDurationOrNull(fallbackValue);
+  if (!resolvedValue) {
+    return undefined;
+  }
+  return Math.min(10, Math.max(2, Math.round(resolvedValue)));
+}
+
 export function stringOrNull(value: unknown) {
   return typeof value === 'string' && value.trim() ? value : null;
 }
diff --git a/src/components/image-editor/ImageCanvasEditorTypes.ts b/src/components/image-editor/ImageCanvasEditorTypes.ts
index 81b7e8238..a49bff48d 100644
--- a/src/components/image-editor/ImageCanvasEditorTypes.ts
+++ b/src/components/image-editor/ImageCanvasEditorTypes.ts
@@ -202,9 +202,9 @@ export type GenerateDialogState = {
   characterAnimationFrameCount?: EditorCharacterAnimationFrameCount;
   characterAnimationDurationSeconds?: 4 | 5 | 6;
   characterAnimationResult?: EditorCharacterAnimationGenerationResult;
-  soundType?: 'one-shot' | 'loop';
-  // 中文注释：音效 tempo 改为可空 BPM，null 表示用户不指定节奏。
-  soundTempo?: number | null;
+  soundModel?: 'audio1.0';
+  // 中文注释：Vidu 文生音频 duration 只允许 2-10 秒，默认 5 秒。
+  soundDurationSeconds?: number;
   makeInstrumental?: boolean;
   audioDurationSeconds?: number | null;
   aspectRatio?: string;
diff --git a/src/components/image-editor/ImageCanvasEditorView.test.tsx b/src/components/image-editor/ImageCanvasEditorView.test.tsx
index 2cb652d4b..17f488673 100644
--- a/src/components/image-editor/ImageCanvasEditorView.test.tsx
+++ b/src/components/image-editor/ImageCanvasEditorView.test.tsx
@@ -1,4 +1,4 @@
-/* @vitest-environment jsdom */
+/* @vitest-environment jsdom */
 
 import {
   act,
@@ -510,7 +510,7 @@ describe('ImageCanvasEditorView', () => {
     expect(
       within(infoPanel).queryByRole('button', { name: '复制Prompt' }),
     ).toBeNull();
-    expect(screen.getByRole('button', { name: '重绘' })).toBeTruthy();
+    expect(screen.getByRole('button', { name: '改造' })).toBeTruthy();
   });
 
   it('hydrates canvas images from Resolution instead of saved Size', async () => {
@@ -895,7 +895,7 @@ describe('ImageCanvasEditorView', () => {
     expect(
       screen.getByRole('button', { name: '查看大鱼素材图片信息' }),
     ).toBeTruthy();
-    expect(screen.getByRole('button', { name: '重绘' })).toBeTruthy();
+    expect(screen.getByRole('button', { name: '改造' })).toBeTruthy();
 
     fireEvent.click(screen.getByRole('button', { name: '打开素材' }));
 
diff --git a/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx b/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
index f4ece5ae5..cfb35bae3 100644
--- a/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationComposerView.test.tsx
@@ -231,6 +231,53 @@ describe('ImageCanvasGenerationComposerView', () => {
     ).toBe(true);
     expect(within(panel).getByRole('button', { name: '参考图' })).toBeTruthy();
   });
+
+  it.each([
+    ['publication-cover-image', '游戏首图', '720 x 540'],
+    ['publication-detail-gallery', '详情五图', '720 x 1280'],
+    ['publication-promo-poster', '运营海报', '1280 x 720'],
+  ] as const)('让%s 宣发素材面板对齐生成角色面板结构', (workflowId, label, sizeLabel) => {
+    renderComposer({
+      mode: 'publication',
+      prompt: '',
+      status: 'idle',
+      composerOpen: true,
+      publicationWorkflowId: workflowId,
+      publicationGameInfo: {
+        gameName: '',
+        gameCategories: '',
+        gameDescription: '',
+      },
+      publicationReferences: [],
+      imageModel: 'gpt-image-2',
+      aspectRatio: '16:9',
+      imageSize: '1K',
+    });
+
+    const panel = screen.getByRole('dialog', { name: `${label}生成卡片` });
+    expect(panel.className).toContain('image-canvas-editor__character-composer');
+    expect(panel.className).toContain('image-canvas-editor__publication-composer');
+    expect(
+      panel.firstElementChild?.className.includes(
+        'image-canvas-editor__reference-strip',
+      ),
+    ).toBe(true);
+    expect(within(panel).getByRole('button', { name: '添加参考图' })).toBeTruthy();
+    expect(
+      within(panel).getByRole('textbox', { name: `${label}游戏名` }),
+    ).toBeTruthy();
+    expect(
+      within(panel).getByRole('textbox', { name: `${label}一句话描述游戏` }),
+    ).toBeTruthy();
+    expect(panel.textContent).toContain(sizeLabel);
+    expect(
+      panel.querySelector('.image-canvas-editor__generation-composer-footer'),
+    ).toBeTruthy();
+    expect(within(panel).getByRole('button', { name: '生成' }).textContent).toBe(
+      '生成12泥点',
+    );
+  });
+
   it('生成图片参考图点击先弹来源菜单，不直接打开上传', () => {
     const onRequestUpload = vi.fn();
     const setIsGenerationReferenceMenuOpen = vi.fn();
@@ -361,6 +408,14 @@ describe('ImageCanvasGenerationComposerView', () => {
         videoResolution: '480p',
         videoMode: 'std',
         videoSound: 'off',
+        placeholder: {
+          x: 53,
+          y: 120,
+          width: 854,
+          height: 480,
+          originalWidth: 854,
+          originalHeight: 480,
+        },
       });
       return (
         <>
@@ -371,6 +426,18 @@ describe('ImageCanvasGenerationComposerView', () => {
           <output aria-label="当前视频模型">{dialog.videoModel}</output>
           <output aria-label="当前视频时长">{dialog.videoDurationSeconds}</output>
           <output aria-label="当前视频清晰度">{dialog.videoResolution}</output>
+          <output aria-label="当前视频占位">
+            {dialog.placeholder
+              ? [
+                  dialog.placeholder.x,
+                  dialog.placeholder.y,
+                  dialog.placeholder.width,
+                  dialog.placeholder.height,
+                  dialog.placeholder.originalWidth,
+                  dialog.placeholder.originalHeight,
+                ].join(':')
+              : '-'}
+          </output>
         </>
       );
     }
@@ -402,6 +469,9 @@ describe('ImageCanvasGenerationComposerView', () => {
     ).toBeTruthy();
     expect(screen.getByLabelText('当前视频时长').textContent).toBe('5');
     expect(screen.getByLabelText('当前视频清晰度').textContent).toBe('720p');
+    expect(screen.getByLabelText('当前视频占位').textContent).toBe(
+      '-160:0:1280:720:1280:720',
+    );
     expect(screen.getByRole('button', { name: '视频参数 16:9 · 5秒 · 720p' })).toBeTruthy();
     expect(screen.getByRole('button', { name: '生成视频' }).textContent).toBe(
       '生成100泥点',
@@ -417,7 +487,7 @@ describe('ImageCanvasGenerationComposerView', () => {
     expect(screen.getByRole('button', { name: '模型 Kling 3.0' })).toBeTruthy();
   });
 
-  it('生成游戏音效面板把类型和 BPM 合并到一个无标题参数按钮', () => {
+  it('生成游戏音效面板使用 Vidu duration 参数且不再显示类型和 BPM', () => {
     const onSubmitImageGeneration = vi.fn();
     function AudioHarness() {
       const [dialog, setDialog] = useState<GenerateDialogState>({
@@ -425,8 +495,8 @@ describe('ImageCanvasGenerationComposerView', () => {
         prompt: '',
         status: 'idle',
         composerOpen: true,
-        soundType: 'one-shot',
-        soundTempo: null,
+        soundModel: 'audio1.0',
+        soundDurationSeconds: 5,
       });
       return (
         <>
@@ -436,8 +506,10 @@ describe('ImageCanvasGenerationComposerView', () => {
               setDialog as Dispatch<SetStateAction<GenerateDialogState | null>>
             }
           />
-          <output aria-label="当前音效类型">{dialog.soundType}</output>
-          <output aria-label="当前BPM">{dialog.soundTempo ?? 'null'}</output>
+          <output aria-label="当前音效模型">{dialog.soundModel}</output>
+          <output aria-label="当前音效时长">
+            {dialog.soundDurationSeconds ?? 'null'}
+          </output>
         </>
       );
     }
@@ -445,46 +517,43 @@ describe('ImageCanvasGenerationComposerView', () => {
     render(<AudioHarness />);
 
     const panel = screen.getByRole('dialog', { name: '生成游戏音效' });
-    expect(within(panel).getByRole('textbox', { name: 'sound提示词' })).toBeTruthy();
+    expect(within(panel).getByRole('textbox', { name: 'prompt' })).toBeTruthy();
+    expect(screen.getByLabelText('当前音效模型').textContent).toBe('audio1.0');
+    expect(within(panel).getByText('Vidu')).toBeTruthy();
+    expect(within(panel).queryByText(/Suno/u)).toBeNull();
     expect(
-      within(panel).getByRole('button', { name: '音效参数 单次' }),
+      within(panel).getByRole('button', { name: '音效时长 5秒' }),
     ).toBeTruthy();
-    expect(within(panel).queryByRole('button', { name: /type/u })).toBeNull();
-    expect(within(panel).queryByRole('button', { name: /tempo/u })).toBeNull();
+    expect(within(panel).queryByText('单次')).toBeNull();
+    expect(within(panel).queryByText('循环')).toBeNull();
+    expect(within(panel).queryByText(/BPM/u)).toBeNull();
     expect(within(panel).getByRole('button', { name: '生成游戏音效' }).textContent).toBe(
       '生成10泥点',
     );
 
     fireEvent.click(
-      within(panel).getByRole('button', { name: '音效参数 单次' }),
+      within(panel).getByRole('button', { name: '音效时长 5秒' }),
     );
-    const optionPanel = screen.getByRole('menu', { name: '音效参数选项' });
-    fireEvent.click(within(optionPanel).getByRole('button', { name: '循环' }));
-    fireEvent.change(within(optionPanel).getByLabelText('BPM数值'), {
-      target: { value: '120' },
-    });
-
-    expect(screen.getByLabelText('当前音效类型').textContent).toBe('loop');
-    expect(screen.getByLabelText('当前BPM').textContent).toBe('120');
+    const optionPanel = screen.getByRole('menu', { name: '音效时长选项' });
     expect(
-      screen.getByRole('button', { name: '音效参数 循环·120BPM' }),
+      within(optionPanel).getByRole('button', { name: '时长 2秒' }),
     ).toBeTruthy();
-
-    fireEvent.change(within(optionPanel).getByLabelText('BPM拖拉条'), {
-      target: { value: '88' },
-    });
-
-    expect(screen.getByLabelText('当前BPM').textContent).toBe('88');
     expect(
-      screen.getByRole('button', { name: '音效参数 循环·88BPM' }),
+      within(optionPanel).getByRole('button', { name: '时长 10秒' }),
+    ).toBeTruthy();
+    expect(within(optionPanel).queryByText(/BPM/u)).toBeNull();
+    fireEvent.click(within(optionPanel).getByRole('button', { name: '时长 8秒' }));
+
+    expect(screen.getByLabelText('当前音效时长').textContent).toBe('8');
+    expect(
+      screen.getByRole('button', { name: '音效时长 8秒' }),
     ).toBeTruthy();
 
     fireEvent.submit(panel);
     expect(onSubmitImageGeneration).toHaveBeenCalledWith(
       expect.objectContaining({
         mode: 'audio-sound-effect',
-        soundType: 'loop',
-        soundTempo: 88,
+        soundDurationSeconds: 8,
       }),
     );
   });
diff --git a/src/components/image-editor/ImageCanvasGenerationComposerView.tsx b/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
index 1b0760b99..1fab35065 100644
--- a/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationComposerView.tsx
@@ -36,10 +36,17 @@ import type {
   UploadTarget,
 } from './ImageCanvasEditorTypes';
 import {
+  calculateEditorBackgroundMusicPrice,
+  calculateEditorSoundEffectPrice,
   calculateEditorVideoPrice,
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
+  DEFAULT_BACKGROUND_MUSIC_MODEL,
+  DEFAULT_SOUND_EFFECT_DURATION_SECONDS,
+  DEFAULT_SOUND_EFFECT_MODEL,
+  EDITOR_SOUND_EFFECT_MODEL_OPTIONS,
+  SOUND_EFFECT_DURATION_OPTIONS,
   EDITOR_VIDEO_DURATION_OPTIONS,
   EDITOR_VIDEO_MODEL_OPTIONS,
+  resizeGenerationPlaceholderToVideoSelection,
   SPEC_TYPE_LABEL,
 } from './ImageCanvasGenerationModel';
 import { ImageCanvasIconSpritesheetComposerView } from './ImageCanvasIconSpritesheetComposerView';
@@ -278,7 +285,11 @@ function ImageCanvasVideoGenerationComposerView({
       (item) => item.value === dialog.videoModel,
     ) ?? EDITOR_VIDEO_MODEL_OPTIONS[0];
   const supportsReferences = isSeedanceVideoModel(currentModel.value);
-  const price = calculateEditorVideoPrice(resolution, durationSeconds);
+  const price = calculateEditorVideoPrice(
+    currentModel.value,
+    resolution,
+    durationSeconds,
+  );
   const isGenerating = dialog.status === 'generating';
   const closeVideoFloatingPanels = useCallback(() => {
     setOpenPanel(null);
@@ -298,10 +309,10 @@ function ImageCanvasVideoGenerationComposerView({
   const updateVideoDialog = (patch: Partial<GenerateDialogState>) => {
     setGenerateDialog((currentDialog) =>
       currentDialog?.mode === 'video'
-        ? {
+        ? resizeGenerationPlaceholderToVideoSelection({
             ...resetFailedVideoDialogStatus(currentDialog),
             ...patch,
-          }
+          })
         : currentDialog,
     );
   };
@@ -613,35 +624,11 @@ function ImageCanvasVideoGenerationComposerView({
   );
 }
 
-const SOUND_TYPE_OPTIONS = [
-  { label: '单次', value: 'one-shot' },
-  { label: '循环', value: 'loop' },
-] as const;
-const SOUND_BPM_MIN = 1;
-const SOUND_BPM_MAX = 300;
-const SOUND_BPM_SLIDER_FALLBACK = 120;
-
-function clampSoundBpm(value: number) {
-  return Math.min(
-    SOUND_BPM_MAX,
-    Math.max(SOUND_BPM_MIN, Math.round(value)),
-  );
-}
-
-function parseSoundBpmInput(value: string) {
-  const normalizedValue = value.trim();
-  if (!normalizedValue) {
-    return null;
+function normalizeSoundDuration(value: number | null | undefined) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return DEFAULT_SOUND_EFFECT_DURATION_SECONDS;
   }
-  const parsedValue = Number(normalizedValue);
-  return Number.isFinite(parsedValue) ? clampSoundBpm(parsedValue) : null;
-}
-
-function formatSoundEffectOptionLabel(
-  typeLabel: string,
-  soundTempo: number | null | undefined,
-) {
-  return soundTempo ? `${typeLabel}·${soundTempo}BPM` : typeLabel;
+  return Math.min(10, Math.max(2, Math.round(value)));
 }
 
 function resetFailedAudioDialogStatus(dialog: GenerateDialogState) {
@@ -672,21 +659,20 @@ function ImageCanvasAudioGenerationComposerView({
 }) {
   const [isSoundOptionsOpen, setIsSoundOptionsOpen] = useState(false);
   const soundOptionsButtonRef = useRef<HTMLButtonElement | null>(null);
+  const soundModelButtonRef = useRef<HTMLButtonElement | null>(null);
   const isSoundEffect = dialog.mode === 'audio-sound-effect';
   const isGenerating = dialog.status === 'generating';
-  const currentType =
-    SOUND_TYPE_OPTIONS.find((option) => option.value === dialog.soundType) ??
-    SOUND_TYPE_OPTIONS[0];
-  const currentTempo =
-    typeof dialog.soundTempo === 'number' ? dialog.soundTempo : null;
-  const soundOptionLabel = formatSoundEffectOptionLabel(
-    currentType.label,
-    currentTempo,
-  );
+  const soundModel = dialog.soundModel ?? DEFAULT_SOUND_EFFECT_MODEL;
+  const currentSoundModel =
+    EDITOR_SOUND_EFFECT_MODEL_OPTIONS.find(
+      (option) => option.value === soundModel,
+    ) ?? EDITOR_SOUND_EFFECT_MODEL_OPTIONS[0];
+  const soundDuration = normalizeSoundDuration(dialog.soundDurationSeconds);
+  const soundOptionLabel = `${soundDuration}秒`;
   const dialogLabel = isSoundEffect ? '生成游戏音效' : '生成游戏背景音乐';
   const cost = isSoundEffect
-    ? EDITOR_GENERATION_MUD_POINT_CONFIG.soundEffect
-    : EDITOR_GENERATION_MUD_POINT_CONFIG.backgroundMusic;
+    ? calculateEditorSoundEffectPrice(soundModel)
+    : calculateEditorBackgroundMusicPrice(DEFAULT_BACKGROUND_MUSIC_MODEL);
 
   useImageCanvasFloatingOptionDismiss({
     isOpen: isSoundOptionsOpen,
@@ -705,8 +691,8 @@ function ImageCanvasAudioGenerationComposerView({
     );
   };
 
-  const updateSoundTempo = (nextTempo: number | null) => {
-    updateAudioDialog({ soundTempo: nextTempo });
+  const updateSoundDuration = (durationSeconds: number) => {
+    updateAudioDialog({ soundDurationSeconds: normalizeSoundDuration(durationSeconds) });
   };
 
   return (
@@ -725,7 +711,7 @@ function ImageCanvasAudioGenerationComposerView({
     >
       <PlatformTextField
         variant="textarea"
-        aria-label={isSoundEffect ? 'sound提示词' : 'gpt_description_prompt'}
+        aria-label={isSoundEffect ? 'prompt' : 'gpt_description_prompt'}
         value={dialog.prompt}
         disabled={isGenerating}
         placeholder={
@@ -751,77 +737,64 @@ function ImageCanvasAudioGenerationComposerView({
       ) : null}
       <div className="image-canvas-editor__generation-composer-footer">
         {isSoundEffect ? (
-          <div className="image-canvas-editor__option-popover-anchor image-canvas-editor__option-popover-anchor--dimensions">
+          <>
             <PlatformInlineOptionButton
-              ref={soundOptionsButtonRef}
-              className="image-canvas-editor__option-cluster image-canvas-editor__option-cluster--dimensions"
-              aria-label={`音效参数 ${soundOptionLabel}`}
-              aria-expanded={isSoundOptionsOpen}
+              ref={soundModelButtonRef}
+              className="image-canvas-editor__option-cluster image-canvas-editor__option-cluster--model"
+              aria-label={`音效模型 ${currentSoundModel.label}`}
               disabled={isGenerating}
-              trailingIcon={<ChevronDown className="h-3 w-3" />}
-              onClick={() => setIsSoundOptionsOpen((isOpen) => !isOpen)}
             >
-              {soundOptionLabel}
+              <span className="image-canvas-editor__model-trigger-label">
+                <span
+                  className="image-canvas-editor__model-icon"
+                  aria-hidden="true"
+                >
+                  <Music />
+                </span>
+                <span>{currentSoundModel.label}</span>
+              </span>
             </PlatformInlineOptionButton>
-            {isSoundOptionsOpen
-              ? renderEditorPortal(
-                  <PlatformFloatingMenu
-                    className="image-canvas-editor__option-popover image-canvas-editor__option-popover--audio-options image-canvas-editor__portal-menu"
-                    label="音效参数选项"
-                    placement="top-start"
-                    style={buildPortalMenuStyle(
-                      soundOptionsButtonRef.current,
-                      'above',
-                    )}
-                  >
-                    <div className="image-canvas-editor__option-popover-items image-canvas-editor__audio-type-options">
-                      {SOUND_TYPE_OPTIONS.map((option) => (
-                        <VideoOptionChoice
-                          key={option.value}
-                          selected={currentType.value === option.value}
-                          disabled={isGenerating}
-                          ariaLabel={option.label}
-                          onClick={() =>
-                            updateAudioDialog({ soundType: option.value })
-                          }
-                        >
-                          {option.label}
-                        </VideoOptionChoice>
-                      ))}
-                    </div>
-                    <div className="image-canvas-editor__audio-bpm-control">
-                      <input
-                        type="range"
-                        min={SOUND_BPM_MIN}
-                        max={SOUND_BPM_MAX}
-                        value={currentTempo ?? SOUND_BPM_SLIDER_FALLBACK}
-                        disabled={isGenerating}
-                        aria-label="BPM拖拉条"
-                        onChange={(event) =>
-                          updateSoundTempo(
-                            clampSoundBpm(Number(event.target.value)),
-                          )
-                        }
-                      />
-                      <input
-                        type="number"
-                        min={SOUND_BPM_MIN}
-                        max={SOUND_BPM_MAX}
-                        value={currentTempo ?? ''}
-                        placeholder="BPM"
-                        disabled={isGenerating}
-                        aria-label="BPM数值"
-                        onChange={(event) =>
-                          updateSoundTempo(
-                            parseSoundBpmInput(event.target.value),
-                          )
-                        }
-                      />
-                    </div>
-                  </PlatformFloatingMenu>,
-                )
-              : null}
-          </div>
+            <div className="image-canvas-editor__option-popover-anchor image-canvas-editor__option-popover-anchor--dimensions">
+              <PlatformInlineOptionButton
+                ref={soundOptionsButtonRef}
+                className="image-canvas-editor__option-cluster image-canvas-editor__option-cluster--dimensions"
+                aria-label={`音效时长 ${soundOptionLabel}`}
+                aria-expanded={isSoundOptionsOpen}
+                disabled={isGenerating}
+                trailingIcon={<ChevronDown className="h-3 w-3" />}
+                onClick={() => setIsSoundOptionsOpen((isOpen) => !isOpen)}
+              >
+                {soundOptionLabel}
+              </PlatformInlineOptionButton>
+              {isSoundOptionsOpen
+                ? renderEditorPortal(
+                    <PlatformFloatingMenu
+                      className="image-canvas-editor__option-popover image-canvas-editor__option-popover--audio-options image-canvas-editor__portal-menu"
+                      label="音效时长选项"
+                      placement="top-start"
+                      style={buildPortalMenuStyle(
+                        soundOptionsButtonRef.current,
+                        'above',
+                      )}
+                    >
+                      <div className="image-canvas-editor__option-popover-items image-canvas-editor__audio-type-options">
+                        {SOUND_EFFECT_DURATION_OPTIONS.map((option) => (
+                          <VideoOptionChoice
+                            key={option}
+                            selected={soundDuration === option}
+                            disabled={isGenerating}
+                            ariaLabel={`时长 ${option}秒`}
+                            onClick={() => updateSoundDuration(option)}
+                          >
+                            {option}秒
+                          </VideoOptionChoice>
+                        ))}
+                      </div>
+                    </PlatformFloatingMenu>,
+                  )
+                : null}
+            </div>
+          </>
         ) : null}
         <PlatformActionButton
           type="submit"
@@ -1009,6 +982,7 @@ export function ImageCanvasGenerationComposerView({
           renderEditorPortal={renderEditorPortal}
           buildPortalMenuStyle={buildPortalMenuStyle}
           onRequestUpload={onRequestUpload}
+          onRememberImageModel={onRememberImageModel}
           onSubmit={onSubmitImageGeneration}
         />
       ) : null}
diff --git a/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts b/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
index 3f9c0313d..d89dd3c86 100644
--- a/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationDialogModel.test.ts
@@ -12,6 +12,7 @@ import {
   assignIconSpecReference,
   assignUiDesignSpecReference,
   closeGenerateComposerDialog,
+  createAudioRedrawGenerationDialogDraft,
   createBackgroundMusicGenerationDialogDraft,
   createCharacterAnimationGenerationDialogDraft,
   createCharacterAnimationPanelDraft,
@@ -19,6 +20,7 @@ import {
   createEditDialogDraft,
   createGenerateDialogDraft,
   createIconGenerationDialogDraft,
+  createPublicationGenerationDialogDraft,
   createQuickEditPanelDraft,
   createSoundEffectGenerationDialogDraft,
   createSpecDialogDraft,
@@ -60,12 +62,12 @@ describe('ImageCanvasGenerationDialogModel', () => {
       status: 'idle',
       composerOpen: true,
       placeholder: {
-        x: -10,
-        y: -30,
-        width: 420,
-        height: 420,
-        originalWidth: 2048,
-        originalHeight: 2048,
+        x: -312,
+        y: -332,
+        width: 1024,
+        height: 1024,
+        originalWidth: 1024,
+        originalHeight: 1024,
       },
     });
     expect(
@@ -78,10 +80,36 @@ describe('ImageCanvasGenerationDialogModel', () => {
         artStyle: '清爽卡通',
       },
       placeholder: {
-        x: -80,
-        y: 22.5,
-        width: 560,
-        height: 315,
+        x: -824,
+        y: -396,
+        width: 2048,
+        height: 1152,
+        originalWidth: 2048,
+        originalHeight: 1152,
+      },
+    });
+  });
+
+  it('creates publication material drafts with the workflow output size', () => {
+    const canvasSize = { width: 960, height: 720 };
+    const viewport = { x: 0, y: 0, scale: 1 };
+
+    expect(
+      createPublicationGenerationDialogDraft({
+        canvasSize,
+        viewport,
+        workflowId: 'publication-promo-poster',
+      }),
+    ).toMatchObject({
+      mode: 'publication',
+      publicationWorkflowId: 'publication-promo-poster',
+      placeholder: {
+        x: -160,
+        y: 0,
+        width: 1280,
+        height: 720,
+        originalWidth: 1280,
+        originalHeight: 720,
       },
     });
   });
@@ -104,10 +132,10 @@ describe('ImageCanvasGenerationDialogModel', () => {
       characterSpecReference: null,
       characterReferences: [],
       placeholder: {
-        x: 270,
-        y: 150,
-        width: 420,
-        height: 420,
+        x: -32,
+        y: -152,
+        width: 1024,
+        height: 1024,
       },
     });
     expect(
@@ -132,10 +160,10 @@ describe('ImageCanvasGenerationDialogModel', () => {
         '冻结按钮',
       ],
       placeholder: {
-        x: 300,
-        y: 180,
-        width: 360,
-        height: 360,
+        x: -32,
+        y: -152,
+        width: 1024,
+        height: 1024,
       },
     });
   });
@@ -157,12 +185,12 @@ describe('ImageCanvasGenerationDialogModel', () => {
         videoMode: 'std',
         videoSound: 'off',
         placeholder: {
-          x: 200,
-          y: 202.5,
-          width: 560,
-          height: 315,
-          originalWidth: 1280,
-          originalHeight: 720,
+          x: 53,
+          y: 120,
+          width: 854,
+          height: 480,
+          originalWidth: 854,
+          originalHeight: 480,
         },
       });
     expect(
@@ -178,10 +206,10 @@ describe('ImageCanvasGenerationDialogModel', () => {
       imageSize: '1K',
       uiDesignSpecReference: null,
       placeholder: {
-        x: 200,
-        y: 202.5,
-        width: 560,
-        height: 315,
+        x: -32,
+        y: 72,
+        width: 1024,
+        height: 576,
       },
     });
   });
@@ -195,8 +223,8 @@ describe('ImageCanvasGenerationDialogModel', () => {
         mode: 'audio-sound-effect',
         status: 'idle',
         composerOpen: true,
-        soundType: 'one-shot',
-        soundTempo: null,
+        soundModel: 'audio1.0',
+        soundDurationSeconds: 5,
         placeholder: {
           x: 270,
           y: 300,
@@ -221,6 +249,64 @@ describe('ImageCanvasGenerationDialogModel', () => {
       });
   });
 
+  it('creates audio remodel drafts from generated audio layers without references', () => {
+    const soundLayer = createLayer({
+      id: 'layer-sfx',
+      title: '游戏音效',
+      mediaType: 'audio',
+      assetKind: 'sound-effect',
+      prompt: '金币收集音',
+      generationInputs: {
+        fields: [
+          { title: 'prompt', value: '金币收集音' },
+          { title: 'model', value: 'audio1.0' },
+          { title: 'duration', value: '7秒' },
+        ],
+        references: [],
+      },
+    });
+    const musicLayer = createLayer({
+      id: 'layer-music',
+      title: '游戏背景音乐',
+      mediaType: 'audio',
+      assetKind: 'background-music',
+      prompt: '',
+      generationInputs: {
+        fields: [{ title: 'gpt_description_prompt', value: '地牢循环音乐' }],
+        references: [],
+      },
+    });
+
+    expect(createAudioRedrawGenerationDialogDraft(soundLayer)).toMatchObject({
+      mode: 'audio-sound-effect',
+      sourceLayerId: 'layer-sfx',
+      prompt: '金币收集音',
+      soundModel: 'audio1.0',
+      soundDurationSeconds: 7,
+      composerOpen: true,
+      placeholder: {
+        x: 472,
+        y: 140,
+        width: 420,
+        height: 120,
+      },
+    });
+    expect(createAudioRedrawGenerationDialogDraft(musicLayer)).toMatchObject({
+      mode: 'audio-background-music',
+      sourceLayerId: 'layer-music',
+      prompt: '地牢循环音乐',
+      makeInstrumental: true,
+      composerOpen: true,
+      placeholder: {
+        x: 472,
+        y: 140,
+        width: 420,
+        height: 120,
+      },
+    });
+    expect(createAudioRedrawGenerationDialogDraft(createLayer())).toBeNull();
+  });
+
   it('creates edit, quick-edit, and character animation panel drafts', () => {
     const sourceLayer = createLayer({
       prompt: '原图提示',
diff --git a/src/components/image-editor/ImageCanvasGenerationDialogModel.ts b/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
index 856ee36f3..a1fcfb8c8 100644
--- a/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationDialogModel.ts
@@ -16,27 +16,21 @@ import {
   CHARACTER_ANIMATION_FRAME_DISPLAY_SIZE,
   CHARACTER_ANIMATION_FRAME_ORIGINAL_SIZE,
   CHARACTER_ANIMATION_DURATION_OPTIONS,
-  CHARACTER_FRAME_DISPLAY_SIZE,
-  CHARACTER_FRAME_ORIGINAL_SIZE,
   appendLimitedQuickEditReferences,
   createCanvasLayerReference,
   DEFAULT_ICON_DESCRIPTIONS,
   DEFAULT_IMAGE_MODEL,
+  DEFAULT_SOUND_EFFECT_DURATION_SECONDS,
   DEFAULT_PUBLICATION_GAME_INFO,
+  DEFAULT_SOUND_EFFECT_MODEL,
   DEFAULT_SPEC_FORM_VALUES,
   DEFAULT_VIDEO_MODEL,
   EDITOR_IMAGE_DIMENSION_OPTIONS,
   ICON_DESCRIPTION_LIMIT,
-  ICON_FRAME_DISPLAY_SIZE,
-  ICON_FRAME_ORIGINAL_SIZE,
-  PUBLICATION_FRAME_DISPLAY_SIZE,
   PUBLICATION_FRAME_ORIGINAL_SIZE,
-  SPEC_FRAME_DISPLAY_SIZE,
+  resolveEditorImageGenerationPixelSize,
+  resolveEditorVideoGenerationPixelSize,
   SPEC_FRAME_ORIGINAL_SIZE,
-  UI_DESIGN_FRAME_DISPLAY_SIZE,
-  UI_DESIGN_FRAME_ORIGINAL_SIZE,
-  VIDEO_FRAME_DISPLAY_SIZE,
-  VIDEO_FRAME_ORIGINAL_SIZE,
 } from './ImageCanvasGenerationModel';
 
 type CanvasSize = { width: number; height: number };
@@ -151,10 +145,13 @@ export function createGenerateDialogDraft({
   canvasSize: CanvasSize;
   viewport: CanvasViewport;
 }): Omit<CanvasGenerationDialogState, 'id'> {
-  const placeholderWidth = 420;
-  const placeholderHeight = 420;
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
   const dimensionDefaults = resolveImageDimensionDefaults(DEFAULT_IMAGE_MODEL);
+  const placeholderSize = resolveEditorImageGenerationPixelSize({
+    model: DEFAULT_IMAGE_MODEL,
+    aspectRatio: dimensionDefaults.aspectRatio,
+    imageSize: dimensionDefaults.imageSize,
+  });
   return {
     mode: 'generate',
     prompt: '',
@@ -164,12 +161,12 @@ export function createGenerateDialogDraft({
     aspectRatio: dimensionDefaults.aspectRatio,
     imageSize: dimensionDefaults.imageSize,
     placeholder: {
-      x: worldCenter.x - placeholderWidth / 2,
-      y: worldCenter.y - placeholderHeight / 2,
-      width: placeholderWidth,
-      height: placeholderHeight,
-      originalWidth: 2048,
-      originalHeight: 2048,
+      x: worldCenter.x - placeholderSize.width / 2,
+      y: worldCenter.y - placeholderSize.height / 2,
+      width: placeholderSize.width,
+      height: placeholderSize.height,
+      originalWidth: placeholderSize.width,
+      originalHeight: placeholderSize.height,
     },
   };
 }
@@ -192,10 +189,10 @@ export function createSpecDialogDraft({
     specType,
     specValues: { ...DEFAULT_SPEC_FORM_VALUES[specType] },
     placeholder: {
-      x: worldCenter.x - SPEC_FRAME_DISPLAY_SIZE.width / 2,
-      y: worldCenter.y - SPEC_FRAME_DISPLAY_SIZE.height / 2,
-      width: SPEC_FRAME_DISPLAY_SIZE.width,
-      height: SPEC_FRAME_DISPLAY_SIZE.height,
+      x: worldCenter.x - SPEC_FRAME_ORIGINAL_SIZE.width / 2,
+      y: worldCenter.y - SPEC_FRAME_ORIGINAL_SIZE.height / 2,
+      width: SPEC_FRAME_ORIGINAL_SIZE.width,
+      height: SPEC_FRAME_ORIGINAL_SIZE.height,
       originalWidth: SPEC_FRAME_ORIGINAL_SIZE.width,
       originalHeight: SPEC_FRAME_ORIGINAL_SIZE.height,
     },
@@ -213,6 +210,11 @@ export function createCharacterGenerationDialogDraft({
 }): Omit<CanvasGenerationDialogState, 'id'> {
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
   const dimensionDefaults = resolveImageDimensionDefaults(imageModel);
+  const placeholderSize = resolveEditorImageGenerationPixelSize({
+    model: imageModel,
+    aspectRatio: dimensionDefaults.aspectRatio,
+    imageSize: dimensionDefaults.imageSize,
+  });
   return {
     mode: 'character',
     prompt: '',
@@ -224,12 +226,12 @@ export function createCharacterGenerationDialogDraft({
     aspectRatio: dimensionDefaults.aspectRatio,
     imageSize: dimensionDefaults.imageSize,
     placeholder: {
-      x: worldCenter.x - CHARACTER_FRAME_DISPLAY_SIZE.width / 2,
-      y: worldCenter.y - CHARACTER_FRAME_DISPLAY_SIZE.height / 2,
-      width: CHARACTER_FRAME_DISPLAY_SIZE.width,
-      height: CHARACTER_FRAME_DISPLAY_SIZE.height,
-      originalWidth: CHARACTER_FRAME_ORIGINAL_SIZE.width,
-      originalHeight: CHARACTER_FRAME_ORIGINAL_SIZE.height,
+      x: worldCenter.x - placeholderSize.width / 2,
+      y: worldCenter.y - placeholderSize.height / 2,
+      width: placeholderSize.width,
+      height: placeholderSize.height,
+      originalWidth: placeholderSize.width,
+      originalHeight: placeholderSize.height,
     },
   };
 }
@@ -245,6 +247,11 @@ export function createIconGenerationDialogDraft({
 }): Omit<CanvasGenerationDialogState, 'id'> {
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
   const dimensionDefaults = resolveImageDimensionDefaults(imageModel);
+  const placeholderSize = resolveEditorImageGenerationPixelSize({
+    model: imageModel,
+    aspectRatio: dimensionDefaults.aspectRatio,
+    imageSize: dimensionDefaults.imageSize,
+  });
   return {
     mode: 'icon',
     prompt: formatIconDescriptionsText(DEFAULT_ICON_DESCRIPTIONS),
@@ -256,12 +263,12 @@ export function createIconGenerationDialogDraft({
     aspectRatio: dimensionDefaults.aspectRatio,
     imageSize: dimensionDefaults.imageSize,
     placeholder: {
-      x: worldCenter.x - ICON_FRAME_DISPLAY_SIZE.width / 2,
-      y: worldCenter.y - ICON_FRAME_DISPLAY_SIZE.height / 2,
-      width: ICON_FRAME_DISPLAY_SIZE.width,
-      height: ICON_FRAME_DISPLAY_SIZE.height,
-      originalWidth: ICON_FRAME_ORIGINAL_SIZE.width,
-      originalHeight: ICON_FRAME_ORIGINAL_SIZE.height,
+      x: worldCenter.x - placeholderSize.width / 2,
+      y: worldCenter.y - placeholderSize.height / 2,
+      width: placeholderSize.width,
+      height: placeholderSize.height,
+      originalWidth: placeholderSize.width,
+      originalHeight: placeholderSize.height,
     },
   };
 }
@@ -276,7 +283,6 @@ export function createPublicationGenerationDialogDraft({
   workflowId: PublicationMaterialsWorkflowId;
 }): Omit<CanvasGenerationDialogState, 'id'> {
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
-  const frameDisplaySize = PUBLICATION_FRAME_DISPLAY_SIZE[workflowId];
   const frameOriginalSize = PUBLICATION_FRAME_ORIGINAL_SIZE[workflowId];
   return {
     mode: 'publication',
@@ -287,10 +293,10 @@ export function createPublicationGenerationDialogDraft({
     publicationGameInfo: { ...DEFAULT_PUBLICATION_GAME_INFO },
     publicationReferences: [],
     placeholder: {
-      x: worldCenter.x - frameDisplaySize.width / 2,
-      y: worldCenter.y - frameDisplaySize.height / 2,
-      width: frameDisplaySize.width,
-      height: frameDisplaySize.height,
+      x: worldCenter.x - frameOriginalSize.width / 2,
+      y: worldCenter.y - frameOriginalSize.height / 2,
+      width: frameOriginalSize.width,
+      height: frameOriginalSize.height,
       originalWidth: frameOriginalSize.width,
       originalHeight: frameOriginalSize.height,
     },
@@ -305,6 +311,10 @@ export function createVideoGenerationDialogDraft({
   viewport: CanvasViewport;
 }): Omit<CanvasGenerationDialogState, 'id'> {
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
+  const placeholderSize = resolveEditorVideoGenerationPixelSize({
+    aspectRatio: '16:9',
+    resolution: '480p',
+  });
   return {
     mode: 'video',
     prompt: '',
@@ -318,12 +328,12 @@ export function createVideoGenerationDialogDraft({
     videoMode: 'std',
     videoSound: 'off',
     placeholder: {
-      x: worldCenter.x - VIDEO_FRAME_DISPLAY_SIZE.width / 2,
-      y: worldCenter.y - VIDEO_FRAME_DISPLAY_SIZE.height / 2,
-      width: VIDEO_FRAME_DISPLAY_SIZE.width,
-      height: VIDEO_FRAME_DISPLAY_SIZE.height,
-      originalWidth: VIDEO_FRAME_ORIGINAL_SIZE.width,
-      originalHeight: VIDEO_FRAME_ORIGINAL_SIZE.height,
+      x: worldCenter.x - placeholderSize.width / 2,
+      y: worldCenter.y - placeholderSize.height / 2,
+      width: placeholderSize.width,
+      height: placeholderSize.height,
+      originalWidth: placeholderSize.width,
+      originalHeight: placeholderSize.height,
     },
   };
 }
@@ -341,8 +351,8 @@ export function createSoundEffectGenerationDialogDraft({
     prompt: '',
     status: 'idle',
     composerOpen: true,
-    soundType: 'one-shot',
-    soundTempo: null,
+    soundModel: DEFAULT_SOUND_EFFECT_MODEL,
+    soundDurationSeconds: DEFAULT_SOUND_EFFECT_DURATION_SECONDS,
     placeholder: {
       x: worldCenter.x - AUDIO_FRAME_DISPLAY_SIZE.width / 2,
       y: worldCenter.y - AUDIO_FRAME_DISPLAY_SIZE.height / 2,
@@ -379,6 +389,105 @@ export function createBackgroundMusicGenerationDialogDraft({
   };
 }
 
+function findGenerationInputFieldValue(
+  layer: CanvasLayer,
+  titles: string[],
+) {
+  const normalizedTitles = new Set(titles.map((title) => title.toLowerCase()));
+  return (
+    layer.generationInputs?.fields.find((field) =>
+      normalizedTitles.has(field.title.trim().toLowerCase()),
+    )?.value ?? null
+  );
+}
+
+function resolveAudioRedrawPrompt(sourceLayer: CanvasLayer) {
+  return (
+    sourceLayer.prompt?.trim() ||
+    findGenerationInputFieldValue(sourceLayer, [
+      'prompt',
+      'sound',
+      'gpt_description_prompt',
+      '生成提示词',
+      '音效提示词',
+      '背景音乐提示词',
+    ])?.trim() ||
+    sourceLayer.generationInputs?.fields[0]?.value?.trim() ||
+    ''
+  );
+}
+
+function resolveAudioRedrawMode(sourceLayer: CanvasLayer) {
+  if (sourceLayer.assetKind === 'background-music') {
+    return 'audio-background-music' as const;
+  }
+  if (sourceLayer.assetKind === 'sound-effect') {
+    return 'audio-sound-effect' as const;
+  }
+  if (sourceLayer.mediaType !== 'audio') {
+    return null;
+  }
+  return sourceLayer.title.includes('背景音乐')
+    ? ('audio-background-music' as const)
+    : ('audio-sound-effect' as const);
+}
+
+function resolveAudioRedrawSoundModel(
+  sourceLayer: CanvasLayer,
+): NonNullable<GenerateDialogState['soundModel']> {
+  const fieldValue = findGenerationInputFieldValue(sourceLayer, ['model'])
+    ?.trim();
+  // 中文注释：编辑器音效改造入口当前只暴露 Vidu audio1.0，历史快照里的其他模型统一回落到默认模型。
+  return fieldValue === DEFAULT_SOUND_EFFECT_MODEL ? 'audio1.0' : 'audio1.0';
+}
+
+function resolveAudioRedrawSoundDuration(sourceLayer: CanvasLayer) {
+  const fieldValue = findGenerationInputFieldValue(sourceLayer, ['duration']);
+  const matchedValue = fieldValue?.match(/\d+/u)?.[0];
+  const duration = matchedValue ? Number.parseInt(matchedValue, 10) : null;
+  if (!duration || !Number.isFinite(duration)) {
+    return DEFAULT_SOUND_EFFECT_DURATION_SECONDS;
+  }
+  return Math.min(10, Math.max(2, duration));
+}
+
+export function createAudioRedrawGenerationDialogDraft(
+  sourceLayer: CanvasLayer,
+): Omit<CanvasGenerationDialogState, 'id'> | null {
+  const mode = resolveAudioRedrawMode(sourceLayer);
+  if (!mode) {
+    return null;
+  }
+  const baseDraft = {
+    mode,
+    sourceLayerId: sourceLayer.id,
+    prompt: resolveAudioRedrawPrompt(sourceLayer),
+    status: 'idle' as const,
+    composerOpen: true,
+    placeholder: {
+      x: sourceLayer.x + sourceLayer.width + 32,
+      y: sourceLayer.y,
+      width: AUDIO_FRAME_DISPLAY_SIZE.width,
+      height: AUDIO_FRAME_DISPLAY_SIZE.height,
+      originalWidth: AUDIO_FRAME_ORIGINAL_SIZE.width,
+      originalHeight: AUDIO_FRAME_ORIGINAL_SIZE.height,
+    },
+  };
+
+  if (mode === 'audio-background-music') {
+    return {
+      ...baseDraft,
+      makeInstrumental: true,
+    };
+  }
+
+  return {
+    ...baseDraft,
+    soundModel: resolveAudioRedrawSoundModel(sourceLayer),
+    soundDurationSeconds: resolveAudioRedrawSoundDuration(sourceLayer),
+  };
+}
+
 export function createUiDesignGenerationDialogDraft({
   canvasSize,
   viewport,
@@ -390,6 +499,11 @@ export function createUiDesignGenerationDialogDraft({
 }): Omit<CanvasGenerationDialogState, 'id'> {
   const worldCenter = getViewportWorldCenter({ canvasSize, viewport });
   const dimensionDefaults = resolveImageDimensionDefaults(imageModel);
+  const placeholderSize = resolveEditorImageGenerationPixelSize({
+    model: imageModel,
+    aspectRatio: '16:9',
+    imageSize: dimensionDefaults.imageSize,
+  });
   return {
     mode: 'ui-design',
     prompt: '',
@@ -400,12 +514,12 @@ export function createUiDesignGenerationDialogDraft({
     aspectRatio: '16:9',
     imageSize: dimensionDefaults.imageSize,
     placeholder: {
-      x: worldCenter.x - UI_DESIGN_FRAME_DISPLAY_SIZE.width / 2,
-      y: worldCenter.y - UI_DESIGN_FRAME_DISPLAY_SIZE.height / 2,
-      width: UI_DESIGN_FRAME_DISPLAY_SIZE.width,
-      height: UI_DESIGN_FRAME_DISPLAY_SIZE.height,
-      originalWidth: UI_DESIGN_FRAME_ORIGINAL_SIZE.width,
-      originalHeight: UI_DESIGN_FRAME_ORIGINAL_SIZE.height,
+      x: worldCenter.x - placeholderSize.width / 2,
+      y: worldCenter.y - placeholderSize.height / 2,
+      width: placeholderSize.width,
+      height: placeholderSize.height,
+      originalWidth: placeholderSize.width,
+      originalHeight: placeholderSize.height,
     },
   };
 }
diff --git a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.test.tsx b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.test.tsx
index eb71e4913..c0f4acc84 100644
--- a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.test.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.test.tsx
@@ -38,6 +38,18 @@ function ImageOptionsHarness({
       <output aria-label="当前尺寸">{dialog.imageSize}</output>
       <output aria-label="当前状态">{dialog.status}</output>
       <output aria-label="当前错误">{dialog.errorMessage ?? '-'}</output>
+      <output aria-label="当前占位">
+        {dialog.placeholder
+          ? [
+              dialog.placeholder.x,
+              dialog.placeholder.y,
+              dialog.placeholder.width,
+              dialog.placeholder.height,
+              dialog.placeholder.originalWidth,
+              dialog.placeholder.originalHeight,
+            ].join(':')
+          : '-'}
+      </output>
     </div>
   ) : null;
 }
@@ -174,4 +186,38 @@ describe('ImageCanvasGenerationImageOptionsView', () => {
     const submit = screen.getByRole('button', { name: '生成角色形象' });
     expect(submit.textContent).toBe('生成12泥点');
   });
+
+  it('keeps the canvas placeholder centered while syncing its ratio and size selection', () => {
+    render(
+      <ImageOptionsHarness
+        initialDialog={{
+          mode: 'character',
+          prompt: '',
+          status: 'idle',
+          imageModel: IMAGE_MODEL_NANOBANANA2,
+          aspectRatio: '1:1',
+          imageSize: '1K',
+          placeholder: {
+            x: 100,
+            y: 200,
+            width: 420,
+            height: 420,
+            originalWidth: 1024,
+            originalHeight: 1024,
+          },
+        }}
+      />,
+    );
+
+    fireEvent.click(
+      screen.getByRole('button', { name: '生成图片尺寸 1:1 · 1K' }),
+    );
+    const panel = screen.getByRole('menu', { name: '生成图片尺寸选项' });
+    fireEvent.click(within(panel).getByRole('button', { name: '16:9' }));
+    fireEvent.click(within(panel).getByRole('button', { name: '2K' }));
+
+    expect(screen.getByLabelText('当前占位').textContent).toBe(
+      '-714:-166:2048:1152:2048:1152',
+    );
+  });
 });
diff --git a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
index a4f6e40f7..93e1ccc70 100644
--- a/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
+++ b/src/components/image-editor/ImageCanvasGenerationImageOptionsView.tsx
@@ -17,6 +17,7 @@ import {
   EDITOR_IMAGE_DIMENSION_OPTIONS,
   EDITOR_IMAGE_MODEL_OPTIONS,
   IMAGE_MODEL_NANOBANANA2,
+  resizeGenerationPlaceholderToImageSelection,
 } from './ImageCanvasGenerationModel';
 import { useImageCanvasFloatingOptionDismiss } from './useImageCanvasFloatingOptionDismiss';
 
@@ -136,10 +137,10 @@ export function ImageCanvasGenerationImageOptionsView({
   const updateDialog = (patch: Partial<GenerateDialogState>) => {
     setGenerateDialog((currentDialog) =>
       currentDialog && currentDialog.mode === dialog.mode
-        ? {
+        ? resizeGenerationPlaceholderToImageSelection({
             ...resetFailedDialogStatus(currentDialog),
             ...patch,
-          }
+          })
         : currentDialog,
     );
   };
@@ -153,7 +154,7 @@ export function ImageCanvasGenerationImageOptionsView({
       const nextOptions = getImageDimensionOptions(model);
       const nextAspectRatios = nextOptions.aspectRatios as readonly string[];
       const nextImageSizes = nextOptions.imageSizes as readonly string[];
-      return {
+      return resizeGenerationPlaceholderToImageSelection({
         ...resetFailedDialogStatus(currentDialog),
         imageModel: model,
         aspectRatio:
@@ -167,7 +168,7 @@ export function ImageCanvasGenerationImageOptionsView({
             ? currentDialog.imageSize
             : (nextOptions.imageSizes.find((size) => size === '1K') ??
               nextOptions.imageSizes[0]),
-      };
+      });
     });
   };
 
diff --git a/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts b/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
index 1c6b32607..5f6815880 100644
--- a/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationLayerModel.test.ts
@@ -292,7 +292,7 @@ describe('ImageCanvasGenerationLayerModel', () => {
         originalHeight: 120,
       },
       generationInputs: {
-        fields: [{ title: 'sound', value: '金币掉落叮当声' }],
+        fields: [{ title: 'prompt', value: '金币掉落叮当声' }],
         references: [],
       },
     });
diff --git a/src/components/image-editor/ImageCanvasGenerationModel.test.ts b/src/components/image-editor/ImageCanvasGenerationModel.test.ts
index 66eda2460..4d35535af 100644
--- a/src/components/image-editor/ImageCanvasGenerationModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationModel.test.ts
@@ -6,6 +6,7 @@ import type {
   CanvasLayer,
 } from './ImageCanvasEditorTypes';
 import {
+  BACKGROUND_MUSIC_MODEL_SUNO,
   buildCharacterGenerationInputs,
   buildEditGenerationInputs,
   buildIconGenerationInputs,
@@ -15,15 +16,118 @@ import {
   buildSoundEffectGenerationInputs,
   buildSpecGenerationInputs,
   buildSpecPrompt,
+  calculateCharacterAnimationPrice,
+  calculateEditorBackgroundMusicPrice,
+  calculateEditorIconSpritesheetPrice,
+  calculateEditorImageGenerationPrice,
+  calculateEditorImageModelPrice,
+  calculateEditorSoundEffectPrice,
+  calculateEditorSpecGenerationPrice,
+  calculateEditorUiDesignPrice,
+  calculateEditorVideoPrice,
+  CHARACTER_ANIMATION_MODEL,
   DEFAULT_IMAGE_MODEL,
+  DEFAULT_SOUND_EFFECT_MODEL,
+  DEFAULT_VIDEO_MODEL,
+  EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG,
+  EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG,
+  EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG,
+  EDITOR_IMAGE_MODEL_OPTIONS,
+  EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG,
+  EDITOR_SOUND_EFFECT_MODEL_OPTIONS,
+  EDITOR_SPEC_MODEL_MUD_POINT_CONFIG,
+  EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG,
+  EDITOR_VIDEO_MODEL_OPTIONS,
   getGenerationFrameAriaLabel,
   getGenerationFrameLabel,
+  IMAGE_MODEL_GPT_IMAGE_2,
   normalizeQuickEditPromptSourceReference,
   resolveCharacterAnimationSourceImageSrc,
   resolveImageGenerationErrorMessage,
+  VIDEO_MODEL_KLING_3,
+  VIDEO_MODEL_KLING_3_OMNI,
+  VIDEO_MODEL_SEEDANCE_2,
+  VIDEO_MODEL_SEEDANCE_2_FAST,
+  VIDEO_MODEL_VEO_3_1,
+  VIDEO_MODEL_VEO_3_1_FAST,
 } from './ImageCanvasGenerationModel';
 
 describe('ImageCanvasGenerationModel', () => {
+  it('为所有编辑器生成模型提供显式定价配置', () => {
+    expect(
+      EDITOR_IMAGE_MODEL_OPTIONS.map((option) => option.value).filter(
+        (model) => !(model in EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG),
+      ),
+    ).toEqual([]);
+    expect(
+      EDITOR_VIDEO_MODEL_OPTIONS.map((option) => option.value).filter(
+        (model) => !(model in EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG),
+      ),
+    ).toEqual([]);
+    expect(
+      EDITOR_SOUND_EFFECT_MODEL_OPTIONS.map((option) => option.value).filter(
+        (model) => !(model in EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG),
+      ),
+    ).toEqual([]);
+    expect(EDITOR_SPEC_MODEL_MUD_POINT_CONFIG[IMAGE_MODEL_GPT_IMAGE_2]).toBe(5);
+    expect(
+      EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG[CHARACTER_ANIMATION_MODEL],
+    ).toBeTruthy();
+    expect(
+      EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG[BACKGROUND_MUSIC_MODEL_SUNO],
+    ).toBe(5);
+    // 中文注释：Veo 已从前端入口移除，但客户端类型和后端兼容层仍保留，定价表也必须覆盖，避免旧布局回放或测试请求价格漂移。
+    expect(EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[VIDEO_MODEL_VEO_3_1]).toBeTruthy();
+    expect(
+      EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[VIDEO_MODEL_VEO_3_1_FAST],
+    ).toBeTruthy();
+  });
+
+  it('所有生成按钮价格都从模型定价配置推导', () => {
+    expect(calculateEditorImageModelPrice(DEFAULT_IMAGE_MODEL)).toBe(
+      EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG[DEFAULT_IMAGE_MODEL],
+    );
+    expect(
+      calculateEditorImageGenerationPrice({
+        kind: 'character',
+        model: IMAGE_MODEL_GPT_IMAGE_2,
+      }),
+    ).toBe(EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG[IMAGE_MODEL_GPT_IMAGE_2]);
+    expect(calculateEditorIconSpritesheetPrice(DEFAULT_IMAGE_MODEL)).toBe(
+      EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG[DEFAULT_IMAGE_MODEL],
+    );
+    expect(calculateEditorUiDesignPrice(IMAGE_MODEL_GPT_IMAGE_2)).toBe(
+      EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG[IMAGE_MODEL_GPT_IMAGE_2],
+    );
+    expect(calculateEditorSpecGenerationPrice(IMAGE_MODEL_GPT_IMAGE_2)).toBe(
+      EDITOR_SPEC_MODEL_MUD_POINT_CONFIG[IMAGE_MODEL_GPT_IMAGE_2],
+    );
+    expect(calculateEditorVideoPrice(DEFAULT_VIDEO_MODEL, '720p', 5)).toBe(
+      EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[DEFAULT_VIDEO_MODEL]['720p'] * 5,
+    );
+    expect(calculateEditorVideoPrice(VIDEO_MODEL_SEEDANCE_2, '480p', 4)).toBe(
+      EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[VIDEO_MODEL_SEEDANCE_2]['480p'] * 4,
+    );
+    expect(calculateEditorVideoPrice(VIDEO_MODEL_KLING_3, '480p', 4)).toBe(
+      EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[VIDEO_MODEL_KLING_3]['480p'] * 4,
+    );
+    expect(calculateEditorVideoPrice(VIDEO_MODEL_KLING_3_OMNI, '720p', 5)).toBe(
+      EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[VIDEO_MODEL_KLING_3_OMNI]['720p'] * 5,
+    );
+    expect(calculateCharacterAnimationPrice(CHARACTER_ANIMATION_MODEL, '720p', 6))
+      .toBe(
+        EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG[
+          CHARACTER_ANIMATION_MODEL
+        ]['720p'] * 6,
+      );
+    expect(calculateEditorSoundEffectPrice(DEFAULT_SOUND_EFFECT_MODEL)).toBe(
+      EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG[DEFAULT_SOUND_EFFECT_MODEL],
+    );
+    expect(calculateEditorBackgroundMusicPrice(BACKGROUND_MUSIC_MODEL_SUNO)).toBe(
+      EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG[BACKGROUND_MUSIC_MODEL_SUNO],
+    );
+  });
+
   it('builds user-facing generation input snapshots instead of backend prompts', () => {
     expect(buildImageGenerationInputs('  一张明亮主视觉  ')).toEqual({
       fields: [{ title: '生成提示词', value: '一张明亮主视觉' }],
@@ -207,11 +311,12 @@ describe('ImageCanvasGenerationModel', () => {
       'Quick Edit Generator',
     );
     expect(
-      buildSoundEffectGenerationInputs('金币掉落叮当声', 'one-shot', null),
+      buildSoundEffectGenerationInputs('金币掉落叮当声', 'audio1.0', 7),
     ).toEqual({
       fields: [
-        { title: 'sound', value: '金币掉落叮当声' },
-        { title: 'type', value: 'one-shot' },
+        { title: 'prompt', value: '金币掉落叮当声' },
+        { title: 'model', value: 'audio1.0' },
+        { title: 'duration', value: '7秒' },
       ],
       references: [],
     });
diff --git a/src/components/image-editor/ImageCanvasGenerationModel.ts b/src/components/image-editor/ImageCanvasGenerationModel.ts
index b250540d0..cebc0d7a7 100644
--- a/src/components/image-editor/ImageCanvasGenerationModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationModel.ts
@@ -39,7 +39,6 @@ export const EDITOR_GENERATION_MUD_POINT_CONFIG = {
   soundEffect: 10,
   backgroundMusic: 5,
 } as const;
-export const SPEC_GENERATION_COST = EDITOR_GENERATION_MUD_POINT_CONFIG.spec;
 export const SPEC_GENERATION_SIZE = '2048x1152';
 export const SPEC_FRAME_ORIGINAL_SIZE = { width: 2048, height: 1152 };
 export const SPEC_FRAME_DISPLAY_SIZE = { width: 560, height: 315 };
@@ -77,6 +76,15 @@ export const IMAGE_MODEL_GPT_IMAGE_2 = 'gpt-image-2';
 export const IMAGE_MODEL_NANOBANANA2 = 'gemini-3.1-flash-image-preview';
 export const DEFAULT_IMAGE_MODEL = IMAGE_MODEL_NANOBANANA2;
 export const SPEC_GENERATION_MODEL = IMAGE_MODEL_GPT_IMAGE_2;
+export const EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG = {
+  [IMAGE_MODEL_NANOBANANA2]: EDITOR_GENERATION_MUD_POINT_CONFIG.image,
+  [IMAGE_MODEL_GPT_IMAGE_2]: EDITOR_GENERATION_MUD_POINT_CONFIG.image,
+} as const;
+export const EDITOR_SPEC_MODEL_MUD_POINT_CONFIG = {
+  [IMAGE_MODEL_GPT_IMAGE_2]: EDITOR_GENERATION_MUD_POINT_CONFIG.spec,
+} as const;
+export const SPEC_GENERATION_COST =
+  EDITOR_SPEC_MODEL_MUD_POINT_CONFIG[SPEC_GENERATION_MODEL];
 export const SPEC_GENERATION_ASPECT_RATIO = '16:9';
 export const SPEC_GENERATION_IMAGE_SIZE = '2K';
 export const ICON_DESCRIPTION_LIMIT = 100;
@@ -116,10 +124,185 @@ export const EDITOR_IMAGE_DIMENSION_OPTIONS = {
     imageSizes: ['1K', '2K'],
   },
 } as const;
+
+type EditorImageFrameSize = {
+  width: number;
+  height: number;
+};
+
+function getSafeImageSizeValue(imageSize: string | null | undefined) {
+  return (imageSize ?? '1K').trim().toUpperCase();
+}
+
+function getImageSizeLongEdge(imageSize: string | null | undefined) {
+  const normalizedImageSize = getSafeImageSizeValue(imageSize);
+  if (normalizedImageSize === '0.5K') {
+    return 512;
+  }
+  if (normalizedImageSize === '2K') {
+    return 2048;
+  }
+  return 1024;
+}
+
+function resolveAspectRatioNumbers(aspectRatio: string | null | undefined) {
+  const [rawWidth = 1, rawHeight = 1] = (aspectRatio ?? '1:1')
+    .split(':')
+    .map((value) => Number(value));
+  const width = Number.isFinite(rawWidth) && rawWidth > 0 ? rawWidth : 1;
+  const height = Number.isFinite(rawHeight) && rawHeight > 0 ? rawHeight : 1;
+  return { width, height };
+}
+
+function resolveImageFrameSizeFromRatio({
+  aspectRatio,
+  imageSize,
+}: {
+  aspectRatio: string | null | undefined;
+  imageSize: string | null | undefined;
+}): EditorImageFrameSize {
+  const longEdge = getImageSizeLongEdge(imageSize);
+  const ratio = resolveAspectRatioNumbers(aspectRatio);
+  if (ratio.width >= ratio.height) {
+    return {
+      width: longEdge,
+      height: Math.max(1, Math.round((longEdge * ratio.height) / ratio.width)),
+    };
+  }
+  return {
+    width: Math.max(1, Math.round((longEdge * ratio.width) / ratio.height)),
+    height: longEdge,
+  };
+}
+
+export function resolveEditorImageGenerationPixelSize({
+  aspectRatio,
+  imageSize,
+}: {
+  model: string | null | undefined;
+  aspectRatio: string | null | undefined;
+  imageSize: string | null | undefined;
+}): EditorImageFrameSize {
+  return resolveImageFrameSizeFromRatio({ aspectRatio, imageSize });
+}
+
+export function resizeGenerationPlaceholderToImageSelection(
+  dialog: GenerateDialogState,
+): GenerateDialogState {
+  if (!dialog.placeholder) {
+    return dialog;
+  }
+  const size = resolveEditorImageGenerationPixelSize({
+    model: dialog.imageModel,
+    aspectRatio: dialog.aspectRatio,
+    imageSize: dialog.imageSize,
+  });
+  const centerX = dialog.placeholder.x + dialog.placeholder.width / 2;
+  const centerY = dialog.placeholder.y + dialog.placeholder.height / 2;
+  return {
+    ...dialog,
+    placeholder: {
+      ...dialog.placeholder,
+      x: centerX - size.width / 2,
+      y: centerY - size.height / 2,
+      width: size.width,
+      height: size.height,
+      originalWidth: size.width,
+      originalHeight: size.height,
+    },
+  };
+}
+
+function resolveEvenVideoWidth(height: number, aspectRatio: string | null | undefined) {
+  const ratio = resolveAspectRatioNumbers(aspectRatio ?? '16:9');
+  const rawWidth = Math.max(1, Math.round((height * ratio.width) / ratio.height));
+  return rawWidth % 2 === 0 ? rawWidth : rawWidth + 1;
+}
+
+export function resolveEditorVideoGenerationPixelSize({
+  aspectRatio,
+  resolution,
+}: {
+  aspectRatio: string | null | undefined;
+  resolution: '480p' | '720p' | string | null | undefined;
+}): EditorImageFrameSize {
+  const height = resolution === '720p' ? 720 : 480;
+  return {
+    width: resolveEvenVideoWidth(height, aspectRatio),
+    height,
+  };
+}
+
+export function resizeGenerationPlaceholderToVideoSelection(
+  dialog: GenerateDialogState,
+): GenerateDialogState {
+  if (!dialog.placeholder) {
+    return dialog;
+  }
+  const size = resolveEditorVideoGenerationPixelSize({
+    aspectRatio: dialog.videoAspectRatio,
+    resolution: dialog.videoResolution,
+  });
+  const centerX = dialog.placeholder.x + dialog.placeholder.width / 2;
+  const centerY = dialog.placeholder.y + dialog.placeholder.height / 2;
+  return {
+    ...dialog,
+    placeholder: {
+      ...dialog.placeholder,
+      x: centerX - size.width / 2,
+      y: centerY - size.height / 2,
+      width: size.width,
+      height: size.height,
+      originalWidth: size.width,
+      originalHeight: size.height,
+    },
+  };
+}
 export const VIDEO_MODEL_SEEDANCE_2 = 'seedance2.0';
 export const VIDEO_MODEL_SEEDANCE_2_FAST = 'seedance2.0-fast';
+export const VIDEO_MODEL_KLING_3 = 'kling3.0';
+export const VIDEO_MODEL_KLING_3_OMNI = 'kling3.0-omni';
+export const VIDEO_MODEL_VEO_3_1 = 'veo3.1';
+export const VIDEO_MODEL_VEO_3_1_FAST = 'veo3.1-fast';
 export const DEFAULT_VIDEO_MODEL = VIDEO_MODEL_SEEDANCE_2_FAST;
 export const CHARACTER_ANIMATION_MODEL = VIDEO_MODEL_SEEDANCE_2_FAST;
+export const SOUND_EFFECT_MODEL_VIDU = 'audio1.0';
+export const DEFAULT_SOUND_EFFECT_MODEL = SOUND_EFFECT_MODEL_VIDU;
+export const DEFAULT_SOUND_EFFECT_DURATION_SECONDS = 5;
+export const SOUND_EFFECT_DURATION_OPTIONS = Array.from(
+  { length: 9 },
+  (_, index) => index + 2,
+);
+export const BACKGROUND_MUSIC_MODEL_SUNO = 'chirp-v5';
+export const DEFAULT_BACKGROUND_MUSIC_MODEL = BACKGROUND_MUSIC_MODEL_SUNO;
+const EDITOR_VIDEO_RESOLUTION_RATE_CONFIG = {
+  '480p': EDITOR_GENERATION_MUD_POINT_CONFIG.videoPerSecond['480p'],
+  '720p': EDITOR_GENERATION_MUD_POINT_CONFIG.videoPerSecond['720p'],
+} as const;
+export const EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG = {
+  [VIDEO_MODEL_SEEDANCE_2_FAST]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+  [VIDEO_MODEL_SEEDANCE_2]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+  [VIDEO_MODEL_KLING_3]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+  [VIDEO_MODEL_KLING_3_OMNI]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+  // 中文注释：前端不展示 Veo 入口，但类型与后端兼容层仍可接收旧布局回放，定价表必须同步覆盖。
+  [VIDEO_MODEL_VEO_3_1]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+  [VIDEO_MODEL_VEO_3_1_FAST]: EDITOR_VIDEO_RESOLUTION_RATE_CONFIG,
+} as const;
+export const EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG = {
+  [CHARACTER_ANIMATION_MODEL]: {
+    '480p': EDITOR_GENERATION_MUD_POINT_CONFIG.characterAnimationPerSecond['480p'],
+    '720p': EDITOR_GENERATION_MUD_POINT_CONFIG.characterAnimationPerSecond['720p'],
+  },
+} as const;
+export const EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG = {
+  [SOUND_EFFECT_MODEL_VIDU]: EDITOR_GENERATION_MUD_POINT_CONFIG.soundEffect,
+} as const;
+export const EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG = {
+  [BACKGROUND_MUSIC_MODEL_SUNO]: EDITOR_GENERATION_MUD_POINT_CONFIG.backgroundMusic,
+} as const;
+export const EDITOR_SOUND_EFFECT_MODEL_OPTIONS = [
+  { label: 'Vidu', value: SOUND_EFFECT_MODEL_VIDU },
+] as const;
 export const SEEDANCE_VIDEO_REFERENCE_LIMITS = {
   image: 9,
   video: 3,
@@ -152,15 +335,15 @@ export const CHARACTER_ANIMATION_DURATION_OPTIONS = [
   { label: '40帧·5秒', frameCount: 40, durationSeconds: 5 },
   { label: '48帧·6秒', frameCount: 48, durationSeconds: 6 },
 ] as const;
-export const VIDEO_FRAME_ORIGINAL_SIZE = { width: 1280, height: 720 };
-export const VIDEO_FRAME_DISPLAY_SIZE = { width: 560, height: 315 };
+export const VIDEO_FRAME_ORIGINAL_SIZE = { width: 854, height: 480 };
+export const VIDEO_FRAME_DISPLAY_SIZE = { width: 854, height: 480 };
 export const AUDIO_FRAME_ORIGINAL_SIZE = { width: 420, height: 120 };
 export const AUDIO_FRAME_DISPLAY_SIZE = { width: 420, height: 120 };
 export const EDITOR_VIDEO_MODEL_OPTIONS = [
   { label: 'Seedance 2.0 Fast', value: VIDEO_MODEL_SEEDANCE_2_FAST },
   { label: 'Seedance 2.0', value: VIDEO_MODEL_SEEDANCE_2 },
-  { label: 'Kling 3.0', value: 'kling3.0' },
-  { label: 'Kling 3.0 Omni', value: 'kling3.0-omni' },
+  { label: 'Kling 3.0', value: VIDEO_MODEL_KLING_3 },
+  { label: 'Kling 3.0 Omni', value: VIDEO_MODEL_KLING_3_OMNI },
 ] as const;
 export const EDITOR_VIDEO_DURATION_OPTIONS = [
   { label: '4秒', value: '4' },
@@ -379,22 +562,101 @@ export function formatLayerImageType(layer: CanvasLayer) {
 }
 
 export function calculateCharacterAnimationPrice(
+  model: string | null | undefined,
   resolution: EditorCharacterAnimationResolution,
   durationSeconds: number,
 ) {
-  return (
-    EDITOR_GENERATION_MUD_POINT_CONFIG.characterAnimationPerSecond[resolution] *
-    durationSeconds
-  );
+  const normalizedModel = (model ?? CHARACTER_ANIMATION_MODEL).trim();
+  const modelRates =
+    EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG
+    ] ?? EDITOR_CHARACTER_ANIMATION_MODEL_MUD_POINT_CONFIG[CHARACTER_ANIMATION_MODEL];
+  return modelRates[resolution] * durationSeconds;
 }
 
 export function calculateEditorVideoPrice(
+  model: string | null | undefined,
   resolution: '480p' | '720p',
   durationSeconds: number,
 ) {
+  const normalizedModel = (model ?? DEFAULT_VIDEO_MODEL).trim();
+  const modelRates =
+    EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG
+    ] ?? EDITOR_VIDEO_MODEL_MUD_POINT_CONFIG[DEFAULT_VIDEO_MODEL];
+  return modelRates[resolution] * durationSeconds;
+}
+
+export function calculateEditorImageModelPrice(
+  model: string | null | undefined,
+) {
+  const normalizedModel = (model ?? DEFAULT_IMAGE_MODEL).trim();
   return (
-    EDITOR_GENERATION_MUD_POINT_CONFIG.videoPerSecond[resolution] *
-    durationSeconds
+    EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_IMAGE_MODEL_MUD_POINT_CONFIG
+    ] ?? EDITOR_GENERATION_MUD_POINT_CONFIG.image
+  );
+}
+
+export function calculateEditorSpecGenerationPrice(
+  model: string | null | undefined = SPEC_GENERATION_MODEL,
+) {
+  const normalizedModel = (model ?? SPEC_GENERATION_MODEL).trim();
+  return (
+    EDITOR_SPEC_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_SPEC_MODEL_MUD_POINT_CONFIG
+    ] ?? EDITOR_SPEC_MODEL_MUD_POINT_CONFIG[SPEC_GENERATION_MODEL]
+  );
+}
+
+export function calculateEditorImageGenerationPrice({
+  kind,
+  model,
+}: {
+  kind?: string | null;
+  model?: string | null;
+} = {}) {
+  const normalizedKind = kind?.trim();
+  if (normalizedKind === 'spec') {
+    return calculateEditorSpecGenerationPrice(model);
+  }
+  return calculateEditorImageModelPrice(model);
+}
+
+export function calculateEditorIconSpritesheetPrice(
+  model: string | null | undefined,
+) {
+  return calculateEditorImageModelPrice(model);
+}
+
+export function calculateEditorUiDesignPrice(
+  model: string | null | undefined,
+) {
+  return calculateEditorImageModelPrice(model);
+}
+
+export function calculateEditorSoundEffectPrice(
+  model: string | null | undefined,
+) {
+  const normalizedModel = (model ?? DEFAULT_SOUND_EFFECT_MODEL).trim();
+  return (
+    EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG
+    ] ?? EDITOR_SOUND_EFFECT_MODEL_MUD_POINT_CONFIG[DEFAULT_SOUND_EFFECT_MODEL]
+  );
+}
+
+export function calculateEditorBackgroundMusicPrice(
+  model: string | null | undefined = DEFAULT_BACKGROUND_MUSIC_MODEL,
+) {
+  const normalizedModel = (model ?? DEFAULT_BACKGROUND_MUSIC_MODEL).trim();
+  return (
+    EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG[
+      normalizedModel as keyof typeof EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG
+    ] ??
+    EDITOR_BACKGROUND_MUSIC_MODEL_MUD_POINT_CONFIG[
+      DEFAULT_BACKGROUND_MUSIC_MODEL
+    ]
   );
 }
 
@@ -495,17 +757,15 @@ export function buildVideoGenerationInputs(
 }
 
 export function buildSoundEffectGenerationInputs(
-  sound: string,
-  soundType: string,
-  tempo: number | null | undefined,
+  prompt: string,
+  model: string,
+  duration: number,
 ): CanvasGenerationInputs {
   return {
     fields: [
-      ...createGenerationInputField('sound', sound),
-      ...createGenerationInputField('type', soundType),
-      ...(tempo
-        ? createGenerationInputField('tempo', `${tempo}BPM`)
-        : []),
+      ...createGenerationInputField('prompt', prompt),
+      ...createGenerationInputField('model', model),
+      ...createGenerationInputField('duration', `${duration}秒`),
     ],
     references: [],
   };
diff --git a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
index e3c962155..780d49c70 100644
--- a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
+++ b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.test.ts
@@ -6,6 +6,16 @@ import {
   buildIconSpritesheetGenerationSubmissionPlan,
   buildImageGenerationSubmissionPlan,
 } from './ImageCanvasGenerationSubmissionModel';
+import {
+  BACKGROUND_MUSIC_MODEL_SUNO,
+  calculateCharacterAnimationPrice,
+  calculateEditorBackgroundMusicPrice,
+  calculateEditorIconSpritesheetPrice,
+  calculateEditorSoundEffectPrice,
+  calculateEditorVideoPrice,
+  CHARACTER_ANIMATION_MODEL,
+  DEFAULT_SOUND_EFFECT_MODEL,
+} from './ImageCanvasGenerationModel';
 
 function createLayer(overrides: Partial<CanvasLayer> = {}): CanvasLayer {
   return {
@@ -268,6 +278,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         prompt: expect.stringContaining('【宣发素材类型】游戏首图'),
         size: '720x540',
         kind: 'publication-material',
+        model: 'gemini-3.1-flash-image-preview',
         referenceImageSrcs: ['data:image/png;base64,ref'],
       },
       result: {
@@ -290,6 +301,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
           ],
         },
       },
+      rememberImageModel: 'gemini-3.1-flash-image-preview',
     });
     const prompt = plan.kind === 'image' ? plan.input.prompt : '';
     expect(prompt).toContain('游戏名：重庆洪崖洞火锅');
@@ -372,6 +384,39 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
     );
   });
 
+  it('builds publication material plans with selected image model', () => {
+    const plan = buildImageGenerationSubmissionPlan({
+      dialog: {
+        mode: 'publication',
+        prompt: '',
+        status: 'idle',
+        publicationWorkflowId: 'publication-promo-poster',
+        publicationGameInfo: {
+          gameName: '星际塔防',
+          gameCategories: '',
+          gameDescription: '',
+        },
+        publicationReferences: [],
+        imageModel: 'gpt-image-2',
+      },
+      layers: [],
+      nextGeneratedIndex: 4,
+    });
+
+    expect(plan.kind).toBe('image');
+    if (plan.kind !== 'image') {
+      return;
+    }
+    expect(plan.input).toEqual(
+      expect.objectContaining({
+        kind: 'publication-material',
+        model: 'gpt-image-2',
+        size: '1280x720',
+      }),
+    );
+    expect(plan.rememberImageModel).toBe('gpt-image-2');
+  });
+
   it('throws when edit source layer is missing', () => {
     expect(() =>
       buildImageGenerationSubmissionPlan({
@@ -445,7 +490,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         model: 'gpt-image-2',
         aspectRatio: '3:2',
         imageSize: '2K',
-        priceMudPoints: 12,
+        priceMudPoints: calculateEditorIconSpritesheetPrice('gpt-image-2'),
       },
       generationInputs: {
         fields: [{ title: '素材描述', value: '返回按钮\n设置按钮' }],
@@ -496,7 +541,11 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         ratio: 'same',
         frameCount: 48,
         durationSeconds: 6,
-        priceMudPoints: 120,
+        priceMudPoints: calculateCharacterAnimationPrice(
+          CHARACTER_ANIMATION_MODEL,
+          '720p',
+          6,
+        ),
         model: 'seedance2.0-fast',
       },
     });
@@ -665,7 +714,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
       normalizedPrompt: '角色绕场一周',
       input: {
         model: 'seedance2.0-fast',
-        priceMudPoints: 40,
+        priceMudPoints: calculateEditorVideoPrice('seedance2.0-fast', '480p', 4),
       },
       result: {
         title: '生成视频 3',
@@ -695,7 +744,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         model: 'seedance2.0',
         resolution: '720p',
         durationSeconds: 5,
-        priceMudPoints: 100,
+        priceMudPoints: calculateEditorVideoPrice('seedance2.0', '720p', 5),
       },
       result: {
         title: '生成视频 7',
@@ -709,8 +758,7 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
         mode: 'audio-sound-effect',
         prompt: '  金币掉落叮当声  ',
         status: 'idle',
-        soundType: 'loop',
-        soundTempo: 120,
+        soundDurationSeconds: 7,
       },
       layers: [],
       nextGeneratedIndex: 4,
@@ -721,18 +769,18 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
       audioKind: 'sound-effect',
       normalizedPrompt: '金币掉落叮当声',
       input: {
-        sound: '金币掉落叮当声',
-        type: 'loop',
-        tempo: 120,
-        priceMudPoints: 10,
+        prompt: '金币掉落叮当声',
+        model: 'audio1.0',
+        duration: 7,
+        priceMudPoints: calculateEditorSoundEffectPrice(DEFAULT_SOUND_EFFECT_MODEL),
       },
       result: {
         title: '游戏音效 4',
         generationInputs: {
           fields: [
-            { title: 'sound', value: '金币掉落叮当声' },
-            { title: 'type', value: 'loop' },
-            { title: 'tempo', value: '120BPM' },
+            { title: 'prompt', value: '金币掉落叮当声' },
+            { title: 'model', value: 'audio1.0' },
+            { title: 'duration', value: '7秒' },
           ],
           references: [],
         },
@@ -740,14 +788,12 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
     });
   });
 
-  it('keeps game sound effect BPM unset as null by default', () => {
+  it('uses 5 seconds as default game sound effect duration', () => {
     const plan = buildImageGenerationSubmissionPlan({
       dialog: {
         mode: 'audio-sound-effect',
         prompt: '按钮确认短促音',
         status: 'idle',
-        soundType: 'one-shot',
-        soundTempo: null,
       },
       layers: [],
       nextGeneratedIndex: 6,
@@ -757,15 +803,16 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
       kind: 'audio',
       audioKind: 'sound-effect',
       input: {
-        sound: '按钮确认短促音',
-        type: 'one-shot',
-        tempo: null,
+        prompt: '按钮确认短促音',
+        model: 'audio1.0',
+        duration: 5,
       },
       result: {
         generationInputs: {
           fields: [
-            { title: 'sound', value: '按钮确认短促音' },
-            { title: 'type', value: 'one-shot' },
+            { title: 'prompt', value: '按钮确认短促音' },
+            { title: 'model', value: 'audio1.0' },
+            { title: 'duration', value: '5秒' },
           ],
         },
       },
@@ -790,7 +837,9 @@ describe('ImageCanvasGenerationSubmissionModel', () => {
       input: {
         gptDescriptionPrompt: '温暖轻快的森林冒险背景音乐',
         makeInstrumental: true,
-        priceMudPoints: 5,
+        priceMudPoints: calculateEditorBackgroundMusicPrice(
+          BACKGROUND_MUSIC_MODEL_SUNO,
+        ),
       },
       result: {
         title: '游戏背景音乐 5',
diff --git a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
index 436141dc5..58a6cd331 100644
--- a/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
+++ b/src/components/image-editor/ImageCanvasGenerationSubmissionModel.ts
@@ -27,13 +27,18 @@ import {
   buildUiDesignGenerationInputs,
   buildVideoGenerationInputs,
   calculateCharacterAnimationPrice,
+  calculateEditorBackgroundMusicPrice,
+  calculateEditorIconSpritesheetPrice,
+  calculateEditorSoundEffectPrice,
   calculateEditorVideoPrice,
+  DEFAULT_BACKGROUND_MUSIC_MODEL,
   CHARACTER_ANIMATION_MODEL,
   DEFAULT_ICON_DESCRIPTIONS,
   DEFAULT_IMAGE_MODEL,
+  DEFAULT_SOUND_EFFECT_DURATION_SECONDS,
+  DEFAULT_SOUND_EFFECT_MODEL,
   DEFAULT_SPEC_FORM_VALUES,
   DEFAULT_VIDEO_MODEL,
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
   ICON_DESCRIPTION_LIMIT,
   resolveCharacterAnimationSourceImageSrc,
   SEEDANCE_VIDEO_REFERENCE_LIMITS,
@@ -302,6 +307,7 @@ export function buildImageGenerationSubmissionPlan({
     const workflow = getPublicationMaterialsWorkflow(
       dialog.publicationWorkflowId ?? 'publication-cover-image',
     );
+    const imageModel = dialog.imageModel ?? DEFAULT_IMAGE_MODEL;
     const publicationPrompt =
       buildPublicationMaterialsPrompt(dialog.publicationGameInfo) ||
       normalizedPrompt;
@@ -316,6 +322,7 @@ export function buildImageGenerationSubmissionPlan({
         prompt: generationPrompt,
         size: workflow.outputSize,
         kind: 'publication-material',
+        model: imageModel,
         ...(dialog.publicationReferences?.length
           ? {
               referenceImageSrcs: dialog.publicationReferences.map(
@@ -331,6 +338,7 @@ export function buildImageGenerationSubmissionPlan({
           dialog.publicationReferences,
         ),
       },
+      rememberImageModel: imageModel,
     };
   }
 
@@ -357,6 +365,7 @@ export function buildImageGenerationSubmissionPlan({
         mode: 'std',
         sound: 'off',
         priceMudPoints: calculateEditorVideoPrice(
+          model,
           resolution,
           durationSeconds,
         ),
@@ -381,24 +390,27 @@ export function buildImageGenerationSubmissionPlan({
   }
 
   if (dialog.mode === 'audio-sound-effect') {
-    const soundType = dialog.soundType ?? 'one-shot';
-    const soundTempo = dialog.soundTempo ?? null;
+    const soundModel = dialog.soundModel ?? DEFAULT_SOUND_EFFECT_MODEL;
+    const durationSeconds =
+      typeof dialog.soundDurationSeconds === 'number'
+        ? Math.min(10, Math.max(2, Math.round(dialog.soundDurationSeconds)))
+        : DEFAULT_SOUND_EFFECT_DURATION_SECONDS;
     return {
       kind: 'audio',
       audioKind: 'sound-effect',
       normalizedPrompt,
       input: {
-        sound: normalizedPrompt,
-        type: soundType,
-        tempo: soundTempo,
-        priceMudPoints: EDITOR_GENERATION_MUD_POINT_CONFIG.soundEffect,
+        prompt: normalizedPrompt,
+        model: soundModel,
+        duration: durationSeconds,
+        priceMudPoints: calculateEditorSoundEffectPrice(soundModel),
       },
       result: {
         title: `游戏音效 ${nextGeneratedIndex}`,
         generationInputs: buildSoundEffectGenerationInputs(
           normalizedPrompt,
-          soundType,
-          soundTempo,
+          soundModel,
+          durationSeconds,
         ),
       },
     };
@@ -412,7 +424,9 @@ export function buildImageGenerationSubmissionPlan({
       input: {
         gptDescriptionPrompt: normalizedPrompt,
         makeInstrumental: true,
-        priceMudPoints: EDITOR_GENERATION_MUD_POINT_CONFIG.backgroundMusic,
+        priceMudPoints: calculateEditorBackgroundMusicPrice(
+          DEFAULT_BACKGROUND_MUSIC_MODEL,
+        ),
       },
       result: {
         title: `游戏背景音乐 ${nextGeneratedIndex}`,
@@ -483,7 +497,7 @@ export function buildIconSpritesheetGenerationSubmissionPlan(
       model: rememberImageModel,
       aspectRatio: dialog.aspectRatio ?? '1:1',
       imageSize: dialog.imageSize ?? '1K',
-      priceMudPoints: EDITOR_GENERATION_MUD_POINT_CONFIG.icon,
+      priceMudPoints: calculateEditorIconSpritesheetPrice(rememberImageModel),
     },
     generationInputs: buildIconGenerationInputs(
       iconDescriptions,
@@ -514,6 +528,7 @@ export function buildCharacterAnimationSubmissionPlan({
       frameCount: panel.frameCount,
       durationSeconds: panel.durationSeconds,
       priceMudPoints: calculateCharacterAnimationPrice(
+        CHARACTER_ANIMATION_MODEL,
         panel.resolution,
         panel.durationSeconds,
       ),
diff --git a/src/components/image-editor/ImageCanvasIconSpritesheetComposerView.tsx b/src/components/image-editor/ImageCanvasIconSpritesheetComposerView.tsx
index 21ea4467e..42c5d035a 100644
--- a/src/components/image-editor/ImageCanvasIconSpritesheetComposerView.tsx
+++ b/src/components/image-editor/ImageCanvasIconSpritesheetComposerView.tsx
@@ -20,8 +20,8 @@ import type {
 } from './ImageCanvasEditorTypes';
 import { ImageCanvasGenerationImageOptionsView } from './ImageCanvasGenerationImageOptionsView';
 import {
+  calculateEditorIconSpritesheetPrice,
   DEFAULT_ICON_DESCRIPTIONS,
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
 } from './ImageCanvasGenerationModel';
 import { ImageCanvasReferenceSlot } from './ImageCanvasReferenceSlot';
 import { useImageCanvasFloatingOptionDismiss } from './useImageCanvasFloatingOptionDismiss';
@@ -200,7 +200,7 @@ export function ImageCanvasIconSpritesheetComposerView({
           includeDimensions
           onRememberImageModel={onRememberImageModel}
           optionLabelPrefix="生成图片"
-          cost={EDITOR_GENERATION_MUD_POINT_CONFIG.icon}
+          cost={calculateEditorIconSpritesheetPrice(dialog.imageModel)}
           submitLabel="生成"
           submitAriaLabel="生成"
           renderEditorPortal={renderEditorPortal}
diff --git a/src/components/image-editor/ImageCanvasPublicationMaterialsDemoPanelView.tsx b/src/components/image-editor/ImageCanvasPublicationMaterialsDemoPanelView.tsx
index 37b1970f4..98e329cb2 100644
--- a/src/components/image-editor/ImageCanvasPublicationMaterialsDemoPanelView.tsx
+++ b/src/components/image-editor/ImageCanvasPublicationMaterialsDemoPanelView.tsx
@@ -7,7 +7,6 @@ import {
   type SetStateAction,
 } from 'react';
 
-import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformFieldLabel } from '../common/PlatformFieldLabel';
 import {
   PlatformFloatingMenu,
@@ -15,14 +14,17 @@ import {
 } from '../common/PlatformFloatingMenu';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
 import { PlatformTextField } from '../common/PlatformTextField';
+import { ImageCanvasReferenceSlot } from './ImageCanvasReferenceSlot';
 import type {
   CharacterReferenceImage,
   GenerateDialogState,
   PublicationMaterialsGameInfo,
   UploadTarget,
 } from './ImageCanvasEditorTypes';
+import { ImageCanvasGenerationImageOptionsView } from './ImageCanvasGenerationImageOptionsView';
 import {
   buildPublicationMaterialsPrompt,
+  calculateEditorImageModelPrice,
   DEFAULT_PUBLICATION_GAME_INFO,
 } from './ImageCanvasGenerationModel';
 import type { PublicationMaterialsWorkflow } from './ImageCanvasPublicationMaterialsModel';
@@ -42,6 +44,7 @@ type ImageCanvasPublicationMaterialsDemoPanelViewProps = {
     placement: 'above' | 'below',
   ) => CSSProperties;
   onRequestUpload: (target: UploadTarget) => void;
+  onRememberImageModel: (model: string) => void;
   onSubmit: (dialog: GenerateDialogState) => void;
 };
 
@@ -76,18 +79,24 @@ function updatePublicationGameInfoField(
 function ReferenceThumb({
   reference,
   index,
+  onRemove,
 }: {
   reference: CharacterReferenceImage;
   index: number;
+  onRemove: () => void;
 }) {
+  const label = reference.label || `参考图${index + 1}`;
   return (
-    <span
-      className="image-canvas-editor__publication-ref-thumb"
+    <ImageCanvasReferenceSlot
+      tone="default"
+      icon={<ImagePlus className="h-4 w-4" aria-hidden="true" />}
+      imageSrc={reference.src}
+      label={label}
+      ariaLabel={label}
       title={reference.label}
-    >
-      <img src={reference.src} alt={reference.label} />
-      <span>{index + 1}</span>
-    </span>
+      onRemove={onRemove}
+      removeLabel={`删除${label}`}
+    />
   );
 }
 
@@ -103,6 +112,7 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
   renderEditorPortal,
   buildPortalMenuStyle,
   onRequestUpload,
+  onRememberImageModel,
   onSubmit,
 }: ImageCanvasPublicationMaterialsDemoPanelViewProps) {
   const references = dialog.publicationReferences ?? [];
@@ -112,26 +122,88 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
   };
   return (
     <form
-      className="image-canvas-editor__publication-composer"
+      className="image-canvas-editor__character-composer image-canvas-editor__publication-composer"
       style={style}
       role="dialog"
       aria-label={`${workflow.label}生成卡片`}
       onPointerDown={(event) => event.stopPropagation()}
       onSubmit={(event) => {
         event.preventDefault();
-        onSubmit(dialog);
+        if (dialog.status !== 'generating') {
+          onSubmit(dialog);
+        }
       }}
     >
-      <header className="image-canvas-editor__publication-composer-header">
-        <div>
-          <span>{workflow.outputLabel}</span>
-          <h2>{workflow.englishName}</h2>
-        </div>
-        <strong>{workflow.sizeLabel}</strong>
-      </header>
+      <div className="image-canvas-editor__reference-strip">
+        {references.map((reference, index) => (
+          <ReferenceThumb
+            key={reference.id}
+            reference={reference}
+            index={index}
+            onRemove={() =>
+              setGenerateDialog((currentDialog) =>
+                currentDialog?.mode === 'publication'
+                  ? {
+                      ...resetFailedDialogStatus(currentDialog),
+                      publicationReferences: (
+                        currentDialog.publicationReferences ?? []
+                      ).filter((item) => item.id !== reference.id),
+                    }
+                  : currentDialog,
+              )
+            }
+          />
+        ))}
+        <ImageCanvasReferenceSlot
+          buttonRef={publicationReferenceButtonRef}
+          tone="default"
+          icon={<ImagePlus className="h-4 w-4" aria-hidden="true" />}
+          label="添加参考图"
+          ariaLabel="添加参考图"
+          disabled={dialog.status === 'generating'}
+          isAdd
+          onClick={() => setIsPublicationReferenceMenuOpen((open) => !open)}
+        />
+        {isPublicationReferenceMenuOpen
+          ? renderEditorPortal(
+              <PlatformFloatingMenu
+                className="image-canvas-editor__publication-reference-menu image-canvas-editor__portal-menu"
+                label="宣发素材参考图来源"
+                placement="top-start"
+                style={buildPortalMenuStyle(
+                  publicationReferenceButtonRef.current,
+                  'above',
+                )}
+              >
+                <PlatformFloatingMenuItem
+                  className="image-canvas-editor__context-menu-item"
+                  onClick={() => {
+                    setIsPickingPublicationReferenceFromCanvas(true);
+                    setIsPublicationReferenceMenuOpen(false);
+                  }}
+                >
+                  从画布中选择
+                </PlatformFloatingMenuItem>
+                <PlatformFloatingMenuItem
+                  className="image-canvas-editor__context-menu-item"
+                  onClick={() => {
+                    setIsPublicationReferenceMenuOpen(false);
+                    onRequestUpload('publication-reference');
+                  }}
+                >
+                  上传图片
+                </PlatformFloatingMenuItem>
+              </PlatformFloatingMenu>,
+            )
+          : null}
+      </div>
 
       <div className="image-canvas-editor__publication-composer-fields">
-        <label>
+        <div className="image-canvas-editor__publication-composer-summary">
+          <span>{workflow.outputLabel}</span>
+          <strong>{workflow.sizeLabel}</strong>
+        </div>
+        <label className="image-canvas-editor__field-block">
           <PlatformFieldLabel
             variant="field"
             className="image-canvas-editor__field-title"
@@ -157,7 +229,7 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
             }
           />
         </label>
-        <label>
+        <label className="image-canvas-editor__field-block">
           <PlatformFieldLabel
             variant="field"
             className="image-canvas-editor__field-title"
@@ -183,7 +255,7 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
             }
           />
         </label>
-        <label>
+        <label className="image-canvas-editor__field-block image-canvas-editor__publication-description-field">
           <PlatformFieldLabel
             variant="field"
             className="image-canvas-editor__field-title"
@@ -210,69 +282,6 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
             }
           />
         </label>
-        <div>
-          <PlatformFieldLabel
-            variant="field"
-            className="image-canvas-editor__field-title"
-          >
-            参考图
-          </PlatformFieldLabel>
-          <div className="image-canvas-editor__publication-reference-list">
-            {references.map((reference, index) => (
-              <ReferenceThumb
-                key={reference.id}
-                reference={reference}
-                index={index}
-              />
-            ))}
-            <button
-              ref={publicationReferenceButtonRef}
-              type="button"
-              className="image-canvas-editor__publication-reference-add image-canvas-editor__reference-tile image-canvas-editor__reference-tile--upload"
-              disabled={dialog.status === 'generating'}
-              onClick={() => setIsPublicationReferenceMenuOpen((open) => !open)}
-            >
-              <span className="image-canvas-editor__reference-tile-visual">
-                <ImagePlus className="h-4 w-4" aria-hidden="true" />
-              </span>
-              <span className="image-canvas-editor__reference-tile-copy">
-                添加参考图
-              </span>
-            </button>
-          </div>
-          {isPublicationReferenceMenuOpen
-            ? renderEditorPortal(
-                <PlatformFloatingMenu
-                  className="image-canvas-editor__publication-reference-menu image-canvas-editor__portal-menu"
-                  label="宣发素材参考图来源"
-                  placement="top-start"
-                  style={buildPortalMenuStyle(
-                    publicationReferenceButtonRef.current,
-                    'above',
-                  )}
-                >
-                  <PlatformFloatingMenuItem
-                    className="image-canvas-editor__context-menu-item"
-                    onClick={() => {
-                      setIsPickingPublicationReferenceFromCanvas(true);
-                      setIsPublicationReferenceMenuOpen(false);
-                    }}
-                  >
-                    从画布中选择
-                  </PlatformFloatingMenuItem>
-                  <PlatformFloatingMenuItem
-                    className="image-canvas-editor__context-menu-item"
-                    onClick={() => {
-                      setIsPublicationReferenceMenuOpen(false);
-                      onRequestUpload('publication-reference');
-                    }}
-                  >
-                    上传图片
-                  </PlatformFloatingMenuItem>
-                </PlatformFloatingMenu>,
-              )
-            : null}
-        </div>
       </div>
 
       {dialog.status === 'failed' ? (
@@ -287,19 +296,20 @@ export function ImageCanvasPublicationMaterialsDemoPanelView({
         </PlatformStatusMessage>
       ) : null}
 
-      <footer className="image-canvas-editor__publication-composer-footer">
-        <span>{workflow.scenario}</span>
-        <PlatformActionButton
-          type="submit"
-          tone="secondary"
-          size="xs"
-          shape="pill"
-          className="image-canvas-editor__generation-submit"
-          disabled={dialog.status === 'generating'}
-        >
-          {dialog.status === 'generating' ? '生成中' : '消耗5泥点 · 生成'}
-        </PlatformActionButton>
-      </footer>
+      <div className="image-canvas-editor__generation-composer-footer">
+        <ImageCanvasGenerationImageOptionsView
+          dialog={dialog}
+          setGenerateDialog={setGenerateDialog}
+          includeDimensions={false}
+          onRememberImageModel={onRememberImageModel}
+          optionLabelPrefix="宣发素材"
+          cost={calculateEditorImageModelPrice(dialog.imageModel)}
+          submitLabel="生成"
+          submitAriaLabel="生成"
+          renderEditorPortal={renderEditorPortal}
+          buildPortalMenuStyle={buildPortalMenuStyle}
+        />
+      </div>
     </form>
   );
 }
diff --git a/src/components/image-editor/ImageCanvasQuickEditPanelView.tsx b/src/components/image-editor/ImageCanvasQuickEditPanelView.tsx
index 59aeb0a1a..ee505d263 100644
--- a/src/components/image-editor/ImageCanvasQuickEditPanelView.tsx
+++ b/src/components/image-editor/ImageCanvasQuickEditPanelView.tsx
@@ -22,7 +22,7 @@ import type {
   QuickEditPanelState,
 } from './ImageCanvasEditorTypes';
 import {
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
+  calculateEditorImageModelPrice,
   QUICK_EDIT_REFERENCE_LIMIT,
 } from './ImageCanvasGenerationModel';
 import { ImageCanvasReferenceSlot } from './ImageCanvasReferenceSlot';
@@ -231,7 +231,7 @@ export function ImageCanvasQuickEditPanelView({
               <>
                 <span>生成</span>
                 <span className="image-canvas-editor__mud-point-inline">
-                  {EDITOR_GENERATION_MUD_POINT_CONFIG.image}泥点
+                  {calculateEditorImageModelPrice(panel.model)}泥点
                 </span>
               </>
             )}
diff --git a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
index 5a22b9946..f1eb5f4db 100644
--- a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
+++ b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.test.tsx
@@ -61,7 +61,7 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
       '快速编辑',
       '裁扩按钮',
       '去除背景按钮',
-      '重绘',
+      '改造',
       '下载按钮',
     ]);
 
@@ -70,7 +70,7 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
     fireEvent.click(
       within(toolbar).getByRole('button', { name: '去除背景按钮' }),
     );
-    fireEvent.click(within(toolbar).getByRole('button', { name: '重绘' }));
+    fireEvent.click(within(toolbar).getByRole('button', { name: '改造' }));
     fireEvent.click(within(toolbar).getByRole('button', { name: '下载按钮' }));
 
     expect(props.onOpenQuickEditPanel).toHaveBeenCalledWith(props.selectedLayer);
@@ -108,7 +108,7 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
       '裁扩按钮',
       '去除背景按钮',
       '提取素材',
-      '重绘',
+      '改造',
       '下载按钮',
     ]);
 
@@ -117,6 +117,39 @@ describe('ImageCanvasSelectedLayerToolbarView', () => {
     expect(props.onExtractUiDesignAssets).toHaveBeenCalledWith(layer);
   });
 
+  it('keeps only remodel and download for audio layers', () => {
+    const layer = createLayer({
+      title: '游戏音效',
+      src: 'data:audio/mpeg;base64,audio',
+      mediaType: 'audio',
+      assetKind: 'sound-effect',
+    });
+    const props = renderSelectedToolbar({ selectedLayer: layer });
+    const toolbar = screen.getByRole('toolbar', { name: '素材工具栏' });
+    const buttons = within(toolbar).getAllByRole('button');
+
+    expect(buttons.map((button) => button.getAttribute('aria-label'))).toEqual([
+      '改造',
+      '下载按钮',
+    ]);
+    expect(within(toolbar).queryByRole('button', { name: '快速编辑' })).toBeNull();
+    expect(
+      within(toolbar).queryByRole('button', { name: '裁扩按钮' }),
+    ).toBeNull();
+    expect(
+      within(toolbar).queryByRole('button', { name: '去除背景按钮' }),
+    ).toBeNull();
+    expect(
+      within(toolbar).queryByRole('button', { name: '生成动画' }),
+    ).toBeNull();
+
+    fireEvent.click(within(toolbar).getByRole('button', { name: '改造' }));
+    fireEvent.click(within(toolbar).getByRole('button', { name: '下载按钮' }));
+
+    expect(props.onOpenRedrawPanel).toHaveBeenCalledWith(layer);
+    expect(props.onDownloadLayer).toHaveBeenCalledWith(layer);
+  });
+
   it('renders character animation only for character layers', () => {
     const layer = createLayer({
       sourceType: 'generated',
diff --git a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
index cda87d1e9..c248de89a 100644
--- a/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
+++ b/src/components/image-editor/ImageCanvasSelectedLayerToolbarView.tsx
@@ -39,6 +39,34 @@ export function ImageCanvasSelectedLayerToolbarView({
     return null;
   }
 
+  if (selectedLayer.mediaType === 'audio') {
+    return (
+      <div
+        className="image-canvas-editor__floating-toolbar"
+        style={selectedToolbarStyle}
+        role="toolbar"
+        aria-label="素材工具栏"
+        onPointerDown={(event) => event.stopPropagation()}
+      >
+        <PlatformIconButton
+          className="image-canvas-editor__floating-toolbar-text-button"
+          label="改造"
+          title="改造"
+          icon={<WandSparkles className="h-4 w-4" />}
+          onClick={() => onOpenRedrawPanel(selectedLayer)}
+        >
+          <span>改造</span>
+        </PlatformIconButton>
+        <EditorIconButton
+          label="下载按钮"
+          title="下载按钮"
+          icon={Download}
+          onClick={() => onDownloadLayer(selectedLayer)}
+        />
+      </div>
+    );
+  }
+
   return (
     <div
       className="image-canvas-editor__floating-toolbar"
@@ -97,12 +125,12 @@ export function ImageCanvasSelectedLayerToolbarView({
       />
       <PlatformIconButton
         className="image-canvas-editor__floating-toolbar-text-button"
-        label="重绘"
-        title="重绘"
+        label="改造"
+        title="改造"
         icon={<WandSparkles className="h-4 w-4" />}
         onClick={() => onOpenRedrawPanel(selectedLayer)}
       >
-        <span>重绘</span>
+        <span>改造</span>
       </PlatformIconButton>
       <EditorIconButton
         label="下载按钮"
diff --git a/src/components/image-editor/ImageCanvasSpecGenerationPanelView.tsx b/src/components/image-editor/ImageCanvasSpecGenerationPanelView.tsx
index ae773485c..6f783d7a5 100644
--- a/src/components/image-editor/ImageCanvasSpecGenerationPanelView.tsx
+++ b/src/components/image-editor/ImageCanvasSpecGenerationPanelView.tsx
@@ -28,10 +28,10 @@ import type {
 import { ImageCanvasGenerationImageOptionsView } from './ImageCanvasGenerationImageOptionsView';
 import { ImageCanvasReferenceSlot } from './ImageCanvasReferenceSlot';
 import {
+  calculateEditorSpecGenerationPrice,
+  calculateEditorUiDesignPrice,
   CHARACTER_SPEC_VIEW_OPTIONS,
-  EDITOR_GENERATION_MUD_POINT_CONFIG,
   SPEC_GENERATION_ASPECT_RATIO,
-  SPEC_GENERATION_COST,
   SPEC_GENERATION_IMAGE_SIZE,
   SPEC_GENERATION_MODEL,
 } from './ImageCanvasGenerationModel';
@@ -87,6 +87,9 @@ export function ImageCanvasSpecGenerationPanelView({
     ? dialog.uiDesignSpecReference
     : dialog.specReference;
   const isGenerating = dialog.status === 'generating';
+  const specGenerationCost = calculateEditorSpecGenerationPrice(
+    SPEC_GENERATION_MODEL,
+  );
   useImageCanvasFloatingOptionDismiss({
     isOpen: isGenerationReferenceMenuOpen,
     boundaryRefs: [generationReferenceButtonRef],
@@ -349,7 +352,7 @@ export function ImageCanvasSpecGenerationPanelView({
             setGenerateDialog={setGenerateDialog ?? (() => undefined)}
             includeDimensions
             onRememberImageModel={onRememberImageModel}
-            cost={EDITOR_GENERATION_MUD_POINT_CONFIG.uiDesign}
+            cost={calculateEditorUiDesignPrice(dialog.imageModel)}
             submitLabel="生成"
             submitAriaLabel="生成UI设计图"
             optionLabelPrefix="生成图片"
@@ -399,7 +402,7 @@ export function ImageCanvasSpecGenerationPanelView({
                 <>
                   <span>生成</span>
                   <span className="image-canvas-editor__mud-point-inline">
-                    {SPEC_GENERATION_COST}泥点
+                    {specGenerationCost}泥点
                   </span>
                 </>
               )}
diff --git a/src/components/image-editor/ImageCanvasWorldView.test.tsx b/src/components/image-editor/ImageCanvasWorldView.test.tsx
index 480c0d772..09f8d89ce 100644
--- a/src/components/image-editor/ImageCanvasWorldView.test.tsx
+++ b/src/components/image-editor/ImageCanvasWorldView.test.tsx
@@ -304,7 +304,31 @@ describe('ImageCanvasWorldView', () => {
       generatorLabel: 'Home Image Generator',
       badgeLabel: '宣发',
       frameClassName: 'image-canvas-editor__generation-frame--publication',
-      iconClassName: 'lucide-image',
+      iconClassName: 'lucide-megaphone',
+    },
+    {
+      mode: 'spec',
+      ariaLabel: '规范生成占位图',
+      generatorLabel: 'Spec Generator',
+      badgeLabel: '规范',
+      frameClassName: 'image-canvas-editor__generation-frame--spec',
+      iconClassName: 'lucide-clipboard-list',
+    },
+    {
+      mode: 'ui-design',
+      ariaLabel: 'UI设计图生成占位图',
+      generatorLabel: 'UI Design Generator',
+      badgeLabel: 'UI设计',
+      frameClassName: 'image-canvas-editor__generation-frame--ui-design',
+      iconClassName: 'lucide-app-window',
+    },
+    {
+      mode: 'quick-edit',
+      ariaLabel: '快速编辑生成占位图',
+      generatorLabel: 'Quick Edit Generator',
+      badgeLabel: '快编',
+      frameClassName: 'image-canvas-editor__generation-frame--quick-edit',
+      iconClassName: 'lucide-sparkles',
     },
     {
       mode: 'video',
@@ -312,7 +336,7 @@ describe('ImageCanvasWorldView', () => {
       generatorLabel: 'Video Generator',
       badgeLabel: '视频',
       frameClassName: 'image-canvas-editor__generation-frame--video',
-      iconClassName: 'lucide-film',
+      iconClassName: 'lucide-clapperboard',
     },
     {
       mode: 'audio-sound-effect',
@@ -330,7 +354,7 @@ describe('ImageCanvasWorldView', () => {
       badgeLabel: '背景音乐',
       frameClassName:
         'image-canvas-editor__generation-frame--audio-background-music',
-      iconClassName: 'lucide-music-2',
+      iconClassName: 'lucide-music',
     },
   ])(
     'renders $mode generation placeholder with its own icon and badge',
@@ -393,18 +417,16 @@ describe('ImageCanvasWorldView', () => {
       ariaLabel: '音效生成占位图',
       generatorLabel: 'Sound Generator',
       badgeLabel: '音效',
-      metricLabel: '时长 --:--',
     },
     {
       mode: 'audio-background-music',
       ariaLabel: '背景音乐生成占位图',
       generatorLabel: 'Music Generator',
       badgeLabel: '背景音乐',
-      metricLabel: '时长 --:--',
     },
   ])(
     'keeps $mode generation title size and badge readable when zoomed out',
-    ({ mode, ariaLabel, generatorLabel, badgeLabel, metricLabel }) => {
+    ({ mode, ariaLabel, generatorLabel, badgeLabel }) => {
       const dialog = createGenerationDialog({
         id: `dialog-zoom-${mode}`,
         mode: mode as CanvasGenerationDialogState['mode'],
@@ -425,10 +447,16 @@ describe('ImageCanvasWorldView', () => {
         ),
       ).toBe(inverseScale);
       expect(
-        (
-          within(frame).getByText(metricLabel ?? '1024 x 768') as HTMLElement
-        ).style.getPropertyValue('--image-canvas-editor-inverse-scale'),
-      ).toBe(inverseScale);
+        mode === 'audio-sound-effect' || mode === 'audio-background-music'
+          ? within(frame).queryByText('1024 x 768')
+          : (
+              within(frame).getByText('1024 x 768') as HTMLElement
+            ).style.getPropertyValue('--image-canvas-editor-inverse-scale'),
+      ).toBe(
+        mode === 'audio-sound-effect' || mode === 'audio-background-music'
+          ? null
+          : inverseScale,
+      );
       expect(
         (within(frame).getByText(badgeLabel) as HTMLElement).style.getPropertyValue(
           '--image-canvas-editor-inverse-scale',
@@ -576,10 +604,18 @@ describe('ImageCanvasWorldView', () => {
     expect(audio.tagName.toLowerCase()).toBe('audio');
     expect(within(layerButton).queryByAltText('画布图片：游戏音效')).toBeNull();
     expect(within(layerButton).getByText('音效')).toBeTruthy();
-    expect(within(layerButton).getByText('时长 --:--')).toBeTruthy();
+    expect(within(layerButton).queryByText(/时长/u)).toBeNull();
+    expect(
+      within(layerButton).getByRole('button', { name: '播放游戏音效' })
+        .querySelector('svg')
+        ?.getAttribute('class'),
+    ).toContain('lucide-volume-2');
+    expect(
+      within(layerButton).queryByText('420 x 120 px'),
+    ).toBeNull();
   });
 
-  it('keeps audio controls interactive and shows the generated prompt', () => {
+  it('keeps audio controls interactive and switches icon, play and pause states', () => {
     const layer = createLayer({
       title: '游戏背景音乐',
       src: 'data:audio/mpeg;base64,audio',
@@ -592,19 +628,54 @@ describe('ImageCanvasWorldView', () => {
       prompt: '紧张的地下城循环音乐',
       durationSeconds: 75,
     });
-    const { props } = renderWorldView({
+    const { props, rerender } = renderWorldView({
       layers: [layer],
       selectedLayerIds: [layer.id],
     });
 
     const layerButton = screen.getByRole('button', { name: '选择游戏背景音乐' });
     const audio = within(layerButton).getByLabelText('画布音频：游戏背景音乐');
+    const playbackButton = within(layerButton).getByRole('button', {
+      name: '播放游戏背景音乐',
+    });
 
     expect(within(layerButton).getByText('紧张的地下城循环音乐')).toBeTruthy();
-    expect(within(layerButton).getByText('时长 1:15')).toBeTruthy();
+    expect(within(layerButton).queryByText(/时长/u)).toBeNull();
+    expect(
+      playbackButton.querySelector('svg')?.getAttribute('class'),
+    ).toContain('lucide-music');
 
-    fireEvent.pointerDown(audio);
-    fireEvent.click(audio);
+    rerender(
+      <ImageCanvasWorldView
+        {...props}
+        layers={[layer]}
+        hoveredLayerId={layer.id}
+        selectedLayerIds={[layer.id]}
+      />,
+    );
+    const hoveredLayerButton = screen.getByRole('button', {
+      name: '选择游戏背景音乐',
+    });
+    expect(
+      within(hoveredLayerButton)
+        .getByRole('button', { name: '播放游戏背景音乐' })
+        .querySelector('svg')
+        ?.getAttribute('class'),
+    ).toContain('lucide-play');
+
+    const hoveredAudio = within(hoveredLayerButton).getByLabelText(
+      '画布音频：游戏背景音乐',
+    );
+    fireEvent.play(hoveredAudio);
+    expect(
+      within(hoveredLayerButton)
+        .getByRole('button', { name: '暂停游戏背景音乐' })
+        .querySelector('svg')
+        ?.getAttribute('class'),
+    ).toContain('lucide-pause');
+
+    fireEvent.pointerDown(hoveredAudio);
+    fireEvent.click(hoveredAudio);
 
     expect(props.onLayerPointerDown).not.toHaveBeenCalled();
     expect(props.onLayerClick).not.toHaveBeenCalled();
@@ -628,7 +699,7 @@ describe('ImageCanvasWorldView', () => {
     );
   });
 
-  it('shows duration instead of resolution for focused audio generation frames', () => {
+  it('hides resolution and duration text for focused audio generation frames', () => {
     const dialog = createGenerationDialog({
       id: 'dialog-audio',
       mode: 'audio-sound-effect',
@@ -640,7 +711,7 @@ describe('ImageCanvasWorldView', () => {
     });
 
     const frame = screen.getByRole('button', { name: '音效生成占位图' });
-    expect(within(frame).getByText('时长 --:--')).toBeTruthy();
+    expect(within(frame).queryByText('时长 --:--')).toBeNull();
     expect(within(frame).queryByText('1024 x 768')).toBeNull();
   });
 
diff --git a/src/components/image-editor/ImageCanvasWorldView.tsx b/src/components/image-editor/ImageCanvasWorldView.tsx
index d85dd37d5..a7f94f328 100644
--- a/src/components/image-editor/ImageCanvasWorldView.tsx
+++ b/src/components/image-editor/ImageCanvasWorldView.tsx
@@ -1,13 +1,20 @@
 import {
-  Film,
+  AppWindow,
+  Clapperboard,
+  ClipboardList,
+  Grid2X2,
   ImageIcon,
   Info,
-  Music2,
+  Megaphone,
+  Music,
+  Pause,
+  Play,
   PersonStanding,
+  Sparkles,
   UserRound,
   Volume2,
 } from 'lucide-react';
-import { useState } from 'react';
+import { useRef, useState } from 'react';
 import type {
   CSSProperties,
   KeyboardEvent as ReactKeyboardEvent,
@@ -35,7 +42,6 @@ import {
   getGenerationFrameLabel,
   getLayerKindLabel,
 } from './ImageCanvasGenerationModel';
-import { formatCanvasDurationMetric } from './ImageCanvasMediaModel';
 
 function getGenerationPlaceholderMeta(dialog: CanvasGenerationDialogState) {
   switch (dialog.mode) {
@@ -61,48 +67,48 @@ function getGenerationPlaceholderMeta(dialog: CanvasGenerationDialogState) {
         frameClassName: 'image-canvas-editor__generation-frame--spec',
         badgeClassName: 'spec',
         badgeLabel: '规范',
-        icon: <ImageIcon className="h-8 w-8" />,
-        labelIcon: <ImageIcon className="h-4 w-4" />,
+        icon: <ClipboardList className="h-8 w-8" />,
+        labelIcon: <ClipboardList className="h-4 w-4" />,
       };
     case 'icon':
       return {
         frameClassName: 'image-canvas-editor__generation-frame--icon',
         badgeClassName: 'icon',
         badgeLabel: '图标',
-        icon: <ImageIcon className="h-8 w-8" />,
-        labelIcon: <ImageIcon className="h-4 w-4" />,
+        icon: <Grid2X2 className="h-8 w-8" />,
+        labelIcon: <Grid2X2 className="h-4 w-4" />,
       };
     case 'ui-design':
       return {
         frameClassName: 'image-canvas-editor__generation-frame--ui-design',
         badgeClassName: 'ui-design',
         badgeLabel: 'UI设计',
-        icon: <ImageIcon className="h-8 w-8" />,
-        labelIcon: <ImageIcon className="h-4 w-4" />,
+        icon: <AppWindow className="h-8 w-8" />,
+        labelIcon: <AppWindow className="h-4 w-4" />,
       };
     case 'quick-edit':
       return {
         frameClassName: 'image-canvas-editor__generation-frame--quick-edit',
         badgeClassName: 'quick-edit',
         badgeLabel: '快编',
-        icon: <ImageIcon className="h-8 w-8" />,
-        labelIcon: <ImageIcon className="h-4 w-4" />,
+        icon: <Sparkles className="h-8 w-8" />,
+        labelIcon: <Sparkles className="h-4 w-4" />,
       };
     case 'publication':
       return {
         frameClassName: 'image-canvas-editor__generation-frame--publication',
         badgeClassName: 'publication',
         badgeLabel: '宣发',
-        icon: <ImageIcon className="h-8 w-8" />,
-        labelIcon: <ImageIcon className="h-4 w-4" />,
+        icon: <Megaphone className="h-8 w-8" />,
+        labelIcon: <Megaphone className="h-4 w-4" />,
       };
     case 'video':
       return {
         frameClassName: 'image-canvas-editor__generation-frame--video',
         badgeClassName: 'video',
         badgeLabel: '视频',
-        icon: <Film className="h-8 w-8" />,
-        labelIcon: <Film className="h-4 w-4" />,
+        icon: <Clapperboard className="h-8 w-8" />,
+        labelIcon: <Clapperboard className="h-4 w-4" />,
       };
     case 'audio-sound-effect':
       return {
@@ -119,8 +125,8 @@ function getGenerationPlaceholderMeta(dialog: CanvasGenerationDialogState) {
           'image-canvas-editor__generation-frame--audio-background-music',
         badgeClassName: 'background-music',
         badgeLabel: '背景音乐',
-        icon: <Music2 className="h-8 w-8" />,
-        labelIcon: <Music2 className="h-4 w-4" />,
+        icon: <Music className="h-8 w-8" />,
+        labelIcon: <Music className="h-4 w-4" />,
       };
     default:
       return {
@@ -147,7 +153,7 @@ function buildInverseScaleStyle(
     '--image-canvas-editor-inverse-scale': String(inverseScale),
     '--image-canvas-editor-corner-offset': `calc(0.35rem * ${inverseScale})`,
     '--image-canvas-editor-kind-offset': `calc(0.38rem * ${inverseScale})`,
-    '--image-canvas-editor-beside-kind-offset': `calc(3.95rem * ${inverseScale})`,
+    '--image-canvas-editor-beside-kind-offset': `calc(1.95rem * ${inverseScale})`,
     '--image-canvas-editor-frame-label-offset': `calc(-1.35rem * ${inverseScale})`,
   };
 }
@@ -221,55 +227,89 @@ function handleLayerKeyboardActivation(
 }
 
 function getLayerMetricLabel(layer: CanvasLayer) {
-  if (layer.mediaType === 'audio') {
-    return formatCanvasDurationMetric(layer.durationSeconds);
-  }
   return `${Math.round(layer.originalWidth)} x ${Math.round(
     layer.originalHeight,
   )} px`;
 }
 
-function isAudioGenerationDialog(dialog: CanvasGenerationDialogState) {
-  return (
-    dialog.mode === 'audio-sound-effect' ||
-    dialog.mode === 'audio-background-music'
+function getAudioLayerIcon(layer: CanvasLayer) {
+  return layer.assetKind === 'background-music' ? (
+    <Music className="h-8 w-8" aria-hidden="true" />
+  ) : (
+    <Volume2 className="h-8 w-8" aria-hidden="true" />
   );
 }
 
-function ImageCanvasAudioLayerCard({ layer }: { layer: CanvasLayer }) {
-  const [loadedDurationSeconds, setLoadedDurationSeconds] = useState<
-    number | null
-  >(null);
+function ImageCanvasAudioLayerCard({
+  layer,
+  isHovered,
+}: {
+  layer: CanvasLayer;
+  isHovered: boolean;
+}) {
+  const audioRef = useRef<HTMLAudioElement | null>(null);
+  const [isPlaying, setIsPlaying] = useState(false);
   const { resolvedUrl } = useResolvedAssetReadUrl(layer.src, {
     refreshKey: layer.taskId ?? layer.resourceId,
   });
   const prompt = layer.prompt?.trim();
-  const durationSeconds = layer.durationSeconds ?? loadedDurationSeconds;
+  const showPlaybackButton = isPlaying || isHovered;
+
+  const togglePlayback = async () => {
+    const audio = audioRef.current;
+    if (!audio) {
+      return;
+    }
+    if (isPlaying) {
+      audio.pause();
+      return;
+    }
+    try {
+      await audio.play();
+    } catch {
+      setIsPlaying(false);
+    }
+  };
 
   return (
     <div className="image-canvas-editor__audio-card">
+      <button
+        type="button"
+        className="image-canvas-editor__audio-card-playback"
+        aria-label={isPlaying ? `暂停${layer.title}` : `播放${layer.title}`}
+        onClick={(event) => {
+          event.stopPropagation();
+          void togglePlayback();
+        }}
+        onPointerDown={stopMediaEventPropagation}
+      >
+        {showPlaybackButton ? (
+          isPlaying ? (
+            <Pause className="h-8 w-8" aria-hidden="true" />
+          ) : (
+            <Play className="h-8 w-8" aria-hidden="true" />
+          )
+        ) : (
+          getAudioLayerIcon(layer)
+        )}
+      </button>
       {prompt ? (
         <span className="image-canvas-editor__audio-card-title">{prompt}</span>
       ) : null}
-      <audio
-        src={resolvedUrl || undefined}
-        controls
-        preload="metadata"
-        aria-label={`画布音频：${layer.title}`}
-        onClick={stopMediaEventPropagation}
-        onPointerDown={stopMediaEventPropagation}
-        onLoadedMetadata={(event) => {
-          const nextDuration = event.currentTarget.duration;
-          setLoadedDurationSeconds(
-            Number.isFinite(nextDuration) && nextDuration > 0
-              ? nextDuration
-              : null,
-          );
-        }}
-      />
-      <span className="image-canvas-editor__audio-card-meta">
-        {formatCanvasDurationMetric(durationSeconds)}
-      </span>
+      <div className="image-canvas-editor__audio-card-controls">
+        <audio
+          ref={audioRef}
+          src={resolvedUrl || undefined}
+          controls
+          preload="metadata"
+          aria-label={`画布音频：${layer.title}`}
+          onClick={stopMediaEventPropagation}
+          onPointerDown={stopMediaEventPropagation}
+          onPlay={() => setIsPlaying(true)}
+          onPause={() => setIsPlaying(false)}
+          onEnded={() => setIsPlaying(false)}
+        />
+      </div>
     </div>
   );
 }
@@ -370,7 +410,10 @@ export function ImageCanvasWorldView({
               aria-label={`选择${layer.title}`}
             >
               {layer.mediaType === 'audio' ? (
-                <ImageCanvasAudioLayerCard layer={layer} />
+                <ImageCanvasAudioLayerCard
+                  layer={layer}
+                  isHovered={isHovered}
+                />
               ) : layer.mediaType === 'video' ? (
                 <video
                   className="image-canvas-editor__layer-video"
@@ -417,7 +460,7 @@ export function ImageCanvasWorldView({
                 }}
                 onPointerDown={(event) => event.stopPropagation()}
               />
-              {isHovered ? (
+              {isHovered && layer.mediaType !== 'audio' ? (
                 <PlatformPillBadge
                   tone="lightOverlay"
                   size="xs"
@@ -552,16 +595,14 @@ export function ImageCanvasWorldView({
                       {placeholderMeta.badgeLabel}
                     </span>
                   ) : null}
-                  {showFocusedChrome ? (
+                  {showFocusedChrome &&
+                  dialog.mode !== 'audio-sound-effect' &&
+                  dialog.mode !== 'audio-background-music' ? (
                     <span
                       className="image-canvas-editor__generation-frame-size"
                       style={inverseScaleStyle}
                     >
-                      {isAudioGenerationDialog(dialog)
-                        ? formatCanvasDurationMetric(
-                            dialog.audioDurationSeconds ?? null,
-                          )
-                        : `${dialog.placeholder.originalWidth} x ${dialog.placeholder.originalHeight}`}
+                      {`${dialog.placeholder.originalWidth} x ${dialog.placeholder.originalHeight}`}
                     </span>
                   ) : null}
                   <span className="image-canvas-editor__generation-frame-icon">
diff --git a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
index 75e95a0af..e77cdb04c 100644
--- a/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.test.tsx
@@ -496,6 +496,7 @@ describe('useImageCanvasGenerationSubmissionWorkflow', () => {
         prompt: expect.stringContaining('【宣发素材类型】详情页单图'),
         size: '720x1280',
         kind: 'publication-material',
+        model: 'gemini-3.1-flash-image-preview',
         referenceImageSrcs: ['data:image/png;base64,large-ref'],
       });
     });
diff --git a/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx b/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
index f451ac26e..260838c9c 100644
--- a/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationSurface.test.tsx
@@ -213,7 +213,7 @@ describe('useImageCanvasGenerationSurface', () => {
 
     fireEvent.click(screen.getByRole('button', { name: '切换生成' }));
     expect(screen.getByTestId('composer-left').textContent).toBe('450');
-    expect(screen.getByTestId('composer-top').textContent).toBe('750');
+    expect(screen.getByTestId('composer-top').textContent).toBe('1354');
 
     fireEvent.click(screen.getByRole('button', { name: '关闭生成图片' }));
     expect(screen.queryByRole('dialog', { name: '生成图片' })).toBeNull();
@@ -321,7 +321,9 @@ 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/useImageCanvasGenerationWorkflow.test.tsx b/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
index a1810607b..0cbbf6e74 100644
--- a/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
+++ b/src/components/image-editor/useImageCanvasGenerationWorkflow.test.tsx
@@ -22,6 +22,8 @@ import { useImageCanvasGenerationWorkflow } from './useImageCanvasGenerationWork
 const generateEditorImageMock = vi.hoisted(() => vi.fn());
 const generateEditorCharacterAnimationMock = vi.hoisted(() => vi.fn());
 const generateEditorIconSpritesheetMock = vi.hoisted(() => vi.fn());
+const generateEditorSoundEffectMock = vi.hoisted(() => vi.fn());
+const generateEditorBackgroundMusicMock = vi.hoisted(() => vi.fn());
 const editEditorImageMock = vi.hoisted(() => vi.fn());
 const renderCropExpandImageMock = vi.hoisted(() => vi.fn());
 
@@ -36,9 +38,11 @@ vi.mock('../../services/image-editor/editorProjectClient', async () => {
   return {
     ...actual,
     editEditorImage: editEditorImageMock,
+    generateEditorBackgroundMusic: generateEditorBackgroundMusicMock,
     generateEditorCharacterAnimation: generateEditorCharacterAnimationMock,
     generateEditorIconSpritesheet: generateEditorIconSpritesheetMock,
     generateEditorImage: generateEditorImageMock,
+    generateEditorSoundEffect: generateEditorSoundEffectMock,
   };
 });
 
@@ -199,6 +203,35 @@ function GenerationWorkflowHarness({
       <button type="button" onClick={workflow.openVideoGenerationDialog}>
         打开视频生成
       </button>
+      <button
+        type="button"
+        onClick={() =>
+          workflow.openRedrawPanel(
+            createLayer({
+              id: 'layer-sound',
+              title: '游戏音效',
+              src: 'data:audio/mpeg;base64,sound',
+              mediaType: 'audio',
+              assetKind: 'sound-effect',
+              width: 420,
+              height: 120,
+              originalWidth: 420,
+              originalHeight: 120,
+              prompt: '金币跳出音',
+              generationInputs: {
+                fields: [
+                  { title: 'prompt', value: '金币跳出音' },
+                  { title: 'model', value: 'audio1.0' },
+                  { title: 'duration', value: '8秒' },
+                ],
+                references: [],
+              },
+            }),
+          )
+        }
+      >
+        打开音效改造
+      </button>
       <button
         type="button"
         onClick={() =>
@@ -409,9 +442,9 @@ describe('useImageCanvasGenerationWorkflow', () => {
     fireEvent.click(screen.getByRole('button', { name: '打开生成' }));
 
     expect(screen.getByTestId('placeholder').textContent).toBe(
-      '-452:-60:420:420',
+      '-1056:-362:1024:1024',
     );
-    expect(screen.getByTestId('viewport').textContent).toBe('934:20:2');
+    expect(screen.getByTestId('viewport').textContent).toBe('1538:20:2');
   });
 
   it('places a new video generation placeholder away from existing canvas images and centers the viewport on it', () => {
@@ -434,9 +467,66 @@ describe('useImageCanvasGenerationWorkflow', () => {
     expect(screen.getByTestId('tool').textContent).toBe('video');
     expect(screen.getByTestId('selected').textContent).toBe('-');
     expect(screen.getByTestId('placeholder').textContent).toBe(
-      '-60:412:560:315',
+      '-207:412:854:480',
+    );
+    expect(screen.getByTestId('viewport').textContent).toBe('10:-984:2');
+  });
+
+  it('opens audio remodel as an audio generation dialog next to the source layer', () => {
+    render(<GenerationWorkflowHarness />);
+
+    fireEvent.click(screen.getByRole('button', { name: '打开音效改造' }));
+
+    expect(screen.getByTestId('tool').textContent).toBe('music');
+    expect(screen.getByTestId('selected').textContent).toBe('layer-sound');
+    expect(screen.getByTestId('quick-edit').textContent).toBe('-');
+    expect(screen.getByTestId('dialog').textContent).toBe(
+      'audio-sound-effect:idle:open:-:placeholder',
+    );
+    expect(screen.getByTestId('placeholder').textContent).toBe(
+      '572:140:420:120',
+    );
+  });
+
+  it('submits audio remodel with restored sound parameters and appends the new audio layer', async () => {
+    generateEditorSoundEffectMock.mockResolvedValueOnce({
+      audioSrc: 'data:audio/mpeg;base64,generated',
+      width: 420,
+      height: 120,
+      sourceType: 'generated',
+      prompt: '金币跳出音',
+      actualPrompt: '金币跳出音',
+      model: 'audio1.0',
+      provider: 'VectorEngine',
+      taskId: 'task-sound',
+      priceMudPoints: 10,
+      audioKind: 'sound-effect',
+      durationSeconds: 4,
+    });
+    render(<GenerationWorkflowHarness />);
+
+    fireEvent.click(screen.getByRole('button', { name: '打开音效改造' }));
+    fireEvent.click(screen.getByRole('button', { name: '提交生成' }));
+
+    await waitFor(() => {
+      expect(generateEditorSoundEffectMock).toHaveBeenCalledWith({
+        prompt: '金币跳出音',
+        model: 'audio1.0',
+        duration: 8,
+        priceMudPoints: 10,
+      });
+    });
+    await waitFor(() => {
+      expect(screen.getByTestId('layers').textContent).toContain(
+        'layer-audio-1:游戏音效 1:-:sound-effect',
+      );
+    });
+    expect(screen.getByTestId('dialog').textContent).toBe(
+      'audio-sound-effect:idle:open:layer-audio-1:placeholder',
+    );
+    expect(screen.getByTestId('placeholder').textContent).toBe(
+      '572:140:420:120',
     );
-    expect(screen.getByTestId('viewport').textContent).toBe('10:-819:2');
   });
 
   it('submits a normal generation, appends the generated layer, and keeps the composer anchored', async () => {
diff --git a/src/components/image-editor/useImageCanvasGenerationWorkflow.ts b/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
index a5c82a916..4fc17584a 100644
--- a/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
+++ b/src/components/image-editor/useImageCanvasGenerationWorkflow.ts
@@ -35,6 +35,7 @@ import {
   assignIconSpecReference,
   assignUiDesignSpecReference,
   closeGenerateComposerDialog,
+  createAudioRedrawGenerationDialogDraft,
   createBackgroundMusicGenerationDialogDraft,
   createCharacterAnimationGenerationDialogDraft,
   createCharacterGenerationDialogDraft,
@@ -281,6 +282,7 @@ export function useImageCanvasGenerationWorkflow({
     : null;
   const characterAnimationPrice = effectiveCharacterAnimationPanel
     ? calculateCharacterAnimationPrice(
+        'seedance2.0-fast',
         effectiveCharacterAnimationPanel.resolution,
         effectiveCharacterAnimationPanel.durationSeconds,
       )
@@ -584,14 +586,26 @@ export function useImageCanvasGenerationWorkflow({
     (sourceLayer: CanvasLayer) => {
       setImageContextMenu(null);
       setMetadataLayer(null);
-      setGenerateDialog(null);
       setCropExpandPanel(null);
       setCharacterAnimationPanel(null);
+      if (sourceLayer.mediaType === 'audio') {
+        const audioDraft = createAudioRedrawGenerationDialogDraft(sourceLayer);
+        if (!audioDraft) {
+          return;
+        }
+        setQuickEditPanel(null);
+        openCanvasGenerationDialog(audioDraft);
+        selectSingleLayer(sourceLayer.id);
+        setActiveTool('music');
+        return;
+      }
+      setGenerateDialog(null);
       setQuickEditPanel(createRedrawPanelDraft(sourceLayer));
       selectSingleLayer(sourceLayer.id);
       setActiveTool('generate');
     },
     [
+      openCanvasGenerationDialog,
       selectSingleLayer,
       setActiveTool,
       setGenerateDialog,
diff --git a/src/index.css b/src/index.css
index 7df9b8c2f..ea708e380 100644
--- a/src/index.css
+++ b/src/index.css
@@ -4040,22 +4040,41 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
 }
 
 .image-canvas-editor__audio-card {
+  position: relative;
   display: flex;
   flex-direction: column;
+  overflow: hidden;
   width: 100%;
   height: 100%;
-  justify-content: center;
-  gap: 0.38rem;
+  justify-content: flex-end;
+  gap: 0.3rem;
   border-radius: 0.85rem;
   background: linear-gradient(135deg, #0f172a, #263449);
-  padding: 0.85rem;
+  padding: 0.7rem;
   box-shadow: 0 16px 38px rgba(15, 23, 42, 0.18);
 }
 
-.image-canvas-editor__audio-card-title,
-.image-canvas-editor__audio-card-meta {
+.image-canvas-editor__audio-card-playback {
+  position: absolute;
+  inset: 0;
+  z-index: 1;
+  display: grid;
+  place-items: center;
+  border: 0;
+  background: transparent;
+  color: rgba(255, 255, 255, 0.9);
+  cursor: pointer;
+}
+
+.image-canvas-editor__audio-card-playback:hover {
+  background: rgba(15, 23, 42, 0.18);
+}
+
+.image-canvas-editor__audio-card-title {
+  position: relative;
+  z-index: 2;
   overflow: hidden;
-  color: rgba(255, 255, 255, 0.86);
+  color: #ffffff;
   font-size: 0.74rem;
   font-weight: 800;
   line-height: 1.1;
@@ -4063,16 +4082,14 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
   white-space: nowrap;
 }
 
-.image-canvas-editor__audio-card-title {
-  color: #ffffff;
-}
-
-.image-canvas-editor__audio-card-meta {
-  color: rgba(226, 232, 240, 0.72);
+.image-canvas-editor__audio-card-controls {
+  position: relative;
+  z-index: 2;
 }
 
 .image-canvas-editor__audio-card audio {
   width: 100%;
+  height: 1.85rem;
 }
 
 .image-canvas-editor__layer--hovered,
@@ -4472,7 +4489,7 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
 }
 
 .image-canvas-editor__metadata-corner--beside-spec {
-  right: var(--image-canvas-editor-beside-kind-offset, 3.95rem);
+  right: var(--image-canvas-editor-beside-kind-offset, 1.95rem);
 }
 
 .image-canvas-editor__metadata-corner--beside-kind {
@@ -4520,7 +4537,7 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
 }
 
 .image-canvas-editor__kind-badge--beside-info {
-  right: var(--image-canvas-editor-beside-kind-offset, 3.95rem);
+  right: var(--image-canvas-editor-beside-kind-offset, 1.95rem);
 }
 
 .image-canvas-editor__kind-badge--spec {
@@ -5760,6 +5777,63 @@ button.image-canvas-editor__reference-chip:disabled {
   grid-column: 1 / -1;
 }
 
+.image-canvas-editor__publication-composer {
+  grid-template-rows: auto auto auto;
+}
+
+.image-canvas-editor__publication-composer-fields {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 0.46rem 0.52rem;
+  min-width: 0;
+}
+
+.image-canvas-editor__publication-composer-summary,
+.image-canvas-editor__publication-description-field {
+  grid-column: 1 / -1;
+}
+
+.image-canvas-editor__publication-composer-summary {
+  display: flex;
+  min-height: 1.5rem;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.6rem;
+  color: #64748b;
+  font-size: 0.72rem;
+  font-weight: 780;
+}
+
+.image-canvas-editor__publication-composer-summary strong {
+  color: #111827;
+  font-size: 0.78rem;
+  font-weight: 860;
+  white-space: nowrap;
+}
+
+.image-canvas-editor__publication-input {
+  min-height: 1.96rem;
+}
+
+.image-canvas-editor__publication-description {
+  min-height: 4rem;
+}
+
+.image-canvas-editor__publication-composer
+  .image-canvas-editor__generation-composer-footer {
+  grid-template-columns: minmax(0, 1fr) auto auto;
+}
+
+.image-canvas-editor__publication-composer
+  .image-canvas-editor__option-popover-anchor--model {
+  grid-column: 2;
+}
+
+.image-canvas-editor__publication-composer
+  .image-canvas-editor__generation-submit {
+  grid-column: 3;
+}
+
 .image-canvas-editor__icon-composer {
   position: absolute;
   z-index: 13;
diff --git a/src/services/image-editor/editorProjectClient.test.ts b/src/services/image-editor/editorProjectClient.test.ts
index 4c0945a58..e859fa81a 100644
--- a/src/services/image-editor/editorProjectClient.test.ts
+++ b/src/services/image-editor/editorProjectClient.test.ts
@@ -985,9 +985,9 @@ describe('editorProjectClient', () => {
     });
 
     const result = await generateEditorSoundEffect({
-      sound: '金币掉落叮当声',
-      type: 'one-shot',
-      tempo: 120,
+      prompt: '金币掉落叮当声',
+      model: 'audio1.0',
+      duration: 7,
       priceMudPoints: 10,
     });
 
@@ -998,9 +998,9 @@ describe('editorProjectClient', () => {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          sound: '金币掉落叮当声',
-          type: 'one-shot',
-          tempo: 120,
+          prompt: '金币掉落叮当声',
+          model: 'audio1.0',
+          duration: 7,
           priceMudPoints: 10,
         }),
       }),
@@ -1012,7 +1012,7 @@ describe('editorProjectClient', () => {
     );
   });
 
-  it('keeps editor sound effect tempo as null when BPM is not selected', async () => {
+  it('sends editor sound effect duration to Vidu instead of legacy type and tempo', async () => {
     requestJsonMock.mockResolvedValueOnce({
       audioSrc: '/generated-character-drafts/editor-audios/sfx-null.mp3',
       width: 420,
@@ -1028,9 +1028,9 @@ describe('editorProjectClient', () => {
     });
 
     await generateEditorSoundEffect({
-      sound: '按钮确认短促音',
-      type: 'one-shot',
-      tempo: null,
+      prompt: '按钮确认短促音',
+      model: 'audio1.0',
+      duration: 5,
       priceMudPoints: 10,
     });
 
@@ -1038,9 +1038,9 @@ describe('editorProjectClient', () => {
       '/api/editor/audios/sound-effects/generations',
       expect.objectContaining({
         body: JSON.stringify({
-          sound: '按钮确认短促音',
-          type: 'one-shot',
-          tempo: null,
+          prompt: '按钮确认短促音',
+          model: 'audio1.0',
+          duration: 5,
           priceMudPoints: 10,
         }),
       }),
diff --git a/src/services/image-editor/editorProjectClient.ts b/src/services/image-editor/editorProjectClient.ts
index 9c50444a2..465698fea 100644
--- a/src/services/image-editor/editorProjectClient.ts
+++ b/src/services/image-editor/editorProjectClient.ts
@@ -241,9 +241,9 @@ export type EditorVideoGenerationResult = {
 };
 
 export type EditorSoundEffectGenerationInput = {
-  sound: string;
-  type: 'one-shot' | 'loop';
-  tempo: number | null;
+  prompt: string;
+  model: 'audio1.0';
+  duration: number;
   priceMudPoints: number;
 };
 
@@ -679,9 +679,9 @@ export async function generateEditorSoundEffect(
   return requestJson<EditorAudioGenerationResponse>(
     EDITOR_SOUND_EFFECT_GENERATION_API,
     jsonRequest('POST', {
-      sound: input.sound,
-      type: input.type,
-      tempo: input.tempo,
+      prompt: input.prompt,
+      model: input.model,
+      duration: input.duration,
       priceMudPoints: input.priceMudPoints,
     }),
     '生成游戏音效失败',