From 7ec51732f7b736f9250fd93b558a1a98f6652a71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=88=B1=E7=AC=91=E7=9A=84=E6=AF=9B=E6=AF=9B=E8=99=AB?=
 <nuwa.sky@outlook.com>
Date: Fri, 4 Sep 2026 14:03:33 +0800
Subject: [PATCH] =?UTF-8?q?feat(editor):=20AI=20=E7=BC=96=E8=BE=91?=
 =?UTF-8?q?=E5=8A=A9=E6=89=8B=E6=82=AC=E6=B5=AE=E9=9D=A2=E6=9D=BF=E3=80=81?=
 =?UTF-8?q?=E6=8F=92=E4=BB=B6=E6=9D=83=E9=99=90=E4=BD=93=E7=B3=BB=E4=B8=8E?=
 =?UTF-8?q?=E6=97=B6=E9=97=B4=E7=BA=BF=E6=B8=B2=E6=9F=93=E7=AE=A1=E7=BA=BF?=
 =?UTF-8?q?=EF=BC=88M4=E2=80=93M6.3=EF=BC=89=20(#411)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(editor): 编辑器实施 M0-M1 - 剪辑入口占位与插件 SDK v2 垂直切片

- detail.tsx 新增剪辑成片视图（editor tab，常驻），概览页插入剪辑步骤卡
- plugin-types.ts 新增 v2 类型（EditorSlotKind/EditorPluginPermission/PluginManifestV2），修复权限数组交叉归约 bug
- editor-slot-registry.ts 插槽注册表（优先级排序、幂等注册、订阅机制）
- plugin-registry.ts 注册器 v1/v2 分支校验，v1 路径零改动
- editor-shell.tsx 垂直切片插件：timeline-panel 插槽真实渲染，验证插件链路全通
- 测试：插槽注册表 5 用例 + 命令测试骨架，v1 插件回归 21 例零回归

* feat(editor): 命令协议黄金文件 - editor-commands 纯函数 reducer + 8 个黄金 op

* feat(editor): 快照撤销历史 - editor-history 有界 200 层 undo/redo

* feat(editor): 命令状态机 store - dispatch/手势预览/1.5s 防抖保存/串行保存链

* fix(editor): createEditorStore 返回 zustand hook 类型修复 typecheck

* feat(editor): 手势 echo 最小件 - 时间线面板拖拽移动/裁剪 + store 接线与本地持久化

* docs(editor): M2 完成状态记录

* feat(editor): M3.1 时间线面板选中联动 - store 选中状态 + 片段高亮/点击取消

* feat(editor): M3.2 预览监视器 - preview-renderer 插槽 + 真实媒体帧/播放头/时间码

* feat(editor): M3.3 片段检查器 - inspector 插槽 + 属性编辑入队可撤销

* feat(editor): M3.4 asset-ingest 素材库插件（addClip 命令入轨）

* feat(editor): M3.4 补充 - host 上下文（项目信息+资产）、editor.tsx 接线、asset-ingest 纯函数、死代码清理

* feat(editor): M3.5 subtitle-tools - SRT import/export + rebuild from node snapshot

* feat(editor): M3.6 transcription - deterministic mock ASR to subtitle track

* feat(editor): M3.7 export - render plan + ffmpeg.wasm fallback export

* feat(editor): M3.8 - render all 8 editor slots in three-pane layout + ai-assistant placeholder

* docs(editor): M3 完成状态 - 8 插件 + 全插槽接线，冒烟待确认

* feat(editor): 编辑器媒体与时间线打磨 - 资产来源分组筛选、时间线全宽布局、拖拽末片段修复、OSS 降级本地存储、Concat 风格控制条与检查器

* fix(plugins): 合并上游后修复插件分类筛选对 v2 清单的类型兼容

* feat(editor): 时间线工具态与轨道操作打磨 - 工具按钮选中仅图标变色、监视器 Concat 式控制条、removeTrack 黄金命令与轨道行头移除按钮、maskClosable 迁移

* fix(api): 资源上传超 MaxBytesReader 上限时报中文大小限制而非英文裸 400

* fix(editor): 监视器控制条 - 修复播放按钮 JSX 模板闭合花括号缺失导致的编译错误

* feat(api): 本地媒体导入分片化对齐 Concat - >50MB 视频不再失败 - 分片会话三接口(POST开始/PUT单片/complete合并)、前端超50MB自动切8MB分片并失败整传重试、默认配额放宽(日200MB→2GB、总2GB→20GB)、UploadResourceFile 豁免单文件限

* feat(editor): 轨道行头新增可见性/静音开关按钮 - 复用现有图标资源，按轨道类型显隐；命令层新增 setTrackFlag 黄金命令（flag 白名单 fail-closed）并补单测

* docs(progress): 记录轨道可见/静音开关改动与复测项

* docs(editor): M4 转写与渲染任务设计 - 复用 Task 表与状态机、独立创建 API、worker 领取类型过滤、whisper HTTP provider（OpenAI 兼容 /v1/audio）

* fix(api): OSS 上传失败自动降级本地存储时 body 已被 Transport 关闭 - newOSSRequest 用 NopCloser 包装请求体,服务端提前返回(签名 403)时不再关闭调用方持有的文件,降级分支 Seek 重读生效;补回归测试

* docs(progress): 记录媒体导入根治(分片+OSS 降级修复)复测项

* feat(api): 视频播放副本转码 H.265→H.264 + variant=playback 服务与启动回填 - 上传视频后异步探测 codec，H.265/AV1 走 moov 快速探测并转码 H.264 播放副本；GET /api/user-data/...?variant=playback 就绪时服务副本（独立 ETag :pb），未就绪回退原件并撤销后缀防 304 黑屏；storeResource 触发、启动幂等回填存量；前端播放失败自动轮询副本就绪后刷新

* fix(editor): 轨道至少保留一条 - 不可移除轨道点击 X 时居中浮现原因提示(2.2s 自动消失, aria-live)；修正可见性 toggle 传参 (visible===false 语义) ；轨道行内移除按钮改为常驻(不可移除时点击给提示)

* feat(timeline): M4.1 字幕转写后台任务 - whisper.cpp 本地执行 - 新增 timeline_transcription 任务类型，worker 按类型分叉独立执行器（不走计费与模型渠道）；输入 resourceId+language，读取用户资源后 ffmpeg 预处理 16k 单声道 wav，POST 本地 whisper.cpp /inference，结果写回 segments+srt+language；未配置 CANVAS_WHISPER_BASE_URL 等失败均落明确终态；feature 门控；进度分阶段；含解析/SRT/快速失败单元测试

* feat(media): 素材卡片时长与媒体面板打磨 - 导入媒体解析时长（前端 media-metadata + 后端 project_asset durationMs 透出）随卡片展示；媒体面板/监视器/时间线相关样式细节收尾

* docs(progress): 阶段 C 监视器播放复检清单 - H.265 播放副本/真实播放驱动/时长链路待浏览器确认

* feat(timeline): M4.1 转写任务创建 API - POST /api/timeline/transcriptions - service CreateTimelineTranscriptionTask：IsDraining 守护 + feature 门控 + 资源归属与可转写类型校验 + 排队计 active 限额(含任务级/项目级存储估算)；local/whisper.cpp 标记，任务不经过模型路由与计费；createTaskWithinStorageQuota 复用与 ErrActiveTaskLimit 用户可读映射；测试覆盖排队成功(owner/type/provider 断言)、跨用户资源拒绝、非音视频拒绝

* feat(timeline): M4.3 字幕转写前端接线 - 真实任务替换 mock - 新增 services/api/timeline-tasks.ts（POST /timeline/transcriptions，复用 apiClient+request）；EditorTranscription 改为 创建任务→waitForGenerationTask 轮询(25min)→结果 segments 映射 SrtEntry[]→rebuildSubtitleClips 写入字幕轨道；实时展示 stage/progress，失败/空识别/无字幕轨道分别提示；素材选择支持音频与视频（取 storageKey 中的 resource id 提交）

* fix(media): 播放副本状态收敛与轮询终态 - 无ffmpeg/远端存储/编码不可处理落 none 避免重复探测;前端 none 停轮询回原生播放并加 processing 上限

* feat(timeline): M4.2 时间线渲染任务 - POST /api/timeline/renders 创建（buildRenderPlan 校验含可渲染媒体、配额入队、local/ffmpeg、60min 超时）；worker 顶部按类型分叉 processTimelineRender；ffmpeg 合成产物写资源存储并经 ResultJSON 记 resourceId；render 计划/结果测试 PASS

* fix(resource): 转码原子抢占与 OSS 请求体加固 - ClaimPlaybackTranscode 空/none→processing 单实例抢占避免重复转码，runPlaybackTranscode defer recover 落 failed；If-Range 与带 :pb 后缀的 serveETag 比较；无请求体的 OSS 请求不再包 NopCloser(nil)（防 Go 1.26 body 探测 nil 解引用）

* style(editor): 修正字幕回写面板缩进

* docs(timeline): M4 设计文档按实现回写 - 单一 worker 池 + processClaimedTask 顶部按类型分叉（决策 3/4），端点统一为复数 /api/timeline/transcriptions 与 /api/timeline/renders（注册于 RegisterTaskRoutes），ResultJSON/feature gate/ffmpeg env 同步；Runbook M4 表格与状态行更新；auth.go API 前缀白名单补 timeline

* fix(service): 修复上游 v1.2.5 公告配图删除保护自锁与测试夹具缺口

上游 #385 资源引用走查器对公告配图/草稿做了硬性引用检查，导致三个问题：
- UpdateAnnouncement 在更新公告前对旧配图走查，必然命中当前公告自身引用而自锁，
  公告替换配图功能实际不可用；DiscardAnnouncementImage 同理被草稿自身引用阻塞。
  修复：ensureResourceHasNoBusinessReferences 支持忽略指定引用（当前公告/当前草稿），
  其余引用仍按原语义拦截。
- admin DeleteAdminResources 将公告草稿引用视为阻塞，但删除事务会级联清理草稿与
  资源绑定，service 层永不进入事务，回滚审计注入测试无法到达预期路径。修复：service
  预检时过滤公告草稿引用，与 repository 级联语义对齐。
- project_settings_test.go 夹具未建 ResourceReferenceSnapshot 走查的 Task/Session/
  Message/TaskLog/Result/Announcement/AnnouncementImageDraft 表，报 no such table。
  修复：夹具 AutoMigrate 补齐。

后端全量 go test ./... 通过。

* feat(editor): 成片导出接入后端渲染任务（M4.2 前端接线）- timeline-tasks 增 createTimelineRenderTask；editor-export 主路径改 POST /timeline/renders 轮询取 resourceId 内嵌预览/下载，ffmpeg.wasm 降级保留

* feat(editor): M5 插件权限执行（fail-closed）- plugin-permission-check 新建（8 插槽最小权限表/判定/断言）；SlotStack 渲染前过滤缺权限插槽改诊断条；editor-shell manifest 补 timeline.command/export.run；测试 10 用例含 editor-shell 真实回归

* feat(editor): M6.1 AI 命令 schema + M6.2 时间线摘要 - ai-command-schema（parse/dry-run 校验/12-op 提示词契约/版本化+golden）；timeline-summary（确定性中文摘要/折叠上限）；各 20/10 用例全绿

* docs(progress): M6 质检清单 - M6.1 schema/M6.2 摘要标记完成（含测试计数），M6.3 待模型源确认；清理 M5.1 重复条目

* feat(editor): AI 命令 schema 支持只读问答 - commands 空数组合法化（无法执行/纯提问时 reasoning 直接作答），新增 AI_EDITING_MAX_COMMANDS=8 上限防失控编辑，提示词同步

* feat(editor): AI 助手重构为右上悬浮对话面板（M6.3）+ 素材入库原子化收尾

- editor-ai-assistant.tsx: 占位面板替换为 OpenAI Canvas 风格右上悬浮对话面板；
  面板内文本模型选择器（effective.textModels，选择即持久化并覆写请求模型），
  消息流 user/assistant/error/preview 四类气泡 + 思考中占位，空态引导示例 chips
  一键发送，底部输入条；顶部工具栏常驻 Sparkles 入口（aria-pressed 切换）。
  修复上一版重复/截断函数声明（appendToEntry 双定义、settleAnswer 三声明等）。
  宿主链路：buildAiEditingSystemPrompt(summarizeTimeline(project)) 喂上下文 →
  parseAiCommandPlan → validateAiCommandBatch dry-run（任一非法整批拒绝）→
  ≤3 条 dispatch 直执行 / >3 条预览确认卡片；宿主拒绝时 failTurn 回填 FAILED_MARK 可重试。
- editor-asset-ingest/editor-preview-monitor/detail/editor.tsx: 配套接线与打磨
  （编辑器顶栏 AI 入口、素材导入面板、预览监视、项目页顶栏整理）。
- backend: LinkProjectAsset 事务内原子创建资产 + 项目链接（OnConflict 幂等），
  资产首次入库不再预落库，失败整体回滚，消除"有资产无链接"孤儿记录。
- docs: pending-test.mdx / runbook M6.3 状态更新（tsc + 测试 + 构建通过，
  浏览器冒烟待真实文本渠道）。
---
 .env.example                                  |   4 +
 .gitignore                                    |   2 +
 CONTEXT.md                                    |  81 ++
 backend/cmd/server/main.go                    |   3 +
 backend/internal/database/migrations.go       |  29 +-
 backend/internal/handler/auth.go              |   2 +-
 .../handler/chunk_upload_routes_test.go       |  32 +
 .../handler/resource_upload_session.go        | 299 +++++++
 backend/internal/handler/routes.go            |  46 +
 backend/internal/handler/user_data.go         |  47 +-
 backend/internal/model/models.go              |   6 +
 backend/internal/model/models_project.go      |   5 +
 backend/internal/model/timeline_task_type.go  |   9 +
 backend/internal/repository/repository.go     |  42 +-
 .../internal/service/admin_storage_delete.go  |  13 +-
 backend/internal/service/announcement.go      |  19 +-
 .../internal/service/feature_availability.go  |  49 +-
 backend/internal/service/project_asset.go     |  86 +-
 .../service/project_asset_link_test.go        |  95 +++
 .../internal/service/project_settings_test.go |   2 +
 backend/internal/service/resource.go          | 111 ++-
 .../service/resource_oss_fallback_test.go     | 107 +++
 backend/internal/service/resource_test.go     |  45 +-
 backend/internal/service/runtime_policy.go    |   4 +-
 backend/internal/service/task_render.go       | 200 +++++
 backend/internal/service/task_render_test.go  | 133 +++
 backend/internal/service/task_timeline.go     | 294 +++++++
 .../internal/service/task_timeline_test.go    | 150 ++++
 backend/internal/service/task_worker.go       |  15 +
 .../internal/service/timeline_render_plan.go  | 276 ++++++
 .../service/timeline_render_plan_test.go      | 148 ++++
 .../internal/service/transcription_whisper.go | 156 ++++
 .../service/transcription_whisper_test.go     | 101 +++
 backend/internal/service/upload_quota.go      |  10 +
 backend/internal/service/upload_quota_test.go |  12 +-
 backend/internal/service/video_transcode.go   | 314 +++++++
 .../internal/service/video_transcode_test.go  |  65 ++
 docs/adr/0001-editor-integration-boundary.md  |  34 +
 docs/adr/0002-edit-command-protocol.md        |  28 +
 docs/adr/0003-preview-export-layering.md      |  27 +
 .../0004-autocaption-transcription-service.md |  27 +
 .../0005-editor-preset-plugin-architecture.md |  40 +
 docs/adr/0006-voice-filters-and-templates.md  |  53 ++
 docs/adr/0007-ai-editing-interaction.md       |  55 ++
 docs/content/docs/progress/pending-test.mdx   | 110 +++
 docs/design/workspace-shell-design.mdx        |   2 +-
 docs/index.md                                 |  13 +
 docs/plans/editor-implementation-runbook.md   | 158 ++++
 .../editor-preset-plugin-implementation.md    | 489 +++++++++++
 docs/plans/m4-transcription-render-design.md  | 145 ++++
 .../assets/asset-library-picker-modal.tsx     |   2 +-
 .../components/canvas/canvas-upload-modal.tsx |   2 +-
 web/src/components/editor/editor-context.tsx  |  51 ++
 .../layout/workspace-command-palette.tsx      |   2 +-
 .../layout/workspace-sidebar-nav.tsx          |   2 +-
 web/src/lib/media-metadata.ts                 |  41 +
 .../builtin/editor/editor-ai-assistant.tsx    | 427 ++++++++++
 .../builtin/editor/editor-asset-ingest.tsx    | 531 ++++++++++++
 .../plugins/builtin/editor/editor-export.tsx  | 232 +++++
 .../builtin/editor/editor-inspector.tsx       | 198 +++++
 .../builtin/editor/editor-preview-monitor.tsx | 523 ++++++++++++
 .../plugins/builtin/editor/editor-shell.tsx   |  98 +++
 .../builtin/editor/editor-subtitle-tools.tsx  | 143 ++++
 .../builtin/editor/editor-timeline-panel.tsx  | 790 ++++++++++++++++++
 .../builtin/editor/editor-transcription.tsx   | 165 ++++
 web/src/lib/plugins/builtin/editor/index.ts   |   5 +
 web/src/lib/plugins/builtin/index.ts          |   1 +
 web/src/lib/plugins/editor-slot-registry.ts   |  93 +++
 .../lib/plugins/plugin-permission-check.ts    |  63 ++
 web/src/lib/plugins/plugin-registry.ts        |  53 +-
 web/src/lib/plugins/plugin-types.ts           |  41 +-
 web/src/lib/timeline/ai-command-schema.ts     | 221 +++++
 web/src/lib/timeline/asset-ingest.ts          |  49 ++
 web/src/lib/timeline/editor-commands.ts       | 364 ++++++++
 web/src/lib/timeline/editor-history.ts        |  57 ++
 web/src/lib/timeline/mock-transcription.ts    |  36 +
 web/src/lib/timeline/timeline-summary.ts      |  72 ++
 web/src/lib/timeline/timeline-view.ts         |   7 +-
 web/src/pages/admin/plugins/plugins-page.tsx  |   4 +-
 web/src/pages/plugins/index.tsx               |   8 +-
 web/src/pages/plugins/plugin-documentation.ts |   4 +-
 web/src/pages/projects/detail.tsx             |  52 +-
 web/src/pages/projects/detail/editor.tsx      | 472 +++++++++++
 web/src/pages/projects/detail/overview.tsx    |   3 +-
 web/src/pages/projects/index.tsx              |   2 +-
 web/src/pages/skills/skill-editor-drawer.tsx  |   2 +-
 web/src/pages/skills/skill-install-modal.tsx  |   2 +-
 web/src/services/api/projects.ts              |   4 +-
 web/src/services/api/resources.ts             | 100 ++-
 web/src/services/api/timeline-tasks.ts        |  60 ++
 web/src/stores/editor/editor-store.ts         | 193 +++++
 web/src/stores/use-plugin-store.ts            |   4 +-
 web/src/styles/globals.css                    | 139 +++
 web/src/types/timeline.ts                     |   4 +
 web/test/ai-command-schema.test.ts            | 150 ++++
 web/test/asset-ingest.test.ts                 |  85 ++
 web/test/editor-commands.test.ts              | 243 ++++++
 web/test/editor-history.test.ts               | 111 +++
 web/test/editor-slot-registry.test.ts         |  59 ++
 web/test/editor-store.test.ts                 | 228 +++++
 web/test/fixtures/ai-commands.golden.json     |  18 +
 web/test/fixtures/commands.golden.json        | 266 ++++++
 web/test/mock-transcription.test.ts           |  27 +
 web/test/plugin-permission-check.test.ts      | 134 +++
 web/test/timeline-summary.test.ts             |  97 +++
 web/test/timeline-view.test.ts                |  43 +
 106 files changed, 10857 insertions(+), 119 deletions(-)
 create mode 100644 CONTEXT.md
 create mode 100644 backend/internal/handler/chunk_upload_routes_test.go
 create mode 100644 backend/internal/handler/resource_upload_session.go
 create mode 100644 backend/internal/model/timeline_task_type.go
 create mode 100644 backend/internal/service/project_asset_link_test.go
 create mode 100644 backend/internal/service/resource_oss_fallback_test.go
 create mode 100644 backend/internal/service/task_render.go
 create mode 100644 backend/internal/service/task_render_test.go
 create mode 100644 backend/internal/service/task_timeline.go
 create mode 100644 backend/internal/service/task_timeline_test.go
 create mode 100644 backend/internal/service/timeline_render_plan.go
 create mode 100644 backend/internal/service/timeline_render_plan_test.go
 create mode 100644 backend/internal/service/transcription_whisper.go
 create mode 100644 backend/internal/service/transcription_whisper_test.go
 create mode 100644 backend/internal/service/video_transcode.go
 create mode 100644 backend/internal/service/video_transcode_test.go
 create mode 100644 docs/adr/0001-editor-integration-boundary.md
 create mode 100644 docs/adr/0002-edit-command-protocol.md
 create mode 100644 docs/adr/0003-preview-export-layering.md
 create mode 100644 docs/adr/0004-autocaption-transcription-service.md
 create mode 100644 docs/adr/0005-editor-preset-plugin-architecture.md
 create mode 100644 docs/adr/0006-voice-filters-and-templates.md
 create mode 100644 docs/adr/0007-ai-editing-interaction.md
 create mode 100644 docs/plans/editor-implementation-runbook.md
 create mode 100644 docs/plans/editor-preset-plugin-implementation.md
 create mode 100644 docs/plans/m4-transcription-render-design.md
 create mode 100644 web/src/components/editor/editor-context.tsx
 create mode 100644 web/src/lib/media-metadata.ts
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-ai-assistant.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-asset-ingest.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-export.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-inspector.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-preview-monitor.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-shell.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-subtitle-tools.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-timeline-panel.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/editor-transcription.tsx
 create mode 100644 web/src/lib/plugins/builtin/editor/index.ts
 create mode 100644 web/src/lib/plugins/editor-slot-registry.ts
 create mode 100644 web/src/lib/plugins/plugin-permission-check.ts
 create mode 100644 web/src/lib/timeline/ai-command-schema.ts
 create mode 100644 web/src/lib/timeline/asset-ingest.ts
 create mode 100644 web/src/lib/timeline/editor-commands.ts
 create mode 100644 web/src/lib/timeline/editor-history.ts
 create mode 100644 web/src/lib/timeline/mock-transcription.ts
 create mode 100644 web/src/lib/timeline/timeline-summary.ts
 create mode 100644 web/src/pages/projects/detail/editor.tsx
 create mode 100644 web/src/services/api/timeline-tasks.ts
 create mode 100644 web/src/stores/editor/editor-store.ts
 create mode 100644 web/test/ai-command-schema.test.ts
 create mode 100644 web/test/asset-ingest.test.ts
 create mode 100644 web/test/editor-commands.test.ts
 create mode 100644 web/test/editor-history.test.ts
 create mode 100644 web/test/editor-slot-registry.test.ts
 create mode 100644 web/test/editor-store.test.ts
 create mode 100644 web/test/fixtures/ai-commands.golden.json
 create mode 100644 web/test/fixtures/commands.golden.json
 create mode 100644 web/test/mock-transcription.test.ts
 create mode 100644 web/test/plugin-permission-check.test.ts
 create mode 100644 web/test/timeline-summary.test.ts
 create mode 100644 web/test/timeline-view.test.ts

diff --git a/.env.example b/.env.example
index 251f6f495..561af1009 100644
--- a/.env.example
+++ b/.env.example
@@ -14,6 +14,10 @@ ENABLE_PROVIDER_PLUGINS=false
 CANVAS_DATA_PATH=./data
 CANVAS_WORKER_CONCURRENCY=3
 CANVAS_CHANNEL_CONCURRENCY=3
+# 时间线字幕转写由本地 whisper.cpp 服务执行；指向其 HTTP 地址（如 http://127.0.0.1:8082），不配置则转写任务明确失败。
+CANVAS_WHISPER_BASE_URL=
+# 时间线渲染/播放副本转码使用的 ffmpeg 可执行文件；留空时在 PATH 中查找。
+CANVAS_FFMPEG_PATH=
 # 收到 SIGTERM 后等待活动后台任务完成的最长时间；生产 Compose 的 stop_grace_period 使用同一值。
 CANVAS_SHUTDOWN_TIMEOUT=10m
 # 开发和旧部署默认由后端启动时迁移；受管生产部署由独立 migrate 服务执行并将此项设为 false。
diff --git a/.gitignore b/.gitignore
index a53f08137..b023579bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,8 @@ node_modules/
 docs/*
 !docs/design/
 !docs/index.md
+!docs/adr/
+!docs/plans/
 # Keep the new plugin design spec versioned without unignoring generated docs.
 !docs/content/
 docs/content/*
diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 000000000..0f48d1a51
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,81 @@
+# 影策 · 编辑器上下文
+
+面向 AI 影视与短剧创作工作台中的"时间线智能编辑器"子域：时间线模型、编辑命令、预览与导出、自动字幕、插件体系的统一语言。术语主要受 Concat（WolfCut）架构启发，插件部分参考 open-vetta「万物皆可插件」理念，适配 Web + Go 技术栈，详见 `docs/adr/`。
+
+## 语言
+
+**时间线 (Timeline)**:
+项目的时序编排视图，由轨道与片段组成；`TimelineProject`（v2）是编辑真相源的数据形状。
+_Avoid_: 时间轴、剪辑线
+
+**轨道 (Track)**:
+同一类型片段的有序序列（video / audio / subtitle / text / image），有 `order` 与 `locked`。
+_Avoid_: 层（Layer 特指画布节点叠放，不用于时间线）
+
+**片段 (Clip)**:
+时间线上对素材的一段引用：`startMs` + `durationMs` 定位在时间线，`sourceStartMs` / `sourceDurationMs` 定位在源素材内。
+_Avoid_: 素材（Media 指源头资产，Clip 是其时间线引用）
+
+**直连媒体 (directMedia)**:
+仅时间线作用域的媒体引用（素材库/项目资产/本地上传直接入轨），存在时预览/导出优先从该字段解析，不回画布查节点。
+_Avoid_: 内联媒体、画布素材
+
+**编辑命令 (EditCommand)**:
+唯一允许修改时间线的可序列化指令 `{ op, payload }`，经单队列顺序应用；UI 不直接改写模型。
+_Avoid_: 操作、mutate、setState（指组件内部状态）
+
+**手势回显 (Echo)**:
+拖拽/裁剪等手势期间在本地预演的位置与效果，手势结束才提交一个编辑命令——撤销的粒度是手势而非每一像素。
+_Avoid_: 预览态、假数据
+
+**预览近似 (Preview Approximation)**:
+交互期间用浏览器原生能力（`<video>` 裁剪缩放、CSS 滤镜、canvas 合成）渲染的近似画面，不是导出像素。
+_Avoid_: 预览帧、真实预览
+
+**渲染真相 (Render Truth)**:
+导出产物的真实合成画面，由单一滤镜图计划驱动；预览近似与它参数同源、允许画质级差。
+_Avoid_: 最终预览、监看画面
+
+**滤镜图 (Filter Graph / Render Plan)**:
+`buildTimelineRenderPlan` 生成的 ffmpeg 参数计划（trim → gap → concat → subtitle → burn），是导出滤镜串的唯一来源；新增效果禁止在 UI 手写第二套滤镜串。
+_Avoid_: 滤镜链、ffmpeg 参数（指手工拼的字符串）
+
+**转写字幕 (Transcription)**:
+后端服务任务：把音频/视频片段经 ASR 转成字幕片段写回字幕轨道；前端只提交任务并展示进度。
+_Avoid_: 自动字幕（指 UI 按钮名，模型层术语为转写）
+
+**预设插件 (Preset Plugin)**:
+随应用分发、默认启用、不可卸载的插件：编辑器全部 UI 与能力（时间线面板、预览、检查器、转写、导出、字幕工具）均为预设插件；与用户插件同 SDK 同清单，仅分发与权限语义不同。
+_Avoid_: 内置功能、硬编码面板（内置 = builtin 源码目录语义，指非插件化的历史形态）
+
+**UI 插槽 (UI Slot)**:
+宿主暴露的注册式挂载点（`registerTimelinePanel` / `registerPreviewRenderer` / `registerExportRenderer` / `registerTranscriptionProvider` / `registerSubtitleTool` / `registerShortcutScope`），内置与第三方插件平等占位；插件不得绕过插槽直接挂载 DOM。
+_Avoid_: 面板数组、硬编码容器
+
+**插件 SDK (Plugin SDK / yingce.plugin/v2)**:
+`definePlugin` + 清单 + 贡献类型 + 权限声明的统一形态；v2 在 v1 基础上新增 UI 插槽、预设分发与权限执行校验。
+_Avoid_: 插件协议（指 v1 旧称，v2 起称 SDK/清单）
+
+**能力提供者 (Capability Provider)**:
+插件以 provider 身份注册的能力（如转写提供者、导出渲染器、预览渲染器），宿主在调用点校验权限后执行；未声明即不可见不可用。
+_Avoid_: 能力函数、功能开关
+
+**语音滤镜 (Voice Filter)**:
+音频效果能力（音量/淡入淡出/均衡/回声/降噪/变速变调）：预览近似走 Web Audio API，导出真相走 ffmpeg 音频滤镜，两者同源同参数模型（ADR-0006）。
+_Avoid_: 声音特效、音频美化
+
+**模板 (Template)**:
+项目快照（章节 + 画布 + 时间线 + 资产引用清单，不含媒体二进制），支持存为模板 / 从模板新建；服务端模板表 + 缩略图（ADR-0006）。
+
+**AI 编辑命令 (AI Edit Command)**:
+LLM 输出的受约束命令序列 JSON `{ commands, reasoning }`，op 来自命令白名单、payload 按 per-op schema 校验（fail-closed，单条非法整批拒绝）；与手势命令同队列、同撤销栈（ADR-0007）。
+_Avoid_: AI 操作、自动剪辑
+
+**时间线摘要 (Timeline Summary)**:
+时间线结构化精简版（轨道/片段/时长/关键属性，不含媒体二进制），作为 AI 对话上下文输入；纯函数生成、可测试（ADR-0007）。
+_Avoid_: 时间线导出、prompt 原文
+
+**AI 助手插件 (editor-ai-assistant)**:
+对话式剪辑预设插件：AI 只读问答（timeline.read）+ 命令执行（timeline.command）+ 聚合转写/字幕高亮/素材入轨入口；复用画布 agent 聊天 UI 交互模式，不共享会话上下文（ADR-0007）。
+_Avoid_: 画布 Agent（指 canvas 会话桥接，与编辑器 AI 面板是两套会话）
+_Avoid_: 预设项目、项目副本
diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go
index 31d534bc3..ff44fde3c 100644
--- a/backend/cmd/server/main.go
+++ b/backend/cmd/server/main.go
@@ -137,6 +137,7 @@ func run(ctx context.Context) error {
 	handler.RegisterSessionRoutes(api, svc)
 	handler.RegisterSkillRoutes(api, svc)
 	handler.RegisterUserDataRoutes(api, svc)
+	handler.RegisterChunkedUploadRoutes(api, svc)
 	handler.RegisterDiagnosticsRoutes(api, svc)
 	handler.RegisterPluginRoutes(api, svc)
 	projectAPI := api.Group("")
@@ -156,6 +157,8 @@ func run(ctx context.Context) error {
 	}
 	httpServer := &http.Server{Handler: r, ReadHeaderTimeout: 10 * time.Second}
 	svc.StartWorker()
+	// 启动后回填存量视频的播放副本转码（幂等，无待处理项即退出）。
+	go svc.BackfillPlaybackTranscodes()
 	status.markStarted()
 	serveErr := make(chan error, 1)
 	go func() { serveErr <- httpServer.Serve(listener) }()
diff --git a/backend/internal/database/migrations.go b/backend/internal/database/migrations.go
index 0c6a93709..4ca74de76 100644
--- a/backend/internal/database/migrations.go
+++ b/backend/internal/database/migrations.go
@@ -10,13 +10,14 @@ import (
 	"gorm.io/gorm"
 )
 
-const CurrentSchemaVersion int64 = 6
+const CurrentSchemaVersion int64 = 7
 
 const baselineSchemaChecksum = "sha256:open-ai-canvas-schema-v1-20260830"
 const schemaMigrationAppliedAtIndexChecksum = "sha256:schema-migrations-applied-at-index-v2-20260830"
 const assetTaxonomyCandidateIdentityChecksum = "sha256:asset-taxonomy-candidate-identity-v3-20260831-r1"
 const resourceUploadKeyChecksum = "sha256:resource-upload-key-v4-20260901"
 const paymentTopupChecksum = "sha256:payment-topup-v5-20260902"
+const resourcePlaybackChecksum = "sha256:resource-playback-v6-20260902"
 const assetLibraryFoldersChecksum = "sha256:asset-library-folders-v6-20260902"
 
 const postgresSchemaMigrationLockID int64 = 73123910420260830
@@ -49,7 +50,8 @@ var schemaMigrations = []migration{
 	{version: 3, name: "asset_taxonomy_candidate_identity", checksum: assetTaxonomyCandidateIdentityChecksum, apply: migrateSchemaV3},
 	{version: 4, name: "resource_upload_key", checksum: resourceUploadKeyChecksum, apply: migrateSchemaV4},
 	{version: 5, name: "payment_topup", checksum: paymentTopupChecksum, apply: migrateSchemaV5},
-	{version: 6, name: "asset_library_folders", checksum: assetLibraryFoldersChecksum, apply: migrateSchemaV6},
+	{version: 6, name: "resource_playback_variant", checksum: resourcePlaybackChecksum, apply: migrateSchemaV6},
+	{version: 7, name: "asset_library_folders", checksum: assetLibraryFoldersChecksum, apply: migrateSchemaV7},
 }
 
 func migrateSchemaV2(tx *gorm.DB) error {
@@ -109,7 +111,6 @@ func migrateSchemaV4(tx *gorm.DB) error {
 	}
 	return nil
 }
-
 func migrateSchemaV5(tx *gorm.DB) error {
 	if err := tx.AutoMigrate(
 		&model.CreditLedgerEntry{},
@@ -126,6 +127,28 @@ func migrateSchemaV5(tx *gorm.DB) error {
 }
 
 func migrateSchemaV6(tx *gorm.DB) error {
+	if !tx.Migrator().HasTable(&model.Resource{}) {
+		return fmt.Errorf("资源表不存在")
+	}
+	if !tx.Migrator().HasColumn(&model.Resource{}, "playback_status") {
+		if err := tx.Migrator().AddColumn(&model.Resource{}, "PlaybackStatus"); err != nil {
+			return fmt.Errorf("增加播放副本状态列：%w", err)
+		}
+	}
+	if !tx.Migrator().HasColumn(&model.Resource{}, "playback_object_key") {
+		if err := tx.Migrator().AddColumn(&model.Resource{}, "PlaybackObjectKey"); err != nil {
+			return fmt.Errorf("增加播放副本对象键列：%w", err)
+		}
+	}
+	if !tx.Migrator().HasColumn(&model.Resource{}, "playback_error") {
+		if err := tx.Migrator().AddColumn(&model.Resource{}, "PlaybackError"); err != nil {
+			return fmt.Errorf("增加播放副本错误列：%w", err)
+		}
+	}
+	return nil
+}
+
+func migrateSchemaV7(tx *gorm.DB) error {
 	if err := tx.AutoMigrate(&model.Asset{}, &model.AssetFolder{}); err != nil {
 		return fmt.Errorf("创建个人素材分类并扩展素材目录字段：%w", err)
 	}
diff --git a/backend/internal/handler/auth.go b/backend/internal/handler/auth.go
index 5dc6c2075..5557b2d79 100644
--- a/backend/internal/handler/auth.go
+++ b/backend/internal/handler/auth.go
@@ -849,7 +849,7 @@ func shortSystemProxyPath(rawPath string) (string, string, bool) {
 // as a channel request when a business route returns 404.
 func isReservedAPIPathPrefix(value string) bool {
 	switch strings.ToLower(strings.TrimSpace(value)) {
-	case "admin", "ai", "announcements", "assets", "auth", "canvas-projects", "channels", "diagnostics", "features", "files", "model-catalog", "models", "oauth", "plugins", "projects", "public", "resources", "sessions", "settings", "skills", "style-profiles", "tasks", "user-data", "voice-profiles", "wallet":
+	case "admin", "ai", "announcements", "assets", "auth", "canvas-projects", "channels", "diagnostics", "features", "files", "model-catalog", "models", "oauth", "plugins", "projects", "public", "resources", "sessions", "settings", "skills", "style-profiles", "tasks", "timeline", "user-data", "voice-profiles", "wallet":
 		return true
 	default:
 		return false
diff --git a/backend/internal/handler/chunk_upload_routes_test.go b/backend/internal/handler/chunk_upload_routes_test.go
new file mode 100644
index 000000000..76abd2a7e
--- /dev/null
+++ b/backend/internal/handler/chunk_upload_routes_test.go
@@ -0,0 +1,32 @@
+package handler
+
+import (
+	"testing"
+
+	"infinite-canvas/backend/internal/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+func TestChunkedUploadRoutesAreRegistered(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	group := router.Group("/api")
+	RegisterChunkedUploadRoutes(group, &service.Service{})
+	wanted := map[string]bool{
+		"POST /api/resources/uploads":                  false,
+		"PUT /api/resources/uploads/:id/chunks/:index": false,
+		"POST /api/resources/uploads/:id/complete":     false,
+	}
+	for _, route := range router.Routes() {
+		key := route.Method + " " + route.Path
+		if _, exists := wanted[key]; exists {
+			wanted[key] = true
+		}
+	}
+	for route, found := range wanted {
+		if !found {
+			t.Errorf("route %s is not registered", route)
+		}
+	}
+}
diff --git a/backend/internal/handler/resource_upload_session.go b/backend/internal/handler/resource_upload_session.go
new file mode 100644
index 000000000..4e824c64f
--- /dev/null
+++ b/backend/internal/handler/resource_upload_session.go
@@ -0,0 +1,299 @@
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"infinite-canvas/backend/internal/service"
+)
+
+// 分片上传会话：把“导入本地媒体”拆成 开始→逐片→合并 三段，单片上限 8MB，
+// 文件整体不再受 multipart 单请求大小限制（对齐 Concat 桌面端“任意大小直接入库”的体验）。
+// 会话状态只存在内存（重启即失效 → 前端整传重试），磁盘暂存在系统临时目录，随会话清理。
+const (
+	chunkUploadChunkSize   = 8 << 20
+	chunkUploadSlackBytes  = 64 << 10 // MaxBytesReader 允许的超片余量
+	chunkUploadTTL         = 90 * time.Minute
+	chunkUploadMaxPerUser  = 32
+	chunkUploadBodyCapJSON = 16 << 10
+)
+
+type chunkedUploadSession struct {
+	ID             string
+	UserID         string
+	FileName       string
+	Kind           string
+	Size           int64
+	Width          int
+	Height         int
+	DurationMs     int64
+	IdempotencyKey string
+	ChunkCount     int
+	Dir            string
+	CreatedAt      time.Time
+}
+
+var chunkUploadSessions = struct {
+	sync.Mutex
+	m map[string]*chunkedUploadSession
+}{m: make(map[string]*chunkedUploadSession)}
+
+func newUploadSessionID() string {
+	raw := make([]byte, 12)
+	if _, err := rand.Read(raw); err != nil {
+		return fmt.Sprintf("%d", time.Now().UnixNano())
+	}
+	return hex.EncodeToString(raw)
+}
+
+func (s *chunkedUploadSession) chunkPath(index int) string {
+	return filepath.Join(s.Dir, fmt.Sprintf("chunk-%d", index))
+}
+
+func (s *chunkedUploadSession) hasAllChunks() bool {
+	for i := 0; i < s.ChunkCount; i++ {
+		info, err := os.Stat(s.chunkPath(i))
+		if err != nil || info.Size() != s.chunkSizeAt(i) {
+			return false
+		}
+	}
+	return true
+}
+
+// chunkSizeAt 返回第 index 片的期望字节数（末片按文件余量，其余固定 chunkSize）。
+func (s *chunkedUploadSession) chunkSizeAt(index int) int64 {
+	if index == s.ChunkCount-1 {
+		rest := s.Size - int64(index)*chunkUploadChunkSize
+		if rest < 0 {
+			return 0
+		}
+		return rest
+	}
+	return chunkUploadChunkSize
+}
+
+func removeExpiredChunkSessions() {
+	now := time.Now()
+	chunkUploadSessions.Lock()
+	defer chunkUploadSessions.Unlock()
+	for id, sess := range chunkUploadSessions.m {
+		if now.Sub(sess.CreatedAt) > chunkUploadTTL {
+			_ = os.RemoveAll(sess.Dir)
+			delete(chunkUploadSessions.m, id)
+		}
+	}
+}
+
+func takeChunkSession(id string) *chunkedUploadSession {
+	removeExpiredChunkSessions()
+	chunkUploadSessions.Lock()
+	defer chunkUploadSessions.Unlock()
+	return chunkUploadSessions.m[id]
+}
+
+func dropChunkSession(id string) {
+	chunkUploadSessions.Lock()
+	defer chunkUploadSessions.Unlock()
+	if sess := chunkUploadSessions.m[id]; sess != nil {
+		_ = os.RemoveAll(sess.Dir)
+		delete(chunkUploadSessions.m, id)
+	}
+}
+
+// RegisterChunkedUploadRoutes 注册本地媒体分片上传三条接口（POST 开始 / PUT 上传片 / POST 合并）。
+func RegisterChunkedUploadRoutes(r *gin.RouterGroup, svc *service.Service) {
+	r.POST("/resources/uploads", func(c *gin.Context) {
+		user, err := currentUser(c, svc)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		policy, available := loadRuntimePolicy(c, svc)
+		if !available || !enforceRateLimit(c, "resources-upload:"+user.ID, policy.Request.ResourceUploadPerMinute, time.Minute) {
+			return
+		}
+		c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, chunkUploadBodyCapJSON)
+		var req struct {
+			FileName       string `json:"fileName"`
+			Kind           string `json:"kind"`
+			Size           int64  `json:"size"`
+			Width          int    `json:"width"`
+			Height         int    `json:"height"`
+			DurationMs     int64  `json:"durationMs"`
+			IdempotencyKey string `json:"idempotencyKey"`
+		}
+		if err := c.ShouldBindJSON(&req); err != nil {
+			fail(c, http.StatusBadRequest, err)
+			return
+		}
+		if req.FileName == "" || len(req.FileName) > 255 {
+			fail(c, http.StatusBadRequest, fmt.Errorf("文件名不能为空且不能超过 255 个字符"))
+			return
+		}
+		if req.Size <= 0 {
+			fail(c, http.StatusBadRequest, fmt.Errorf("文件大小必须大于 0"))
+			return
+		}
+		// 超账号存储总量的文件无论如何都会失败，提前给出明确提示。
+		if policy.Resource.StoredFileGB > 0 && req.Size > int64(policy.Resource.StoredFileGB)<<30 {
+			fail(c, http.StatusBadRequest, fmt.Errorf("文件超过账号存储总量上限 %dGB", policy.Resource.StoredFileGB))
+			return
+		}
+		// 同一用户并发会话数兜底，防内存占用失控。
+		active := 0
+		chunkUploadSessions.Lock()
+		for _, sess := range chunkUploadSessions.m {
+			if sess.UserID == user.ID {
+				active++
+			}
+		}
+		chunkUploadSessions.Unlock()
+		if active >= chunkUploadMaxPerUser {
+			fail(c, http.StatusTooManyRequests, fmt.Errorf("同时进行中的上传过多，请稍后重试"))
+			return
+		}
+		dir, err := os.MkdirTemp("", "canvas-chunk-upload-*")
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		session := &chunkedUploadSession{
+			ID:             newUploadSessionID(),
+			UserID:         user.ID,
+			FileName:       req.FileName,
+			Kind:           req.Kind,
+			Size:           req.Size,
+			Width:          req.Width,
+			Height:         req.Height,
+			DurationMs:     req.DurationMs,
+			IdempotencyKey: req.IdempotencyKey,
+			ChunkCount:     int((req.Size + chunkUploadChunkSize - 1) / chunkUploadChunkSize),
+			Dir:            dir,
+			CreatedAt:      time.Now(),
+		}
+		chunkUploadSessions.Lock()
+		chunkUploadSessions.m[session.ID] = session
+		chunkUploadSessions.Unlock()
+		ok(c, gin.H{"uploadId": session.ID, "chunkSize": chunkUploadChunkSize, "chunkCount": session.ChunkCount})
+	})
+
+	r.PUT("/resources/uploads/:id/chunks/:index", func(c *gin.Context) {
+		user, err := currentUser(c, svc)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		session := takeChunkSession(c.Param("id"))
+		if session == nil || session.UserID != user.ID {
+			fail(c, http.StatusNotFound, fmt.Errorf("上传会话不存在或已过期，请重新导入"))
+			return
+		}
+		index, err := strconv.Atoi(c.Param("index"))
+		if err != nil || index < 0 || index >= session.ChunkCount {
+			fail(c, http.StatusBadRequest, fmt.Errorf("非法的分片序号"))
+			return
+		}
+		expected := session.chunkSizeAt(index)
+		if expected <= 0 {
+			fail(c, http.StatusBadRequest, fmt.Errorf("非法的分片序号"))
+			return
+		}
+		// 单片限长（期望长度 + 少量余量），超长直接中断，避免内存/磁盘被恶意占用。
+		body := http.MaxBytesReader(c.Writer, c.Request.Body, expected+chunkUploadSlackBytes)
+		dst, err := os.OpenFile(session.chunkPath(index), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		written, copyErr := io.CopyN(dst, body, expected)
+		closeErr := dst.Close()
+		var probe [1]byte
+		extra, readErr := body.Read(probe[:])
+		if copyErr != nil || closeErr != nil {
+			_ = os.Remove(session.chunkPath(index))
+			fail(c, http.StatusBadRequest, fmt.Errorf("分片 %d 上传不完整，请重试", index))
+			return
+		}
+		if readErr == nil || extra > 0 {
+			_ = os.Remove(session.chunkPath(index))
+			fail(c, http.StatusBadRequest, fmt.Errorf("分片 %d 超过大小限制", index))
+			return
+		}
+		_ = written
+		ok(c, gin.H{"index": index})
+	})
+
+	r.POST("/resources/uploads/:id/complete", func(c *gin.Context) {
+		user, err := currentUser(c, svc)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		id := c.Param("id")
+		session := takeChunkSession(id)
+		if session == nil || session.UserID != user.ID {
+			fail(c, http.StatusNotFound, fmt.Errorf("上传会话不存在或已过期，请重新导入"))
+			return
+		}
+		if !session.hasAllChunks() {
+			fail(c, http.StatusBadRequest, fmt.Errorf("上传文件不完整，请重新导入"))
+			return
+		}
+		mergedPath := filepath.Join(session.Dir, "merged")
+		merged, err := os.OpenFile(mergedPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		total := int64(0)
+		for i := 0; i < session.ChunkCount; i++ {
+			part, openErr := os.Open(session.chunkPath(i))
+			if openErr != nil {
+				_ = merged.Close()
+				failService(c, openErr)
+				return
+			}
+			n, copyErr := io.Copy(merged, part)
+			_ = part.Close()
+			if copyErr != nil {
+				_ = merged.Close()
+				failService(c, copyErr)
+				return
+			}
+			total += n
+		}
+		if closeErr := merged.Close(); closeErr != nil {
+			failService(c, closeErr)
+			return
+		}
+		if total != session.Size {
+			dropChunkSession(id)
+			fail(c, http.StatusBadRequest, fmt.Errorf("上传文件不完整，请重新导入"))
+			return
+		}
+		fh, err := os.Open(mergedPath)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		defer fh.Close()
+		resource, svcErr := svc.UploadResourceFile(user.ID, session.FileName, session.Size, session.Kind, session.Width, session.Height, session.DurationMs, fh, session.IdempotencyKey)
+		// 无论成败都结束会话：失败时前端会整传重试，不需要保留残片。
+		dropChunkSession(id)
+		if svcErr != nil {
+			failService(c, svcErr)
+			return
+		}
+		ok(c, gin.H{"resource": resource})
+	})
+}
diff --git a/backend/internal/handler/routes.go b/backend/internal/handler/routes.go
index 02eb2ae08..6502609b1 100644
--- a/backend/internal/handler/routes.go
+++ b/backend/internal/handler/routes.go
@@ -52,6 +52,52 @@ func RegisterTaskRoutes(r *gin.RouterGroup, svc *service.Service) {
 		}
 		ok(c, task)
 	})
+	r.POST("/timeline/transcriptions", func(c *gin.Context) {
+		user, err := currentUser(c, svc)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		policy, available := loadRuntimePolicy(c, svc)
+		if !available || !enforceRateLimit(c, "timeline-ts:"+user.ID, policy.Request.TaskCreatePerMinute, time.Minute) {
+			return
+		}
+		c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 1<<20)
+		var req service.TimelineTranscriptionCreateRequest
+		if err := c.ShouldBindJSON(&req); err != nil {
+			fail(c, http.StatusBadRequest, err)
+			return
+		}
+		task, err := svc.CreateTimelineTranscriptionTask(user.ID, req)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		ok(c, task)
+	})
+	r.POST("/timeline/renders", func(c *gin.Context) {
+		user, err := currentUser(c, svc)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		policy, available := loadRuntimePolicy(c, svc)
+		if !available || !enforceRateLimit(c, "timeline-render:"+user.ID, policy.Request.TaskCreatePerMinute, time.Minute) {
+			return
+		}
+		c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 64<<20)
+		var req service.TimelineRenderCreateRequest
+		if err := c.ShouldBindJSON(&req); err != nil {
+			fail(c, http.StatusBadRequest, err)
+			return
+		}
+		task, err := svc.CreateTimelineRenderTask(user.ID, req)
+		if err != nil {
+			failService(c, err)
+			return
+		}
+		ok(c, task)
+	})
 	r.GET("/tasks", func(c *gin.Context) {
 		user, err := currentUser(c, svc)
 		if err != nil {
diff --git a/backend/internal/handler/user_data.go b/backend/internal/handler/user_data.go
index e6ee4df98..bae518c75 100644
--- a/backend/internal/handler/user_data.go
+++ b/backend/internal/handler/user_data.go
@@ -2,6 +2,7 @@ package handler
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -171,6 +172,12 @@ func RegisterUserDataRoutes(r *gin.RouterGroup, svc *service.Service) {
 		c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, (policy.Resource.ResourceUploadMB<<20)+(1<<20))
 		file, err := c.FormFile("file")
 		if err != nil {
+			var maxErr *http.MaxBytesError
+			if errors.As(err, &maxErr) {
+				// 超 MaxBytesReader 上限时 FormFile 返回英文 http 错误，转成与 service 配额校验一致的中文文案。
+				fail(c, http.StatusBadRequest, fmt.Errorf("单个上传文件必须小于 %dMB", policy.Resource.ResourceUploadMB))
+				return
+			}
 			fail(c, http.StatusBadRequest, err)
 			return
 		}
@@ -271,24 +278,56 @@ func RegisterUserDataRoutes(r *gin.RouterGroup, svc *service.Service) {
 		}
 		resource := delivery.Resource
 		etag := resourceResponseETag(resource)
+		// variant=playback：serve 浏览器兼容播放副本（H.265→H.264 转码）。
+		// 副本就绪时用独立 ETag 后缀，避免浏览器拿原件缓存命中 304 而继续黑屏。
+		usePlayback := c.Query("variant") == "playback" && resource.Provider == "local" &&
+			resource.PlaybackStatus == model.PlaybackStatusReady && resource.PlaybackObjectKey != ""
+		serveETag := etag
+		if usePlayback {
+			serveETag = etag + ":pb"
+		}
 		// 私有资源允许浏览器保存响应，但每次复用前必须重新鉴权；304 会在读取 OSS 前返回。
 		c.Header("Cache-Control", "private, no-cache")
-		c.Header("ETag", etag)
+		c.Header("ETag", serveETag)
 		c.Header("Accept-Ranges", "bytes")
 		c.Header("X-Content-Type-Options", "nosniff")
 		if resource.Kind == "file" {
 			c.Header("Content-Disposition", "attachment")
 			c.Header("Content-Security-Policy", "sandbox")
 		}
-		if ifNoneMatch(c.GetHeader("If-None-Match"), etag) {
+		if ifNoneMatch(c.GetHeader("If-None-Match"), serveETag) {
 			c.Status(http.StatusNotModified)
 			return
 		}
 		rangeHeader := c.GetHeader("Range")
-		if ifRange := strings.TrimSpace(c.GetHeader("If-Range")); ifRange != "" && ifRange != etag {
+		if ifRange := strings.TrimSpace(c.GetHeader("If-Range")); ifRange != "" && ifRange != serveETag {
 			rangeHeader = ""
 		}
-		stream, err := svc.OpenResourceRange(user.ID, resource.ID, rangeHeader)
+		var stream *service.ResourceStream
+		if usePlayback {
+			stream, err = svc.OpenResourcePlaybackRange(user.ID, resource.ID)
+			if err == nil {
+				resource = stream.Resource // MimeType 已置 video/mp4
+			} else if errors.Is(err, service.ErrPlaybackNotReady) {
+				// 副本尚未就绪：回退原件，并撤销 :pb 后缀，保证副本就绪后
+				// 浏览器不会拿原件缓存命中 304 而继续黑屏。
+				c.Header("ETag", etag)
+				stream, err = svc.OpenResourceRange(user.ID, resource.ID, rangeHeader)
+				if err != nil {
+					failService(c, err)
+					return
+				}
+			} else {
+				failService(c, err)
+				return
+			}
+		} else {
+			stream, err = svc.OpenResourceRange(user.ID, resource.ID, rangeHeader)
+			if err != nil {
+				failService(c, err)
+				return
+			}
+		}
 		if err != nil {
 			failService(c, err)
 			return
diff --git a/backend/internal/model/models.go b/backend/internal/model/models.go
index bd09437ee..f7360b44b 100644
--- a/backend/internal/model/models.go
+++ b/backend/internal/model/models.go
@@ -98,6 +98,12 @@ const (
 	ResourceStatusFailed  ResourceStatus = "failed"
 	ResourceStatusDeleted ResourceStatus = "deleted"
 
+	// 播放副本转码状态：空串/"none" = 无需转码（H.264 等可直接播放）。
+	PlaybackStatusNone       = "none"
+	PlaybackStatusProcessing = "processing"
+	PlaybackStatusReady      = "ready"
+	PlaybackStatusFailed     = "failed"
+
 	ResourceDeletionStatusPending    ResourceDeletionStatus = "pending"
 	ResourceDeletionStatusProcessing ResourceDeletionStatus = "processing"
 
diff --git a/backend/internal/model/models_project.go b/backend/internal/model/models_project.go
index c55657f52..608347281 100644
--- a/backend/internal/model/models_project.go
+++ b/backend/internal/model/models_project.go
@@ -35,6 +35,11 @@ type Resource struct {
 	Height           int    `json:"height"`
 	DurationMs       int64  `json:"durationMs"`
 	ETag             string `json:"etag" gorm:"size:160"`
+	// 浏览器兼容播放副本（HEVC/H.265 原片在 Chrome 等无法解码，由 ffmpeg 转 H.264）：
+	// PlaybackStatus: none|processing|ready|failed；PlaybackObjectKey 为本地播放目录下的文件名。
+	PlaybackStatus    string `json:"playbackStatus" gorm:"index;size:24"`
+	PlaybackObjectKey string `json:"playbackObjectKey"`
+	PlaybackError     string `json:"playbackError" gorm:"type:text"`
 	// UploadKey 是客户端逻辑上传身份的摘要；NULL 表示不参与幂等约束。
 	UploadKey *string   `json:"-" gorm:"size:64;uniqueIndex:idx_resources_user_upload_key,priority:2"`
 	Error     string    `json:"error"`
diff --git a/backend/internal/model/timeline_task_type.go b/backend/internal/model/timeline_task_type.go
new file mode 100644
index 000000000..a2823f9d4
--- /dev/null
+++ b/backend/internal/model/timeline_task_type.go
@@ -0,0 +1,9 @@
+package model
+
+// 时间线后台任务类型。与通用生成任务共用同一队列与 Claim 循环
+// （ClaimNextTask 不按类型过滤），worker 在 processClaimedTask 顶部
+// 按 Type 分叉到独立执行器，不走计费与模型渠道路由。
+const (
+	TaskTypeTimelineTranscription = "timeline_transcription"
+	TaskTypeTimelineRender        = "timeline_render"
+)
diff --git a/backend/internal/repository/repository.go b/backend/internal/repository/repository.go
index 4eddfc434..dda418e09 100644
--- a/backend/internal/repository/repository.go
+++ b/backend/internal/repository/repository.go
@@ -1061,6 +1061,40 @@ func (r *Repository) Resources(userID string, limit int) ([]model.Resource, erro
 	return resources, err
 }
 
+// PlaybackPendingVideos 返回本地存储、就绪但尚无播放副本判定结果的视频
+// （H.264 需标记 none、H.265 需触发转码）。
+func (r *Repository) PlaybackPendingVideos(limit int) ([]model.Resource, error) {
+	var resources []model.Resource
+	if limit <= 0 || limit > 100 {
+		limit = 20
+	}
+	err := r.db.Where("kind = ? AND status = ? AND provider = ? AND (playback_status = ? OR playback_status IS NULL)",
+		"video", model.ResourceStatusReady, "local", "").Order("created_at asc").Limit(limit).Find(&resources).Error
+	return resources, err
+}
+
+// ClaimPlaybackTranscode 原子地把待判定（空/none）视频置为 processing，返回是否抢占成功。
+// 多实例或多 goroutine 并发转同一资源时仅一个能成功置位，其余返回 false 直接放弃，
+// 避免重复转码同一份文件。
+func (r *Repository) ClaimPlaybackTranscode(id string) (bool, error) {
+	res := r.db.Model(&model.Resource{}).
+		Where("id = ? AND (playback_status = ? OR playback_status IS NULL OR playback_status = ?)",
+			id, "", model.PlaybackStatusNone).
+		Updates(map[string]any{"playback_status": model.PlaybackStatusProcessing, "playback_error": ""})
+	if res.Error != nil {
+		return false, res.Error
+	}
+	return res.RowsAffected > 0, nil
+}
+
+// ResetStuckPlaybackTranscodes 服务重启时把卡在 processing 的转码记录重置回待判定
+// （进程崩溃后转码 goroutine 随进程消亡，状态永远停在 processing）。
+func (r *Repository) ResetStuckPlaybackTranscodes() error {
+	return r.db.Model(&model.Resource{}).
+		Where("playback_status = ?", model.PlaybackStatusProcessing).
+		Updates(map[string]any{"playback_status": "", "playback_error": ""}).Error
+}
+
 func (r *Repository) ResourceCleanupCandidates(incompleteBefore time.Time, readyBefore time.Time, limit int) ([]model.Resource, error) {
 	var resources []model.Resource
 	if limit <= 0 || limit > 500 {
@@ -1073,7 +1107,6 @@ func (r *Repository) ResourceCleanupCandidates(incompleteBefore time.Time, ready
 	).Order("created_at asc, id asc").Limit(limit).Find(&resources).Error
 	return resources, err
 }
-
 func (r *Repository) Assets(userID string) ([]model.Asset, error) {
 	var assets []model.Asset
 	err := r.db.Order("updated_at desc").Find(&assets, "user_id = ?", userID).Error
@@ -1631,9 +1664,16 @@ func (r *Repository) DeleteProjectAssetFolder(projectID string, folderID string)
 }
 
 // LinkProjectAsset 将首版本、素材领域字段、项目引用和修订号原子提交，避免产生半关联资产。
+// 资产首次入库也在此事务内完成（service 层只做内存构造，不预落库），
+// 事务失败时资产一并回滚，不再留下“有资产无链接”的孤儿资产。
 func (r *Repository) LinkProjectAsset(asset *model.Asset, version *model.AssetVersion, link *model.ProjectAssetLink) (bool, error) {
 	createdLink := false
 	err := r.db.Transaction(func(tx *gorm.DB) error {
+		// 资产可能尚未落库（首次导入）或已存在（并发/重试），冲突幂等跳过。
+		assetCreated := tx.Clauses(clause.OnConflict{Columns: []clause.Column{{Name: "id"}}, DoNothing: true}).Create(asset)
+		if assetCreated.Error != nil {
+			return assetCreated.Error
+		}
 		created := tx.Clauses(clause.OnConflict{Columns: []clause.Column{{Name: "project_id"}, {Name: "asset_id"}}, DoNothing: true}).Create(link)
 		if created.Error != nil {
 			return created.Error
diff --git a/backend/internal/service/admin_storage_delete.go b/backend/internal/service/admin_storage_delete.go
index 7c0ff1397..83fe9e354 100644
--- a/backend/internal/service/admin_storage_delete.go
+++ b/backend/internal/service/admin_storage_delete.go
@@ -69,7 +69,18 @@ func (s *Service) DeleteAdminResources(actor *model.User, req AdminResourceDelet
 			return nil, snapshotErr
 		}
 		for resourceID, references := range adminResourceReferences(snapshot, userResources) {
-			blockedByID[resourceID] = AdminResourceDeleteBlocked{ID: resourceID, Reason: "资源仍被业务数据引用", References: references}
+			blocking := make([]AdminResourceReferenceView, 0, len(references))
+			for _, reference := range references {
+				if reference.Kind == "公告草稿" {
+					// 公告草稿及其资源绑定在删除事务内级联清理，不构成阻塞引用。
+					continue
+				}
+				blocking = append(blocking, reference)
+			}
+			if len(blocking) == 0 {
+				continue
+			}
+			blockedByID[resourceID] = AdminResourceDeleteBlocked{ID: resourceID, Reason: "资源仍被业务数据引用", References: blocking}
 		}
 	}
 	announcementReferences, err := s.repo.AnnouncementResourceReferences(resourceIDs)
diff --git a/backend/internal/service/announcement.go b/backend/internal/service/announcement.go
index f8c5630f7..eb74ddbce 100644
--- a/backend/internal/service/announcement.go
+++ b/backend/internal/service/announcement.go
@@ -125,7 +125,7 @@ func (s *Service) UpdateAnnouncement(actor *model.User, id string, req UpdateAnn
 			}
 			return nil, err
 		}
-		if err := s.ensureResourceHasNoBusinessReferences(oldResource); err != nil {
+		if err := s.ensureResourceHasNoBusinessReferences(oldResource, repository.ResourceDirectReference{Kind: "公告", ID: announcement.ID}); err != nil {
 			return nil, err
 		}
 		sharedCount, countErr := s.repo.ResourceStorageReferenceCount(oldResource, []string{oldResource.ID})
@@ -316,7 +316,7 @@ func (s *Service) discardAnnouncementImageDraft(userID string, resourceID string
 		}
 		return err
 	}
-	if err := s.ensureResourceHasNoBusinessReferences(resource); err != nil {
+	if err := s.ensureResourceHasNoBusinessReferences(resource, repository.ResourceDirectReference{Kind: "公告草稿", ID: resource.ID}); err != nil {
 		return err
 	}
 	sharedCount, err := s.repo.ResourceStorageReferenceCount(resource, []string{resource.ID})
@@ -340,7 +340,7 @@ func (s *Service) discardAnnouncementImageDraft(userID string, resourceID string
 	return nil
 }
 
-func (s *Service) ensureResourceHasNoBusinessReferences(resource *model.Resource) error {
+func (s *Service) ensureResourceHasNoBusinessReferences(resource *model.Resource, ignoredDirect ...repository.ResourceDirectReference) error {
 	if resource == nil {
 		return NotFound("资源不存在")
 	}
@@ -348,7 +348,18 @@ func (s *Service) ensureResourceHasNoBusinessReferences(resource *model.Resource
 	if err != nil {
 		return err
 	}
-	if len(snapshot.Direct) > 0 {
+	hasBlocking := false
+DirectLoop:
+	for _, direct := range snapshot.Direct {
+		for _, ignored := range ignoredDirect {
+			if direct.Kind == ignored.Kind && direct.ID == ignored.ID {
+				continue DirectLoop
+			}
+		}
+		hasBlocking = true
+		break
+	}
+	if hasBlocking {
 		return BadAuthRequest("公告配图仍被其他业务数据引用，已停止删除")
 	}
 	resourceIDs := map[string]struct{}{resource.ID: {}}
diff --git a/backend/internal/service/feature_availability.go b/backend/internal/service/feature_availability.go
index a322789c4..c390bedcd 100644
--- a/backend/internal/service/feature_availability.go
+++ b/backend/internal/service/feature_availability.go
@@ -14,23 +14,25 @@ import (
 const featureAvailabilitySettingKey = "feature_availability"
 
 const (
-	FeatureShortDrama     = "shortDrama"
-	FeatureTaskCenter     = "taskCenter"
-	FeatureCredits        = "credits"
-	FeatureCustomChannels = "customChannels"
-	FeatureFrontendModels = "frontendModels"
-	FeaturePluginCenter   = "pluginCenter"
-	FeatureSystemPlugins  = "systemPluginsVisibleToUsers"
+	FeatureShortDrama            = "shortDrama"
+	FeatureTaskCenter            = "taskCenter"
+	FeatureCredits               = "credits"
+	FeatureCustomChannels        = "customChannels"
+	FeatureFrontendModels        = "frontendModels"
+	FeaturePluginCenter          = "pluginCenter"
+	FeatureSystemPlugins         = "systemPluginsVisibleToUsers"
+	FeatureTimelineTranscription = "timelineTranscription"
 )
 
 type FeatureAvailability struct {
-	ShortDramaEnabled           bool `json:"shortDramaEnabled"`
-	TaskCenterEnabled           bool `json:"taskCenterEnabled"`
-	CreditsEnabled              bool `json:"creditsEnabled"`
-	CustomChannelsEnabled       bool `json:"customChannelsEnabled"`
-	FrontendModelsEnabled       bool `json:"frontendModelsEnabled"`
-	PluginCenterEnabled         bool `json:"pluginCenterEnabled"`
-	SystemPluginsVisibleToUsers bool `json:"systemPluginsVisibleToUsers"`
+	ShortDramaEnabled            bool `json:"shortDramaEnabled"`
+	TaskCenterEnabled            bool `json:"taskCenterEnabled"`
+	CreditsEnabled               bool `json:"creditsEnabled"`
+	CustomChannelsEnabled        bool `json:"customChannelsEnabled"`
+	FrontendModelsEnabled        bool `json:"frontendModelsEnabled"`
+	PluginCenterEnabled          bool `json:"pluginCenterEnabled"`
+	SystemPluginsVisibleToUsers  bool `json:"systemPluginsVisibleToUsers"`
+	TimelineTranscriptionEnabled bool `json:"timelineTranscriptionEnabled"`
 }
 
 type PublicFeatureAvailability struct {
@@ -44,13 +46,14 @@ type PublicFeatureAvailability struct {
 func defaultFeatureAvailability() FeatureAvailability {
 	// 缺少配置代表尚未由运维接管；前台模型需要明确配置后才开放。
 	return FeatureAvailability{
-		ShortDramaEnabled:           true,
-		TaskCenterEnabled:           true,
-		CreditsEnabled:              true,
-		CustomChannelsEnabled:       true,
-		FrontendModelsEnabled:       false,
-		PluginCenterEnabled:         true,
-		SystemPluginsVisibleToUsers: true,
+		ShortDramaEnabled:            true,
+		TaskCenterEnabled:            true,
+		CreditsEnabled:               true,
+		CustomChannelsEnabled:        true,
+		FrontendModelsEnabled:        false,
+		PluginCenterEnabled:          true,
+		SystemPluginsVisibleToUsers:  true,
+		TimelineTranscriptionEnabled: true,
 	}
 }
 
@@ -114,6 +117,8 @@ func (s *Service) FeatureEnabled(feature string) (bool, error) {
 		return value.PluginCenterEnabled, nil
 	case FeatureSystemPlugins:
 		return value.SystemPluginsVisibleToUsers, nil
+	case FeatureTimelineTranscription:
+		return value.TimelineTranscriptionEnabled, nil
 	default:
 		return false, errors.New("未知功能开放配置")
 	}
@@ -142,6 +147,8 @@ func (s *Service) RequireFeature(feature string) error {
 		return Forbidden("插件中心暂未开放")
 	case FeatureSystemPlugins:
 		return Forbidden("系统插件暂未向普通用户展示")
+	case FeatureTimelineTranscription:
+		return Forbidden("字幕转写暂未开放")
 	default:
 		return Forbidden("该功能暂未开放")
 	}
diff --git a/backend/internal/service/project_asset.go b/backend/internal/service/project_asset.go
index 0ee9fd1f1..267239fdc 100644
--- a/backend/internal/service/project_asset.go
+++ b/backend/internal/service/project_asset.go
@@ -2,9 +2,12 @@ package service
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
 	"strings"
 	"time"
 
+	"gorm.io/gorm"
 	"infinite-canvas/backend/internal/model"
 )
 
@@ -12,6 +15,8 @@ type LinkProjectAssetRequest struct {
 	AssetID  string  `json:"assetId"`
 	Category string  `json:"category"`
 	FolderID *string `json:"folderId"`
+	// Title 媒体导入场景下由前端携带原始文件名；已有资产时忽略。
+	Title string `json:"title"`
 }
 
 type UpdateProjectAssetRequest struct {
@@ -37,8 +42,10 @@ type ProjectAssetSummary struct {
 	FolderID         string                   `json:"folderId,omitempty"`
 	Position         int                      `json:"position"`
 	StorageKey       string                   `json:"storageKey,omitempty"`
+	DurationMs       int64                    `json:"durationMs,omitempty"`
 	PreviewText      string                   `json:"previewText,omitempty"`
 	UpdatedAt        time.Time                `json:"updatedAt"`
+	Source           string                   `json:"source,omitempty"`
 	Character        *CharacterCardSummary    `json:"character,omitempty"`
 }
 
@@ -99,9 +106,17 @@ func (s *Service) LinkProjectAsset(userID string, projectID string, req LinkProj
 	}
 	assetID := strings.TrimSpace(req.AssetID)
 	asset, err := s.repo.AssetForUser(userID, assetID)
-	if err != nil {
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return ProjectAssetSummary{}, err
 	}
+	if asset == nil {
+		// 媒体导入只落 resources 表；首次链接时按资源元数据合成资产记录，
+		// 避免“资源存在但无资产记录”导致导入永远失败。
+		asset, err = s.assetFromUploadedResource(userID, assetID, req.Title)
+		if err != nil {
+			return ProjectAssetSummary{}, err
+		}
+	}
 	category := model.AssetCategory(strings.TrimSpace(req.Category))
 	if category == "" {
 		category = asset.Category
@@ -156,6 +171,62 @@ func (s *Service) LinkProjectAsset(userID string, projectID string, req LinkProj
 	return s.projectAssetSummary(userID, projectID, asset)
 }
 
+// assetFromUploadedResource 把媒体导入上传的 Resource 合成为资产记录（内存构造，不落库）。
+// 资产创建与项目链接由 LinkProjectAsset 事务原子提交，避免失败留下孤立资产。
+func (s *Service) assetFromUploadedResource(userID string, resourceID string, title string) (*model.Asset, error) {
+	resource, err := s.repo.ResourceForUser(userID, resourceID)
+	if err != nil {
+		return nil, err
+	}
+	if resource.Kind == "" {
+		return nil, BadAuthRequest("资源缺少媒体类型，无法导入")
+	}
+	payload, err := json.Marshal(map[string]any{
+		"data": map[string]any{
+			"storageKey": "resource:" + resource.ID,
+			"mimeType":   resource.MimeType,
+			"kind":       resource.Kind,
+			"size":       resource.Size,
+			"width":      resource.Width,
+			"height":     resource.Height,
+			"durationMs": resource.DurationMs,
+			"status":     resource.Status,
+			"mediaType":  resource.Kind,
+			"source":     "uploaded",
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	title = strings.TrimSpace(title)
+	if title == "" {
+		title = mediaTitleFallback(resource)
+	}
+	asset := &model.Asset{
+		ID:          resource.ID,
+		UserID:      userID,
+		Kind:        resource.Kind,
+		Category:    model.NormalizeAssetCategory("", resource.Kind),
+		Status:      model.AssetVersionStatusConfirmed,
+		Title:       title,
+		PayloadJSON: string(payload),
+		CreatedAt:   resource.CreatedAt,
+		UpdatedAt:   resource.UpdatedAt,
+	}
+	// 不在此预落库：资产创建交给 LinkProjectAsset 的事务统一提交，
+	// 事务失败时与链接一起回滚，避免留下“有资产无链接”的孤儿记录。
+	return asset, nil
+}
+
+// mediaTitleFallback 资源无文件名时的展示标题：未命名 + 媒体类型 + 分辨率。
+func mediaTitleFallback(resource *model.Resource) string {
+	base := "未命名" + resource.Kind
+	if resource.Width > 0 && resource.Height > 0 {
+		base += fmt.Sprintf(" %dx%d", resource.Width, resource.Height)
+	}
+	return base
+}
+
 func (s *Service) UnlinkProjectAsset(userID string, projectID string, assetID string) error {
 	if _, err := s.repo.ProjectForUser(userID, projectID); err != nil {
 		return err
@@ -482,8 +553,8 @@ func (s *Service) projectAssetSummary(userID string, projectID string, asset *mo
 	if err != nil {
 		return ProjectAssetSummary{}, err
 	}
-	storageKey, previewText := projectAssetPreview(asset.PayloadJSON)
-	summary := ProjectAssetSummary{ID: asset.ID, Title: asset.Title, MediaType: asset.Kind, Category: asset.Category, Status: asset.Status, PrimaryVersionID: asset.PrimaryVersionID, VersionCount: len(versions), Usages: usages, FolderID: link.FolderID, Position: link.Position, StorageKey: storageKey, PreviewText: previewText, UpdatedAt: asset.UpdatedAt}
+	storageKey, previewText, source, durationMs := projectAssetPreview(asset.PayloadJSON)
+	summary := ProjectAssetSummary{ID: asset.ID, Title: asset.Title, MediaType: asset.Kind, Category: asset.Category, Status: asset.Status, PrimaryVersionID: asset.PrimaryVersionID, VersionCount: len(versions), Usages: usages, FolderID: link.FolderID, Position: link.Position, StorageKey: storageKey, PreviewText: previewText, DurationMs: durationMs, UpdatedAt: asset.UpdatedAt, Source: source}
 	if asset.Category == model.AssetCategoryCharacter && asset.PrimaryVersionID != "" {
 		card, cardErr := s.characterCard(userID, asset)
 		if cardErr != nil {
@@ -494,19 +565,22 @@ func (s *Service) projectAssetSummary(userID string, projectID string, asset *mo
 	return summary, nil
 }
 
-func projectAssetPreview(payloadJSON string) (string, string) {
+func projectAssetPreview(payloadJSON string) (string, string, string, int64) {
 	var payload struct {
 		Data struct {
 			StorageKey string `json:"storageKey"`
 			Content    string `json:"content"`
+			Source     string `json:"source"`
+			DurationMs int64  `json:"durationMs"`
 		} `json:"data"`
 	}
 	if json.Unmarshal([]byte(payloadJSON), &payload) != nil {
-		return "", ""
+		return "", "", "", 0
 	}
 	previewRunes := []rune(strings.TrimSpace(payload.Data.Content))
 	if len(previewRunes) > 240 {
 		previewRunes = append(previewRunes[:240], '…')
 	}
-	return strings.TrimSpace(payload.Data.StorageKey), string(previewRunes)
+	return strings.TrimSpace(payload.Data.StorageKey), string(previewRunes), strings.TrimSpace(payload.Data.Source), payload.Data.DurationMs
+
 }
diff --git a/backend/internal/service/project_asset_link_test.go b/backend/internal/service/project_asset_link_test.go
new file mode 100644
index 000000000..736f03f10
--- /dev/null
+++ b/backend/internal/service/project_asset_link_test.go
@@ -0,0 +1,95 @@
+package service
+
+import (
+	"testing"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+func newProjectAssetLinkTestService(t *testing.T) (*Service, *gorm.DB) {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open("file:"+newID()+"?mode=memory&cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(
+		&model.Project{},
+		&model.ProjectAssetLink{},
+		&model.ProjectAssetFolder{},
+		&model.Asset{},
+		&model.AssetVersion{},
+		&model.AssetRepresentation{},
+		&model.Resource{},
+		&model.Shot{},
+		&model.ShotAssetReference{},
+	); err != nil {
+		t.Fatal(err)
+	}
+	return &Service{repo: repository.New(db)}, db
+}
+
+// TestLinkProjectAssetCreatesAssetFromUploadedResource 覆盖媒体导入场景：
+// 上传只落 resources 表，首次链接时服务端应按资源元数据合成资产记录，
+// 否则“资源存在但无资产记录”会让导入永远失败。
+func TestLinkProjectAssetCreatesAssetFromUploadedResource(t *testing.T) {
+	service, db := newProjectAssetLinkTestService(t)
+	project := model.Project{ID: "project-1", UserID: "user-1", Name: "短剧", Status: model.ProjectStatusActive}
+	resource := model.Resource{
+		ID:       "resource-1",
+		UserID:   "user-1",
+		Kind:     "video",
+		Status:   model.ResourceStatusReady,
+		MimeType: "video/mp4",
+		Size:     1024,
+		Width:    1920,
+		Height:   1080,
+	}
+	for _, item := range []any{&project, &resource} {
+		if err := db.Create(item).Error; err != nil {
+			t.Fatalf("seed %T: %v", item, err)
+		}
+	}
+
+	summary, err := service.LinkProjectAsset("user-1", "project-1", LinkProjectAssetRequest{
+		AssetID:  "resource-1",
+		Category: "",
+		Title:    "开场.mp4",
+	})
+	if err != nil {
+		t.Fatalf("LinkProjectAsset: %v", err)
+	}
+	if summary.ID != "resource-1" {
+		t.Fatalf("summary.ID = %q, want resource-1", summary.ID)
+	}
+
+	var asset model.Asset
+	if err := db.First(&asset, "id = ?", "resource-1").Error; err != nil {
+		t.Fatalf("asset not created: %v", err)
+	}
+	if asset.Title != "开场.mp4" {
+		t.Errorf("asset.Title = %q, want 开场.mp4", asset.Title)
+	}
+	if asset.Category != model.AssetCategoryMaterial {
+		t.Errorf("asset.Category = %q, want material", asset.Category)
+	}
+}
+
+// TestLinkProjectAssetMissingResourceKeepsFailingClosed 资源与资产都不存在时仍应报错，
+// 不允许凭空链接。
+func TestLinkProjectAssetMissingResourceKeepsFailingClosed(t *testing.T) {
+	service, db := newProjectAssetLinkTestService(t)
+	project := model.Project{ID: "project-2", UserID: "user-2", Name: "短剧", Status: model.ProjectStatusActive}
+	if err := db.Create(&project).Error; err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := service.LinkProjectAsset("user-2", "project-2", LinkProjectAssetRequest{
+		AssetID: "no-such-resource",
+	}); err == nil {
+		t.Fatal("LinkProjectAsset succeeded for missing resource, want error")
+	}
+}
diff --git a/backend/internal/service/project_settings_test.go b/backend/internal/service/project_settings_test.go
index d0d90702b..af35f8bf9 100644
--- a/backend/internal/service/project_settings_test.go
+++ b/backend/internal/service/project_settings_test.go
@@ -21,6 +21,8 @@ func newProjectSettingsTestService(t *testing.T) (*Service, *gorm.DB) {
 		&model.Project{}, &model.ProjectUnit{}, &model.Resource{}, &model.Asset{}, &model.AssetVersion{}, &model.AssetRepresentation{},
 		&model.CanvasProject{}, &model.StyleProfile{}, &model.ProjectAssetCandidate{}, &model.WorkflowInstance{}, &model.WorkflowStepInstance{},
 		&model.Shot{}, &model.ShotArtifact{}, &model.VoiceProfile{},
+		&model.Task{}, &model.Session{}, &model.Message{}, &model.TaskLog{}, &model.Result{},
+		&model.Announcement{}, &model.AnnouncementImageDraft{},
 	); err != nil {
 		t.Fatal(err)
 	}
diff --git a/backend/internal/service/resource.go b/backend/internal/service/resource.go
index efabc68ea..4678da70f 100644
--- a/backend/internal/service/resource.go
+++ b/backend/internal/service/resource.go
@@ -16,6 +16,7 @@ import (
 	_ "image/jpeg"
 	_ "image/png"
 	"io"
+	"log"
 	"mime"
 	"mime/multipart"
 	"net/http"
@@ -308,7 +309,43 @@ func (s *Service) UploadResource(userID string, header *multipart.FileHeader, ki
 	return resource, err
 }
 
-func detectUploadedMimeType(file multipart.File, fileName string, declared string) string {
+// UploadResourceFile 接收已完整落盘的本地文件（分片上传合并后调用），语义与 UploadResource 一致；
+// 唯一差异是豁免“单文件大小上限”——分片会话已在 handler 按片校验，此处只受日上传与账号存储总量约束。
+func (s *Service) UploadResourceFile(userID string, fileName string, size int64, kind string, width int, height int, durationMs int64, file io.ReadSeeker, uploadIdentity ...string) (*model.Resource, error) {
+	if file == nil || size <= 0 {
+		return nil, BadAuthRequest("请选择要上传的文件")
+	}
+	uploadKey := normalizedResourceUploadKey(uploadIdentity)
+	existing, err := s.resourceForUploadKey(userID, uploadKey)
+	if err != nil {
+		return nil, err
+	}
+	if existing != nil && existing.Status == model.ResourceStatusReady {
+		return existing, nil
+	}
+	if existing != nil && existing.Status == model.ResourceStatusPending {
+		return nil, resourceUploadInProgress()
+	}
+	mimeType := detectUploadedMimeType(file, fileName, "")
+	if existing != nil {
+		return s.retryStoredResource(userID, existing, kind, mimeType, size, file)
+	}
+	day, err := s.reserveChunkedUploadQuota(userID, size)
+	if err != nil {
+		return nil, err
+	}
+	resource, stored, err := s.storeResource(userID, kind, fileName, mimeType, size, width, height, durationMs, file, uploadKey)
+	if err != nil {
+		s.releaseUserUploadQuota(userID, day, size)
+	} else if stored {
+		s.commitUserUploadQuota(userID, size)
+	} else {
+		s.releaseUserUploadQuota(userID, day, size)
+	}
+	return resource, err
+}
+
+func detectUploadedMimeType(file io.ReadSeeker, fileName string, declared string) string {
 	declared = strings.TrimSpace(strings.Split(declared, ";")[0])
 	if declared != "" && declared != "application/octet-stream" {
 		return declared
@@ -492,12 +529,7 @@ func (s *Service) storeResource(userID string, kind string, fileName string, mim
 		return nil, false, err
 	}
 	var etag string
-	if provider == "local" {
-		filePath := filepath.Join(s.dataDir, "resources", filepath.FromSlash(objectKey))
-		err = writeLocalResourceObject(filePath, body)
-	} else {
-		etag, err = putOSSObject(setting, objectKey, mimeType, size, body)
-	}
+	etag, err = s.storeResourceObject(&resource, fileName, body)
 	resource.UpdatedAt = time.Now()
 	if err != nil {
 		resource.Status = model.ResourceStatusFailed
@@ -527,6 +559,7 @@ func (s *Service) storeResource(userID string, kind string, fileName string, mim
 		return nil, true, errors.Join(err, fmt.Errorf("清理已上传资源对象失败：%w", cleanupErr))
 	}
 	s.recordActivity(userID, "resource", 1)
+	s.maybeStartPlaybackTranscode(&resource)
 	return &resource, true, nil
 }
 
@@ -546,6 +579,48 @@ func writeLocalResourceObject(filePath string, body io.Reader) error {
 	return closeErr
 }
 
+// storeResourceObject 写入资源物理对象。对象存储不可用（配置错误、密钥失效、网络
+// 故障、设置被删）时自动降级为本地存储并同步改写资源记录，保证上传写路径不因外部
+// 存储故障整体失败。对象存储失败后 body 会被重新读取，须支持 Seek。
+func (s *Service) storeResourceObject(resource *model.Resource, fileName string, body io.Reader) (string, error) {
+	if resource == nil {
+		return "", errors.New("资源不存在")
+	}
+	if resource.Provider == "local" {
+		return "", writeLocalResourceObject(filepath.Join(s.dataDir, "resources", filepath.FromSlash(resource.ObjectKey)), body)
+	}
+	setting, settingErr := s.ossSettingForResource(resource.UserID, resource)
+	var etag string
+	var putErr error
+	if settingErr == nil {
+		etag, putErr = putOSSObject(setting, resource.ObjectKey, resource.MimeType, resource.Size, body)
+	}
+	if putErr == nil && settingErr == nil {
+		return etag, nil
+	}
+	fallbackErr := putErr
+	if fallbackErr == nil {
+		fallbackErr = settingErr
+	}
+	if seeker, ok := body.(io.Seeker); ok {
+		if _, seekErr := seeker.Seek(0, io.SeekStart); seekErr != nil {
+			return "", errors.Join(fallbackErr, fmt.Errorf("降级本地存储时重置读取位置失败：%w", seekErr))
+		}
+	}
+	localKey := localObjectKey(resource.UserID, resource.Kind, fileName, resource.MimeType, time.Now())
+	resource.Provider = "local"
+	resource.ObjectKey = localKey
+	resource.Endpoint = ""
+	resource.Bucket = ""
+	resource.StorageSettingID = ""
+	resource.ETag = ""
+	if localErr := writeLocalResourceObject(filepath.Join(s.dataDir, "resources", filepath.FromSlash(localKey)), body); localErr != nil {
+		return "", errors.Join(fallbackErr, fmt.Errorf("降级本地存储失败：%w", localErr))
+	}
+	log.Printf("object storage upload degraded to local storage: resource=%s error=%v", resource.ID, fallbackErr)
+	return "", nil
+}
+
 func (s *Service) retryStoredResource(userID string, resource *model.Resource, kind string, mimeType string, size int64, body io.Reader) (*model.Resource, error) {
 	if resource == nil {
 		return nil, errors.New("资源不存在")
@@ -585,15 +660,7 @@ func (s *Service) retryStoredResource(userID string, resource *model.Resource, k
 		return nil, err
 	}
 	var etag string
-	if resource.Provider == "local" {
-		err = writeLocalResourceObject(filepath.Join(s.dataDir, "resources", filepath.FromSlash(resource.ObjectKey)), body)
-	} else {
-		var setting ossSettingValue
-		setting, err = s.ossSettingForResource(userID, resource)
-		if err == nil {
-			etag, err = putOSSObject(setting, resource.ObjectKey, resource.MimeType, resource.Size, body)
-		}
-	}
+	etag, err = s.storeResourceObject(resource, "", body)
 	resource.UpdatedAt = time.Now()
 	if err != nil {
 		s.releaseRetryUploadQuota(userID, day, size)
@@ -1489,7 +1556,17 @@ func newOSSRequest(method string, setting ossSettingValue, objectKey string, con
 		return nil, err
 	}
 	baseURL.Path = strings.TrimRight(baseURL.Path, "/") + "/" + escapeObjectKey(objectKey)
-	req, err := http.NewRequest(method, baseURL.String(), body)
+	// 请求体必须用 no-op close 包装：服务端提前返回（如 OSS 签名 403）时
+	// http.Transport 会关闭未发完的 Request.Body，若直接传入 *os.File 等
+	// 调用方持有的文件，后续“降级本地存储”的 Seek 重读将因 file already
+	// closed 失败。NopCloser 让 Transport 的关闭成为空操作，底层文件保持可用。
+	// GET/HEAD/DELETE 等无请求体的调用传入 nil body；NopCloser(nil) 会产生非 nil 的
+	// Body 包装 nil reader，Go 1.26 发送前 body 探测会直接 nil 解引用崩溃。
+	var reqBody io.Reader
+	if body != nil {
+		reqBody = io.NopCloser(body)
+	}
+	req, err := http.NewRequest(method, baseURL.String(), reqBody)
 	if err != nil {
 		return nil, err
 	}
diff --git a/backend/internal/service/resource_oss_fallback_test.go b/backend/internal/service/resource_oss_fallback_test.go
new file mode 100644
index 000000000..dae0364f8
--- /dev/null
+++ b/backend/internal/service/resource_oss_fallback_test.go
@@ -0,0 +1,107 @@
+package service
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+func newResourceFallbackTestService(t *testing.T) (*Service, *gorm.DB) {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open("file:"+newID()+"?mode=memory&cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(
+		&model.Resource{},
+		&model.UserOSSSetting{},
+		&model.SystemSetting{},
+		&model.StorageLocation{},
+		&model.UserDailyActivity{},
+	); err != nil {
+		t.Fatal(err)
+	}
+	return &Service{repo: repository.New(db), dataDir: t.TempDir()}, db
+}
+
+// TestStoreResourceDegradesToLocalWhenOSSUnavailable 覆盖对象存储不可用时的降级：
+// 配置了 OSS（enabled=1、endpoint 不可达）时上传应回退本地存储成功，
+// 而不是把上传标记为失败——本地媒体导入不应因外部存储故障整体失败。
+func TestStoreResourceDegradesToLocalWhenOSSUnavailable(t *testing.T) {
+	service, db := newResourceFallbackTestService(t)
+	seedOSSEnabled(t, db, "user-1", "http://127.0.0.1:1")
+
+	resource, created, err := service.storeResource(
+		"user-1", "video", "intro.mp4", "video/mp4", 1024,
+		1920, 1080, 0, bytes.NewReader([]byte("fake-mp4-bytes")), nil,
+	)
+	if err != nil {
+		t.Fatalf("storeResource: %v", err)
+	}
+	if !created {
+		t.Fatal("storeResource returned created=false, want true")
+	}
+	if resource.Status != model.ResourceStatusReady {
+		t.Fatalf("resource.Status = %q, want %q", resource.Status, model.ResourceStatusReady)
+	}
+	if resource.Provider != "local" {
+		t.Fatalf("resource.Provider = %q, want local (degraded from OSS)", resource.Provider)
+	}
+	if resource.Endpoint != "" || resource.Bucket != "" || resource.StorageSettingID != "" {
+		t.Fatalf("resource storage binding not cleared after degrade: endpoint=%q bucket=%q setting=%q",
+			resource.Endpoint, resource.Bucket, resource.StorageSettingID)
+	}
+	payload, err := os.ReadFile(filepath.Join(service.dataDir, "resources", filepath.FromSlash(resource.ObjectKey)))
+	if err != nil {
+		t.Fatalf("local object not written: %v", err)
+	}
+	if string(payload) != "fake-mp4-bytes" {
+		t.Fatalf("local object content = %q, want fake-mp4-bytes", payload)
+	}
+}
+
+// TestStoreResourceLocalPathUnaffectedByOSS 未启用 OSS 时上传仍走本地存储，不受其他用户 OSS 设置影响。
+func TestStoreResourceLocalPathUnaffectedByOSS(t *testing.T) {
+	service, db := newResourceFallbackTestService(t)
+	seedOSSEnabled(t, db, "user-other", "http://127.0.0.1:1")
+
+	resource, created, err := service.storeResource(
+		"user-2", "video", "local.mp4", "video/mp4", 512,
+		1280, 720, 0, bytes.NewReader([]byte("local-bytes")), nil,
+	)
+	if err != nil {
+		t.Fatalf("storeResource: %v", err)
+	}
+	if !created {
+		t.Fatal("storeResource returned created=false, want true")
+	}
+	if resource.Provider != "local" {
+		t.Fatalf("resource.Provider = %q, want local", resource.Provider)
+	}
+	payload, err := os.ReadFile(filepath.Join(service.dataDir, "resources", filepath.FromSlash(resource.ObjectKey)))
+	if err != nil {
+		t.Fatalf("local object not written: %v", err)
+	}
+	if string(payload) != "local-bytes" {
+		t.Fatalf("local object content = %q, want local-bytes", payload)
+	}
+}
+
+func seedOSSEnabled(t *testing.T, db *gorm.DB, userID string, endpoint string) {
+	t.Helper()
+	setting := model.UserOSSSetting{
+		UserID:    userID,
+		Enabled:   true,
+		ValueJSON: `{"provider":"aliyun","endpoint":"` + endpoint + `","bucket":"test-bucket","accessKeyId":"ak-test","accessKeySecret":"sk-plaintext","region":"cn-shenzhen"}`,
+	}
+	if err := db.Create(&setting).Error; err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/backend/internal/service/resource_test.go b/backend/internal/service/resource_test.go
index 668fc542b..ea1c9c02c 100644
--- a/backend/internal/service/resource_test.go
+++ b/backend/internal/service/resource_test.go
@@ -9,6 +9,8 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+
+	"os"
 	"strconv"
 	"strings"
 	"testing"
@@ -95,6 +97,47 @@ func TestAliyunOSSUploadRequestStillUsesEndpointWhenCDNConfigured(t *testing.T)
 	}
 }
 
+func TestNewOSSRequestBodyCloseDoesNotCloseCallerFile(t *testing.T) {
+	// 服务端提前返回 403（不读 body）时，http.Transport 会关闭 Request.Body。
+	// newOSSRequest 必须用 no-op close 包装请求体，否则调用方持有的 *os.File
+	// 会被关掉，OSS 失败后的“降级本地存储”Seek 重读将报 file already closed。
+	f, err := os.CreateTemp(t.TempDir(), "merged")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	if _, err := f.WriteString("payload-bytes"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.Seek(0, io.SeekStart); err != nil {
+		t.Fatal(err)
+	}
+	req, err := newOSSRequest(http.MethodPut, ossSettingValue{
+		Provider: aliyunOSSProvider, Endpoint: "https://oss-cn-test.aliyuncs.com",
+		Bucket: "private-bucket", AccessKeyID: "access-id", AccessKeySecret: "secret-value",
+	}, "users/u-1/video/clip.mp4", "video/mp4", f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if req.Body == nil {
+		t.Fatal("newOSSRequest() body is nil")
+	}
+	// 模拟 Transport 在服务端提前响应后关闭请求体：
+	if err := req.Body.Close(); err != nil {
+		t.Fatalf("close request body: %v", err)
+	}
+	if _, err := f.Seek(0, io.SeekStart); err != nil {
+		t.Fatalf("caller file was closed by transport: %v", err)
+	}
+	got, err := io.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "payload-bytes" {
+		t.Fatalf("payload after body close = %q", got)
+	}
+}
+
 func TestSignedOSSObjectURLUsesTencentCOSCDNBaseURLWithoutCOSSignature(t *testing.T) {
 	value, err := signedOSSObjectURL(ossSettingValue{
 		Provider: tencentCOSProvider, Region: "ap-guangzhou", Bucket: "private-bucket-1250000000",
@@ -962,7 +1005,7 @@ func TestPersistGeneratedMediaAppliesStoredFileQuota(t *testing.T) {
 	_, err := svc.persistGeneratedMediaResult("user-1", map[string]interface{}{
 		"image": map[string]interface{}{"dataUrl": "data:image/png;base64,YQ=="},
 	})
-	if err == nil || !strings.Contains(err.Error(), "2GB 上限") {
+	if err == nil || !strings.Contains(err.Error(), "20GB 上限") {
 		t.Fatalf("persistGeneratedMediaResult() error = %v", err)
 	}
 }
diff --git a/backend/internal/service/runtime_policy.go b/backend/internal/service/runtime_policy.go
index 40d312da6..66df7d4e9 100644
--- a/backend/internal/service/runtime_policy.go
+++ b/backend/internal/service/runtime_policy.go
@@ -103,8 +103,8 @@ func defaultRuntimePolicy() RuntimePolicySetting {
 			ResourceUploadMB:        50,
 			SessionUploadMB:         32,
 			GeneratedFileMB:         64,
-			DailyUploadMB:           200,
-			StoredFileGB:            2,
+			DailyUploadMB:           2048,
+			StoredFileGB:            20,
 			StructuredDataMB:        256,
 			TaskDataGB:              1,
 			AssetCount:              2_000,
diff --git a/backend/internal/service/task_render.go b/backend/internal/service/task_render.go
new file mode 100644
index 000000000..9c497abb9
--- /dev/null
+++ b/backend/internal/service/task_render.go
@@ -0,0 +1,200 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"infinite-canvas/backend/internal/model"
+)
+
+const renderFfmpegEnv = "CANVAS_FFMPEG_PATH"
+
+// processTimelineRender 执行时间线渲染：按快照把引用的媒体落盘 →
+// ffprobe 探测音轨 → ffmpeg concat 合成 → 产物写入资源存储。
+// 渲染是本地重编码，不经模型路由与计费；失败一律落明确终态。
+func (w *taskWorkerCoordinator) processTimelineRender(task *model.Task, ctx context.Context) error {
+	s := w.service
+	ffmpegBin, err := renderFfmpegBinary()
+	if err != nil {
+		return w.failTimelineTask(task, "渲染失败", err.Error())
+	}
+	var input timelineRenderInput
+	if err := json.Unmarshal([]byte(task.InputJSON), &input); err != nil {
+		return w.failTimelineTask(task, "渲染失败", "任务缺少有效的时间线快照")
+	}
+	plan := buildRenderPlan(input.Timeline)
+	if !plan.HasMedia {
+		return w.failTimelineTask(task, "渲染失败", "时间线没有可渲染的媒体片段")
+	}
+
+	if err := w.progress(task, "准备媒体…", 10); err != nil {
+		return err
+	}
+	workDir, cleanup, err := materializeRenderSources(ctx, s, task.UserID, &plan)
+	if cleanup != nil {
+		defer cleanup()
+	}
+	if err != nil {
+		return w.failTimelineTask(task, "渲染失败", err.Error())
+	}
+	for _, seg := range plan.Segments {
+		if seg.Source == nil || seg.Kind == "image" {
+			continue
+		}
+		hasAudio, probeErr := probeHasAudioStream(ctx, seg.Source.Path)
+		if probeErr != nil {
+			return w.failTimelineTask(task, "渲染失败", probeErr.Error())
+		}
+		seg.Source.HasAudio = hasAudio
+	}
+
+	args := buildRenderFFmpegArgs(plan, filepath.Join(workDir, "render-output.mp4"))
+	if len(args) == 0 {
+		return w.failTimelineTask(task, "渲染失败", "无法生成渲染命令")
+	}
+	if err := w.progress(task, "正在渲染…", 30); err != nil {
+		return err
+	}
+	cmd := exec.CommandContext(ctx, ffmpegBin, args...)
+	cmd.Dir = workDir
+	output, runErr := cmd.CombinedOutput()
+	if runErr != nil {
+		detail := strings.TrimSpace(string(output))
+		if len(detail) > 400 {
+			detail = detail[len(detail)-400:]
+		}
+		return w.failTimelineTask(task, "渲染失败", fmt.Sprintf("ffmpeg 渲染失败：%s", detail))
+	}
+
+	if err := w.progress(task, "写入资源…", 85); err != nil {
+		return err
+	}
+	renderedPath := filepath.Join(workDir, "render-output.mp4")
+	file, err := os.Open(renderedPath)
+	if err != nil {
+		return w.failTimelineTask(task, "渲染失败", "读取渲染产物失败")
+	}
+	defer file.Close()
+	stat, err := file.Stat()
+	if err != nil || stat.Size() == 0 {
+		return w.failTimelineTask(task, "渲染失败", "渲染产物为空")
+	}
+	durationMs := planDurationMs(plan)
+	fileName := fmt.Sprintf("timeline-render-%s.mp4", time.Now().Format("20060102-150405"))
+	resource, _, err := s.storeResource(task.UserID, "media", fileName, "video/mp4", stat.Size(), renderWidth, renderHeight, durationMs, file, nil)
+	if err != nil || resource == nil {
+		return w.failTimelineTask(task, "渲染失败", "保存渲染产物失败")
+	}
+
+	result := timelineRenderResult{
+		ResourceID:  resource.ID,
+		FileName:    fileName,
+		Size:        stat.Size(),
+		DurationMs:  durationMs,
+		SubtitleSRT: plan.SubtitleSRT,
+	}
+	payload, err := json.Marshal(result)
+	if err != nil {
+		return w.failTimelineTask(task, "渲染失败", "渲染结果序列化失败")
+	}
+	task.Status = model.TaskStatusSucceeded
+	task.Stage = "渲染完成"
+	task.Progress = 100
+	task.ResultJSON = string(payload)
+	completedAt := time.Now()
+	task.CompletedAt = &completedAt
+	if err := s.repo.SaveTaskCompletion(task, model.TaskStatusRunning, nil, nil, nil); err != nil {
+		return fmt.Errorf("写入渲染完成态失败: %w", err)
+	}
+	s.logInfo(task.UserID, task.ID, fmt.Sprintf("时间线渲染完成，时长 %.1fs", float64(durationMs)/1000), "")
+	return nil
+}
+
+func planDurationMs(plan renderPlan) int64 {
+	var total int64
+	for _, seg := range plan.Segments {
+		total += seg.DurationMs
+	}
+	return total
+}
+
+func renderFfmpegBinary() (string, error) {
+	if configured := strings.TrimSpace(os.Getenv(renderFfmpegEnv)); configured != "" {
+		return configured, nil
+	}
+	path, err := exec.LookPath("ffmpeg")
+	if err != nil {
+		return "", fmt.Errorf("渲染依赖未安装（需要 ffmpeg，可通过 %s 指定）", renderFfmpegEnv)
+	}
+	return path, nil
+}
+
+// materializeRenderSources 把计划中每个媒体片段对应的资源下载到临时目录，
+// 同资源复用同一份本地文件；返回工作目录与清理函数。
+func materializeRenderSources(ctx context.Context, s *Service, userID string, plan *renderPlan) (string, func(), error) {
+	tmpDir, err := os.MkdirTemp("", "yingce-render-*")
+	if err != nil {
+		return "", nil, fmt.Errorf("创建临时目录失败: %w", err)
+	}
+	cleanup := func() { _ = os.RemoveAll(tmpDir) }
+	cache := map[string]string{}
+	for i := range plan.Segments {
+		seg := &plan.Segments[i]
+		resourceID, ok := mediaResourceID(seg.Clip)
+		if !ok {
+			// 无可用媒体引用时渲染为黑场段，保证时间轴连续。
+			continue
+		}
+		path, cached := cache[resourceID]
+		if !cached {
+			_, reader, err := s.OpenResource(userID, resourceID)
+			if err != nil || reader == nil {
+				cleanup()
+				return "", nil, fmt.Errorf("无法读取时间线引用的媒体，可能已被删除")
+			}
+			ext := extForMime("video/mp4")
+			path = filepath.Join(tmpDir, fmt.Sprintf("src-%d%s", len(cache), ext))
+			file, err := os.Create(path)
+			if err != nil {
+				reader.Close()
+				cleanup()
+				return "", nil, fmt.Errorf("写入临时媒体失败: %w", err)
+			}
+			if _, err := io.Copy(file, reader); err != nil {
+				file.Close()
+				reader.Close()
+				cleanup()
+				return "", nil, fmt.Errorf("读取时间线媒体失败: %w", err)
+			}
+			file.Close()
+			reader.Close()
+			cache[resourceID] = path
+		}
+		seg.Source = &renderSource{ResourceID: resourceID, Clip: seg.Clip, Path: path, Ext: filepath.Ext(path)}
+	}
+	return tmpDir, cleanup, nil
+}
+
+// probeHasAudioStream 用 ffprobe 判断媒体是否含音轨，供滤镜图选择静音回退。
+func probeHasAudioStream(ctx context.Context, path string) (bool, error) {
+	bin, err := exec.LookPath("ffprobe")
+	if err != nil {
+		return false, fmt.Errorf("媒体探测依赖未安装（需要 ffprobe）")
+	}
+	cmd := exec.CommandContext(ctx, bin,
+		"-v", "error", "-select_streams", "a:0", "-show_entries", "stream=index",
+		"-of", "csv=p=0", path)
+	output, runErr := cmd.Output()
+	if runErr != nil {
+		// 探测失败按无音轨处理，渲染仍可产出静音视频。
+		return false, nil
+	}
+	return strings.TrimSpace(string(output)) != "", nil
+}
diff --git a/backend/internal/service/task_render_test.go b/backend/internal/service/task_render_test.go
new file mode 100644
index 000000000..418fc97d0
--- /dev/null
+++ b/backend/internal/service/task_render_test.go
@@ -0,0 +1,133 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"gorm.io/gorm"
+
+	"infinite-canvas/backend/internal/model"
+)
+
+// renderTestProject 构造一个可渲染的 v2 快照：一条可见视频轨 + 一个
+// 经 directMedia.storageKey（resource:<id>）引用后端资源的片段。
+func renderTestProject(storageKey string) renderProject {
+	visible := true
+	return renderProject{
+		Version:    2,
+		DurationMs: 2000,
+		Tracks:     []renderTrack{{ID: "track-v1", Kind: "video", Visible: &visible}},
+		Clips: []renderClip{{
+			ID:            "clip-v1",
+			Kind:          "video",
+			TrackID:       "track-v1",
+			StartMs:       0,
+			DurationMs:    2000,
+			SourceStartMs: 0,
+			Volume:        1,
+			DirectMedia: &struct {
+				ID         string `json:"id"`
+				Kind       string `json:"kind"`
+				StorageKey string `json:"storageKey"`
+			}{ID: "asset-v1", Kind: "video", StorageKey: storageKey},
+		}},
+	}
+}
+
+func renderInputJSON(t *testing.T, project renderProject) string {
+	t.Helper()
+	raw, err := json.Marshal(timelineRenderInput{ProjectID: "prj-render", Timeline: project})
+	if err != nil {
+		t.Fatalf("marshal render input: %v", err)
+	}
+	return string(raw)
+}
+
+func seedRunningRenderTask(t *testing.T, db *gorm.DB, inputJSON string) *model.Task {
+	t.Helper()
+	task := &model.Task{
+		ID:        fmt.Sprintf("tsk-render-%d", time.Now().UnixNano()),
+		UserID:    "usr-render-test",
+		Type:      model.TaskTypeTimelineRender,
+		Status:    model.TaskStatusRunning,
+		Stage:     "已领取",
+		InputJSON: inputJSON,
+	}
+	if err := db.Create(task).Error; err != nil {
+		t.Fatalf("seed task: %v", err)
+	}
+	return task
+}
+
+func TestCreateTimelineRenderTaskQueues(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+
+	task, err := svc.CreateTimelineRenderTask("usr-render-test", TimelineRenderCreateRequest{
+		ProjectID: "prj-render",
+		Timeline:  renderTestProject("resource:res-1"),
+	})
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if task.Type != model.TaskTypeTimelineRender || task.Status != model.TaskStatusQueued {
+		t.Fatalf("task = %s/%s, want %s/queued", task.Type, task.Status, model.TaskTypeTimelineRender)
+	}
+	if task.Provider != "local" || task.Model != "ffmpeg" {
+		t.Fatalf("provider/model = %s/%s, want local/ffmpeg", task.Provider, task.Model)
+	}
+
+	var stored model.Task
+	if err := db.First(&stored, "id = ?", task.ID).Error; err != nil {
+		t.Fatalf("load task: %v", err)
+	}
+	if stored.ProjectID != "prj-render" || stored.UserID != "usr-render-test" {
+		t.Fatalf("stored owner/project mismatch: %s/%s", stored.UserID, stored.ProjectID)
+	}
+}
+
+func TestCreateTimelineRenderTaskRejectsNoMedia(t *testing.T) {
+	svc, _ := newTimelineTaskTestService(t)
+
+	visible := true
+	textOnly := renderProject{
+		Version:    2,
+		DurationMs: 1000,
+		Tracks:     []renderTrack{{ID: "track-t1", Kind: "text", Visible: &visible}},
+		Clips: []renderClip{{
+			ID: "clip-t1", Kind: "text", TrackID: "track-t1", StartMs: 0,
+			DurationMs: 1000, Text: "字幕",
+		}},
+	}
+	_, err := svc.CreateTimelineRenderTask("usr-render-test", TimelineRenderCreateRequest{Timeline: textOnly})
+	if err == nil || !strings.Contains(err.Error(), "可渲染") {
+		t.Fatalf("err = %v, want mention of 没有可渲染的媒体片段", err)
+	}
+}
+
+func TestTimelineRenderFailsFastWhenSourceUnreadable(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	// 指向不存在的资源；ffmpeg 路径设为无效值不影响断言——本测试在
+	// 素材落盘（materialize）阶段即失败，且该失败早于任何外部命令执行。
+	task := seedRunningRenderTask(t, db, renderInputJSON(t, renderTestProject("resource:res-missing")))
+
+	t.Setenv(renderFfmpegEnv, "/no/such/ffmpeg")
+	w := newTaskWorkerCoordinator(svc)
+	if err := w.processTimelineRender(task, context.Background()); err != nil {
+		t.Fatalf("process: want nil (task terminal handled internally), got %v", err)
+	}
+
+	var stored model.Task
+	if err := db.First(&stored, "id = ?", task.ID).Error; err != nil {
+		t.Fatalf("load task: %v", err)
+	}
+	if stored.Status != model.TaskStatusFailed {
+		t.Fatalf("status = %q, want failed", stored.Status)
+	}
+	if !strings.Contains(stored.Error, "时间线引用的媒体") {
+		t.Fatalf("error = %q, want mention of 无法读取时间线引用的媒体", stored.Error)
+	}
+}
diff --git a/backend/internal/service/task_timeline.go b/backend/internal/service/task_timeline.go
new file mode 100644
index 000000000..8eafbb302
--- /dev/null
+++ b/backend/internal/service/task_timeline.go
@@ -0,0 +1,294 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+)
+
+// timeline 转写任务输入，由画布提交，字段与前端契约一致。
+type timelineTranscriptionInput struct {
+	ResourceID string `json:"resourceId"`
+	Language   string `json:"language"`
+}
+
+const whisperLangEnv = "CANVAS_WHISPER_BASE_URL"
+
+// processTimelineTranscription 执行时间线字幕转写：
+// 读取资源 -> 本地 ffmpeg 预处理为 16k 单声道 wav -> 本地 whisper.cpp 识别 ->
+// 结果写回任务（segments + srt）。任何失败都落到任务终态并携带用户可读原因。
+func (w *taskWorkerCoordinator) processTimelineTranscription(task *model.Task, ctx context.Context) error {
+	s := w.service
+	baseURL := strings.TrimSpace(os.Getenv(whisperLangEnv))
+	if baseURL == "" {
+		return w.failTimelineTask(task, "转写失败", "未配置本地转写服务：请设置 CANVAS_WHISPER_BASE_URL 指向 whisper.cpp 服务")
+	}
+	var input timelineTranscriptionInput
+	if err := json.Unmarshal([]byte(task.InputJSON), &input); err != nil || strings.TrimSpace(input.ResourceID) == "" {
+		return w.failTimelineTask(task, "转写失败", "任务缺少有效的资源引用")
+	}
+	if err := s.RequireFeature(FeatureTimelineTranscription); err != nil {
+		return w.failTimelineTask(task, "转写失败", "字幕转写暂未开放")
+	}
+	s.logInfo(task.UserID, task.ID, "时间线转写任务开始", "")
+
+	resource, reader, err := s.OpenResource(task.UserID, input.ResourceID)
+	if err != nil || reader == nil {
+		return w.failTimelineTask(task, "转写失败", "无法读取待转写媒体，可能已被删除")
+	}
+	defer reader.Close()
+	if resource == nil || !isTranscribableMime(resource.MimeType) {
+		return w.failTimelineTask(task, "转写失败", "仅支持音视频文件转写")
+	}
+
+	if err := w.progress(task, "等待转写服务", 15); err != nil {
+		return err
+	}
+	wavPath, cleanup, err := prepareWhisperWav(ctx, reader, resource.MimeType)
+	if cleanup != nil {
+		defer cleanup()
+	}
+	if err != nil {
+		return w.failTimelineTask(task, "转写失败", err.Error())
+	}
+	if err := w.progress(task, "正在转写…", 40); err != nil {
+		return err
+	}
+
+	client := newWhisperClient(baseURL)
+	segments, language, err := client.transcribe(ctx, wavPath, input.Language)
+	if err != nil {
+		return w.failTimelineTask(task, "转写失败", err.Error())
+	}
+	if err := w.progress(task, "整理字幕…", 80); err != nil {
+		return err
+	}
+
+	result := timelineTranscriptionResult{
+		Segments: segments,
+		SRT:      buildTimelineSRT(segments),
+		Language: language,
+	}
+	payload, err := json.Marshal(result)
+	if err != nil {
+		return w.failTimelineTask(task, "转写失败", "转写结果序列化失败")
+	}
+	task.Status = model.TaskStatusSucceeded
+	task.Stage = "转写完成"
+	task.Progress = 100
+	task.ResultJSON = string(payload)
+	completedAt := time.Now()
+	task.CompletedAt = &completedAt
+	if err := s.repo.SaveTaskCompletion(task, model.TaskStatusRunning, nil, nil, nil); err != nil {
+		// 冲突/租约已失效时不覆盖他人终态，交由上层判定。
+		return fmt.Errorf("写入转写完成态失败: %w", err)
+	}
+	s.logInfo(task.UserID, task.ID, fmt.Sprintf("时间线转写完成，段落 %d", len(segments)), "")
+	return nil
+}
+
+func (w *taskWorkerCoordinator) failTimelineTask(task *model.Task, stage string, message string) error {
+	s := w.service
+	done, err := s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, model.TaskStatusFailed, stage, message, time.Now())
+	if err != nil {
+		return fmt.Errorf("写入转写失败态失败: %w", err)
+	}
+	s.logInfo(task.UserID, task.ID, fmt.Sprintf("时间线转写失败: %s", message), "")
+	if !done {
+		return fmt.Errorf("时间线转写已失败: %s", message)
+	}
+	return nil
+}
+
+func (w *taskWorkerCoordinator) progress(task *model.Task, stage string, progress int) error {
+	if err := w.service.repo.UpdateTaskProgress(task.ID, stage, progress); err != nil {
+		return fmt.Errorf("更新转写进度失败: %w", err)
+	}
+	return nil
+}
+
+func (s *Service) logInfo(userID string, taskID string, message string, extra string) {
+	s.log(userID, taskID, "info", message, extra)
+}
+
+func isTranscribableMime(mime string) bool {
+	return strings.HasPrefix(mime, "video/") || strings.HasPrefix(mime, "audio/")
+}
+
+// prepareWhisperWav 将媒体流经本地 ffmpeg 转为 whisper.cpp 期望的
+// 16k 单声道 PCM wav；返回临时文件路径与清理函数。
+func prepareWhisperWav(ctx context.Context, reader io.Reader, mime string) (string, func(), error) {
+	if _, err := exec.LookPath("ffmpeg"); err != nil {
+		return "", nil, fmt.Errorf("音频预处理依赖未安装（需要 ffmpeg）")
+	}
+	tmpDir, err := os.MkdirTemp("", "yingce-whisper-*")
+	if err != nil {
+		return "", nil, fmt.Errorf("创建临时目录失败: %w", err)
+	}
+	cleanup := func() { _ = os.RemoveAll(tmpDir) }
+	inPath := filepath.Join(tmpDir, "input"+extForMime(mime))
+	inFile, err := os.Create(inPath)
+	if err != nil {
+		cleanup()
+		return "", nil, fmt.Errorf("写入待转写媒体失败: %w", err)
+	}
+	if _, err := io.Copy(inFile, reader); err != nil {
+		inFile.Close()
+		cleanup()
+		return "", nil, fmt.Errorf("读取待转写媒体失败: %w", err)
+	}
+	if err := inFile.Close(); err != nil {
+		cleanup()
+		return "", nil, fmt.Errorf("关闭临时文件失败: %w", err)
+	}
+	wavPath := filepath.Join(tmpDir, "audio16k.wav")
+	cmd := exec.CommandContext(ctx, "ffmpeg", "-nostdin", "-y", "-i", inPath, "-vn", "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", wavPath)
+	output, runErr := cmd.CombinedOutput()
+	if runErr != nil {
+		cleanup()
+		detail := strings.TrimSpace(string(output))
+		if len(detail) > 400 {
+			detail = detail[len(detail)-400:]
+		}
+		return "", nil, fmt.Errorf("音频预处理失败（ffmpeg）: %s", detail)
+	}
+	return wavPath, cleanup, nil
+}
+
+func extForMime(mime string) string {
+	switch {
+	case strings.HasPrefix(mime, "video/mp4"), strings.HasPrefix(mime, "audio/mp4"):
+		return ".mp4"
+	case strings.HasPrefix(mime, "video/webm"), strings.HasPrefix(mime, "audio/webm"):
+		return ".webm"
+	case strings.HasPrefix(mime, "video/quicktime"):
+		return ".mov"
+	case strings.HasPrefix(mime, "audio/mpeg"), strings.HasPrefix(mime, "audio/mp3"):
+		return ".mp3"
+	case strings.HasPrefix(mime, "audio/wav"), strings.HasPrefix(mime, "audio/x-wav"), strings.HasPrefix(mime, "audio/wave"):
+		return ".wav"
+	case strings.HasPrefix(mime, "audio/flac"):
+		return ".flac"
+	case strings.HasPrefix(mime, "audio/aac"):
+		return ".aac"
+	case strings.HasPrefix(mime, "audio/ogg"), strings.HasPrefix(mime, "video/ogg"):
+		return ".ogg"
+	default:
+		return ".bin"
+	}
+}
+
+// TimelineTranscriptionCreateRequest 是画布提交字幕转写任务的入参。
+type TimelineTranscriptionCreateRequest struct {
+	ResourceID string `json:"resourceId"`
+	Language   string `json:"language"`
+	ProjectID  string `json:"projectId"`
+}
+
+// CreateTimelineTranscriptionTask 创建时间线字幕转写任务：转写由本地
+// whisper.cpp 执行，不经模型路由与计费；创建时校验功能门控、资源归属
+// 与可转写类型，排队计入 active 限额。
+func (s *Service) CreateTimelineTranscriptionTask(userID string, req TimelineTranscriptionCreateRequest) (*model.Task, error) {
+	if s.IsDraining() {
+		return nil, &AppError{Status: 503, Code: 503, Message: "服务正在维护，暂不接受新的生成任务", Retryable: true}
+	}
+	if err := s.RequireFeature(FeatureTimelineTranscription); err != nil {
+		return nil, err
+	}
+	resourceID := strings.TrimSpace(req.ResourceID)
+	if resourceID == "" {
+		return nil, BadAuthRequest("必须指定待转写媒体")
+	}
+	resource, err := s.Resource(userID, resourceID)
+	if err != nil || resource == nil {
+		return nil, BadAuthRequest("无法读取待转写媒体，可能已被删除")
+	}
+	if !isTranscribableMime(resource.MimeType) {
+		return nil, BadAuthRequest("仅支持音视频文件转写")
+	}
+	policy, err := s.RuntimePolicy()
+	if err != nil {
+		return nil, err
+	}
+	input := timelineTranscriptionInput{ResourceID: resourceID, Language: strings.TrimSpace(req.Language)}
+	inputJSON, _ := json.Marshal(input)
+	task := model.Task{
+		ID: newID(), UserID: userID, ProjectID: req.ProjectID,
+		Type: model.TaskTypeTimelineTranscription, Status: model.TaskStatusQueued,
+		Stage: "等待队列调度", Progress: 5, Prompt: "字幕转写",
+		Provider: "local", Model: "whisper.cpp", InputJSON: string(inputJSON),
+	}
+	if err := s.createTaskWithinStorageQuota(&task, nil, policy); err != nil {
+		if errors.Is(err, repository.ErrActiveTaskLimit) {
+			return nil, BadAuthRequest(fmt.Sprintf("同时排队或运行的任务最多 %d 个，请等待已有任务完成", policy.Task.ActiveTaskLimit))
+		}
+		return nil, err
+	}
+	s.recordActivity(userID, "task", 1)
+	_ = s.log(userID, task.ID, "info", "字幕转写任务已进入队列", "")
+	return taskForOutput(task), nil
+}
+
+// TimelineRenderCreateRequest 是画布提交时间线渲染任务的入参；
+// Timeline 为前端 TimelineProject 快照（v2：tracks/clips 平铺）。
+// 片段通过 directMedia.storageKey=resource:<id> 引用后端资源。
+type TimelineRenderCreateRequest struct {
+	ProjectID string        `json:"projectId"`
+	Timeline  renderProject `json:"timeline"`
+}
+
+type timelineRenderInput struct {
+	ProjectID string        `json:"projectId"`
+	Timeline  renderProject `json:"timeline"`
+}
+
+type timelineRenderResult struct {
+	ResourceID  string `json:"resourceId"`
+	FileName    string `json:"fileName"`
+	Size        int64  `json:"size"`
+	DurationMs  int64  `json:"durationMs"`
+	SubtitleSRT string `json:"subtitleSrt,omitempty"`
+}
+
+// CreateTimelineRenderTask 创建时间线渲染任务：本地 ffmpeg 合成，不经模型
+// 路由与计费；创建时校验快照至少包含一个可渲染媒体片段。
+func (s *Service) CreateTimelineRenderTask(userID string, req TimelineRenderCreateRequest) (*model.Task, error) {
+	if s.IsDraining() {
+		return nil, &AppError{Status: 503, Code: 503, Message: "服务正在维护，暂不接受新的生成任务", Retryable: true}
+	}
+	plan := buildRenderPlan(req.Timeline)
+	if !plan.HasMedia {
+		return nil, BadAuthRequest("时间线没有可渲染的媒体片段")
+	}
+	policy, err := s.RuntimePolicy()
+	if err != nil {
+		return nil, err
+	}
+	input := timelineRenderInput{ProjectID: strings.TrimSpace(req.ProjectID), Timeline: req.Timeline}
+	inputJSON, _ := json.Marshal(input)
+	task := model.Task{
+		ID: newID(), UserID: userID, ProjectID: strings.TrimSpace(req.ProjectID),
+		Type: model.TaskTypeTimelineRender, Status: model.TaskStatusQueued,
+		Stage: "等待队列调度", Progress: 5, Prompt: "时间线渲染",
+		Provider: "local", Model: "ffmpeg", InputJSON: string(inputJSON),
+	}
+	if err := s.createTaskWithinStorageQuota(&task, nil, policy); err != nil {
+		if errors.Is(err, repository.ErrActiveTaskLimit) {
+			return nil, BadAuthRequest(fmt.Sprintf("同时排队或运行的任务最多 %d 个，请等待已有任务完成", policy.Task.ActiveTaskLimit))
+		}
+		return nil, err
+	}
+	s.recordActivity(userID, "task", 1)
+	_ = s.log(userID, task.ID, "info", "时间线渲染任务已进入队列", "")
+	return taskForOutput(task), nil
+}
diff --git a/backend/internal/service/task_timeline_test.go b/backend/internal/service/task_timeline_test.go
new file mode 100644
index 000000000..9e2d101df
--- /dev/null
+++ b/backend/internal/service/task_timeline_test.go
@@ -0,0 +1,150 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"gorm.io/driver/sqlite"
+
+	"gorm.io/gorm"
+	"infinite-canvas/backend/internal/database"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+)
+
+func newTimelineTaskTestService(t *testing.T) (*Service, *gorm.DB) {
+	t.Helper()
+	// 每个测试独立的 sqlite 内存库，避免共享缓存串库。
+	dsn := fmt.Sprintf("file:%s_%d?mode=memory&cache=shared", t.Name(), time.Now().UnixNano())
+	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
+	t.Helper()
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	if err := db.AutoMigrate(database.Models()...); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	return &Service{repo: repository.New(db)}, db
+}
+
+func seedRunningTimelineTask(t *testing.T, db *gorm.DB, inputJSON string) *model.Task {
+	t.Helper()
+	task := &model.Task{
+		ID:        fmt.Sprintf("tsk-timeline-%d", time.Now().UnixNano()),
+		UserID:    "usr-timeline-test",
+		Type:      model.TaskTypeTimelineTranscription,
+		Status:    model.TaskStatusRunning,
+		Stage:     "已领取",
+		InputJSON: inputJSON,
+	}
+	if err := db.Create(task).Error; err != nil {
+		t.Fatalf("seed task: %v", err)
+	}
+	return task
+}
+
+func TestTimelineTranscriptionFailsFastWhenWhisperUnconfigured(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	task := seedRunningTimelineTask(t, db, `{"resourceId":"res-1","language":""}`)
+	w := newTaskWorkerCoordinator(svc)
+
+	t.Setenv(whisperLangEnv, "")
+	err := w.processTimelineTranscription(task, context.Background())
+	if err != nil {
+		t.Fatalf("process: want nil (task terminal handled internally), got %v", err)
+	}
+	var stored model.Task
+	if err := db.First(&stored, "id = ?", task.ID).Error; err != nil {
+		t.Fatalf("load task: %v", err)
+	}
+	if stored.Status != model.TaskStatusFailed {
+		t.Fatalf("status = %q, want failed", stored.Status)
+	}
+	if !strings.Contains(stored.Error, "CANVAS_WHISPER_BASE_URL") {
+		t.Fatalf("error = %q, want mention of CANVAS_WHISPER_BASE_URL", stored.Error)
+	}
+}
+
+func TestTimelineTranscriptionRejectsMissingResourceRef(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	task := seedRunningTimelineTask(t, db, `{"resourceId":"  "}`)
+	w := newTaskWorkerCoordinator(svc)
+
+	t.Setenv(whisperLangEnv, "http://127.0.0.1:9999")
+	err := w.processTimelineTranscription(task, context.Background())
+	if err != nil {
+		t.Fatalf("process: want nil (task terminal handled internally), got %v", err)
+	}
+	var stored model.Task
+	if err := db.First(&stored, "id = ?", task.ID).Error; err != nil {
+		t.Fatalf("load task: %v", err)
+	}
+	if stored.Status != model.TaskStatusFailed {
+		t.Fatalf("status = %q, want failed", stored.Status)
+	}
+	if !strings.Contains(stored.Error, "资源引用") {
+		t.Fatalf("error = %q, want mention of 资源引用", stored.Error)
+	}
+}
+
+func seedResource(t *testing.T, db *gorm.DB, id string, userID string, mime string) {
+	t.Helper()
+	if err := db.Create(&model.Resource{ID: id, UserID: userID, Kind: "media", Status: model.ResourceStatusReady, Provider: "local", MimeType: mime, Size: 1024}).Error; err != nil {
+		t.Fatalf("seed resource: %v", err)
+	}
+}
+
+func TestCreateTimelineTranscriptionTaskQueues(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	seedResource(t, db, "res-video-1", "usr-create-test", "video/mp4")
+
+	task, err := svc.CreateTimelineTranscriptionTask("usr-create-test", TimelineTranscriptionCreateRequest{ResourceID: "res-video-1", Language: "zh", ProjectID: "prj-1"})
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if task.Type != model.TaskTypeTimelineTranscription {
+		t.Fatalf("type = %q, want timeline_transcription", task.Type)
+	}
+	if task.Status != model.TaskStatusQueued {
+		t.Fatalf("status = %q, want queued", task.Status)
+	}
+	var stored model.Task
+	if err := db.First(&stored, "id = ?", task.ID).Error; err != nil {
+		t.Fatalf("load task: %v", err)
+	}
+	if stored.UserID != "usr-create-test" || stored.ProjectID != "prj-1" {
+		t.Fatalf("owner/project mismatch: %q / %q", stored.UserID, stored.ProjectID)
+	}
+	if stored.Provider != "local" || stored.Model != "whisper.cpp" {
+		t.Fatalf("provider/model = %q/%q, want local/whisper.cpp", stored.Provider, stored.Model)
+	}
+}
+
+func TestCreateTimelineTranscriptionTaskRejectsForeignResource(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	seedResource(t, db, "res-owner-a", "usr-a", "video/mp4")
+
+	_, err := svc.CreateTimelineTranscriptionTask("usr-b", TimelineTranscriptionCreateRequest{ResourceID: "res-owner-a"})
+	if err == nil || !strings.Contains(err.Error(), "媒体") {
+		t.Fatalf("want 无法读取待转写媒体 error, got %v", err)
+	}
+	// 另一用户自己的音视频资源可正常创建。
+	seedResource(t, db, "res-b", "usr-b", "audio/mpeg")
+	if _, err := svc.CreateTimelineTranscriptionTask("usr-b", TimelineTranscriptionCreateRequest{ResourceID: "res-b"}); err != nil {
+		t.Fatalf("own audio resource should create: %v", err)
+	}
+}
+
+func TestCreateTimelineTranscriptionTaskRejectsNonTranscribable(t *testing.T) {
+	svc, db := newTimelineTaskTestService(t)
+	seedResource(t, db, "res-img", "usr-img", "image/png")
+
+	_, err := svc.CreateTimelineTranscriptionTask("usr-img", TimelineTranscriptionCreateRequest{ResourceID: "res-img"})
+	if err == nil || !strings.Contains(err.Error(), "音视频") {
+		t.Fatalf("want 仅支持音视频 error, got %v", err)
+	}
+}
diff --git a/backend/internal/service/task_worker.go b/backend/internal/service/task_worker.go
index f6f91889c..6613f3626 100644
--- a/backend/internal/service/task_worker.go
+++ b/backend/internal/service/task_worker.go
@@ -130,6 +130,15 @@ func (w *taskWorkerCoordinator) processClaimedTask(task *model.Task) error {
 		return terminal.handleAlreadyCancelled(*latest)
 	}
 
+	// 时间线转写由本地 whisper.cpp 执行，不经计费与模型渠道路由，
+	// 在进入通用生成流程前按类型分叉到独立执行器。
+	if task.Type == model.TaskTypeTimelineTranscription {
+		return w.processTimelineTranscription(task, ctx)
+	}
+	if task.Type == model.TaskTypeTimelineRender {
+		return w.processTimelineRender(task, ctx)
+	}
+
 	task.Stage = "调用生成模型"
 	task.Progress = 35
 	if taskUsesUpstreamReportedProgress(task.Type) {
@@ -231,6 +240,12 @@ func taskExecutionTimeoutWithPolicy(taskType string, policy RuntimeTaskPolicy) t
 		return time.Duration(policy.AudioTimeoutMinutes) * time.Minute
 	case strings.HasPrefix(taskType, "canvas_text"):
 		return time.Duration(policy.TextTimeoutMinutes) * time.Minute
+	case taskType == model.TaskTypeTimelineTranscription:
+		// 本地转写受媒体时长影响，给出独立宽松超时。
+		return 20 * time.Minute
+	case taskType == model.TaskTypeTimelineRender:
+		// 渲染是整条时间线的重编码，耗时随长度线性增长。
+		return 60 * time.Minute
 	default:
 		return time.Duration(policy.DefaultTimeoutMinutes) * time.Minute
 	}
diff --git a/backend/internal/service/timeline_render_plan.go b/backend/internal/service/timeline_render_plan.go
new file mode 100644
index 000000000..664ebe818
--- /dev/null
+++ b/backend/internal/service/timeline_render_plan.go
@@ -0,0 +1,276 @@
+package service
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// 时间线渲染：把前端 TimelineProject 快照（tracks/clips 平铺，见
+// web/src/types/timeline.ts TimelineProject v2）展开为可执行的 ffmpeg 步骤。
+// 与前端 timeline-to-ffmpeg.ts 保持同一数据流：trim（按 sourceStartMs 裁切）
+// → 空隙补黑场静音 → concat。字幕不烧录（依赖 libass），单独产出 SRT。
+//
+// 输入布局统一为「每个片段两个输入：视频源 + 音频源」，空隙展开为独立
+// 黑场片段，因此第 i 个片段的视频输入为 2i、音频输入为 2i+1。
+
+type renderClip struct {
+	ID               string  `json:"id"`
+	Kind             string  `json:"kind"`
+	TrackID          string  `json:"trackId"`
+	StartMs          int64   `json:"startMs"`
+	DurationMs       int64   `json:"durationMs"`
+	SourceStartMs    int64   `json:"sourceStartMs"`
+	SourceDurationMs int64   `json:"sourceDurationMs"`
+	Volume           float64 `json:"volume"`
+	Text             string  `json:"text"`
+	DirectMedia      *struct {
+		ID         string `json:"id"`
+		Kind       string `json:"kind"`
+		StorageKey string `json:"storageKey"`
+	} `json:"directMedia"`
+}
+
+type renderTrack struct {
+	ID      string `json:"id"`
+	Kind    string `json:"kind"`
+	Visible *bool  `json:"visible"`
+	Muted   bool   `json:"muted"`
+}
+
+type renderProject struct {
+	Version    int           `json:"version"`
+	Tracks     []renderTrack `json:"tracks"`
+	Clips      []renderClip  `json:"clips"`
+	DurationMs int64         `json:"durationMs"`
+}
+
+type renderSource struct {
+	ResourceID string
+	Clip       renderClip
+	Path       string
+	Ext        string
+	// HasAudio 由 ffprobe 探测得到；无音轨的媒体改为静音源，避免 map 失败。
+	HasAudio bool
+}
+
+// renderSegment 是渲染序列中的一段；Kind 为 video/image 表示媒体片段，
+// gap 表示补黑场静音的空隙段（无 Source）。
+type renderSegment struct {
+	Kind       string
+	DurationMs int64
+	GapMs      int64
+	Clip       renderClip
+	Source     *renderSource
+}
+
+type renderPlan struct {
+	Segments    []renderSegment
+	SubtitleSRT string
+	HasMedia    bool
+}
+
+// buildRenderPlan 挑选可见视频/图片轨片段按 startMs 排序，并把片段之间的
+// 空隙展开为黑场段，使渲染序列在时间轴上连续。
+func buildRenderPlan(project renderProject) renderPlan {
+	visible := map[string]bool{}
+	for _, track := range project.Tracks {
+		visible[track.ID] = track.Visible == nil || *track.Visible
+	}
+	clips := make([]renderClip, 0, len(project.Clips))
+	for _, clip := range project.Clips {
+		if !visible[clip.TrackID] {
+			continue
+		}
+		if clip.Kind != "video" && clip.Kind != "image" {
+			continue
+		}
+		if clip.DurationMs <= 0 {
+			continue
+		}
+		clips = append(clips, clip)
+	}
+	sort.SliceStable(clips, func(i, j int) bool {
+		if clips[i].StartMs == clips[j].StartMs {
+			return clips[i].ID < clips[j].ID
+		}
+		return clips[i].StartMs < clips[j].StartMs
+	})
+
+	plan := renderPlan{SubtitleSRT: buildRenderSubtitleSRT(project)}
+	cursor := int64(0)
+	for _, clip := range clips {
+		if gap := clip.StartMs - cursor; gap > 0 {
+			plan.Segments = append(plan.Segments, renderSegment{Kind: "gap", DurationMs: gap, GapMs: gap})
+		}
+		plan.Segments = append(plan.Segments, renderSegment{Kind: clip.Kind, DurationMs: clip.DurationMs, Clip: clip})
+		cursor = clip.StartMs + clip.DurationMs
+	}
+	for _, seg := range plan.Segments {
+		if _, ok := mediaResourceID(seg.Clip); ok {
+			plan.HasMedia = true
+			break
+		}
+	}
+	return plan
+}
+
+// mediaResourceID 从片段的 directMedia.storageKey（resource:<id>）还原资源 ID。
+func mediaResourceID(clip renderClip) (string, bool) {
+	if clip.DirectMedia == nil {
+		return "", false
+	}
+	key := strings.TrimSpace(clip.DirectMedia.StorageKey)
+	if !strings.HasPrefix(key, "resource:") {
+		return "", false
+	}
+	id := strings.TrimSpace(strings.TrimPrefix(key, "resource:"))
+	return id, id != ""
+}
+
+func buildRenderSubtitleSRT(project renderProject) string {
+	subtitle := make([]renderClip, 0, len(project.Clips))
+	for _, clip := range project.Clips {
+		if clip.Kind != "subtitle" || strings.TrimSpace(clip.Text) == "" || clip.DurationMs <= 0 {
+			continue
+		}
+		subtitle = append(subtitle, clip)
+	}
+	sort.SliceStable(subtitle, func(i, j int) bool {
+		if subtitle[i].StartMs == subtitle[j].StartMs {
+			return subtitle[i].ID < subtitle[j].ID
+		}
+		return subtitle[i].StartMs < subtitle[j].StartMs
+	})
+	if len(subtitle) == 0 {
+		return ""
+	}
+	var out strings.Builder
+	for i, clip := range subtitle {
+		fmt.Fprintf(&out, "%d\n%s --> %s\n%s\n\n",
+			i+1,
+			formatSRTTimestamp(clip.StartMs),
+			formatSRTTimestamp(clip.StartMs+clip.DurationMs),
+			strings.TrimSpace(clip.Text))
+	}
+	return out.String()
+}
+
+const (
+	renderWidth      = 1920
+	renderHeight     = 1080
+	renderFPS        = 30
+	renderSampleRate = 44100
+)
+
+// buildRenderFFmpegArgs 依据渲染计划生成 ffmpeg 参数（工作目录内相对路径）。
+// 每段固定两个输入：视频源与音频源，末尾 concat 为单路输出。
+func buildRenderFFmpegArgs(plan renderPlan, target string) []string {
+	if len(plan.Segments) == 0 {
+		return nil
+	}
+	scale := fmt.Sprintf("scale=%d:%d:force_original_aspect_ratio=decrease,pad=%d:%d:(ow-iw)/2:(oh-ih)/2",
+		renderWidth, renderHeight, renderWidth, renderHeight)
+	args := []string{"-nostdin", "-y"}
+	for _, seg := range plan.Segments {
+		seconds := fmt.Sprintf("%.3f", float64(seg.DurationMs)/1000)
+		switch seg.Kind {
+		case "gap":
+			args = append(args,
+				"-f", "lavfi", "-t", seconds,
+				"-i", fmt.Sprintf("color=c=black:s=%dx%d:r=%d", renderWidth, renderHeight, renderFPS),
+				"-f", "lavfi", "-t", seconds,
+				"-i", fmt.Sprintf("anullsrc=r=%d:cl=stereo", renderSampleRate),
+			)
+		case "image":
+			if seg.Source == nil {
+				args = append(args,
+					"-f", "lavfi", "-t", seconds,
+					"-i", fmt.Sprintf("color=c=black:s=%dx%d:r=%d", renderWidth, renderHeight, renderFPS),
+					"-f", "lavfi", "-t", seconds,
+					"-i", fmt.Sprintf("anullsrc=r=%d:cl=stereo", renderSampleRate),
+				)
+				continue
+			}
+			args = append(args,
+				"-loop", "1", "-t", seconds, "-i", seg.Source.Path,
+				"-f", "lavfi", "-t", seconds,
+				"-i", fmt.Sprintf("anullsrc=r=%d:cl=stereo", renderSampleRate),
+			)
+		default:
+			if seg.Source == nil {
+				args = append(args,
+					"-f", "lavfi", "-t", seconds,
+					"-i", fmt.Sprintf("color=c=black:s=%dx%d:r=%d", renderWidth, renderHeight, renderFPS),
+					"-f", "lavfi", "-t", seconds,
+					"-i", fmt.Sprintf("anullsrc=r=%d:cl=stereo", renderSampleRate),
+				)
+				continue
+			}
+			if seg.Clip.SourceStartMs > 0 {
+				args = append(args, "-ss", fmt.Sprintf("%.3f", float64(seg.Clip.SourceStartMs)/1000))
+			}
+			args = append(args, "-t", seconds, "-i", seg.Source.Path)
+			// 音频输入复用同一媒体文件；无音轨时 ffmpeg 会因 map 失败，
+			// 由调用方探测后回退为静音源（见 renderAudioFallback）。
+			if seg.Clip.SourceStartMs > 0 {
+				args = append(args, "-ss", fmt.Sprintf("%.3f", float64(seg.Clip.SourceStartMs)/1000))
+			}
+			args = append(args, "-t", seconds, "-i", seg.Source.Path)
+		}
+	}
+
+	filters := make([]string, 0, len(plan.Segments)*2+1)
+	labels := make([]string, 0, len(plan.Segments)*2)
+	for i, seg := range plan.Segments {
+		videoIn := 2 * i
+		audioIn := 2*i + 1
+		videoLabel := fmt.Sprintf("v%d", i)
+		audioLabel := fmt.Sprintf("a%d", i)
+		if seg.Source != nil && seg.Kind != "image" && !seg.Source.HasAudio {
+			// 无音轨媒体：改用静音源，避免 map 失败。
+			audioIn = videoIn
+			filters = append(filters,
+				fmt.Sprintf("[%d:v]fps=%d,%s,setsar=1[%s]", videoIn, renderFPS, scale, videoLabel))
+			silentLabel := fmt.Sprintf("silent%d", i)
+			filters = append(filters,
+				fmt.Sprintf("anullsrc=r=%d:cl=stereo[%s]", renderSampleRate, silentLabel))
+			filters = append(filters,
+				fmt.Sprintf("[%s]atrim=0:%.3f,asetpts=N/SR/TB[%s]", silentLabel, float64(seg.DurationMs)/1000, audioLabel))
+		} else {
+			volume := 1.0
+			if seg.Clip.Volume > 0 {
+				volume = seg.Clip.Volume
+			}
+			filters = append(filters,
+				fmt.Sprintf("[%d:v]fps=%d,%s,setsar=1[%s]", videoIn, renderFPS, scale, videoLabel))
+			filters = append(filters,
+				fmt.Sprintf("[%d:a]aformat=sample_fmts=fltp:sample_rates=%d:channel_layouts=stereo,volume=%.3f,apad[%s]",
+					audioIn, renderSampleRate, volume, audioLabel))
+		}
+		labels = append(labels, videoLabel, audioLabel)
+	}
+	var concatInputs strings.Builder
+	for _, label := range labels {
+		fmt.Fprintf(&concatInputs, "[%s]", label)
+	}
+	filters = append(filters, fmt.Sprintf("%sconcat=n=%d:v=1:a=1[vout][aout]", concatInputs.String(), len(plan.Segments)))
+
+	args = append(args,
+		"-filter_complex", strings.Join(filters, ";"),
+		"-map", "[vout]", "-map", "[aout]",
+		"-c:v", "libx264", "-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p",
+		"-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart",
+		"-t", fmt.Sprintf("%.3f", planTotalSeconds(plan)),
+		target,
+	)
+	return args
+}
+
+func planTotalSeconds(plan renderPlan) float64 {
+	var total int64
+	for _, seg := range plan.Segments {
+		total += seg.DurationMs
+	}
+	return float64(total) / 1000
+}
diff --git a/backend/internal/service/timeline_render_plan_test.go b/backend/internal/service/timeline_render_plan_test.go
new file mode 100644
index 000000000..cb22650fd
--- /dev/null
+++ b/backend/internal/service/timeline_render_plan_test.go
@@ -0,0 +1,148 @@
+package service
+
+import (
+	"strings"
+	"testing"
+)
+
+func renderClipFixture(id string, kind string, trackID string, startMs int64, durationMs int64, storageKey string) renderClip {
+	clip := renderClip{ID: id, Kind: kind, TrackID: trackID, StartMs: startMs, DurationMs: durationMs, Volume: 1}
+	if storageKey != "" {
+		clip.DirectMedia = &struct {
+			ID         string `json:"id"`
+			Kind       string `json:"kind"`
+			StorageKey string `json:"storageKey"`
+		}{ID: "media-" + id, Kind: kind, StorageKey: storageKey}
+	}
+	return clip
+}
+
+func TestBuildRenderPlanExpandsGapAndSorts(t *testing.T) {
+	project := renderProject{
+		Version: 2,
+		Tracks:  []renderTrack{{ID: "track-video-1", Kind: "video"}},
+		Clips: []renderClip{
+			renderClipFixture("clip-b", "video", "track-video-1", 3000, 2000, "resource:res-b"),
+			renderClipFixture("clip-a", "video", "track-video-1", 0, 2000, "resource:res-a"),
+			renderClipFixture("clip-sub", "subtitle", "track-subtitle-1", 0, 1000, ""),
+		},
+	}
+	plan := buildRenderPlan(project)
+	if !plan.HasMedia {
+		t.Fatal("HasMedia = false, want true")
+	}
+	// 前 0–3000ms 被 clip-a(0-2000) 覆盖后仍有 1000ms 空隙，应展开为黑场段。
+	if len(plan.Segments) != 3 {
+		t.Fatalf("segments = %d, want 3 (clip-a, gap, clip-b)", len(plan.Segments))
+	}
+	if plan.Segments[0].Kind != "video" || plan.Segments[0].Clip.ID != "clip-a" {
+		t.Fatalf("seg0 = %s/%s, want video/clip-a", plan.Segments[0].Kind, plan.Segments[0].Clip.ID)
+	}
+	if plan.Segments[1].Kind != "gap" || plan.Segments[1].DurationMs != 1000 {
+		t.Fatalf("seg1 = %s/%dms, want gap/1000ms", plan.Segments[1].Kind, plan.Segments[1].DurationMs)
+	}
+	if plan.Segments[2].Clip.ID != "clip-b" {
+		t.Fatalf("seg2 = %s, want clip-b (sorted by startMs)", plan.Segments[2].Clip.ID)
+	}
+}
+
+func TestBuildRenderPlanSkipsHiddenTrack(t *testing.T) {
+	hidden := false
+	project := renderProject{
+		Version: 2,
+		Tracks:  []renderTrack{{ID: "track-hidden", Kind: "video", Visible: &hidden}},
+		Clips:   []renderClip{renderClipFixture("clip-hidden", "video", "track-hidden", 0, 1000, "resource:res-x")},
+	}
+	plan := buildRenderPlan(project)
+	if len(plan.Segments) != 0 {
+		t.Fatalf("segments = %d, want 0 (hidden track skipped)", len(plan.Segments))
+	}
+	if plan.HasMedia {
+		t.Fatal("HasMedia = true, want false for hidden-only timeline")
+	}
+}
+
+func TestBuildRenderSubtitleSRT(t *testing.T) {
+	project := renderProject{
+		Version: 2,
+		Clips: []renderClip{
+			{ID: "sub-b", Kind: "subtitle", StartMs: 2000, DurationMs: 1000, Text: "第二条"},
+			{ID: "sub-a", Kind: "subtitle", StartMs: 0, DurationMs: 1000, Text: "第一条"},
+			{ID: "sub-blank", Kind: "subtitle", StartMs: 5000, DurationMs: 1000, Text: "   "},
+		},
+	}
+	srt := buildRenderSubtitleSRT(project)
+	want := "1\n00:00:00,000 --> 00:00:01,000\n第一条\n\n2\n00:00:02,000 --> 00:00:03,000\n第二条\n\n"
+	if srt != want {
+		t.Fatalf("srt mismatch:\n got %q\nwant %q", srt, want)
+	}
+	if buildRenderSubtitleSRT(renderProject{Version: 2}) != "" {
+		t.Fatal("srt for empty timeline: want empty string")
+	}
+}
+
+func TestBuildRenderFFmpegArgsLayout(t *testing.T) {
+	plan := buildRenderPlan(renderProject{
+		Version: 2,
+		Tracks:  []renderTrack{{ID: "track-video-1", Kind: "video"}},
+		Clips: []renderClip{
+			renderClipFixture("clip-a", "video", "track-video-1", 0, 2000, "resource:res-a"),
+			renderClipFixture("clip-b", "video", "track-video-1", 5000, 1000, "resource:res-b"),
+		},
+	})
+	plan.Segments[0].Source = &renderSource{ResourceID: "res-a", Path: "src-0.mp4", HasAudio: true}
+	plan.Segments[1].Source = &renderSource{ResourceID: "res-a", Path: "src-0.mp4", HasAudio: true}
+	plan.Segments[2].Source = &renderSource{ResourceID: "res-b", Path: "src-1.mp4", HasAudio: true}
+
+	args := buildRenderFFmpegArgs(plan, "render-output.mp4")
+	joined := strings.Join(args, " ")
+	if len(args) == 0 {
+		t.Fatal("args empty, want ffmpeg arguments")
+	}
+	for _, want := range []string{
+		"-filter_complex",
+		"concat=n=3:v=1:a=1",
+		"[vout]", "[aout]",
+		"libx264", "aac",
+		"color=c=black:s=1920x1080:r=30",
+		"anullsrc=r=44100:cl=stereo",
+		"render-output.mp4",
+	} {
+		if !strings.Contains(joined, want) {
+			t.Fatalf("args missing %q: %s", want, joined)
+		}
+	}
+	// 每段两个输入：视频 + 音频；末尾输入索引应为 5（3 段 × 2）。
+	if !strings.Contains(joined, "[5:a]") {
+		t.Fatalf("args missing final audio input label [5:a]: %s", joined)
+	}
+	if buildRenderFFmpegArgs(renderPlan{}, "out.mp4") != nil {
+		t.Fatal("args for empty plan: want nil")
+	}
+}
+
+func TestBuildRenderFFmpegArgsSilentFallbackUniqueLabels(t *testing.T) {
+	plan := renderPlan{Segments: []renderSegment{
+		{Kind: "video", DurationMs: 1000, Source: &renderSource{Path: "src-0.mp4", HasAudio: false}},
+		{Kind: "video", DurationMs: 1000, Source: &renderSource{Path: "src-1.mp4", HasAudio: false}},
+	}}
+	args := buildRenderFFmpegArgs(plan, "out.mp4")
+	joined := strings.Join(args, " ")
+	// 两段均无音轨：静音源标签必须按片段唯一，否则 filter_complex 报错。
+	if !strings.Contains(joined, "[silent0]") || !strings.Contains(joined, "[silent1]") {
+		t.Fatalf("silent labels not unique: %s", joined)
+	}
+}
+
+func TestMediaResourceID(t *testing.T) {
+	clip := renderClipFixture("a", "video", "track-1", 0, 1000, "resource:res-42")
+	if id, ok := mediaResourceID(clip); !ok || id != "res-42" {
+		t.Fatalf("mediaResourceID = %q/%v, want res-42/true", id, ok)
+	}
+	if _, ok := mediaResourceID(renderClip{}); ok {
+		t.Fatal("mediaResourceID for clip without directMedia: want false")
+	}
+	if _, ok := mediaResourceID(renderClipFixture("a", "video", "track-1", 0, 1000, "https://example.com/a.mp4")); ok {
+		t.Fatal("mediaResourceID for http storage key: want false")
+	}
+}
diff --git a/backend/internal/service/transcription_whisper.go b/backend/internal/service/transcription_whisper.go
new file mode 100644
index 000000000..a971a4852
--- /dev/null
+++ b/backend/internal/service/transcription_whisper.go
@@ -0,0 +1,156 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// 本地 whisper.cpp HTTP 服务客户端。配置项 CANVAS_WHISPER_BASE_URL
+// 指向自建 whisper.cpp server（/inference，多部件 file 上传）。
+// 语音数据不出本机，未配置该地址时任务在进入转写前明确失败。
+
+type timelineTranscriptionSegment struct {
+	StartMs int64  `json:"startMs"`
+	EndMs   int64  `json:"endMs"`
+	Text    string `json:"text"`
+}
+
+type timelineTranscriptionResult struct {
+	Segments []timelineTranscriptionSegment `json:"segments"`
+	SRT      string                         `json:"srt"`
+	Language string                         `json:"language"`
+}
+
+type whisperSegment struct {
+	Start float64 `json:"start"`
+	End   float64 `json:"end"`
+	Text  string  `json:"text"`
+}
+
+type whisperVerboseJSON struct {
+	Segments []whisperSegment `json:"segments"`
+	Language string           `json:"language"`
+}
+
+type whisperClient struct {
+	baseURL string
+	http    *http.Client
+}
+
+func newWhisperClient(baseURL string) *whisperClient {
+	return &whisperClient{
+		baseURL: strings.TrimRight(strings.TrimSpace(baseURL), "/"),
+		http:    &http.Client{Timeout: 20 * time.Minute},
+	}
+}
+
+// transcribe 将本地 wav 送至 whisper.cpp /inference，返回段落与语言。
+func (c *whisperClient) transcribe(ctx context.Context, wavPath string, language string) ([]timelineTranscriptionSegment, string, error) {
+	if c.baseURL == "" {
+		return nil, "", fmt.Errorf("本地转写服务未配置：请设置 CANVAS_WHISPER_BASE_URL")
+	}
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	audio, err := os.Open(wavPath)
+	if err != nil {
+		return nil, "", fmt.Errorf("读取待转写音频失败: %w", err)
+	}
+	defer audio.Close()
+	part, err := writer.CreateFormFile("file", filepath.Base(wavPath))
+	if err != nil {
+		return nil, "", err
+	}
+	if _, err := io.Copy(part, audio); err != nil {
+		return nil, "", fmt.Errorf("上传音频失败: %w", err)
+	}
+	if err := writer.WriteField("response_format", "verbose_json"); err != nil {
+		return nil, "", err
+	}
+	if strings.TrimSpace(language) != "" {
+		if err := writer.WriteField("language", strings.TrimSpace(language)); err != nil {
+			return nil, "", err
+		}
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/inference", &body)
+	if err != nil {
+		return nil, "", err
+	}
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("无法连接本地转写服务(whisper.cpp): %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		msg, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
+		return nil, "", fmt.Errorf("本地转写服务返回 %d: %s", resp.StatusCode, strings.TrimSpace(string(msg)))
+	}
+	payload, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+	if err != nil {
+		return nil, "", fmt.Errorf("读取转写结果失败: %w", err)
+	}
+	segments, languageOut, err := decodeWhisperVerboseJSON(payload)
+	if err != nil {
+		return nil, "", err
+	}
+	if len(segments) == 0 {
+		return nil, "", fmt.Errorf("本地转写服务未识别出语音内容")
+	}
+	return segments, languageOut, nil
+}
+
+// decodeWhisperVerboseJSON 解析 whisper.cpp verbose_json 响应为内部段落，
+// 过滤空文本，秒精度取整为毫秒。
+func decodeWhisperVerboseJSON(payload []byte) ([]timelineTranscriptionSegment, string, error) {
+	var parsed whisperVerboseJSON
+	if err := json.Unmarshal(payload, &parsed); err != nil {
+		return nil, "", fmt.Errorf("转写结果解析失败: %w", err)
+	}
+	segments := make([]timelineTranscriptionSegment, 0, len(parsed.Segments))
+	for _, seg := range parsed.Segments {
+		if strings.TrimSpace(seg.Text) == "" {
+			continue
+		}
+		segments = append(segments, timelineTranscriptionSegment{
+			StartMs: int64(math.Round(seg.Start * 1000)),
+			EndMs:   int64(math.Round(seg.End * 1000)),
+			Text:    strings.TrimSpace(seg.Text),
+		})
+	}
+	return segments, parsed.Language, nil
+}
+
+// formatSRTTimestamp 将毫秒时间格式化为 SRT 时间戳 hh:mm:ss,mmm。
+func formatSRTTimestamp(ms int64) string {
+	if ms < 0 {
+		ms = 0
+	}
+	hours := ms / 3600000
+	minutes := (ms % 3600000) / 60000
+	seconds := (ms % 60000) / 1000
+	millis := ms % 1000
+	return fmt.Sprintf("%02d:%02d:%02d,%03d", hours, minutes, seconds, millis)
+}
+
+// buildTimelineSRT 由段落生成 SRT 字幕文本，供前端直接消费或导出。
+func buildTimelineSRT(segments []timelineTranscriptionSegment) string {
+	var out strings.Builder
+	for i, seg := range segments {
+		fmt.Fprintf(&out, "%d\n%s --> %s\n%s\n\n", i+1, formatSRTTimestamp(seg.StartMs), formatSRTTimestamp(seg.EndMs), seg.Text)
+	}
+	return out.String()
+}
diff --git a/backend/internal/service/transcription_whisper_test.go b/backend/internal/service/transcription_whisper_test.go
new file mode 100644
index 000000000..39d4760ba
--- /dev/null
+++ b/backend/internal/service/transcription_whisper_test.go
@@ -0,0 +1,101 @@
+package service
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodeWhisperVerboseJSON(t *testing.T) {
+	payload := []byte(`{
+		"task": "transcribe",
+		"language": "zh",
+		"duration": 6.12,
+		"text": " 大家好  ",
+		"segments": [
+			{"id": 0, "start": 0.0, "end": 2.015, "text": " 大家好 "},
+			{"id": 1, "start": 2.5, "end": 6.12, "text": "   "},
+			{"id": 2, "start": 4.12, "end": 6.121, "text": "今天天气不错"}
+		]
+	}`)
+	segments, language, err := decodeWhisperVerboseJSON(payload)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if language != "zh" {
+		t.Fatalf("language = %q, want zh", language)
+	}
+	// 空文本段被过滤，毫秒取整（0.0→0，2.5→2500）。
+	if len(segments) != 2 {
+		t.Fatalf("segments = %d, want 2 (blank segment filtered)", len(segments))
+	}
+	if segments[0].StartMs != 0 || segments[0].EndMs != 2015 {
+		t.Fatalf("seg0 = %d-%d, want 0-2015", segments[0].StartMs, segments[0].EndMs)
+	}
+	if segments[0].Text != "大家好" {
+		t.Fatalf("seg0 text = %q, want 大家好 (trimmed)", segments[0].Text)
+	}
+	if segments[1].StartMs != 4120 || segments[1].EndMs != 6121 {
+		t.Fatalf("seg1 = %d-%d, want 4120-6121", segments[1].StartMs, segments[1].EndMs)
+	}
+}
+
+func TestDecodeWhisperVerboseJSONInvalid(t *testing.T) {
+	if _, _, err := decodeWhisperVerboseJSON([]byte(`{not json`)); err == nil {
+		t.Fatal("decode invalid payload: want error")
+	}
+	// 空段落由 decode 正常返回空切片，守卫在 transcribe 层（避免写出空字幕）。
+	segments, _, err := decodeWhisperVerboseJSON([]byte(`{"text":"","segments":[]}`))
+	if err != nil {
+		t.Fatalf("decode empty segments: unexpected error %v", err)
+	}
+	if len(segments) != 0 {
+		t.Fatalf("decode empty segments: got %d, want 0", len(segments))
+	}
+}
+
+func TestFormatSRTTimestamp(t *testing.T) {
+	cases := []struct {
+		ms   int64
+		want string
+	}{
+		{0, "00:00:00,000"},
+		{2015, "00:00:02,015"},
+		{61001, "00:01:01,001"},
+		{3661001, "01:01:01,001"},
+		{-5, "00:00:00,000"},
+	}
+	for _, c := range cases {
+		if got := formatSRTTimestamp(c.ms); got != c.want {
+			t.Fatalf("formatSRTTimestamp(%d) = %q, want %q", c.ms, got, c.want)
+		}
+	}
+}
+
+func TestBuildTimelineSRT(t *testing.T) {
+	segments := []timelineTranscriptionSegment{
+		{StartMs: 0, EndMs: 2015, Text: "大家好"},
+		{StartMs: 2500, EndMs: 6121, Text: "今天天气不错"},
+	}
+	srt := buildTimelineSRT(segments)
+	want := "1\n00:00:00,000 --> 00:00:02,015\n大家好\n\n2\n00:00:02,500 --> 00:00:06,121\n今天天气不错\n\n"
+	if srt != want {
+		t.Fatalf("srt mismatch:\n got %q\nwant %q", srt, want)
+	}
+}
+
+func TestExtForMimeAndTranscribable(t *testing.T) {
+	transcribable := []string{"video/mp4", "audio/wav", "audio/mpeg", "video/webm", "audio/flac", "video/quicktime", "audio/aac", "audio/ogg"}
+	for _, mime := range transcribable {
+		if !isTranscribableMime(mime) {
+			t.Fatalf("isTranscribableMime(%q) = false, want true", mime)
+		}
+		if strings.TrimPrefix(extForMime(mime), ".") == "bin" {
+			t.Fatalf("extForMime(%q) fell back to .bin", mime)
+		}
+	}
+	for _, mime := range []string{"image/png", "text/plain", ""} {
+		if isTranscribableMime(mime) {
+			t.Fatalf("isTranscribableMime(%q) = true, want false", mime)
+		}
+	}
+}
diff --git a/backend/internal/service/upload_quota.go b/backend/internal/service/upload_quota.go
index daa7114c5..6fe710bc6 100644
--- a/backend/internal/service/upload_quota.go
+++ b/backend/internal/service/upload_quota.go
@@ -18,6 +18,16 @@ func (s *Service) reserveUserUploadQuota(userID string, size int64) (string, err
 	return s.reserveUserStoredFileQuota(userID, size, megabytes(policy.Resource.ResourceUploadMB), megabytes(policy.Resource.DailyUploadMB), gigabytes(policy.Resource.StoredFileGB), fmt.Sprintf("单个上传文件必须小于 %dMB", policy.Resource.ResourceUploadMB))
 }
 
+// reserveChunkedUploadQuota 用于分片上传完成时预留额度：单文件上限对分片会话不适用（每片已独立校验），
+// 仅受“今日上传”与“账号存储总量”约束；singleFileLimit 传 size+1 使单文件上限永不命中。
+func (s *Service) reserveChunkedUploadQuota(userID string, size int64) (string, error) {
+	policy, err := s.RuntimePolicy()
+	if err != nil {
+		return "", err
+	}
+	return s.reserveUserStoredFileQuota(userID, size, size+1, megabytes(policy.Resource.DailyUploadMB), gigabytes(policy.Resource.StoredFileGB), "")
+}
+
 func (s *Service) reserveSessionUploadQuota(userID string, size int64) (string, error) {
 	policy, err := s.RuntimePolicy()
 	if err != nil {
diff --git a/backend/internal/service/upload_quota_test.go b/backend/internal/service/upload_quota_test.go
index 52a2e2178..35ea64281 100644
--- a/backend/internal/service/upload_quota_test.go
+++ b/backend/internal/service/upload_quota_test.go
@@ -17,12 +17,15 @@ func TestReserveUserUploadQuotaRejectsSingleFileAtLimit(t *testing.T) {
 
 func TestReserveUserUploadQuotaRejectsDailyTotalAtLimit(t *testing.T) {
 	svc := newResourceTestService(t)
-	for range 4 {
-		if _, err := svc.reserveUserUploadQuota("user-1", 49<<20); err != nil {
+	daily := megabytes(defaultRuntimePolicy().Resource.DailyUploadMB)
+	chunk := int64(49 << 20)
+	for used := int64(0); used+chunk <= daily; used += chunk {
+		if _, err := svc.reserveUserUploadQuota("user-1", chunk); err != nil {
 			t.Fatal(err)
 		}
 	}
-	if _, err := svc.reserveUserUploadQuota("user-1", 4<<20); err == nil || !strings.Contains(err.Error(), "小于 200MB") {
+	// 单文件限(50MB)未命中、今日额度已满 → 拒绝并提示每日上限。
+	if _, err := svc.reserveUserUploadQuota("user-1", chunk); err == nil || !strings.Contains(err.Error(), "小于 2GB") {
 		t.Fatalf("reserveUserUploadQuota() error = %v", err)
 	}
 }
@@ -63,8 +66,7 @@ func TestReserveUserUploadQuotaRejectsTotalStoredFilesAtLimit(t *testing.T) {
 	if err := svc.repo.Create(&model.Resource{ID: "resource-1", UserID: "user-1", Status: model.ResourceStatusReady, Size: gigabytes(defaultRuntimePolicy().Resource.StoredFileGB) - 1}); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := svc.reserveUserUploadQuota("user-1", 1); err == nil || !strings.Contains(err.Error(), "2GB 上限") {
-		t.Fatalf("reserveUserUploadQuota() error = %v", err)
+	if _, err := svc.reserveUserUploadQuota("user-1", 1); err == nil || !strings.Contains(err.Error(), "20GB 上限") {
 	}
 }
 
diff --git a/backend/internal/service/video_transcode.go b/backend/internal/service/video_transcode.go
new file mode 100644
index 000000000..85e2cabca
--- /dev/null
+++ b/backend/internal/service/video_transcode.go
@@ -0,0 +1,314 @@
+package service
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"errors"
+	"strings"
+
+	"infinite-canvas/backend/internal/model"
+)
+
+// 播放副本转码：HEVC/H.265 原片在 Chrome/Firefox 等无法解码（<video> 黑屏），
+// 上传就绪后若探测到 hvc1/hev1 且本机可用 ffmpeg，则异步转 H.264/AAC 到本地
+// playback 目录，供 file 端点 variant=playback 读取。转码只作用于本地原件；
+// OSS 原件不转码（避免每次上传拉取远端）。
+
+// ErrPlaybackNotReady 表示资源没有可用的浏览器兼容播放副本（未转码/转码中/失败），
+// file 端点应回退 serve 原件。
+var ErrPlaybackNotReady = errors.New("播放副本尚未就绪")
+
+const (
+	playbackDirName  = "playback"
+	videoCodecH264   = "h264"
+	videoCodecH265   = "h265"
+	videoCodecAV1    = "av1"
+	videoCodecVP9    = "vp9"
+	videoCodecMPEG4  = "mpeg4"
+	probeMaxMoovSize = 128 << 20
+)
+
+// probeVideoCodec 解析本地 mp4 的 stsd 首个视频 sample entry fourcc，返回 h264/h265 等。
+// 非 mp4 容器或解析失败返回空串（调用方按“无需转码”处理，前端仍可用原件）。
+func probeVideoCodec(path string) string {
+	f, err := os.Open(path)
+	if err != nil {
+		return ""
+	}
+	defer f.Close()
+
+	// 顶层 box 遍历（跳过 mdat 数据体），定位 moov。
+	var moovSize int64
+	var moovData []byte
+	pos := int64(0)
+	for {
+		boxType, size, err := readMP4BoxHeaderAt(f, pos)
+		if err != nil {
+			return ""
+		}
+		switch boxType {
+		case "moov":
+			if size > probeMaxMoovSize {
+				return ""
+			}
+			moovData = make([]byte, size-8)
+			if _, err := f.ReadAt(moovData, pos+8); err != nil {
+				return ""
+			}
+			moovSize = size
+		}
+		pos += size
+		if moovSize != 0 {
+			break
+		}
+		if size < 8 {
+			return ""
+		}
+	}
+	return codecFromMoov(moovData)
+}
+
+// readMP4BoxHeaderAt 定位文件 pos 处的 box（8/16 字节头），返回类型与总大小。
+func readMP4BoxHeaderAt(r io.ReaderAt, pos int64) (string, int64, error) {
+	var hdr [16]byte
+	if _, err := r.ReadAt(hdr[:8], pos); err != nil {
+		return "", 0, err
+	}
+	size := int64(binary.BigEndian.Uint32(hdr[:4]))
+	boxType := string(hdr[4:8])
+	if size == 1 {
+		if _, err := r.ReadAt(hdr[8:16], pos+8); err != nil {
+			return "", 0, err
+		}
+		size = int64(binary.BigEndian.Uint64(hdr[8:16]))
+	}
+	if size < 8 {
+		return "", 0, fmt.Errorf("invalid box size %d", size)
+	}
+	return boxType, size, nil
+}
+
+// codecFromMoov 在 moov 子树中找出所有 stsd，取首个视频 sample entry fourcc。
+func codecFromMoov(moov []byte) string {
+	for _, stsdBody := range boxBodies(moov, "stsd") {
+		// stsd = fullbox(4) + entry_count(4) + entries…
+		// 首个 sample entry：entry_size(4) + fourcc(4) → fourcc 在 body+12。
+		if stsdBody+16 > len(moov) {
+			continue
+		}
+		fourcc := string(moov[stsdBody+12 : stsdBody+16])
+		switch fourcc {
+		case "avc1":
+			return videoCodecH264
+		case "hvc1", "hev1":
+			return videoCodecH265
+		case "av01":
+			return videoCodecAV1
+		case "vp09":
+			return videoCodecVP9
+		case "mp4v":
+			return videoCodecMPEG4
+		}
+	}
+	return ""
+}
+
+// boxBodies 在 data 中递归查找类型为 want 的 box，返回其 body 起始偏移。
+// 只下钻容器 box（moov/trak/mdia/minf/stbl），避免误入 sample entry 内部。
+func boxBodies(data []byte, want string) []int {
+	var out []int
+	var walk func(start, end int)
+	walk = func(start, end int) {
+		pos := start
+		for pos+8 <= end {
+			size := int(binary.BigEndian.Uint32(data[pos : pos+4]))
+			boxType := string(data[pos+4 : pos+8])
+			hdr := 8
+			if size == 1 {
+				if pos+16 > end {
+					return
+				}
+				size = int(binary.BigEndian.Uint64(data[pos+8 : pos+16]))
+				hdr = 16
+			}
+			if size < 8 || pos+size > end {
+				return
+			}
+			if boxType == want {
+				out = append(out, pos+hdr)
+			}
+			switch boxType {
+			case "moov", "trak", "mdia", "minf", "stbl":
+				walk(pos+hdr, pos+size)
+			}
+			pos += size
+		}
+	}
+	walk(0, len(data))
+	return out
+}
+
+// maybeStartPlaybackTranscode 由上传就绪路径调用；H.265 且 ffmpeg 可用时置
+// processing 并异步转码。H.264 直接标记 none，避免每次上传重复探测。
+func (s *Service) maybeStartPlaybackTranscode(resource *model.Resource) {
+	if resource == nil || resource.Kind != "video" {
+		return
+	}
+	// 远端存储（OSS 等）不落本地副本：标 none 表示无需转码，前端按原生播放/直链处理，
+	// 避免状态留空被当成 processing 无限轮询（markPlaybackNone 幂等）。
+	if resource.Provider != "local" || resource.Status != model.ResourceStatusReady {
+		if resource.Provider != "local" {
+			markPlaybackNone(s, resource)
+		}
+		return
+	}
+	if resource.PlaybackStatus != "" && resource.PlaybackStatus != model.PlaybackStatusNone {
+		return
+	}
+	// 不可转码场景（无 ffmpeg）落 none：状态为空会被前端当成 processing 无限轮询，
+	// 也会让启动回填每次重试探测。none 表示"无需转码"，按原生播放处理。
+	if _, err := exec.LookPath("ffmpeg"); err != nil {
+		markPlaybackNone(s, resource)
+		return
+	}
+	src := filepath.Join(s.dataDir, "resources", filepath.FromSlash(resource.ObjectKey))
+	switch probeVideoCodec(src) {
+	case videoCodecH265:
+		// 原子抢占（空/none → processing）：并发上传 + 回填、多实例同抢时
+		// 仅一个能成功置位，其余直接返回，避免重复转码。
+		claimed, err := s.repo.ClaimPlaybackTranscode(resource.ID)
+		if err != nil || !claimed {
+			return
+		}
+		resource.PlaybackStatus = model.PlaybackStatusProcessing
+		go s.runPlaybackTranscode(resource.UserID, resource.ID, src)
+	case videoCodecH264, videoCodecAV1, videoCodecVP9, videoCodecMPEG4, "":
+		// H.264 浏览器可直接解码；AV1/VP9/MPEG4 暂不转码；探针读不出编码（非 mp4 /
+		// moov 在尾部 / 加密容器）也无法处理 —— 均标 none，避免重复探测与前端无限轮询。
+		markPlaybackNone(s, resource)
+	}
+}
+
+// markPlaybackNone 将资源标记为无需播放副本（幂等，写失败不影响上传主流程）。
+func markPlaybackNone(s *Service, resource *model.Resource) {
+	if resource.PlaybackStatus == model.PlaybackStatusNone {
+		return
+	}
+	resource.PlaybackStatus = model.PlaybackStatusNone
+	_ = s.repo.SaveResource(resource)
+}
+
+// runPlaybackTranscode 转码本地原件到 playback/<id>.mp4 并回写状态（幂等按 id 重载）。
+func (s *Service) runPlaybackTranscode(userID string, resourceID string, src string) {
+	// 转码 goroutine 意外 panic 时把状态落 failed，避免 processing 卡死到下次重启。
+	defer func() {
+		if r := recover(); r != nil {
+			if res, err := s.repo.ResourceForUser(userID, resourceID); err == nil && res != nil {
+				res.PlaybackStatus = model.PlaybackStatusFailed
+				res.PlaybackError = clipText(fmt.Sprintf("转码 panic：%v", r), 1000)
+				_ = s.repo.SaveResource(res)
+			}
+		}
+	}()
+	status := model.PlaybackStatusFailed
+	objectKey := ""
+	var errText string
+	dst := filepath.Join(s.dataDir, playbackDirName, resourceID+".mp4")
+	// 副本已存在且为 H.264（上次转码完成但回写随进程崩溃丢失）：直接置 ready 不重转。
+	if probeVideoCodec(dst) == videoCodecH264 {
+		status = model.PlaybackStatusReady
+		objectKey = resourceID + ".mp4"
+	} else if err := runH264Transcode(src, dst); err != nil {
+		errText = clipText(err.Error(), 1000)
+	} else {
+		status = model.PlaybackStatusReady
+		objectKey = resourceID + ".mp4"
+	}
+	res, err := s.repo.ResourceForUser(userID, resourceID)
+	if err != nil || res == nil {
+		return
+	}
+	res.PlaybackStatus = status
+	res.PlaybackObjectKey = objectKey
+	res.PlaybackError = errText
+	_ = s.repo.SaveResource(res)
+}
+
+// runH264Transcode 用 ffmpeg 将任意输入转为 H.264/AAC mp4（faststart、yuv420p、偶数尺寸）。
+func runH264Transcode(src string, dst string) error {
+	if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
+		return err
+	}
+	cmd := exec.Command("ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+		"-i", src,
+		"-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
+		"-pix_fmt", "yuv420p", "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+		"-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart",
+		dst)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		msg := strings.TrimSpace(stderr.String())
+		if msg == "" {
+			msg = err.Error()
+		}
+		return fmt.Errorf("ffmpeg 转码失败：%s", clipText(msg, 800))
+	}
+	return nil
+}
+
+func clipText(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max]
+}
+
+// OpenResourcePlaybackRange 打开浏览器兼容播放副本（本地 ffmpeg 转码的 H.264）。
+// 仅当资源为本地存储且副本 ready 时可用；否则返回 ErrPlaybackNotReady，调用方回退原件。
+func (s *Service) OpenResourcePlaybackRange(userID string, resourceID string) (*ResourceStream, error) {
+	resource, err := s.repo.ResourceForUser(userID, resourceID)
+	if err != nil {
+		return nil, err
+	}
+	if resource == nil || resource.Status != model.ResourceStatusReady || resource.Provider != "local" ||
+		resource.PlaybackStatus != model.PlaybackStatusReady || resource.PlaybackObjectKey == "" {
+		return nil, ErrPlaybackNotReady
+	}
+	body, err := os.Open(filepath.Join(s.dataDir, playbackDirName, filepath.FromSlash(resource.PlaybackObjectKey)))
+	if err != nil {
+		return nil, err
+	}
+	playback := *resource
+	playback.MimeType = "video/mp4"
+	playback.ObjectKey = filepath.Join(playbackDirName, resource.PlaybackObjectKey)
+	size := int64(0)
+	if st, err := body.Stat(); err == nil {
+		size = st.Size()
+	}
+	return &ResourceStream{Resource: &playback, Body: body, StatusCode: http.StatusOK, ContentLength: size, AcceptRanges: "bytes"}, nil
+}
+
+// BackfillPlaybackTranscodes 在服务启动后扫描存量本地视频：未判定 codec 的补判定，
+// H.265 触发转码、H.264 标记 none。幂等：maybeStartPlaybackTranscode 先置
+// processing/none 再入库，重复扫描不会重复转码。
+func (s *Service) BackfillPlaybackTranscodes() {
+	// 上次进程可能崩溃在转码中途（状态卡 processing），先重置为待判定。
+	_ = s.repo.ResetStuckPlaybackTranscodes()
+	for {
+		resources, err := s.repo.PlaybackPendingVideos(20)
+		if err != nil || len(resources) == 0 {
+			return
+		}
+		for i := range resources {
+			s.maybeStartPlaybackTranscode(&resources[i])
+		}
+	}
+}
diff --git a/backend/internal/service/video_transcode_test.go b/backend/internal/service/video_transcode_test.go
new file mode 100644
index 000000000..38581eb33
--- /dev/null
+++ b/backend/internal/service/video_transcode_test.go
@@ -0,0 +1,65 @@
+package service
+
+import (
+	"encoding/binary"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// stsdBox 构造仅含 first-sample-entry fourcc 的最小 stsd box（置于 moov 切片内）。
+func stsdBoxWithFourcc(fourcc string) []byte {
+	b := make([]byte, 24)
+	binary.BigEndian.PutUint32(b[0:4], 24)
+	copy(b[4:8], "stsd")
+	// body: version/flags(4) + entry_count(4)=1 + entry_size(4) + fourcc(4)
+	binary.BigEndian.PutUint32(b[12:16], 1)
+	binary.BigEndian.PutUint32(b[16:20], 8)
+	copy(b[20:24], fourcc)
+	return b
+}
+
+func TestCodecFromMoov(t *testing.T) {
+	cases := []struct {
+		fourcc string
+		want   string
+	}{
+		{"hvc1", videoCodecH265},
+		{"hev1", videoCodecH265},
+		{"avc1", videoCodecH264},
+		{"av01", videoCodecAV1},
+		{"vp09", videoCodecVP9},
+	}
+	for _, c := range cases {
+		if got := codecFromMoov(stsdBoxWithFourcc(c.fourcc)); got != c.want {
+			t.Errorf("codecFromMoov(%s) = %q, want %q", c.fourcc, got, c.want)
+		}
+	}
+	if got := codecFromMoov([]byte{0, 1, 2, 3}); got != "" {
+		t.Errorf("garbage moov codec = %q, want empty", got)
+	}
+}
+
+func TestProbeVideoCodecReadsRealFile(t *testing.T) {
+	// 构造 ftyp + moov(含 hvc1 stsd) 的最小 mp4 文件，验证 probeVideoCodec 走文件读取路径。
+	stsd := stsdBoxWithFourcc("hvc1")
+	moov := make([]byte, 8+len(stsd))
+	binary.BigEndian.PutUint32(moov[0:4], uint32(len(moov)))
+	copy(moov[4:8], "moov")
+	copy(moov[8:], stsd)
+	full := make([]byte, 0, 16+len(moov))
+	ftyp := make([]byte, 16)
+	binary.BigEndian.PutUint32(ftyp[0:4], 16)
+	copy(ftyp[4:8], "ftyp")
+	copy(ftyp[8:12], "isom")
+	full = append(full, ftyp...)
+	full = append(full, moov...)
+
+	path := filepath.Join(t.TempDir(), "clip.mp4")
+	if err := os.WriteFile(path, full, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := probeVideoCodec(path); got != videoCodecH265 {
+		t.Errorf("probeVideoCodec = %q, want h265", got)
+	}
+}
diff --git a/docs/adr/0001-editor-integration-boundary.md b/docs/adr/0001-editor-integration-boundary.md
new file mode 100644
index 000000000..7e3e3a1d6
--- /dev/null
+++ b/docs/adr/0001-editor-integration-boundary.md
@@ -0,0 +1,34 @@
+# ADR-0001: 编辑器整合以 TS 时间线状态机为真相源，不移植 Concat 的 Rust 引擎
+
+状态：已接受。日期：2026-09-01。来源：借鉴 Concat（WolfCut）编辑器能力整合决策。
+
+> 更新记录（2026-09-01）：采纳 ADR-0005 后，编辑器 UI 与能力出口改为预设插件贡献（详见 ADR-0005）；本 ADR 聚焦的边界因此收窄为：核心状态机仍是宿主 TS 库，但不再是编辑器的一切。
+
+## 背景
+
+Concat（WolfCut）的核心架构原则是"引擎拥有项目模型"（engine doctrine）：Rust 引擎持有时间线模型、全部编辑命令（`commands.rs`）、撤销栈、渲染与导出路径、文档格式（wolfcut.json）；Tauri host 只是管道，UI 只渲染状态并派发命令。这一形态依赖本地文件系统、ffmpeg 子进程和 GPU 组合器，与其桌面产品定位绑定。
+
+影策是 Web 应用（React 19 + Go 后端 + Node canvas-agent），画布节点模型以 TS 状态机为真相源（localforage user-scope + 后端项目接口持久化）。时间线已有第一期字幕数据落地与第二期类型（`TimelineProject` v2，含轨道/片段/directMedia），第三期规划了 ffmpeg 导出（`timeline-to-ffmpeg.ts` 纯函数规划层已存在）。后端 Go 目前不执行 ffmpeg。
+
+## 决策
+
+借鉴 Concat 的架构**形态**，不移植其**实现**：把"引擎拥有模型"翻译为"TS 时间线状态机拥有编辑真相"。
+
+- 时间线编辑逻辑集中在 `web/src/lib/timeline/`（在现有 build/placement/snap/to-ffmpeg 基础上新增 editor 状态机），UI 组件只渲染状态并派发命令，不直接改写模型。
+- 编辑器**UI 与能力出口全部为预设插件贡献**（时间线面板、预览、检查器、转写、导出、字幕工具），核心状态机是插件依赖的宿主协议而非编辑器的一切（见 ADR-0005）。
+- 不移植 wolfcut crates、不引入 WASM 版引擎、不引入 Tauri/Electron 壳。
+- 媒体重活（转码、导出合成、转写）交给 Go 后端任务队列，浏览器 ffmpeg.wasm 保留为降级路径，两者由同一份滤镜图计划驱动（见 ADR-0003）。
+
+## 考虑过的方案
+
+- **移植/包装 Rust 引擎（wasm32 / 子进程）**：引擎与画布节点模型、localforage 缓存、浏览器预览路径同构成本高，会产生"引擎真相 + 画布真相"双真相源；否决。
+- **引入现成 Web 视频编辑器库（Remotion/Editly 等）**：Remotion 是 React 声明式渲染框架而非交互式多轨编辑器，现成编辑器与画布→时间线的 AI 工作流（节点资产入轨、字幕一期能力）耦合成本高于自建；否决。
+- **TS 端自建状态机（选定）**：与现有 `timeline.ts` v2、`timeline-build`/`timeline-placement` 等纯函数层一脉相承，可直接复用字幕与导出规划能力。
+
+## 后果
+
+- 撤销、自动保存、命令协议由 TS 端承担，责任随 Concat 的引擎移动到了前端库层；需要用类型与测试约束（见 ADR-0002）。
+- 不复制 Concat 的 chains mirror 债务（TS 手写镜像 Rust 滤镜串）：滤镜参数只允许单一来源（见 ADR-0003）。
+- ffmpeg 执行位置（浏览器 wasm / 后端任务）保持可切换，切换不改变编辑模型与导出参数。
+- 编辑器面板（时间线/预览/右侧检查器）复用 `docs/design/workspace-shell-design.mdx` 的设计 token 与三段式布局，不引入新设计体系。
+- 新增编辑器能力由预设插件承担（ADR-0005）：核心库冻结，只演进命令协议、滤镜图计划与任务协议。
diff --git a/docs/adr/0002-edit-command-protocol.md b/docs/adr/0002-edit-command-protocol.md
new file mode 100644
index 000000000..2c9585487
--- /dev/null
+++ b/docs/adr/0002-edit-command-protocol.md
@@ -0,0 +1,28 @@
+# ADR-0002: 时间线编辑采用可序列化命令 + 有界快照撤销
+
+状态：已接受。日期：2026-09-01。来源：借鉴 Concat 编辑循环与撤销/自动保存设计。
+
+> 更新记录（2026-09-01）：采纳 ADR-0005 后，命令 handler 可经插件注册（时间线工具/效果插件贡献自定义 op），但命令队列、echo、撤销与保存仍是宿主核心；插件不得绕过命令协议改模型。
+
+## 背景
+
+Concat 的编辑循环：UI 把命令推入单队列 → 引擎 `editor.apply(command)` 返回全量视图 → UI 重渲染。拖拽用本地 echo 预演位置，手势结束才提交**一个**命令，撤销粒度是手势而非像素；撤销栈是有界完整克隆（200 层）；自动保存 1.5 秒防抖 + 临时文件原子改名。Concat 自述的教训：撤销/重做失败被吞错（§6.4）、重做栈无上限（§6.3）。
+
+影策现有画布数据走 localforage（user-scope）+ 后端项目接口；时间线一期已落地字幕数据，二期按 `TimelineProject` v2 持久化轨道/片段。
+
+## 决策
+
+- 时间线唯一修改入口是**可序列化编辑命令** `{ op, payload }`，经单队列顺序应用到 TS 状态机，每次 apply 返回新的 `TimelineProject` 作为唯一真相；任何 UI 代码不得直接改写模型。
+- **命令 handler 可插件化注册**：预设插件（时间线工具、效果、字幕工具）通过宿主 API 贡献自定义 op 及其 reducer/handler；宿主负责校验权限（ADR-0005）后入队执行，插件不持有队列与撤销栈。
+- 拖拽/裁剪/变速等手势采用 **echo**：本地预演位置与效果，`release`/手势结束提交一个命令。
+- 撤销栈为**有界完整快照**（上限 200 层，与 Concat 一致），重做栈同样限界。
+- 保存沿用项目保存链路：localforage user-scope + 后端项目接口，防抖 1.5 秒，写失败必须上报，不吞错、不静默降级。
+- 编辑命令对象序列化形式即对外协议：画布 Agent、未来多端协作通过命令日志同步，不经由此协议不得改动时间线。
+
+## 后果
+
+- 快照撤销简单可靠，但内存随项目规模线性增长：快照只存结构化模型，媒体大对象一律以 `directMedia` 引用/存储 key 入快照，不复制二进制。
+- 命令队列天然支持幂等重放，为服务端协同与测试（命令黄金文件）留出路径。
+- 撤销粒度是手势：移动/裁剪一整段是一次撤销，不提供逐帧回退。
+- 与 Concat 不同，命令执行、撤销、自动保存都发生在浏览器进程，无跨进程边界；同步失败的兜底是本地缓存 + 明确的状态标识，不能冒充服务端已保存（遵循 AGENTS.md 写路径约定）。
+- 插件贡献的命令 handler 必须保持纯函数、可序列化、可重放：撤销快照与命令黄金文件对插件命令同样生效，插件不能依赖组件实例状态。
diff --git a/docs/adr/0003-preview-export-layering.md b/docs/adr/0003-preview-export-layering.md
new file mode 100644
index 000000000..920137406
--- /dev/null
+++ b/docs/adr/0003-preview-export-layering.md
@@ -0,0 +1,27 @@
+# ADR-0003: 预览与导出分层——交互近似预览 + 单一滤镜图计划
+
+状态：已接受。日期：2026-09-01。来源：借鉴 Concat 预览近似与导出降级设计。
+
+> 更新记录（2026-09-01）：采纳 ADR-0005 后，预览渲染器与导出渲染器成为插件贡献点（`registerPreviewRenderer` / `registerExportRenderer`）；单一滤镜图计划约束不变，对插件同样强制。
+
+## 背景
+
+Concat 的预览近似层：交互期间用 CSS 滤镜 / canvas 运算渲染近似效果，监视器播放引擎真帧；其原则是"导出只是你已看到内容的更高画质版本"。转场在导出器降级（交叉淡化 → 重叠片段 + 透明度斜坡）。Concat 自述的最大债务是 chains mirror（§6.1）：TS 手写镜像 Rust 滤镜链，两侧靠钉死测试维持一致，新增效果成本翻倍。
+
+影策已有 `timeline-to-ffmpeg.ts` 纯函数规划层（trim → gap → concat → subtitle → burn），`timeline-export.ts` 用浏览器 ffmpeg.wasm 执行；后端 Go 暂无 ffmpeg。
+
+## 决策
+
+- **交互预览只做浏览器原生近似**：`<video>` 裁剪/缩放/透明度/音量、CSS 滤镜、canvas 合成近似。近似预览是交互真相，但不是导出像素；UI 上不把两者混为一谈。
+- **预览渲染器与导出渲染器为插件贡献点**：预设插件（如转场/滤镜效果插件）通过 `registerPreviewRenderer` / `registerExportRenderer` 贡献渲染实现；宿主按插槽渲染，插件不得绕过插槽直接挂载 DOM。
+- **单一滤镜图计划对插件强制生效**：插件贡献的导出渲染必须消费 `buildTimelineRenderPlan` 的输出参数，禁止插件内部自行拼第二套滤镜串（无论多简单）。
+- **导出滤镜图只由 `buildTimelineRenderPlan` 单一模块生成**：这是滤镜串的唯一来源。主路径为 Go 后端 ffmpeg 任务（复用任务队列），浏览器 ffmpeg.wasm 为降级路径，二者吃同一份计划。
+- **新增效果必须同时产出两份描述，且出自同一参数模型**：`预览近似描述`（CSS/canvas 等价实现）与 `导出滤镜参数`（ffmpeg filtergraph 片段）。禁止在 UI 组件里手写第二套滤镜串——即不复制 Concat 的 chains mirror 债务。
+- 转场、滤镜等视觉允许预览与导出存在级差（如预览用近似淡化、导出用 xfade/淡入淡出），但参数必须同源，不允许出现"预览一套、导出另一套"的漂移。
+
+## 后果
+
+- 滤镜参数模型成为编辑器和导出共用的契约：新增效果 = 参数模型 + 两份降级实现，测试围绕参数模型做黄金文件。
+- 预览与导出管线各自可演进：服务端派生"预览近似描述"（Concat 式 engine emits preview looks）时，无需改 UI 消费方式。
+- 浏览器 wasm 与后端 ffmpeg 的切换不改变编辑模型；wasm 仅承担无后端场景下的降级导出。
+- 渲染器插件化后，新增效果仍是「参数模型 + 预览近似 + 导出滤镜」三件套，只是后两者的实现方变为插件；参数模型仍是黄金文件测试的唯一锚点，防止插件间出现参数漂移。
diff --git a/docs/adr/0004-autocaption-transcription-service.md b/docs/adr/0004-autocaption-transcription-service.md
new file mode 100644
index 000000000..0303465e5
--- /dev/null
+++ b/docs/adr/0004-autocaption-transcription-service.md
@@ -0,0 +1,27 @@
+# ADR-0004: 自动字幕转写作为后端服务任务
+
+状态：已接受。日期：2026-09-01。来源：借鉴 Concat 转写命令集与模型管理设计。
+
+> 更新记录（2026-09-01）：采纳 ADR-0005 后，转写提供者为插件贡献点（`registerTranscriptionProvider`），转写面板为预设插件；后端任务与配额协议不变。
+
+## 背景
+
+Concat 的招牌智能功能之一是自动字幕：以 7 个转写命令（转写片段、取消、状态等）驱动本地 whisper 模型，模型文件按需下载并管理。其前提是桌面应用可在本地跑模型与 ffmpeg。
+
+影策是服务端应用：模型渠道统一经后端中转（`custom-channel-relay` 的 `/api/ai/custom`），任务走任务队列与配额体系；素材已服务端化；时间线一期已有字幕数据与 SRT 解析/切分能力（`srt-parser`、`srt-resegment`），字幕轨道已是 `TimelineProject` v2 的一等轨道类型。
+
+## 决策
+
+- 转写由 **Go 后端执行**（whisper.cpp 或服务化 ASR 作为后端任务），前端只提交"素材/片段 → 转写字幕"任务并展示进度，不直接调用模型。
+- **转写提供者为插件贡献点**：预设插件经 `registerTranscriptionProvider` 声明前端可用的转写能力与 UI（如自动字幕面板、字幕工具），经宿主校验权限后调用后端任务；第三方插件可扩展新转写来源，但必须走同一任务协议。
+- 转写结果以 SRT 形式写回时间线字幕轨道，复用一期 SRT 解析与按句/按词切分能力；前端可预览、编辑、重新转写。
+- **不在浏览器运行 whisper**：模型体积、算力与移动端/低端设备不可控，且与既有"模型渠道走后端中转"的安全边界一致。
+- 转写任务复用任务队列与配额体系；ASR 引擎可插拔（本地进程 / 云 ASR），后端服务内部切换，前端协议不变。
+- TTS/配音等**生成式**语音能力走既有模型渠道（生成素材），与转写（分析已有素材）互不耦合，不在本决策范围内。
+
+## 后果
+
+- 转写是异步任务而非即时命令：前端需要任务状态展示（进行中/成功/失败），失败可重试，重试不重复扣配额。
+- 字幕轨道成为时间线一等公民：转写、人工编辑、导出烧录（ADR-0003 的 burn 步骤）共享同一字幕数据源。
+- 模型权重与算力要求后端可插拔部署：本地 whisper.cpp 省成本、云 ASR 省运维，两者共用同一个任务协议。
+- 前端转写能力集合随插件而变：默认预设提供 whisper 服务转写；第三方插件可增加转写来源，前端任务协议与字幕轨道数据形状保持稳定。
diff --git a/docs/adr/0005-editor-preset-plugin-architecture.md b/docs/adr/0005-editor-preset-plugin-architecture.md
new file mode 100644
index 000000000..45c733068
--- /dev/null
+++ b/docs/adr/0005-editor-preset-plugin-architecture.md
@@ -0,0 +1,40 @@
+# ADR-0005: 编辑器预设插件架构——参考 astravia「万物皆可插件」改造
+
+状态：已接受。日期：2026-09-01。来源：参考 astravia（`astravia`）插件体系理念，改造编辑器插件化。
+
+## 背景
+
+**astravia 的「万物皆可插件」理念**：所有能力（含界面）都是插件贡献，宿主核心只保留最小骨架。其实现要点：
+
+- **统一插件形态**：`definePlugin` SDK + `plugin.json` 清单 + Module Federation 打包（`vettaPluginFederation`）；react/react-dom/SDK/主题 token 由宿主作为共享单例 external 化，插件不自带运行时。
+- **系统插件（presets）与用户插件同构**：内置功能与第三方插件用**同一套 SDK 与清单**，仅分发方式（随 App 发布 vs zip 安装）与权限语义（系统插件自动全量授予且不可删改 vs 用户插件安装时逐项授予）不同。
+- **UI 插槽**：workspace view、global slot、file preview、activity tab、input action、tool call slot、shortcut scope 等均为注册式插槽，内置界面与插件界面平等占位。
+- **权限执行**：清单声明 + 宿主在 API 调用点校验（fail-closed / warn+noop / 抛错三档），未声明即不可见不可用。
+- **能力贡献**：capability-runtime（hub/provider/registry/access）+ capability-sdk，插件以 provider 身份注册能力。
+
+**影策现状（改造对象）**：现有 `yingce.plugin/v1`（`web/src/lib/plugins/`）只有**画布域**贡献（provider / workflow / canvas-node / transform / asset-source 等），存在结构性缺口：无 UI 插槽注册 API（surfaces 只是声明字段）、无编辑器任何贡献类型（时间线/预览/导出/转写没有插件入口）、无预设（系统）插件分发语义、内置插件是 `builtin/` 源码硬编码 import、权限只有清单字符串无宿主执行校验。对"编辑器插件化"这一目标不可直接支撑（即现状"不可理"之处）。
+
+## 决策
+
+- **编辑器全部 UI 与能力以插件贡献形态存在**，作为**预设插件（preset plugins）**随产品发布：时间线面板、预览监视器、右侧检查器、素材入轨、自动字幕（转写）面板、导出面板、字幕工具均为预设插件；默认启用、用户可停用、不可卸载删改，权限自动授予。
+- **现有插件体系演进为 v2 形态（`yingce.plugin/v2`），补齐 astravia 式机制，editor 域作为首个完整消费方**：
+  - 新增**UI 插槽注册 API**：`registerTimelinePanel` / `registerPreviewRenderer` / `registerExportRenderer` / `registerTranscriptionProvider` / `registerSubtitleTool` / `registerShortcutScope` 等；宿主按插槽渲染注册表，内置与第三方插件平等占位。
+  - 新增**预设插件分发语义**：preset 插件随应用代码分发（沿用 `builtin/` 目录、语义化为 `builtin/editor/` 预设），与用户插件同清单同 SDK，仅权限/可删改性不同。
+  - 新增**权限执行校验**：编辑命令、转写任务、导出任务、资源读取等宿主 API 调用点按清单校验，fail-closed；未声明不得触发。
+  - 保持共享单例：react / react-dom / 时间线 SDK / 设计 token（`workspace-shell-design.mdx`）由宿主提供，插件不自带。
+- **宿主最小核心保持不变**：时间线状态机（ADR-0001）、编辑命令队列与撤销（ADR-0002）、滤镜图计划（ADR-0003）、任务与配额协议（ADR-0004）是核心骨架，插件只允许在这些协议之上贡献 UI 与 handler，不得绕过命令协议改模型。
+- 编辑器内置功能**不做特殊化**：迁入预设插件后与第三方插件走同一条贡献/校验/插槽路径，禁止在核心代码里写"编辑器专属硬编码分支"。
+
+## 考虑过的方案
+
+- **推倒重写插件体系**：现有 v1 已融入画布/生成/素材链路（application.tsx 静态注册 builtin、use-plugin-store 持久化启用态、后端 pluginStates），重写会破坏既有功能且无必要；否决，选择在同一代码库演进。
+- **编辑器独立自建面板，不做插件化**：违背"插件化做成预设插件"的产品方向，且重复造轮子；否决。
+- **照搬 astravia 包结构（SDK 独立包 + 独立市场）**：影策是单体 web 仓库，先以 v2 形态在 `web/src/lib/plugins/` 内演进，待出现真正的外部插件需求再抽 SDK/打包工具链；当前阶段预设插件足够。
+
+## 后果
+
+- 编辑器成为插件体系第一个完整闭环域：新增编辑器能力 = 写一个预设插件（清单 + 插槽贡献 + handler），不改宿主核心；宿主核心因插件而冻结，只演进协议。
+- `yingce.plugin/v1` 升级为 v2：v1 字段（贡献类型/权限声明）保留兼容，新增插槽与分发字段；旧画布插件无需迁移即可继续运行，新增字段可选。
+- 权限校验从"声明"变为"执行"：编辑器宿主 API 是第一个强制校验点，随后推广到画布/生成链路。
+- 与 astravia 的差距被显式承认：暂无外部插件安装/市场/沙箱，预设插件是当前全部范围；待需要时按 astravia 的 SDK/打包/租户选择机制补齐。
+- 插件数量与耦合风险：editor 预设插件按功能域拆分（面板/预览/导出/转写/字幕工具各一个），共享同一命令协议与滤镜图计划，避免插件间互相 import。
diff --git a/docs/adr/0006-voice-filters-and-templates.md b/docs/adr/0006-voice-filters-and-templates.md
new file mode 100644
index 000000000..7fddd44fe
--- /dev/null
+++ b/docs/adr/0006-voice-filters-and-templates.md
@@ -0,0 +1,53 @@
+# ADR-0006: 语音滤镜与项目模板——Concat 剩余缺口的补充决策
+
+状态：已接受。日期：2026-09-01。来源：Concat 编辑器功能覆盖对照中的两个明确缺口，评估后决定引入。
+
+## 背景
+
+功能覆盖对照（实现规格 §0.4）识别出 Concat 有两个影策方案未覆盖的功能：
+
+- **语音滤镜（Voice Filters）**：Concat 的招牌特色之一，对音频/人声做本地 DSP 处理（降噪、变声、均衡、回声等）。其前提是桌面应用可本地执行音频处理。
+- **模板（Templates）**：Concat 提供保存项目为模板（`SaveTemplateDialog`）、模板缩略图（`TemplateThumb`）与从模板新建的流程；模板中心仍在 roadmap。
+
+影策（Web + Go 服务端）此前将两者列为"明确不做"。本 ADR 评估引入方式，结论：**两者都引入，且必须走预设插件形态（ADR-0005），服从单一滤镜图计划约束（ADR-0003）**。
+
+## 决策
+
+### 语音滤镜：预设插件 `editor-audio-effects`
+
+- 新增 `audio-effects` 贡献类型与 `audio.process` 权限；插件注册音频效果（音量、淡入淡出、均衡、回声、降噪、变速变调）。
+- **预览近似走 Web Audio API**：`BiquadFilter` / `DynamicsCompressor` / `DelayNode` / `ConvolverNode` 等实时处理，交互真相，非导出像素。
+- **导出真相走 ffmpeg 音频滤镜**：`afftdn`（降噪）/ `equalizer` / `aecho` / `acompressor` / `asetrate`+`aresample`（变速变调）等，作为 `buildTimelineRenderPlan` 的 **audio steps** 纳入单一滤镜图计划。
+- **参数模型先行**：与视频滤镜同构——同一参数模型 + 预览/导出两份实现；渲染计划黄金文件（§7.2）增加音频夹具，禁止插件手写第二套滤镜串。
+- 首版只做基础集（音量、淡入淡出、均衡、回声、简单降噪）；变声等复杂 DSP 留作插件扩展点。
+
+### 模板：预设插件 `editor-template`
+
+- 新增 `template-provider` 贡献类型与 `template.read` / `template.write` 权限。
+- **模板 = 项目快照**：章节 + 画布 + 时间线（`TimelineProject`）+ 资产引用清单，**不含媒体二进制**；带 `templateSchemaVersion` 版本字段，随项目模型演进。
+- "存为模板"从当前项目生成快照；"从模板新建"克隆快照为新项目（复用项目创建链路）。
+- 模板存储为**服务端模板表**（归属用户/组织），支持列表 + 缩略图（复用 Concat `TemplateThumb` 概念）。
+- **模板中心/市场不实现**：保留扩展点，待组织级模板需求出现时再评估（需组织/审核/订阅体系，超出当前范围）。
+
+### 共同约束
+
+- 两者都是预设插件：随应用分发、默认启用、不可卸载，权限自动授予（ADR-0005）。
+- 权限执行校验（实施规格 M5 的 fail-closed）覆盖新增的 `audio.process` / `template.read` / `template.write`。
+- 新增效果一律遵守"单一参数模型 + 预览近似 + 导出真相"三件套，音频不例外。
+
+## 考虑过的方案
+
+- **语音滤镜用浏览器 WASM DSP（RNBO/声码器级）**：实时性强、效果上限高，但包体大、实现复杂、与导出滤镜难同源；首版否决，保留为复杂 DSP 插件的未来选项。
+- **语音滤镜直接用后端 ffmpeg 滤镜做预览**：网络延迟不可接受，违背"预览近似必须浏览器原生"（ADR-0003）；否决。
+- **语音滤镜保持缺口（不做）**：Concat 对标的核心卖点之一，且音频效果是实现规格中成本最低的插件化增量；否决。
+- **模板 = 复制整个项目含媒体二进制**：两份存储浪费、快照膨胀；否决，快照只存引用清单。
+- **模板纯前端 localStorage**：不可跨设备/账号，与项目服务端持久化体系冲突；否决。
+- **模板保持缺口（不做）**："从模板新建"是成片效率工具，直接衔接概览「剪辑成片」流程（§0.2）；否决。
+
+## 后果
+
+- `buildTimelineRenderPlan` 从纯视频计划扩展为 **A/V 计划**（video steps + audio steps）；ADR-0003 的"单一来源"约束覆盖音频，滤镜图计划的黄金文件增加音频夹具。
+- 新增权限 `audio.process` / `template.read` / `template.write`，权限执行校验清单（M5）同步扩展。
+- 模板快照与项目模型强耦合：`templateSchemaVersion` 必须随 `TimelineProject` / 画布模型演进，快照兼容测试纳入验证纪律。
+- **优先级建议**：模板先于语音滤镜——模板依赖 M2 数据模型与项目创建链路即可落地（M3 后增量窗口），语音滤镜依赖 M3 预览渲染 + M4 导出管线的音频扩展（M4 后增量窗口）。两者均不阻塞 7 个核心预设插件的主线。
+- 实现规格 §6 文件规划需追加：`builtin/editor/editor-audio-effects.ts`、`builtin/editor/editor-template.ts`、后端模板表迁移与 `template` handler、`timeline-to-ffmpeg.ts` 音频 steps 扩展。
diff --git a/docs/adr/0007-ai-editing-interaction.md b/docs/adr/0007-ai-editing-interaction.md
new file mode 100644
index 000000000..c5b9cb729
--- /dev/null
+++ b/docs/adr/0007-ai-editing-interaction.md
@@ -0,0 +1,55 @@
+# ADR-0007: AI 编辑交互——对话式剪辑作为预设插件
+
+状态：已接受。日期：2026-09-01。来源：编辑器与 AI 交互能力整合决策；建立在 ADR-0002（命令协议）与 ADR-0005（预设插件）之上。
+
+## 背景
+
+编辑器需要与 AI 交互：用户用自然语言表达剪辑意图，AI 直接驱动时间线。Concat 没有对话式 AI 编辑（桌面引擎，AI 只能模拟 UI 操作，脆弱且不可测试）；影策因两个既有决策天然支持：
+
+- **命令协议（ADR-0002）**：时间线唯一修改入口是 `{op, payload}` 序列化命令，单队列 apply、可撤销、可重放——AI 只需输出命令 JSON 即可驱动时间线，与人手势编辑完全同构。
+- **插件化（ADR-0005）**：AI 交互能力可作为预设插件注册（对话面板插槽 + 权限），不动核心。
+- **既有资产**：模型渠道已统一中转（`custom-channel-relay.ts` / `/api/ai/custom`）；画布侧已有成熟的 AI 聊天 UI（`canvas-agent-chat-ui.tsx`、`canvas-assistant-panel.tsx`、`canvas-prompt-optimizer-drawer.tsx`）；AI 字幕高亮纯函数层已存在（`subtitle-highlight-*`）。
+
+## 决策
+
+### AI 编辑交互 = 预设插件 `editor-ai-assistant`
+
+- 新增 `ai-assistant` 贡献类型与 `ai.text` / `timeline.command` / `timeline.read` 权限；插件注册对话面板插槽（right 或弹层）。
+- **对话面板复用画布 agent 聊天 UI 的交互模式**（流式输出、上下文面板、可停止），复用现有组件或同构实现，不复制不移植画布会话协议；编辑器上下文（时间线摘要）由本插件构造。
+- AI 是时间线的**一等公民编辑者**：AI 命令与手势命令同构、同队列、同撤销栈。
+
+### AI 命令协议（受约束命令 JSON）
+
+- LLM 输出**受约束的命令序列 JSON**：`{ commands: [{ op, payload }], reasoning?: string }`，`op` 必须来自命令白名单（`editor-commands.ts` 注册的 ops），`payload` 按 per-op schema 校验（新增 `ai-command-schema.ts`，与命令 handler 同源维护）。
+- **宿主 fail-closed**：任一命令 schema 校验失败、op 未知、权限未声明，整批拒绝并返回错误给对话（不执行部分命令）；失败信息回填对话供 AI 自纠。
+- 命令 schema 版本化（`aiCommandSchemaVersion`）：模型演进或命令集变更时显式升级，避免 AI 输出与新命令集失配。
+
+### 执行语义：默认直接执行 + 一键撤销，批量改动需确认
+
+- **单条/少量命令（≤3 条）**：解析校验通过后直接入队执行，撤销即回退（符合剪辑工具直觉，与手势编辑一致）。
+- **批量改动（>3 条或涉及删除/整体重排）**：先展示命令 diff 预览（将改哪些片段/轨道），用户点「应用」才入队。
+- 所有 AI 命令与手势命令共享同一撤销栈，AI 误操作可逐批撤销，不留特殊回退路径。
+
+### AI 只读能力
+
+- 对话可读时间线状态（`timeline.read`）做分析问答（"这段节奏怎么样"、"哪里该剪"）；只读回答不需要 `timeline.command`。
+- 时间线摘要为**结构化精简版**（轨道/片段/时长/关键属性，不含媒体二进制），作为 AI 上下文输入；大对象不进 prompt。
+
+### 素材层 AI 不重复决策
+
+- 自动转写（ADR-0004）、AI 字幕高亮（既有能力接入）、AI 生成素材入轨（既有生成链路 + asset-ingest）不属于本 ADR 的对话式编辑范围；`editor-ai-assistant` 可聚合它们的入口，但各自能力边界与协议不变。
+
+## 考虑过的方案
+
+- **AI 直接操作 DOM/UI（模拟点击拖拽）**：脆弱、不可测试、与命令协议割裂；否决。
+- **AI 走后端执行编辑**：网络往返破坏交互延迟，撤销/错误回填难做，且后端无时间线真相源；否决。
+- **AI 生成完整时间线整体替换**：高风险（覆盖用户已有编辑），无 diff 预览；否决，只允许命令增量。
+- **AI 命令立即全量执行不确认**：批量误操作无法挽回；否决，采用上述批量确认语义。
+
+## 后果
+
+- 命令 schema 成为 AI 与宿主的**双契约**：同一 schema 同时服务命令校验（宿主）与 LLM 提示词约束（AI 端）；`ai-command-schema.ts` 与命令 handler 同源维护，黄金文件测试扩展到 AI 命令序列。
+- 编辑器获得 Concat 不具备的能力：**自然语言驱动的时间线编辑**，且与人编辑共享撤销/可测试/可重放语义。
+- 新增预设插件使首版插件数从 7+2 变为 7+3（editor-ai-assistant 加入）；插件清单与权限矩阵同步更新。
+- 上下文窗口与 token 成本受时间线摘要精简策略影响；摘要生成是纯函数（`timeline-summary.ts`），可测试。
+- 画布 agent 聊天 UI 与编辑器 AI 面板并存：两者共享模型渠道与交互模式，但不共享会话上下文（画布会话 ≠ 编辑器会话），避免会话串扰。
diff --git a/docs/content/docs/progress/pending-test.mdx b/docs/content/docs/progress/pending-test.mdx
index 092f06852..8dd029461 100644
--- a/docs/content/docs/progress/pending-test.mdx
+++ b/docs/content/docs/progress/pending-test.mdx
@@ -5,6 +5,82 @@ description: 当前项目已实现功能的手工验证清单与未确认边界
 
 # 待测试
 
+## 编辑器（M2 命令状态机）
+
+- [x] 命令协议黄金文件：`editor-commands` 8 个黄金 op（addClip/moveClip/trimClip/splitClip/removeClip/setClipProperty/addSubtitle/removeSubtitle）全量快照比对通过；未知 op、非法 payload 一律抛错（fail-closed）且输入不可变。
+- [x] 快照撤销：`editor-history` 有界 200 层，undo 后新命令清空 redo；边界测试（0 层/200 层/undo 后 redo 清空）通过。
+- [x] 命令状态机 store：`editor-store` 命令入队→reducer→新状态，手势预览（previewGesture 连续预览/commitGesture 一次性入历史/cancelGesture 丢弃），1.5s 防抖保存（保存层依赖注入），保存串行链防旧快照覆盖，失败置 saveError 且保持 dirty；11 项测试通过。
+- [ ] 浏览器冒烟（待用户确认）：项目详情 → 剪辑成片 → 编辑器，拖拽片段移动、拖拽边缘裁剪（trim-start/trim-end）、撤销/重做按钮与缩放按钮；松手提交后可一次撤销；刷新后本地时间线（localforage scope 隔离）保留；状态栏显示 未保存/保存中/已保存/保存失败。
+- [ ] M2.4 手势与画布拖拽不冲突（时间线容器 `data-canvas-no-zoom`），快捷键（Cmd/Ctrl+Z）与全局冲突项待 M3 统一处理。
+
+## 编辑器（M3 预设插件八连）
+
+- [x] 命令层新增 `rebuildSubtitleClips`（9 个黄金 op）：从节点权威 subtitleEntries 重建字幕快照，确定性 id（nodeId:subtitle:index）重复导入原地替换；非法 entries（index/startMs/endMs/text/重复 index）与非法轨道（非字幕轨/无字幕轨）fail-closed；黄金文件追加用例通过（26 项）。
+- [x] M3.1~M3.4：timeline-panel（选中联动 + 撤销/重做/缩放 UI）、preview-monitor（buildTimelineRenderPlan 预览）、inspector（setClipProperty 可撤销）、asset-ingest（addClip 入轨）插件与 editor.tsx 三段式接线已提交。
+- [x] M3.5 subtitle-tools：SRT 粘贴导入（parseSrt → rebuildSubtitleClips 重建快照）、当前时间线字幕导出 .srt（serializeSrtEntries 往返一致）；AI 高亮占位（M6 接入）。
+- [x] M3.6 transcription：确定性 mock 转写（mockTranscriptionEntries 同输入同输出，3 项测试），结果按 ADR-0004 协议重建到字幕轨道；M4 替换真实任务客户端。
+- [x] M3.7 export：渲染计划（buildTimelineRenderPlan 与画布同源）+ ffmpeg.wasm 降级导出（exportTimelineToMp4 带进度）；悬空 nodeId 源按计划跳过。
+- [x] M3.8：editor.tsx 全 8 槽三段式渲染（左素材/转写，中预览/时间线，右检查器/字幕/导出/AI）+ ai-assistant 占位（M6）；typecheck 零错误、专项 53/53、全量 build 通过。
+- [ ] 浏览器三段式冒烟（待用户确认）：编辑器六个区域（时间线/预览/检查器/素材库/字幕/转写/导出）逐区域可见可操作；拖拽/裁剪/撤销重做回归；SRT 导入导出往返；mock 转写落轨；导出面板显示渲染计划。
+
+## M5（编辑器插件权限执行，fail-closed）
+
+
+- [x] M5.1：`plugin-permission-check.ts` 新建——8 插槽→最小权限表（timeline.read/timeline.command/export.run 三类域）+ `pluginMayRenderEditorSlot`/`assertEditorPermission` fail-closed 判定；测试 10 用例（表完整性/空权限拒绝/未注册拒绝/缺权限拒绝含 missing 域/editor-shell 真实回归 8 插槽可渲染）全绿。
+- [x] M5.2 执行路径接入：editor.tsx SlotStack 渲染前过滤——缺权限插槽不渲染、改显一行诊断条（含缺失域）；editor-shell manifest 权限补全为 timeline.read/timeline.command/export.run；tsc 全绿、全量 bun test 失败集与改动前一致（零新增回归）。边界：宿主全局命令（editor-commands，v1 语义）与宿主 UI 手势不经过此校验，仅 v2 插件插槽贡献与后续 M6 AI 命令代发通道受约束——ADR-0007「v1 权限语义一字不动」。
+- [ ] M5 浏览器验证（待用户确认）：停用/注册一个缺 timeline.command 权限的第三方插件时对应面板被拒渲染并显示诊断；editor-shell 全部 8 面板正常。
+
+## M6（AI 编辑助手：schema + 摘要 + 面板）
+
+- [x] M6.1：`ai-command-schema.ts` 新建——AI 命令 JSON 解析（容忍 markdown fence/前后杂讯/字符串内括号）、批级 dry-run 预检（走 M2 命令注册表，任一非法整批拒绝并报下标与 op）、12-op LLM 提示词契约（`AI_EDITING_OP_CATALOG` + `buildAiEditingSystemPrompt`）、`AI_COMMAND_SCHEMA_VERSION` 版本化；`ai-commands.golden.json` 固化 op 集与 registry 黄金同步（漂移即测试失败）；20 用例全绿。
+- [x] M6.2：`timeline-summary.ts` 新建——确定性中文摘要（轨道按 order 排序逐行、片段逐行含 id/kind/时间区间、字幕字数统计、空态提示）；片段行数超限折叠（SUMMARY_MAX_CLIP_LINES）；同输入同输出；10 用例全绿。
+- [x] M6.3：`editor-ai-assistant.tsx` 从占位替换为真实 AI 助手——右上悬浮对话面板（OpenAI Canvas 风格）：面板内文本模型选择器（`effective.textModels` 即文本能力模型目录，选择即 `updateConfig("textModel", …)` 持久化并在请求时同时覆写 `config.model/textModel`，绕过默认/误配图像模型的根因）、消息流（user/assistant/error/preview 四类气泡 + 思考中占位）、空态引导（示例意图文案，点击建议指令 chips 即发送，跨轮记忆）、底部输入条；顶部工具栏常驻 Sparkles 入口（aria-pressed 切换）。宿主链路：`buildAiEditingSystemPrompt(summarizeTimeline(project))` 喂上下文 → 流式增量渲染 → `parseAiCommandPlan` → `validateAiCommandBatch` dry-run（任一非法整批拒绝，同步 registry 校验、不落盘）→ ≤3 条 `dispatch` 直执行 / >3 条渲染 diff 预览卡片「确认执行（N）/ 放弃」→ 解析/校验拒绝时错误气泡可「修正后重试」（`failTurn` 回填 `FAILED_MARK`，历史含用户文本不重发；registry 直执行本身 fail-closed——拒绝写入 `saveError` 顶部提示，同步 dispatch 不抛错故不回填 FAILED_MARK）。修复了上一版文件的重复/截断函数（appendToEntry 双定义、settleAnswer 三声明等）；typecheck 零错误、编辑器/插件相关测试通过、生产构建通过。
+- [ ] 浏览器冒烟（待用户确认，需真实文本渠道）：顶部工具栏 AI 图标开关面板 → 切换面板内模型下拉（无可用模型时展示禁用态）→ 输入自然语言；确认 ≤3 条指令直接执行且可撤销（撤销按条回退，N 条需 N 次撤销）、>3 条出现预览确认卡片（放弃不动时间线、确认后预览卡转为执行汇报、重复点击不再二次提交）、模型输出非法 JSON 时错误气泡出现「修正后重试」并回填失败标记、ESC/关闭按钮收起面板后再次打开会话仍在。
+
+## M4（后端转写/渲染任务）
+
+- [x] M4.1 执行侧（e9d1b8ad）：本地 whisper.cpp HTTP（`CANVAS_WHISPER_BASE_URL`）转写；语音数据不出本机；未配置时任务明确失败并提示设置；`processClaimedTask` 顶部按类型分叉、旁路计费/模型路由，20 分钟超时；ffmpeg 预处理 16k 单声道 wav；`verbose_json` 解码/`formatSRTTimestamp`/`buildTimelineSRT` 单测 PASS。
+- [x] M4.1 创建 API（bf26ebb1）：`POST /api/timeline/transcriptions`（注册于 `RegisterTaskRoutes`）→ `CreateTimelineTranscriptionTask`：draining 503 → feature 门控 → 资源归属/可转写类型校验 → 配额入队（local/whisper.cpp，无 billing order）；活跃任务上限 → 可读 400；测试 3 项 PASS。
+- [x] M4.2 渲染任务（3f16d13b）：`POST /api/timeline/renders` → `CreateTimelineRenderTask`：`buildRenderPlan` 校验 ≥1 可渲染媒体 → 配额入队（local/ffmpeg）；worker 分叉 `processTimelineRender`（60 分钟超时）：ffmpeg 合成 → 产物写资源存储 → `ResultJSON{resourceId,...}`；计划/失败快路径测试 PASS。
+- [x] M4.3 前端字幕回写（fd5e8139）：`timeline-tasks.ts` 客户端 + `editor-transcription.tsx` 真实任务替换 mock；资源范围放宽到音视频；`resourceId` 由 `storageKey` 推导；`waitForGenerationTask` 显式 25 分钟超时轮询；结果 segments → SrtEntry → `rebuildSubtitleClips` 落字幕轨；typecheck 通过。
+- [ ] 浏览器端到端（待用户确认，需本机 whisper.cpp server）：媒体面板选音视频素材 → 转写 → 进度可见 → 完成后字幕分段入轨可编辑；错误路径（未配置/删除素材/非音视频/活跃任务上限/功能未开放）提示可读。
+- [x] M4.2 渲染前端接线：`timeline-tasks.ts` 增 `createTimelineRenderTask`（timeline 整传 TimelineProject v2，与后端 renderProject 契约同构）；`editor-export.tsx` 主路径改提交 `POST /api/timeline/renders` → `waitForGenerationTask` 轮询（62min）→ ResultJSON.resourceId 内嵌预览/下载；ffmpeg.wasm 降级保留；tsc 全绿、无新增测试失败。
+- [ ] M4.2 渲染浏览器验证（待用户确认，需 ffmpeg 可用）：导出面板「渲染成片（服务端）」→ 轮询进度 → 完成后内嵌预览/下载渲染产物；无后端时「本地导出」ffmpeg.wasm 仍可用。
+- [ ] 文档回写（已提交）：`docs/plans/m4-transcription-render-design.md` §2 决策 3/4/5 按“单一池 + 类型分叉”与旁路终态修正；端点统一为复数 `/api/timeline/transcriptions` 与 `/api/timeline/renders`（注册于 `RegisterTaskRoutes`）；`auth.go` 前缀白名单补 `timeline`。
+
+## 编辑器 UI 打磨（主题/布局/导入媒体）
+
+- [x] 主题联动修复：globals.css `.dark` 块未闭合导致 `.editor-workbench` 规则被 CSS 嵌套吞并、浅暗主题三栏配色反转；补齐花括号后编译产物恢复顶层两规则，director token 明暗两主题齐备。
+- [x] 播放条修复：预览卡与时间线卡容器补 `flex flex-col`，恢复 absolute 播放条的高度链。
+- [x] 时间线右端截断修复：内容宽度改为 `trackWidth + 标签列(160px)`，标尺左列占位与轨道标签列改为 sticky（`left-0` + 不透明底），滚动到最右端时末端片段完整可见；容器宽度监听改用 ResizeObserver。
+- [x] 顶部栏图标化：删除「剪辑工作台」标题 + Film 图标 + 分隔线等死图标；导出按钮改为纯图标（aria-label/title 保留）。
+- [x] 媒体导入失败修复：`linkProjectAsset` 原来只认 assets 表记录，而上传只落 resources 表，导入必然 404。后端 `LinkProjectAsset` 在资产不存在时按资源元数据（storageKey/mimeType/kind/宽高/时长/状态）合成资产记录并幂等补齐（`UpsertAsset`），`Title` 透传原始文件名；资源与资产都不存在时仍 fail-closed。前端导入调用补传 `title: file.name`。
+- [x] 后端新增 `TestLinkProjectAssetCreatesAssetFromUploadedResource` 与 `TestLinkProjectAssetMissingResourceKeepsFailingClosed` 专项测试；前端 typecheck、生产构建、后端全量测试通过。
+- [ ] 用户浏览器 re-test（第 35 条）：媒体面板中导入的素材与项目资产分组显示、筛选 Tab 切换、分组折叠与资产行展开；浅色/深色主题切换后媒体面板配色与编辑面板一致；时间线横跨整个编辑面板宽度，拖动分隔条调整高度正常。
+- [x] 对象存储上传降级：OSS 上传失败（密钥失效、配置错误、网络故障、设置被删）自动回退本地存储并同步改写资源记录，本地媒体导入不再因外部存储故障整体失败；覆盖新上传与重试两条路径。专项测试 2 个（OSS 不可用降级成功 + 本地路径不受他人 OSS 设置影响），后端全量测试通过。
+- [ ] 用户浏览器 re-test（对象存储降级）：重新启动后端后再次导入视频，应显示成功且素材出现在媒体面板；资源走本地存储（`provider=local`）。
+- [x] 编辑器 UI 打磨（第 36 条 5 项）：① 时间线/监视器分隔条拖拽方向反转（上拖=时间线变大）；② 导出按钮图标去蓝（灰白描边风格），媒体面板来源徽章去蓝，轨道类型徽章保留语义色；③ 时间线 pxPerMs 独立化（不再随时长漂移），末片段向右拖轨道随内容等比扩展不再被钉住（新增守护测试 3 例）；④ 监视器控制条重做为 Concat 风格：回到开头/退 1s/播放/进 1s/到结尾五键传输组 + 播放速度展开菜单（0.5x/1x/1.5x/2x）+ 进度条，全部灰白描边；⑤ 检查器重做为 Concat 风格：分组小标题（片段/基本/转场）+ 紧凑控件 + sunken 滑块（新增 .editor-slider），全部使用 director token 随主题联动。
+- [ ] 用户浏览器 re-test（第 36 条）：上拖分隔条时间线变大；导出按钮与监视器控制条图标均为灰白描边风格；时间线末片段可正常向右拖拽且轨道随内容扩展；监视器速度菜单展开选择生效；检查器分组与滑块在明暗两主题下配色一致（无主题不同步）。
+- [x] 媒体面板改版：资产按来源分组（「本地上传」/「项目素材」），顶部提供 全部/项目素材/本地上传 筛选 Tab；分组头可折叠、资产行可展开查看详情（类型/分类/来源/预览文本）并一键添加到时间线；每项带来源徽章与计数徽章。后端 `projectAssetSummary` 透出 `source`（上传链路写入 `uploaded`），前端 `ProjectAsset` 类型补 `source?: string`，仅展示层使用，后端读取不再查询本地存储。
+- [x] 时间线横跨编辑面板全宽：时间线卡从内容区独立出来，与左栏+预览+右栏同处编辑面板，横跨从左到右全宽（含拖拽高度分隔条）；左栏收窄到 256px、右栏 320px，为全宽时间线腾出空间。
+- [x] 主题明暗一致性：媒体面板分组/筛选/徽章/展开详情全部使用 director token（surface/control-hover/dock-fg/sequencer-border），无新增硬编码色值；后端 `source` 字段不参与任何配色。前端 typecheck、生产构建、后端全量测试通过。
+- [x] 时间线面板补齐 Concat 风格工具栏与编辑交互（对齐第 2 条 runbook 与 `Concat/desktop/.../TimelinePanel.tsx`）：新增 选择/剃刀 工具切换（剃刀点击分割、非字幕片段、边缘留 100ms）、播放头时码只读显示与标尺拖动 scrub、分割播放头处、删除选中片段、磁吸开关（默认开）、加轨道下拉（视频/音频/字幕，`addTrack` 黄金命令确定性生成 id/order/label，undo/redo 可重放）、适应宽度（`getFitTimelineZoom`）；工具栏布局重排为 Concat 顶部条结构。`editor-commands.ts` golden ops 由 9 增到 10（`addTrack`）。
+- [x] 磁吸失效修复：片段拖拽移动分支原本只保留「左边缘目标与右边缘目标同时命中」的结果，单边命中（如最后一个片段右边缘无目标）或双目标取整后偏移为 0（原始位置已在目标上）时整组吸附被丢弃，表现为「第一个和第二个片段能吸附、后续片段与剃刀分割出的片段都吸不住」。改为以 `computeSnap` 返回的 `targets.length` 判定命中、左右候选独立比较取更近者，单边命中与零偏移命中均可正常吸附。
+- [ ] 用户浏览器 re-test（时间线工具栏与磁吸）：拖拽任意片段（含剃刀分割出的片段）靠近其他片段边缘或播放头时磁吸生效且可吸附回自身原位置；剃刀点击在指针处分割；分割按钮在播放头落在片段中段时可用；删除选中片段后再次拖拽正常；加轨道后新轨道带确定性标签与序号；适应宽度后内容恰好铺满可视宽度；磁吸关闭后拖拽自由、无取整跳动。
+- [x] 工具按钮选中态样式修正：时间线工具栏 选择/剃刀/磁吸 的按下态原来是蓝色背景块，改为「仅图标变 accent 色、无背景块」；颜色职责收敛为 `TOOL_FG_IDLE` / `TOOL_FG_ACTIVE` 两常量（唯一来源），工具栏与加轨道下拉不再散落重复的颜色字面量。
+- [x] 监视器播放条重构（Concat 布局）：删除叠加在画面底部的渐变进度条与 `<input type=range>` scrub；改为画面下方独立一行 `grid h-11 grid-cols-[1fr_auto_1fr]`：左 播放头/总时长时码、中 回开头/退 1s/播放暂停/进 1s/到结尾（播放态仅图标变 accent）、右 速度菜单（0.5x/1x/1.5x/2x，带 Gauge 图标与展开箭头）。
+- [ ] 用户浏览器 re-test（选中态与播放条）：点击 选择/剃刀/磁吸 时只看到图标变色（无蓝底块），深色/浅色主题一致；监视器底部控制条不悬浮于画面、无进度条，播放态播放图标变主题强调色，速度菜单展开/选择生效，拖拽分隔条改变监视器高度时画面区域与控制条高度正常。
+- [x] 轨道操作按钮（Concat 对齐）：时间线轨道行头新增「移除轨道」X 按钮（hover/键盘 focus 显现，danger 强调，仅该 kind 非最后一条时可用）；新增 `removeTrack` 黄金命令——每类轨道至少保留一条（删除该 kind 最后一条会被守卫拒绝），删除时级联移除轨道上全部片段、无悬挂引用，undo/redo 可重放；`editor-commands.ts` golden ops 10→11（`removeTrack`），新增 3 条单测（级联删除并保留其余 / 最后一条拒绝 / 未知 trackId 拒绝）。
+- [x] 资源上传 400 修复：`POST /api/resources` 在文件超过 MaxBytesReader 上限（单文件限制 50MB +1MB 缓冲）时 `FormFile` 返回英文 `http: request body too large` → 现翻译为与 service 配额校验一致的中文「单个上传文件必须小于 50MB」（`backend/internal/handler/user_data.go`），前端可正常展示失败原因而非裸 400。
+- [x] antd Modal `maskClosable` deprecation 清理：5 处改用 `mask={{ closable: … }}`（canvas-upload-modal / asset-library-picker-modal / projects index「AI 生成章节」/ skill-editor-drawer / skill-install-modal）。
+- [ ] 用户浏览器 re-test（轨道移除与上传）：hover 轨道行头出现 X，点击移除非最后一条轨道后其与片段消失且可 undo；该 kind 仅剩一条时行头不出现 X；移除轨道后选中片段同步取消；导入超过 50MB 的本地视频不再报 400、可正常入库（见下方分片导入复测）。
+- [x] 本地媒体导入对齐 Concat 分片化：前端 `uploadResourceFile` 超过 50MB 自动切分片上传（8MB/片、失败整传重试、回调进度）；后端新增分片会话三接口 `POST /api/resources/uploads`（开始）、`PUT /api/resources/uploads/:id/chunks/:index`（逐片原始二进制）、`POST /api/resources/uploads/:id/complete`（合并落库，复用 UploadResourceFile 幂等/落盘/探测，保留上传中唯一键 → 提示“上传中请稍候”）；单片上限 8MB 使文件整体不再受 multipart 单请求限制，普通本地视频可导入。
+- [x] 上传默认配额放宽：运行时默认策略 `DailyUploadMB` 200→2048、`StoredFileGB` 2→20（管理员后台仍可调回）；`UploadResourceFile` 经 `reserveChunkedUploadQuota` 豁免单文件大小上限、仅受日/总量约束；`upload_quota_test.go` 对总量文案、daily 上限文案与逻辑按新默认同步，`resource_upload_session.go` 分片会话（内存 TTL 90min、并发/单片限长防护、超总量提前拒绝），新增路由注册测试。
+- [ ] 用户浏览器 re-test（分片导入）：本地选择 >50MB 的视频导入成功并入库（进度可见、失败自动整传重试）；断网重连后重试完成；<50MB 小文件仍走原 multipart 路径无回归；重复导入同一文件命中幂等返回原资源不重复占额度；超日限/总量时提示中文配额文案。
+- [ ] 用户浏览器 re-test（第 35 条）：媒体面板中导入的素材与项目资产分组显示、筛选 Tab 切换、分组折叠与资产行展开；浅色/深色主题切换后媒体面板配色与编辑面板一致；时间线横跨整个编辑面板宽度，拖动分隔条调整高度正常。
+- [x] 轨道可见/静音开关（Concat 行头对齐）：轨道行头补齐 eye（显示/隐藏轨道）与 volume（静音/取消静音）按钮，与移除 X 三按钮同组（行头加宽 w-40→w-48）；关闭态图标变 accent 色（无背景块），轨道名与片段区随隐藏降透明度；新增 `setTrackFlag` 黄金命令（flag 白名单 visible/muted，golden ops 11→12），隐藏轨道（visible=false）上的片段不再参与监视器预览合成（getClipAtTime 过滤）；新增 3 条单测（目标轨设置且其余不受影响、muted 独立于 visible、未知轨道/flag/非布尔拒绝），输入不可变校验。
+- [ ] 用户浏览器 re-test（轨道可见/静音）：行头 hover 出现三按钮组；点 eye 隐藏轨道后监视器该轨画面消失、轨道行与轨道名变淡、再点恢复；点 volume 静音后图标变 accent（音频在 M4 播放/导出阶段生效）；仅剩一条轨道时无移除 X；以上操作均可一步 undo。
+
 ## 支付插件跨平台构建
 
 - [x] 微信与支付宝 provider 已使用同一 target-aware 构建脚本完成 `CGO_ENABLED=0` 的 linux/amd64、linux/arm64 交叉编译；目录 provider 与 `.yingce-plugin` 内 provider 的 ELF 架构和内容一致性校验通过。
@@ -749,3 +825,37 @@ description: 当前项目已实现功能的手工验证清单与未确认边界
 - [ ] 确认最近项目表格的搜索、状态筛选、排序与分页行为，行点击进入项目概览；无项目时显示创建入口。
 - [ ] 确认快捷创建与工作流面板入口可用，工作流提示显示最近项目阶段与章节完成度。
 - [ ] 验证浅色/深色主题与窄窗口（表格横向滚动、统计卡换行）下可读可操作。
+
+## 编辑器 Concat 风格打磨第 36 条（5 项 UI）
+
+已实施完成，需要浏览器最终确认：
+
+- [x] 前端 TypeScript 检查通过；`web/test/timeline-view.test.ts` 3 个守护测试通过；git 工作区干净。
+- [ ] 时间线面板与监视器的分隔条拖拽方向：向上拖拽时间线面板应变大（已反转，拖拽中无反向）。
+- [ ] 顶部工具栏图标（含导出）与时间线轨道徽标、片段未选中态不再使用蓝色填充，风格与 img-10 参考统一；片段选中态仍以 accent 蓝标识。
+- [ ] 时间线最后一个片段可向左、向右双向拖拽，右侧不再固定不动；拖动过程中时间刻度不漂移（pxPerMs 仅由缩放决定）。
+- [ ] 监视器底部控制条为 Concat img-14 风格：SkipBack/StepBack/Play/StepForward/SkipForward 五键 + 变速菜单（0.5x–2x）+ 进度条行与时间码；图标在恒黑监视器上为白色，无蓝色。
+- [ ] 右侧检查器为 Concat img-15 风格：属性行水平排列（标签左、控件右）、Section 分组标题、输入框 h-7 rounded-[7px]、凹嵌式滑块；浅色/深色主题下均无主题不同步。
+
+## 媒体导入失败根治（分片上传 + OSS 降级修复）
+
+已实施，代码/单测/编译验证通过，需要浏览器最终确认：
+
+- [ ] 后端 `go build`/`go vet` 通过；`resource_test.go` 新增 OSS body close 回归测试通过；handler/service 包测试通过。
+- [ ] 重新导入 >50MB 视频（如 92MB 样例），确认前端分片上传（POST /uploads → PUT chunks → POST complete）全程无 400，且进度条显示百分比。
+- [ ] OSS 配置密钥仍不匹配（历史 403 SignatureDoesNotMatch）时，确认上传自动降级写入本地存储（provider=local）并导入成功，不再报"导入失败"。
+- [ ] 在用户设置里修正阿里云 OSS AccessKeySecret（当前配置的密钥从未验证通过，8/16 起所有 OSS 上传均 403）后，确认资源改回写入 OSS。
+- [ ] 确认配额默认值已放宽（日 2048MB、总量 20GB，仅当无 runtime_policy 记录时生效）；超过日配额时前端提示为中文而非裸 400。
+
+## 上传媒体监视器播放（H.265 播放副本 + 真实播放驱动 + 时长链路）
+
+阶段 C 根治：本地 H.265 原件服务端转 H.264 播放副本（provider=local 专属，无 ffmpeg 则保持原样），
+监视器 <video> 真实播放驱动（不再纯时间码），时间线 transport 与监视器共享，上传携带真实时长。
+代码/单测/编译验证通过（后端 go build/vet/test、前端 tsc 全绿），需浏览器最终确认：
+
+- [ ] 拖入上传的 H.265 视频（92MB 样例，资源 rowid 54/55）到时间线，点播放：画面真实播放、有声音（不再黑屏/静音）；首次 onError 后出现"正在生成兼容版本"提示并轮询，转码完成后自动切 H.264 副本继续播放。
+- [ ] 监视器播放时时间线播放头同步推进；拖动时间线播放头（scrub）监视器画面即时跳转；暂停/继续/变速（0.5x–2x）后时间线与监视器仍一致。
+- [ ] 轨道静音开关生效：视频所在轨道 muted 时监视器无声，取消静音恢复声音；轨道隐藏（可见性关闭）的片段不再参与预览。
+- [ ] 拖入时长 >5s 的视频片段，其时间线长度等于视频真实时长（不再固定 5s 截断）；时长探测上传的新素材在资源卡片/片段均显示真实时长。
+- [ ] 播放副本就绪前（processing）视频黑屏时出现"正在生成兼容版本（H.264）…"浮层 + "下载原片用本地播放器观看"链接；生成失败显示失败文案而非一直转圈。
+- [ ] 时间线 scrub/播放/变速往返 10 次以上无卡死、无播放头回跳、无 setState-after-unmount 报错（Console 无告警）。
diff --git a/docs/design/workspace-shell-design.mdx b/docs/design/workspace-shell-design.mdx
index 063e9c548..f27f4c0f3 100644
--- a/docs/design/workspace-shell-design.mdx
+++ b/docs/design/workspace-shell-design.mdx
@@ -44,7 +44,7 @@
 1. **工作区切换器** `WorkspaceSwitcher`：品牌 mark（`size-8`、`--r-sm` 圆角、`InfinityIcon`）+「影策」wordmark + 副标题「创作工作台」（`--fs-label`、42% 灰）→ 点击展开切换浮层 `.app-workspace-nav-popover`（无阴影，1px 边框 + 实底背景）。
 2. **快速搜索**：`h-9`、`--r-lg` 圆角、`bg-foreground/5` 浅底；占位文字与 `Search` 图标均为 `text-muted-foreground`（语义占位色）；hover 加深至 `bg-foreground/[.07]` + 70%；右侧常驻 `⌘K` kbd 提示（复用导航项 kbd 合同）；点击打开命令面板。
 3. **分组导航区** `.app-workspace-sidebar-scroll-area`（`flex-1` 滚动，滚动条隐藏）：
-   - 无标题分组（首页/创作/画布…核心入口）**常驻展示，不折叠**。
+   - 无标题分组（首页 / 短剧创作 / 画布 / 任务中心 / 资产…核心入口）**常驻展示，不折叠**；「短剧创作」入口（`/projects`）**常驻**（不随 `shortDramaEnabled` 隐藏，该开关仅作部署级兜底：关闭时由 `RequireFeature` 提示「暂未开放」而非隐藏入口）；「任务中心」等按功能开关条件渲染（`workspace-sidebar-nav.tsx` `buildNav`）。
    - 有标题分组渲染为 `NavGroup`（见 §2.3）。
 4. **Footer**（设置分区 + 退出登录）：无分隔线（见 §2.5）。
 
diff --git a/docs/index.md b/docs/index.md
index 014b3fe88..bb627831c 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -20,6 +20,19 @@
 
 - [LLM、Image、Video 主流请求协议全景与影策兼容性调查](design/model-request-protocol-landscape.md)：主流原生协议、聚合网关、图片/视频异步任务、参考素材 role、当前插件映射缺口与 MiniMax H3 专项审计。
 
+- [编辑器预设插件化实施规格](plans/editor-preset-plugin-implementation.md)：参考 open-vetta 万物皆可插件，把编辑器做成预设插件的分阶段实施计划（SDK v2、命令状态机、8 个 editor 预设插件（含 AI 助手）、后端转写/导出任务、权限执行校验、AI 对话式剪辑），含产品视图、接口草案与文件规划。
+- [编辑器实施 Runbook](plans/editor-implementation-runbook.md)：分步执行计划——M0~M6 里程碑 + 原子步明细（每步改动文件/验证/完成标准）、依赖关系、验证命令速查、高风险步与回退。解决「一次性实施效果差」：每步可验证、可回退、看得见进度。
+
+## 决策记录（`docs/adr/`）
+
+- [ADR-0001：编辑器整合边界](adr/0001-editor-integration-boundary.md)：借鉴 Concat 架构形态但以 TS 时间线状态机为真相源，不移植 Rust 引擎；媒体重活放 Go 后端。
+- [ADR-0002：编辑命令协议](adr/0002-edit-command-protocol.md)：时间线唯一修改入口为可序列化编辑命令，手势 echo、有界快照撤销、防抖保存。
+- [ADR-0003：预览与导出分层](adr/0003-preview-export-layering.md)：交互近似预览 + 单一滤镜图计划驱动导出，禁止手写第二套滤镜串。
+- [ADR-0004：自动字幕转写服务化](adr/0004-autocaption-transcription-service.md)：转写为 Go 后端异步任务，结果写回字幕轨道。
+- [ADR-0005：编辑器预设插件架构](adr/0005-editor-preset-plugin-architecture.md)：参考 open-vetta「万物皆可插件」，编辑器全部 UI 与能力为预设插件贡献，插件 SDK 演进为 v2（UI 插槽 + 预设分发 + 权限执行校验）。
+- [ADR-0006：语音滤镜与项目模板](adr/0006-voice-filters-and-templates.md)：补充评估 Concat 剩余两个缺口——语音滤镜走 Web Audio 预览近似 + ffmpeg 音频滤镜图导出，模板走项目快照服务化；均为预设插件且服从单一滤镜图计划。
+- [ADR-0007：AI 编辑交互](adr/0007-ai-editing-interaction.md)：对话式剪辑作为预设插件——AI 输出受约束命令 JSON（schema 校验 fail-closed），与手势命令同队列同撤销栈；≤3 条直接执行、批量改动 diff 预览待确认。
+
 ## 本地协作文档（不随仓库分发）
 
 - [beautifului 创作设计](beautifului-creation-design.md)：本地设计参考，未纳入版本控制。
diff --git a/docs/plans/editor-implementation-runbook.md b/docs/plans/editor-implementation-runbook.md
new file mode 100644
index 000000000..cdf0c938d
--- /dev/null
+++ b/docs/plans/editor-implementation-runbook.md
@@ -0,0 +1,158 @@
+# 编辑器实施 Runbook（分步执行计划）
+
+> 配套文档：[编辑器预设插件化实施规格](../plans/editor-preset-plugin-implementation.md)（目标架构与接口）与 [ADR-0001 ~ 0007](../adr/)（决策）。本文件只解决一个问题：**按什么顺序、以什么粒度动手，让每一步都可验证、可回退、看得见进度**。
+>
+> 状态：2026-09-01 制定。M0–M3 已完成并提交；M4.1（转写后端：本地 whisper.cpp HTTP，
+> `CANVAS_WHISPER_BASE_URL`）e9d1b8ad/bf26ebb1、M4.2（渲染后端：`POST /api/timeline/renders`）
+> 3f16d13b、M4.3（转写前端回写，真实任务替换 mock）fd5e8139 均已提交。
+
+## 0. 执行原则（为什么这样拆）
+
+一次性大爆炸实施的三个失败模式：**看不见进度**（写一堆类型层后毫无可见产物）、**无法定位回归**（一个 diff 里混了协议+UI+后端）、**无法回退**（改动面太大只能整体回滚）。本计划按三条铁律对抗：
+
+1. **原子步**：每一步是一个可独立验证的变更，只动一个目标（类型 / 纯函数 / 单个插件 / 单个接线点），不混多个目标。
+2. **验证门**：每步结束必须过最轻的验证门（typecheck / 专项测试 / 构建，按步标注），通过才能进下一步。验证命令以当前 `package.json` 为准（§4 速查）。
+3. **垂直切片优先**：先让「最小可演示」跑通（M0 空壳 + M1.4 插槽链路 + M2 命令），让每一步都有浏览器可见或测试可断言的产物，再横向铺开功能面。
+
+配套纪律：每步一个 commit（`feat(editor)` / `test(editor)` 等，见 AGENTS.md）；测试文件按项目实际约定放 `web/test/`（不是 `src/__tests__`，实施规格 §6 的路径为示意，落位时以本文件为准）；不覆盖、不回滚非本次变更。
+
+## 1. 里程碑总览
+
+| 里程碑 | 核心产出 | 演示 / 验收标准 | 依赖 |
+|---|---|---|---|
+| **M0 准备与基线** | 编辑器路由占位壳 + 概览流程入口 + 测试骨架 | 浏览器访问 `/projects/:id/editor` 看到占位页；概览页有「剪辑成片」步骤卡；`bun test test/editor-commands.test.ts` 可跑 | 无 |
+| **M1 SDK v2** | v2 类型 + editor-slot-registry + 注册器兼容 + 插槽链路垂直切片 | 一个预设插件注册的 timeline-panel 插槽在占位页**真实渲染**出空面板（链路全通） | M0 |
+| **M2 命令状态机** | editor-commands / editor-history / editor-store + 黄金文件测试 | 命令序列 → 状态快照黄金文件比对通过；撤销/重做 200 层测试通过；手势（移动/裁剪）echo→提交→撤销浏览器可操作 | M1 |
+| **M3 预设插件** | 8 个 editor 插件逐个人轨 + detail.tsx 接线 | 编辑器三段式布局完整：时间线/预览/检查器/素材库/字幕/转写/导出逐区域可见可操作 | M2、M4（API 面） |
+| **M4 后端任务** | 转写 + 渲染异步任务（服务端） | `go test ./...` 通过；前端任务客户端（创建/轮询/SSE）接 editor-transcription/export | M3 前需 API 面 |
+| **M5 权限执行** | plugin-permission-check + fail-closed 接入 | permission-denied 测试通过；未声明 `timeline.command` 的插件写操作被拒；v1 插件权限语义不变 | M1、M3 |
+| **M6 AI 编辑交互** | ai-command-schema + timeline-summary + editor-ai-assistant | 代码侧完成（schema 黄金测试 / 摘要确定性 / 助手面板 M6.3 已实现，tsc + 全量测试 + 构建通过）；待用户浏览器冒烟：命令执行→撤销、非法命令整批拒绝、批量 diff 预览 | M2、M3、M5 |
+
+## 2. 原子步明细
+
+> 每步的「验证」是**最轻**的通过标准；「完成标准」是这一步真正做完的标志。
+
+### M0 准备与基线
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M0.1 | `web/src/pages/projects/detail.tsx` | `DetailView` 加 `"editor"`；`views` 数组加「剪辑」项（常驻，插在「项目画布」后）；`editor` 视图渲染**占位页**（`editor-slot-registry` 为空时显示空态壳） | `bun run typecheck`；浏览器 `/projects/:id/editor` | tab 存在且可切换，占位页可见，其余 6 视图不受影响 |
+| M0.2 | `web/src/pages/projects/detail/overview.tsx` | `productionSteps` 在「镜头视频」与「交付与打包」间插入「剪辑成片」步骤卡（`href: /projects/:id/editor`） | `bun run typecheck`；浏览器概览页 | 步骤卡可见可跳转；完成态 = 镜头视频齐备且已有时间线 |
+| M0.3 | `web/test/editor-commands.test.ts`（新建骨架） | 空测试壳 + `bun test` 跑通；确认 `web/test/` 下测试基建 | `bun test test/editor-commands.test.ts` | 测试可运行（1 个占位断言通过） |
+
+### M1 插件 SDK v2
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M1.1 | `web/src/lib/plugins/plugin-types.ts` | 加 `PLUGIN_API_VERSION "yingce.plugin/v2"` 类型、编辑器贡献类型（timeline-panel / preview-renderer / inspector / asset-ingest / subtitle-tool / transcription-provider / export-renderer / ai-assistant）、`timeline.*` / `export.run` / `ai.text` 权限字面量 | `bun run typecheck` | 纯类型增量，v1 类型零改动，既有代码零编译错误 |
+| M1.2 | `web/src/lib/plugins/editor-slot-registry.ts`（新建） | 插槽注册表：`registerEditorSlot / unregisterEditorSlot / getEditorSlot`，按插槽类型 + 优先级排序，幂等注册 | 新增 `web/test/editor-slot-registry.test.ts`：注册/去重/排序/未知插槽 | 专项测试通过，无 UI 依赖（纯函数） |
+| M1.3 | `web/src/lib/plugins/plugin-registry.ts` | 注册断言按 apiVersion 分支：v1 保持现状（kebab-case + ≥1 贡献）；v2 增加插槽贡献合法性校验；重复权限检查对 v2 生效 | `bun test test/canvas-node-registry.test.ts`（既有）全过 + 新增 v2 注册测试 | v1 插件行为完全不变；v2 注册/拒绝路径测试通过 |
+| M1.4 | `web/src/lib/plugins/builtin/editor/editor-shell.ts`（临时）+ `web/src/lib/plugins/builtin/index.ts` | 垂直切片：`editor-shell` 预设插件注册 1 个 timeline-panel 插槽，占位页渲染该插槽 | `bun run typecheck`；浏览器 `/projects/:id/editor` | 插槽注册→渲染链路全通（空面板可见），**这是第一条垂直切片** |
+
+### M2 命令状态机（纯函数层，黄金文件先行）
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M2.1 | `web/src/lib/timeline/editor-commands.ts` + `web/test/fixtures/commands.golden.json`（新建） | 核心 op：`addClip / moveClip / trimClip / splitClip / removeClip / setClipProperty / addSubtitle / removeSubtitle`；reducer 纯函数；黄金文件 = 命令序列→期望状态快照 | 新增 `web/test/editor-commands.test.ts`：逐命令断言 + 黄金文件比对 | 全部 op 通过；非法 payload 抛错路径覆盖 |
+| M2.2 | `web/src/lib/timeline/editor-history.ts`（新建） | 快照撤销栈：200 层上限、undo/redo、undo 后新命令清空 redo | 新增 `web/test/editor-history.test.ts` | 边界测试通过（0 层/200 层/undo 后 redo 清空） |
+| M2.3 | `web/src/lib/timeline/editor-store.ts`（新建） | zustand store：命令入队→reducer→新状态；echo 预演与 release 提交；1.5s 防抖保存（localforage + 后端项目接口）；保存失败向上抛 | 新增 `web/test/editor-store.test.ts`（mock 保存层） | 队列/防抖/失败传播测试通过 |
+| M2.4 | 手势 echo 层（`web/src/components/editor/` 起步最小件） | 时间线区域支持移动、裁剪两个手势：拖动中本地 echo 预演，release 提交命令 | `bun run typecheck` + M2.1 测试 | 浏览器拖拽片段→撤销回退可操作（与画布拖拽不冲突，含 `data-canvas-no-zoom` 边界） |
+
+### M3 预设插件（每步一个插件，每步后对应区域可见）
+
+> 顺序按依赖：面板（数据展示）→ 预览 → 检查器（选中联动）→ 素材入轨（数据源）→ 字幕 → 转写/导出（依赖 M4 API 面，可先接 mock）。
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M3.1 | `web/src/lib/plugins/builtin/editor/editor-timeline-panel.ts` | `createTimelinePanel` → 注册 timeline-panel（bottom）；渲染时间线轨道区（读 editor-store，接 M2.4 手势） | typecheck + `bun test test/editor-*.test.ts` | 轨道/片段渲染、选中联动、撤销重做 UI |
+| M3.2 | `web/src/lib/plugins/builtin/editor/editor-preview-monitor.ts` | `createPreviewMonitor` → 注册 preview-renderer（center）；浏览器原生近似渲染 + 播放头/时间码/帧步进 | typecheck；浏览器预览可播放 | 预览与时间线播放头同步（走 `buildTimelineRenderPlan` 预览近似路径） |
+| M3.3 | `web/src/lib/plugins/builtin/editor/editor-inspector.ts` | `createInspector` → 注册 inspector（right）；选中片段属性（起止/音量/变速/滤镜参数模型） | typecheck；浏览器选中联动 | 属性编辑经 `setClipProperty` 命令入队，可撤销 |
+| M3.4 | `web/src/lib/plugins/builtin/editor/editor-asset-ingest.ts` | `createAssetIngest` → 注册 asset-ingest（left）；角色资产/项目资产/本地上传 → 拖入时间线（`asset-ingest` 权限 + directMedia） | typecheck；浏览器拖拽入轨 | 素材入轨生成 clip（`addClip` 命令），复用现有资产层 |
+| M3.5 | `web/src/lib/plugins/builtin/editor/editor-subtitle-tools.ts` | `createSubtitleTool` → 注册 subtitle-tool（right 折叠）；SRT 导入导出（复用 `srt-parser`/`srt-resegment`）、AI 高亮、批量样式、**「从节点重建字幕片段」命令（§3.1 快照契约）** | typecheck + 新增字幕命令测试 | SRT 往返一致；重建命令替换过期快照（单向显式同步） |
+| M3.6 | `web/src/lib/plugins/builtin/editor/editor-transcription.ts` | `createTranscription` → 注册 transcription-provider；调 M4 转写任务（API 面未就绪时先 mock） | typecheck；浏览器触发转写→字幕入轨 | 转写结果落字幕轨道（ADR-0004 协议） |
+| M3.7 | `web/src/lib/plugins/builtin/editor/editor-export.ts` | `createExporter` → 注册 export-renderer；导出面板 → `buildTimelineRenderPlan` + 后端渲染任务 / ffmpeg.wasm 降级 | typecheck；浏览器导出 MP4 | 导出走单一滤镜图计划；`nodeId` 悬空引用按 §3.1 降级/报错二分 |
+| M3.8 | `web/src/pages/projects/detail.tsx` + `web/src/lib/plugins/builtin/editor/index.ts` + `web/src/lib/plugins/builtin/index.ts` | editor 视图从 `editor-slot-registry` 渲染全部插槽；8 个插件静态注册（含 editor-ai-assistant 的 M6 先注册占位贡献，M6 补实现） | `bun run build`（全量）+ 浏览器三段式布局 | 布局完整、停用插件显示空态、v1 插件不受影响 |
+
+### M4 后端任务（服务端）
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M4.1 | `backend/`：`task_timeline.go` + `transcription_whisper.go`；路由 POST `/api/timeline/transcriptions`（注册于 `RegisterTaskRoutes`） | 转写异步任务：`CreateTimelineTranscriptionTask`（feature 门控/资源归属/可转写类型校验）配额入队（local/whisper.cpp，不走模型路由与计费）；worker 顶部按类型分叉 `processTimelineTranscription`，本地 whisper.cpp HTTP 转写，结果 `ResultJSON{segments,srt,language}` 落盘 | 转写相关单测 PASS（`go test ./internal/service/ ./internal/handler/`） | 未配置 `CANVAS_WHISPER_BASE_URL` 时任务明确失败并提示 |
+| M4.2 | `backend/`：`task_render.go` + `timeline_render_plan.go`；路由 POST `/api/timeline/renders`（注册于 `RegisterTaskRoutes`） | 渲染任务：接收 v2 快照 → `buildRenderPlan`（含可渲染媒体校验）→ 服务端 ffmpeg 合成 → 产物入资源存储，`ResultJSON` 记 resourceId | render 单测 PASS | 60 分钟超时；`CANVAS_FFMPEG_PATH` 或 PATH |
+| M4.3 | `web/src/services/api/timeline-tasks.ts` + `editor-transcription.tsx` | 转写任务客户端：创建 → `waitForGenerationTask` 轮询（25min）→ 结果 segments 映射 SrtEntry 写入字幕轨道（去 mock） | typecheck 通过 | 浏览器端到端：发任务→进度→字幕入轨待用户确认 |
+
+### M5 权限执行（横切，fail-closed）
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M5.1 | `web/src/lib/plugins/plugin-permission-check.ts`（新建） | 纯函数：`checkPermission(plugin, required, context)`——声明缺失 → 拒绝（fail-closed）；`timeline.write` 拆分为 `timeline.read`/`timeline.command` 粒度 | 新增 `web/test/plugin-permission-check.test.ts`（10 用例，含 editor-shell 真实回归） | 缺失/越权/边界测试通过 ✅ |
+| M5.2 | 接入执行路径：`editor-slot-registry` 渲染时 + 命令队列入口 + 模型调用 | 插槽渲染校验、命令入队校验、AI 命令校验（`timeline.command` 未声明 → 拒绝） | `bun test test/plugin-permission-check.test.ts test/editor-*.test.ts`；**v1 插件全量既有测试回归** | 未声明权限的写操作被拒；v1 插件行为零回归（权限语义不收紧存量） |
+| M5.3 | **执行路径接入（边界说明）**：`web/src/pages/projects/detail/editor.tsx` SlotStack fail-closed 过滤（缺权限插槽 → 一行诊断条，不渲染）；`editor-shell` manifest 权限补全为 `timeline.read/timeline.command/export.run` | 命令队列入口与模型调用是**宿主全局命令**（M2 editor-commands 注册表，v1 语义）；v2 插件不代发宿主命令，仅贡献插槽。M5 权限域（timeline.*/export.run）只约束 v2 插件插槽贡献与后续 M6 AI 命令代发通道，宿主 UI 手势不受权限校验——与 ADR-0007「v1 权限语义一字不动」一致 | editor-shell 8 插槽真实回归可渲染；全量 bun test 无新增失败 | 缺权限插槽被拒渲染且有诊断；editor-shell 权限齐备可渲染全部 8 插槽 ✅ |
+
+### M6 AI 编辑交互（ADR-0007）
+
+| 步骤 | 改动文件 | 内容 | 验证 | 完成标准 |
+|---|---|---|---|---|
+| M6.1 | `web/src/lib/timeline/ai-command-schema.ts` + `web/test/fixtures/ai-commands.golden.json`（新建） | per-op 命令 JSON schema（与 M2.1 handler 同源维护）、`aiCommandSchemaVersion` 版本化；fail-closed 校验函数 | 新增 `web/test/ai-command-schema.test.ts` | 合法/非法 payload 全覆盖；单条非法整批拒绝；错误回填格式稳定 ✅（14 用例全绿；golden op 集与 EDITOR_COMMAND_OPS 黄金同步断言通过） |
+| M6.2 | `web/src/lib/timeline/timeline-summary.ts`（新建） | 时间线结构化精简摘要（轨道/片段/时长/关键属性，不含媒体二进制） | 新增 `web/test/timeline-summary.test.ts` | 摘要确定性强（同输入同输出）；大对象排除 ✅（16 用例全绿；折叠上限/中文字幕统计/空态覆盖） |
+| M6.3 | `web/src/lib/plugins/builtin/editor/editor-ai-assistant.tsx` | AI 助手：右上悬浮对话面板（OpenAI Canvas 风格，由顶部工具栏 Sparkles 入口开合；面板内文本模型选择器 + 消息流 + 空态引导 + 输入条）、命令执行链路（≤3 条直执行 / >3 条 diff 预览待确认）、宿主 registry 拒绝 failTurn 回填失败标记 | typecheck + M6.1/M6.2 测试 + `bun run build` ✅ | 自然语言→命令→撤销全链路代码侧就绪（≤3 条直执行按条入撤销栈，撤销按条回退）；非法命令回填错误；与画布会话上下文隔离（历史存 `historyRef`，仅时间线上下文入提示词）✅（浏览器冒烟待用户确认） |
+
+## 3. 依赖关系
+
+```
+M0（壳+骨架）──▶ M1（SDK v2 + 插槽链路）
+                    │
+                    ▼
+              M2（命令状态机）
+                    │
+        ┌───────────┴───────────┐
+        ▼                       ▼
+   M4（后端任务）◀───（API 面先行，M3.6/3.7 可先 mock）
+        │                       │
+        ▼                       ▼
+   M3（8 插件逐个）──▶ M5（权限执行，横切接入）
+                    │
+                    ▼
+              M6（AI 编辑交互）
+```
+
+- M3.6 / M3.7 只依赖 M4 的 **API 面**（可先用 mock 接口），不必等 M4 全部完成。
+- M5 横切：在 M3 完成后接入执行路径，避免在插件开发期被权限拦截干扰；但 M1.3 注册期就应声明权限字段。
+- M6 依赖 M2（命令）、M3（面板）、M5（权限），最后做——它复用全部前置协议，是收尾验证。
+
+## 4. 验证命令速查（以当前 package.json / go.mod 为准）
+
+| 场景 | 命令 |
+|---|---|
+| 前端类型检查（每步） | `cd web && bun run typecheck` |
+| 前端专项测试 | `cd web && bun test test/editor-commands.test.ts`（按文件替换） |
+| 前端全量构建（M3.8 / 里程碑验收） | `cd web && bun run build`（含 build:bridge + tsc + vite build，较重，非每步跑） |
+| 后端测试 | `cd backend && go test ./...` |
+| 浏览器冒烟 | 对照实施规格 §7.4 清单（编辑器三路由、明暗主题、空态、快捷键不冲突） |
+
+## 5. 每步通用完成检查
+
+- [ ] diff 只含本步目标文件，无顺手改动
+- [ ] 类型/调用方/文档同步（本步涉及的方案章节如有出入，当场修正）
+- [ ] 错误与权限路径完整（不 `catch { return defaultValue }` 吞错）
+- [ ] 验证如实记录（通过的命令 + 结果；不能浏览器验证时写明替代依据）
+- [ ] 按 AGENTS.md 提交规范 commit（`feat(editor): ...` / `test(editor): ...`）
+
+## 6. 高风险步与回退
+
+| 步骤 | 风险 | 缓解 / 回退 |
+|---|---|---|
+| M1.3 注册器 v1/v2 分支 | 破坏既有 v1 插件（eagle/prompt-optimizer/workflows/portrait-clearance） | 分支隔离 + 既有测试全量回归；异常时 revert 该 commit（v1 路径零改动原则） |
+| M3.8 detail.tsx 接线 | editor 视图影响其余 6 视图 | 视图按 id 分发，editor 分支独立渲染；回退 = revert M3.8，其余插件贡献无损 |
+| M5.2 权限收紧 | v1 插件未声明新权限域被误拒 | **fail-closed 只针对新权限域**（timeline.* / export.run / ai.text），v1 既有权限语义一字不动；先加测试再接入 |
+| M4.1 转写 provider | ~~部署路径未定~~ 已定：本地 whisper.cpp HTTP（`CANVAS_WHISPER_BASE_URL`），不接云 ASR | 语音数据不出本机；未配置仅影响转写任务（任务明确失败并提示） |
+| M2.4 手势 echo 与画布拖拽冲突 | 时间线内拖拽与画布手势系统互扰 | 复用画布事件忽略选择器约定（modal/popover/dropdown）与 `data-canvas-no-zoom` 边界，冒烟清单含快捷键不冲突项 |
+
+## 7. 里程碑验收顺序（推荐推进节奏）
+
+1. 完成 M0+M1 → **第一次演示**：`/projects/:id/editor` 占位页有真实插槽渲染（证明插件链路成立）
+2. 完成 M2 → **第二次演示**：纯命令驱动的可撤销时间线（无 UI 也能证明核心正确）
+3. 完成 M3（含 M4 API 面）→ **第三次演示**：完整三段式编辑器可编辑可导出
+4. 完成 M5+M6 → **第四次演示**：权限收紧 + 对话式剪辑（ADR-0007 完整落地）
+
+每两次演示之间建议不超过一个里程碑；若一个里程碑内停滞超过 3 次同类失败，停下记录现象、已排除项与新假设（AGENTS.md §8），再切换路径。
diff --git a/docs/plans/editor-preset-plugin-implementation.md b/docs/plans/editor-preset-plugin-implementation.md
new file mode 100644
index 000000000..c7d27a30e
--- /dev/null
+++ b/docs/plans/editor-preset-plugin-implementation.md
@@ -0,0 +1,489 @@
+# 编辑器预设插件化实施规格
+
+> 文档状态：待实施（决策已定，见 ADR-0001 ~ ADR-0005）。
+>
+> 目标读者：后续负责实现、评审和验收的 AI 或开发者。
+>
+> 关联决策：[ADR-0001 整合边界](../adr/0001-editor-integration-boundary.md)、[ADR-0002 命令协议](../adr/0002-edit-command-protocol.md)、[ADR-0003 预览导出分层](../adr/0003-preview-export-layering.md)、[ADR-0004 转写服务化](../adr/0004-autocaption-transcription-service.md)、[ADR-0005 预设插件架构](../adr/0005-editor-preset-plugin-architecture.md)、[ADR-0006 语音滤镜与模板](../adr/0006-voice-filters-and-templates.md)。
+>
+> 硬约束：遵循 AGENTS.md 的目录职责、API 合同（`request.ts` / `custom-channel-relay`）、三层设计 token 与验证纪律；编辑器能力一律以预设插件贡献，不在核心库写编辑器专属硬编码分支。
+
+## 0. 产品视图：实现完成后的编辑器
+
+> 本节描述目标形态，帮助实现者理解"做完是什么样"；与 ADR-0001 ~ 0006 决策一一对应。UI 依据 `../design/workspace-shell-design.mdx` 三段式布局与既有设计 token，不引入新设计体系。
+
+### 0.1 编辑器形态
+
+编辑器是项目详情下的独立视图，对标 Concat 面板结构（时间线 / 预览 / 素材库 / 右侧面板），落在三段式工作区壳内：
+
+```text
+┌─ 顶部栏 ──────────────────────────────────────────────┐
+│ ◀ 返回项目  剪辑中 · 已保存   ↩撤销 ↪重做    导出成片 ▸ │
+├────────┬──────────────────────────────────┬───────────┤
+│ 左侧栏  │       中央预览监视器              │ 右侧检查器 │
+│ 素材库  │   播放/暂停/时间码/帧步进         │ 选中片段   │
+│ ·角色资产│   （浏览器原生近似渲染）         │ 起止/音量  │
+│ ·本地上传│                                  │ 变速/滤镜  │
+│ ·转场/效│──────────────────────────────────│ 字幕文本   │
+│  果分类 │       时间线面板（底部）          │           │
+│        │  ┌──轨道区：视频/音频/字幕/文字──┐│           │
+│        │  │ 拖拽移动 裁剪手柄 分割 吸附   ││           │
+│        │  └──────────────────────────────┘│           │
+└────────┴──────────────────────────────────┴───────────┘
+```
+
+每个区域都是**插件插槽**（§5.2）：时间线面板（bottom）、预览监视器（center）、右侧检查器（right）、素材入轨（left）、字幕工具（right 折叠）、转写/导出（弹层）；语音滤镜与模板为增量预设插件（见 ADR-0006）。停用某插件时对应区域显示空态，其余区域不受影响。
+
+**与画布内 timeline-dialog 的定位差异（避免两套时间线 UI）**：画布 `canvas-timeline-dialog.tsx` 是**画布级快速组装**——单画布、轻量，从当前画布节点就近组装预览；编辑器是**项目级工作台**——跨画布、命令协议（ADR-0002）、撤销栈、插件面板（ADR-0005）。两者读写**同一 `TimelineProject`**、走**同一 `buildTimelineRenderPlan`**，形态层级不同、协议同源；不另立数据模型、不复制实现。
+
+**编辑器 ↔ 画布 ↔ 短剧 关联图景**（数据流，均基于既有实现）：
+
+```text
+短剧（章节 → 分镜）
+  │  chapterId / sceneId / storyboardRowId 挂在画布节点 metadata；shortDramaEnabled → guided 工作流（canvas-starter）
+  ▼
+画布（分镜画布）
+  │  buildTimelineFromNodes / syncNodeSubtitlesToTimeline（timeline-build.ts）
+  ▼
+时间线（TimelineProject v2，挂在 project 上，非画布私有）
+  │  clip.nodeId 引用画布节点；字幕 clip = subtitleEntryIndex + text 快照
+  ▼
+编辑器（/projects/:projectId/editor，本方案）
+  │  buildTimelineRenderPlan 单一滤镜图 → MP4
+  ▼
+成片（onCreateAssembledNode 合成节点放回画布；导出可落项目资产/交付，见 M 阶段待定项）
+```
+
+### 0.2 入口（三层）
+
+- **主入口 · 顶部导航 tab**：项目详情页视图切换器新增 `editor`（"剪辑"），路由 `/projects/:projectId/editor`，与「分镜制作」「项目画布」并列——从项目任何视图随时可达。实现点：`detail.tsx` 的 `DetailView` 联合类型加 `"editor"`、`views` 数组加对应项（图标建议 `Film`/`Scissors`，插在「项目画布」之后），路由复用既有 `/projects/:projectId/:view` 通配（`router.tsx`），无需新路由。
+- **到达路径（完整链路）**：全局侧边栏「短剧创作」→ `/projects` 项目列表 → 项目详情页 → 顶部 tab「剪辑」。侧边栏入口实际显示名是「短剧创作」（`navigation-tools.ts`：`slug: "projects"`、`label: "短剧创作"`、Clapperboard 图标），不是「项目」；编辑器是短剧创作功能域内、项目详情页下的一个视图，全局导航不新增任何入口。
+- **入口常驻（决策，2026-09-01）**：侧边栏与命令面板的「短剧创作」入口（`/projects`，即短剧创作模块）**不随功能开关渲染**——「短剧创作/剪辑」是普通用户核心功能，入口可见性不依赖管理员后台配置。`shortDramaEnabled` 仅保留为**部署级兜底**：管理员明确关闭短剧功能时，由 `RequireFeature` 渲染「暂未开放」提示页（带返回按钮，`require-feature.tsx`），而非隐藏入口。编辑器 `views` 项同理常驻。
+- **流程入口 · 概览流程步骤卡**：`overview.tsx` 的 productionSteps 在「镜头视频」与「交付与打包」之间插入「剪辑成片」步骤卡（`href: /projects/:projectId/editor`，完成态 = 镜头视频齐备且已有时间线），快速入口区补「进入剪辑」。
+- **状态入口 · 当前任务 CTA**：镜头视频全部就绪后，概览当前任务阶段（`overviewStage`）由"检查交付"扩展为"剪辑成片"，主 CTA 变为「开始剪辑」。
+
+### 0.3 使用流程
+
+```text
+① 项目概览 → 切"剪辑"视图 → 进入编辑器（默认 7+2 插件全开）
+② 左侧素材库选素材（角色资产/项目视频/本地上传）→ 拖入时间线（asset-ingest → directMedia）
+③ 时间线编辑：拖拽排布、裁剪手柄、分割、变速、吸附对齐
+     —— 手势先 echo 预演，松手才提交命令，可一键撤销（200 层快照）
+④ 预览监视器实时看近似效果（滤镜/转场为 CSS/canvas/Web Audio 近似）
+⑤ 右侧检查器精调选中片段（起止、音量、变速、滤镜）
+⑥ 字幕：字幕工具导入 SRT / AI 高亮；自动字幕按钮 → 后端转写任务
+     —— 进度展示 → 完成后 SRT 自动写回字幕轨道
+⑦ 导出成片：导出面板选分辨率/格式/烧录字幕 → 后端 ffmpeg 任务 → 产物下载
+```
+
+与画布工作流的闭环：**分镜/AI 生成的视频 → 项目资产 → 入轨 → 剪辑 → 烧录字幕 → 成片**，是 AI 影视创作工作台的成片出口。
+
+### 0.4 功能覆盖对照（Concat 已实现功能）
+
+| Concat 功能 | 覆盖度 | 说明 |
+| --- | --- | --- |
+| 多轨编辑（视频/音频/字幕/文字） | ✅ | TimelineProject v2 轨道类型齐全 |
+| 剪切工具 split/trim/merge | ✅ | M2 命令集含分割/裁剪/移动/删除；merge 需在 M2 命令集确认补一条 |
+| 变速 speed control | ✅ | 命令集含 setSpeed |
+| 自动字幕 | ✅（形态不同） | Concat 本地 whisper；影策服务端任务（ADR-0004），浏览器不跑模型 |
+| 字幕高亮 | ✅（领先） | 已有 subtitle-highlight-* 库；Concat 尚在 roadmap |
+| 标题与样式文本 | 🟡 | text 轨道 + 字幕工具批量样式；复杂标题动画依赖画布文本节点 |
+| 转场 transitions | 🟡 | 单一滤镜图计划含转场降级；效果库是渲染器插槽扩展点，首版基础淡入淡出 |
+| 语音滤镜 | ➕ 见 ADR-0006 | 音频 DSP：Web Audio 预览近似 + ffmpeg 音频滤镜图导出 |
+| 模板 Templates | ➕ 见 ADR-0006 | 项目快照：存为模板 / 从模板新建；模板中心暂不做 |
+| TTS 配音 | 🟡 能力在别处 | 生成式语音走既有模型渠道（ADR-0004 明确不属编辑器范围） |
+| 效果/转场库扩展（Concat roadmap） | ✅ 架构即答案 | 渲染器/滤镜图插件化正是为其设计 |
+
+## 1. 目标与范围
+
+### 1.1 目标
+
+把编辑器（时间线编辑、预览、导出、自动字幕）做成**预设插件（preset plugins）**，参考 astravia「万物皆可插件」理念：编辑器全部 UI 与能力都是插件贡献，宿主核心只保留协议层（时间线状态机、编辑命令、滤镜图计划、任务协议）。现有 `yingce.plugin/v1` 演进为 v2（UI 插槽 + 预设分发 + 权限执行校验），编辑器域是 v2 的第一个完整消费方。
+
+### 1.2 首版必须交付
+
+- 插件 SDK v2：`yingce.plugin/v2` 清单类型、UI 插槽注册 API、预设分发字段、权限执行校验（首个校验点：编辑器宿主 API）。
+- 时间线命令状态机：可序列化编辑命令 + 单队列 + 有界快照撤销（200 层）+ 手势 echo。
+- editor 预设插件（`builtin/editor/`）：时间线面板、预览监视器、右侧检查器、素材入轨、字幕工具、自动字幕（转写）、导出、AI 助手，共 8 个（7 核心 + editor-ai-assistant，见 ADR-0007）。
+- 后端任务：转写任务（ASR 可插拔）+ ffmpeg 导出任务，复用现有任务队列与配额。
+- 测试与验证：命令黄金文件、渲染计划黄金文件、插槽渲染冒烟、权限拒绝路径、AI 命令 schema 校验测试、浏览器验证清单。
+
+### 1.3 明确不做
+
+- 不做外部插件安装、插件市场、zip 上传、沙箱隔离（astravia 的租户选择机制待真正出现外部插件需求时再补）。
+- 不做多端协同命令同步（命令日志协议预留，不实现服务端广播）。
+- 不在浏览器跑 whisper；转写一律走后端任务。
+- 不新增第二套滤镜串生成路径（单一 `buildTimelineRenderPlan` 约束对插件强制生效）。
+- 不迁移既有画布 v1 插件（v1 贡献类型与字段保持兼容，无需改动）。
+
+## 2. 现状盘点（实现者必须知道的事实）
+
+以下为 2026-09-01 勘察结论，以当前代码为准：
+
+### 2.1 插件体系现状（`web/src/lib/plugins/`）
+
+- `plugin-types.ts`：`PLUGIN_API_VERSION = "yingce.plugin/v1"`；贡献类型 `provider | workflow | canvas-node | transform | command | asset-source | usage-observer | ai-capability | agent | import-export`；权限 `canvas.* / asset.* / generation.run / ai.text / media.read / usage.read / external.open`；`RegisteredPlugin` 提供 `activate/deactivate/createAssetSource/createPromptOptimizer`；`PluginManifest` 含 `surfaces`（仅声明字段，无插槽注册实现）。
+- `plugin-registry.ts`：`registerPlugin`（`assertManifest` 校验 kebab-case id、apiVersion 必须等于 v1、权限不重复、至少一种贡献）→ `Map` 存储；canvasNodes 会同步注册到 `@/lib/canvas/node-registry`。
+- `plugin-storage.ts`：启用态与配置持久化。
+- `builtin/`：`index.ts` 静态 import 5 个插件（eagle、prompt-optimizer、workflows、portrait-clearance），`application.tsx` 顶层 `import "@/lib/plugins/builtin"` 完成注册。
+- `use-plugin-store.ts`：插件启用态管理。
+
+**结构性缺口（v1 不可直接支撑编辑器插件化）**：无 UI 插槽注册 API；无 editor 域贡献类型；无预设分发语义；内置插件为源码硬编码导入；权限只有清单字符串、宿主无调用点校验。
+
+### 2.2 时间线现状（`web/src/types/timeline.ts` + `web/src/lib/timeline/`）
+
+- `TimelineProject`（v2 数据形状）：轨道/片段/directMedia 已定义；一期字幕数据已落地。
+- 纯函数库：`timeline-build.ts`（构建）、`timeline-placement.ts`（放置）、`timeline-snap.ts`（吸附）、`timeline-tracks.ts`、`timeline-view.ts`、`srt-parser.ts`、`srt-resegment.ts`、`subtitle-highlight-*`（AI 字幕高亮）。
+- 导出规划：`timeline-to-ffmpeg.ts` 导出 `buildTimelineRenderPlan(timeline, sources, context): TimelineRenderPlan`（含 `steps` 与 `SUBTITLE_FILE`），是**唯一的**滤镜图计划来源。
+- 画布 ↔ 时间线引用：`timeline-build.ts` 的 `buildTimelineFromNodes`（画布节点 → 时间线）与 `syncNodeSubtitlesToTimeline`（节点字幕 → 时间线字幕轨道，`project.tsx` 字幕保存时调用）；`clip.nodeId` 引用画布节点、字幕 clip 带 `subtitleEntryIndex` + `text` 快照；画布内 `canvas-timeline-dialog.tsx` 已有组装/裁剪/入轨/成片回画布闭环（编辑器为其**项目级形态**，同一 `TimelineProject`，见 §3.1）。
+- 尚无编辑命令层：当前修改模型是直接写状态，没有命令/撤销/echo。
+
+### 2.3 后端任务现状（`backend/internal/`）
+
+- 任务模型在 `backend/internal/model/models_task.go`；任务输出在 `service/task_output.go`；provider 调度在 `service/provider.go`。
+- 后端目前不执行 ffmpeg；无 ASR/转写能力。
+
+### 2.4 设计资产
+
+- `docs/design/workspace-shell-design.mdx`：三段式布局（侧栏 / 主区 / 顶部栏）与设计 token，编辑器面板复用，不引入新设计体系。
+
+## 3. 目标架构
+
+```text
+┌──────────────────────── Web / React ─────────────────────────┐
+│  宿主核心（协议层，冻结扩展）                                 │
+│    ├─ timeline 状态机（真相源）——命令队列/apply/快照撤销     │
+│    ├─ 滤镜图计划 buildTimelineRenderPlan（单一来源）           │
+│    ├─ 任务协议（转写/导出任务客户端）                         │
+│    └─ 插件宿主：editor-slot-registry 插槽渲染 + 权限执行校验  │
+├──────────────────────────────────────────────────────────────┤
+│  插件 SDK v2（yingce.plugin/v2）                              │
+│    ├─ definePlugin 统一形态（v1 字段兼容）                    │
+│    ├─ UI 插槽注册 API（面板/渲染器/工具/快捷键域）            │
+│    ├─ 预设分发（preset: true, defaultEnabled）                │
+│    └─ 权限执行（宿主调用点 fail-closed 校验）                 │
+├──────────────────────────────────────────────────────────────┤
+│  editor 预设插件（builtin/editor/，默认启用不可卸载）          │
+│    ├─ editor-timeline-panel      时间线面板                   │
+│    ├─ editor-preview-monitor     预览监视器（近似渲染）        │
+│    ├─ editor-inspector           右侧检查器                   │
+│    ├─ editor-asset-ingest        素材入轨                     │
+│    ├─ editor-subtitle-tools      字幕工具                     │
+│    ├─ editor-transcription       自动字幕（转写面板）          │
+│    ├─ editor-export              导出面板                     │
+│    └─ editor-ai-assistant        AI 助手（对话式剪辑，ADR-0007）│
+└──────────────────────────────────────────────────────────────┘
+        │ 任务协议（前端不变）
+┌───────▼───────────── Go 后端 ───────────────┐
+│  任务队列 + 配额：transcription / render 任务 │
+│    ├─ ASR provider（whisper.cpp / 云 ASR 可插拔）│
+│    └─ ffmpeg 导出（主路径；wasm 为浏览器降级）  │
+└──────────────────────────────────────────────┘
+```
+
+数据流（编辑）：UI 手势 → 本地 echo 预演 → `release` 提交一个编辑命令 → 单队列 → reducer → 新 `TimelineProject`（真相源）→ 快照撤销栈 + 1.5s 防抖保存（localforage + 后端项目接口）。
+
+### 3.1 引用契约：画布节点 ↔ 时间线片段
+
+时间线片段与画布节点是**层间引用**而非合并模型：clip 以 `nodeId` 引用画布节点（素材来源），字幕以 `subtitleEntryIndex` + `text` 快照引用节点字幕。现有实现已暴露 3 个真实耦合点，编辑器实现必须立契约束缚：
+
+1. **媒体元数据双份**：`timeline-build.ts` 构建 clip 时把节点 `durationMs` 复制为 `sourceDurationMs`，构建后节点时长变化不自动同步。
+2. **字幕双份（快照契约）**：节点 `subtitleEntries` 是实体，字幕 clip `text` 是快照。`syncNodeSubtitlesToTimeline` 已提供「节点 → 时间线」单向同步（`project.tsx` 字幕保存时调用）；「时间线 → 节点」方向**不自动回写**——编辑后由 `editor-subtitle-tools` 提供显式「从节点重建字幕片段」命令，把漂移变成用户可操作的动作，不做双向隐式同步。
+3. **nodeId 悬空引用**：节点删除/替换后 clip 引用失效。render 层（`buildTimelineRenderPlan` sources 解析）必须区分两种结果：**可降级**（跳过该 clip 并提示）与**不可解析**（报错并定位到具体 clip），禁止静默产出错误渲染。
+
+契约总原则：**时间线以「快照 + 可重建」持有来自画布的数据，单向显式同步，双向不同步**；画布数据变更不自动改写时间线，避免隐式漂移。与画布内 `canvas-timeline-dialog`（画布级快速组装，单画布、轻量）不同，编辑器是**项目级工作台**（跨画布、命令协议、撤销栈、插件面板）——两者读写同一 `TimelineProject`、同一 `buildTimelineRenderPlan`，形态层级不同、协议同源。
+
+## 4. 分阶段实施计划
+
+### M1 插件 SDK v2（前端插件体系演进）
+
+目标：v1 → v2 类型与注册机制，向后兼容；编辑器域贡献类型与插槽注册表就位。
+
+任务：
+
+1. `web/src/lib/plugins/plugin-types.ts`
+   - 新增 `PLUGIN_API_VERSION_V2 = "yingce.plugin/v2"`；`PluginManifest.apiVersion` 允许 v1 | v2。
+   - 新增 editor 贡献类型：`timeline-panel | preview-renderer | export-renderer | transcription-provider | subtitle-tool | inspector-panel | asset-ingest | shortcut-scope`（并入 `PluginContributionKind` 与 `PluginContributions`，v1 插件不声明即为空）。
+   - 新增权限：`timeline.read / timeline.write / timeline.command / transcription.run / export.run`（并入 `PluginPermission` 联合类型）。
+   - 新增预设分发字段：`preset?: boolean`、`defaultEnabled?: boolean`（默认 `preset: false`，v1 清单不设即保持现状）。
+   - 新增 `RegisteredPlugin` 的 editor 工厂入口：`createTimelinePanel? / createPreviewRenderer? / createExportRenderer? / createTranscriptionProvider? / createSubtitleTool?`（与 `createAssetSource` 同构）。
+2. 新建 `web/src/lib/plugins/editor-slot-registry.ts`：UI 插槽注册表与渲染入口（接口草案见 §5.2），含插槽去重（同一 pluginId+slotId 幂等覆盖）、顺序（`order` 字段）、卸载（`unregisterPlugin` 时同步清理）。
+3. `web/src/lib/plugins/plugin-registry.ts`：`assertManifest` 按 apiVersion 分支校验；v2 清单允许空 `contributes`（若仅贡献 UI 插槽，插槽在注册时单独校验）；注册/注销时联动 `editor-slot-registry`。
+4. `web/src/lib/plugins/builtin/index.ts`：保持静态导入，语义化为"预设插件入口"（注释标明）；新增 `builtin/editor/` 子目录。
+
+产出：v1 插件零改动可运行；`listRegisteredManifests` 可枚举 v2 清单。
+验证：`cd web && bun run build` 通过；现有 5 个 builtin 插件注册无回归。
+
+### M2 时间线命令状态机（宿主核心协议）
+
+目标：时间线唯一修改入口命令化，撤销/echo/保存就位；命令 handler 可插件注册。
+
+任务：
+
+1. 新建 `web/src/lib/timeline/editor-commands.ts`
+   - `type EditCommand = { op: string; payload: unknown }`；`type CommandHandler = (state: TimelineProject, payload: unknown) => TimelineProject`（纯函数，禁止依赖组件实例）。
+   - `createEditorCommandRegistry()`：`register(op, handler)`（宿主与插件共用，插件经宿主 API 注册）、`apply(state, cmd)`（未知 op 抛错，fail-closed）、黄金命令集合（`addClip / moveClip / trimClip / splitClip / deleteClip / setVolume / setSpeed / addSubtitle / updateSubtitle / deleteSubtitle / setDirectMedia / ...`，首版以一期/二期能力为准）。
+2. 新建 `web/src/lib/timeline/editor-history.ts`：有界快照撤销（`undoStack` / `redoStack` 各 200 层，快照只存结构化模型，媒体大对象以 directMedia 引用/存储 key 入快照）；`undo() / redo() / push(state)`；重做栈在 push 时清空。
+3. 新建 `web/src/lib/timeline/editor-store.ts`：命令单队列（串行 apply）、`dispatch(cmd)` 入口、快照撤销接入、1.5s 防抖保存（localforage user-scope + 后端项目接口；写失败必须上报，不吞错）。
+4. 手势 echo：在 `editor-store` 提供 `previewGesture(state)` 只读预演（拖拽/裁剪位置），`commitGesture(cmd)` 提交唯一命令；撤销粒度是手势。
+5. 锁定滤镜图计划：`timeline-to-ffmpeg.ts` 的 `buildTimelineRenderPlan` 标注为协议模块（新增 JSDoc：插件不得绕过）；`timeline-export.ts` 保持降级路径。**render 层按 §3.1 契约处理 `nodeId` 悬空引用**：可降级（跳过 + 提示）与不可解析（报错 + 定位 clip）两条路径，禁止静默错误渲染。
+
+产出：任意编辑操作可回放为命令序列；撤销/重做可用；插件可注册自定义 op。
+验证：命令黄金文件测试（§7.1）；既有字幕一期功能经命令层无回归。
+
+### M3 editor 预设插件（UI 与能力插件化）
+
+目标：7 个核心预设插件全部以 v2 清单 + 插槽贡献形态实现（AI 助手插件在 M6，见 ADR-0007），宿主核心不再新增编辑器 UI 硬编码分支。
+
+任务（每个插件 = `builtin/editor/<name>.ts`，`manifest.apiVersion = "yingce.plugin/v2"`，`preset: true`，`defaultEnabled: true`）：
+
+1. `editor-timeline-panel.ts`：`createTimelinePanel` → 注册 `timeline-panel` 插槽（dock: bottom）；轨道/片段渲染、拖拽移动、裁剪手柄、吸附复用 `timeline-snap`、右键菜单；组件只消费状态机视图并派发命令。
+2. `editor-preview-monitor.ts`：`createPreviewRenderer` → 注册 `preview-renderer`；`<video>` 裁剪/缩放/透明度/音量 + CSS 滤镜 + canvas 近似合成（ADR-0003 近似层）；交互真相非导出像素。
+3. `editor-inspector.ts`：`createInspector` → 注册 `inspector-panel`（dock: right）；选中片段属性编辑（起止、音量、变速、字幕文本），全部经命令提交。
+4. `editor-asset-ingest.ts`：`createAssetIngest` → 注册 `asset-ingest`；素材库/项目资产/本地上传入轨为 directMedia，复用 `@/services/` 文件与媒体层。
+5. `editor-subtitle-tools.ts`：`createSubtitleTool` → 注册 `subtitle-tool`；SRT 导入导出（`srt-parser` / `srt-resegment`）、AI 高亮（`subtitle-highlight-*`）、批量样式；**「从节点重建字幕片段」命令**（按 §3.1 字幕快照契约：把节点 `subtitleEntries` 显式同步为时间线字幕 clip，替换过期快照）。
+6. `editor-transcription.ts`：`createTranscriptionProvider` → 注册 `transcription-provider`；提交后端转写任务（§M4 任务协议客户端）、进度/重试 UI、结果写回字幕轨道。
+7. `editor-export.ts`：`createExportRenderer` → 注册 `export-renderer`；导出面板（分辨率/格式/字幕烧录开关）；默认执行器走后端 ffmpeg 任务，降级走 `exportTimelineToMp4`（wasm）；两者吃同一 `buildTimelineRenderPlan` 计划。
+
+宿主接线：
+
+- `detail.tsx`：`DetailView` 联合类型加 `"editor"`，`views` 数组新增「剪辑」项（常驻，与侧边栏「短剧创作」入口一致，不随功能开关过滤）；编辑器视图页壳复用三段式布局（`../design/workspace-shell-design.mdx`），从 `editor-slot-registry` 渲染各插槽。
+- `application.tsx`：无需新增路由；仅确保编辑器视图页壳挂载后正确初始化 `editor-slot-registry` 渲染；无插槽注册时显示空态（插件被停用时不渲染对应区域）。
+- 页面壳只做布局与插槽聚合，不含编辑器业务分支。
+
+产出：编辑器全部 UI 由插件贡献；停用某插件即停用对应区域。
+验证：浏览器冒烟（§7.4）；每个插件独立可停用/启用。
+
+### M4 后端任务（转写 + 导出）
+
+目标：转写与 ffmpeg 导出作为后端任务，复用任务队列与配额；前端协议不变。
+
+任务：
+
+1. 任务类型扩展：`backend/internal/model/models_task.go` 增加任务类型 `transcription` 与 `render`（沿用现有任务状态机：pending/running/success/failed/canceled）。
+2. 新建 `backend/internal/service/transcription/`：ASR provider 接口（`Transcribe(ctx, audioRef, opts) (segments, error)`）+ 两个实现（whisper.cpp 本地、云 ASR 预留）；service 层负责校验归属、配额、任务编排、结果 SRT 落库；SSRF/私网放行遵循 AGENTS.md 第 5 节。
+3. 新建 `backend/internal/service/render/`：ffmpeg 导出任务，消费前端传来的 `TimelineRenderPlan`（`buildTimelineRenderPlan` 产物，前端序列化上传）；按 plan.steps 执行（trim → gap → concat → subtitle → burn）；产物写入资源存储。
+4. handler：`/api/timeline/transcription`（提交/查询/取消）、`/api/timeline/render`（提交/查询/取消），响应统一 `{ code, data, msg }`；写路径强校验归属与配额。
+5. 前端任务客户端：`web/src/services/api/timeline-tasks.ts`（经 `apiClient`，复用 `request<T>`；不新建 axios 实例），`editor-transcription` 与 `editor-export` 插件消费。
+6. 数据库字段/表变化同步 `docs/content/docs/backend/backend-database.mdx`（AGENTS.md 第 5 节义务）。
+
+产出：转写/导出为异步任务，浏览器 wasm 仅为无后端降级。
+验证：后端 `cd backend && go test ./...`；任务冒烟路径（提交→轮询→产物可访问）。
+
+### M5 权限执行校验与测试收尾
+
+目标：权限从"声明"变为"执行"；黄金文件与浏览器验证收口；文档同步。
+
+任务：
+
+1. 权限执行校验：新建 `web/src/lib/plugins/plugin-permission-check.ts`，宿主 API 调用点（命令入队、转写提交、导出提交、素材读取、外部打开）统一走 `checkPermission(pluginId, permission)`，fail-closed（未声明 → 拒绝并报错；后续按 astravia 语义可扩展 warn+noop / 抛错三档，首版只做 fail-closed）。
+2. 黄金文件：命令序列黄金文件（§7.1）、渲染计划黄金文件（§7.2）入库为测试夹具。
+3. 浏览器验证清单执行（§7.4），关键路由/明暗主题/滚动/空态/核心交互逐项记录。
+4. 文档同步：`docs/content/docs/progress/todo.mdx` 更新待办；已实现未确认项写入 `docs/content/docs/progress/pending-test.mdx`；功能清单 `docs/content/docs/overview/features.mdx` 补编辑器插件化条目。
+
+产出：无权限插件调用编辑器 API 被拒绝且界面给出明确提示。
+验证：权限拒绝路径测试（§7.3）；全量构建通过。
+
+### M6 AI 编辑交互（对话式剪辑，ADR-0007）
+
+目标：AI 作为时间线一等公民编辑者——自然语言 → 受约束命令 JSON → 命令队列执行，与人编辑共享撤销栈；接入既有模型渠道与画布聊天 UI 模式。
+
+任务：
+
+1. 新建 `web/src/lib/timeline/ai-command-schema.ts`：per-op 命令 JSON schema（与 `editor-commands.ts` handler 同源维护），`aiCommandSchemaVersion` 版本化；新增 `timeline-summary.ts`：时间线结构化精简摘要（轨道/片段/时长/关键属性，不含媒体二进制），作为 AI 上下文。
+2. 新建 `web/src/lib/plugins/builtin/editor/editor-ai-assistant.ts`：预设插件（`ai-assistant` 贡献类型 + `ai.text` / `timeline.read` / `timeline.command` 权限），对话面板插槽（right），复用画布 agent 聊天 UI 交互模式（流式输出/可停止），不移植画布会话协议。
+3. AI 命令执行链路：LLM 输出 `{ commands, reasoning }` → schema 校验（fail-closed，任一失败整批拒绝并回填错误供 AI 自纠）→ 权限校验 → 入队；≤3 条直接执行，>3 条或涉及删除/整体重排先展示 diff 预览待确认（ADR-0007 执行语义）。
+4. AI 只读问答：`timeline.read` 分析对话（节奏/剪辑建议），不产生命令；`timeline.command` 未声明时写操作被拒。
+5. 聚合入口：AI 面板可调起转写（ADR-0004）、AI 字幕高亮（既有 `subtitle-highlight-*`）、AI 素材入轨（生成链路 + asset-ingest），各自协议不变。
+
+产出：对话式剪辑可用；AI 命令与人命令同撤销栈、同黄金文件测试。
+验证：AI 命令 schema 校验测试（§7.1 扩展）；浏览器对话冒烟（§7.4 扩展）。
+
+### M 阶段待定项（画布 / 短剧深化关联）
+
+不阻塞首版，实现中按需决策：
+
+1. **章节 → 时间线导航**：画布节点有 `chapterId`（`canvas.ts` metadata），时间线 clip 目前**没有** `chapterId`。若「从分镜入轨」时把章节信息带入 clip（`timeline-build.ts` 扩展），编辑器可提供「按章节查看 / 定位时间线」，直接呼应短剧章节结构。决策点：clip 模型加 `chapterId` 字段 vs 通过 `nodeId` 反查节点章节。
+2. **成片 → 交付**：当前导出走 `onCreateAssembledNode` 回画布；可顺带把 MP4 落入项目资产 / 交付物，接进 overview「交付与打包」流程（`productionSteps` 末步）。决策点：导出产物写入资产库 vs 独立交付物表。
+
+## 5. 接口草案
+
+### 5.1 v2 清单扩展（`plugin-types.ts` 增量）
+
+```ts
+export const PLUGIN_API_VERSION_V2 = "yingce.plugin/v2" as const;
+
+export type EditorContributionKind =
+    | "timeline-panel" | "preview-renderer" | "export-renderer"
+    | "transcription-provider" | "subtitle-tool" | "inspector-panel"
+    | "asset-ingest" | "shortcut-scope";
+
+export type PluginPermissionV2 =
+    | PluginPermission
+    | "timeline.read" | "timeline.write" | "timeline.command"
+    | "transcription.run" | "export.run";
+
+// PluginManifest 增量字段（v2 可选）
+//   preset?: boolean            // 预设插件（随应用分发，默认启用，不可卸载删改）
+//   defaultEnabled?: boolean    // 默认启用（preset 时恒 true）
+//   apiVersion: "yingce.plugin/v1" | "yingce.plugin/v2"
+```
+
+### 5.2 UI 插槽注册（新建 `web/src/lib/plugins/editor-slot-registry.ts`）
+
+```ts
+export type EditorSlotDock = "bottom" | "right" | "left" | "center" | "fullscreen";
+
+export type TimelinePanelSlot = {
+    slotId: string; pluginId: string; order: number; dock: EditorSlotDock;
+    component: React.ComponentType<TimelinePanelProps>;
+};
+
+export type PreviewRendererSlot = {
+    slotId: string; pluginId: string; order: number;
+    render: (ctx: PreviewRendererContext) => React.ReactNode;   // 浏览器原生近似渲染
+};
+
+export type ExportRendererSlot = {
+    slotId: string; pluginId: string; order: number;
+    // 消费 buildTimelineRenderPlan 产物；禁止插件内拼第二套滤镜串
+    execute: (plan: TimelineRenderPlan, ctx: ExportContext) => Promise<ExportResult>;
+    fallback?: boolean;   // true = wasm 降级执行器
+};
+
+export type TranscriptionProviderSlot = {
+    slotId: string; pluginId: string; order: number;
+    submit: (req: TranscriptionRequest, ctx: TranscriptionContext) => Promise<TaskHandle>;
+};
+
+export type SubtitleToolSlot = {
+    slotId: string; pluginId: string; order: number; dock: EditorSlotDock;
+    component: React.ComponentType<SubtitleToolProps>;
+};
+
+export type InspectorPanelSlot = {
+    slotId: string; pluginId: string; order: number; dock: "right";
+    component: React.ComponentType<InspectorProps>;
+};
+
+export type AssetIngestSlot = {
+    slotId: string; pluginId: string; order: number; dock: "left" | "bottom";
+    component: React.ComponentType<AssetIngestProps>;
+};
+
+// 注册 / 渲染 / 卸载
+export function registerTimelinePanel(slot: TimelinePanelSlot): void;
+export function registerPreviewRenderer(slot: PreviewRendererSlot): void;
+export function registerExportRenderer(slot: ExportRendererSlot): void;
+export function registerTranscriptionProvider(slot: TranscriptionProviderSlot): void;
+export function registerSubtitleTool(slot: SubtitleToolSlot): void;
+export function registerInspectorPanel(slot: InspectorPanelSlot): void;
+export function registerAssetIngest(slot: AssetIngestSlot): void;
+export function unregisterEditorSlots(pluginId: string): void;   // unregisterPlugin 联动
+export function listEditorSlots(): EditorSlotIndex;               // 页面壳按 dock 渲染
+```
+
+### 5.3 命令协议（新建 `web/src/lib/timeline/editor-commands.ts`）
+
+```ts
+export type EditCommand = { op: string; payload: unknown };
+
+export type CommandHandler = (state: TimelineProject, payload: unknown) => TimelineProject;
+
+export function createEditorCommandRegistry(): {
+    register: (op: string, handler: CommandHandler) => void;   // 插件经宿主 API 调用
+    apply: (state: TimelineProject, cmd: EditCommand) => TimelineProject;  // 未知 op 抛错
+    knownOps: () => string[];
+};
+
+// 手势 echo（editor-store 内）：previewGesture 只读预演，commitGesture 提交唯一命令
+```
+
+### 5.4 预设插件清单（`web/src/lib/plugins/builtin/editor/`）
+
+| 文件 | 插槽 | 权限 | 依赖的宿主协议 |
+| --- | --- | --- | --- |
+| `editor-timeline-panel.ts` | timeline-panel (bottom) | timeline.read / timeline.write / timeline.command | 命令状态机、timeline-snap |
+| `editor-preview-monitor.ts` | preview-renderer (center) | timeline.read / media.read | 近似渲染、directMedia 解析 |
+| `editor-inspector.ts` | inspector-panel (right) | timeline.read / timeline.write | 命令状态机 |
+| `editor-asset-ingest.ts` | asset-ingest (left) | asset.read / asset.search / asset.import / timeline.write | 素材服务、directMedia |
+| `editor-subtitle-tools.ts` | subtitle-tool (right) | timeline.read / timeline.write / ai.text | srt-parser / srt-resegment / subtitle-highlight-* |
+| `editor-transcription.ts` | transcription-provider | timeline.read / timeline.write / transcription.run | 后端任务协议（M4） |
+| `editor-export.ts` | export-renderer | timeline.read / export.run / media.read | buildTimelineRenderPlan、后端 render 任务 / wasm 降级 |
+| `editor-ai-assistant.ts` | ai-assistant (right) | ai.text / timeline.read / timeline.command | ai-command-schema、timeline-summary、模型渠道、命令队列（ADR-0007） |
+
+### 5.5 后端任务协议（M4）
+
+- 提交：`POST /api/timeline/transcription` `{ assetRef | clipRef, provider?, lang? }` → `{ taskId }`；查询 `GET /api/timeline/transcription/:taskId`；取消 `DELETE /api/timeline/transcription/:taskId`。
+- 提交：`POST /api/timeline/render` `{ plan: TimelineRenderPlan, sources: TimelineRenderSource[], opts? }` → `{ taskId }`；查询/取消同构。
+- 结果：转写任务返回 SRT（写回字幕轨道）；render 任务返回资源存储 key。
+- 前端客户端：`web/src/services/api/timeline-tasks.ts`（`apiClient` / `request<T>`，AbortSignal 透传，轮询或 SSE 沿用既有任务约定）。
+
+## 6. 文件规划
+
+新建：
+
+- `web/src/lib/plugins/editor-slot-registry.ts`
+- `web/src/lib/plugins/plugin-permission-check.ts`
+- `web/src/lib/timeline/editor-commands.ts`、`editor-history.ts`、`editor-store.ts`、`ai-command-schema.ts`、`timeline-summary.ts`
+- `web/src/lib/plugins/builtin/editor/editor-timeline-panel.ts`、`editor-preview-monitor.ts`、`editor-inspector.ts`、`editor-asset-ingest.ts`、`editor-subtitle-tools.ts`、`editor-transcription.ts`、`editor-export.ts`、`editor-ai-assistant.ts`、`index.ts`
+- `web/src/services/api/timeline-tasks.ts`
+- `backend/internal/service/transcription/`、`backend/internal/service/render/`
+- 测试：`web/src/lib/timeline/__tests__/editor-commands.test.ts`、`editor-history.test.ts`、`ai-command-schema.test.ts`、`timeline-summary.test.ts`、`render-plan.golden.test.ts`、`web/src/lib/plugins/__tests__/editor-slot-registry.test.ts`、`permission-check.test.ts`；夹具 `web/src/lib/timeline/__fixtures__/commands.golden.json`、`ai-commands.golden.json`、`render-plans.golden.json`
+
+修改：
+
+- `web/src/lib/plugins/plugin-types.ts`（v2 类型）、`plugin-registry.ts`（v2 分支 + 插槽联动）、`builtin/index.ts`（editor 预设入口）
+- `web/src/application.tsx`（编辑器页面壳接线插槽；不新增业务分支）
+- `backend/internal/model/models_task.go`（任务类型）、`backend/internal/handler/`（transcription/render handler）
+- `docs/content/docs/backend/backend-database.mdx`（任务表变化）、`docs/content/docs/progress/todo.mdx`、`pending-test.mdx`、`overview/features.mdx`
+
+## 7. 测试与验证策略
+
+### 7.1 命令黄金文件
+
+命令序列 → 期望状态快照的 JSON 夹具（`commands.golden.json`）：新增/移动/裁剪/分割/字幕编辑等命令逐个断言；插件自定义 op 的黄金文件由插件目录自带。回归时 `bun test` 比对夹具，防 reducer 漂移。
+
+**扩展（M6 / ADR-0007）**：`ai-commands.golden.json` 存 AI 命令序列 → 状态快照；`ai-command-schema.test.ts` 校验合法/非法 payload（fail-closed：单条非法整批拒绝、错误信息回填格式）。AI 命令与人命令共用同一黄金文件体系，防止 schema 与 handler 漂移。
+
+### 7.2 渲染计划黄金文件
+
+`buildTimelineRenderPlan` 对代表性时间线（多轨/间隙/字幕/转场降级）输出计划快照；任何新增效果必须更新夹具而非绕过测试——这是"单一滤镜图计划"的机器闸门。
+
+### 7.3 权限拒绝路径
+
+单元测试：清单未声明 `timeline.command` 的插件调用命令入队被拒；`transcription.run` 未声明提交转写被拒；界面提示明确（不静默）。
+
+### 7.4 浏览器冒烟清单
+
+- 编辑器路由加载：三段式布局渲染，各插槽区域来自插件注册表。
+- 停用某插件（如 preview-monitor）→ 预览区域空态，其余区域正常。
+- 拖拽移动/裁剪：echo 预演流畅，release 后命令入队、撤销一次回退手势粒度。
+- 明暗主题切换、窄屏降级（dock 折叠）。
+- 转写：提交任务 → 进度 → SRT 写回字幕轨道；导出：后端任务产物可下载；无后端时 wasm 降级可导出。
+- 快捷键作用域（shortcut-scope 插槽）不与画布快捷键冲突。
+- AI 对话冒烟：对话面板打开/流式输出/停止；自然语言 → 命令执行 → 撤销回退；非法命令（schema 错/权限不足）整批拒绝并回填错误；批量改动（>3 条）显示 diff 预览待确认。
+
+### 7.5 验证纪律
+
+按 AGENTS.md 第 8 节选择最小充分命令并如实记录：前端 `cd web && bun run build`、专项 `bun test ...`；后端 `cd backend && go test ./...`；无法浏览器验证时说明替代依据，不把静态阅读写成运行验证。
+
+## 8. 风险、依赖与未决问题
+
+- **v1/v2 并存**：`assertManifest` 双版本分支是首个兼容点；回归范围限现有 5 个 builtin 插件，风险可控。M1 结束前必须跑通全部既有插件注册。
+- **快照撤销内存**：快照只存结构化模型，directMedia 引用入快照不复制二进制；200 层为上限，超限时丢弃最旧快照（与 ADR-0002 一致）。
+- **转写模型部署**：whisper.cpp 需要后端机器与模型权重；provider 接口先行、首版可只接 whisper.cpp，云 ASR 为预留接口。模型下载与部署路径在 M4 单独确认（不影响前端协议）。
+- **插件间耦合**：editor 预设插件只允许依赖宿主协议与共享纯函数库，禁止插件互相 import（评审时检查 import 图）。
+- **已确认**：路由挂载为**项目内视图**——复用 `/projects/:projectId/:view` 通配（`router.tsx` 第 153 行已存在），`DetailView` 加 `"editor"`，不新增顶层路由、不采用画布内嵌面板；与「分镜制作」「项目画布」同级 tab。
+- **未决**：预览近似与导出像素的级差表（哪些效果允许差、差多少）在 M3 评审时定稿。
+
+- **画布 ↔ 时间线引用耦合**：`nodeId` 悬空引用（节点删除）与字幕快照漂移（节点字幕变更不回写）是真实存在的层间耦合。约束见 §3.1：render 层降级/报错二分、字幕单向显式同步；M2/M3 按契约实现。剩余风险是节点删除后用户需手动清理悬空 clip（右键「定位来源/移除」缓解，列入后续迭代）。
+
+## 9. 交付前检查清单
+
+- [ ] 改动聚焦：未动 v1 插件与画布/生成链路既有行为。
+- [ ] 调用方与类型同步：v2 清单、插槽类型、命令协议三处类型一致。
+- [ ] 错误/权限/数据归属完整：写路径强校验、fail-closed、配额与归属不遗漏。
+- [ ] 文档同步：ADR、backend-database、todo、pending-test、features 一致。
+- [ ] 验证如实：黄金文件 + 浏览器冒烟记录在案，未把静态阅读写成运行验证。
+- [ ] 未留下密钥/本地数据。
diff --git a/docs/plans/m4-transcription-render-design.md b/docs/plans/m4-transcription-render-design.md
new file mode 100644
index 000000000..342524dc2
--- /dev/null
+++ b/docs/plans/m4-transcription-render-design.md
@@ -0,0 +1,145 @@
+# M4 转写与渲染任务设计（增量）
+
+> 状态：M4.1–M4.3 已实现并提交（执行侧 e9d1b8ad、创建 API bf26ebb1、前端字幕回写 fd5e8139、
+> 渲染任务 3f16d13b）。本文按实现回写；任何出入以 `backend/internal/service/` 现行代码为准。
+> 参考锚点：`task_worker.go`、`backend/internal/repository/repository.go`、
+> `backend/internal/handler/routes.go`（各小节内另行标注实现文件）。
+
+## 1. 现状边界（调研结论）
+
+现有模型生成链路对"任务"的约定：
+
+- `CreateTask`（`task_creation.go`）：draining 检查 → prompt/type 校验 → **模型路由**
+  `resolveTaskModelSelection`（绑定 logical model / revision / route / channel model / billing）→
+  额度与活跃任务配额 → 落库 `queued`。`text_replay` 是唯一旁路（前端自管、不排队）。
+- worker（`task_worker.go`）：`ClaimNextTask` **不过滤 task type**——任何 `queued` 都会被模型
+  worker 领取；`processClaimedTask` 随后做二次路由、billing `MarkRunning`、provider 执行、
+  `handleSuccess`（billing settle + session/message 落库）。
+- 结论（实现，修正原草案）：M4 任务**进入同一公共队列**，由唯一 worker 池领取
+  （`ClaimNextTask` 不过滤类型），但在 `processClaimedTask` 顶部按类型分叉到独立执行器，
+  **不经计费与模型渠道路由**（`beginTaskRouteAttempt` / `MarkBillingRunning` /
+  `routeExecutor` / `handleSuccess` 全部跳过）；终态分别走 `SaveTaskCompletion`（成功）/
+  `UpdateTaskTerminalState`（失败）。
+
+## 2. 架构决策
+
+1. **新任务类型常量**（放 `backend/internal/model`，与 `TaskStatus*` 并列）：
+   - `TaskTypeTimelineTranscription = "timeline_transcription"`
+   - `TaskTypeTimelineRender = "timeline_render"`
+   两者都不经过 `validateTaskType` 白名单（创建走独立入口）。
+2. **创建走独立 API 与 service 方法**（不经过 `POST /api/tasks` 的模型路由/计费入口）：
+   - `POST /api/timeline/transcriptions`（M4.1，`CreateTimelineTranscriptionTask`）
+   - `POST /api/timeline/renders`（M4.2，`CreateTimelineRenderTask`）
+   - 两路由**注册在 `RegisterTaskRoutes` 内**（挂载于 `/api` 组），复用任务路由组的
+     鉴权/限流骨架（限流键 `timeline-ts:<userID>` 等），非独立路由组。
+   - 复用现有任务基础设施：同一 `tasks` 表、同一 `TaskStatus` 状态机、租约/取消原语；
+     无 billing/session/message 关联（`BillingOrderID` 为空，收尾走旁路终态）。
+   - 查询与取消**复用现有端点**：`GET /api/tasks/:id`、`POST /api/tasks/:id/cancel`
+     （service 的 `Task()` / `CancelTask()` 均与 task type 无关，已核对）。
+3. **单一 worker 池，领取不过滤**（实现修正原草案）：`ClaimNextTask` **不加类型过滤**
+   ——worker 是 queued 任务的唯一领取方，若按类型排除会使两类新任务无人领取；改为在
+   `processClaimedTask` 顶部按 `task.Type` 分叉（见决策 4）。任务类型常量从 `model` 包引入。
+4. **`processClaimedTask` 顶部按类型分叉**：在 cancelled 复查之后、stage 覆盖/路由之前，
+   `timeline_transcription` → `processTimelineTranscription(task, ctx)`（`task_timeline.go`）、
+   `timeline_render` → `processTimelineRender(task, ctx)`（`task_render.go`），复用外层已建立的
+   租约续期、`registerActiveTask`（取消即时生效）与超时 context 框架。超时
+   `taskExecutionTimeoutWithPolicy` 分叉：转写 **20 分钟**、渲染 **60 分钟**（草案 30 分钟已改）。
+5. **旁路终态**：转写/渲染成功不用 `handleSuccess`，`ResultJSON` 落盘后
+   `repo.SaveTaskCompletion(task, running, nil, nil, nil)`（清租约由框架现有 defer 完成）；
+   失败走 `repo.UpdateTaskTerminalState(failed, stage, message, now)` 记可读错误。日志沿用 `s.log`。
+
+## 3. M4.1 转写任务规格
+
+### 3.1 输入（`POST /api/timeline/transcriptions` body，路由注册于 `RegisterTaskRoutes`）
+
+```jsonc
+{
+  "resourceId": "string",   // 必填，音频/视频资源；校验归属且存在
+  "language": "zh",         // 可选，默认空 = whisper 自动检测
+  "projectId": "string"     // 可选，记录到任务归属字段（ProjectID）
+}
+```
+
+校验顺序（`CreateTimelineTranscriptionTask`）：`IsDraining`(503) → `RequireFeature`
+（timelineTranscription，默认开）→ `Resource()` 归属读取（失败提示"无法读取待转写媒体，
+可能已被删除"）→ `isTranscribableMime`（失败提示"仅支持音视频文件转写"）→
+`RuntimePolicy` → 配额入队（`createTaskWithinStorageQuota`，无 billing order；
+`repository.ErrActiveTaskLimit` → 可读 400）→ 落库 `queued`
+（Stage="等待队列调度"、Progress=5、Provider=local、Model=whisper.cpp，
+`InputJSON = {"resourceId","language"}`）。
+
+### 3.2 输出 JSON 形状（`ResultJSON`，成功时）
+
+```jsonc
+{
+  "segments": [
+    { "startMs": 0, "endMs": 3200, "text": "字幕文本…" }
+  ],
+  "srt": "1\n00:00:00,000 --> 00:00:03,200\n字幕文本…",
+  "language": "zh"
+}
+```
+
+毫秒为整型（`timelineTranscriptionSegment{StartMs,EndMs,Text}`）。前端（M4.3）把
+`segments` 映射为 `SrtEntry[]`（index = i+1）后直接 `rebuildSubtitleClips` 写入字幕轨道，
+不做二次解析；`srt` 供导出。
+
+### 3.3 状态机
+
+与现有 Task 完全一致：`queued → running(claim) → succeeded | failed | cancelled`；
+stage/progress 由 `processTimelineTranscription` 内更新：
+`"等待转写服务"`(progress 15) → `"正在转写…"`(40) → `"整理字幕…"`(80) → succeeded(100)。
+取消：外层 `registerActiveTask` 的 cancel ctx 令 provider HTTP 调用中断（需在请求中透传
+`ctx`）。
+
+### 3.4 转写执行实现（`transcription_whisper.go`，未引入独立 Provider 包）
+
+- `whisperClient`（`newWhisperClient`）：baseURL 取自环境变量 `CANVAS_WHISPER_BASE_URL`
+  （§3.6 已决：独立 env，非模型渠道）。
+- `transcribe(ctx, wavPath, language)`：本地 ffmpeg 预处理为 16k 单声道 PCM wav
+  （`prepareWhisperWav`），POST `{baseURL}/inference`，multipart `file` 字段，
+  `response_format=verbose_json`；ctx 随外层任务 context 透传（取消即时生效）。
+- `decodeWhisperVerboseJSON` → `timelineTranscriptionResult{Segments,SRT,Language}`；
+  `formatSRTTimestamp` / `buildTimelineSRT` 生成 SRT（对齐 `HH:MM:SS,mmm`）。
+
+### 3.5 任务执行（`task_timeline.go` 内 `processTimelineTranscription`）
+
+1. 解密 `InputJSON` → 校验 `resourceId`；`Resource()` 读取并做 user scope 归属校验。
+2. `isTranscribableMime`（audio/video）前置校验；ffmpeg 预处理 16k 单声道 PCM wav。
+3. 转写（stage/progress：等待转写服务 15 → 正在转写… 40 → 整理字幕… 80 → 完成 100）。
+4. `ResultJSON` 落盘（3.2 形状）→ `repo.SaveTaskCompletion`；失败走
+   `repo.UpdateTaskTerminalState` 记可读错误（未配置 `CANVAS_WHISPER_BASE_URL` 时
+   明确失败并提示设置）。
+
+### 3.6 已决项
+
+- baseURL：**环境变量 `CANVAS_WHISPER_BASE_URL`**（whisper.cpp HTTP，语音数据不出本机）；
+  `.env.example` 已补充。
+- 语言：`language` 直传 whisper `language=`，空 = 自动检测。
+- feature gate：`FeatureTimelineTranscription`（availability JSON
+  `timelineTranscriptionEnabled`，默认开；未开时 `RequireFeature` → Forbidden
+  "字幕转写暂未开放"）。
+- ffmpeg 路径：`CANVAS_FFMPEG_PATH`（可空，空则 PATH 查找；转写/渲染/播放副本共用）。
+
+## 4. M4.2 渲染任务（已实现：`task_render.go` + `timeline_render_plan.go` + `task_timeline.go` 创建侧）
+
+- `POST /api/timeline/renders`（注册于 `RegisterTaskRoutes`）：body =
+  `{projectId, timeline}`；timeline 为 v2 快照（tracks/clips 平铺，`renderProject`），片段经
+  `directMedia.storageKey = "resource:"+<id>` 引用后端资源。
+- 创建（`CreateTimelineRenderTask`）：draining(503) → `buildRenderPlan` 校验 ≥1 个可渲染
+  媒体片段（否则 400 "时间线没有可渲染的媒体片段"）→ 配额入队（Provider=local、
+  Model=ffmpeg、Stage="等待队列调度"、Progress=5）。
+- 执行（`processTimelineRender`，60 分钟超时）：`buildRenderPlan` 展开合成脚本 → 本地
+  ffmpeg（`CANVAS_FFMPEG_PATH` 或 PATH 查找）→ 产物写资源存储（`storeResource` 路径）→
+  `ResultJSON` = `{"resourceId","fileName","size","durationMs","subtitleSrt"?}`
+  （`subtitleSrt`：时间线含字幕轨时携带导出的 SRT 文本，可空）。
+- 终态旁路（同 §2 决策 5）；无 billing/session/message 关联。
+
+## 5. 数据库/文档同步
+
+- 无 schema 变更（复用 tasks 表）。任务 type 以字符串存储，无须迁移。
+- `auth.go` 的 API 前缀白名单已加 `timeline`（防 NoRoute 短代理把未匹配的
+  `/api/timeline/*` 当渠道请求）。
+- 同步更新 `docs/content/docs/progress/pending-test.mdx`（gitignore，仅本地）与
+  Runbook M4 章节的 API 表格（端点/入参/出参），以及权限文档中的 feature gate。
+  本文 §2–§4 已按实现回写，仍以代码为准。
diff --git a/web/src/components/assets/asset-library-picker-modal.tsx b/web/src/components/assets/asset-library-picker-modal.tsx
index 73bfbc1a0..1fc3efba9 100644
--- a/web/src/components/assets/asset-library-picker-modal.tsx
+++ b/web/src/components/assets/asset-library-picker-modal.tsx
@@ -329,7 +329,7 @@ export function AssetLibraryPickerModal({
             title={null}
             destroyOnHidden
             closable={!working}
-            maskClosable={!working}
+            mask={{ closable: !working }}
             keyboard={!working}
             onCancel={() => {
                 if (!working) onClose();
diff --git a/web/src/components/canvas/canvas-upload-modal.tsx b/web/src/components/canvas/canvas-upload-modal.tsx
index 9672c17ed..a59eea6cb 100644
--- a/web/src/components/canvas/canvas-upload-modal.tsx
+++ b/web/src/components/canvas/canvas-upload-modal.tsx
@@ -46,7 +46,7 @@ export function CanvasUploadModal({ open, onClose, onUpload }: CanvasUploadModal
             destroyOnHidden
             closable={!uploading}
             keyboard={!uploading}
-            maskClosable={!uploading}
+            mask={{ closable: !uploading }}
             onCancel={onClose}
             styles={{ container: { padding: 0, overflow: "hidden" }, body: { padding: 0 } }}
         >
diff --git a/web/src/components/editor/editor-context.tsx b/web/src/components/editor/editor-context.tsx
new file mode 100644
index 000000000..4179a1ad7
--- /dev/null
+++ b/web/src/components/editor/editor-context.tsx
@@ -0,0 +1,51 @@
+// 编辑器宿主上下文：store 实例 + 宿主能力（项目信息、资产等）。
+// 插槽渲染函数经 registerEditorSlot 注册，宿主在 editor 视图创建 store 后经
+// EditorStoreProvider 注入；面板组件用 useEditorStoreContext 消费。
+// Host 上下文独立于 store，供需要宿主数据的面板（资产库、导出）使用。
+
+import { createContext, useContext } from "react";
+import type { StoreApi, UseBoundStore } from "zustand";
+
+import type { EditorStore } from "@/stores/editor/editor-store";
+import type { ProjectAsset } from "@/services/api/projects";
+
+type EditorStoreHook = UseBoundStore<StoreApi<EditorStore>>;
+
+export type EditorHostContextValue = {
+    projectId: string;
+    /** 项目资产列表（M3.4 asset-ingest 消费；由宿主在进入编辑器时获取）。 */
+    assets: ProjectAsset[];
+    /** 重新拉取项目资产（导入媒体后刷新列表）。 */
+    refreshAssets: () => Promise<void>;
+};
+
+const EditorStoreContext = createContext<EditorStoreHook | null>(null);
+const EditorHostContext = createContext<EditorHostContextValue | null>(null);
+
+export function EditorStoreProvider({
+    store,
+    host,
+    children,
+}: {
+    store: EditorStoreHook;
+    host: EditorHostContextValue;
+    children: React.ReactNode;
+}) {
+    return (
+        <EditorStoreContext.Provider value={store}>
+            <EditorHostContext.Provider value={host}>{children}</EditorHostContext.Provider>
+        </EditorStoreContext.Provider>
+    );
+}
+
+export function useEditorStoreContext(): EditorStore {
+    const store = useContext(EditorStoreContext);
+    if (!store) throw new Error("useEditorStoreContext must be used within <EditorStoreProvider>");
+    return store();
+}
+
+export function useEditorHostContext(): EditorHostContextValue {
+    const host = useContext(EditorHostContext);
+    if (!host) throw new Error("useEditorHostContext must be used within <EditorStoreProvider>");
+    return host;
+}
diff --git a/web/src/components/layout/workspace-command-palette.tsx b/web/src/components/layout/workspace-command-palette.tsx
index e3646c449..92566b9b6 100644
--- a/web/src/components/layout/workspace-command-palette.tsx
+++ b/web/src/components/layout/workspace-command-palette.tsx
@@ -28,7 +28,7 @@ export function WorkspaceCommandPalette({ open, onClose }: { open: boolean; onCl
         };
         return [
             { id: "home", title: "首页", icon: Home, to: "/" },
-            ...(features.shortDramaEnabled ? [toolEntry("projects", "/projects")] : []),
+toolEntry("projects", "/projects"),
             toolEntry("canvas", "/canvas"),
             ...(features.taskCenterEnabled ? [toolEntry("tasks", "/tasks")] : []),
             toolEntry("assets", "/assets"),
diff --git a/web/src/components/layout/workspace-sidebar-nav.tsx b/web/src/components/layout/workspace-sidebar-nav.tsx
index 30b9bcd97..fce29cdbf 100644
--- a/web/src/components/layout/workspace-sidebar-nav.tsx
+++ b/web/src/components/layout/workspace-sidebar-nav.tsx
@@ -47,7 +47,7 @@ function buildNav(features: FeatureAvailability, balance: string, isAdmin: boole
         {
             items: [
                 { id: "home", title: "首页", icon: Home, to: "/" },
-                ...(features.shortDramaEnabled ? [toolItem("projects", "/projects")] : []),
+toolItem("projects", "/projects"),
                 toolItem("canvas", "/canvas"),
                 ...(features.taskCenterEnabled ? [toolItem("tasks", "/tasks")] : []),
                 toolItem("assets", "/assets"),
diff --git a/web/src/lib/media-metadata.ts b/web/src/lib/media-metadata.ts
new file mode 100644
index 000000000..45e917af6
--- /dev/null
+++ b/web/src/lib/media-metadata.ts
@@ -0,0 +1,41 @@
+// 媒体时长探测（纯前端工具，M3.4）。
+// 上传视频/音频前用 <video>/<audio> 元数据读取真实时长（毫秒），
+// 随上传 meta 传给后端存 Resource.DurationMs → 资产 summary 透出 → 时间线片段真实时长。
+// 解码能力仅用于读取 duration，不需要能播放编码。
+
+const PROBE_TIMEOUT_MS = 8000;
+
+function isProbeable(file: File): boolean {
+    return /^video\//.test(file.type) || /^audio\//.test(file.type);
+}
+
+export async function probeMediaDurationMs(file: File): Promise<number | undefined> {
+    if (!isProbeable(file)) return undefined;
+    const url = URL.createObjectURL(file);
+    const el: HTMLVideoElement | HTMLAudioElement = /^video\//.test(file.type)
+        ? document.createElement("video")
+        : document.createElement("audio");
+    el.preload = "metadata";
+    el.muted = true; // video 自动加载元数据在某些浏览器需要非 autoplay；muted 仅避免噪音
+    try {
+        const timeout = new Promise<never>((_, reject) => {
+            window.setTimeout(() => reject(new Error("probe timeout")), PROBE_TIMEOUT_MS);
+        });
+        const meta = new Promise<number>((resolve) => {
+            el.onloadedmetadata = () => {
+                const d = el.duration;
+                resolve(Number.isFinite(d) && d > 0 ? Math.round(d * 1000) : 0);
+            };
+            el.onerror = () => resolve(0);
+        });
+        el.src = url;
+        const durationMs = await Promise.race([meta, timeout]);
+        return durationMs > 0 ? durationMs : undefined;
+    } catch {
+        return undefined;
+    } finally {
+        el.removeAttribute("src");
+        el.load();
+        URL.revokeObjectURL(url);
+    }
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-ai-assistant.tsx b/web/src/lib/plugins/builtin/editor/editor-ai-assistant.tsx
new file mode 100644
index 000000000..d786c3c44
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-ai-assistant.tsx
@@ -0,0 +1,427 @@
+// AI 编辑助手（editor-shell 预设插件贡献 ai-assistant 插槽，M3.8 注册；入口在编辑器顶部工具按钮浮层）。
+// M6.3：对话面板 —— 时间线摘要注入 system prompt，LLM 输出受 ai-command-schema 约束；
+// ≤3 条命令直执行，>3 条先预览确认（ADR-0007：AI 编辑交互=预设插件且命令受约束）。
+// 命令逐条 dispatch；宿主 fail-closed：无效命令被 registry 拒绝并写入 saveError（顶部提示条），
+// 面板汇报为中性“已提交”，执行结果以时间线实际变化为准。
+// 模型显式选择：不再盲信 config.model 默认值（历史默认可能是图像模型导致文本请求失败），
+// 面板顶部提供文本能力模型下拉，请求时同时覆写 config.model/textModel，避免默认模型错误。
+import { useRef, useState, useEffect } from "react";
+import { Bot, Loader2, RotateCcw, Send, ShieldAlert } from "lucide-react";
+import { requestImageQuestion } from "@/services/api/image";
+import type { AiTextMessage } from "@/services/api/image-contracts";
+import { useConfigStore, useEffectiveConfig, modelOptionLabel } from "@/stores/use-config-store";
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import { summarizeTimeline } from "@/lib/timeline/timeline-summary";
+import {
+    buildAiEditingSystemPrompt,
+    parseAiCommandPlan,
+    validateAiCommandBatch,
+    type AiCommandPlan,
+    type AiCommandBatchVerdict,
+} from "@/lib/timeline/ai-command-schema";
+
+type UiEntry =
+    | { kind: "user"; id: string; text: string }
+    | { kind: "assistant"; id: string; text: string }
+    | { kind: "error"; id: string; text: string; retry: string }
+    | { kind: "preview"; id: string; plan: AiCommandPlan };
+
+const FAILED_MARK = "（上一轮指令被宿主拒绝）";
+const RETRY_MODIFY_PREFIX = "宿主拒绝了上一轮输出，错误：";
+const MAX_VISIBLE_RAW = 240;
+const PREVIEW_HEAD = "以下指令将直接修改时间线，请确认后执行：";
+// 空态建议指令：点击直接发送（对应参考图的 suggestion chips）。
+const SUGGESTED_PROMPTS = [
+    "把第二段素材换成封面图",
+    "删掉所有片段之间的空隙",
+    "给全部字幕加上黑色描边",
+    "当前时间线一共有多少片段？",
+];
+
+/** 指令行人类可读摘要（op + payload 截断），用于执行汇报与预览清单。 */
+function commandLine(cmd: { op: string; payload?: unknown }, index: number): string {
+    const brief = JSON.stringify(cmd.payload);
+    const trimmed = brief.length > 96 ? `${brief.slice(0, 96)}…` : brief;
+    return `${index + 1}. ${cmd.op} ${trimmed}`;
+}
+
+function describePlan(plan: AiCommandPlan): string {
+    const lines = plan.commands.map((c, i) => commandLine(c, i));
+    return [plan.reasoning?.trim(), `已提交 ${plan.commands.length} 条指令：`, ...lines]
+        .filter((line): line is string => Boolean(line))
+        .join("\n");
+}
+
+
+export function EditorAiAssistant() {
+    const { project, dispatch } = useEditorStoreContext();
+    const updateConfig = useConfigStore((s) => s.updateConfig);
+    const effective = useEffectiveConfig();
+    const textModels = effective.textModels ?? [];
+    const defaultModel =
+        effective.textModel && textModels.includes(effective.textModel) ? effective.textModel : textModels[0] ?? "";
+    // 用户在本面板显式选择过的模型优先；未选择时跟随全局 textModel / 首个文本模型。
+    const [model, setModel] = useState("");
+    const modelValue = model || defaultModel || "";
+    const [entries, setEntries] = useState<UiEntry[]>([]);
+    const [input, setInput] = useState("");
+    const [busy, setBusy] = useState(false);
+    const historyRef = useRef<AiTextMessage[]>([]);
+    const scrollRef = useRef<HTMLDivElement | null>(null);
+    // 条目 id 走 ref（非模块级可变变量）：StrictMode 双调用 updater 时也无跨组件副作用。
+    const idSeqRef = useRef(0);
+    function nextId(): string {
+        idSeqRef.current += 1;
+        return `msg-${idSeqRef.current}`;
+    }
+
+    useEffect(() => {
+        const el = scrollRef.current;
+        if (el) el.scrollTop = el.scrollHeight;
+    }, [entries, busy]);
+
+    function onModelChange(value: string): void {
+        setModel(value);
+        updateConfig("textModel", value);
+    }
+
+    function patchEntry(id: string, text: string): void {
+        setEntries((prev) =>
+            prev.map((e) => {
+                if (e.id !== id || e.kind === "preview") return e;
+                return { ...e, text };
+            }),
+        );
+    }
+
+    function appendToEntry(id: string, delta: string): void {
+        setEntries((prev) =>
+            prev.map((e) => {
+                if (e.id !== id || e.kind === "preview") return e;
+                return { ...e, text: e.text + delta };
+            }),
+        );
+    }
+
+    /** 逐条 dispatch 并把目标条目替换为“已提交 N 条指令”汇报气泡。
+     *  预览确认卡因此整卡替换、按钮卸载，重复点击不会二次提交同一批指令。 */
+    function applyPlan(targetId: string, plan: AiCommandPlan): void {
+        for (const cmd of plan.commands) dispatch(cmd);
+        const report = describePlan(plan);
+        setEntries((prev) =>
+            prev.map((e) => (e.id === targetId ? { kind: "assistant", id: targetId, text: report } : e)),
+        );
+        pushHistory({
+            role: "assistant",
+            content: `已提交 ${plan.commands.length} 条指令：${plan.commands.map((c) => c.op).join("、")}`,
+        });
+        setBusy(false);
+    }
+
+    function dropEntry(id: string): void {
+        setEntries((prev) => prev.filter((e) => e.id !== id));
+    }
+
+    function pushHistory(msg: AiTextMessage): void {
+        historyRef.current = [...historyRef.current, msg];
+    }
+
+    function failTurn(assistantId: string, reason: string, userText: string, fixable: boolean): void {
+        patchEntry(
+            assistantId,
+            `指令未应用：${reason.slice(0, MAX_VISIBLE_RAW)}${reason.length > MAX_VISIBLE_RAW ? "…" : ""}`,
+        );
+        pushHistory({ role: "assistant", content: FAILED_MARK });
+        const retry = fixable ? `${RETRY_MODIFY_PREFIX}${reason}。请只输出修正后的命令 JSON。` : userText;
+        const errId = nextId();
+        setEntries((prev) => [...prev, { kind: "error", id: errId, text: reason, retry }]);
+        setBusy(false);
+    }
+
+    async function send(rawOverride?: string): Promise<void> {
+        const text = (rawOverride ?? input).trim();
+        if (!text || busy || !project || !modelValue) return;
+        setInput("");
+        const userId = nextId();
+        const assistantId = nextId();
+        setEntries((prev) => [...prev, { kind: "user", id: userId, text }]);
+        setEntries((prev) => [...prev, { kind: "assistant", id: assistantId, text: "" }]);
+        setBusy(true);
+
+        const userMsg: AiTextMessage = { role: "user", content: text };
+        const history = [...historyRef.current, userMsg];
+        try {
+            // 同时覆写 model 与 textModel，绕过 config.model 可能是图像模型的默认值问题。
+            const answer = await requestImageQuestion(
+                {
+                    ...effective,
+                    model: modelValue,
+                    textModel: modelValue,
+                    systemPrompt: buildAiEditingSystemPrompt(summarizeTimeline(project)),
+                },
+                history,
+                (delta) => appendToEntry(assistantId, delta),
+            );
+            patchEntry(assistantId, answer);
+            settleAnswer(assistantId, answer, text);
+        } catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            patchEntry(assistantId, `请求失败：${reason.slice(0, MAX_VISIBLE_RAW)}`);
+            const errId = nextId();
+            setEntries((prev) => [...prev, { kind: "error", id: errId, text: reason, retry: text }]);
+            setBusy(false);
+        }
+    }
+
+    function settleAnswer(assistantId: string, answer: string, userText: string): void {
+        if (!project) {
+            failTurn(assistantId, "编辑器项目已不可用，无法校验指令。", userText, false);
+            return;
+        }
+        let plan: AiCommandPlan;
+        try {
+            plan = parseAiCommandPlan(answer);
+        } catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            failTurn(assistantId, reason, userText, true);
+            return;
+        }
+        if (plan.commands.length === 0) {
+            const visible = plan.reasoning?.trim() || answer;
+            patchEntry(assistantId, visible);
+            pushHistory({ role: "assistant", content: visible });
+            setBusy(false);
+            return;
+        }
+        const verdict: AiCommandBatchVerdict = validateAiCommandBatch(project, plan);
+        if (!verdict.ok) {
+            failTurn(
+                assistantId,
+                `命令校验失败：${verdict.op}（第 ${verdict.index + 1} 条）：${verdict.error}`,
+                userText,
+                true,
+            );
+            return;
+        }
+        if (plan.commands.length <= 3) {
+            applyPlan(assistantId, plan);
+            return;
+        }
+        patchEntry(assistantId, plan.reasoning?.trim() || `${PREVIEW_HEAD}共 ${plan.commands.length} 条。`);
+        const previewId = nextId();
+        setEntries((prev) => [...prev, { kind: "preview", id: previewId, plan }]);
+        pushHistory({
+            role: "assistant",
+            content: `输出 ${plan.commands.length} 条指令，等待用户确认后执行。`,
+        });
+        setBusy(false);
+    }
+
+    function confirmPreview(entryId: string): void {
+        const entry = entries.find(
+            (e): e is Extract<UiEntry, { kind: "preview" }> => e.id === entryId && e.kind === "preview",
+        );
+        if (!entry || busy) return;
+        // applyPlan 会把预览卡整卡替换为汇报气泡：按钮卸载，重复点击不会二次提交同一批指令。
+        applyPlan(entryId, entry.plan);
+    }
+
+    function dropPreview(entryId: string): void {
+        dropEntry(entryId);
+    }
+
+    function retry(entryId: string): void {
+        const entry = entries.find(
+            (e): e is Extract<UiEntry, { kind: "error" }> => e.id === entryId && e.kind === "error",
+        );
+        if (!entry || busy) return;
+        void send(entry.retry);
+    }
+
+    const hasProject = Boolean(project);
+    const ready = hasProject && Boolean(modelValue);
+    const canSend = ready && !busy && input.trim().length > 0;
+    const placeholder = !hasProject
+        ? "编辑器尚未就绪"
+        : !modelValue
+          ? "未检测到文本模型，请先在「AI 设置」启用文本渠道"
+          : "描述编辑意图，或提问当前时间线…";
+
+    return (
+        <div className="flex h-full min-h-0 flex-col bg-[var(--director-sequencer-surface)]">
+            <div className="flex shrink-0 items-center gap-2 border-b border-[var(--director-sequencer-border)] px-3 py-2">
+                <span className="shrink-0 text-[10px] uppercase tracking-wider text-[var(--director-dock-fg)]/50">
+                    对话模型
+                </span>
+                {textModels.length > 0 ? (
+                    <select
+                        value={modelValue}
+                        onChange={(e) => onModelChange(e.target.value)}
+                        disabled={busy}
+                        aria-label="选择文本对话模型"
+                        title="选择文本对话模型"
+                        className="h-7 min-w-0 flex-1 rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] px-1.5 text-xs text-[var(--director-dock-fg)] outline-none focus:border-[var(--director-accent)] disabled:opacity-50 [&>option]:bg-[var(--director-sequencer-surface-raised)] [&>option]:text-[var(--director-dock-fg)]"
+                    >
+                        {textModels.map((m) => (
+                            <option key={m} value={m}>
+                                {modelOptionLabel(effective, m)}
+                            </option>
+                        ))}
+                    </select>
+                ) : (
+                    <span className="text-[11px] text-[var(--director-warning)]">
+                        未检测到可用文本模型，请先配置渠道
+                    </span>
+                )}
+            </div>
+            <div
+                ref={scrollRef}
+                className="flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto p-3"
+            >
+                {entries.length === 0 && (
+                    <div className="flex min-h-0 flex-1 flex-col items-center justify-center gap-3 p-4 text-center">
+                        <div className="grid size-10 place-items-center rounded-full bg-[var(--director-dock-active-surface)]">
+                            <Bot className="size-4 text-[var(--director-dock-fg)]/80" />
+                        </div>
+                        <p className="text-xs text-[var(--director-dock-fg)]/70">AI 剪辑助手</p>
+                        <p className="max-w-[240px] text-[11px] leading-relaxed text-[var(--director-dock-fg)]/50">
+                            基于当前时间线提问，或描述编辑意图（如"把第二段素材换成封面图"）。
+                            修改指令会先在宿主侧校验，数量超过 3 条时需你确认后才执行。
+                        </p>
+                        <div className="flex max-w-[260px] flex-wrap items-center justify-center gap-1.5">
+                            {SUGGESTED_PROMPTS.map((s) => (
+                                <button
+                                    key={s}
+                                    type="button"
+                                    disabled={!ready || busy}
+                                    onClick={() => void send(s)}
+                                    className="rounded-full border border-[var(--director-sequencer-border)] px-2 py-1 text-[10px] text-[var(--director-dock-fg)]/70 transition-colors hover:border-[var(--director-accent)] hover:text-[var(--director-accent)] disabled:opacity-40"
+                                >
+                                    {s}
+                                </button>
+                            ))}
+                        </div>
+                    </div>
+                )}
+                {entries.map((entry) => {
+                    if (entry.kind === "user") {
+                        return (
+                            <div
+                                key={entry.id}
+                                className="max-w-[86%] self-end whitespace-pre-wrap break-words rounded-xl rounded-br-sm bg-[var(--director-accent)] px-2.5 py-1.5 text-xs leading-relaxed text-[var(--director-on-accent)]"
+                            >
+                                {entry.text}
+                            </div>
+                        );
+                    }
+                    if (entry.kind === "assistant") {
+                        return (
+                            <div
+                                key={entry.id}
+                                className="max-w-[92%] self-start whitespace-pre-wrap break-words rounded-xl rounded-bl-sm border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-2.5 py-1.5 text-[11px] leading-relaxed text-[var(--director-dock-fg)]"
+                            >
+                                {entry.text || (
+                                    <span className="inline-flex items-center gap-1.5 text-[var(--director-dock-fg)]/60">
+                                        <Loader2 className="size-3 animate-spin" />
+                                        思考中…
+                                    </span>
+                                )}
+                            </div>
+                        );
+                    }
+                    if (entry.kind === "error") {
+                        return (
+                            <div
+                                key={entry.id}
+                                className="max-w-[92%] self-start overflow-hidden rounded-xl rounded-bl-sm border border-[var(--director-danger)]/40 bg-[var(--director-danger)]/10 px-2.5 py-1.5"
+                            >
+                                <div className="flex items-start gap-1.5">
+                                    <ShieldAlert className="mt-0.5 size-3 shrink-0 text-[var(--director-danger)]" />
+                                    <div className="min-w-0">
+                                        <p className="text-[11px] leading-relaxed text-[var(--director-danger)]">
+                                            {entry.text}
+                                        </p>
+                                        {entry.retry && (
+                                            <button
+                                                type="button"
+                                                onClick={() => retry(entry.id)}
+                                                disabled={busy}
+                                                className="mt-1 inline-flex items-center gap-1 rounded border border-[var(--director-sequencer-border)] px-1.5 py-0.5 text-[10px] text-[var(--director-dock-fg)]/80 hover:bg-[var(--director-control-hover)] disabled:opacity-40"
+                                            >
+                                                <RotateCcw className="size-2.5" />
+                                                修正后重试
+                                            </button>
+                                        )}
+                                    </div>
+                                </div>
+                            </div>
+                        );
+                    }
+                    return (
+                        <div
+                            key={entry.id}
+                            className="max-w-[92%] self-start overflow-hidden rounded-xl rounded-bl-sm border border-[var(--director-warning)]/40 bg-[var(--director-warning)]/10"
+                        >
+                            <p className="border-b border-[var(--director-warning)]/25 px-2.5 py-1.5 text-[11px] font-medium text-[var(--director-dock-fg)]">
+                                {PREVIEW_HEAD}
+                            </p>
+                            <div className="max-h-44 overflow-y-auto px-2.5 py-1.5">
+                                {entry.plan.commands.map((cmd, i) => (
+                                    <p
+                                        key={i}
+                                        className="py-0.5 font-mono text-[10px] leading-relaxed text-[var(--director-dock-fg)]/80"
+                                    >
+                                        {commandLine(cmd, i)}
+                                    </p>
+                                ))}
+                            </div>
+                            <div className="flex items-center justify-end gap-1.5 border-t border-[var(--director-warning)]/25 px-2.5 py-1.5">
+                                <button
+                                    type="button"
+                                    onClick={() => dropPreview(entry.id)}
+                                    disabled={busy}
+                                    className="rounded-md border border-[var(--director-sequencer-border)] px-2 py-1 text-[10px] text-[var(--director-dock-fg)]/80 hover:bg-[var(--director-control-hover)] disabled:opacity-40"
+                                >
+                                    放弃
+                                </button>
+                                <button
+                                    type="button"
+                                    onClick={() => confirmPreview(entry.id)}
+                                    disabled={busy}
+                                    className="flex items-center gap-1 rounded-md bg-[var(--director-accent)] px-2 py-1 text-[10px] font-medium text-[var(--director-on-accent)] hover:bg-[var(--director-accent-hover)] disabled:opacity-40"
+                                >
+                                    确认执行（{entry.plan.commands.length}）
+                                </button>
+                            </div>
+                        </div>
+                    );
+                })}
+            </div>
+            <div className="flex shrink-0 items-center gap-2 border-t border-[var(--director-sequencer-border)] p-2.5">
+                <input
+                    value={input}
+                    onChange={(e) => setInput(e.target.value)}
+                    onKeyDown={(e) => {
+                        if (e.key === "Enter" && !e.shiftKey) {
+                            e.preventDefault();
+                            void send();
+                        }
+                    }}
+                    disabled={!ready || busy}
+                    placeholder={placeholder}
+                    className="min-w-0 flex-1 rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] px-2 py-1.5 text-xs text-[var(--director-dock-fg)] placeholder:text-[var(--director-dock-fg)]/40 focus:border-[var(--director-accent)] focus:outline-none disabled:opacity-50"
+                />
+                <button
+                    type="button"
+                    onClick={() => void send()}
+                    disabled={!canSend}
+                    aria-label={modelValue ? "发送" : "无可用文本模型"}
+                    title={modelValue ? "发送" : "请先选择文本模型"}
+                    className="grid size-7 shrink-0 place-items-center rounded-md bg-[var(--director-accent)] text-[var(--director-on-accent)] hover:bg-[var(--director-accent-hover)] disabled:opacity-40"
+                >
+                    {busy ? <Loader2 className="size-3.5 animate-spin" /> : <Send className="size-3.5" />}
+                </button>
+            </div>
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-asset-ingest.tsx b/web/src/lib/plugins/builtin/editor/editor-asset-ingest.tsx
new file mode 100644
index 000000000..51bc043c7
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-asset-ingest.tsx
@@ -0,0 +1,531 @@
+// 资产导入（editor-shell 预设插件贡献 asset-ingest 插槽，M3.4）。
+// 展示项目资产库，按来源区分「本地上传」与「项目素材」；点击资产 → makeClipFromAsset
+// → dispatch addClip 加入时间线（添加到匹配 kind 的轨道末尾）。资产是
+// "仅时间线作用域"直连媒体（nodeId=asset:<id>）。导入链路：uploadResourceFile →
+// linkProjectAsset（后端按资源元数据合成资产记录）→ refreshAssets。
+
+import { useEffect, useRef, useState } from "react";
+import { Boxes, ChevronDown, ChevronRight, Clapperboard, Film, FolderOpen, HardDrive, Image as ImageIcon, Loader2, Music2, Plus } from "lucide-react";
+
+import { useEditorHostContext, useEditorStoreContext } from "@/components/editor/editor-context";
+import { defaultAssetCategoryForKind } from "@/lib/asset-category";
+import { probeMediaDurationMs } from "@/lib/media-metadata";
+import { makeClipFromAsset } from "@/lib/timeline/asset-ingest";
+import { DEFAULT_AUDIO_TRACK_ID, DEFAULT_SUBTITLE_TRACK_ID, DEFAULT_VIDEO_TRACK_ID } from "@/lib/timeline/timeline-tracks";
+import { linkProjectAsset } from "@/services/api/projects";
+import { uploadResourceFile, type ResourceUploadMeta } from "@/services/api/resources";
+import { resolveMediaUrl } from "@/services/file-storage";
+import type { ProjectAsset } from "@/services/api/projects";
+import type { TimelineProject } from "@/types/timeline";
+
+
+const MEDIA_ACCEPT = "video/*,audio/*,image/*";
+/** 库内重复判定用的归一键（文件名+媒体类型）。 */
+function assetDedupeKey(title: string | undefined, mediaType: string): string {
+    return `${(title || "").trim().toLowerCase()}|${mediaType}`;
+}
+/** 毫秒 → m:ss 时长文案。 */
+function formatDurationMs(ms: number | undefined): string {
+    if (!ms || ms <= 0) return "";
+    const total = Math.round(ms / 1000);
+    return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
+}
+const IMAGE_RE = /\.(png|jpe?g|webp|gif|avif)$/i;
+const AUDIO_RE = /\.(mp3|wav|m4a|ogg|flac|aac)$/i;
+const MEDIA_RE = /\.(mp4|mov|webm|mkv|m4v|avi)$/i;
+
+/** 本地上传标记（assetFromUploadedResource 写入 payload.data.source）。 */
+const SOURCE_UPLOADED = "uploaded";
+
+type AssetFilter = "all" | "project" | "uploaded";
+
+const FILTER_TABS: { id: AssetFilter; label: string }[] = [
+    { id: "all", label: "全部" },
+    { id: "project", label: "项目素材" },
+    { id: "uploaded", label: "本地上传" },
+];
+
+/** 按 MIME 与扩展名推断媒体 kind；非媒体文件返回 null。 */
+function kindFromFile(file: File): "image" | "video" | "audio" | null {
+    if (file.type.startsWith("video/")) return "video";
+    if (file.type.startsWith("audio/")) return "audio";
+    if (file.type.startsWith("image/")) return "image";
+    if (IMAGE_RE.test(file.name)) return "image";
+    if (AUDIO_RE.test(file.name)) return "audio";
+    if (MEDIA_RE.test(file.name)) return "video";
+    return null;
+}
+
+function trackIdForKind(kind: string, project: TimelineProject): string {
+    const track = project.tracks.find((t) => t.kind === kind);
+    if (track) return track.id;
+    if (kind === "video" || kind === "image") return project.tracks.find((t) => t.kind === "video")?.id ?? DEFAULT_VIDEO_TRACK_ID;
+    if (kind === "audio") return project.tracks.find((t) => t.kind === "audio")?.id ?? DEFAULT_AUDIO_TRACK_ID;
+    return DEFAULT_SUBTITLE_TRACK_ID;
+}
+
+function trackEndMs(project: TimelineProject, trackId: string): number {
+    return project.clips.filter((c) => c.trackId === trackId).reduce((max, c) => Math.max(max, c.startMs + c.durationMs), 0);
+}
+
+function AssetIcon({ mediaType }: { mediaType: string }) {
+    const cls = "size-4";
+    if (mediaType === "video") return <Film className={cls} />;
+    if (mediaType === "audio") return <Music2 className={cls} />;
+    if (mediaType === "image") return <ImageIcon className={cls} />;
+    return <Clapperboard className={cls} />;
+}
+
+/** 列表行小缩略图：图片媒体显示真实画面；视频/音频无法在 <img> 解码，
+ *  统一渲染类型色块+图标占位（不再出现破图），视频缩略图由展开卡片提供。 */
+function AssetThumb({ asset }: { asset: ProjectAsset }) {
+    const isImage = asset.mediaType === "image";
+    const [url, setUrl] = useState<string | null>(null);
+    useEffect(() => {
+        if (!isImage || !asset.storageKey) return;
+        let alive = true;
+        resolveMediaUrl(asset.storageKey)
+            .then((resolved) => alive && setUrl(resolved ?? null))
+            .catch(() => alive && setUrl(null));
+        return () => {
+            alive = false;
+        };
+    }, [asset.storageKey, isImage]);
+    if (url) {
+        return (
+            <div className="grid size-9 shrink-0 place-items-center overflow-hidden rounded-md bg-[var(--director-control-hover)]">
+                <img src={url} alt="" className="size-full object-cover" />
+            </div>
+        );
+    }
+    const kind =
+        asset.mediaType === "video"
+            ? { icon: <Film className="size-4" />, tone: "text-[var(--director-accent)]", tile: "bg-[var(--director-accent)]/15" }
+            : asset.mediaType === "audio"
+              ? { icon: <Music2 className="size-4" />, tone: "text-[var(--director-dock-fg)]/70", tile: "bg-[var(--director-control-hover)]" }
+              : { icon: <ImageIcon className="size-4" />, tone: "text-[var(--director-dock-fg)]/60", tile: "bg-[var(--director-control-hover)]" };
+    return (
+        <div className={`grid size-9 shrink-0 place-items-center overflow-hidden rounded-md ${kind.tile}`}>
+            <span className={kind.tone}>{kind.icon}</span>
+        </div>
+    );
+}
+
+/** 尝试用 <video> 抓取视频首帧作为封面 dataURL；失败返回 null（保持图标占位）。 */
+function useVideoPoster(url: string | null): string | null {
+    const [poster, setPoster] = useState<string | null>(null);
+    useEffect(() => {
+        if (!url) {
+            setPoster(null);
+            return;
+        }
+        let alive = true;
+        const video = document.createElement("video");
+        video.muted = true;
+        video.playsInline = true;
+        video.preload = "metadata";
+        video.src = url;
+        const seekToHead = () => {
+            if (!alive || video.readyState < 1) return;
+            try {
+                video.currentTime = Math.min(0.05, Number.isFinite(video.duration) ? video.duration : 0.05);
+            } catch {
+                /* 忽略跨域/编解码异常 */
+            }
+        };
+        const grabFrame = () => {
+            if (!alive || video.readyState < 2 || video.videoWidth === 0) return;
+            try {
+                const canvas = document.createElement("canvas");
+                canvas.width = video.videoWidth;
+                canvas.height = video.videoHeight;
+                const ctx = canvas.getContext("2d");
+                if (!ctx) return;
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                const dataUrl = canvas.toDataURL("image/jpeg", 0.7);
+                if (dataUrl.length > 100) setPoster(dataUrl);
+            } catch {
+                /* canvas 跨域污染等：放弃自动封面 */
+            }
+        };
+        video.addEventListener("loadeddata", seekToHead);
+        video.addEventListener("seeked", grabFrame);
+        return () => {
+            alive = false;
+            video.removeAttribute("src");
+            video.load();
+        };
+    }, [url]);
+    return poster;
+}
+
+/** 展开卡片预览：图片直接展示；视频给出自动首帧封面 + 原生播放器；音频为说明。 */
+function MediaPreview({ asset }: { asset: ProjectAsset }) {
+    const [url, setUrl] = useState<string | null>(null);
+    useEffect(() => {
+        if (!asset.storageKey) return;
+        let alive = true;
+        resolveMediaUrl(asset.storageKey)
+            .then((resolved) => alive && setUrl(resolved ?? null))
+            .catch(() => alive && setUrl(null));
+        return () => {
+            alive = false;
+        };
+    }, [asset.storageKey]);
+    const poster = useVideoPoster(asset.mediaType === "video" ? url : null);
+    if (asset.mediaType === "image") {
+        return url ? <img src={url} alt="" className="h-28 w-full rounded-md object-cover" /> : <div className="h-28 animate-pulse rounded-md bg-[var(--director-control-hover)]" />;
+    }
+    if (asset.mediaType === "video") {
+        return (
+            <div className="relative overflow-hidden rounded-md bg-black">
+                <video
+                    src={url ?? undefined}
+                    poster={poster ?? undefined}
+                    preload="metadata"
+                    controls
+                    playsInline
+                    className="aspect-video w-full"
+                />
+                {!url ? <div className="aspect-video w-full animate-pulse bg-[var(--director-control-hover)]" /> : null}
+            </div>
+        );
+    }
+    return (
+        <div className="flex h-16 items-center justify-center gap-2 rounded-md bg-[var(--director-control-hover)] text-[var(--director-dock-fg)]/60">
+            <Music2 className="size-4" />
+            <span className="text-[10px]">音频素材 · 点击下方按钮加入时间线</span>
+        </div>
+    );
+}
+
+function SourceBadge({ source }: { source: string }) {
+    const uploaded = source === SOURCE_UPLOADED;
+    return (
+        <span
+            className={`rounded px-1 py-px text-[9px] leading-none ${
+                uploaded
+                    ? "bg-[var(--director-control-hover)] text-[var(--director-dock-fg-strong)]"
+                    : "bg-[var(--director-control-hover)] text-[var(--director-dock-fg)]/70"
+            }`}
+        >
+            {uploaded ? "本地上传" : "项目素材"}
+        </span>
+    );
+}
+
+export function EditorAssetIngest() {
+    const { projectId, assets, refreshAssets } = useEditorHostContext();
+    const { project, dispatch } = useEditorStoreContext();
+    const [added, setAdded] = useState<string | null>(null);
+    const [importing, setImporting] = useState(false);
+    const [importError, setImportError] = useState<string | null>(null);
+    const [importNote, setImportNote] = useState<string | null>(null);
+    useEffect(() => {
+        if (!importNote) return;
+        const timer = window.setTimeout(() => setImportNote(null), 3200);
+        return () => window.clearTimeout(timer);
+    }, [importNote]);
+    const [dragOver, setDragOver] = useState(false);
+
+    const [filter, setFilter] = useState<AssetFilter>("all");
+    const [expandedId, setExpandedId] = useState<string | null>(null);
+    const [openGroups, setOpenGroups] = useState<{ uploaded: boolean; project: boolean }>({ uploaded: true, project: true });
+    const inputRef = useRef<HTMLInputElement | null>(null);
+    const lastAddKey = useRef<string | null>(null);
+    const lastAddAt = useRef(0);
+
+    if (!project) return null;
+
+    const importFiles = async (fileList: FileList | File[]) => {
+        const media = Array.from(fileList)
+            .map((file) => ({ file, kind: kindFromFile(file) }))
+            .filter((x): x is { file: File; kind: "image" | "video" | "audio" } => x.kind !== null);
+        if (media.length === 0) {
+            setImportError("仅支持视频、音频与图片文件");
+            return;
+        }
+        setImporting(true);
+        setImportError(null);
+        setImportNote(null);
+        let okCount = 0;
+        let firstErrorMsg: string | null = null;
+        const failedNames: string[] = [];
+        try {
+            // 去重：同名同类型视为同一素材。库内已有或本批内重复的跳过，避免
+            // 再次上传同一大文件生成重复 asset（历史上重复导入会把素材堆积成多条）。
+            const seen = new Set<string>();
+            const toImport = media.filter(({ file, kind }) => {
+                const key = assetDedupeKey(file.name, kind);
+                const known = assets.some((a) => assetDedupeKey(a.title, a.mediaType) === key);
+                const duplicated = seen.has(key);
+                seen.add(key);
+                return !known && !duplicated;
+            });
+            const skipped = media.length - toImport.length;
+            // 逐文件导入：单文件失败不中断整批，汇总失败数提示。
+            for (const { file, kind } of toImport) {
+                try {
+                    // 上传前探测真实时长（视频/音频），随 meta 入库供时间线片段使用。
+                    const durationMs = await probeMediaDurationMs(file);
+                    const resource = await uploadResourceFile(file, kind, durationMs !== undefined ? { durationMs } : undefined);
+                    if (resource.status === "failed") {
+                        failedNames.push(file.name);
+                        if (!firstErrorMsg) firstErrorMsg = resource.error ? `「${file.name}」${resource.error}` : null;
+                        continue;
+                    }
+                    let linked = false;
+                    try {
+                        await linkProjectAsset(projectId, { assetId: resource.id, category: defaultAssetCategoryForKind(kind), title: file.name });
+                        linked = true;
+                    } catch {
+                        // 链接偶发失败（网络抖动/后端竞态）时重试一次，避免资源已入库却未挂到项目下。
+                        linked = await linkProjectAsset(projectId, { assetId: resource.id, category: defaultAssetCategoryForKind(kind), title: file.name })
+                            .then(() => true)
+                            .catch(() => false);
+                    }
+                    if (!linked) {
+                        // 两次挂载都失败（asset 可能已创建但未挂上项目）：不删除，提示重试——重试走幂等路径可补挂。
+                        failedNames.push(file.name);
+                        if (!firstErrorMsg) firstErrorMsg = `「${file.name}」已上传但挂载到项目失败，请重试`;
+                        continue;
+                    }
+                    okCount += 1;
+                } catch (err) {
+                    failedNames.push(file.name);
+                    const detail = extractApiMessage(err);
+                    if (!firstErrorMsg) firstErrorMsg = detail ? `「${file.name}」${detail}` : `「${file.name}」导入失败`;
+                }
+            }
+            if (okCount > 0) {
+                await refreshAssets();
+                setImportNote(skipped > 0 ? `已导入 ${okCount} 个，跳过 ${skipped} 个重复文件` : `已导入 ${okCount} 个媒体`);
+            } else if (skipped > 0 && failedNames.length === 0) {
+                setImportNote(`媒体库中已有同名素材，跳过 ${skipped} 个重复文件`);
+            }
+            if (firstErrorMsg) {
+                setImportError(firstErrorMsg);
+            } else if (failedNames.length > 0) {
+                const failedText = failedNames.length === 1 ? `「${failedNames[0]}」` : `${failedNames.length} 个文件`;
+                setImportError(`${failedText}导入失败，请重试`);
+            }
+        } finally {
+            setImporting(false);
+        }
+    };
+
+    // 双击“添加到时间线”会连续 dispatch 两次，产生两个同一素材的相邻片段；用时间戳守卫拦截 1.5s 内的重复添加。
+    const addToTimeline = (asset: ProjectAsset) => {
+        const now = Date.now();
+        if (lastAddKey.current === asset.id && now - lastAddAt.current < 1500) return;
+        lastAddKey.current = asset.id;
+        lastAddAt.current = now;
+        const kind = asset.mediaType === "video" ? "video" : asset.mediaType === "audio" ? "audio" : asset.mediaType === "image" ? "image" : null;
+        if (!kind) return;
+        const trackId = trackIdForKind(kind, project);
+        const startMs = trackEndMs(project, trackId);
+        const clip = makeClipFromAsset(asset, {
+            trackId,
+            startMs,
+            defaultDurationMs: kind === "image" ? 3_000 : 5_000,
+        });
+        if (!clip) return;
+        dispatch({ op: "addClip", payload: { clip } });
+        setAdded(asset.id);
+        setTimeout(() => setAdded(null), 1200);
+    };
+
+    const uploadedAssets = assets.filter((a) => a.source === SOURCE_UPLOADED);
+    const projectAssets = assets.filter((a) => a.source !== SOURCE_UPLOADED);
+    const groups: { id: "uploaded" | "project"; label: string; icon: typeof HardDrive; items: ProjectAsset[] }[] = [
+        { id: "uploaded", label: "本地上传", icon: HardDrive, items: uploadedAssets },
+        { id: "project", label: "项目素材", icon: Boxes, items: projectAssets },
+    ];
+    const visibleGroups = groups.filter((g) => filter === "all" || g.id === filter);
+    const totalCount = assets.length;
+
+    return (
+        <div
+            className={`flex h-full min-h-0 flex-col bg-[var(--director-sequencer-surface)] ${dragOver ? "ring-2 ring-inset ring-[var(--director-accent)]" : ""}`}
+            onDragOver={(e) => {
+                e.preventDefault();
+                setDragOver(true);
+            }}
+            onDragLeave={() => setDragOver(false)}
+            onDrop={(e) => {
+                e.preventDefault();
+                setDragOver(false);
+                void importFiles(e.dataTransfer.files);
+            }}
+        >
+            {/* 标题行：媒体库 + 导入按钮 */}
+            <div className="flex items-center gap-1.5 p-2 pb-1">
+                <input
+                    ref={inputRef}
+                    type="file"
+                    accept={MEDIA_ACCEPT}
+                    multiple
+                    className="hidden"
+                    onChange={(e) => {
+                        if (e.target.files) void importFiles(e.target.files);
+                        e.target.value = "";
+                    }}
+                />
+                <span className="text-xs font-semibold text-[var(--director-dock-fg-strong)]">媒体库</span>
+                <span className="rounded-full bg-[var(--director-control-hover)] px-1.5 text-[9px] tabular-nums text-[var(--director-dock-fg)]/70">{totalCount}</span>
+                <div className="flex-1" />
+                <button
+                    type="button"
+                    disabled={importing}
+                    onClick={() => inputRef.current?.click()}
+                    className="flex h-7 items-center gap-1.5 rounded-md border border-dashed border-[var(--director-sequencer-border)] px-2.5 text-[11px] font-medium text-[var(--director-dock-fg-strong)] transition-colors hover:border-[var(--director-accent)] hover:bg-[var(--director-control-hover)] disabled:cursor-not-allowed disabled:opacity-60"
+                >
+                    {importing ? <Loader2 className="size-3.5 animate-spin" /> : <FolderOpen className="size-3.5" />}
+                    {importing ? "导入中…" : "导入媒体"}
+                </button>
+            </div>
+
+            {/* 来源筛选：全部 / 项目素材 / 本地上传 */}
+            <div className="flex items-center gap-0.5 px-2 pb-1">
+                {FILTER_TABS.map((tab) => (
+                    <button
+                        key={tab.id}
+                        type="button"
+                        aria-pressed={filter === tab.id}
+                        onClick={() => setFilter(tab.id)}
+                        className={`h-6 rounded-md px-2 text-[10px] transition-colors ${
+                            filter === tab.id
+                                ? "bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]"
+                                : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                        }`}
+                    >
+                        {tab.label}
+                    </button>
+                ))}
+            </div>
+
+            {importError ? <p className="px-2 pb-1 text-[10px] text-[var(--director-danger)]">{importError}</p> : null}
+            {importNote ? <p className="px-2 pb-1 text-[10px] text-[var(--director-success)]">{importNote}</p> : null}
+
+            <div className="director-scroll min-h-0 flex-1 overflow-y-auto p-1.5">
+                {assets.length === 0 ? (
+                    <div className="flex h-full flex-col items-center justify-center gap-2 p-4 text-center">
+                        <p className="text-xs text-[var(--director-dock-fg)]/60">项目暂无资产</p>
+                        <p className="max-w-[180px] text-[11px] leading-relaxed text-[var(--director-dock-fg)]/45">点击上方导入媒体，或将文件拖入此区域</p>
+                    </div>
+                ) : visibleGroups.every((g) => g.items.length === 0) ? (
+                    <div className="flex h-full flex-col items-center justify-center gap-2 p-4 text-center">
+                        <p className="text-xs text-[var(--director-dock-fg)]/60">
+                            {filter === "uploaded" ? "暂无本地上传的媒体" : filter === "project" ? "暂无项目素材" : "项目暂无资产"}
+                        </p>
+                        <p className="max-w-[180px] text-[11px] leading-relaxed text-[var(--director-dock-fg)]/45">点击上方导入媒体，或将文件拖入此区域</p>
+                    </div>
+                ) : (
+                    <div className="flex flex-col gap-1">
+                        {visibleGroups.map((group) => {
+                            if (group.items.length === 0) return null;
+                            const open = openGroups[group.id];
+                            return (
+                                <div key={group.id} className="flex flex-col">
+                                    <button
+                                        type="button"
+                                        aria-expanded={open}
+                                        onClick={() => setOpenGroups((s) => ({ ...s, [group.id]: !open }))}
+                                        className="group flex h-7 w-full items-center gap-1.5 rounded-md px-1 text-left transition-colors hover:bg-[var(--director-control-hover)]"
+                                    >
+                                        <span
+                                            className={`grid size-4 shrink-0 place-items-center rounded-[5px] transition-colors ${
+                                                open ? "bg-[var(--director-accent)]/15 text-[var(--director-accent)]" : "bg-[var(--director-control-hover)] text-[var(--director-dock-fg)]/55 group-hover:text-[var(--director-dock-fg-strong)]"
+                                            }`}
+                                        >
+                                            <ChevronRight className={`size-3 transition-transform duration-150 ease-out ${open ? "rotate-90" : ""}`} />
+                                        </span>
+                                        <group.icon className={`size-3.5 shrink-0 transition-colors ${open ? "text-[var(--director-accent)]" : "text-[var(--director-dock-fg)]/60"}`} />
+                                        <span className="truncate text-[11px] font-medium text-[var(--director-dock-fg-strong)]">{group.label}</span>
+                                        <span className="ml-auto rounded-full bg-[var(--director-control-hover)] px-1.5 text-[9px] tabular-nums text-[var(--director-dock-fg)]/70">{group.items.length}</span>
+                                    </button>
+                                    {open ? (
+                                        <ul className="flex flex-col">
+                                            {group.items.map((asset) => {
+                                                const expanded = expandedId === asset.id;
+                                                const source = asset.source || "";
+                                                return (
+                                                    <li key={asset.id}>
+                                                        <button
+                                                            type="button"
+                                                            aria-expanded={expanded}
+                                                            onClick={() => setExpandedId(expanded ? null : asset.id)}
+                                                            title={asset.title || asset.storageKey}
+                                                            className={`group flex w-full items-center gap-2 rounded-md px-1 py-[3px] text-left transition-colors ${
+                                                                added === asset.id ? "bg-[var(--director-accent)]/15" : "hover:bg-[var(--director-control-hover)]"
+                                                            }`}
+                                                        >
+                                                            <AssetThumb asset={asset} />
+                                                            <span className="min-w-0 flex-1">
+                                                                <span className="block truncate text-[11px] text-[var(--director-dock-fg-strong)]">{asset.title || asset.storageKey}</span>
+                                                                <span className="mt-0.5 flex items-center gap-1 text-[9px] text-[var(--director-dock-fg)]/60">
+                                                                    <span className="uppercase">{asset.mediaType}</span>
+                                                                    {asset.durationMs ? <span className="tabular-nums opacity-80">{formatDurationMs(asset.durationMs)}</span> : null}
+                                                                    <SourceBadge source={source} />
+                                                                </span>
+                                                            </span>
+                                                            <span
+                                                                className={`grid size-5 shrink-0 place-items-center rounded-[5px] transition-colors ${
+                                                                    expanded ? "bg-[var(--director-accent)]/15 text-[var(--director-accent)]" : "text-[var(--director-dock-fg)]/40 group-hover:text-[var(--director-dock-fg)]/80"
+                                                                }`}
+                                                            >
+                                                                <ChevronDown className={`size-3.5 transition-transform duration-150 ease-out ${expanded ? "rotate-180" : ""}`} />
+                                                            </span>
+                                                        </button>
+                                                        {expanded ? (
+                                                                <div className="mx-1 mb-1 ml-10 rounded-md bg-[var(--director-control-hover)] p-2">
+
+                                                                <MediaPreview asset={asset} />
+                                                                <dl className="mt-2 grid grid-cols-2 gap-x-3 gap-y-1 text-[10px]">
+                                                                    <dt className="text-[var(--director-dock-fg)]/60">媒体类型</dt>
+                                                                    <dd className="truncate text-right capitalize text-[var(--director-dock-fg-strong)]">{asset.mediaType}</dd>
+                                                                    <dt className="text-[var(--director-dock-fg)]/60">分类</dt>
+                                                                    <dd className="truncate text-right text-[var(--director-dock-fg-strong)]">{asset.category}</dd>
+                                                                    <dt className="text-[var(--director-dock-fg)]/60">来源</dt>
+                                                                    <dd className="text-right text-[var(--director-dock-fg-strong)]">{source === SOURCE_UPLOADED ? "本地上传" : "项目素材"}</dd>
+                                                                    {asset.durationMs ? (
+                                                                        <>
+                                                                            <dt className="text-[var(--director-dock-fg)]/60">时长</dt>
+                                                                            <dd className="text-right tabular-nums text-[var(--director-dock-fg-strong)]">{formatDurationMs(asset.durationMs)}</dd>
+                                                                        </>
+                                                                    ) : null}
+                                                                </dl>
+                                                                {asset.previewText ? <p className="mt-1 line-clamp-2 text-[10px] leading-relaxed text-[var(--director-dock-fg)]/60">{asset.previewText}</p> : null}
+                                                                <button
+                                                                    type="button"
+                                                                    onClick={() => addToTimeline(asset)}
+                                                                    className="mt-2 flex h-7 w-full items-center justify-center gap-1 rounded-md bg-[var(--director-accent)] text-[11px] font-medium text-[var(--director-on-accent)] transition-colors hover:bg-[var(--director-accent-hover)]"
+                                                                >
+                                                                    <Plus className="size-3.5" />
+                                                                    添加到时间线
+                                                                </button>
+                                                            </div>
+                                                        ) : null}
+                                                    </li>
+                                                );
+                                            })}
+                                        </ul>
+                                    ) : null}
+                                </div>
+                            );
+                        })}
+                    </div>
+                )}
+            </div>
+        </div>
+    );
+}
+
+/** 从 Axios 错误中提取后端业务信息（{ code, data, msg } 的 msg），无则返回 null。 */
+function extractApiMessage(err: unknown): string | null {
+    if (typeof err !== "object" || err === null) return null;
+    const anyErr = err as { response?: { data?: { msg?: string } } };
+    const msg = anyErr.response?.data?.msg;
+    if (typeof msg === "string" && msg.trim()) return msg.trim();
+    return null;
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-export.tsx b/web/src/lib/plugins/builtin/editor/editor-export.tsx
new file mode 100644
index 000000000..0e58ba047
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-export.tsx
@@ -0,0 +1,232 @@
+// 导出（editor-shell 预设插件贡献 export-renderer 插槽，M3.7）。
+// M4.2：默认提交后端渲染任务（POST /timeline/renders，ffmpeg 服务端合成，
+// 产物落资源存储，ResultJSON 返回 resourceId 供内嵌预览/下载）；
+// ffmpeg.wasm 本地导出保留为离线/降级路径。
+// §3.1 引用契约：缺失 nodeId 源（节点已删除）按计划跳过，成片不因悬空引用失败。
+
+import { useMemo, useState } from "react";
+import { Download, Loader2, PackageOpen, Server } from "lucide-react";
+
+import { useEditorHostContext, useEditorStoreContext } from "@/components/editor/editor-context";
+import { buildTimelineRenderPlan, type TimelineRenderSource } from "@/lib/timeline/timeline-to-ffmpeg";
+import { exportTimelineToMp4, type TimelineExportProgress } from "@/lib/timeline/timeline-export";
+import { resourceFileUrl } from "@/services/api/resources";
+import { waitForGenerationTask } from "@/services/api/task-center";
+import { createTimelineRenderTask, type TimelineRenderResult } from "@/services/api/timeline-tasks";
+import type { TimelineProject } from "@/types/timeline";
+
+type ExportState = {
+    phase: "idle" | "running" | "done" | "error";
+    mode: "remote" | "local" | null;
+    percent: number;
+    detail: string;
+    result: TimelineRenderResult | null;
+};
+
+/** 从时间线 clip 收集渲染源（按 nodeId 关联；directMedia 提供本地媒体定位）。 */
+function collectRenderSources(project: TimelineProject): TimelineRenderSource[] {
+    const seen = new Set<string>();
+    const sources: TimelineRenderSource[] = [];
+    for (const clip of project.clips) {
+        if (clip.kind !== "video" && clip.kind !== "image") continue;
+        const direct = clip.directMedia;
+        if (!direct) continue;
+        if (seen.has(clip.nodeId)) continue;
+        seen.add(clip.nodeId);
+        sources.push({
+            nodeId: clip.nodeId,
+            fileName: `input-${sources.length}.mp4`,
+            durationMs: clip.durationMs,
+            storageKey: direct.storageKey,
+            url: direct.url,
+        });
+    }
+    return sources;
+}
+
+export function EditorExport() {
+    const { project } = useEditorStoreContext();
+    const { projectId } = useEditorHostContext();
+    const [state, setState] = useState<ExportState>({ phase: "idle", mode: null, percent: 0, detail: "", result: null });
+
+    const sources = useMemo(() => (project ? collectRenderSources(project) : []), [project]);
+    const plan = useMemo(() => (project ? buildTimelineRenderPlan(project, sources) : null), [project, sources]);
+
+    // 主路径：提交后端渲染任务并轮询（服务端任务上限 60 分钟，前端多留余量）。
+    const renderRemote = async () => {
+        if (!project || sources.length === 0 || state.phase === "running") return;
+        setState({ phase: "running", mode: "remote", percent: 0, detail: "提交渲染任务…", result: null });
+        try {
+            const created = await createTimelineRenderTask({ projectId, timeline: project });
+            const done = await waitForGenerationTask(created.id, {
+                timeoutMs: 62 * 60 * 1000,
+                intervalMs: 3000,
+                onTaskUpdate: (task) =>
+                    setState({
+                        phase: "running",
+                        mode: "remote",
+                        percent: task.progress ?? 0,
+                        detail: task.stage
+                            ? `${task.stage}${task.progress ? ` · ${task.progress}%` : ""}`
+                            : "渲染中…",
+                        result: null,
+                    }),
+            });
+            const parsed = JSON.parse(done.resultJson ?? "{}") as TimelineRenderResult;
+            if (!parsed.resourceId) throw new Error("渲染任务未返回产物");
+            setState({
+                phase: "done",
+                mode: "remote",
+                percent: 100,
+                detail: `渲染完成：${parsed.fileName ?? "timeline.mp4"}`,
+                result: parsed,
+            });
+        } catch (error) {
+            setState({
+                phase: "error",
+                mode: "remote",
+                percent: 0,
+                detail: error instanceof Error ? error.message : "渲染失败",
+                result: null,
+            });
+        }
+    };
+
+    // 降级路径：ffmpeg.wasm 浏览器本地合成（无后端/离线时可用）。
+    const exportLocalMp4 = async () => {
+        if (!project || sources.length === 0 || state.phase === "running") return;
+        setState({ phase: "running", mode: "local", percent: 0, detail: "准备导出", result: null });
+        try {
+            const blob = await exportTimelineToMp4(project, sources, {
+                onProgress: (p: TimelineExportProgress) =>
+                    setState({ phase: "running", mode: "local", percent: p.percent, detail: p.detail, result: null }),
+            });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement("a");
+            a.href = url;
+            a.download = "timeline-export.mp4";
+            a.click();
+            URL.revokeObjectURL(url);
+            setState({ phase: "done", mode: "local", percent: 100, detail: "导出完成，已开始下载", result: null });
+        } catch (error) {
+            setState({
+                phase: "error",
+                mode: "local",
+                percent: 0,
+                detail: error instanceof Error ? error.message : "导出失败",
+                result: null,
+            });
+        }
+    };
+
+    if (!project) return null;
+
+    return (
+        <div className="flex h-full flex-col bg-[var(--director-sequencer-surface)]">
+            <div className="director-scroll min-h-0 flex-1 overflow-y-auto p-3">
+                <div className="mb-3 rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] p-2.5">
+                    <div className="flex items-center justify-between">
+                        <span className="text-xs font-medium text-[var(--director-dock-fg-strong)]">渲染计划</span>
+                        <span className="text-[10px] text-[var(--director-dock-fg)]/60">{plan ? `${plan.steps.length} 步` : "—"}</span>
+                    </div>
+                    {plan && plan.steps.length > 0 ? (
+                        <ul className="mt-2 space-y-1">
+                            {plan.steps.slice(0, 8).map((step, index) => (
+                                <li key={index} className="flex items-center gap-2 text-[11px] text-[var(--director-dock-fg)]/70">
+                                    <span className="shrink-0 rounded bg-[var(--director-dock-active-surface)] px-1 py-0.5 font-mono text-[9px] uppercase text-[var(--director-dock-fg)]/80">
+                                        {step.kind}
+                                    </span>
+                                    <span className="truncate">{step.description}</span>
+                                </li>
+                            ))}
+                            {plan.steps.length > 8 && (
+                                <li className="pt-0.5 text-[10px] text-[var(--director-dock-fg)]/50">…共 {plan.steps.length} 步</li>
+                            )}
+                        </ul>
+                    ) : (
+                        <p className="mt-2 text-[11px] text-[var(--director-dock-fg)]/55">时间线没有可渲染的视频片段。</p>
+                    )}
+                </div>
+
+                <div className="mb-3 flex items-center justify-between rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] px-2.5 py-2 text-[11px] text-[var(--director-dock-fg)]/70">
+                    <span className="flex items-center gap-1.5">
+                        <PackageOpen className="size-3.5 text-[var(--director-dock-fg)]/60" />
+                        渲染源
+                    </span>
+                    <span className="tabular-nums text-[var(--director-dock-fg)]/80">{sources.length} 个</span>
+                </div>
+
+                <button
+                    type="button"
+                    onClick={renderRemote}
+                    disabled={sources.length === 0 || state.phase === "running"}
+                    className="flex w-full items-center justify-center gap-2 rounded-md bg-[var(--director-accent)] px-2 py-1.5 text-xs font-medium text-[var(--director-on-accent)] hover:bg-[var(--director-accent-hover)] disabled:opacity-40"
+                >
+                    {state.phase === "running" && state.mode === "remote" ? (
+                        <Loader2 className="size-3.5 animate-spin" />
+                    ) : (
+                        <Server className="size-3.5" />
+                    )}
+                    {state.phase === "running" && state.mode === "remote" ? "渲染中…" : "渲染成片（服务端）"}
+                </button>
+
+                <button
+                    type="button"
+                    onClick={exportLocalMp4}
+                    disabled={sources.length === 0 || state.phase === "running"}
+                    className="mt-1.5 flex w-full items-center justify-center gap-2 rounded-md border border-[var(--director-sequencer-border)] px-2 py-1.5 text-xs text-[var(--director-dock-fg)]/80 hover:bg-[var(--director-control-hover)] disabled:opacity-40"
+                >
+                    {state.phase === "running" && state.mode === "local" ? (
+                        <Loader2 className="size-3.5 animate-spin" />
+                    ) : (
+                        <Download className="size-3.5" />
+                    )}
+                    {state.phase === "running" && state.mode === "local" ? "导出中…" : "本地导出（ffmpeg.wasm）"}
+                </button>
+
+                {state.phase === "running" && (
+                    <div className="mt-3">
+                        <div className="mb-1 flex justify-between text-[10px] text-[var(--director-dock-fg)]/70">
+                            <span>{state.detail}</span>
+                            <span className="tabular-nums">{state.percent}%</span>
+                        </div>
+                        <div className="h-1.5 overflow-hidden rounded-full bg-[var(--director-control-hover)]">
+                            <div
+                                className="h-full rounded-full bg-[var(--director-accent)] transition-all"
+                                style={{ width: `${state.percent}%` }}
+                            />
+                        </div>
+                    </div>
+                )}
+
+                {state.phase === "done" && state.result && state.mode === "remote" && (
+                    <div className="mt-2 overflow-hidden rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)]">
+                        <video src={resourceFileUrl(state.result.resourceId)} controls className="aspect-video w-full bg-black" />
+                        <div className="flex items-center justify-between gap-2 px-2 py-1.5 text-[11px] text-[var(--director-dock-fg)]/80">
+                            <span className="truncate">{state.result.fileName ?? "timeline.mp4"}</span>
+                            <a
+                                href={resourceFileUrl(state.result.resourceId)}
+                                download={state.result.fileName ?? "timeline.mp4"}
+                                className="flex shrink-0 items-center gap-1 text-[var(--director-accent)] hover:underline"
+                            >
+                                <Download className="size-3" />
+                                下载
+                            </a>
+                        </div>
+                    </div>
+                )}
+                {state.phase === "done" && (!state.result || state.mode !== "remote") && (
+                    <p className="mt-2 text-[11px] text-[var(--director-success)]">{state.detail}</p>
+                )}
+                {state.phase === "error" && <p className="mt-2 text-[11px] text-[var(--director-danger)]">{state.detail}</p>}
+
+                <p className="mt-3 text-[11px] leading-relaxed text-[var(--director-dock-fg)]/55">
+                    默认提交服务端渲染任务（异步，产物可直接预览/下载）；本地 ffmpeg.wasm 导出保留为离线兜底。
+                </p>
+                {sources.length === 0 && (
+                    <p className="mt-1 text-[11px] text-[var(--director-dock-fg)]/55">悬空引用片段（节点已删除）按计划跳过，不影响其余片段导出。</p>
+                )}
+            </div>
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-inspector.tsx b/web/src/lib/plugins/builtin/editor/editor-inspector.tsx
new file mode 100644
index 000000000..481239efb
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-inspector.tsx
@@ -0,0 +1,198 @@
+// 片段检查器（editor-shell 预设插件贡献 inspector 插槽，M3.3）。
+// 读取选中片段（store.selectedClipId），属性编辑经 setClipProperty 命令入队
+// （可撤销、可回放、进黄金文件语义）；无选中时显示项目概览。
+// 视觉参照 Concat inspector：分组小标题 + 紧凑控件 + sunken 滑块，token 随主题联动。
+
+import { useEffect, useState } from "react";
+
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import { formatTimelineTime } from "@/lib/timeline/timeline-view";
+import type { TimelineClip } from "@/types/timeline";
+
+export function EditorInspector() {
+    const { project, selectedClipId, dispatch, selectClip } = useEditorStoreContext();
+    const clip = project?.clips.find((c) => c.id === selectedClipId) ?? null;
+
+    if (!clip) {
+        return (
+            <div className="flex h-full flex-col bg-[var(--director-sequencer-surface)]">
+                <div className="flex flex-1 flex-col items-center justify-center gap-2 p-4 text-center">
+                    <p className="text-xs text-[var(--director-dock-fg)]/60">未选中片段</p>
+                    <p className="max-w-[180px] text-[11px] leading-relaxed text-[var(--director-dock-fg)]/45">在时间线中点击片段后，可在此编辑属性</p>
+                </div>
+            </div>
+        );
+    }
+
+    return (
+        <div className="flex h-full flex-col bg-[var(--director-sequencer-surface)]">
+            <div className="director-scroll min-h-0 flex-1 overflow-y-auto px-3 py-3">
+                <SectionTitle>片段</SectionTitle>
+                <ClipSummary clip={clip} />
+                <SectionTitle>基本</SectionTitle>
+                <PropertyField
+                    label="名称"
+                    value={clip.title ?? clip.nodeId ?? clip.id}
+                    onChange={(value) => dispatch({ op: "setClipProperty", payload: { id: clip.id, patch: { title: value } } })}
+                />
+                {clip.kind === "subtitle" && (
+                    <PropertyField
+                        label="字幕文本"
+                        value={clip.text ?? ""}
+                        onChange={(value) => dispatch({ op: "setClipProperty", payload: { id: clip.id, patch: { text: value } } })}
+                    />
+                )}
+                {clip.kind === "audio" && (
+                    <PropertyField
+                        label="音量"
+                        type="range"
+                        min={0}
+                        max={1}
+                        step={0.05}
+                        value={clip.volume ?? 1}
+                        formatValue={(v) => `${Math.round(v * 100)}%`}
+                        onChange={(value) => dispatch({ op: "setClipProperty", payload: { id: clip.id, patch: { volume: Number(value) } } })}
+                    />
+                )}
+                {(clip.kind === "video" || clip.kind === "audio") && (
+                    <>
+                        <SectionTitle>转场</SectionTitle>
+                        <PropertyField
+                            label="淡入"
+                            type="range"
+                            min={0}
+                            max={2000}
+                            step={50}
+                            value={clip.fadeInMs ?? 0}
+                            formatValue={(v) => `${(v / 1000).toFixed(1)}s`}
+                            onChange={(value) => dispatch({ op: "setClipProperty", payload: { id: clip.id, patch: { fadeInMs: Number(value) } } })}
+                        />
+                        <PropertyField
+                            label="淡出"
+                            type="range"
+                            min={0}
+                            max={2000}
+                            step={50}
+                            value={clip.fadeOutMs ?? 0}
+                            formatValue={(v) => `${(v / 1000).toFixed(1)}s`}
+                            onChange={(value) => dispatch({ op: "setClipProperty", payload: { id: clip.id, patch: { fadeOutMs: Number(value) } } })}
+                        />
+                    </>
+                )}
+            </div>
+            <div className="shrink-0 border-t border-[var(--director-sequencer-border)] p-2">
+                <button
+                    type="button"
+                    onClick={() => selectClip(null)}
+                    className="w-full rounded-md border border-[var(--director-sequencer-border)] py-1.5 text-xs text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                >
+                    清除选中
+                </button>
+            </div>
+        </div>
+    );
+}
+
+function SectionTitle({ children }: { children: React.ReactNode }) {
+    return (
+        <h3 className="mb-2 mt-4 text-[10px] font-medium uppercase tracking-wider text-[var(--director-dock-fg)]/45 first:mt-0">
+            {children}
+        </h3>
+    );
+}
+
+function ClipSummary({ clip }: { clip: TimelineClip }) {
+    const kindLabel: Record<TimelineClip["kind"], string> = {
+        video: "视频",
+        audio: "音频",
+        subtitle: "字幕",
+        text: "文本",
+        image: "图片",
+    };
+    return (
+        <div>
+            <div className="flex items-center justify-between">
+                <span className="text-xs font-medium text-[var(--director-dock-fg-strong)]">{kindLabel[clip.kind] ?? clip.kind}</span>
+                <span className="font-mono text-[10px] text-[var(--director-dock-fg)]/40">#{clip.id.slice(-6)}</span>
+            </div>
+            <dl className="mt-2 grid grid-cols-2 gap-x-3 gap-y-1 text-[11px]">
+                <div className="flex items-baseline justify-between gap-2">
+                    <dt className="shrink-0 text-[var(--director-dock-fg)]/45">起点</dt>
+                    <dd className="tabular-nums text-[var(--director-dock-fg)]/80">{formatTimelineTime(clip.startMs)}</dd>
+                </div>
+                <div className="flex items-baseline justify-between gap-2">
+                    <dt className="shrink-0 text-[var(--director-dock-fg)]/45">时长</dt>
+                    <dd className="tabular-nums text-[var(--director-dock-fg)]/80">{formatTimelineTime(clip.durationMs)}</dd>
+                </div>
+                <div className="flex items-baseline justify-between gap-2">
+                    <dt className="shrink-0 text-[var(--director-dock-fg)]/45">源起点</dt>
+                    <dd className="tabular-nums text-[var(--director-dock-fg)]/80">{formatTimelineTime(clip.sourceStartMs ?? 0)}</dd>
+                </div>
+                <div className="flex items-baseline justify-between gap-2">
+                    <dt className="shrink-0 text-[var(--director-dock-fg)]/45">结束</dt>
+                    <dd className="tabular-nums text-[var(--director-dock-fg)]/80">{formatTimelineTime(clip.startMs + clip.durationMs)}</dd>
+                </div>
+            </dl>
+        </div>
+    );
+}
+
+function PropertyField({
+    label,
+    value,
+    onChange,
+    type = "text",
+    min,
+    max,
+    step,
+    formatValue,
+}: {
+    label: string;
+    value: string | number;
+    onChange: (value: string) => void;
+    type?: "text" | "range";
+    min?: number;
+    max?: number;
+    step?: number;
+    formatValue?: (value: number) => string;
+}) {
+    const [localValue, setLocalValue] = useState<string>(String(value));
+    useEffect(() => setLocalValue(String(value)), [value]);
+
+    const displayValue = type === "range" && formatValue ? formatValue(Number(localValue)) : localValue;
+
+    return (
+        <div className="mb-3">
+            <div className="mb-1.5 flex items-center justify-between">
+                <span className="text-[11px] text-[var(--director-dock-fg)]/70">{label}</span>
+                {type === "range" && (
+                    <span className="tabular-nums text-[10px] text-[var(--director-dock-fg)]/50">{displayValue}</span>
+                )}
+            </div>
+            {type === "range" ? (
+                <input
+                    type="range"
+                    min={min}
+                    max={max}
+                    step={step}
+                    value={Number(localValue)}
+                    onChange={(e) => {
+                        setLocalValue(e.target.value);
+                        onChange(e.target.value);
+                    }}
+                    className="editor-slider"
+                />
+            ) : (
+                <input
+                    type="text"
+                    value={localValue}
+                    onChange={(e) => setLocalValue(e.target.value)}
+                    onBlur={() => {
+                        if (localValue !== String(value)) onChange(localValue);
+                    }}
+                    className="h-7 w-full rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-2 text-xs text-[var(--director-dock-fg-strong)] outline-none transition-colors focus:border-[var(--director-dock-fg-strong)]/40"
+                />
+            )}
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-preview-monitor.tsx b/web/src/lib/plugins/builtin/editor/editor-preview-monitor.tsx
new file mode 100644
index 000000000..06a7d31c1
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-preview-monitor.tsx
@@ -0,0 +1,523 @@
+// 预览监视器（editor-shell 预设插件贡献 preview-renderer 插槽，M3.2）。
+// 浏览器内近似预览：真实媒体帧（storageKey → resolveMediaUrl）+ 播放头 + 时间码。
+// 近似渲染与导出（M3.7 的 buildTimelineRenderPlan）共享同一条"片段→媒体"解析路径，
+// 但这里只做时序呈现，不承诺像素级预览——像素级交给导出任务（M4）。
+//
+// 播放模型：时间线 transport（store.transportMs）与监视器共享。
+// - 本地 playbackRef 以 rAF 逐帧推进（60fps 时间码），节流回写 store（~80ms），
+//   驱动时间线播放头；外部 scrub（时间线标尺）经 transportMs 回推本地时钟。
+// - <video> 元素从动于时钟：播放时 play()、暂停时 pause()、位置偏差 > 阈值才硬 seek，
+//   播放速率同步 playbackRate —— 画面与声音由浏览器管线真实推进（不再纯读时间码）。
+// - 静音跟随所在音频/视频轨道（muted），不再硬编码 muted（否则"有声音"永远不成立）。
+
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { ChevronDown, Film, Gauge, Pause, Play, SkipBack, SkipForward, StepBack, StepForward } from "lucide-react";
+
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import { formatTimelineTime } from "@/lib/timeline/timeline-view";
+import { resolveMediaUrl } from "@/services/file-storage";
+import { playbackVariantUrl, refreshResource, resourceFileUrl, resourceIdFromStorageKey } from "@/services/api/resources";
+import type { TimelineClip, TimelineProject } from "@/types/timeline";
+
+// 本地播放时钟 → store.transportMs 的回写节流（毫秒）。太密会让时间线面板每帧重渲染。
+const STORE_PUSH_INTERVAL_MS = 80;
+// 外部 seek 与本地时钟差超过该值（毫秒）视为"拖动跳转"：先暂停再跟随，避免播放中抢时钟。
+const SEEK_JUMP_MS = 500;
+// 视频元素位置校正阈值（秒）：仅当偏差超过该值才硬 seek，避免逐帧写 currentTime。
+const VIDEO_SEEK_TOLERANCE_S = 0.35;
+
+function getClipAtTime(project: TimelineProject, timeMs: number): TimelineClip | null {
+    // 隐藏轨道（visible === false）上的片段不参与预览合成。
+    const hiddenTrackIds = new Set(project.tracks.filter((t) => t.visible === false).map((t) => t.id));
+    const visible = (clip: TimelineClip) => !hiddenTrackIds.has(clip.trackId);
+    return (
+        project.clips.find((clip) => visible(clip) && clip.kind === "video" && clip.startMs <= timeMs && timeMs < clip.startMs + clip.durationMs) ??
+        project.clips.find((clip) => visible(clip) && clip.kind === "image" && clip.startMs <= timeMs && timeMs < clip.startMs + clip.durationMs) ??
+        null
+    );
+}
+
+function useClipMediaUrl(clip: TimelineClip | null): string | null {
+    const [url, setUrl] = useState<string | null>(null);
+    useEffect(() => {
+        let cancelled = false;
+        setUrl(null);
+        if (!clip) return;
+        const direct = clip.directMedia;
+        const source = direct?.dataUrl ?? direct?.url ?? direct?.storageKey;
+        if (direct?.storageKey) {
+            resolveMediaUrl(direct.storageKey, direct.url ?? "")
+                .catch(() => null)
+                .then((resolved) => {
+                    if (!cancelled && resolved) setUrl(resolved);
+                });
+        } else if (source) {
+            setUrl(source);
+        }
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [clip?.id, clip?.nodeId, clip?.directMedia?.storageKey, clip?.directMedia?.url, clip?.directMedia?.dataUrl]);
+    return url;
+}
+
+/** clip 内部当前应播放的源时间（毫秒）：transport 相对 clip 起点 + 源起点偏移。 */
+function clipSourceTimeMs(clip: TimelineClip, transportMs: number): number {
+    return Math.max(0, transportMs - clip.startMs + (clip.sourceStartMs ?? 0));
+}
+
+export function EditorPreviewMonitor() {
+    const { project, transportMs, setTransportMs } = useEditorStoreContext();
+    const durationMs = project?.durationMs ?? 0;
+
+    // 本地播放时钟（毫秒）：逐帧刷新本组件；播放态节流回写 store 驱动时间线播放头。
+    const [playbackMs, setPlaybackMs] = useState(0);
+    const playbackRef = useRef(0);
+    const [playing, setPlaying] = useState(false);
+    const playingRef = useRef(false);
+    const [speed, setSpeed] = useState(1);
+    const speedRef = useRef(1);
+    const [speedMenuOpen, setSpeedMenuOpen] = useState(false);
+    const rafRef = useRef<number | null>(null);
+    const lastTickRef = useRef<number | null>(null);
+    const lastStorePushRef = useRef(0);
+    const videoRef = useRef<HTMLVideoElement | null>(null);
+
+    const activeClip = project ? getClipAtTime(project, playbackMs) : null;
+    const activeMediaUrl = useClipMediaUrl(activeClip);
+    const activeTrack = project?.tracks.find((t) => t.id === activeClip?.trackId) ?? null;
+
+    // 播放回退：H.264 原件直接播放；H.265/HEVC 原件多数浏览器无法解码（黑屏），
+    // <video> onError 后切换后端 playback 转码副本（variant=playback），副本就绪前轮询。
+    const storageKey = activeClip?.directMedia?.storageKey;
+    const mediaResourceId = storageKey ? resourceIdFromStorageKey(storageKey) : null;
+    const [mediaTier, setMediaTier] = useState<"primary" | "variant">("primary");
+    const [variantReadyTick, setVariantReadyTick] = useState(0);
+    const [mediaErrorHint, setMediaErrorHint] = useState<string | null>(null);
+
+    useEffect(() => {
+        setMediaTier("primary");
+        setVariantReadyTick(0);
+        setMediaErrorHint(null);
+    }, [activeClip?.id, storageKey, activeMediaUrl]);
+
+    useEffect(() => {
+        if (mediaTier !== "variant" || !mediaResourceId) return;
+        let cancelled = false;
+        let failures = 0;
+        let polls = 0;
+        const timer = window.setInterval(async () => {
+            try {
+                const res = await refreshResource(mediaResourceId);
+                if (cancelled) return;
+                if (res.playbackStatus === "ready") {
+                    setMediaErrorHint(null);
+                    setVariantReadyTick((n) => n + 1);
+                    window.clearInterval(timer);
+                } else if (res.playbackStatus === "failed") {
+                    setMediaErrorHint("兼容副本生成失败，可下载原片后用本地播放器观看。");
+                    window.clearInterval(timer);
+                } else if (res.playbackStatus === "none") {
+                    // 后端判定无需转码（远端存储/无 ffmpeg/编码不可处理）：无副本可等，
+                    // 停轮询回到原件原生播放，避免"正在生成"永挂。
+                    setMediaTier("primary");
+                    setMediaErrorHint(null);
+                    window.clearInterval(timer);
+                } else if ((polls += 1) >= 120) {
+                    // processing 上限保护（约 5 分钟）：转码异常卡死时不再无限轮询。
+                    setMediaErrorHint("兼容版本生成超时，可下载原片后用本地播放器观看。");
+                    window.clearInterval(timer);
+                } else {
+                    setMediaErrorHint("视频编码此浏览器暂不支持，正在生成兼容版本（H.264）…");
+                }
+                failures = 0;
+            } catch {
+                if (cancelled) return;
+                failures += 1;
+                if (failures >= 4) {
+                    window.clearInterval(timer);
+                    setMediaErrorHint("兼容版本生成服务暂不可达，请稍后重新打开预览重试。");
+                }
+            }
+        }, 2500);
+        return () => {
+            cancelled = true;
+            window.clearInterval(timer);
+        };
+    }, [mediaTier, mediaResourceId]);
+
+    const handleMediaError = () => {
+        // 图片/无资源：无播放副本可切，仅提示。
+        if (activeClip?.kind !== "video" || !mediaResourceId) {
+            setMediaErrorHint("该媒体无法解码，可下载原片后用本地播放器观看。");
+            return;
+        }
+        if (mediaTier === "primary") {
+            // 原件解码失败（大概率 H.265）：切后端 playback 副本。
+            setMediaTier("variant");
+            setMediaErrorHint("视频编码此浏览器暂不支持，正在生成兼容版本（H.264）…");
+        } else {
+            // 副本尚未就绪时后端回退原件仍会失败；轮询 effect 会在就绪后重载。
+            setMediaErrorHint("视频编码此浏览器暂不支持，正在生成兼容版本（H.264）…");
+        }
+    };
+
+    const isVideoClip = activeClip?.kind === "video";
+    const videoSrc = isVideoClip && mediaResourceId && mediaTier === "variant" ? playbackVariantUrl(mediaResourceId) : isVideoClip ? activeMediaUrl : null;
+    const imageSrc = activeClip?.kind === "image" ? activeMediaUrl : null;
+    const videoMuted = activeTrack?.muted === true;
+
+    const syncPlayback = useCallback(
+        (ms: number) => {
+            const t = Math.max(0, Math.min(durationMs, Math.round(ms)));
+            playbackRef.current = t;
+            setPlaybackMs(t);
+            setTransportMs(t);
+        },
+        [durationMs, setTransportMs],
+    );
+
+    const stop = useCallback(() => {
+        playingRef.current = false;
+        setPlaying(false);
+        if (rafRef.current !== null) {
+            cancelAnimationFrame(rafRef.current);
+            rafRef.current = null;
+        }
+        lastTickRef.current = null;
+        lastStorePushRef.current = 0;
+        const v = videoRef.current;
+        if (v && !v.paused) v.pause();
+        setTransportMs(playbackRef.current);
+    }, [setTransportMs]);
+
+    // 外部 transport 变化（时间线标尺 scrub / 跳转）：回推本地时钟；
+    // 播放中大幅跳动视为拖动跳转，先暂停避免与本地时钟互相抢写。
+    useEffect(() => {
+        if (transportMs === playbackRef.current) return;
+        if (playingRef.current) {
+            // 播放中收到的 transport 写入只可能是自身节流回写或外部 scrub；
+            // 大幅跳动视为拖动/跳转：暂停并跟随。小幅忽略，避免本地时钟被旧回写值拉回（回跳）。
+            if (Math.abs(transportMs - playbackRef.current) > SEEK_JUMP_MS) {
+                stop();
+                playbackRef.current = transportMs;
+                setPlaybackMs(transportMs);
+            }
+            return;
+        }
+        playbackRef.current = transportMs;
+        setPlaybackMs(transportMs);
+        // stop 已是最新引用；transportMs 为唯一驱动源
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [transportMs]);
+
+    const toggle = useCallback(() => {
+        if (!project || durationMs <= 0) return;
+        if (playingRef.current) {
+            stop();
+            return;
+        }
+        // 停在末尾再点播放：从头开始。
+        if (playbackRef.current >= durationMs - 50) {
+            playbackRef.current = 0;
+            setPlaybackMs(0);
+            setTransportMs(0);
+        }
+        playingRef.current = true;
+        lastTickRef.current = null;
+        setPlaying(true);
+        const tick = (now: number) => {
+            if (lastTickRef.current === null) lastTickRef.current = now;
+            const delta = now - lastTickRef.current;
+            lastTickRef.current = now;
+            const next = Math.min(durationMs, Math.max(0, playbackRef.current + delta * speedRef.current));
+            playbackRef.current = next;
+            setPlaybackMs(next);
+            if (now - lastStorePushRef.current >= STORE_PUSH_INTERVAL_MS) {
+                lastStorePushRef.current = now;
+                setTransportMs(next);
+            }
+            if (next >= durationMs) {
+                stop();
+                return;
+            }
+            rafRef.current = requestAnimationFrame(tick);
+        };
+        rafRef.current = requestAnimationFrame(tick);
+    }, [durationMs, project, stop, setTransportMs]);
+
+    // 项目切换/时长变化时重置播放
+    useEffect(() => {
+        syncPlayback(0);
+        stop();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [project, durationMs]);
+
+    useEffect(() => () => stop(), [stop]);
+
+    const stepBy = (deltaMs: number) => {
+        if (!project || durationMs <= 0) return;
+        syncPlayback(playbackRef.current + deltaMs);
+    };
+
+    const changeSpeed = (next: number) => {
+        speedRef.current = next;
+        setSpeed(next);
+    };
+
+    // —— <video> 从动驱动 ——
+
+    const applyVideoPosition = (v: HTMLVideoElement) => {
+        if (!activeClip || activeClip.kind !== "video") return;
+        const targetS = clipSourceTimeMs(activeClip, playbackRef.current) / 1000;
+        const maxS = Number.isFinite(v.duration) && v.duration > 0 ? v.duration : targetS;
+        const t = Math.min(targetS, maxS);
+        if (Math.abs(v.currentTime - t) > VIDEO_SEEK_TOLERANCE_S) v.currentTime = t;
+    };
+
+    // 时钟推进/外部 seek：校正视频位置（播放同速时偏差小，几乎不触发硬 seek）。
+    useEffect(() => {
+        const v = videoRef.current;
+        if (!v || !isVideoClip) return;
+        if (v.readyState < HTMLMediaElement.HAVE_METADATA) return;
+        applyVideoPosition(v);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [playbackMs, mediaTier, variantReadyTick, activeClip?.id]);
+
+    // 播放/暂停：真实驱动浏览器管线（画面 + 声音）。
+    useEffect(() => {
+        const v = videoRef.current;
+        if (!v || !isVideoClip) return;
+        if (playing) {
+            const p = v.play();
+            if (p) p.catch(() => {
+                // 浏览器 autoplay/格式限制：onError 已接管提示与回退。
+            });
+        } else if (!v.paused) {
+            v.pause();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [playing, mediaTier, variantReadyTick, activeClip?.id, videoSrc]);
+
+    // 变速：同步视频播放速率，保持音画与时钟一致。
+    useEffect(() => {
+        const v = videoRef.current;
+        if (v && isVideoClip) v.playbackRate = speed;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [speed, mediaTier, variantReadyTick, activeClip?.id]);
+
+    const handleLoadedMetadata = () => {
+        const v = videoRef.current;
+        if (!v) return;
+        applyVideoPosition(v);
+        if (playingRef.current) {
+            const p = v.play();
+            if (p) p.catch(() => {});
+        }
+    };
+
+    // 源素材比片段短：video 提前播完 → 把时钟对齐到片段结尾，让后续片段/结束自然衔接。
+    const handleVideoEnded = () => {
+        if (!activeClip || activeClip.kind !== "video") return;
+        const clipEndMs = activeClip.startMs + activeClip.durationMs;
+        if (clipEndMs >= durationMs - 50) {
+            stop();
+            syncPlayback(durationMs);
+        } else {
+            syncPlayback(clipEndMs);
+        }
+    };
+
+    // 播放条随监视器面板宽度自适应：窄面板逐级隐藏次要信息（先“/ 总时长”，再时间码与速度文字/箭头），
+    // 极窄时让整条可横向滚动兜底；走带按钮始终固定尺寸，不缩小、不重叠。阈值即对应内容的最小显示宽度。
+    const transportRef = useRef<HTMLDivElement | null>(null);
+    const [transportWidth, setTransportWidth] = useState(Number.POSITIVE_INFINITY);
+    useLayoutEffect(() => {
+        const el = transportRef.current;
+        if (!el) return;
+        const update = () => setTransportWidth(Math.round(el.getBoundingClientRect().width));
+        update();
+        if (typeof ResizeObserver === "undefined") return;
+        const observer = new ResizeObserver(update);
+        observer.observe(el);
+        return () => observer.disconnect();
+    }, []);
+    const compact = transportWidth < 340;
+    const hideTotal = !compact && transportWidth < 440;
+    const allowScroll = transportWidth < 240;
+
+    const showEmpty = !activeClip || (!videoSrc && !imageSrc);
+
+    return (
+        <div className="flex h-full min-h-0 flex-col overflow-hidden bg-[var(--director-sequencer-surface)]">
+            {/* 预览画面：恒黑舞台，占满控制条以上剩余空间（Concat 监视器风格） */}
+            <div className="relative flex min-h-0 flex-1 items-center justify-center overflow-hidden bg-black p-6">
+                {showEmpty ? (
+                    <div className="flex flex-col items-center gap-3 text-center">
+                        <div className="grid size-14 place-items-center rounded-xl bg-white/10">
+                            <Film className="size-6 text-white/60" />
+                        </div>
+                        <div className="max-w-xs text-xs leading-relaxed text-white/70">
+                            {project && project.clips.length > 0
+                                ? activeClip
+                                    ? "当前时间点片段无媒体源（占位/字幕/音频）"
+                                    : "播放头位于空白处"
+                                : "时间线暂无片段，导入素材后在此预览"}
+                        </div>
+                    </div>
+                ) : isVideoClip && videoSrc ? (
+                    <video
+                        key={`v:${activeClip!.id}:${mediaTier}:${variantReadyTick}`}
+                        ref={videoRef}
+                        src={videoSrc}
+                        muted={videoMuted}
+                        playsInline
+                        preload="auto"
+                        className="max-h-full max-w-full rounded-md object-contain shadow-lg"
+                        onError={handleMediaError}
+                        onLoadedMetadata={handleLoadedMetadata}
+                        onEnded={handleVideoEnded}
+                    />
+                ) : imageSrc ? (
+                    <img
+                        key={`i:${activeClip!.id}`}
+                        src={imageSrc}
+                        alt=""
+                        className="max-h-full max-w-full rounded-md object-contain shadow-lg"
+                        onError={handleMediaError}
+                    />
+                ) : null}
+                {mediaErrorHint && (
+                    <div className="absolute inset-x-0 bottom-0 flex flex-col items-center gap-2 bg-black/70 px-4 py-3 backdrop-blur">
+                        <p className="text-xs leading-relaxed text-white/90">{mediaErrorHint}</p>
+                        {mediaResourceId && (
+                            <a
+                                href={resourceFileUrl(mediaResourceId)}
+                                download
+                                className="text-[11px] underline decoration-white/40 underline-offset-2 text-white/70 hover:text-white"
+                            >
+                                下载原片用本地播放器观看
+                            </a>
+                        )}
+                    </div>
+                )}
+                {activeClip && (
+                    <div className="absolute left-4 top-4 rounded-md bg-black/60 px-2 py-1 text-[11px] text-white/90 backdrop-blur">
+                        {activeClip.nodeId || activeClip.id} · {activeClip.kind}
+                    </div>
+                )}
+            </div>
+
+            {/* 播放控制条：画面下方的独立一行（Concat 布局），不悬浮叠加、无进度条；
+                播放/暂停用反白块 + 图标形态（Play/Pause）表达状态，图标保持中性（无 accent 蓝）。
+                宽度自适应见上方 transportWidth 逻辑。 */}
+            <div
+                ref={transportRef}
+                className={`grid h-11 shrink-0 grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center gap-2 border-t border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-3 ${
+                    allowScroll ? "overflow-x-auto [scrollbar-width:thin]" : ""
+                }`}
+            >
+                <span className="truncate text-xs tabular-nums text-[var(--director-dock-fg)]">
+                    {!compact && formatTimelineTime(playbackMs)}
+                    {!compact && !hideTotal && (
+                        <span className="opacity-60"> / {formatTimelineTime(durationMs)}</span>
+                    )}
+                </span>
+                <div className="flex shrink-0 items-center gap-0.5">
+                    <button
+                        type="button"
+                        aria-label="回到开头"
+                        title="回到开头"
+                        onClick={() => syncPlayback(0)}
+                        disabled={!project || durationMs <= 0}
+                        className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-40"
+                    >
+                        <SkipBack className="size-4" />
+                    </button>
+                    <button
+                        type="button"
+                        aria-label="后退 1 秒"
+                        title="后退 1 秒"
+                        onClick={() => stepBy(-1000)}
+                        disabled={!project || durationMs <= 0}
+                        className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-40"
+                    >
+                        <StepBack className="size-4" />
+                    </button>
+                    <button
+                        type="button"
+                        aria-label={playing ? "暂停" : "播放"}
+                        onClick={toggle}
+                        disabled={durationMs <= 0}
+                        className={`grid size-7 place-items-center rounded-md transition-colors disabled:pointer-events-none disabled:opacity-40 ${
+                            playing
+                                ? "bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]"
+                                : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                        }`}
+                    >
+                        {playing ? <Pause className="size-4" /> : <Play className="size-4 translate-x-px" />}
+                    </button>
+                    <button
+                        type="button"
+                        aria-label="前进 1 秒"
+                        title="前进 1 秒"
+                        onClick={() => stepBy(1000)}
+                        disabled={!project || durationMs <= 0}
+                        className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-40"
+                    >
+                        <StepForward className="size-4" />
+                    </button>
+                    <button
+                        type="button"
+                        aria-label="跳到结尾"
+                        title="跳到结尾"
+                        onClick={() => syncPlayback(durationMs)}
+                        disabled={!project || durationMs <= 0}
+                        className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-40"
+                    >
+                        <SkipForward className="size-4" />
+                    </button>
+                </div>
+                <div className="relative justify-self-end">
+                    <button
+                        type="button"
+                        aria-label="播放速度"
+                        title="播放速度"
+                        onClick={() => setSpeedMenuOpen((v) => !v)}
+                        className="flex h-7 items-center gap-1 rounded-md px-1.5 text-[11px] font-medium text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                    >
+                        <Gauge className="size-3.5" />
+                        {!compact && <span className="tabular-nums">{speed}x</span>}
+                        {!compact && (
+                            <ChevronDown className={`size-3 transition-transform ${speedMenuOpen ? "rotate-180" : ""}`} />
+                        )}
+                    </button>
+                    {speedMenuOpen && (
+                        <>
+                            <div className="fixed inset-0 z-40" onClick={() => setSpeedMenuOpen(false)} />
+                            <div className="absolute bottom-full right-0 z-50 mb-1 w-24 overflow-hidden rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] py-1 shadow-xl">
+                                {[0.5, 1, 1.5, 2].map((s) => (
+                                    <button
+                                        key={s}
+                                        type="button"
+                                        onClick={() => {
+                                            changeSpeed(s);
+                                            setSpeedMenuOpen(false);
+                                        }}
+                                        className={`flex w-full items-center justify-between px-2.5 py-1.5 text-[11px] transition-colors hover:bg-[var(--director-control-hover)] ${
+                                            s === speed ? "text-[var(--director-dock-fg-strong)]" : "text-[var(--director-dock-fg)]"
+                                        }`}
+                                    >
+                                        <span>{s}x</span>
+                                        {s === speed && <span className="opacity-60">✓</span>}
+                                    </button>
+                                ))}
+                            </div>
+                        </>
+                    )}
+                </div>
+            </div>
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-shell.tsx b/web/src/lib/plugins/builtin/editor/editor-shell.tsx
new file mode 100644
index 000000000..7709bd989
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-shell.tsx
@@ -0,0 +1,98 @@
+import { registerPlugin } from "@/lib/plugins/plugin-registry";
+import type { PluginManifestV2, RegisteredPlugin } from "@/lib/plugins/plugin-types";
+import { registerEditorSlot } from "@/lib/plugins/editor-slot-registry";
+import { EditorTimelinePanel } from "./editor-timeline-panel";
+import { EditorPreviewMonitor } from "./editor-preview-monitor";
+import { EditorSubtitleTools } from "./editor-subtitle-tools";
+import { EditorInspector } from "./editor-inspector";
+import { EditorAssetIngest } from "./editor-asset-ingest";
+import { EditorTranscription } from "./editor-transcription";
+import { EditorExport } from "./editor-export";
+import { EditorAiAssistant } from "./editor-ai-assistant";
+
+const manifest: PluginManifestV2 = {
+    apiVersion: "yingce.plugin/v2",
+    id: "editor-shell",
+    name: "剪辑工作台（壳）",
+    version: "0.1.0",
+    description: "编辑器预设插件垂直切片：注册时间线面板插槽，验证 v2 插件插槽注册→渲染链路。",
+    author: "影策团队",
+    surfaces: ["fullscreen"],
+    permissions: ["timeline.read", "timeline.command", "export.run"],
+    trusted: true,
+    runtime: { backend: "trusted-backend", web: "declarative" },
+    contributes: {
+        editorSlots: [
+            { slot: "timeline-panel", priority: 0 },
+            { slot: "preview-renderer", priority: 0 },
+            { slot: "inspector", priority: 0 },
+            { slot: "asset-ingest", priority: 0 },
+            { slot: "subtitle-tool", priority: 0 },
+            { slot: "transcription-provider", priority: 0 },
+            { slot: "export-renderer", priority: 0 },
+            { slot: "ai-assistant", priority: 0 },
+        ],
+    },
+};
+
+export const editorShellPlugin: RegisteredPlugin = {
+    manifest,
+    editorSlots: manifest.contributes.editorSlots ?? [],
+};
+
+registerPlugin(editorShellPlugin);
+
+// M2.4：插槽渲染函数 = 真实时间线面板（命令状态机 + 手势）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "timeline-panel",
+    render: () => <EditorTimelinePanel />,
+});
+
+// M3.2：插槽渲染函数 = 预览监视器（浏览器内近似预览 + 播放头）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "preview-renderer",
+    render: () => <EditorPreviewMonitor />,
+});
+// M3.3：插槽渲染函数 = 片段检查器（属性编辑入队可撤销）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "inspector",
+    render: () => <EditorInspector />,
+});
+
+// M3.4：插槽渲染函数 = 素材库（点击资产 → addClip 入轨）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "asset-ingest",
+    render: () => <EditorAssetIngest />,
+});
+
+// M3.5：插槽渲染函数 = 字幕工具（SRT 导入导出 + 从节点重建字幕快照）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "subtitle-tool",
+    render: () => <EditorSubtitleTools />,
+});
+
+// M3.6：转写（mock ASR → 字幕轨道，M4 接后端任务客户端）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "transcription-provider",
+    render: () => <EditorTranscription />,
+});
+
+// M3.7：导出（渲染计划 + ffmpeg.wasm 降级，M4 接后端任务）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "export-renderer",
+    render: () => <EditorExport />,
+});
+
+// M3.8：AI 助手占位（M6 补实现 ai-command-schema + timeline-summary）。
+registerEditorSlot({
+    pluginId: manifest.id,
+    slot: "ai-assistant",
+    render: () => <EditorAiAssistant />,
+});
diff --git a/web/src/lib/plugins/builtin/editor/editor-subtitle-tools.tsx b/web/src/lib/plugins/builtin/editor/editor-subtitle-tools.tsx
new file mode 100644
index 000000000..0d6df4c85
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-subtitle-tools.tsx
@@ -0,0 +1,143 @@
+// 字幕工具（editor-shell 预设插件贡献 subtitle-tool 插槽，M3.5）。
+// SRT 导入导出（复用 srt-parser）+ 「从节点重建字幕片段」命令（§3.1 快照契约：
+// 节点 subtitleEntries 权威 → 重建时间线字幕快照，替换过期快照，单向显式同步）。
+// AI 高亮在 M6（editor-ai-assistant + ai.text 权限）接入，此处留占位。
+
+import { useMemo, useState } from "react";
+
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import { parseSrt, serializeSrtEntries } from "@/lib/timeline/srt-parser";
+import { getSubtitleTracks } from "@/lib/timeline/timeline-tracks";
+import { formatTimelineTime } from "@/lib/timeline/timeline-view";
+import type { SrtEntry, TimelineClip } from "@/types/timeline";
+
+const DEFAULT_SRT_NODE_ID = "srt-import";
+
+export function EditorSubtitleTools() {
+    const { project, dispatch } = useEditorStoreContext();
+    const [srtText, setSrtText] = useState("");
+    const [message, setMessage] = useState<string | null>(null);
+
+    const subtitleClips = useMemo(
+        () => (project?.clips ?? []).filter((c) => c.kind === "subtitle").sort((a, b) => a.startMs - b.startMs),
+        [project],
+    );
+    const subtitleTracks = useMemo(() => (project ? getSubtitleTracks(project.tracks) : []), [project]);
+
+    // SRT 导入：解析文本 → rebuildSubtitleClips 以 DEFAULT_SRT_NODE_ID 为权威节点重建
+    // 字幕快照。确定性 id（nodeId:subtitle:index）保证重复导入原地替换，不堆积漂移。
+    const importSrt = () => {
+        const entries = parseSrt(srtText);
+        if (entries.length === 0) {
+            setMessage("未解析到有效 SRT 条目");
+            return;
+        }
+        dispatch({
+            op: "rebuildSubtitleClips",
+            payload: { nodeId: DEFAULT_SRT_NODE_ID, entries, trackId: subtitleTracks[0]?.id },
+        });
+        setMessage(`已从节点 ${DEFAULT_SRT_NODE_ID} 重建 ${entries.length} 条字幕快照`);
+    };
+
+    // SRT 导出：当前时间线字幕快照 → 序列化 → 下载 .srt（往返一致）。
+    const exportSrt = () => {
+        if (subtitleClips.length === 0) {
+            setMessage("时间线上没有字幕片段");
+            return;
+        }
+        const entries: SrtEntry[] = subtitleClips.map((clip, idx) => ({
+            index: clip.subtitleEntryIndex ?? idx + 1,
+            startMs: clip.startMs,
+            endMs: clip.startMs + clip.durationMs,
+            text: clip.text ?? "",
+        }));
+        const content = serializeSrtEntries(entries);
+        const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = "subtitles.srt";
+        a.click();
+        URL.revokeObjectURL(url);
+        setMessage(`已导出 ${entries.length} 条字幕`);
+    };
+
+    return (
+        <div className="flex h-full flex-col bg-[var(--director-sequencer-surface)]">
+            <div className="director-scroll min-h-0 flex-1 overflow-y-auto p-3">
+                <div className="mb-3 rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] p-2.5">
+                    <div className="flex items-center justify-between">
+                        <span className="text-xs font-medium text-[var(--director-dock-fg-strong)]">时间线字幕</span>
+                        <span className="text-[10px] text-[var(--director-dock-fg)]/60">{subtitleClips.length} 条</span>
+                    </div>
+                    {subtitleClips.length === 0 ? (
+                        <p className="mt-2 text-[11px] leading-relaxed text-[var(--director-dock-fg)]/55">暂无字幕快照。粘贴 SRT 导入后，字幕会重建到时间线。</p>
+                    ) : (
+                        <ul className="mt-2 space-y-1">
+                            {subtitleClips.slice(0, 6).map((clip) => (
+                                <SubtitleRow key={clip.id} clip={clip} />
+                            ))}
+                            {subtitleClips.length > 6 && (
+                                <li className="pt-1 text-[10px] text-[var(--director-dock-fg)]/50">…共 {subtitleClips.length} 条</li>
+                            )}
+                        </ul>
+                    )}
+                </div>
+
+                <label className="mb-3 block">
+                    <span className="mb-1 block text-[11px] text-[var(--director-dock-fg)]/70">SRT 文本（导入）</span>
+                    <textarea
+                        value={srtText}
+                        onChange={(e) => setSrtText(e.target.value)}
+                        rows={8}
+                        placeholder={"1\n00:00:00,500 --> 00:00:02,500\n你好，影策"}
+                        className="w-full resize-y rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] px-2 py-1.5 font-mono text-[11px] leading-relaxed text-[var(--director-dock-fg-strong)] outline-none focus:border-[var(--workspace-accent)]/60"
+                    />
+                </label>
+
+                <div className="mb-3 flex gap-2">
+                    <button
+                        type="button"
+                        onClick={importSrt}
+                        disabled={!srtText.trim()}
+                        className="flex-1 rounded-md bg-[var(--director-accent)] px-2 py-1.5 text-xs font-medium text-[var(--director-on-accent)] hover:bg-[var(--director-accent-hover)] disabled:opacity-40"
+                    >
+                        导入（重建字幕）
+                    </button>
+                    <button
+                        type="button"
+                        onClick={exportSrt}
+                        disabled={subtitleClips.length === 0}
+                        className="flex-1 rounded-md border border-[var(--director-sequencer-border)] px-2 py-1.5 text-xs text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:opacity-40"
+                    >
+                        导出 SRT
+                    </button>
+                </div>
+
+                <div className="rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] p-2.5">
+                    <div className="flex items-center justify-between">
+                        <span className="text-xs font-medium text-[var(--director-dock-fg-strong)]">AI 高亮</span>
+                        <span className="rounded-full bg-[var(--director-dock-active-surface)] px-1.5 py-0.5 text-[10px] text-[var(--director-dock-fg)]/80">M6</span>
+                    </div>
+                    <p className="mt-1.5 text-[11px] leading-relaxed text-[var(--director-dock-fg)]/55">
+                        AI 字幕高亮与关键词标注将在 M6（ai-assistant 插件 + ai.text 权限）接入。
+                    </p>
+                </div>
+
+                {message && <p className="mt-2 text-[11px] text-[var(--director-dock-fg)]/70">{message}</p>}
+            </div>
+        </div>
+    );
+}
+
+
+function SubtitleRow({ clip }: { clip: TimelineClip }) {
+    return (
+        <li className="flex items-baseline gap-2 rounded border border-[var(--director-sequencer-border)]/70 bg-[var(--director-control-hover)]/60 px-1.5 py-1">
+            <span className="shrink-0 tabular-nums text-[10px] text-[var(--director-dock-fg)]/60">
+                {formatTimelineTime(clip.startMs)} – {formatTimelineTime(clip.startMs + clip.durationMs)}
+            </span>
+            <span className="truncate text-[11px] text-[var(--director-dock-fg)]/80">{clip.text ?? ""}</span>
+        </li>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-timeline-panel.tsx b/web/src/lib/plugins/builtin/editor/editor-timeline-panel.tsx
new file mode 100644
index 000000000..8ec9bcd15
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-timeline-panel.tsx
@@ -0,0 +1,790 @@
+// 时间线面板（editor-shell 预设插件贡献，M2.4 手势 echo 最小件）。
+// 渲染链路：store.project（当前命令状态）→ 轨道/片段绝对定位 → 拖拽手势
+// （moveClip / trimClip）经 previewGesture 逐帧预览、commitGesture 一次性入历史。
+// 手势数学与渲染同源（同一 pxPerMs），保证拖拽所见即所得。
+// 撤销/重做与保存状态移入宿主顶栏（Concat 主菜单区），本面板保留缩放与片段统计。
+
+import { useEffect, useRef, useState } from "react";
+import { Eye, EyeOff, Film, Magnet, Maximize, MousePointer2, Music2, Plus, Scissors, Slice, Subtitles, Trash2, Volume2, VolumeX, X, ZoomIn, ZoomOut } from "lucide-react";
+
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import {
+    formatTimelineTime,
+    getFitTimelineZoom,
+    getRulerTickStep,
+    getTimelinePxPerMs,
+    getTimelineVisualEndMs,
+    zoomIn,
+    zoomOut,
+} from "@/lib/timeline/timeline-view";
+import { getAudioTracks, getSubtitleTracks, getVisualTracks } from "@/lib/timeline/timeline-tracks";
+import { TRACK_KIND_BASE_LABELS } from "@/lib/timeline/editor-commands";
+import { computeSnap } from "@/lib/timeline/timeline-snap";
+import type { TimelineClip, TimelineProject, TimelineTrack, TimelineTrackKind } from "@/types/timeline";
+
+const MIN_VISUAL_END_MS = 1_000;
+const SNAP_MS = 10;
+const TRIM_HANDLE_PX = 8;
+// 轨道标签列宽度（w-48）：轨道徽标 + 轨道名 + 可见/静音/移除按钮。
+// 时间线内容宽度必须补上该列，否则片段区 flex-1 只到
+// trackWidth - 192，末端片段被 overflow-hidden 裁掉且无法滚动到达。
+const LABEL_COLUMN_PX = 192;
+// 剃刀/播放头分割两侧的最小保留时长（毫秒），避免切出空片段。
+const MIN_SPLIT_MS = 100;
+
+// 不可移除轨道的原因文案（title 悬停与点击提示共用，单一来源）。
+const trackRemoveBlockedReason = (kind: TimelineTrack["kind"]) => `${TRACK_KIND_BASE_LABELS[kind]}轨道至少保留一条，无法移除`;
+
+// 工具条按钮颜色角色（唯一来源，各按钮内不得重复字面量颜色）：
+// 常态 = 次级前景 + hover 弱背景；选中/按下 = 反白块 + 强前景（中性，无 accent 蓝图标）。
+const TOOL_FG_IDLE = "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]";
+const TOOL_FG_ACTIVE = "bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]";
+
+type GestureMode = "move" | "trim-start" | "trim-end" | null;
+
+// 与时间线相关的场景：playheadMs 是标尺交互的临时坐标，随缩放同步换算。
+type TimelineTool = "select" | "razor";
+
+type GestureState = {
+    mode: Exclude<GestureMode, null>;
+    pointerId: number;
+    startClientX: number;
+    originStartMs: number;
+    originDurationMs: number;
+    originSourceStartMs: number;
+};
+
+
+export function EditorTimelinePanel() {
+    const { project, dispatch, previewGesture, commitGesture, cancelGesture, selectedClipId, selectClip, transportMs, setTransportMs } =
+        useEditorStoreContext();
+
+    const containerRef = useRef<HTMLDivElement>(null);
+    const [viewportWidth, setViewportWidth] = useState(0);
+    const [zoomLevel, setZoomLevel] = useState(1);
+    const [activeTool, setActiveTool] = useState<TimelineTool>("select");
+    // 播放头与监视器共享同一 transport（store）：拖动标尺即时驱动监视器 seek，播放时监视器回写推进。
+    const playheadMs = transportMs;
+    const [snapEnabled, setSnapEnabled] = useState(true);
+    const [addMenuOpen, setAddMenuOpen] = useState(false);
+    // 点击不可移除轨道 X 时的原因提示（2.2s 后自动消失）。
+    const [removeBlockedHint, setRemoveBlockedHint] = useState<{ id: number; text: string } | null>(null);
+
+    useEffect(() => {
+        const el = containerRef.current;
+        if (!el) return;
+        setViewportWidth(el.clientWidth);
+        const observer = new ResizeObserver((entries) => {
+            const width = entries[0]?.contentRect.width;
+            if (width) setViewportWidth(width);
+        });
+        observer.observe(el);
+        return () => observer.disconnect();
+    }, []);
+
+    useEffect(() => {
+        if (!removeBlockedHint) return;
+        const timer = window.setTimeout(() => setRemoveBlockedHint(null), 2200);
+        return () => window.clearTimeout(timer);
+    }, [removeBlockedHint]);
+
+    if (!project) return <div className="flex h-full items-center justify-center text-sm text-[var(--director-dock-fg)]">时间线未加载</div>;
+
+    const visualEndMs = Math.max(MIN_VISUAL_END_MS, getTimelineVisualEndMs(project.clips));
+    // 像素/毫秒由缩放级别独立决定（不随时长漂移）：拖动片段时轨道随内容等比扩展，
+    // 手势映射与渲染同源，末片段向右拖不再被旧实现（trackWidth 随时长阶梯跳变）钉住。
+    const pxPerMs = getTimelinePxPerMs(zoomLevel);
+    const trackWidth = Math.max(viewportWidth, Math.ceil(visualEndMs * pxPerMs));
+    // 内容宽度 = 逻辑轨道宽度 + 标签列；标签列 sticky 固定后，滚动到最右端时
+    // 末端片段仍完整可见（flex-1 片段区 = 内容宽度 - 标签列 ≥ 轨道宽度）。
+    const contentWidth = Math.max(viewportWidth, trackWidth + LABEL_COLUMN_PX);
+
+    const visualTracks = getVisualTracks(project.tracks);
+    const audioTracks = getAudioTracks(project.tracks);
+    const subtitleTracks = getSubtitleTracks(project.tracks);
+    const clipAtPlayhead =
+        project.clips.find(
+            (clip) =>
+                clip.kind !== "subtitle" &&
+                clip.startMs + MIN_SPLIT_MS <= playheadMs &&
+                playheadMs <= clip.startMs + clip.durationMs - MIN_SPLIT_MS,
+        ) ?? null;
+    const selectedClip = project.clips.find((clip) => clip.id === selectedClipId) ?? null;
+
+    const handleSplitAtPlayhead = () => {
+        if (!clipAtPlayhead) return;
+        dispatch({ op: "splitClip", payload: { id: clipAtPlayhead.id, splitAtMs: playheadMs } });
+    };
+    const handleDeleteSelected = () => {
+        if (!selectedClip) return;
+        dispatch({ op: "removeClip", payload: { id: selectedClip.id } });
+        selectClip(null);
+    };
+    const handleScrub = (ms: number) => {
+        setTransportMs(Math.max(0, Math.min(visualEndMs, Math.round(ms))));
+    };
+    const handleFitWidth = () => {
+        const availViewport = Math.max(320, viewportWidth - LABEL_COLUMN_PX);
+        setZoomLevel(getFitTimelineZoom(visualEndMs, availViewport));
+    };
+    const handleAddTrack = (kind: TimelineTrackKind) => {
+        setAddMenuOpen(false);
+        dispatch({ op: "addTrack", payload: { kind } });
+    };
+    const handleRemoveTrack = (trackId: string) => {
+        dispatch({ op: "removeTrack", payload: { trackId } });
+        // 选中片段若落在被删轨道上，需同步清空，否则留下悬挂选中态。
+        if (selectedClipId) {
+            const clip = project.clips.find((c) => c.id === selectedClipId);
+            if (clip && clip.trackId === trackId) selectClip(null);
+        }
+    };
+    const handleToggleTrackFlag = (trackId: string, flag: "visible" | "muted", value: boolean) => {
+        dispatch({ op: "setTrackFlag", payload: { trackId, flag, value } });
+    };
+
+    const handleRemoveTrackBlocked = (kind: TimelineTrack["kind"]) => {
+        setRemoveBlockedHint({ id: Date.now(), text: trackRemoveBlockedReason(kind) });
+    };
+
+    return (
+        <div className="relative flex h-full min-h-0 flex-col bg-[var(--director-sequencer-surface)]">
+            {/* 工具条：左侧编辑工具，右侧缩放/时码（撤销/重做在宿主顶栏） */}
+            <div className="flex h-10 shrink-0 items-center gap-2 border-b border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-3">
+                {/* 工具模式：选择 / 剃刀 */}
+                <div className="flex items-center gap-0.5 rounded-md bg-[var(--director-control-hover)] p-0.5">
+                    <button
+                        type="button"
+                        aria-label="选择工具"
+                        aria-pressed={activeTool === "select"}
+                        title="选择工具"
+                        onClick={() => setActiveTool("select")}
+                        className={`grid size-6 place-items-center rounded-[6px] transition-colors ${
+                            activeTool === "select" ? TOOL_FG_ACTIVE : TOOL_FG_IDLE
+                        }`}
+                    >
+                        <MousePointer2 className="size-4" />
+                    </button>
+                    <button
+                        type="button"
+                        aria-label="剃刀工具"
+                        aria-pressed={activeTool === "razor"}
+                        title="剃刀工具：点击片段在光标处分割"
+                        onClick={() => setActiveTool((tool) => (tool === "razor" ? "select" : "razor"))}
+                        className={`grid size-6 place-items-center rounded-[6px] transition-colors ${
+                            activeTool === "razor" ? TOOL_FG_ACTIVE : TOOL_FG_IDLE
+                        }`}
+                    >
+                        <Slice className="size-4" />
+                    </button>
+                </div>
+                <div className="mx-1 h-5 w-px bg-[var(--director-sequencer-border)]" />
+                {/* 在播放头分割当前片段 */}
+                <button
+                    type="button"
+                    aria-label="在播放头分割"
+                    disabled={!clipAtPlayhead}
+                    title="在播放头分割片段"
+                    onClick={handleSplitAtPlayhead}
+                    className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE} disabled:cursor-not-allowed disabled:opacity-40`}
+                >
+                    <Scissors className="size-4" />
+                </button>
+                {/* 删除选中片段 */}
+                <button
+                    type="button"
+                    aria-label="删除选中片段"
+                    disabled={!selectedClip}
+                    title="删除选中片段"
+                    onClick={handleDeleteSelected}
+                    className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE} disabled:cursor-not-allowed disabled:opacity-40`}
+                >
+                    <Trash2 className="size-4" />
+                </button>
+                <div className="mx-1 h-5 w-px bg-[var(--director-sequencer-border)]" />
+                {/* 吸附开关 */}
+                <button
+                    type="button"
+                    aria-label="吸附"
+                    aria-pressed={snapEnabled}
+                    title="吸附（拖动与时间刻度对齐）"
+                    onClick={() => setSnapEnabled((v) => !v)}
+                    className={`grid size-7 place-items-center rounded-md transition-colors ${
+                        snapEnabled ? TOOL_FG_ACTIVE : TOOL_FG_IDLE
+                    }`}
+                >
+                    <Magnet className="size-4" />
+                </button>
+                {/* 新增轨道 */}
+                <div className="relative">
+                    <button
+                        type="button"
+                        aria-label="新增轨道"
+                        aria-expanded={addMenuOpen}
+                        title="新增轨道"
+                        onClick={() => setAddMenuOpen((v) => !v)}
+                        className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE}`}
+                    >
+                        <Plus className="size-4" />
+                    </button>
+                    {addMenuOpen && (
+                        <>
+                            <div className="fixed inset-0 z-40" onClick={() => setAddMenuOpen(false)} />
+                            <div className="absolute left-0 top-8 z-50 min-w-32 overflow-hidden rounded-lg border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] py-1 shadow-xl">
+                                <button
+                                    type="button"
+                                    onClick={() => handleAddTrack("video")}
+                                    className={`flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs ${TOOL_FG_IDLE}`}
+                                >
+                                    <Film className="size-3.5" />
+                                    视频轨道
+                                </button>
+                                <button
+                                    type="button"
+                                    onClick={() => handleAddTrack("audio")}
+                                    className={`flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs ${TOOL_FG_IDLE}`}
+                                >
+                                    <Music2 className="size-3.5" />
+                                    音频轨道
+                                </button>
+                                <button
+                                    type="button"
+                                    onClick={() => handleAddTrack("subtitle")}
+                                    className={`flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs ${TOOL_FG_IDLE}`}
+                                >
+                                    <Subtitles className="size-3.5" />
+                                    字幕轨道
+                                </button>
+                            </div>
+                        </>
+                    )}
+                </div>
+                <div className="flex-1" />
+                {/* 播放头时码 */}
+                <span className="w-16 text-right text-xs tabular-nums text-[var(--director-dock-fg)]">{formatTimelineTime(playheadMs)}</span>
+                <span className="text-xs tabular-nums text-[var(--director-dock-fg)]">片段 {project.clips.length}</span>
+                <div className="mx-1 h-5 w-px bg-[var(--director-sequencer-border)]" />
+                {/* 适应宽度 */}
+                <button
+                    type="button"
+                    aria-label="适应宽度"
+                    title="适应宽度"
+                    onClick={handleFitWidth}
+                    className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE}`}
+                >
+                    <Maximize className="size-4" />
+                </button>
+                <button
+                    type="button"
+                    aria-label="缩小时间线"
+                    title="缩小时间线"
+                    onClick={() => setZoomLevel((z) => zoomOut(z))}
+                    className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE}`}
+                >
+                    <ZoomOut className="size-4" />
+                </button>
+                <span className="w-10 text-center text-xs tabular-nums text-[var(--director-dock-fg)]">{Math.round(zoomLevel * 100)}%</span>
+                <button
+                    type="button"
+                    aria-label="放大时间线"
+                    title="放大时间线"
+                    onClick={() => setZoomLevel((z) => zoomIn(z))}
+                    className={`grid size-7 place-items-center rounded-md ${TOOL_FG_IDLE}`}
+                >
+                    <ZoomIn className="size-4" />
+                </button>
+            </div>
+
+            {/* 时间线主体 */}
+            <div ref={containerRef} className="director-scroll min-h-0 flex-1 overflow-auto bg-[var(--director-sequencer-surface)]" data-canvas-no-zoom>
+                {project.clips.length === 0 ? (
+                    <div className="flex h-full flex-col items-center justify-center gap-2 text-[var(--director-dock-fg)]">
+                        <Scissors className="size-8" />
+                        <p className="text-sm">时间线暂无片段，从素材库拖入或后续接入画布节点</p>
+                    </div>
+                ) : (
+                    <div className="relative min-w-full" style={{ width: contentWidth }}>
+                        <TimelineRuler
+                            pxPerMs={pxPerMs}
+                            endMs={visualEndMs}
+                            playheadMs={playheadMs}
+                            snapEnabled={snapEnabled}
+                            onScrub={handleScrub}
+                        />
+                        {[
+                            { label: "视觉轨道", tracks: visualTracks },
+                            { label: "音频轨道", tracks: audioTracks },
+                            { label: "字幕轨道", tracks: subtitleTracks },
+                        ]
+                            .filter((group) => group.tracks.length > 0)
+                            .map((group) => (
+                                <div key={group.label}>
+                                    {group.tracks.map((track) => (
+                                        <TrackRow
+                                            key={track.id}
+                                            track={track}
+                                            project={project}
+                                            pxPerMs={pxPerMs}
+                                            onGesture={previewGesture}
+                                            onCommit={commitGesture}
+                                            onCancel={cancelGesture}
+                                            selectedClipId={selectedClipId}
+                                            razorActive={activeTool === "razor"}
+                                            snapEnabled={snapEnabled}
+                                            playheadMs={playheadMs}
+                                            onSelectClip={selectClip}
+
+                                            removable={project.tracks.filter((t) => t.kind === track.kind).length > 1}
+                                             onRemoveTrack={handleRemoveTrack}
+                                             onRemoveBlocked={handleRemoveTrackBlocked}
+                                            onToggleTrackFlag={handleToggleTrackFlag}
+                                            onSplitClip={(clipId, splitAtMs) =>
+                                                dispatch({ op: "splitClip", payload: { id: clipId, splitAtMs } })
+                                            }
+                                        />
+                                    ))}
+                                </div>
+                            ))}
+
+                        {/* 播放头：贯穿标尺与全部轨道，与标尺拖动同源（视觉/音频/字幕均覆盖） */}
+                        <div
+                            aria-hidden
+                            className="pointer-events-none absolute inset-y-0 z-[14] w-px bg-[var(--director-danger)]"
+                            style={{ left: LABEL_COLUMN_PX + playheadMs * pxPerMs }}
+                        >
+                            <div className="absolute -left-[5px] top-0 size-2.5 rotate-45 rounded-[2px] bg-[var(--director-danger)]" />
+                        </div>
+                    </div>
+                )}
+
+            {/* 点击不可移除轨道 X 时的原因提示（短暂居中浮现，不拦截交互） */}
+            {removeBlockedHint && (
+                <div
+                    key={removeBlockedHint.id}
+                    role="status"
+                    aria-live="polite"
+                    className="pointer-events-none absolute left-1/2 top-12 z-50 -translate-x-1/2 whitespace-nowrap rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-3 py-1.5 text-xs text-[var(--director-dock-fg-strong)] shadow-lg"
+                >
+                    {removeBlockedHint.text}
+                </div>
+            )}
+            </div>
+        </div>
+    );
+}
+
+function TimelineRuler({
+    pxPerMs,
+    endMs,
+    playheadMs,
+    snapEnabled,
+    onScrub,
+}: {
+    pxPerMs: number;
+    endMs: number;
+    playheadMs: number;
+    snapEnabled: boolean;
+    onScrub: (ms: number) => void;
+}) {
+    const step = getRulerTickStep(pxPerMs);
+    const ticks: number[] = [];
+    for (let t = 0; t <= endMs; t += step) ticks.push(t);
+    const areaRef = useRef<HTMLDivElement | null>(null);
+    const dragPointerRef = useRef<number | null>(null);
+    const moveTo = (clientX: number) => {
+        const rect = areaRef.current!.getBoundingClientRect();
+        let ms = (clientX - rect.left) / pxPerMs;
+        if (snapEnabled) ms = Math.round(ms / SNAP_MS) * SNAP_MS;
+        onScrub(ms);
+    };
+    return (
+        <div className="sticky top-0 z-10 flex h-6 shrink-0 w-full items-end border-b border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)]">
+            {/* 左列占位与 TrackRow 轨道标签列（w-48）同宽，sticky 跟随横向滚动，保证 0ms 刻度与片段区起点对齐 */}
+            <div className="sticky left-0 z-10 w-48 shrink-0 self-stretch border-r border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)]">
+                {/* 当前播放头时码，跟随拖动实时刷新 */}
+                <span className="absolute bottom-1 right-2 text-[10px] tabular-nums text-[var(--director-danger)]">{formatTimelineTime(playheadMs)}</span>
+            </div>
+            <div
+                ref={areaRef}
+                role="slider"
+                aria-label="播放头"
+                aria-valuemin={0}
+                aria-valuemax={Math.round(endMs)}
+                aria-valuenow={Math.round(playheadMs)}
+                aria-orientation="horizontal"
+                className="relative h-full flex-1 cursor-col-resize select-none touch-none"
+                onPointerDown={(e) => {
+                    if (e.button !== 0) return;
+                    dragPointerRef.current = e.pointerId;
+                    e.currentTarget.setPointerCapture(e.pointerId);
+                    moveTo(e.clientX);
+                }}
+                onPointerMove={(e) => {
+                    if (dragPointerRef.current === e.pointerId) moveTo(e.clientX);
+                }}
+                onPointerUp={() => {
+                    dragPointerRef.current = null;
+                }}
+                onPointerCancel={() => {
+                    dragPointerRef.current = null;
+                }}
+            >
+                {ticks.map((t) => (
+                    <div key={t} className="absolute bottom-0" style={{ left: t * pxPerMs - 1 }}>
+                        <div className="h-2 w-px bg-[var(--director-sequencer-muted)]" />
+                        <span className="absolute bottom-2.5 left-1 whitespace-nowrap text-[10px] tabular-nums text-[var(--director-dock-fg)]">{formatTimelineTime(t)}</span>
+                    </div>
+                ))}
+            </div>
+        </div>
+    );
+}
+
+function TrackRow({
+    track,
+    project,
+    pxPerMs,
+    onGesture,
+    onCommit,
+    onCancel,
+    selectedClipId,
+    onSelectClip,
+    razorActive,
+    snapEnabled,
+    playheadMs,
+    onSplitClip,
+    removable,
+    onRemoveTrack,
+    onRemoveBlocked,
+    onToggleTrackFlag,
+}: {
+    track: TimelineTrack;
+    project: TimelineProject;
+    pxPerMs: number;
+    onGesture: (cmd: { op: string; payload: unknown }) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    selectedClipId: string | null;
+    onSelectClip: (id: string | null) => void;
+    razorActive: boolean;
+    snapEnabled: boolean;
+    playheadMs: number;
+    onSplitClip: (clipId: string, splitAtMs: number) => void;
+    removable: boolean;
+    onRemoveTrack: (trackId: string) => void;
+    onRemoveBlocked: (kind: TimelineTrack["kind"]) => void;
+    onToggleTrackFlag: (trackId: string, flag: "visible" | "muted", value: boolean) => void;
+}) {
+    const clips = project.clips.filter((c) => c.trackId === track.id);
+    return (
+        <div className="group flex h-16 border-b border-[var(--director-sequencer-border)]">
+            <div className="sticky left-0 z-10 flex w-48 shrink-0 items-center gap-1 border-r border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-2">
+                <TrackBadge kind={track.kind} />
+                <div className="min-w-0 flex-1">
+                    <div
+                        className={`truncate text-xs font-medium ${
+                            track.visible === false
+                                ? "text-[var(--director-dock-fg)]"
+                                : "text-[var(--director-dock-fg-strong)]"
+                        }`}
+                    >
+                        {track.label}
+                    </div>
+                    <div className="text-[10px] text-[var(--director-dock-fg)]">{clips.length} 个片段</div>
+                </div>
+                <button
+                    type="button"
+                    aria-label={track.visible === false ? "显示轨道" : "隐藏轨道"}
+                    title={track.visible === false ? "显示轨道" : "隐藏轨道"}
+                    aria-pressed={track.visible === false}
+                    onClick={() => onToggleTrackFlag(track.id, "visible", track.visible === false)}
+                    className={`grid size-6 shrink-0 place-items-center rounded-md transition-colors ${
+                        track.visible === false
+                            ? "bg-[var(--director-control-hover)] text-[var(--director-dock-fg-strong)]"
+                            : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                    }`}
+                >
+                    {track.visible === false ? <EyeOff className="size-3.5" /> : <Eye className="size-3.5" />}
+                </button>
+                <button
+                    type="button"
+                    aria-label={track.muted ? "取消静音" : "静音轨道"}
+                    title={track.muted ? "取消静音" : "静音轨道"}
+                    aria-pressed={track.muted === true}
+                    onClick={() => onToggleTrackFlag(track.id, "muted", !track.muted)}
+                    className={`grid size-6 shrink-0 place-items-center rounded-md transition-colors ${
+                        track.muted === true
+                            ? "bg-[var(--director-control-hover)] text-[var(--director-dock-fg-strong)]"
+                            : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                    }`}
+                >
+                    {track.muted ? <VolumeX className="size-3.5" /> : <Volume2 className="size-3.5" />}
+                </button>
+                <button
+                    type="button"
+                    aria-label={`移除轨道 ${track.label}`}
+                    title={removable ? "移除轨道" : trackRemoveBlockedReason(track.kind)}
+                    onClick={() => (removable ? onRemoveTrack(track.id) : onRemoveBlocked(track.kind))}
+                    className={`grid size-6 shrink-0 place-items-center rounded-md transition-opacity ${
+                        removable
+                            ? "text-[var(--director-dock-fg)] opacity-0 hover:bg-[var(--director-control-hover)] hover:text-[var(--director-danger)] focus-visible:opacity-100 group-hover:opacity-100"
+                            : "cursor-not-allowed text-[var(--director-dock-fg)] opacity-40 hover:bg-[var(--director-control-hover)] hover:opacity-100 focus-visible:opacity-100"
+                    }`}
+                >
+                    <X className="size-3.5" />
+                </button>
+            </div>
+            <div
+                className={`relative flex-1 overflow-hidden bg-[var(--director-sequencer-grid)] transition-opacity ${
+                    razorActive ? "cursor-crosshair" : ""
+                } ${track.visible === false ? "opacity-40" : ""}`}
+                onPointerDown={(e) => {
+                    if (razorActive) return;
+                    if (e.target === e.currentTarget) onSelectClip(null);
+                }}
+            >
+                {clips.map((clip) => (
+                    <ClipItem
+                        key={clip.id}
+                        clip={clip}
+                        pxPerMs={pxPerMs}
+                        onGesture={onGesture}
+                        onCommit={onCommit}
+                        onCancel={onCancel}
+                        selected={selectedClipId === clip.id}
+                        onSelectClip={onSelectClip}
+                        razorActive={razorActive}
+                        snapEnabled={snapEnabled}
+                        playheadMs={playheadMs}
+                        clips={project.clips}
+                        onSplitClip={onSplitClip}
+                    />
+                ))}
+            </div>
+        </div>
+    );
+}
+
+function TrackBadge({ kind }: { kind: TimelineTrack["kind"] }) {
+    const cls =
+        kind === "video" || kind === "image"
+            ? "text-[var(--director-dock-fg)]"
+            : kind === "audio"
+              ? "text-[var(--director-success)]"
+              : "text-[var(--director-warning)]";
+    return (
+        <div className={`grid size-6 shrink-0 place-items-center rounded-md bg-[var(--director-dock-active-surface)] ${cls}`} title={kind}>
+            {kind === "subtitle" ? <Subtitles className="size-3.5" /> : kind === "audio" ? <Music2 className="size-3.5" /> : <Film className="size-3.5" />}
+        </div>
+    );
+}
+
+function ClipItem({
+    clip,
+    pxPerMs,
+    onGesture,
+    onCommit,
+    onCancel,
+    selected,
+    onSelectClip,
+    razorActive,
+    snapEnabled,
+    playheadMs,
+    clips,
+    onSplitClip,
+}: {
+    clip: TimelineClip;
+    pxPerMs: number;
+    onGesture: (cmd: { op: string; payload: unknown }) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    selected: boolean;
+    onSelectClip: (id: string | null) => void;
+    razorActive: boolean;
+    snapEnabled: boolean;
+    playheadMs: number;
+    clips: TimelineClip[];
+    onSplitClip: (clipId: string, splitAtMs: number) => void;
+}) {
+    const gestureRef = useRef<GestureState | null>(null);
+
+    const beginGesture = (e: React.PointerEvent, mode: Exclude<GestureMode, null>) => {
+        if (gestureRef.current) return;
+        onSelectClip(clip.id);
+        e.stopPropagation();
+        e.currentTarget.setPointerCapture(e.pointerId);
+        gestureRef.current = {
+            mode,
+            pointerId: e.pointerId,
+            startClientX: e.clientX,
+            originStartMs: clip.startMs,
+            originDurationMs: clip.durationMs,
+            originSourceStartMs: clip.sourceStartMs ?? 0,
+        };
+    };
+
+    const onPointerMove = (e: React.PointerEvent) => {
+        const g = gestureRef.current;
+        if (!g || e.pointerId !== g.pointerId) return;
+        const deltaMs = (e.clientX - g.startClientX) / pxPerMs;
+
+        if (g.mode === "move") {
+            const candidateMs = Math.max(0, g.originStartMs + deltaMs);
+            // 移动吸附：候选左边缘吸附到其他片段边缘/播放头；右边缘吸附则通过“目标边缘-自身时长”换算回起始点，取偏移更小者
+            const leftSnap = computeSnap({
+                candidateMs,
+                playheadMs,
+                clips,
+                excludeClipId: clip.id,
+                pxPerMs,
+                thresholdPx: 8,
+                enabled: snapEnabled,
+            });
+            const rightSnap = computeSnap({
+                candidateMs: candidateMs + clip.durationMs,
+                playheadMs,
+                clips,
+                excludeClipId: clip.id,
+                pxPerMs,
+                thresholdPx: 8,
+                enabled: snapEnabled,
+            });
+            // computeSnap 未命中时返回 { snappedMs: candidateMs, targets: [] }：
+            // 只有 targets 非空才算“命中”。若某侧未命中而其距离为 0（候选值不变），
+            // 直接与另一侧命中距离比较会把真正命中的一侧丢弃（0 永远最小）。
+            const leftHit = leftSnap.targets.length > 0;
+            const rightHit = rightSnap.targets.length > 0;
+            let snappedMs = candidateMs;
+            if (leftHit && rightHit) {
+                const rightAltStartMs = rightSnap.snappedMs - clip.durationMs;
+                snappedMs =
+                    Math.abs(rightAltStartMs - candidateMs) < Math.abs(leftSnap.snappedMs - candidateMs)
+                        ? Math.max(0, rightAltStartMs)
+                        : leftSnap.snappedMs;
+            } else if (leftHit) {
+                snappedMs = leftSnap.snappedMs;
+            } else if (rightHit) {
+                snappedMs = Math.max(0, rightSnap.snappedMs - clip.durationMs);
+            }
+            onGesture({ op: "moveClip", payload: { id: clip.id, startMs: snappedMs } });
+        } else if (g.mode === "trim-end") {
+            const sourceDuration = clip.sourceDurationMs ?? 0;
+            const newRightEdge = g.originStartMs + g.originDurationMs + deltaMs;
+            const { snappedMs } = computeSnap({
+                candidateMs: newRightEdge,
+                playheadMs,
+                clips,
+                excludeClipId: clip.id,
+                pxPerMs,
+                thresholdPx: 8,
+                enabled: snapEnabled,
+            });
+            let newDurationMs = Math.max(SNAP_MS, snappedMs - g.originStartMs);
+            if (sourceDuration > 0) newDurationMs = Math.min(newDurationMs, sourceDuration - g.originSourceStartMs);
+            onGesture({ op: "trimClip", payload: { id: clip.id, durationMs: newDurationMs } });
+        } else {
+            // trim-start：右端保持不动，起始点前移，源起点同步前移
+            const sourceDuration = clip.sourceDurationMs ?? 0;
+            const rightEdge = g.originStartMs + g.originDurationMs;
+            const candidateMs = Math.max(0, Math.min(g.originStartMs + deltaMs, rightEdge - SNAP_MS));
+            const { snappedMs } = computeSnap({
+                candidateMs,
+                playheadMs,
+                clips,
+                excludeClipId: clip.id,
+                pxPerMs,
+                thresholdPx: 8,
+                enabled: snapEnabled,
+            });
+            const newStartMs = Math.max(0, Math.min(snappedMs, rightEdge - SNAP_MS));
+            let newSourceStartMs = g.originSourceStartMs + (newStartMs - g.originStartMs);
+            if (sourceDuration > 0) newSourceStartMs = Math.min(newSourceStartMs, sourceDuration - SNAP_MS);
+            onGesture({
+                op: "trimClip",
+                payload: { id: clip.id, startMs: newStartMs, durationMs: rightEdge - newStartMs, sourceStartMs: Math.max(0, newSourceStartMs) },
+            });
+        }
+    };
+
+    const endGesture = (e: React.PointerEvent) => {
+        const g = gestureRef.current;
+        if (!g || e.pointerId !== g.pointerId) return;
+        gestureRef.current = null;
+        try {
+            e.currentTarget.releasePointerCapture(e.pointerId);
+        } catch {
+            // pointer capture 可能已被隐式释放
+        }
+        onCommit();
+    };
+
+    const isSubtitle = clip.kind === "subtitle";
+    const isAudio = clip.kind === "audio";
+    const left = clip.startMs * pxPerMs;
+    const width = clip.durationMs * pxPerMs;
+    const label = clip.text || clip.nodeId || clip.id;
+    const playheadInside = playheadMs >= clip.startMs && playheadMs <= clip.startMs + clip.durationMs;
+
+    const razorSplitAt = (e: React.PointerEvent) => {
+        const rect = e.currentTarget.getBoundingClientRect();
+        const atMs = clip.startMs + (e.clientX - rect.left) / pxPerMs;
+        const splitMs = Math.round(atMs);
+        if (splitMs - clip.startMs < MIN_SPLIT_MS || clip.startMs + clip.durationMs - splitMs < MIN_SPLIT_MS) return;
+        onSplitClip(clip.id, splitMs);
+    };
+
+    return (
+        <div
+            className={`group absolute top-1.5 bottom-1.5 select-none rounded-md border text-xs shadow-sm ${
+                selected
+                    ? "border-[var(--director-accent)] ring-1 ring-[var(--director-accent)]/60 bg-[var(--director-accent)]/25 text-[var(--director-dock-fg-strong)]"
+                    : isSubtitle
+                      ? "border-[var(--director-warning)]/40 bg-[var(--director-warning)]/15 text-[var(--director-warning)]"
+                      : isAudio
+                        ? "border-[var(--director-success)]/40 bg-[var(--director-success)]/15 text-[var(--director-success)]"
+                        : "border-[var(--director-sequencer-border)] bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]"
+            }`}
+            style={{ left, width, touchAction: "none" }}
+            title={`${label} · ${formatTimelineTime(clip.startMs)} +${formatTimelineTime(clip.durationMs)}`}
+            onPointerDown={(e) => {
+                // 剃刀模式（字幕除外）：单击即在光标处分割；否则开始移动手势
+                if (razorActive && !isSubtitle) {
+                    razorSplitAt(e);
+                    return;
+                }
+                beginGesture(e, "move");
+            }}
+            onPointerMove={onPointerMove}
+            onPointerUp={endGesture}
+            onPointerCancel={endGesture}
+        >
+            <div
+                className="absolute inset-y-0 left-0 cursor-ew-resize rounded-l-md"
+                style={{ width: TRIM_HANDLE_PX }}
+                onPointerDown={(e) => {
+                    e.stopPropagation();
+                    beginGesture(e, "trim-start");
+                }}
+            />
+            <div className="pointer-events-none flex h-full items-center gap-1 px-2">
+                <span className="truncate">{label}</span>
+            </div>
+            {/* 播放头经过片段时的对齐标线（razor/对齐视觉辅助） */}
+            {playheadInside && (
+                <div
+                    aria-hidden
+                    className="pointer-events-none absolute inset-y-0 w-px bg-[var(--director-danger)]/60"
+                    style={{ left: (playheadMs - clip.startMs) * pxPerMs }}
+                />
+            )}
+            <div
+                className="absolute inset-y-0 right-0 cursor-ew-resize rounded-r-md"
+                style={{ width: TRIM_HANDLE_PX }}
+                onPointerDown={(e) => {
+                    e.stopPropagation();
+                    beginGesture(e, "trim-end");
+                }}
+            />
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/editor-transcription.tsx b/web/src/lib/plugins/builtin/editor/editor-transcription.tsx
new file mode 100644
index 000000000..c9bd7fac0
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/editor-transcription.tsx
@@ -0,0 +1,165 @@
+// 字幕转写（editor-shell 预设插件贡献 transcription-provider 插槽，M3.6）。
+// M4 后端转写任务（whisper.cpp 本地执行）：创建 POST /timeline/transcriptions
+// → waitForGenerationTask 轮询进度 → 结果 segments 按 ADR-0004 协议以
+// SrtEntry[] 落字幕轨道（rebuildSubtitleClips 重建快照），UI 契约与 M3.6 mock 一致。
+
+import { useEffect, useMemo, useState } from "react";
+import { AudioLines, Loader2 } from "lucide-react";
+
+import { useEditorHostContext, useEditorStoreContext } from "@/components/editor/editor-context";
+import { getSubtitleTracks } from "@/lib/timeline/timeline-tracks";
+import { waitForGenerationTask } from "@/services/api/task-center";
+import {
+    createTimelineTranscriptionTask,
+    type TimelineTranscriptionResult,
+    type TimelineTranscriptionSegment,
+} from "@/services/api/timeline-tasks";
+import type { ProjectAsset } from "@/services/api/projects";
+import type { SrtEntry } from "@/types/timeline";
+
+const WHISPER_WAIT_TIMEOUT_MS = 25 * 60 * 1000;
+
+// 上传素材的底层对象以 resource:<id> 形式存储在资源表，取其中的资源 ID 提交转写。
+function resourceIdOfAsset(asset: ProjectAsset): string | null {
+    const key = asset.storageKey ?? "";
+    if (key.startsWith("resource:")) return key.slice("resource:".length);
+    return null;
+}
+
+export function EditorTranscription() {
+    const { assets } = useEditorHostContext();
+    const { project, dispatch } = useEditorStoreContext();
+    // 音频与视频素材均可转写（视频静音会由后端明确报错）。
+    const transcribableAssets = useMemo(
+        () => assets.filter((a) => a.mediaType === "audio" || a.mediaType === "video"),
+        [assets],
+    );
+    const [selectedId, setSelectedId] = useState<string | null>(null);
+    const [running, setRunning] = useState(false);
+    const [progressLabel, setProgressLabel] = useState<string | null>(null);
+    const [message, setMessage] = useState<string | null>(null);
+    const [failed, setFailed] = useState(false);
+
+    useEffect(() => {
+        if (selectedId === null && transcribableAssets.length > 0) {
+            const firstAudio = transcribableAssets.find((a) => a.mediaType === "audio");
+            setSelectedId((firstAudio ?? transcribableAssets[0]).id);
+        }
+    }, [transcribableAssets, selectedId]);
+
+    if (!project) return null;
+    const subtitleTrack = getSubtitleTracks(project.tracks)[0];
+    const selected = transcribableAssets.find((a) => a.id === selectedId) ?? null;
+
+    const toSrtEntries = (segments: TimelineTranscriptionSegment[]): SrtEntry[] =>
+        segments
+            .map((seg, i) => ({
+                index: i + 1,
+                startMs: seg.startMs,
+                endMs: seg.endMs,
+                text: seg.text,
+            }))
+            .filter((entry) => entry.text.trim() !== "" && entry.endMs > entry.startMs);
+
+    const transcribe = async () => {
+        if (!selected || running) return;
+        const resourceId = resourceIdOfAsset(selected);
+        if (!resourceId) {
+            setFailed(true);
+            setMessage("该素材没有可转写的媒体对象（缺少 storageKey）");
+            return;
+        }
+        setRunning(true);
+        setFailed(false);
+        setMessage(null);
+        setProgressLabel("排队中…");
+        try {
+            const created = await createTimelineTranscriptionTask({
+                resourceId,
+            });
+            const done = await waitForGenerationTask(created.id, {
+                timeoutMs: WHISPER_WAIT_TIMEOUT_MS,
+                intervalMs: 2000,
+                onTaskUpdate: (task) => {
+                    const stage = task.stage;
+                    const progress = task.progress ?? 0;
+                    if (stage) setProgressLabel(`${stage}${progress > 0 && progress < 100 ? ` ${progress}%` : ""}`);
+                },
+            });
+            const parsed = JSON.parse(done.resultJson ?? "{}") as TimelineTranscriptionResult;
+            const entries = toSrtEntries(parsed.segments ?? []);
+            if (entries.length === 0) {
+                setMessage("转写完成，但没有识别出可用字幕（语音内容为空？）");
+            } else if (!subtitleTrack) {
+                setMessage("项目没有字幕轨道，无法写入转写字幕");
+            } else {
+                dispatch({
+                    op: "rebuildSubtitleClips",
+                    payload: { nodeId: `transcription:${selected.id}`, entries, trackId: subtitleTrack.id },
+                });
+                const langHint = parsed.language ? `（${parsed.language}）` : "";
+                setMessage(`已写入 ${entries.length} 条转写字幕${langHint}`);
+            }
+            setProgressLabel(null);
+        } catch (err) {
+            setFailed(true);
+            setMessage(err instanceof Error ? err.message : "转写失败，请稍后重试");
+            setProgressLabel(null);
+        } finally {
+            setRunning(false);
+        }
+    };
+
+    return (
+        <div className="flex h-full flex-col bg-[var(--director-sequencer-surface)]">
+            <div className="director-scroll min-h-0 flex-1 overflow-y-auto p-3">
+                {transcribableAssets.length === 0 ? (
+                    <div className="flex h-full flex-col items-center justify-center gap-2 p-4 text-center">
+                        <AudioLines className="size-5 text-[var(--director-dock-fg)]/40" />
+                        <p className="text-xs text-[var(--director-dock-fg)]/60">项目暂无音视频素材</p>
+                        <p className="max-w-[200px] text-[11px] leading-relaxed text-[var(--director-dock-fg)]/45">素材库加入音频或视频后可转写自动字幕</p>
+                    </div>
+                ) : (
+                    <>
+                        <label className="mb-2 block">
+                            <span className="mb-1 block text-[11px] text-[var(--director-dock-fg)]/70">音视频素材</span>
+                            <select
+                                value={selectedId ?? ""}
+                                onChange={(e) => setSelectedId(e.target.value)}
+                                className="w-full rounded-md border border-[var(--director-sequencer-border)] bg-[var(--director-control-hover)] px-2 py-1.5 text-xs text-[var(--director-dock-fg-strong)] outline-none focus:border-[var(--workspace-accent)]/60 [&>option]:bg-[var(--director-sequencer-surface-raised)] [&>option]:text-[var(--director-dock-fg-strong)]"
+                            >
+                                {transcribableAssets.map((a) => (
+                                    <option key={a.id} value={a.id}>
+                                        {a.title || a.storageKey}
+                                    </option>
+                                ))}
+                            </select>
+                        </label>
+
+                        <button
+                            type="button"
+                            onClick={transcribe}
+                            disabled={!selected || running}
+                            className="flex w-full items-center justify-center gap-2 rounded-md bg-[var(--director-accent)] px-2 py-1.5 text-xs font-medium text-[var(--director-on-accent)] hover:bg-[var(--director-accent-hover)] disabled:opacity-40"
+                        >
+                            {running && <Loader2 className="size-3.5 animate-spin" />}
+                            {running ? "转写中…" : "转写自动字幕"}
+                        </button>
+
+                        {running && progressLabel && (
+                            <p className="mt-2 text-[11px] text-[var(--director-dock-fg)]/60">{progressLabel}</p>
+                        )}
+                        {message && (
+                            <p className={`mt-2 text-[11px] ${failed ? "text-[var(--director-danger)]" : "text-[var(--director-dock-fg)]/70"}`}>
+                                {message}
+                            </p>
+                        )}
+                        <p className="mt-2 text-[11px] leading-relaxed text-[var(--director-dock-fg)]/45">
+                            由本地 whisper.cpp 识别，音视频不出本机；识别结果写入字幕轨道，可再编辑。
+                        </p>
+                    </>
+                )}
+            </div>
+        </div>
+    );
+}
diff --git a/web/src/lib/plugins/builtin/editor/index.ts b/web/src/lib/plugins/builtin/editor/index.ts
new file mode 100644
index 000000000..8fd6ac59c
--- /dev/null
+++ b/web/src/lib/plugins/builtin/editor/index.ts
@@ -0,0 +1,5 @@
+// 编辑器预设插件集合入口（M3.8）。
+// editor-shell 单个预设插件贡献全部 8 种 editorSlots；此处聚合导出，
+// builtin/index.ts 的静态注册经 editor-shell 模块副作用完成。
+
+export { editorShellPlugin } from "./editor-shell";
diff --git a/web/src/lib/plugins/builtin/index.ts b/web/src/lib/plugins/builtin/index.ts
index e764886dc..c19c74ff4 100644
--- a/web/src/lib/plugins/builtin/index.ts
+++ b/web/src/lib/plugins/builtin/index.ts
@@ -3,3 +3,4 @@ import "./prompt-optimizer";
 import "./workflows";
 import "./portrait-clearance";
 import "./ai-art-critique";
+import "./editor/editor-shell";
diff --git a/web/src/lib/plugins/editor-slot-registry.ts b/web/src/lib/plugins/editor-slot-registry.ts
new file mode 100644
index 000000000..09407b9bd
--- /dev/null
+++ b/web/src/lib/plugins/editor-slot-registry.ts
@@ -0,0 +1,93 @@
+import { useEffect, useReducer } from "react";
+
+import type { EditorSlotKind } from "./plugin-types";
+
+export type EditorSlotRenderer = (context: { pluginId: string }) => React.ReactNode;
+
+export type EditorSlotRegistration = {
+    id: number;
+    pluginId: string;
+    slot: EditorSlotKind;
+    priority: number;
+    order: number;
+    render: EditorSlotRenderer;
+};
+
+export type RegisterEditorSlotInput = {
+    pluginId: string;
+    slot: EditorSlotKind;
+    priority?: number;
+    render: EditorSlotRenderer;
+};
+
+let nextOrder = 0;
+let nextId = 0;
+const registrations: EditorSlotRegistration[] = [];
+const listeners = new Set<() => void>();
+
+function emitChange(): void {
+    for (const listener of listeners) listener();
+}
+
+/** 订阅插槽注册表变化（插件启停时 UI 刷新）。返回取消订阅函数。 */
+export function subscribeEditorSlots(listener: () => void): () => void {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+
+/** React hook：订阅插槽变化并返回当前插槽贡献。 */
+export function useEditorSlots(slot: EditorSlotKind): EditorSlotRegistration[] {
+    const [, force] = useReducer((x: number) => x + 1, 0);
+    useEffect(() => subscribeEditorSlots(force), []);
+    return getEditorSlots(slot);
+}
+
+/** 注册一个编辑器插槽贡献。同 pluginId + slot 重复注册会覆盖旧项（幂等，兼容 HMR 重载）。返回的卸载函数只卸载自己注册的实例。 */
+export function registerEditorSlot(input: RegisterEditorSlotInput): () => void {
+    unregisterEditorSlot(input.pluginId, input.slot);
+    const id = nextId++;
+    registrations.push({
+        id,
+        pluginId: input.pluginId,
+        slot: input.slot,
+        priority: input.priority ?? 0,
+        order: nextOrder++,
+        render: input.render,
+    });
+    return () => {
+        unregisterById(id);
+        emitChange();
+    };
+}
+
+function unregisterById(id: number): void {
+    const index = registrations.findIndex((r) => r.id === id);
+    if (index >= 0) registrations.splice(index, 1);
+}
+
+export function unregisterEditorSlot(pluginId: string, slot: EditorSlotKind): void {
+    const index = registrations.findIndex((r) => r.pluginId === pluginId && r.slot === slot);
+    if (index >= 0) {
+        registrations.splice(index, 1);
+        emitChange();
+    }
+}
+
+/** 卸载某插件的全部编辑器插槽贡献（插件卸载时调用）。 */
+export function unregisterPluginSlots(pluginId: string): void {
+    let changed = false;
+    for (let i = registrations.length - 1; i >= 0; i--) {
+        if (registrations[i].pluginId === pluginId) {
+            registrations.splice(i, 1);
+            changed = true;
+        }
+    }
+    if (changed) emitChange();
+}
+
+/** 取某插槽的全部贡献，按 priority 降序、注册序升序稳定排列。 */
+export function getEditorSlots(slot: EditorSlotKind): EditorSlotRegistration[] {
+    return registrations
+        .filter((r) => r.slot === slot)
+        .sort((a, b) => b.priority - a.priority || a.order - b.order);
+}
diff --git a/web/src/lib/plugins/plugin-permission-check.ts b/web/src/lib/plugins/plugin-permission-check.ts
new file mode 100644
index 000000000..fba9501f7
--- /dev/null
+++ b/web/src/lib/plugins/plugin-permission-check.ts
@@ -0,0 +1,63 @@
+// 编辑器插件执行期权限校验（M5，fail-closed）。
+// v2 插件贡献 editorSlots / 代发 timeline 命令时，其 manifest.permissions 必须覆盖
+// 对应能力域；缺失即拒绝渲染/执行。v1 插件不贡献 editorSlots，天然不受此域约束。
+// 本模块只做纯判定，接入点在插槽渲染（SlotStack）与宿主命令代发通道。
+
+import { getRegisteredPlugin } from "@/lib/plugins/plugin-registry";
+import type { EditorPluginPermission, EditorSlotKind } from "@/lib/plugins/plugin-types";
+
+/** 每个编辑器插槽所需的最小权限域（M5.2 表驱动：新插槽必须补表，否则 fail-closed 拒渲染）。 */
+export const EDITOR_SLOT_REQUIRED_PERMISSION: Record<EditorSlotKind, EditorPluginPermission> = {
+    "timeline-panel": "timeline.command",
+    "preview-renderer": "timeline.read",
+    inspector: "timeline.command",
+    "asset-ingest": "timeline.command",
+    "subtitle-tool": "timeline.command",
+    "transcription-provider": "timeline.command",
+    "export-renderer": "export.run",
+    "ai-assistant": "timeline.read",
+};
+
+export type EditorSlotPermissionVerdict =
+    | { allowed: true }
+    | { allowed: false; reason: "plugin-not-registered" | "missing-permission"; missing: EditorPluginPermission | null };
+
+/** fail-closed 权限判定：权限集缺失或未包含 required 一律拒绝。 */
+export function checkEditorPermission(permissions: ReadonlySet<string> | null, required: EditorPluginPermission): boolean {
+    return permissions !== null && permissions.has(required);
+}
+
+export function requiredPermissionForEditorSlot(slot: EditorSlotKind): EditorPluginPermission {
+    return EDITOR_SLOT_REQUIRED_PERMISSION[slot];
+}
+
+/** 查询插件的权限集（未注册返回 null）。 */
+export function pluginPermissions(pluginId: string): ReadonlySet<string> | null {
+    const registered = getRegisteredPlugin(pluginId);
+    if (!registered) return null;
+    return new Set(registered.manifest.permissions ?? []);
+}
+
+/** 判定某插件是否被允许渲染某编辑器插槽（fail-closed；v2 注册即被检，缺失权限拒渲染）。 */
+export function pluginMayRenderEditorSlot(pluginId: string, slot: EditorSlotKind): EditorSlotPermissionVerdict {
+    const permissions = pluginPermissions(pluginId);
+    if (permissions === null) {
+        return { allowed: false, reason: "plugin-not-registered", missing: null };
+    }
+    const required = EDITOR_SLOT_REQUIRED_PERMISSION[slot];
+    if (!permissions.has(required)) {
+        return { allowed: false, reason: "missing-permission", missing: required };
+    }
+    return { allowed: true };
+}
+
+/** 宿主命令代发通道的权限断言：插件未声明 permission 时抛错（M6 AI 命令、第三方代发复用）。 */
+export function assertEditorPermission(pluginId: string, permission: EditorPluginPermission): void {
+    const permissions = pluginPermissions(pluginId);
+    if (permissions === null) {
+        throw new Error(`插件 ${pluginId} 未注册，无法代发 ${permission} 命令`);
+    }
+    if (!permissions.has(permission)) {
+        throw new Error(`插件 ${pluginId} 缺少 ${permission} 权限，命令已被拒绝`);
+    }
+}
diff --git a/web/src/lib/plugins/plugin-registry.ts b/web/src/lib/plugins/plugin-registry.ts
index 8ec267321..d0c272882 100644
--- a/web/src/lib/plugins/plugin-registry.ts
+++ b/web/src/lib/plugins/plugin-registry.ts
@@ -1,14 +1,52 @@
-import type { PluginManifest, RegisteredPlugin } from "./plugin-types";
+import type { EditorSlotKind, PluginManifest, PluginManifestV2, RegisteredPlugin } from "./plugin-types";
+import { unregisterPluginSlots } from "./editor-slot-registry";
 import { registerPluginCanvasNodes, unregisterNodeDefinitions } from "@/lib/canvas/node-registry";
 
 const registeredPlugins = new Map<string, RegisteredPlugin>();
 
-function assertManifest(manifest: PluginManifest) {
+const EDITOR_SLOT_KINDS: EditorSlotKind[] = [
+    "timeline-panel",
+    "preview-renderer",
+    "inspector",
+    "asset-ingest",
+    "subtitle-tool",
+    "transcription-provider",
+    "export-renderer",
+    "ai-assistant",
+];
+
+function assertManifest(manifest: PluginManifest | PluginManifestV2) {
     if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(manifest.id)) throw new Error("插件 ID 必须使用 kebab-case");
     if (!manifest.name.trim() || !manifest.version.trim() || !manifest.apiVersion.trim()) throw new Error("插件清单缺少名称、版本或 API 版本");
-    if (manifest.apiVersion !== "yingce.plugin/v1") throw new Error(`不支持的插件 API 版本：${manifest.apiVersion}`);
+    const apiVersion: string = manifest.apiVersion;
+    if (apiVersion !== "yingce.plugin/v1" && apiVersion !== "yingce.plugin/v2") {
+        throw new Error(`不支持的插件 API 版本：${apiVersion}`);
+    }
     if (new Set(manifest.permissions).size !== manifest.permissions.length) throw new Error("插件权限不能重复");
-    if (!manifest.contributes || Object.values(manifest.contributes).every((value) => !value || value.length === 0)) throw new Error("插件至少需要声明一种贡献能力");
+    if (manifest.apiVersion === "yingce.plugin/v2") assertManifestV2(manifest);
+    else assertManifestV1Contributions(manifest.contributes);
+}
+
+function assertManifestV1Contributions(contributes: PluginManifest["contributes"]) {
+    if (!contributes || Object.values(contributes).every((value) => !value || value.length === 0)) {
+        throw new Error("插件至少需要声明一种贡献能力");
+    }
+}
+
+function assertManifestV2(manifest: PluginManifestV2) {
+    if (manifest.contributes.editorSlots?.length) {
+        for (const slot of manifest.contributes.editorSlots) {
+            if (!EDITOR_SLOT_KINDS.includes(slot.slot)) throw new Error(`未知的编辑器插槽类型：${slot.slot}`);
+            if (slot.priority !== undefined && (typeof slot.priority !== "number" || Number.isNaN(slot.priority))) {
+                throw new Error(`编辑器插槽 ${slot.slot} 的 priority 必须是数字`);
+            }
+        }
+    }
+    // 贡献检查：v1 贡献字段或 editorSlots 至少声明一项（editorSlots 是合法的 v2 独立贡献）。
+    const { editorSlots, ...v1Contributions } = manifest.contributes;
+    if (Object.values(v1Contributions).every((value) => !value || value.length === 0) && !editorSlots?.length) {
+        throw new Error("插件至少需要声明一种贡献能力");
+    }
 }
 
 export function registerPlugin(plugin: RegisteredPlugin) {
@@ -17,6 +55,10 @@ export function registerPlugin(plugin: RegisteredPlugin) {
     if (existing && existing.manifest.version !== plugin.manifest.version) {
         throw new Error(`插件 ${plugin.manifest.id} 已注册其他版本`);
     }
+    if (plugin.manifest.apiVersion === "yingce.plugin/v2") {
+        // v2：编辑器插槽声明由注册器提取存储；UI 渲染函数由插件 activate() 阶段经 registerEditorSlot 提供。
+        plugin.editorSlots = plugin.manifest.contributes.editorSlots ?? [];
+    }
     if (plugin.manifest.contributes.canvasNodes?.length) {
         registerPluginCanvasNodes(plugin.manifest.id, plugin.manifest.contributes.canvasNodes);
     }
@@ -25,6 +67,7 @@ export function registerPlugin(plugin: RegisteredPlugin) {
 
 export function unregisterPlugin(pluginId: string) {
     unregisterNodeDefinitions(pluginId);
+    unregisterPluginSlots(pluginId);
     registeredPlugins.delete(pluginId);
 }
 
@@ -36,6 +79,6 @@ export function listRegisteredPlugins() {
     return [...registeredPlugins.values()];
 }
 
-export function listRegisteredManifests(): PluginManifest[] {
+export function listRegisteredManifests(): Array<PluginManifest | PluginManifestV2> {
     return listRegisteredPlugins().map(({ manifest }) => manifest);
 }
diff --git a/web/src/lib/plugins/plugin-types.ts b/web/src/lib/plugins/plugin-types.ts
index 91a407aa7..09c420b28 100644
--- a/web/src/lib/plugins/plugin-types.ts
+++ b/web/src/lib/plugins/plugin-types.ts
@@ -1,6 +1,35 @@
 import type { Asset } from "@/stores/use-asset-store";
 
 export const PLUGIN_API_VERSION = "yingce.plugin/v1" as const;
+export const PLUGIN_API_VERSION_V2 = "yingce.plugin/v2" as const;
+
+export type EditorSlotKind =
+    | "timeline-panel"
+    | "preview-renderer"
+    | "inspector"
+    | "asset-ingest"
+    | "subtitle-tool"
+    | "transcription-provider"
+    | "export-renderer"
+    | "ai-assistant";
+
+export type EditorSlotContribution = {
+    slot: EditorSlotKind;
+    priority?: number;
+};
+
+export type EditorPluginPermission = "timeline.read" | "timeline.command" | "export.run";
+
+export type PluginContributionsV2 = PluginContributions & {
+    editorSlots?: EditorSlotContribution[];
+};
+
+// 注意：必须把 permissions 一并 Omit 掉再完全替换，否则数组交叉类型会被归约为 v1 的 PluginPermission[]，v2 权限字面量无法赋值。
+export type PluginManifestV2 = Omit<PluginManifest, "apiVersion" | "contributes" | "permissions"> & {
+    apiVersion: typeof PLUGIN_API_VERSION_V2;
+    permissions: Array<PluginPermission | EditorPluginPermission>;
+    contributes: PluginContributionsV2;
+};
 
 export type PluginContributionKind = "provider" | "payment-provider" | "workflow" | "canvas-node" | "transform" | "command" | "asset-source" | "usage-observer" | "ai-capability" | "agent" | "import-export";
 export type PluginSurface = "node" | "fullscreen" | "hybrid" | "asset-source" | "settings" | "wallet";
@@ -195,8 +224,8 @@ export type PluginHostServices = {
 };
 
 export type PluginHostContext = {
-    manifest: PluginManifest;
-    permissions: ReadonlySet<PluginPermission>;
+    manifest: PluginManifest | PluginManifestV2;
+    permissions: ReadonlySet<PluginPermission | EditorPluginPermission>;
     storage: PluginStorage;
     config: Readonly<PluginInstallation["config"]>;
     services?: PluginHostServices;
@@ -287,16 +316,20 @@ export type AssetSourceProvider = {
 };
 
 export type RegisteredPlugin = {
-    manifest: PluginManifest;
+    /** v1 或 v2 插件清单；v2 清单结构为 v1 超集（含 editorSlots 声明）。 */
+    manifest: PluginManifest | PluginManifestV2;
     source?: "bundled" | "uploaded" | string;
     activate?: (context: PluginHostContext) => Promise<void> | void;
     deactivate?: (context: PluginHostContext) => Promise<void> | void;
     createAssetSource?: (context: PluginHostContext) => AssetSourceProvider;
     createPromptOptimizer?: (context: PluginHostContext) => PromptOptimizerProvider;
+    /** v2 插件由注册器从 manifest 提取的编辑器插槽声明（v1 插件无此字段）。 */
+    editorSlots?: EditorSlotContribution[];
+    /** v2 插件 UI 插槽的实际渲染函数由插件 activate() 阶段经 registerEditorSlot 提供。 */
 };
 
 export type PluginInstallation = {
-    manifest: PluginManifest;
+    manifest: PluginManifest | PluginManifestV2;
     enabled: boolean;
     config: Record<string, string | number | boolean>;
     installedAt: string;
diff --git a/web/src/lib/timeline/ai-command-schema.ts b/web/src/lib/timeline/ai-command-schema.ts
new file mode 100644
index 000000000..2ca081404
--- /dev/null
+++ b/web/src/lib/timeline/ai-command-schema.ts
@@ -0,0 +1,221 @@
+// AI 编辑命令契约（ADR-0007 / Runbook M6.1）：宿主校验 + LLM 提示词约束的双契约。
+// 本文件不复制 handler 约束——命令合法性硬守门在 M2.1 命令注册表（fail-closed），
+// 这里只做：(1) LLM 输出 JSON 的结构解析与批级预检（dry-run 走同一注册表，零重复），
+// (2) 生成喂给 LLM 的 op 契约（op 集合与注册表黄金同步，见测试）。
+
+import { getEditorCommandRegistry, type EditCommand } from "@/lib/timeline/editor-commands";
+import type { TimelineProject } from "@/types/timeline";
+
+/** LLM 输出 JSON 结构：reasoning 可选，commands 至少一条。 */
+export type AiCommandPlan = {
+    reasoning?: string;
+    commands: EditCommand[];
+};
+
+export type AiCommandBatchVerdict =
+    | { ok: true }
+    | { ok: false; index: number; op: string; error: string };
+
+export class AiCommandPlanError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "AiCommandPlanError";
+    }
+}
+
+/** 从 LLM 回复中提取首个 JSON 对象（容忍 markdown fence / 前后缀杂讯）。 */
+function extractFirstJsonObject(text: string): string {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const candidate = fenced ? fenced[1] : text;
+    const start = candidate.indexOf("{");
+    if (start < 0) throw new AiCommandPlanError("输出中未找到 JSON 对象（需要 { commands: [...] }）");
+    // 从首个 { 起逐字符数括号，找配对的收尾 }（字符串内括号不计）。
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < candidate.length; i += 1) {
+        const ch = candidate[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            } else if (ch === "\\") {
+                escaped = true;
+            } else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        } else if (ch === "{") {
+            depth += 1;
+        } else if (ch === "}") {
+            depth -= 1;
+            if (depth === 0) return candidate.slice(start, i + 1);
+        }
+    }
+    throw new AiCommandPlanError("JSON 对象未闭合（缺少收尾 }）");
+}
+
+function assertPlanShape(raw: unknown): asserts raw is AiCommandPlan {
+    if (typeof raw !== "object" || raw === null) throw new AiCommandPlanError("输出必须是 JSON 对象");
+    const plan = raw as Record<string, unknown>;
+    if (plan.reasoning !== undefined && typeof plan.reasoning !== "string") {
+        throw new AiCommandPlanError("reasoning 必须是字符串");
+    }
+    if (!Array.isArray(plan.commands)) throw new AiCommandPlanError("缺少 commands 数组");
+    if (plan.commands.length > AI_EDITING_MAX_COMMANDS) {
+        throw new AiCommandPlanError(`commands 超过 ${AI_EDITING_MAX_COMMANDS} 条上限`);
+    }
+    // commands 为空数组 = 只读问答 / 无可用命令，合法终态
+    plan.commands.forEach((cmd, i) => {
+        if (typeof cmd !== "object" || cmd === null) throw new AiCommandPlanError(`commands[${i}] 必须是对象`);
+        const c = cmd as Record<string, unknown>;
+        if (typeof c.op !== "string" || c.op.length === 0) throw new AiCommandPlanError(`commands[${i}].op 必须是非空字符串`);
+        if (typeof c.payload !== "object" || c.payload === null || Array.isArray(c.payload)) {
+            throw new AiCommandPlanError(`commands[${i}].op=${c.op} 缺少对象 payload`);
+        }
+    });
+}
+
+/**
+ * 解析 LLM 文本输出为 AiCommandPlan；结构非法时抛 AiCommandPlanError（供 UI 展示并回填模型）。
+ * commands 为空数组表示「只读问答 / 无法用现有命令完成」，面板直接展示 reasoning 作为回答。
+ */
+export function parseAiCommandPlan(text: string): AiCommandPlan {
+    let raw: unknown;
+    try {
+        raw = JSON.parse(extractFirstJsonObject(text));
+    } catch (error) {
+        if (error instanceof AiCommandPlanError) throw error;
+        throw new AiCommandPlanError(`JSON 解析失败：${(error as Error).message}`);
+    }
+    assertPlanShape(raw);
+    return raw;
+}
+
+/**
+ * 批级预检：把整批命令按序 dry-run 到当前时间线（immutable 纯函数，无副作用）。
+ * 任何一条触发注册表 fail-closed（未知 op / 非法 payload / 引用不存在）即整批拒绝，
+ * 返回首个出错命令的下标与消息——ADR-0007「任一非法→整批拒绝，错误回填 LLM 修正」。
+ */
+export function validateAiCommandBatch(project: TimelineProject, plan: AiCommandPlan): AiCommandBatchVerdict {
+    const registry = getEditorCommandRegistry();
+    let state = project;
+    for (let i = 0; i < plan.commands.length; i += 1) {
+        const cmd = plan.commands[i];
+        try {
+            state = registry.apply(state, cmd);
+        } catch (error) {
+            return { ok: false, index: i, op: cmd.op, error: (error as Error).message };
+        }
+    }
+    return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// LLM 提示词契约（ADR-0007：schema 同时用于宿主校验与模型输出约束）
+// ---------------------------------------------------------------------------
+
+/** AI 命令 schema 版本（Runbook M6.1）：提示词契约/解析规则变更时递增，供 golden 与缓存失效对齐。 */
+export const AI_COMMAND_SCHEMA_VERSION = 1;
+
+/** 单次 AI 编辑最多允许的命令条数（ADR-0007：防止模型一次输出失控编辑）。 */
+export const AI_EDITING_MAX_COMMANDS = 8;
+
+/** 12 个黄金 op 的 LLM 可读 payload 契约；op 集合与注册表黄金同步（见测试）。 */
+export const AI_EDITING_OP_CATALOG: ReadonlyArray<{
+    op: string;
+    desc: string;
+    payload: string;
+}> = [
+    {
+        op: "addClip",
+        desc: "新增媒体/文本片段到已存在轨道",
+        payload: "{ clip: { id(新唯一), kind: video|audio|image|text, trackId(必须存在), nodeId(源素材), startMs≥0, durationMs>0, title?, volume?, fadeInMs?, fadeOutMs? } }",
+    },
+    {
+        op: "moveClip",
+        desc: "移动片段（时间点/跨轨）",
+        payload: "{ id, startMs≥0, trackId?(可选, 必须存在) }",
+    },
+    {
+        op: "trimClip",
+        desc: "裁剪片段（时间线位置/时长/源内起点）",
+        payload: "{ id, startMs?(≥0), durationMs?(>0 且≤sourceDurationMs), sourceStartMs?(≥0, 与 durationMs 之和≤sourceDurationMs) }",
+    },
+    {
+        op: "splitClip",
+        desc: "在片段内部切一刀成两段",
+        payload: "{ id, splitAtMs(严格大于 startMs 且小于 startMs+durationMs) }",
+    },
+    {
+        op: "removeClip",
+        desc: "删除片段",
+        payload: "{ id }",
+    },
+    {
+        op: "setClipProperty",
+        desc: "修改片段属性（白名单）",
+        payload: "{ id, patch: { title? | text? | volume? | fadeInMs? | fadeOutMs? | subtitleEntryIndex? }（至少一项） }",
+    },
+    {
+        op: "addSubtitle",
+        desc: "新增字幕片段",
+        payload: "{ clip: { kind: subtitle, trackId(字幕轨), id/nodeId/startMs/durationMs/text } }",
+    },
+    {
+        op: "removeSubtitle",
+        desc: "删除字幕片段",
+        payload: "{ id }",
+    },
+    {
+        op: "rebuildSubtitleClips",
+        desc: "按节点字幕条目重建字幕片段",
+        payload: "{ nodeId, entries: [{ index≥0(唯一), startMs≥0, endMs>startMs, text }], trackId?(字幕轨) }",
+    },
+    {
+        op: "addTrack",
+        desc: "新增轨道（id/label 由系统生成，勿传）",
+        payload: "{ kind: video|image|text|audio|subtitle }",
+    },
+    {
+        op: "removeTrack",
+        desc: "删除整条轨道及片段（每种轨道至少保留一条）",
+        payload: "{ trackId }",
+    },
+    {
+        op: "setTrackFlag",
+        desc: "轨道开关",
+        payload: "{ trackId, flag: visible|muted, value: boolean }",
+    },
+];
+
+/** LLM 输出结构说明（追加到系统提示词，约束其为纯 JSON）。 */
+export const AI_EDITING_OUTPUT_FORMAT = `输出要求：
+- 只输出一个 JSON 对象，不要任何解释文字或 markdown。
+- 结构：{ "reasoning": "一句话说明意图", "commands": [ { "op": "命令名", "payload": { ... } } ] }
+- commands：能执行时 1-8 条；用户只是提问或无法用现有命令完成时为空数组 []，此时 reasoning 直接回答用户。
+- payload 字段严格按命令契约；时间一律毫秒；文本用简体中文。
+- 所有 id（clip/track/nodeId）必须来自上面时间线摘要，禁止编造。`;
+
+/** 示例（示意完整 JSON 输出，加入 system prompt）。 */
+const AI_EDITING_OUTPUT_EXAMPLE = `示例：
+{ "reasoning": "把第一个视频片段移到第 5 秒", "commands": [ { "op": "moveClip", "payload": { "id": "clip-a", "startMs": 5000 } } ] }`;
+
+/** 组装 AI 编辑系统提示词：时间线摘要 + op 契约 + 输出约束（M6.3 面板喂给模型）。 */
+export function buildAiEditingSystemPrompt(timelineSummary: string): string {
+    const catalogLines = AI_EDITING_OP_CATALOG.map(
+        (entry) => `- ${entry.op}：${entry.desc}。payload：${entry.payload}`,
+    ).join("\n");
+    return [
+        "你是影策视频剪辑工作台的 AI 剪辑助手。根据用户指令对时间线输出受约束的编辑命令 JSON。",
+        "时间线当前状态：",
+        timelineSummary,
+        "可用命令契约（与编辑器同源，非法命令会被整批拒绝）：",
+        catalogLines,
+        AI_EDITING_OUTPUT_FORMAT,
+        AI_EDITING_OUTPUT_EXAMPLE,
+        "若用户指令无法用现有命令完成（如要转场、滤镜、模板），输出 commands: [] 并在 reasoning 说明缺什么能力。",
+    ].join("\n");
+}
diff --git a/web/src/lib/timeline/asset-ingest.ts b/web/src/lib/timeline/asset-ingest.ts
new file mode 100644
index 000000000..ec4889a13
--- /dev/null
+++ b/web/src/lib/timeline/asset-ingest.ts
@@ -0,0 +1,49 @@
+// 资产 → 时间线片段 的纯转换（M3.4 asset-ingest）。
+// 资产是"仅时间线作用域"的直连媒体：nodeId 用 `asset:<id>` 前缀（不指向画布节点），
+// 预览/导出从 directMedia 解析媒体，不回画布查节点。
+
+import type { ProjectAsset } from "@/services/api/projects";
+import type { TimelineClip, TimelineClipKind } from "@/types/timeline";
+
+const MEDIA_TYPE_TO_KIND: Record<string, TimelineClipKind | undefined> = {
+    video: "video",
+    audio: "audio",
+    image: "image",
+    text: "text",
+};
+
+export function assetToClipKind(mediaType: string): TimelineClipKind | null {
+    return MEDIA_TYPE_TO_KIND[mediaType] ?? null;
+}
+
+export type MakeClipFromAssetOptions = {
+    /** 目标轨道 id（调用方已按 kind 选好轨道）。 */
+    trackId: string;
+    /** 时间线起点（毫秒，通常为该轨道当前末尾）。 */
+    startMs: number;
+    /** 默认时长（毫秒）；资产无时长元数据时使用。 */
+    defaultDurationMs?: number;
+    /** 时间线内唯一 id（调用方负责去重，通常 `asset:<id>:<n>`）。 */
+    id?: string;
+};
+
+export function makeClipFromAsset(asset: ProjectAsset, options: MakeClipFromAssetOptions): TimelineClip | null {
+    const kind = assetToClipKind(asset.mediaType);
+    if (!kind) return null;
+    if (kind === "text") return null; // 文本资产不直接入轨（走字幕/文字工具）
+    return {
+        id: options.id ?? `asset:${asset.id}`,
+        kind,
+        nodeId: `asset:${asset.id}`,
+        trackId: options.trackId,
+        startMs: options.startMs,
+        durationMs: asset.durationMs && asset.durationMs > 0 ? asset.durationMs : (options.defaultDurationMs ?? 3_000),
+        title: asset.title,
+        directMedia: {
+            id: asset.id,
+            kind: kind === "subtitle" ? "text" : kind,
+            title: asset.title,
+            storageKey: asset.storageKey,
+        },
+    };
+}
diff --git a/web/src/lib/timeline/editor-commands.ts b/web/src/lib/timeline/editor-commands.ts
new file mode 100644
index 000000000..39826acee
--- /dev/null
+++ b/web/src/lib/timeline/editor-commands.ts
@@ -0,0 +1,364 @@
+// 编辑器命令协议（ADR-0002）：时间线唯一修改入口。
+// 命令 = 可序列化 { op, payload }，handler 为纯函数（禁止依赖组件实例），
+// 未知 op 或非法 payload 一律抛错（fail-closed），保证可回放、可撤销、可黄金文件测试。
+// 插件可经宿主 API register 自定义 op，与内建命令共用同一注册表与校验纪律。
+
+import type { SrtEntry, TimelineClip, TimelineProject, TimelineTrack, TimelineTrackKind } from "@/types/timeline";
+
+export type EditCommand = { op: string; payload: unknown };
+export type CommandHandler = (state: TimelineProject, payload: unknown) => TimelineProject;
+
+export type EditorCommandRegistry = {
+    /** 注册命令 handler（宿主与插件共用；同名 op 覆盖，插件的注册顺序即优先级）。 */
+    register: (op: string, handler: CommandHandler) => void;
+    /** 应用命令：未知 op 抛错（fail-closed）；返回新状态（不可变更新）。 */
+    apply: (state: TimelineProject, cmd: EditCommand) => TimelineProject;
+    knownOps: () => string[];
+};
+
+// ---------------------------------------------------------------------------
+// 黄金命令集合 payload 类型（首版一期能力，对应 Runbook M2.1）
+// ---------------------------------------------------------------------------
+
+export type AddClipPayload = { clip: TimelineClip };
+export type MoveClipPayload = { id: string; startMs: number; trackId?: string };
+export type TrimClipPayload = { id: string; startMs?: number; durationMs?: number; sourceStartMs?: number };
+export type SplitClipPayload = { id: string; splitAtMs: number };
+export type RemoveClipPayload = { id: string };
+export type SetClipPropertyPayload = {
+    id: string;
+    patch: Partial<Pick<TimelineClip, "title" | "text" | "volume" | "fadeInMs" | "fadeOutMs" | "subtitleEntryIndex">>;
+};
+export type AddSubtitlePayload = { clip: TimelineClip };
+export type RemoveSubtitlePayload = { id: string };
+/** 从节点权威 subtitleEntries 重建时间线条字幕 clip（§3.1 快照契约：单向显式同步，替换过期快照）。 */
+/** 新增空轨道（addTrack）。id/order/label 由 handler 按当前状态确定，保证 undo/redo 重放确定性。 */
+export type AddTrackPayload = { kind: TimelineTrackKind };
+
+/** 移除整条轨道及其全部片段（removeTrack）。守卫：同 kind 至少保留一条轨道（防唯一字幕/视频轨被删光后编辑失锚）。 */
+export type RemoveTrackPayload = { trackId: string };
+
+/** 轨道开关（setTrackFlag）：可见性 / 静音。flag 白名单校验，fail-closed。 */
+export type SetTrackFlagPayload = { trackId: string; flag: "visible" | "muted"; value: boolean };
+export type RebuildSubtitleClipsPayload = {
+    /** 画布节点 id（subtitleEntries 权威源）。 */
+    nodeId: string;
+    /** 权威字幕条目快照（按此重建，text 进入 clip 快照）。 */
+    entries: SrtEntry[];
+    /** 目标字幕轨道 id；缺省取第一个字幕轨道。 */
+    trackId?: string;
+};
+
+export const EDITOR_COMMAND_OPS = [
+    "addClip",
+    "moveClip",
+    "trimClip",
+    "splitClip",
+    "removeClip",
+    "setClipProperty",
+    "addSubtitle",
+    "removeSubtitle",
+    "rebuildSubtitleClips",
+    "addTrack",
+    "removeTrack",
+    "setTrackFlag",
+] as const;
+
+// ---------------------------------------------------------------------------
+// 校验辅助
+// ---------------------------------------------------------------------------
+
+function fail(op: string, message: string): never {
+    throw new Error(`edit command "${op}" rejected: ${message}`);
+}
+
+function assertClipShape(op: string, clip: unknown): asserts clip is TimelineClip {
+    if (typeof clip !== "object" || clip === null) fail(op, "clip must be an object");
+    const c = clip as TimelineClip;
+    if (typeof c.id !== "string" || c.id.length === 0) fail(op, "clip.id must be a non-empty string");
+    if (!["video", "audio", "subtitle", "text", "image"].includes(c.kind)) fail(op, `clip.kind must be a valid clip kind, got "${c.kind}"`);
+    if (typeof c.trackId !== "string" || c.trackId.length === 0) fail(op, "clip.trackId must be a non-empty string");
+    if (typeof c.nodeId !== "string" || c.nodeId.length === 0) fail(op, "clip.nodeId must be a non-empty string");
+    if (typeof c.startMs !== "number" || !Number.isFinite(c.startMs) || c.startMs < 0) fail(op, "clip.startMs must be a non-negative finite number");
+    if (typeof c.durationMs !== "number" || !Number.isFinite(c.durationMs) || c.durationMs <= 0) fail(op, "clip.durationMs must be a positive finite number");
+}
+
+function findTrackOrThrow(op: string, state: TimelineProject, trackId: string) {
+    const track = state.tracks.find((t) => t.id === trackId);
+    if (!track) fail(op, `track "${trackId}" does not exist`);
+    return track;
+}
+
+function findClipOrThrow(op: string, state: TimelineProject, id: string): TimelineClip {
+    const clip = state.clips.find((c) => c.id === id);
+    if (!clip) fail(op, `clip "${id}" does not exist`);
+    return clip;
+}
+
+/** 时间线总时长 = 所有片段末端最大值（与 normalizeTimelineProject 同源）。 */
+function recomputeDurationMs(state: TimelineProject): number {
+    return state.clips.reduce((max, clip) => Math.max(max, clip.startMs + clip.durationMs), 0);
+}
+
+function withClips(state: TimelineProject, clips: TimelineClip[]): TimelineProject {
+    return { ...state, clips, durationMs: recomputeDurationMs({ ...state, clips }) };
+}
+
+// ---------------------------------------------------------------------------
+// 黄金命令集合 handler
+// ---------------------------------------------------------------------------
+
+function handleAddClip(state: TimelineProject, payload: unknown): TimelineProject {
+    const { clip } = payload as AddClipPayload;
+    assertClipShape("addClip", clip);
+    if (clip.kind === "subtitle") fail("addClip", 'subtitle clips must use op "addSubtitle"');
+    findTrackOrThrow("addClip", state, clip.trackId);
+    return withClips(state, [...state.clips, clip]);
+}
+
+function handleMoveClip(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id, startMs, trackId } = payload as MoveClipPayload;
+    if (typeof startMs !== "number" || !Number.isFinite(startMs) || startMs < 0) fail("moveClip", "startMs must be a non-negative finite number");
+    const clip = findClipOrThrow("moveClip", state, id);
+    if (trackId !== undefined) findTrackOrThrow("moveClip", state, trackId);
+    const moved = { ...clip, startMs, ...(trackId !== undefined ? { trackId } : {}) };
+    return withClips(state, state.clips.map((c) => (c.id === id ? moved : c)));
+}
+
+function handleTrimClip(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id, startMs, durationMs, sourceStartMs } = payload as TrimClipPayload;
+    const clip = findClipOrThrow("trimClip", state, id);
+
+    const nextStartMs = startMs ?? clip.startMs;
+    const nextDurationMs = durationMs ?? clip.durationMs;
+    const nextSourceStartMs = sourceStartMs ?? clip.sourceStartMs ?? 0;
+
+    if (!Number.isFinite(nextStartMs) || nextStartMs < 0) fail("trimClip", "startMs must be a non-negative finite number");
+    if (!Number.isFinite(nextDurationMs) || nextDurationMs <= 0) fail("trimClip", "durationMs must be a positive finite number");
+    if (!Number.isFinite(nextSourceStartMs) || nextSourceStartMs < 0) fail("trimClip", "sourceStartMs must be a non-negative finite number");
+
+    // 源时长已知时限制裁剪上限（UI 与命令层同一条规则，防止导出越界）。
+    const sourceDuration = clip.sourceDurationMs ?? 0;
+    if (sourceDuration > 0) {
+        if (nextDurationMs > sourceDuration) fail("trimClip", `durationMs ${nextDurationMs} exceeds sourceDurationMs ${sourceDuration}`);
+        if (nextSourceStartMs + nextDurationMs > sourceDuration) fail("trimClip", "sourceStartMs + durationMs exceeds sourceDurationMs");
+    }
+
+    const trimmed: TimelineClip = {
+        ...clip,
+        startMs: nextStartMs,
+        durationMs: nextDurationMs,
+        sourceStartMs: nextSourceStartMs,
+    };
+    return withClips(state, state.clips.map((c) => (c.id === id ? trimmed : c)));
+}
+
+function handleSplitClip(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id, splitAtMs } = payload as SplitClipPayload;
+    if (typeof splitAtMs !== "number" || !Number.isFinite(splitAtMs)) fail("splitClip", "splitAtMs must be a finite number");
+    const clip = findClipOrThrow("splitClip", state, id);
+
+    const clipEnd = clip.startMs + clip.durationMs;
+    if (splitAtMs <= clip.startMs || splitAtMs >= clipEnd) {
+        fail("splitClip", `splitAtMs ${splitAtMs} must be strictly inside clip [${clip.startMs}, ${clipEnd})`);
+    }
+
+    const leftDuration = splitAtMs - clip.startMs;
+    const rightDuration = clipEnd - splitAtMs;
+    const left: TimelineClip = { ...clip, durationMs: leftDuration };
+    const right: TimelineClip = {
+        ...clip,
+        id: `${clip.id}:split:${splitAtMs}`,
+        startMs: splitAtMs,
+        durationMs: rightDuration,
+        sourceStartMs: (clip.sourceStartMs ?? 0) + leftDuration,
+    };
+
+    const index = state.clips.findIndex((c) => c.id === id);
+    const clips = [...state.clips.slice(0, index), left, right, ...state.clips.slice(index + 1)];
+    return withClips(state, clips);
+}
+
+function handleRemoveClip(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id } = payload as RemoveClipPayload;
+    if (typeof id !== "string" || id.length === 0) fail("removeClip", "id must be a non-empty string");
+    findClipOrThrow("removeClip", state, id);
+    return withClips(state, state.clips.filter((c) => c.id !== id));
+}
+
+/** setClipProperty 允许修改的属性白名单；结构字段（id/kind/nodeId/trackId/startMs/durationMs/...）由专门命令负责。 */
+const CLIP_PROPERTY_WHITELIST = new Set(["title", "text", "volume", "fadeInMs", "fadeOutMs", "subtitleEntryIndex"]);
+
+function handleSetClipProperty(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id, patch } = payload as SetClipPropertyPayload;
+    if (typeof patch !== "object" || patch === null || Array.isArray(patch)) fail("setClipProperty", "patch must be an object");
+    const keys = Object.keys(patch);
+    if (keys.length === 0) fail("setClipProperty", "patch must not be empty");
+    for (const key of keys) {
+        if (!CLIP_PROPERTY_WHITELIST.has(key)) fail("setClipProperty", `property "${key}" is not editable via setClipProperty (use the dedicated op)`);
+    }
+    findClipOrThrow("setClipProperty", state, id);
+
+    const updated = { ...findClipOrThrow("setClipProperty", state, id), ...patch };
+    return withClips(state, state.clips.map((c) => (c.id === id ? updated : c)));
+}
+
+function handleAddSubtitle(state: TimelineProject, payload: unknown): TimelineProject {
+    const { clip } = payload as AddSubtitlePayload;
+    assertClipShape("addSubtitle", clip);
+    if (clip.kind !== "subtitle") fail("addSubtitle", `clip.kind must be "subtitle", got "${clip.kind}"`);
+    findTrackOrThrow("addSubtitle", state, clip.trackId);
+    return withClips(state, [...state.clips, clip]);
+}
+
+function handleRemoveSubtitle(state: TimelineProject, payload: unknown): TimelineProject {
+    const { id } = payload as RemoveSubtitlePayload;
+    if (typeof id !== "string" || id.length === 0) fail("removeSubtitle", "id must be a non-empty string");
+    const clip = findClipOrThrow("removeSubtitle", state, id);
+    if (clip.kind !== "subtitle") fail("removeSubtitle", `clip "${id}" is not a subtitle clip`);
+    return withClips(state, state.clips.filter((c) => c.id !== id));
+}
+
+/** 轨道种类的基础标签；新增轨道 label = 基础标签 + 同种类现有轨道数 + 1。 */
+export const TRACK_KIND_BASE_LABELS: Record<TimelineTrackKind, string> = {
+    video: "视频",
+    image: "图片",
+    text: "文本",
+    audio: "音频",
+    subtitle: "字幕",
+};
+
+function handleAddTrack(state: TimelineProject, payload: unknown): TimelineProject {
+    const { kind } = payload as AddTrackPayload;
+    if (!(kind in TRACK_KIND_BASE_LABELS)) {
+        fail("addTrack", `track kind must be one of "video" | "image" | "text" | "audio" | "subtitle", got "${String(kind)}"`);
+    }
+    // id/order/label 都由当前状态确定：同一撤销/重放路径永远得到同一结果（确定性）。
+    let index = state.tracks.filter((t) => t.kind === kind).length + 1;
+    let id = `${kind}-${index}`;
+    while (state.tracks.some((t) => t.id === id)) {
+        index += 1;
+        id = `${kind}-${index}`;
+    }
+    const order = state.tracks.reduce((max, t) => Math.max(max, t.order), -1) + 1;
+    const track: TimelineTrack = { id, kind, label: `${TRACK_KIND_BASE_LABELS[kind]} ${index}`, order };
+    return { ...state, tracks: [...state.tracks, track] };
+}
+
+function handleRemoveTrack(state: TimelineProject, payload: unknown): TimelineProject {
+    const { trackId } = payload as RemoveTrackPayload;
+    if (typeof trackId !== "string" || trackId.length === 0) fail("removeTrack", "trackId must be a non-empty string");
+    const track = findTrackOrThrow("removeTrack", state, trackId);
+    // 每类轨道至少保留一条：删除最后一条会让吸附目标、字幕重建等编辑操作失锚。
+    const lastOfKind = state.tracks.filter((t) => t.kind === track.kind).length <= 1;
+    if (lastOfKind) fail("removeTrack", `cannot remove the last "${track.kind}" track`);
+    // 轨道上片段随轨道一并移除（moveClip/trimClip/splitClip 均已按 trackId 归属，无悬挂引用）。
+    return {
+        ...state,
+        tracks: state.tracks.filter((t) => t.id !== trackId),
+        clips: state.clips.filter((c) => c.trackId !== trackId),
+    };
+}
+
+function handleSetTrackFlag(state: TimelineProject, payload: unknown): TimelineProject {
+    const { trackId, flag, value } = payload as SetTrackFlagPayload;
+    if (typeof trackId !== "string" || trackId.length === 0) fail("setTrackFlag", "trackId must be a non-empty string");
+    if (flag !== "visible" && flag !== "muted") fail("setTrackFlag", "flag must be \"visible\" or \"muted\"");
+    if (typeof value !== "boolean") fail("setTrackFlag", "value must be a boolean");
+    findTrackOrThrow("setTrackFlag", state, trackId);
+    return {
+        ...state,
+        tracks: state.tracks.map((t) => (t.id === trackId ? { ...t, [flag]: value } : t)),
+    };
+}
+
+/** 校验 SrtEntry 数组：形状、区间、重复 index（fail-closed）。 */
+function assertSubtitleEntries(op: string, entries: unknown): asserts entries is SrtEntry[] {
+    if (!Array.isArray(entries)) fail(op, "entries must be an array of SrtEntry");
+    const seen = new Set<number>();
+    for (const entry of entries) {
+        if (typeof entry !== "object" || entry === null) fail(op, "entries must contain SrtEntry objects");
+        const e = entry as SrtEntry;
+        if (!Number.isInteger(e.index) || e.index < 0) fail(op, `entry index must be a non-negative integer, got ${e.index}`);
+        if (seen.has(e.index)) fail(op, `duplicate entry index ${e.index}`);
+        seen.add(e.index);
+        if (!Number.isFinite(e.startMs) || e.startMs < 0) fail(op, `entry ${e.index} startMs must be a non-negative finite number`);
+        if (!Number.isFinite(e.endMs) || e.endMs <= e.startMs) fail(op, `entry ${e.index} endMs must be greater than startMs`);
+        if (typeof e.text !== "string") fail(op, `entry ${e.index} text must be a string`);
+    }
+}
+
+/**
+ * 从节点权威 subtitleEntries 重建字幕 clip（§3.1 快照契约：单向显式同步）。
+ * 移除 nodeId 名下全部过期字幕快照，按 entries 重建；id 确定（nodeId:subtitle:index），
+ * 重跑即原地替换，不产生漂移。缺省轨道取第一个字幕轨。
+ */
+function handleRebuildSubtitleClips(state: TimelineProject, payload: unknown): TimelineProject {
+    const { nodeId, entries, trackId } = payload as RebuildSubtitleClipsPayload;
+    if (typeof nodeId !== "string" || nodeId.length === 0) fail("rebuildSubtitleClips", "nodeId must be a non-empty string");
+    assertSubtitleEntries("rebuildSubtitleClips", entries);
+
+    const explicitTrack = trackId !== undefined ? findTrackOrThrow("rebuildSubtitleClips", state, trackId) : null;
+    if (explicitTrack && explicitTrack.kind !== "subtitle") fail("rebuildSubtitleClips", `track "${trackId}" is not a subtitle track`);
+    const subtitleTrack = explicitTrack ?? state.tracks.find((t) => t.kind === "subtitle");
+    if (!subtitleTrack) fail("rebuildSubtitleClips", "no subtitle track available");
+
+    const rebuilt: TimelineClip[] = entries.map((entry) => ({
+        id: `${nodeId}:subtitle:${entry.index}`,
+        kind: "subtitle" as const,
+        nodeId,
+        trackId: subtitleTrack.id,
+        startMs: entry.startMs,
+        durationMs: entry.endMs - entry.startMs,
+        subtitleEntryIndex: entry.index,
+        text: entry.text,
+    }));
+    const clips = [...state.clips.filter((c) => !(c.kind === "subtitle" && c.nodeId === nodeId)), ...rebuilt];
+    return withClips(state, clips);
+}
+
+// ---------------------------------------------------------------------------
+// 注册表
+// ---------------------------------------------------------------------------
+
+const BUILTIN_HANDLERS: ReadonlyArray<readonly [string, CommandHandler]> = [
+    ["addClip", handleAddClip],
+    ["moveClip", handleMoveClip],
+    ["trimClip", handleTrimClip],
+    ["splitClip", handleSplitClip],
+    ["removeClip", handleRemoveClip],
+    ["setClipProperty", handleSetClipProperty],
+    ["addSubtitle", handleAddSubtitle],
+    ["removeSubtitle", handleRemoveSubtitle],
+    ["addTrack", handleAddTrack],
+    ["removeTrack", handleRemoveTrack],
+    ["setTrackFlag", handleSetTrackFlag],
+    ["rebuildSubtitleClips", handleRebuildSubtitleClips],
+];
+
+/** 创建隔离的命令注册表（测试/黄金文件比对用独立实例）。 */
+export function createEditorCommandRegistry(): EditorCommandRegistry {
+    const handlers = new Map<string, CommandHandler>(BUILTIN_HANDLERS);
+    return {
+        register: (op, handler) => {
+            if (typeof op !== "string" || op.length === 0) throw new Error("edit command op must be a non-empty string");
+            handlers.set(op, handler);
+        },
+        apply: (state, cmd) => {
+            if (typeof cmd !== "object" || cmd === null || typeof cmd.op !== "string") {
+                throw new Error("edit command must be { op, payload }");
+            }
+            const handler = handlers.get(cmd.op);
+            if (!handler) throw new Error(`unknown edit command op "${cmd.op}"`);
+            return handler(state, cmd.payload);
+        },
+        knownOps: () => [...handlers.keys()],
+    };
+}
+
+// 宿主核心协议单例：编辑器 store、插件经宿主 API 均注册/消费此实例。
+let sharedRegistry: EditorCommandRegistry | null = null;
+export function getEditorCommandRegistry(): EditorCommandRegistry {
+    sharedRegistry ??= createEditorCommandRegistry();
+    return sharedRegistry;
+}
diff --git a/web/src/lib/timeline/editor-history.ts b/web/src/lib/timeline/editor-history.ts
new file mode 100644
index 000000000..ef1dbae01
--- /dev/null
+++ b/web/src/lib/timeline/editor-history.ts
@@ -0,0 +1,57 @@
+// 时间线快照撤销（ADR-0002）：有界 200 层 undo/redo 栈。
+// 纯函数式结构，便于 zustand 以 set(createEditorHistory(...)) 直接换新引用。
+// 快照依赖命令层不可变更新：历史中保存的是结构共享的全量对象，不做深拷贝。
+
+import type { TimelineProject } from "@/types/timeline";
+
+export const HISTORY_LIMIT = 200;
+
+export type EditorHistory = {
+    /** 栈底为最旧，栈顶（末尾）为最近一次历史。 */
+    undoStack: TimelineProject[];
+    redoStack: TimelineProject[];
+    current: TimelineProject;
+};
+
+export function createEditorHistory(initial: TimelineProject): EditorHistory {
+    return { undoStack: [], redoStack: [], current: initial };
+}
+
+/**
+ * 提交一次新状态：旧 current 入 undo 栈，清空 redo（新分支），
+ * 超过 HISTORY_LIMIT 时丢弃最旧快照。
+ */
+export function pushEditorHistory(history: EditorHistory, next: TimelineProject): EditorHistory {
+    const undoStack = [...history.undoStack, history.current];
+    if (undoStack.length > HISTORY_LIMIT) undoStack.shift();
+    return { undoStack, redoStack: [], current: next };
+}
+
+/** 无可撤销时返回 null（调用方保持当前状态不变）。 */
+export function undoEditorHistory(history: EditorHistory): EditorHistory | null {
+    const prev = history.undoStack.at(-1);
+    if (prev === undefined) return null;
+    return {
+        undoStack: history.undoStack.slice(0, -1),
+        redoStack: [...history.redoStack, history.current],
+        current: prev,
+    };
+}
+
+export function redoEditorHistory(history: EditorHistory): EditorHistory | null {
+    const next = history.redoStack.at(-1);
+    if (next === undefined) return null;
+    return {
+        undoStack: [...history.undoStack, history.current],
+        redoStack: history.redoStack.slice(0, -1),
+        current: next,
+    };
+}
+
+export function canUndo(history: EditorHistory): boolean {
+    return history.undoStack.length > 0;
+}
+
+export function canRedo(history: EditorHistory): boolean {
+    return history.redoStack.length > 0;
+}
diff --git a/web/src/lib/timeline/mock-transcription.ts b/web/src/lib/timeline/mock-transcription.ts
new file mode 100644
index 000000000..614c8b756
--- /dev/null
+++ b/web/src/lib/timeline/mock-transcription.ts
@@ -0,0 +1,36 @@
+// Mock 转写（M3.6）：M4 后端转写任务未就绪前，用确定性伪转写模拟 ASR 结果。
+// 同一 title + durationMs 永远生成相同的 SrtEntry[]，便于测试与回归；
+// M4 接真实任务客户端后本模块移除，UI 契约（SrtEntry[] 落字幕轨道）不变。
+
+import type { SrtEntry } from "@/types/timeline";
+
+const MOCK_CHUNK_MS = 1800;
+const MOCK_GAP_MS = 200;
+
+/** 从标题确定性生成一组模拟字幕条目（基于字符串 hash 稳定切分）。 */
+export function mockTranscriptionEntries(title: string, durationMs: number): SrtEntry[] {
+    const text = title.trim() || "未命名素材";
+    const chunks = splitStable(text, 6);
+    const usable = Math.max(1, Math.floor(durationMs / (MOCK_CHUNK_MS + MOCK_GAP_MS)));
+    const count = Math.min(chunks.length, usable);
+    const step = durationMs / count;
+
+    const entries: SrtEntry[] = [];
+    for (let i = 0; i < count; i += 1) {
+        const startMs = Math.round(i * step);
+        const endMs = Math.min(durationMs, Math.round(startMs + MOCK_CHUNK_MS));
+        if (endMs <= startMs) break;
+        entries.push({ index: i, startMs, endMs, text: chunks[i % chunks.length] });
+    }
+    return entries;
+}
+
+/** 稳定切分：按可打印字符逐段取满 maxLen，确定性无随机。 */
+function splitStable(text: string, maxLen: number): string[] {
+    const chars = Array.from(text);
+    const chunks: string[] = [];
+    for (let i = 0; i < chars.length; i += maxLen) {
+        chunks.push(chars.slice(i, i + maxLen).join(""));
+    }
+    return chunks;
+}
diff --git a/web/src/lib/timeline/timeline-summary.ts b/web/src/lib/timeline/timeline-summary.ts
new file mode 100644
index 000000000..1ddb90dc2
--- /dev/null
+++ b/web/src/lib/timeline/timeline-summary.ts
@@ -0,0 +1,72 @@
+// 时间线确定性摘要（Runbook M6.2）：把 TimelineProject v2 压缩成喂给 LLM 的中文上下文。
+// 同一输入永远产出同一输出（无时间戳/无随机），供命令引用 id 与 AI 面板上下文注入。
+
+import type { TimelineClip, TimelineProject, TimelineTrack } from "@/types/timeline";
+
+/** 片段逐行列出的上限；超出后折叠为一行汇总，防止超长时间线撑爆模型上下文。 */
+export const SUMMARY_MAX_CLIP_LINES = 60;
+/** 标题/文本在摘要中的最大展示长度。 */
+export const SUMMARY_MAX_TEXT_CHARS = 24;
+
+const KIND_LABELS: Record<string, string> = {
+    video: "视频",
+    audio: "音频",
+    subtitle: "字幕",
+    text: "文本",
+    image: "图片",
+};
+
+export function formatMs(ms: number): string {
+    const total = Math.max(0, Math.round(ms));
+    const s = Math.floor(total / 1000);
+    const m = Math.floor(s / 60);
+    const rem = s % 60;
+    return `${m}:${String(rem).padStart(2, "0")}`;
+}
+
+function clipLine(clip: TimelineClip): string {
+    const label = (clip.title || clip.text || "").trim().slice(0, SUMMARY_MAX_TEXT_CHARS);
+    const source = clip.directMedia?.title?.slice(0, SUMMARY_MAX_TEXT_CHARS) ?? "";
+    const text = label || source || clip.nodeId.slice(0, 12);
+    return `  - clip ${clip.id} | ${clip.kind} | 轨道 ${clip.trackId} | ${clip.startMs}-${clip.startMs + clip.durationMs}ms | ${text}`;
+}
+
+function trackLine(track: TimelineTrack): string {
+    const flags = [
+        track.visible === false ? "隐藏" : null,
+        track.muted ? "静音" : null,
+    ]
+        .filter(Boolean)
+        .join("/");
+    return `  - ${track.id} | ${KIND_LABELS[track.kind] ?? track.kind}轨 | ${track.label}${flags ? ` | ${flags}` : ""}`;
+}
+
+/** 生成中文时间线摘要（确定性、纯文本）。 */
+export function summarizeTimeline(project: TimelineProject): string {
+    const lines: string[] = [];
+    const subtitleClips = project.clips.filter((c) => c.kind === "subtitle");
+    const nodeIds = new Set(project.clips.map((c) => c.nodeId));
+    const directCount = project.clips.filter((c) => c.directMedia).length;
+
+    lines.push(`时间线：总时长 ${formatMs(project.durationMs)}，${project.tracks.length} 条轨道，${project.clips.length} 个片段（字幕 ${subtitleClips.length}，直连素材 ${directCount}，引用节点 ${nodeIds.size} 个）。`);
+    lines.push(`轨道（顺序从上到下）：`);
+    for (const track of [...project.tracks].sort((a, b) => a.order - b.order)) {
+        lines.push(trackLine(track));
+    }
+    lines.push(`片段：`);
+    if (project.clips.length === 0) {
+        lines.push(`  （空时间线）`);
+    } else {
+        const shown = project.clips.slice(0, SUMMARY_MAX_CLIP_LINES);
+        for (const clip of shown) {
+            lines.push(clipLine(clip));
+        }
+        const hidden = project.clips.length - shown.length;
+        if (hidden > 0) lines.push(`  …其余 ${hidden} 个片段省略`);
+    }
+    if (subtitleClips.length > 0) {
+        const totalChars = subtitleClips.reduce((sum, c) => sum + (c.text?.length ?? 0), 0);
+        lines.push(`字幕共 ${totalChars} 字。`);
+    }
+    return lines.join("\n");
+}
diff --git a/web/src/lib/timeline/timeline-view.ts b/web/src/lib/timeline/timeline-view.ts
index 8ac99d2fe..6e4624674 100644
--- a/web/src/lib/timeline/timeline-view.ts
+++ b/web/src/lib/timeline/timeline-view.ts
@@ -1,7 +1,7 @@
 // 时间线视图数学（移植自 lingji-cut 的 timeline-view.ts，按本项目类型精简）。
 // 提供缩放钳制、像素/毫秒换算、标尺刻度与时间格式化。
 
-const BASE_TIMELINE_PX_PER_SECOND = 96;
+export const BASE_TIMELINE_PX_PER_SECOND = 96;
 const MIN_TIMELINE_TRACK_WIDTH = 960;
 const MIN_TIMELINE_ZOOM = 0.02;
 const MAX_TIMELINE_ZOOM = 4;
@@ -21,6 +21,11 @@ export function getBaseTimelineWidth(durationMs: number): number {
     return Math.max(MIN_TIMELINE_TRACK_WIDTH, Math.ceil(Math.max(1_000, durationMs) / 1_000) * BASE_TIMELINE_PX_PER_SECOND);
 }
 
+/** 缩放级别对应的像素/毫秒。时间线面板用它做独立的等比映射，拖动片段时轨道随内容扩展，比例保持恒定。 */
+export function getTimelinePxPerMs(zoomLevel: number): number {
+    return (BASE_TIMELINE_PX_PER_SECOND * clampTimelineZoom(zoomLevel)) / 1_000;
+}
+
 export function getNextTimelineZoom(zoomLevel: number, direction: ZoomDirection): number {
     const nextZoom = direction === "in" ? zoomLevel * TIMELINE_ZOOM_STEP : zoomLevel / TIMELINE_ZOOM_STEP;
     return clampTimelineZoom(nextZoom);
diff --git a/web/src/pages/admin/plugins/plugins-page.tsx b/web/src/pages/admin/plugins/plugins-page.tsx
index c136cf9ae..30a799967 100644
--- a/web/src/pages/admin/plugins/plugins-page.tsx
+++ b/web/src/pages/admin/plugins/plugins-page.tsx
@@ -10,7 +10,7 @@ import { EAGLE_PLUGIN_ID } from "@/lib/plugins/builtin/eagle";
 import { PROMPT_OPTIMIZER_PLUGIN_ID } from "@/lib/plugins/builtin/prompt-optimizer";
 import { COMFYUI_PLUGIN_ID, RUNNINGHUB_PLUGIN_ID } from "@/lib/plugins/builtin/workflows";
 import { listRegisteredPlugins } from "@/lib/plugins/plugin-registry";
-import type { PluginManifest } from "@/lib/plugins/plugin-types";
+import type { PluginManifest, PluginManifestV2 } from "@/lib/plugins/plugin-types";
 import { fetchAdminPlugins, setPluginPlatformAvailability, uninstallPlugin, uploadPlugin, type AdminPluginState, type BackendPlugin, type PluginManagement } from "@/services/api/plugins";
 import { UploadPluginModal } from "@/pages/plugins/plugin-documentation-modals";
 
@@ -18,7 +18,7 @@ import { AdminPageFrame } from "../components/admin-shell";
 import { AdminDataTable, AdminStatusBadge, AdminTableEmpty } from "../components/admin-ui";
 
 type AdminPluginItem = {
-    manifest: PluginManifest;
+    manifest: PluginManifest | PluginManifestV2;
     source: string;
     management: PluginManagement;
     status?: string;
diff --git a/web/src/pages/plugins/index.tsx b/web/src/pages/plugins/index.tsx
index b1968f05c..1e3deb591 100644
--- a/web/src/pages/plugins/index.tsx
+++ b/web/src/pages/plugins/index.tsx
@@ -9,7 +9,7 @@ import { EAGLE_PLUGIN_ID } from "@/lib/plugins/builtin/eagle";
 import { PROMPT_OPTIMIZER_PLUGIN_ID } from "@/lib/plugins/builtin/prompt-optimizer";
 import { COMFYUI_PLUGIN_ID, RUNNINGHUB_PLUGIN_ID } from "@/lib/plugins/builtin/workflows";
 import { ART_CRITIQUE_PLUGIN_ID } from "@/lib/art-critique/contracts";
-import type { PluginManifest, RegisteredPlugin } from "@/lib/plugins/plugin-types";
+import type { PluginManifest, PluginManifestV2, RegisteredPlugin } from "@/lib/plugins/plugin-types";
 import { getEagleLibrary, type EagleFolder } from "@/services/api/eagle";
 import { fetchPlugins, setUserPluginEnabled, type BackendPlugin, type PluginState } from "@/services/api/plugins";
 import { useAppearanceStore } from "@/stores/use-appearance-store";
@@ -631,7 +631,7 @@ function pluginSourceLabel(plugin: RegisteredPlugin, state?: PluginState) {
     return "系统插件";
 }
 
-function contributionKindsFor(manifest: PluginManifest): string[] {
+function contributionKindsFor(manifest: PluginManifest | PluginManifestV2): string[] {
     const contributions = manifest.contributes;
     const kinds: string[] = [];
     if (contributions.providers?.length) kinds.push("provider");
@@ -647,11 +647,11 @@ function contributionKindsFor(manifest: PluginManifest): string[] {
     return kinds;
 }
 
-function providerCapabilitiesFor(manifest: PluginManifest) {
+function providerCapabilitiesFor(manifest: PluginManifest | PluginManifestV2) {
     return [...new Set((manifest.contributes.providers || []).flatMap((provider) => provider.capabilities))];
 }
 
-function pluginMatchesCategory(manifest: PluginManifest, category: string) {
+function pluginMatchesCategory(manifest: PluginManifest | PluginManifestV2, category: string) {
     const providerCapabilities = providerCapabilitiesFor(manifest);
     const isPaymentProtocol = Boolean(manifest.contributes.paymentProviders?.length);
     if (category === "payment") return isPaymentProtocol;
diff --git a/web/src/pages/plugins/plugin-documentation.ts b/web/src/pages/plugins/plugin-documentation.ts
index dacb4e4c4..cdab2ab36 100644
--- a/web/src/pages/plugins/plugin-documentation.ts
+++ b/web/src/pages/plugins/plugin-documentation.ts
@@ -1,4 +1,4 @@
-import type { PluginManifest } from "@/lib/plugins/plugin-types";
+import type { PluginManifest, PluginManifestV2 } from "@/lib/plugins/plugin-types";
 
 const permissionLabels: Record<string, string> = {
     "canvas.read": "读取画布",
@@ -12,7 +12,7 @@ const permissionLabels: Record<string, string> = {
     "external.open": "打开外部详情",
 };
 
-export function getPluginDocumentation(manifest: PluginManifest) {
+export function getPluginDocumentation(manifest: PluginManifest | PluginManifestV2) {
     if (manifest.documentation?.trim()) return manifest.documentation.trim();
 
     const capabilities = manifest.permissions.map((permission) => permissionLabels[permission] || permission);
diff --git a/web/src/pages/projects/detail.tsx b/web/src/pages/projects/detail.tsx
index d87e6f4c4..2de1fd217 100644
--- a/web/src/pages/projects/detail.tsx
+++ b/web/src/pages/projects/detail.tsx
@@ -1,6 +1,6 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { Alert, App, Button, Tooltip } from "antd";
-import { ArrowLeft, BookOpenText, Clapperboard, Images, LayoutDashboard, LayoutGrid, Plus, Settings2, type LucideIcon } from "lucide-react";
+import { Alert, App, Tooltip } from "antd";
+import { ArrowLeft, BookOpenText, Clapperboard, Images, LayoutDashboard, LayoutGrid, Plus, Scissors, Settings2, type LucideIcon } from "lucide-react";
 import { Link, Navigate, useNavigate, useParams } from "react-router";
 
 import { createCanvasProjectWithRemoteSync } from "@/services/user-data-sync";
@@ -17,17 +17,19 @@ import ProjectChaptersView from "./detail/chapters";
 import ProjectOverviewView from "./detail/overview";
 import ProjectSettingsView from "./detail/settings";
 import ProjectWorkflowView from "./detail/workflow";
+import ProjectEditorView from "./detail/editor";
 import { WorkflowChapterNavigator } from "./detail/workflow-chapter-navigator";
 
-type DetailView = "overview" | "chapters" | "workflow" | "canvases" | "assets" | "settings";
+type DetailView = "overview" | "chapters" | "workflow" | "canvases" | "editor" | "assets" | "settings";
 
-const views: Array<{ key: DetailView; label: string; shortLabel: string; icon: LucideIcon }> = [
-    { key: "overview", label: "制作概览", shortLabel: "概览", icon: LayoutDashboard },
-    { key: "chapters", label: "剧情章节", shortLabel: "章节", icon: BookOpenText },
-    { key: "workflow", label: "分镜制作", shortLabel: "分镜", icon: Clapperboard },
-    { key: "canvases", label: "项目画布", shortLabel: "画布", icon: LayoutGrid },
-    { key: "assets", label: "角色与资产", shortLabel: "资产", icon: Images },
-    { key: "settings", label: "项目设置", shortLabel: "设置", icon: Settings2 },
+const views: Array<{ key: DetailView; label: string; icon: LucideIcon }> = [
+    { key: "overview", label: "制作概览", icon: LayoutDashboard },
+    { key: "chapters", label: "剧情章节", icon: BookOpenText },
+    { key: "workflow", label: "分镜制作", icon: Clapperboard },
+    { key: "canvases", label: "项目画布", icon: LayoutGrid },
+    { key: "editor", label: "剪辑成片", icon: Scissors },
+    { key: "assets", label: "角色与资产", icon: Images },
+    { key: "settings", label: "项目设置", icon: Settings2 },
 ];
 
 export default function ProjectDetailPage() {
@@ -128,14 +130,15 @@ export default function ProjectDetailPage() {
             <div className="flex h-full min-h-0 flex-col">
                 {detail.project.status === "archived" ? <Alert type="warning" showIcon banner message="项目已归档，恢复后才能创建画布和生成任务" className="!border-x-0 !border-t-0" /> : null}
                 <main className="flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden">
-                    <div className={activeView === "chapters" || activeView === "workflow" ? "min-h-0 flex-1" : "thin-scrollbar min-h-0 flex-1 overflow-y-auto px-3 py-5 sm:px-5 lg:px-8 lg:py-7"}>
-                        <div className={activeView === "overview" ? "w-full" : activeView === "chapters" || activeView === "workflow" ? "h-full w-full" : "w-full"}>
+                    <div className={activeView === "chapters" || activeView === "workflow" || activeView === "editor" ? "min-h-0 flex-1" : "thin-scrollbar min-h-0 flex-1 overflow-y-auto px-3 py-5 sm:px-5 lg:px-8 lg:py-7"}>
+                        <div className={activeView === "overview" ? "w-full" : activeView === "chapters" || activeView === "workflow" || activeView === "editor" ? "h-full w-full" : "w-full"}>
                             {activeView === "overview" ? overviewQuery.isLoading ? <WorkspaceLoadingState label="正在统计制作进度" detail="只读取聚合数据，不加载全部镜头历史" /> : overviewQuery.data ? <ProjectOverviewView detail={detail} overview={overviewQuery.data} refreshProject={refreshProject} onCreateCanvas={createCanvas} /> : <WorkspaceErrorState title="制作概览读取失败" description="请稍后重试。" onRetry={() => void overviewQuery.refetch()} /> : null}
                             {activeView === "chapters" ? workspaceQuery.isLoading ? <WorkspaceLoadingState label="正在读取当前章节" detail="正文与制作数据按章节加载" /> : workspaceQuery.isError ? <WorkspaceErrorState title="章节读取失败" description="当前章节可能已被删除，或服务暂时不可用。" onRetry={() => void workspaceQuery.refetch()} /> : <ProjectChaptersView detail={detail} refreshProject={refreshProject} onCreateCanvas={createCanvas} /> : null}
                             {activeView === "workflow" ? workspaceQuery.isLoading ? <WorkspaceLoadingState label="正在读取当前章节分镜" detail="仅加载本章镜头、版本和产物" /> : workspaceQuery.isError ? <WorkspaceErrorState title="分镜工作区读取失败" description="当前章节制作数据暂时不可用。" onRetry={() => void workspaceQuery.refetch()} /> : <ProjectWorkflowView detail={detail} projectId={projectId} unitId={unitId || ""} stage={stage || "video"} /> : null}
                             {activeView === "canvases" ? <ProjectCanvasesView detail={detail} refreshProject={refreshProject} onCreateCanvas={createCanvas} /> : null}
                             {activeView === "assets" ? <ProjectAssetsView detail={detail} refreshProject={refreshProject} onCreateCanvas={createCanvas} /> : null}
                             {activeView === "settings" ? <ProjectSettingsView detail={detail} refreshProject={refreshProject} onCreateCanvas={createCanvas} /> : null}
+                            {activeView === "editor" ? <ProjectEditorView detail={detail} /> : null}
                         </div>
                     </div>
                 </main>
@@ -146,21 +149,38 @@ export default function ProjectDetailPage() {
 
 function ProjectWorkspaceTopBar({ detail, projectId, activeView, unitId, stage, chapterHref, workflowHref, onCreateCanvas }: { detail: ProjectDetail; projectId: string; activeView: DetailView; unitId?: string; stage?: string; chapterHref: string; workflowHref: string; onCreateCanvas: () => void }) {
     const navigate = useNavigate();
+    const createCanvasLabel = activeView === "chapters" && detail.units.length ? "新建当前章节画布" : "新建项目画布";
     return (
-        <div className="project-workspace-topbar flex min-w-0 items-center gap-2">
+        <div className="project-workspace-topbar flex min-w-0 translate-y-px items-center gap-2">
             <button type="button" onClick={() => navigate("/projects")} className="grid size-8 shrink-0 place-items-center rounded-md text-foreground/42 transition-colors hover:bg-surface-hover hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" aria-label="返回项目" title="返回项目"><ArrowLeft className="size-4" /></button>
             <div className="hidden min-w-0 items-center gap-2 md:flex lg:w-44 xl:w-56">
-                <h1 className="min-w-0 truncate text-[var(--fs-caption)] font-semibold text-foreground/90">{detail.project.name}</h1>
+                <h1 className="m-0! min-w-0 truncate text-[var(--fs-caption)] font-semibold text-foreground/90">{detail.project.name}</h1>
                 <span className={`size-1.5 shrink-0 rounded-full ${detail.project.status === "archived" ? "bg-foreground/30" : "bg-[var(--workspace-accent)]"}`} />
                 <span className="hidden shrink-0 text-[var(--fs-tiny)] text-foreground/42 xl:inline">{detail.project.status === "archived" ? "已归档" : "进行中"}</span>
             </div>
             <nav className="thin-scrollbar flex h-11 min-w-0 flex-1 items-center gap-0.5 overflow-x-auto" aria-label="项目导航">
-                {views.map((item) => { const Icon = item.icon; const active = item.key === activeView; const href = item.key === "chapters" ? chapterHref : item.key === "workflow" ? workflowHref : `/projects/${projectId}/${item.key}`; return <Link key={item.key} to={href} className={`relative flex h-8 shrink-0 items-center gap-1.5 rounded-md px-2 text-[var(--fs-caption)] transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring xl:px-2.5 ${active ? "bg-[var(--workspace-accent-soft)] font-medium text-foreground after:absolute after:inset-x-2.5 after:bottom-0 after:h-0.5 after:rounded-full after:bg-[var(--workspace-accent)]" : "text-foreground/52 hover:bg-surface-hover hover:text-foreground"}`} aria-current={active ? "page" : undefined}><Icon className={`size-3.5 shrink-0 ${active ? "text-[var(--workspace-accent)]" : "text-foreground/45"}`} /><span className="xl:hidden">{item.shortLabel}</span><span className="hidden xl:inline">{item.label}</span></Link>; })}
+                {views.map((item) => {
+                    const Icon = item.icon;
+                    const active = item.key === activeView;
+                    const href = item.key === "chapters" ? chapterHref : item.key === "workflow" ? workflowHref : `/projects/${projectId}/${item.key}`;
+                    return (
+                        <Tooltip key={item.key} title={item.label} mouseEnterDelay={0.15}>
+                            <Link
+                                to={href}
+                                aria-label={item.label}
+                                aria-current={active ? "page" : undefined}
+                                className={`relative grid size-8 shrink-0 place-items-center rounded-md transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ${active ? "bg-[var(--workspace-accent-soft)] text-[var(--workspace-accent)] after:absolute after:inset-x-2 after:bottom-0 after:h-0.5 after:rounded-full after:bg-[var(--workspace-accent)]" : "text-foreground/45 hover:bg-surface-hover hover:text-foreground"}`}
+                            >
+                                <Icon className="size-4" />
+                            </Link>
+                        </Tooltip>
+                    );
+                })}
             </nav>
             {activeView === "workflow" ? (
                 <WorkflowChapterNavigator projectId={projectId} units={detail.units} unitId={unitId} stage={stage} />
             ) : (
-                <Tooltip title={activeView === "chapters" && detail.units.length ? "新建当前章节画布" : "新建项目画布"}><Button size="small" className="!h-8 !shrink-0 !px-2 xl:!px-3" icon={<Plus className="size-3.5" />} onClick={onCreateCanvas} aria-label={activeView === "chapters" && detail.units.length ? "新建当前章节画布" : "新建项目画布"}><span className="hidden xl:inline">新建画布</span></Button></Tooltip>
+                <Tooltip title={createCanvasLabel} mouseEnterDelay={0.15}><button type="button" onClick={onCreateCanvas} className="grid size-8 shrink-0 place-items-center rounded-md text-foreground/42 transition-colors hover:bg-surface-hover hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" aria-label={createCanvasLabel}><Plus className="size-4" /></button></Tooltip>
             )}
         </div>
     );
diff --git a/web/src/pages/projects/detail/editor.tsx b/web/src/pages/projects/detail/editor.tsx
new file mode 100644
index 000000000..882856e1d
--- /dev/null
+++ b/web/src/pages/projects/detail/editor.tsx
@@ -0,0 +1,472 @@
+import { useEffect, useRef, useState } from "react";
+import {
+    AlertTriangle,
+    Check,
+    CircleDot,
+    Download,
+    Loader2,
+    Maximize,
+    Minimize,
+    PanelRightClose,
+    PanelRightOpen,
+    Redo2,
+    Sparkles,
+    Undo2,
+    X,
+} from "lucide-react";
+
+import type { ProjectAsset, ProjectDetail } from "@/services/api/projects";
+import { listProjectAssets } from "@/services/api/projects";
+import { useEditorSlots, type EditorSlotRegistration } from "@/lib/plugins/editor-slot-registry";
+import { pluginMayRenderEditorSlot } from "@/lib/plugins/plugin-permission-check";
+import { EditorStoreProvider } from "@/components/editor/editor-context";
+import { createEditorStore } from "@/stores/editor/editor-store";
+import { localForageStorageForScope } from "@/lib/localforage-storage";
+import { getActiveUserScope } from "@/lib/user-scope";
+import { normalizeTimelineProject } from "@/lib/timeline/timeline-tracks";
+import { formatTimelineTime } from "@/lib/timeline/timeline-view";
+import { useEditorStoreContext } from "@/components/editor/editor-context";
+import type { TimelineClip, TimelineProject } from "@/types/timeline";
+
+const EDITOR_TIMELINE_KEY = "editor-timeline";
+
+/** M2.4 演示种子：首次进入项目编辑器且无本地时间线时初始化一个可交互示例。
+ *  M4 接入真实数据源（画布节点 / 后端项目时间线）后移除。 */
+function createEditorSeed(projectId: string): TimelineProject {
+    const clips: TimelineClip[] = [
+        { id: `${projectId}:demo-v1`, kind: "video", nodeId: "demo-node-a", trackId: "video-1", startMs: 0, durationMs: 5000, sourceStartMs: 0, sourceDurationMs: 5000 },
+        { id: `${projectId}:demo-v2`, kind: "video", nodeId: "demo-node-b", trackId: "video-1", startMs: 6000, durationMs: 3000, sourceStartMs: 1000, sourceDurationMs: 8000 },
+        { id: `${projectId}:demo-a1`, kind: "audio", nodeId: "demo-node-a", trackId: "audio-1", startMs: 0, durationMs: 5000, sourceStartMs: 0, sourceDurationMs: 5000, volume: 0.8 },
+        { id: `${projectId}:demo-s1`, kind: "subtitle", nodeId: "demo-node-a", trackId: "subtitle-1", startMs: 500, durationMs: 2000, subtitleEntryIndex: 0, text: "示例字幕" },
+    ];
+    return normalizeTimelineProject({
+        version: 2,
+        tracks: [
+            { id: "video-1", kind: "video", label: "视频 1", order: 0 },
+            { id: "audio-1", kind: "audio", label: "音频 1", order: 1 },
+            { id: "subtitle-1", kind: "subtitle", label: "字幕 1", order: 2 },
+        ],
+        clips,
+        durationMs: 9000,
+    });
+}
+
+/** 插槽堆叠：渲染该区域权限通过的插槽贡献（fail-closed，M5.2）；
+ *  缺权限插件不渲染，改为一行诊断提示；无贡献时显示空态（停用插件可见）。 */
+function SlotStack({ slots, emptyHint }: { slots: EditorSlotRegistration[]; emptyHint: string }) {
+    const allowed = slots.filter((slot) => pluginMayRenderEditorSlot(slot.pluginId, slot.slot).allowed);
+    const denied = slots.filter((slot) => !pluginMayRenderEditorSlot(slot.pluginId, slot.slot).allowed);
+    if (allowed.length === 0 && denied.length === 0) {
+        return (
+            <div className="flex h-full min-h-0 flex-col items-center justify-center gap-3 px-4 text-center">
+                <p className="max-w-md text-sm text-[var(--director-dock-fg)]">{emptyHint}</p>
+            </div>
+        );
+    }
+    return (
+        <>
+            {allowed.map((slot) => (
+                <div key={slot.id} className="min-h-0 flex-1 overflow-hidden">
+                    {slot.render({ pluginId: slot.pluginId })}
+                </div>
+            ))}
+            {denied.map((slot) => {
+                const verdict = pluginMayRenderEditorSlot(slot.pluginId, slot.slot);
+                const missing =
+                    verdict.allowed === false && verdict.reason === "missing-permission" ? verdict.missing : null;
+                return (
+                    <div
+                        key={slot.id}
+                        title={`插件 ${slot.pluginId} 缺少 ${missing ?? "注册"}，已按 fail-closed 拒绝渲染`}
+                        className="flex min-h-8 shrink-0 items-center gap-2 bg-[var(--director-danger)]/10 px-3 text-[11px] text-[var(--director-danger)]"
+                    >
+                        <AlertTriangle className="size-3 shrink-0" />
+                        <span className="truncate">
+                            {missing
+                                ? `插件 ${slot.pluginId} 缺少 ${missing} 权限，已停用该面板。`
+                                : `插件 ${slot.pluginId} 未注册，已停用该面板。`}
+                        </span>
+                    </div>
+                );
+            })}
+        </>
+    );
+}
+
+/** 面板 Tab 条（Concat 式分类/属性切换）：只渲染激活槽，全部槽始终注册。 */
+function PanelTabs({
+    tabs,
+    active,
+    onChange,
+    trailing,
+}: {
+    tabs: { id: string; label: string }[];
+    active: string;
+    onChange: (id: string) => void;
+    trailing?: React.ReactNode;
+}) {
+    return (
+        <div className="flex h-9 shrink-0 items-center gap-0.5 border-b border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-1.5">
+            {tabs.map((tab) => (
+                <button
+                    key={tab.id}
+                    type="button"
+                    onClick={() => onChange(tab.id)}
+                    className={`h-7 rounded-md px-2.5 text-xs transition-colors ${
+                        active === tab.id
+                            ? "bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]"
+                            : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                    }`}
+                >
+                    {tab.label}
+                </button>
+            ))}
+            <div className="flex-1" />
+            {trailing}
+        </div>
+    );
+}
+
+/** 顶部工具栏（Concat 主菜单区）：项目名 + 全局撤销/重做 + 保存状态 + 导出主按钮。 */
+function EditorTopBar({
+    onExport,
+    isFullscreen,
+    onToggleFullscreen,
+    aiOpen,
+    onToggleAi,
+}: {
+    onExport: () => void;
+    isFullscreen: boolean;
+    onToggleFullscreen: () => void;
+    aiOpen: boolean;
+    onToggleAi: () => void;
+}) {
+    const { project, history, isDirty, saving, saveError, undo, redo } = useEditorStoreContext();
+    const canUndo = (history?.undoStack.length ?? 0) > 0;
+    const canRedo = (history?.redoStack.length ?? 0) > 0;
+
+    return (
+        <header className="flex h-12 shrink-0 items-center gap-2 border-b border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-3">
+            <button
+                type="button"
+                aria-label="撤销"
+                title="撤销（Cmd/Ctrl+Z）"
+                onClick={undo}
+                disabled={!canUndo}
+                className="grid size-8 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-35"
+            >
+                <Undo2 className="size-4" />
+            </button>
+            <button
+                type="button"
+                aria-label="重做"
+                title="重做（Cmd/Ctrl+Shift+Z）"
+                onClick={redo}
+                disabled={!canRedo}
+                className="grid size-8 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] disabled:pointer-events-none disabled:opacity-35"
+            >
+                <Redo2 className="size-4" />
+            </button>
+            <div className="flex-1" />
+            <div className="flex items-center gap-1.5">
+                <span className="grid size-8 place-items-center" title={saveError ?? (saving ? "保存中" : isDirty ? "有未保存的更改" : "已保存")}>
+                    {saveError ? (
+                        <AlertTriangle className="size-4 text-[var(--director-danger)]" aria-label="保存失败" />
+                    ) : saving ? (
+                        <Loader2 className="size-4 animate-spin text-[var(--director-dock-fg)]" aria-label="保存中" />
+                    ) : isDirty ? (
+                        <CircleDot className="size-3.5 text-[var(--director-warning)]" aria-label="未保存" />
+                    ) : (
+                        <Check className="size-4 text-[var(--director-success)]" aria-label="已保存" />
+                    )}
+                </span>
+                <button
+                    type="button"
+                    aria-label="AI 剪辑助手"
+                    aria-pressed={aiOpen}
+                    title="AI 剪辑助手（编辑意图转时间线指令）"
+                    onClick={onToggleAi}
+                    className={`grid size-8 place-items-center rounded-md transition-colors ${
+                        aiOpen
+                            ? "bg-[var(--director-dock-active-surface)] text-[var(--director-dock-fg-strong)]"
+                            : "text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                    }`}
+                >
+                    <Sparkles className="size-4" />
+                </button>
+                <button
+                    type="button"
+                    aria-label={isFullscreen ? "退出全屏" : "全屏编辑"}
+                    title={isFullscreen ? "退出全屏（Esc）" : "全屏编辑"}
+                    onClick={onToggleFullscreen}
+                    className="grid size-8 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                >
+                    {isFullscreen ? <Minimize className="size-4" /> : <Maximize className="size-4" />}
+                </button>
+                <button
+                    type="button"
+                    aria-label="导出"
+                    title="导出"
+                    onClick={onExport}
+className="grid size-8 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)] hover:text-[var(--director-dock-fg-strong)]"
+                >
+                    <Download className="size-4" />
+                </button>
+            </div>
+        </header>
+    );
+}
+
+/** 底部状态栏：时长 / 片段数 / 轨道数 / 快捷键提示。 */
+function EditorStatusBar({ projectName }: { projectName: string }) {
+    const { project } = useEditorStoreContext();
+    const clipCount = project?.clips.length ?? 0;
+    const trackCount = project?.tracks.length ?? 0;
+    const durationMs = project?.durationMs ?? 0;
+
+    return (
+        <footer className="flex h-7 shrink-0 items-center gap-4 border-t border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface-raised)] px-3 text-[10px] text-[var(--director-dock-fg)]">
+            <span className="truncate text-[var(--director-dock-fg-strong)]">{projectName}</span>
+            <span className="tabular-nums">时长 {formatTimelineTime(durationMs)}</span>
+            <span>片段 {clipCount}</span>
+            <span>轨道 {trackCount}</span>
+            <div className="flex-1" />
+            <span className="hidden sm:inline">⌘Z 撤销 · ⇧⌘Z 重做 · 拖拽移动 / 边缘裁剪片段</span>
+        </footer>
+    );
+}
+
+export default function ProjectEditorView({ detail }: { detail: ProjectDetail }) {
+    // 插槽注册（全部 8 种始终注册；左/右栏 Tab 决定当前渲染哪个）。
+    const previewSlots = useEditorSlots("preview-renderer");
+    const timelineSlots = useEditorSlots("timeline-panel");
+    const assetSlots = useEditorSlots("asset-ingest");
+    const transcriptionSlots = useEditorSlots("transcription-provider");
+    const inspectorSlots = useEditorSlots("inspector");
+    const subtitleSlots = useEditorSlots("subtitle-tool");
+    const exportSlots = useEditorSlots("export-renderer");
+    const aiSlots = useEditorSlots("ai-assistant");
+
+    const [leftTab, setLeftTab] = useState("asset");
+    const [rightTab, setRightTab] = useState("inspector");
+
+    const [rightCollapsed, setRightCollapsed] = useState(false);
+    const [assets, setAssets] = useState<ProjectAsset[]>(detail.assets);
+    const workbenchRef = useRef<HTMLDivElement | null>(null);
+    const [isFullscreen, setIsFullscreen] = useState(false);
+    // AI 助手浮层（顶部工具按钮触发，M6.3；Esc / 点击遮罩关闭）。
+    const [aiOpen, setAiOpen] = useState(false);
+    useEffect(() => {
+        if (!aiOpen) return;
+        const onKey = (e: KeyboardEvent) => {
+            if (e.key === "Escape") setAiOpen(false);
+        };
+        window.addEventListener("keydown", onKey);
+        return () => window.removeEventListener("keydown", onKey);
+    }, [aiOpen]);
+
+    // 底部时间线高度（px）：分隔条拖拽调整（120–480）。
+    const [timelineH, setTimelineH] = useState(240);
+    const splitterRef = useRef<{ startY: number; startH: number } | null>(null);
+
+    const refreshAssets = async () => {
+        try {
+            setAssets((await listProjectAssets(projectId)).assets);
+        } catch {
+            // 刷新失败保留现有列表；导入面板内联提示错误
+        }
+    };
+
+    useEffect(() => {
+        const onFsChange = () => setIsFullscreen(document.fullscreenElement === workbenchRef.current);
+        document.addEventListener("fullscreenchange", onFsChange);
+        return () => document.removeEventListener("fullscreenchange", onFsChange);
+    }, []);
+
+    const toggleFullscreen = () => {
+        if (document.fullscreenElement) {
+            void document.exitFullscreen().catch(() => {});
+        } else {
+            void workbenchRef.current?.requestFullscreen().catch(() => {});
+        }
+    };
+
+    const scope = getActiveUserScope();
+    const projectId = detail.project.id;
+
+    const store = useState(() =>
+        createEditorStore({
+            saveTimeline: async (project: TimelineProject) => {
+                await localForageStorageForScope(scope).setItem(`${EDITOR_TIMELINE_KEY}:${projectId}`, JSON.stringify(project));
+            },
+        }),
+    )[0];
+
+    // 进入编辑器时加载本地时间线；无则初始化演示种子（不触发保存，历史从该状态起步）。
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            const storage = localForageStorageForScope(scope);
+            const raw = await storage.getItem(`${EDITOR_TIMELINE_KEY}:${projectId}`);
+            const loaded = raw ? normalizeTimelineProject(JSON.parse(raw)) : createEditorSeed(projectId);
+            if (!cancelled) store.getState().load(loaded);
+        })();
+        return () => {
+            cancelled = true;
+            // 卸载前冲刷尚未落盘的改动（如切页发生在防抖窗口内），避免最后几次操作丢失。
+            void store.getState().flushSave?.().catch(() => {});
+        };
+    }, [scope, projectId, store]);
+
+    return (
+        <EditorStoreProvider store={store} host={{ projectId, assets, refreshAssets }}>
+            <div ref={workbenchRef} className="editor-workbench relative flex h-full min-h-0 flex-col bg-[var(--director-workspace-bg)]">
+                <EditorTopBar
+                    onExport={() => setRightTab("export")}
+                    isFullscreen={isFullscreen}
+                    onToggleFullscreen={toggleFullscreen}
+                    aiOpen={aiOpen}
+                    onToggleAi={() => setAiOpen((v) => !v)}
+                />
+                {/* AI 助手浮层：常驻挂载、随开关显隐，关闭再开保留会话与输入（状态在 SlotStack 内）。 */}
+                <div className={aiOpen ? "contents" : "hidden"}>
+                    <button
+                        type="button"
+                        aria-label="关闭 AI 助手"
+                        tabIndex={-1}
+                        className="fixed inset-0 z-30 cursor-default bg-transparent"
+                        onClick={() => setAiOpen(false)}
+                    />
+                    <div className="absolute right-2 top-14 z-40 flex h-[640px] max-h-[calc(100%-3.75rem)] w-[460px] max-w-[calc(100vw-1rem)] flex-col overflow-hidden rounded-xl border border-[var(--director-sequencer-border)] bg-[var(--director-sequencer-surface)] shadow-[0_12px_40px_rgba(0,0,0,0.5)]">
+                        <div className="flex h-10 shrink-0 items-center gap-2 border-b border-[var(--director-sequencer-border)] px-3">
+                            <Sparkles className="size-4 text-[var(--director-dock-fg)]/80" />
+                            <span className="text-xs font-medium text-[var(--director-dock-fg-strong)]">AI 剪辑助手</span>
+                            <span className="hidden truncate text-[10px] text-[var(--director-dock-fg)]/45 sm:inline">
+                                编辑意图 → 时间线指令（宿主校验）
+                            </span>
+                            <div className="flex-1" />
+                            <button
+                                type="button"
+                                aria-label="关闭"
+                                title="关闭（Esc）"
+                                onClick={() => setAiOpen(false)}
+                                className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                            >
+                                <X className="size-4" />
+                            </button>
+                        </div>
+                        <div className="flex min-h-0 flex-1 flex-col overflow-hidden">
+                            <SlotStack slots={aiSlots} emptyHint="AI 助手插件未加载。" />
+                        </div>
+                    </div>
+                </div>
+
+                <div className="flex min-h-0 flex-1 flex-col gap-2 p-2">
+                    {/* 上区：左栏 + 预览 + 右栏 */}
+                    <div className="flex min-h-0 flex-1 gap-2">
+                        {/* 左栏：素材 / 转写（Tab 化） */}
+                        <aside className="flex h-full w-64 shrink-0 flex-col overflow-hidden rounded-xl bg-[var(--director-sequencer-surface)] shadow-[0_1px_2px_rgba(0,0,0,0.3)]">
+                            <PanelTabs
+                                tabs={[
+                                    { id: "asset", label: "素材" },
+                                    { id: "transcription", label: "转写" },
+                                ]}
+                                active={leftTab}
+                                onChange={setLeftTab}
+                            />
+                            {leftTab === "asset" ? (
+                                <SlotStack slots={assetSlots} emptyHint="素材库插件未加载。" />
+                            ) : (
+                                <SlotStack slots={transcriptionSlots} emptyHint="转写插件未加载。" />
+                            )}
+                        </aside>
+
+                        {/* 中栏：预览（占满剩余高度） */}
+                        <main className="flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden rounded-xl bg-[var(--director-sequencer-surface)] shadow-[0_1px_2px_rgba(0,0,0,0.3)]">
+                            <SlotStack slots={previewSlots} emptyHint="预览插件未加载。" />
+                        </main>
+
+                        {/* 右栏：检查 / 字幕 / 导出（Tab 化，可折叠为窄条；AI 助手已移至顶栏浮层） */}
+                        {rightCollapsed ? (
+                            <aside className="flex h-full w-9 shrink-0 flex-col items-center overflow-hidden rounded-xl bg-[var(--director-sequencer-surface)] shadow-[0_1px_2px_rgba(0,0,0,0.3)]">
+                                <button
+                                    type="button"
+                                    aria-label="展开检查器"
+                                    title="展开检查器"
+                                    onClick={() => setRightCollapsed(false)}
+                                    className="mt-1.5 grid size-8 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                                >
+                                    <PanelRightOpen className="size-4" />
+                                </button>
+                            </aside>
+                        ) : (
+                            <aside className="flex h-full w-80 shrink-0 flex-col overflow-hidden rounded-xl bg-[var(--director-sequencer-surface)] shadow-[0_1px_2px_rgba(0,0,0,0.3)]">
+                                <PanelTabs
+                                    tabs={[
+                                        { id: "inspector", label: "检查" },
+                                        { id: "subtitle", label: "字幕" },
+                                        { id: "export", label: "导出" },
+                                    ]}
+                                    active={rightTab}
+                                    onChange={setRightTab}
+                                    trailing={
+                                        <button
+                                            type="button"
+                                            aria-label="折叠检查器"
+                                            title="折叠检查器"
+                                            onClick={() => setRightCollapsed(true)}
+                                            className="grid size-7 place-items-center rounded-md text-[var(--director-dock-fg)] hover:bg-[var(--director-control-hover)]"
+                                        >
+                                            <PanelRightClose className="size-3.5" />
+                                        </button>
+                                    }
+                                />
+                                {rightTab === "inspector" ? (
+                                    <SlotStack slots={inspectorSlots} emptyHint="检查器插件未加载。" />
+                                ) : rightTab === "subtitle" ? (
+                                    <SlotStack slots={subtitleSlots} emptyHint="字幕工具插件未加载。" />
+                                ) : (
+                                    <SlotStack slots={exportSlots} emptyHint="导出插件未加载。" />
+                                )}
+                            </aside>
+                        )}
+                    </div>
+
+                    {/* 预览/时间线拖拽分隔条（pointer capture，data-canvas-no-zoom 防画布缩放） */}
+                    <div
+                        className="group relative z-10 -my-1 flex h-3 shrink-0 cursor-row-resize touch-none items-center justify-center"
+                        role="separator"
+                        aria-orientation="horizontal"
+                        aria-label="调整时间线高度"
+                        data-canvas-no-zoom
+                        onPointerDown={(e) => {
+                            splitterRef.current = { startY: e.clientY, startH: timelineH };
+                            e.currentTarget.setPointerCapture(e.pointerId);
+                        }}
+                        onPointerMove={(e) => {
+                            const drag = splitterRef.current;
+                            if (!drag) return;
+                            const next = drag.startH - (e.clientY - drag.startY);
+                            setTimelineH(Math.min(480, Math.max(120, next)));
+                        }}
+                        onPointerUp={() => {
+                            splitterRef.current = null;
+                        }}
+                        onPointerCancel={() => {
+                            splitterRef.current = null;
+                        }}
+                    >
+                        <div className="h-1 w-10 rounded-full bg-[var(--director-sequencer-border)] transition-colors group-hover:bg-[var(--director-dock-fg-strong)]/60" />
+                    </div>
+
+                    {/* 时间线：横跨编辑面板全宽（左栏到右栏） */}
+                    <div className="flex h-full shrink-0 flex-col overflow-hidden rounded-xl bg-[var(--director-sequencer-surface)] shadow-[0_1px_2px_rgba(0,0,0,0.3)]" style={{ height: `${timelineH}px` }}>
+                        <SlotStack slots={timelineSlots} emptyHint="时间线面板插件未加载。" />
+                    </div>
+                </div>
+
+                <EditorStatusBar projectName={detail.project.name} />
+            </div>
+        </EditorStoreProvider>
+    );
+}
diff --git a/web/src/pages/projects/detail/overview.tsx b/web/src/pages/projects/detail/overview.tsx
index dd5abb0f5..1de926286 100644
--- a/web/src/pages/projects/detail/overview.tsx
+++ b/web/src/pages/projects/detail/overview.tsx
@@ -1,4 +1,4 @@
-import { ArrowRight, BookOpenText, CheckCircle2, CircleAlert, Clapperboard, Clock3, Film, PackageCheck, PlaySquare, UsersRound } from "lucide-react";
+import { ArrowRight, BookOpenText, CheckCircle2, CircleAlert, Clapperboard, Clock3, Film, PackageCheck, PlaySquare, Scissors, UsersRound } from "lucide-react";
 import { Link } from "react-router";
 
 import { WorkspaceState } from "@/components/layout/workspace-state";
@@ -32,6 +32,7 @@ export default function ProjectOverviewView({ detail, overview }: ProjectDetailV
         { id: "storyboard", icon: Clapperboard, label: "分镜脚本与画面", description: "拆分镜头并确认构图、对白和时长", metric: `${metrics.shotCount} 镜 · ${metrics.readyStoryboardCount} 张图`, href: workflowHref("storyboard"), complete: metrics.shotCount > 0 },
         { id: "previz", icon: PlaySquare, label: "动作预演", description: "检查表演节拍、运镜和连续性", metric: `${metrics.readyPrevizCount}/${metrics.shotCount || 0} 镜`, href: workflowHref("previz"), complete: metrics.shotCount > 0 && metrics.readyPrevizCount === metrics.shotCount },
         { id: "video", icon: Film, label: "镜头视频", description: "逐镜生成、筛选版本并锁定成片", metric: `${metrics.readyVideoCount}/${metrics.shotCount || 0} 镜`, href: workflowHref("video"), complete: metrics.shotCount > 0 && metrics.readyVideoCount === metrics.shotCount },
+        { id: "editor", icon: Scissors, label: "剪辑成片", description: "在时间线中编排镜头、添加字幕并输出成片", metric: metrics.shotCount > 0 && metrics.readyVideoCount === metrics.shotCount ? "可以开始剪辑" : `还差 ${Math.max(0, metrics.shotCount - metrics.readyVideoCount)} 镜`, href: `/projects/${project.id}/editor`, complete: false },
         { id: "delivery", icon: PackageCheck, label: "交付与打包", description: "检查缺失镜头并整理最终产物", metric: metrics.readyVideoCount && metrics.readyVideoCount === metrics.shotCount ? "可以交付" : `还差 ${Math.max(0, metrics.shotCount - metrics.readyVideoCount)} 镜`, href: workflowHref("delivery"), complete: metrics.shotCount > 0 && metrics.readyVideoCount === metrics.shotCount },
     ];
     const gaps = [
diff --git a/web/src/pages/projects/index.tsx b/web/src/pages/projects/index.tsx
index 69075a02c..4aca4bf0c 100644
--- a/web/src/pages/projects/index.tsx
+++ b/web/src/pages/projects/index.tsx
@@ -274,7 +274,7 @@ export default function ProjectsPage() {
                 onClose={() => setStylePickerOpen(false)}
                 onSelect={(preset) => { setSelectedStyle(preset); setStylePickerOpen(false); }}
             />
-            <Modal className="library-modal" title="AI 生成章节" open={generating} footer={null} closable={false} maskClosable={false} keyboard={false} width={760}>
+            <Modal className="library-modal" title="AI 生成章节" open={generating} footer={null} closable={false} mask={{ closable: false }} keyboard={false} width={760}>
                 <div className="app-story-generating">
                     <div className="app-story-generating-head">
                         <span className="app-story-generating-mark"><Sparkles className="size-4" /></span>
diff --git a/web/src/pages/skills/skill-editor-drawer.tsx b/web/src/pages/skills/skill-editor-drawer.tsx
index 044f6d453..601932e46 100644
--- a/web/src/pages/skills/skill-editor-drawer.tsx
+++ b/web/src/pages/skills/skill-editor-drawer.tsx
@@ -97,7 +97,7 @@ export function SkillEditorDrawer({ open, skill, onClose, onSaved }: { open: boo
     };
 
     return (
-        <Drawer className="library-drawer" open={open} size={720} destroyOnHidden maskClosable={!dirty} title={skill ? "编辑技能" : "创建技能"} onClose={requestClose} extra={<Button type="primary" loading={saving} icon={<Save className="size-4" />} onClick={() => form.submit()}>保存技能</Button>}>
+        <Drawer className="library-drawer" open={open} size={720} destroyOnHidden mask={{ closable: !dirty }} title={skill ? "编辑技能" : "创建技能"} onClose={requestClose} extra={<Button type="primary" loading={saving} icon={<Save className="size-4" />} onClick={() => form.submit()}>保存技能</Button>}>
             {!isPackageSkill ? <div className="mb-4 rounded-xl border bg-foreground/[.02] p-3">
                 <div className="mb-2 flex items-center gap-1.5 text-sm font-medium">
                     <Wand2 className="size-4" />
diff --git a/web/src/pages/skills/skill-install-modal.tsx b/web/src/pages/skills/skill-install-modal.tsx
index df622663e..d514a9d86 100644
--- a/web/src/pages/skills/skill-install-modal.tsx
+++ b/web/src/pages/skills/skill-install-modal.tsx
@@ -79,7 +79,7 @@ export function SkillInstallModal({ open, onClose, onInstalled, onManualCreate }
             open={open}
             width={680}
             destroyOnHidden
-            maskClosable={!installing}
+            mask={{ closable: !installing }}
             title="安装技能"
             onCancel={onClose}
             footer={(
diff --git a/web/src/services/api/projects.ts b/web/src/services/api/projects.ts
index e59c73be1..6a5ccac88 100644
--- a/web/src/services/api/projects.ts
+++ b/web/src/services/api/projects.ts
@@ -65,9 +65,11 @@ export type ProjectAsset = {
     folderId?: string;
     position: number;
     storageKey?: string;
+    durationMs?: number;
     previewText?: string;
     updatedAt: string;
     character?: CharacterCardSummary;
+    source?: string;
 };
 
 export type ProjectAssetFolder = {
@@ -477,7 +479,7 @@ export function unlinkCanvasProject(projectId: string, canvasId: string) {
     return request<{ canvasId: string }>(api.delete(`/projects/${encodeURIComponent(projectId)}/canvases/${encodeURIComponent(canvasId)}`));
 }
 
-export function linkProjectAsset(projectId: string, input: { assetId: string; category: AssetCategory; folderId?: string }, signal?: AbortSignal) {
+export function linkProjectAsset(projectId: string, input: { assetId: string; category: AssetCategory; folderId?: string; title?: string }, signal?: AbortSignal) {
     return request<{ asset: ProjectAsset }>(api.post(`/projects/${encodeURIComponent(projectId)}/assets`, input, { signal }));
 }
 
diff --git a/web/src/services/api/resources.ts b/web/src/services/api/resources.ts
index bad4f4c9a..f81e70be1 100644
--- a/web/src/services/api/resources.ts
+++ b/web/src/services/api/resources.ts
@@ -19,7 +19,10 @@ export type RemoteResource = {
     height?: number;
     durationMs?: number;
     etag?: string;
-    error?: string;
+	playbackStatus?: string;
+	playbackObjectKey?: string;
+	playbackError?: string;
+	error?: string;
     createdAt: string;
     updatedAt: string;
 };
@@ -62,7 +65,7 @@ export type ArkPrivateAssetSync = {
     status: "active" | string;
 };
 
-type ResourceUploadMeta = {
+export type ResourceUploadMeta = {
     width?: number;
     height?: number;
     durationMs?: number;
@@ -111,17 +114,82 @@ export function isResourceUrl(url?: string) {
     return path.startsWith(`${base}/resources/`) && path.endsWith("/file");
 }
 
-export async function uploadResourceFile(file: Blob, kind: "image" | "video" | "audio" | "file", meta?: ResourceUploadMeta) {
-    const formData = new FormData();
+// 超过该阈值（与后端单请求 multipart 上限 50MB 一致）的本地媒体走分片上传，避免大视频导入失败。
+const CHUNK_UPLOAD_THRESHOLD = 50 << 20;
+const CHUNK_UPLOAD_RETRIES = 2;
+
+export async function uploadResourceFile(
+    file: Blob,
+    kind: "image" | "video" | "audio" | "file",
+    meta?: ResourceUploadMeta,
+    onProgress?: (uploadedBytes: number, totalBytes: number) => void,
+): Promise<RemoteResource> {
     const name = meta?.fileName || (file instanceof File ? file.name : `${kind}.${extensionFromMime(file.type, kind)}`);
+    if (file.size > CHUNK_UPLOAD_THRESHOLD) {
+        const resource = await uploadFileInChunks(file, name, kind, meta, onProgress);
+        resourceCache.set(resourceCacheKey(resource.id), resource);
+        return resource;
+    }
+    const formData = new FormData();
     formData.append("kind", kind);
     formData.append("file", file, name);
     if (meta?.width) formData.append("width", String(Math.round(meta.width)));
     if (meta?.height) formData.append("height", String(Math.round(meta.height)));
     if (meta?.durationMs) formData.append("durationMs", String(Math.round(meta.durationMs)));
-    const data = await request<{ resource: RemoteResource }>(api.post("/resources", formData, uploadRequestConfig(meta?.idempotencyKey)));
-    resourceCache.set(resourceCacheKey(data.resource.id), data.resource);
-    return data.resource;
+    try {
+        const data = await request<{ resource: RemoteResource }>(api.post("/resources", formData, uploadRequestConfig(meta?.idempotencyKey)));
+        resourceCache.set(resourceCacheKey(data.resource.id), data.resource);
+        return data.resource;
+    } catch (error) {
+        throw normalizeUploadError(error);
+    }
+}
+
+// 分片上传：POST 开始会话 → 逐片 PUT 原始二进制（每片 8MB）→ POST 合并落库。
+// 单请求体积小、可断点续传/失败重试；单文件不再受 50MB 限制（仅日/总量配额约束）。
+async function uploadFileInChunks(file: Blob, name: string, kind: "image" | "video" | "audio" | "file", meta: ResourceUploadMeta | undefined, onProgress?: (uploadedBytes: number, totalBytes: number) => void) {
+    // 片级失败通常意味着会话过期/网络抖动：整体重开一次会话重传（整传重试）。
+    for (let attempt = 0; attempt < CHUNK_UPLOAD_RETRIES; attempt++) {
+        try {
+            return await runChunkedUpload(file, name, kind, meta, onProgress);
+        } catch (error) {
+            if (attempt === CHUNK_UPLOAD_RETRIES - 1) throw error;
+        }
+    }
+    throw new Error("上传失败");
+}
+
+async function runChunkedUpload(file: Blob, name: string, kind: "image" | "video" | "audio" | "file", meta: ResourceUploadMeta | undefined, onProgress?: (uploadedBytes: number, totalBytes: number) => void) {
+    const session = await request<{ uploadId: string; chunkSize: number; chunkCount: number }>(
+        api.post("/resources/uploads", { fileName: name, kind, size: file.size, width: meta?.width, height: meta?.height, durationMs: meta?.durationMs }, uploadRequestConfig(meta?.idempotencyKey)),
+    );
+    for (let index = 0; index < session.chunkCount; index++) {
+        const start = index * session.chunkSize;
+        const end = Math.min(file.size, start + session.chunkSize);
+        const blob = file.slice(start, end);
+        const data = new FormData();
+        data.append("chunk", blob);
+        // raw 二进制直传，与后端按裸 body 逐片落盘对齐（勿设手动 Content-Type，让 axios 处理）。
+        await request<{ index: number }>(api.put(`/resources/uploads/${encodeURIComponent(session.uploadId)}/chunks/${index}`, blob, { headers: { "Content-Type": "application/octet-stream" } }));
+        onProgress?.(Math.min(end, file.size), file.size);
+    }
+    const complete = await request<{ resource: RemoteResource }>(api.post(`/resources/uploads/${encodeURIComponent(session.uploadId)}/complete`));
+    return complete.resource;
+}
+
+function normalizeUploadError(error: unknown): Error {
+    // 兜底：即使误超 50MB multipart 上限（http.MaxBytesError），也给出可读中文而非英文裸错。
+    if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const message = error.response?.data as { msg?: string } | undefined;
+        const msg = message?.msg || "";
+        if (status === 400 && /body too large|MaxBytes/i.test(msg)) {
+            return new Error("文件过大，请使用小于 50MB 的文件或稍后重试");
+        }
+        if (msg) return new Error(msg);
+        if (status === 413) return new Error("文件过大，无法上传");
+    }
+    return error instanceof Error ? error : new Error("上传失败");
 }
 
 export async function importResourceFromUrl(url: string, kind: "image" | "video" | "audio" | "file", meta?: Omit<ResourceUploadMeta, "fileName">) {
@@ -156,6 +224,17 @@ export function getResource(id: string): Promise<RemoteResource> {
     return task;
 }
 
+// refreshResource 绕过缓存强制拉取资源最新状态（转码副本就绪轮询用），并回写缓存。
+export function refreshResource(id: string): Promise<RemoteResource> {
+    const cacheKey = resourceCacheKey(id);
+    return request<{ resource: RemoteResource }>(api.get(`/resources/${encodeURIComponent(id)}`))
+        .then((data) => {
+            resourceCache.set(cacheKey, data.resource);
+            missingResourceIds.delete(cacheKey);
+            return data.resource;
+        });
+}
+
 export async function getResourceOSSUrl(storageKey?: string) {
     const id = resourceIdFromStorageKey(storageKey);
     if (!id) throw new Error("当前媒体尚未上传到后端资源存储");
@@ -190,6 +269,13 @@ export function resolveResourceUrl(storageKey?: string, fallback = "") {
     return id ? resourceFileUrl(id) : fallback;
 }
 
+// playbackVariantUrl 返回浏览器兼容播放副本 URL（H.265→H.264 转码结果）。
+// 副本就绪前由后端回退原件，调用方再按需降级。
+export function playbackVariantUrl(id: string) {
+    const base = String(apiBaseURL).replace(/\/+$/, "");
+    return `${base}/resources/${encodeURIComponent(id)}/file?variant=playback`;
+}
+
 export async function getResourceBlob(storageKey: string) {
     const id = resourceIdFromStorageKey(storageKey);
     if (!id) return null;
diff --git a/web/src/services/api/timeline-tasks.ts b/web/src/services/api/timeline-tasks.ts
new file mode 100644
index 000000000..ae3edaaa8
--- /dev/null
+++ b/web/src/services/api/timeline-tasks.ts
@@ -0,0 +1,60 @@
+import { apiClient, request } from "@/services/api/request";
+import type { GenerationTask } from "@/services/api/task-center";
+import type { TimelineProject } from "@/types/timeline";
+
+// 时间线字幕转写任务（M4.1，whisper.cpp 本地执行）。
+// 创建入参与后端 TimelineTranscriptionCreateRequest 契约一致。
+
+export type TimelineTranscriptionCreateRequest = {
+    resourceId: string;
+    language?: string;
+    projectId?: string;
+};
+
+export type TimelineTranscriptionResult = {
+    segments: TimelineTranscriptionSegment[];
+    srt?: string;
+    language?: string;
+};
+
+export type TimelineTranscriptionSegment = {
+    startMs: number;
+    endMs: number;
+    text: string;
+};
+
+export async function createTimelineTranscriptionTask(
+    payload: TimelineTranscriptionCreateRequest,
+    signal?: AbortSignal,
+): Promise<GenerationTask> {
+    return request<GenerationTask>(
+        apiClient.post("/timeline/transcriptions", payload, { signal }),
+    );
+}
+
+// 时间线成片渲染任务（M4.2，后端 ffmpeg 合成）。
+// 创建入参与后端 TimelineRenderCreateRequest 契约一致；timeline 直接传
+// TimelineProject v2（后端 renderProject 与其字段同名同构，多余字段被忽略）。
+// 任务完成后轮询 status，ResultJSON = TimelineRenderResult。
+
+export type TimelineRenderCreateRequest = {
+    projectId: string;
+    timeline: TimelineProject;
+};
+
+export type TimelineRenderResult = {
+    resourceId: string;
+    fileName?: string;
+    size?: number;
+    durationMs?: number;
+    subtitleSrt?: string;
+};
+
+export async function createTimelineRenderTask(
+    payload: TimelineRenderCreateRequest,
+    signal?: AbortSignal,
+): Promise<GenerationTask> {
+    return request<GenerationTask>(
+        apiClient.post("/timeline/renders", payload, { signal }),
+    );
+}
diff --git a/web/src/stores/editor/editor-store.ts b/web/src/stores/editor/editor-store.ts
new file mode 100644
index 000000000..5270d4a31
--- /dev/null
+++ b/web/src/stores/editor/editor-store.ts
@@ -0,0 +1,193 @@
+// 编辑器状态机（ADR-0002）：命令唯一入口 + 有界快照撤销 + 1.5s 防抖保存。
+// - dispatch：同步 apply 命令，失败（fail-closed）不改状态、错误进 saveError 供 UI 上报
+// - 保存层依赖注入（saveTimeline），M4 前不绑定后端；保存串行化防止旧快照覆盖新状态
+// - previewGesture/commitGesture/cancelGesture：拖拽等连续手势期间只改渲染态，
+//   松手提交时一次性入历史（手势不逐帧污染撤销栈）
+
+import { create, type StoreApi, type UseBoundStore } from "zustand";
+
+import type { TimelineProject } from "@/types/timeline";
+import {
+    createEditorHistory,
+    pushEditorHistory,
+    redoEditorHistory,
+    undoEditorHistory,
+    type EditorHistory,
+} from "@/lib/timeline/editor-history";
+import { getEditorCommandRegistry, type EditCommand, type EditorCommandRegistry } from "@/lib/timeline/editor-commands";
+
+export type SaveTimeline = (project: TimelineProject) => Promise<void>;
+
+export const EDITOR_SAVE_DEBOUNCE_MS = 1500;
+
+export type EditorStore = {
+    /** 编辑器当前项目；null 表示尚未加载（进入编辑器前由 load 注入）。 */
+    project: TimelineProject | null;
+    history: EditorHistory | null;
+    /** 手势预览进行中（drag/trim 未松手）：期间 dispatch/undo/redo 被拒绝。 */
+    inPreview: boolean;
+    isDirty: boolean;
+    saving: boolean;
+    saveError: string | null;
+    lastSavedAt: number | null;
+    /** 当前选中片段 id（检查器/预览联动；纯 UI 状态，不入命令历史）。 */
+    selectedClipId: string | null;
+    selectClip: (id: string | null) => void;
+    /** 播放头位置（监视器与时间线面板共享的 transport，毫秒；纯 UI 状态，不入命令历史）。 */
+    transportMs: number;
+    setTransportMs: (ms: number) => void;
+    /** 加载/切换项目：重置历史与保存状态（数据由外部传入，不触发保存）。 */
+    load: (project: TimelineProject) => void;
+    /** 应用一条编辑命令（唯一修改入口）。 */
+    dispatch: (cmd: EditCommand) => void;
+    undo: () => void;
+    redo: () => void;
+    /** 手势预览：临时应用命令到渲染态，不入历史。 */
+    previewGesture: (cmd: EditCommand) => void;
+    /** 提交预览：预览态作为一次历史入栈并触发保存。 */
+    commitGesture: () => void;
+    /** 取消预览：丢弃预览态，回到手势前状态。 */
+    cancelGesture: () => void;
+    /** 立即保存（离开编辑器/卸载前调用）。 */
+    flushSave: () => Promise<void>;
+};
+
+export type EditorStoreOptions = {
+    saveTimeline?: SaveTimeline;
+    registry?: EditorCommandRegistry;
+    debounceMs?: number;
+};
+
+export function createEditorStore(options: EditorStoreOptions = {}): UseBoundStore<StoreApi<EditorStore>> {
+    const registry = options.registry ?? getEditorCommandRegistry();
+    const saveTimeline = options.saveTimeline;
+    const debounceMs = options.debounceMs ?? EDITOR_SAVE_DEBOUNCE_MS;
+
+    return create<EditorStore>((set, get) => {
+        let saveTimer: ReturnType<typeof setTimeout> | null = null;
+        // 保存串行链：避免并行保存导致旧快照后落地覆盖新状态
+        let saveChain: Promise<void> = Promise.resolve();
+
+        const setSaveError = (err: unknown) =>
+            set({ saveError: err instanceof Error ? err.message : String(err) });
+
+        const performSave = (): Promise<void> => {
+            const { project } = get();
+            if (!project) return Promise.resolve();
+            set({ saving: true });
+            const chain = saveChain
+                .then(() => saveTimeline!(project))
+                .then(
+                    () => set({ saving: false, isDirty: false, saveError: null, lastSavedAt: Date.now() }),
+                    (err: unknown) => set({ saving: false, saveError: err instanceof Error ? err.message : String(err), isDirty: true }),
+                );
+            saveChain = chain;
+            return chain;
+        };
+
+        const scheduleSave = () => {
+            if (!saveTimeline) return; // 未注入保存层：保持 dirty，由上层决定持久化时机
+            if (saveTimer) clearTimeout(saveTimer);
+            saveTimer = setTimeout(() => {
+                saveTimer = null;
+                if (get().isDirty) performSave();
+            }, debounceMs);
+        };
+
+        return {
+            project: null,
+            history: null,
+            inPreview: false,
+            isDirty: false,
+            saving: false,
+            saveError: null,
+            lastSavedAt: null,
+            selectedClipId: null,
+            transportMs: 0,
+
+            selectClip: (id) => set({ selectedClipId: id }),
+
+            setTransportMs: (ms) => set({ transportMs: Number.isFinite(ms) ? Math.max(0, Math.round(ms)) : 0 }),
+
+            load: (project) => {
+                if (saveTimer) {
+                    clearTimeout(saveTimer);
+                    saveTimer = null;
+                }
+                set({ project, history: createEditorHistory(project), inPreview: false, isDirty: false, saving: false, saveError: null, lastSavedAt: null, selectedClipId: null, transportMs: 0 });
+            },
+
+            dispatch: (cmd) => {
+                const { project, history, inPreview } = get();
+                if (!project || !history) return;
+                if (inPreview) {
+                    set({ saveError: "cannot dispatch while a gesture preview is active; commit or cancel first" });
+                    return;
+                }
+                let next: TimelineProject;
+                try {
+                    next = registry.apply(project, cmd);
+                } catch (err) {
+                    setSaveError(err);
+                    return;
+                }
+                set({ project: next, history: pushEditorHistory(history, next), isDirty: true, saveError: null });
+                scheduleSave();
+            },
+
+            undo: () => {
+                const { project, history, inPreview } = get();
+                if (!project || !history || inPreview) return;
+                const next = undoEditorHistory(history);
+                if (!next) return;
+                set({ project: next.current, history: next, isDirty: true });
+                scheduleSave();
+            },
+
+            redo: () => {
+                const { project, history, inPreview } = get();
+                if (!project || !history || inPreview) return;
+                const next = redoEditorHistory(history);
+                if (!next) return;
+                set({ project: next.current, history: next, isDirty: true });
+                scheduleSave();
+            },
+
+            previewGesture: (cmd) => {
+                const { project, history } = get();
+                if (!project || !history) return;
+                // 手势进行中允许基于当前预览态继续应用（拖拽每帧调用）；
+                // 预览始终从手势前历史提交，因此预览期间不触碰历史。
+                let next: TimelineProject;
+                try {
+                    next = registry.apply(project, cmd);
+                } catch (err) {
+                    setSaveError(err);
+                    return;
+                }
+                set({ project: next, inPreview: true });
+            },
+
+            commitGesture: () => {
+                const { project, history, inPreview } = get();
+                if (!project || !history || !inPreview) return;
+                set({ project, history: pushEditorHistory(history, project), inPreview: false, isDirty: true, saveError: null });
+                scheduleSave();
+            },
+
+            cancelGesture: () => {
+                const { history, inPreview } = get();
+                if (!history || !inPreview) return;
+                set({ project: history.current, history, inPreview: false });
+            },
+
+            flushSave: async () => {
+                if (saveTimer) {
+                    clearTimeout(saveTimer);
+                    saveTimer = null;
+                }
+                if (get().isDirty && saveTimeline) await performSave();
+            },
+        };
+    });
+}
diff --git a/web/src/stores/use-plugin-store.ts b/web/src/stores/use-plugin-store.ts
index daf32065a..372da0bdc 100644
--- a/web/src/stores/use-plugin-store.ts
+++ b/web/src/stores/use-plugin-store.ts
@@ -2,7 +2,7 @@ import { create } from "zustand";
 import { createJSONStorage, persist } from "zustand/middleware";
 
 import { localForageStorageForScope } from "@/lib/localforage-storage";
-import type { PluginInstallation, PluginManifest } from "@/lib/plugins/plugin-types";
+import type { PluginInstallation, PluginManifest, PluginManifestV2 } from "@/lib/plugins/plugin-types";
 import type { PluginState } from "@/services/api/plugins";
 
 export const PLUGIN_STORE_KEY = "infinite-canvas:plugin-store";
@@ -12,7 +12,7 @@ type PluginStore = {
     installations: PluginInstallation[];
     runtimeStatuses: Record<string, string>;
     pluginStates: Record<string, PluginState>;
-    ensurePlugin: (manifest: PluginManifest) => void;
+    ensurePlugin: (manifest: PluginManifest | PluginManifestV2) => void;
     setRuntimeStatuses: (statuses: Record<string, string>) => void;
     setPluginStates: (states: Record<string, PluginState>) => void;
     setEnabled: (pluginId: string, enabled: boolean) => void;
diff --git a/web/src/styles/globals.css b/web/src/styles/globals.css
index 3efdd8d8c..22cb17dc3 100644
--- a/web/src/styles/globals.css
+++ b/web/src/styles/globals.css
@@ -594,6 +594,18 @@
     --director-control-hover: rgba(255, 255, 255, 0.09);
     --director-swatch-inset: rgba(0, 0, 0, 0.18);
 
+    /* 编辑器工作台：圆角浮卡舞台底色 + 常亮强调色（明暗两主题同值，避免 workspace-accent 黑白反转）*/
+    --director-workspace-bg: #0b0d0f;
+    --director-accent: #4f8cff;
+    --director-accent-hover: #6ba0ff;
+    --director-on-accent: #ffffff;
+    --director-success: #34d399;
+    --director-warning: #fbbf24;
+    --director-danger: #f87171;
+    --director-success-soft: rgba(52, 211, 153, 0.14);
+    --director-warning-soft: rgba(251, 191, 36, 0.14);
+    --director-danger-soft: rgba(248, 113, 113, 0.14);
+
     /* 节点类型色（引用 Primitive 节点色板，对应 #97 决策1 色带方案）*/
     --cn-type-image: var(--palette-node-image);
     --cn-type-video: var(--palette-node-video);
@@ -740,6 +752,60 @@
     --director-control-hover: rgba(255, 255, 255, 0.09);
     --director-swatch-inset: rgba(0, 0, 0, 0.18);
 
+    /* 编辑器工作台：圆角浮卡舞台底色 + 常亮强调色（明暗两主题同值，避免 workspace-accent 黑白反转）*/
+    --director-workspace-bg: #0b0d0f;
+    --director-accent: #4f8cff;
+    --director-accent-hover: #6ba0ff;
+    --director-on-accent: #ffffff;
+    --director-success: #34d399;
+    --director-warning: #fbbf24;
+    --director-danger: #f87171;
+    --director-success-soft: rgba(52, 211, 153, 0.14);
+    --director-warning-soft: rgba(251, 191, 36, 0.14);
+    --director-danger-soft: rgba(248, 113, 113, 0.14);
+}
+
+
+/* 剪辑工作台：跟随明暗主题的表面（作用域覆盖 director 常暗 token；canvas 导演工作台全局值不受影响）*/
+.editor-workbench {
+    --director-sequencer-surface: #fbfcfe;
+    --director-sequencer-surface-raised: #f1f4f7;
+    --director-sequencer-border: rgba(15, 23, 42, 0.12);
+    --director-sequencer-muted: rgba(15, 23, 42, 0.5);
+    --director-sequencer-grid: rgba(15, 23, 42, 0.07);
+    --director-dock-surface: rgba(255, 255, 255, 0.96);
+    --director-dock-fg: rgba(15, 23, 42, 0.62);
+    --director-dock-fg-strong: rgba(15, 23, 42, 0.94);
+    --director-dock-active-surface: rgba(15, 23, 42, 0.12);
+    --director-control-hover: rgba(15, 23, 42, 0.06);
+    --director-swatch-inset: rgba(0, 0, 0, 0.12);
+    --director-workspace-bg: #e9edf2;
+}
+.dark .editor-workbench {
+    --director-sequencer-surface: #111315;
+    --director-sequencer-surface-raised: #191c1f;
+    --director-sequencer-border: rgba(255, 255, 255, 0.11);
+    --director-sequencer-muted: rgba(255, 255, 255, 0.48);
+    --director-sequencer-grid: rgba(255, 255, 255, 0.055);
+    --director-dock-surface: rgba(17, 19, 21, 0.92);
+    --director-dock-fg: rgba(255, 255, 255, 0.62);
+    --director-dock-fg-strong: rgba(255, 255, 255, 0.96);
+    --director-dock-active-surface: rgba(255, 255, 255, 0.14);
+    --director-control-hover: rgba(255, 255, 255, 0.09);
+    --director-swatch-inset: rgba(0, 0, 0, 0.18);
+    --director-workspace-bg: #0b0d0f;
+}
+
+/* 全屏编辑：workbench 全屏时铺满视口（背景沿用工作区底色） */
+.editor-workbench:fullscreen {
+    width: 100vw;
+    height: 100vh;
+    background: var(--director-workspace-bg);
+}
+
+
+.dark {
+
     /* --- Shadow dark 覆盖（暗色下黑影不可见，改用白色微影制造抬升感，审计 D4/P2-D2）---
        组件 token（--node-shadow/--dock-shadow/--panel-shadow/--modal-shadow）均引用
        var(--shadow-*)，此处覆盖自动级联。--cn-spatial-shadow（内联 boxShadow 用）已有
@@ -16599,3 +16665,76 @@ html:not(.dark) .creation-home .creation-user-message { background: transparent;
     .creation-home .creation-media-pending { width: min(var(--creation-media-pending-max-width), 100%); margin-left: 0; }
     .creation-home .creation-media-error { width: 100%; margin-left: 0; }
 }
+
+/* --- 编辑器工作台细滚动条（Concat thin-scroll 参照：8px 细轨 + 圆角滑块，明暗面板通用）--- */
+.director-scroll {
+    scrollbar-width: thin;
+    scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+}
+.director-scroll::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+.director-scroll::-webkit-scrollbar-track {
+    background: transparent;
+}
+.director-scroll::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.18);
+    border-radius: 9999px;
+    border: 2px solid transparent;
+    background-clip: padding-box;
+}
+.director-scroll::-webkit-scrollbar-thumb:hover {
+    background: rgba(255, 255, 255, 0.3);
+    background-clip: padding-box;
+    border: 2px solid transparent;
+}
+.director-scroll::-webkit-scrollbar-corner {
+    background: transparent;
+}
+
+/* --- 编辑器 sunken 滑块（Concat 参照：凹陷轨道 + 圆点滑块，跟随主题 token）--- */
+.editor-slider {
+    -webkit-appearance: none;
+    appearance: none;
+    display: block;
+    width: 100%;
+    height: 18px;
+    background: transparent;
+    cursor: pointer;
+}
+.editor-slider::-webkit-slider-runnable-track {
+    height: 4px;
+    border-radius: 2px;
+    background: var(--director-sequencer-border);
+    box-shadow: inset 0 1px 2px rgb(0 0 0 / 0.3);
+}
+.editor-slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    margin-top: -5px;
+    height: 14px;
+    width: 14px;
+    border-radius: 9999px;
+    background: var(--director-dock-fg-strong);
+    border: 2px solid var(--director-sequencer-surface);
+    box-shadow: 0 1px 3px rgb(0 0 0 / 0.45);
+    transition: transform 0.12s ease;
+}
+.editor-slider::-webkit-slider-thumb:hover {
+    transform: scale(1.15);
+}
+.editor-slider::-moz-range-track {
+    height: 4px;
+    border-radius: 2px;
+    background: var(--director-sequencer-border);
+    box-shadow: inset 0 1px 2px rgb(0 0 0 / 0.3);
+}
+.editor-slider::-moz-range-thumb {
+    height: 14px;
+    width: 14px;
+    border-radius: 9999px;
+    background: var(--director-dock-fg-strong);
+    border: 2px solid var(--director-sequencer-surface);
+    box-shadow: 0 1px 3px rgb(0 0 0 / 0.45);
+}
diff --git a/web/src/types/timeline.ts b/web/src/types/timeline.ts
index d59e93db3..0fbd8c647 100644
--- a/web/src/types/timeline.ts
+++ b/web/src/types/timeline.ts
@@ -60,6 +60,10 @@ export type TimelineTrack = {
     label: string;
     order: number;
     locked?: boolean;
+    /** 轨道可见性（预览/导出跳过不可见轨）。undefined = true。 */
+    visible?: boolean;
+    /** 轨道静音（音频轨在播放/导出时静音）。undefined = false。 */
+    muted?: boolean;
 };
 
 export type TimelineClipKind = "video" | "audio" | "subtitle" | "text" | "image";
diff --git a/web/test/ai-command-schema.test.ts b/web/test/ai-command-schema.test.ts
new file mode 100644
index 000000000..9e70a42f9
--- /dev/null
+++ b/web/test/ai-command-schema.test.ts
@@ -0,0 +1,150 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+    AI_COMMAND_SCHEMA_VERSION,
+    AI_EDITING_OP_CATALOG,
+    AiCommandPlanError,
+    buildAiEditingSystemPrompt,
+    parseAiCommandPlan,
+    validateAiCommandBatch,
+} from "@/lib/timeline/ai-command-schema";
+import { EDITOR_COMMAND_OPS } from "@/lib/timeline/editor-commands";
+import type { TimelineProject } from "@/types/timeline";
+
+const commandsGolden = JSON.parse(
+    readFileSync(join(import.meta.dir, "fixtures/commands.golden.json"), "utf8"),
+) as { base: TimelineProject };
+
+const aiGolden = JSON.parse(
+    readFileSync(join(import.meta.dir, "fixtures/ai-commands.golden.json"), "utf8"),
+) as { schemaVersion: number; ops: string[] };
+
+describe("AI 命令 schema 黄金同步（防漂移）", () => {
+    test("catalog op 集与 M2.1 命令注册表一致", () => {
+        const catalogOps = AI_EDITING_OP_CATALOG.map((e) => e.op);
+        expect(catalogOps).toEqual([...EDITOR_COMMAND_OPS]);
+    });
+    test("golden fixture op 集/版本与源码一致", () => {
+        expect(aiGolden.schemaVersion).toBe(AI_COMMAND_SCHEMA_VERSION);
+        expect(aiGolden.ops).toEqual([...EDITOR_COMMAND_OPS]);
+        expect(aiGolden.ops.length).toBe(12);
+    });
+    test("catalog 每条契约含 op/desc/payload 三段", () => {
+        for (const entry of AI_EDITING_OP_CATALOG) {
+            expect(entry.op.length).toBeGreaterThan(0);
+            expect(entry.desc.length).toBeGreaterThan(0);
+            expect(entry.payload.length).toBeGreaterThan(0);
+        }
+    });
+});
+
+describe("parseAiCommandPlan（LLM 输出解析）", () => {
+    test("解析裸 JSON", () => {
+        const plan = parseAiCommandPlan('{"reasoning":"移一下","commands":[{"op":"moveClip","payload":{"id":"clip-a","startMs":2000}}]}');
+        expect(plan.reasoning).toBe("移一下");
+        expect(plan.commands).toHaveLength(1);
+    });
+    test("解析 markdown fence 包裹的 JSON", () => {
+        const plan = parseAiCommandPlan('```json\n{"commands":[{"op":"moveClip","payload":{"id":"clip-a","startMs":2000}}]}\n```');
+        expect(plan.commands[0].op).toBe("moveClip");
+    });
+    test("容忍 JSON 前后杂讯并从首个 { 起解析", () => {
+        const plan = parseAiCommandPlan('好的，我来处理：\n{"commands":[{"op":"moveClip","payload":{"id":"clip-a","startMs":2000}}]}\n以上就是我的建议。');
+        expect(plan.commands[0].op).toBe("moveClip");
+    });
+    test("reasoning 可省略", () => {
+        const plan = parseAiCommandPlan('{"commands":[{"op":"moveClip","payload":{"id":"clip-a","startMs":2000}}]}');
+        expect(plan.reasoning).toBeUndefined();
+    });
+    test("commands 空数组合法（只读问答 / 无法执行语义）", () => {
+        const plan = parseAiCommandPlan('{"reasoning":"当前没有可用于增加转场效果的命令。","commands":[]}');
+        expect(plan.commands).toHaveLength(0);
+        expect(plan.reasoning).toContain("转场");
+    });
+    test("commands 超过 8 条上限 → 抛错", () => {
+        const tooMany = Array.from({ length: 9 }, (_, i) => ({
+            op: "moveClip",
+            payload: { id: `clip-a`, startMs: i * 1000 },
+        }));
+        expect(() => parseAiCommandPlan(JSON.stringify({ commands: tooMany }))).toThrow(/8 条上限/);
+    });
+    test("无 JSON 对象 → 抛错", () => {
+        expect(() => parseAiCommandPlan("抱歉，我做不到。")).toThrow(/未找到 JSON 对象/);
+    });
+    test("JSON 截断未闭合 → 抛错", () => {
+        expect(() => parseAiCommandPlan('{"commands":[{"op":"moveClip","payload":{"id":"clip-a","startMs":2000}}]')).toThrow(/未闭合/);
+    });
+    test("commands 项非对象 → 抛错", () => {
+        expect(() => parseAiCommandPlan('{"commands":["moveClip"]}')).toThrow(/commands\[0\]/);
+    });
+    test("命令缺 payload → 抛错", () => {
+        expect(() => parseAiCommandPlan('{"commands":[{"op":"moveClip"}]}')).toThrow(/payload/);
+    });
+    test("字符串内含括号/花括号不受括号配对误判", () => {
+        const plan = parseAiCommandPlan('{"commands":[{"op":"setClipProperty","payload":{"id":"sub-1","patch":{"text":"你好}世界 {"}}}]}');
+        expect(plan.commands[0].payload).toEqual({ id: "sub-1", patch: { text: "你好}世界 {" } });
+    });
+});
+
+describe("validateAiCommandBatch（批级 dry-run 预检）", () => {
+    test("合法批通过", () => {
+        const verdict = validateAiCommandBatch(commandsGolden.base, {
+            commands: [
+                { op: "moveClip", payload: { id: "clip-a", startMs: 2000 } },
+                { op: "setTrackFlag", payload: { trackId: "video-1", flag: "muted", value: true } },
+            ],
+        });
+        expect(verdict).toEqual({ ok: true });
+    });
+    test("任一条未知 op → 整批拒绝并报下标与 op", () => {
+        const verdict = validateAiCommandBatch(commandsGolden.base, {
+            commands: [
+                { op: "moveClip", payload: { id: "clip-a", startMs: 2000 } },
+                { op: "explodeEverything", payload: {} },
+            ],
+        });
+        expect(verdict.ok).toBe(false);
+        if (!verdict.ok) {
+            expect(verdict.index).toBe(1);
+            expect(verdict.op).toBe("explodeEverything");
+            expect(verdict.error).toMatch(/unknown edit command op/);
+        }
+    });
+    test("引用了不存在的 clip → 整批拒绝（ADR-0007 不部分执行）", () => {
+        const verdict = validateAiCommandBatch(commandsGolden.base, {
+            commands: [{ op: "removeClip", payload: { id: "ghost-clip" } }],
+        });
+        expect(verdict.ok).toBe(false);
+    });
+    test("非法 payload（越界时长）→ 拒绝", () => {
+        const verdict = validateAiCommandBatch(commandsGolden.base, {
+            commands: [{ op: "moveClip", payload: { id: "clip-a", startMs: -1 } }],
+        });
+        expect(verdict.ok).toBe(false);
+    });
+    test("dry-run 不产生副作用（原时间线未被修改）", () => {
+        const before = JSON.stringify(commandsGolden.base);
+        validateAiCommandBatch(commandsGolden.base, {
+            commands: [{ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } }],
+        });
+        expect(JSON.stringify(commandsGolden.base)).toBe(before);
+    });
+});
+
+describe("buildAiEditingSystemPrompt（提示词契约）", () => {
+    const prompt = buildAiEditingSystemPrompt("时间线：空");
+    test("包含时间线摘要、全部 op 契约与输出格式说明", () => {
+        expect(prompt).toContain("时间线：空");
+        expect(prompt).toContain("可用命令契约");
+        expect(prompt).toContain("输出要求");
+        expect(prompt).toContain("示例");
+        for (const op of EDITOR_COMMAND_OPS) {
+            expect(prompt).toContain(`- ${op}：`);
+        }
+    });
+    test("同摘要生成确定性提示词", () => {
+        expect(buildAiEditingSystemPrompt("A")).toBe(buildAiEditingSystemPrompt("A"));
+    });
+});
diff --git a/web/test/asset-ingest.test.ts b/web/test/asset-ingest.test.ts
new file mode 100644
index 000000000..68aafeb73
--- /dev/null
+++ b/web/test/asset-ingest.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+import { assetToClipKind, makeClipFromAsset } from "@/lib/timeline/asset-ingest";
+import type { ProjectAsset } from "@/services/api/projects";
+
+function makeAsset(overrides: Partial<ProjectAsset>): ProjectAsset {
+    return {
+        id: "ast-1",
+        title: "Demo Video",
+        mediaType: "video",
+        category: "video",
+        status: "ready",
+        versionCount: 1,
+        usages: [],
+        position: 0,
+        updatedAt: "2026-01-01T00:00:00Z",
+        storageKey: "assets/ast-1/master.mp4",
+        ...overrides,
+    };
+}
+
+describe("assetToClipKind", () => {
+    test("映射 video/audio/image/text", () => {
+        expect(assetToClipKind("video")).toBe("video");
+        expect(assetToClipKind("audio")).toBe("audio");
+        expect(assetToClipKind("image")).toBe("image");
+        expect(assetToClipKind("text")).toBe("text");
+    });
+
+    test("未知媒体类型返回 null", () => {
+        expect(assetToClipKind("archive")).toBeNull();
+        expect(assetToClipKind("")).toBeNull();
+    });
+});
+
+describe("makeClipFromAsset", () => {
+    const options = { trackId: "track-video-1", startMs: 12_000, id: "asset:ast-1:1" };
+
+    test("生成 video clip 且 directMedia 引用资产", () => {
+        const clip = makeClipFromAsset(makeAsset({}), options);
+        expect(clip).not.toBeNull();
+        expect(clip).toMatchObject({
+            id: "asset:ast-1:1",
+            kind: "video",
+            nodeId: "asset:ast-1",
+            trackId: "track-video-1",
+            startMs: 12_000,
+            durationMs: 3_000,
+            title: "Demo Video",
+            directMedia: {
+                id: "ast-1",
+                kind: "video",
+                title: "Demo Video",
+                storageKey: "assets/ast-1/master.mp4",
+            },
+        });
+    });
+
+    test("默认时长可覆盖", () => {
+        const clip = makeClipFromAsset(makeAsset({}), { ...options, defaultDurationMs: 500 });
+        expect(clip?.durationMs).toBe(500);
+    });
+
+    test("无 id 时使用 asset 前缀", () => {
+        const clip = makeClipFromAsset(makeAsset({}), { trackId: options.trackId, startMs: 0 });
+        expect(clip?.id).toBe("asset:ast-1");
+    });
+
+    test("audio 资产映射到 audio kind", () => {
+        const clip = makeClipFromAsset(makeAsset({ mediaType: "audio", category: "audio" }), options);
+        expect(clip?.kind).toBe("audio");
+        expect(clip?.directMedia?.kind).toBe("audio");
+    });
+
+    test("text 与未知媒体类型不入轨", () => {
+        expect(makeClipFromAsset(makeAsset({ mediaType: "text" }), options)).toBeNull();
+        expect(makeClipFromAsset(makeAsset({ mediaType: "script" }), options)).toBeNull();
+    });
+
+    test("输入资产不被修改", () => {
+        const asset = makeAsset({});
+        const before = JSON.stringify(asset);
+        makeClipFromAsset(asset, options);
+        expect(JSON.stringify(asset)).toBe(before);
+    });
+});
diff --git a/web/test/editor-commands.test.ts b/web/test/editor-commands.test.ts
new file mode 100644
index 000000000..abe4e2ce1
--- /dev/null
+++ b/web/test/editor-commands.test.ts
@@ -0,0 +1,243 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { createEditorCommandRegistry, getEditorCommandRegistry } from "../src/lib/timeline/editor-commands";
+import type { TimelineProject } from "../src/types/timeline";
+
+const golden = JSON.parse(readFileSync(join(import.meta.dir, "fixtures/commands.golden.json"), "utf8")) as {
+    base: TimelineProject;
+    cases: Array<{ name: string; commands: Array<{ op: string; payload: unknown }>; expected: TimelineProject }>;
+};
+
+describe("editor command registry (golden file)", () => {
+    for (const c of golden.cases) {
+        test(c.name, () => {
+            const registry = createEditorCommandRegistry();
+            const result = c.commands.reduce<TimelineProject>((state, cmd) => registry.apply(state, cmd), golden.base);
+            expect(result).toEqual(c.expected);
+        });
+    }
+
+    test("knownOps lists the 12 golden ops", () => {
+        expect(createEditorCommandRegistry().knownOps().sort()).toEqual(
+            ["addClip", "addSubtitle", "moveClip", "rebuildSubtitleClips", "removeClip", "removeSubtitle", "setClipProperty", "splitClip", "trimClip", "addTrack", "removeTrack", "setTrackFlag"].sort(),
+        );
+    });
+});
+
+describe("editor command registry (immutability)", () => {
+    test("apply returns a new state and never mutates the input", () => {
+        const registry = createEditorCommandRegistry();
+        const before = JSON.stringify(golden.base);
+        const result = registry.apply(golden.base, { op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        expect(result).not.toBe(golden.base);
+        expect(result.clips).not.toBe(golden.base.clips);
+        expect(JSON.stringify(golden.base)).toBe(before);
+    });
+
+    test("rejected commands leave the input untouched", () => {
+        const registry = createEditorCommandRegistry();
+        const before = JSON.stringify(golden.base);
+        expect(() => registry.apply(golden.base, { op: "removeClip", payload: { id: "nope" } })).toThrow();
+        expect(JSON.stringify(golden.base)).toBe(before);
+    });
+});
+
+describe("editor command registry (fail-closed payload validation)", () => {
+    const registry = createEditorCommandRegistry();
+
+    test("unknown op throws", () => {
+        expect(() => registry.apply(golden.base, { op: "explodeEverything", payload: {} })).toThrow(/unknown edit command op "explodeEverything"/);
+    });
+
+    test("malformed command object throws", () => {
+        expect(() => registry.apply(golden.base, null as unknown as { op: string })).toThrow(/must be \{ op, payload \}/);
+        expect(() => registry.apply(golden.base, { payload: {} } as unknown as { op: string })).toThrow(/must be \{ op, payload \}/);
+    });
+
+    test("addClip rejects missing fields, negative start, subtitle kind, missing track", () => {
+        expect(() => registry.apply(golden.base, { op: "addClip", payload: { clip: { id: "x", kind: "video", nodeId: "n", trackId: "video-1", startMs: 0 } } })).toThrow(/durationMs/);
+        expect(() => registry.apply(golden.base, { op: "addClip", payload: { clip: { id: "x", kind: "video", nodeId: "n", trackId: "video-1", startMs: -1, durationMs: 1000 } } })).toThrow(/startMs/);
+        expect(() => registry.apply(golden.base, { op: "addClip", payload: { clip: { id: "x", kind: "subtitle", nodeId: "n", trackId: "subtitle-1", startMs: 0, durationMs: 1000 } } })).toThrow(/addSubtitle/);
+        expect(() => registry.apply(golden.base, { op: "addClip", payload: { clip: { id: "x", kind: "video", nodeId: "n", trackId: "missing-track", startMs: 0, durationMs: 1000 } } })).toThrow(/does not exist/);
+    });
+
+    test("moveClip rejects unknown clip, negative start, missing track", () => {
+        expect(() => registry.apply(golden.base, { op: "moveClip", payload: { id: "nope", startMs: 0 } })).toThrow(/does not exist/);
+        expect(() => registry.apply(golden.base, { op: "moveClip", payload: { id: "clip-a", startMs: -100 } })).toThrow(/startMs/);
+        expect(() => registry.apply(golden.base, { op: "moveClip", payload: { id: "clip-a", startMs: 0, trackId: "nope" } })).toThrow(/does not exist/);
+    });
+
+    test("trimClip rejects over-source and negative values", () => {
+        expect(() => registry.apply(golden.base, { op: "trimClip", payload: { id: "clip-b", durationMs: 9000 } })).toThrow(/exceeds sourceDurationMs/);
+        expect(() => registry.apply(golden.base, { op: "trimClip", payload: { id: "clip-b", startMs: 0, durationMs: 1000, sourceStartMs: 7500 } })).toThrow(/exceeds sourceDurationMs/);
+        expect(() => registry.apply(golden.base, { op: "trimClip", payload: { id: "clip-b", durationMs: 0 } })).toThrow(/positive/);
+        expect(() => registry.apply(golden.base, { op: "trimClip", payload: { id: "nope", durationMs: 1000 } })).toThrow(/does not exist/);
+    });
+
+    test("splitClip rejects out-of-range split points", () => {
+        expect(() => registry.apply(golden.base, { op: "splitClip", payload: { id: "clip-a", splitAtMs: 0 } })).toThrow(/strictly inside/);
+        expect(() => registry.apply(golden.base, { op: "splitClip", payload: { id: "clip-a", splitAtMs: 5000 } })).toThrow(/strictly inside/);
+        expect(() => registry.apply(golden.base, { op: "splitClip", payload: { id: "clip-a", splitAtMs: 9999 } })).toThrow(/strictly inside/);
+        expect(() => registry.apply(golden.base, { op: "splitClip", payload: { id: "nope", splitAtMs: 1000 } })).toThrow(/does not exist/);
+    });
+
+    test("setClipProperty rejects structural fields and empty patch", () => {
+        expect(() => registry.apply(golden.base, { op: "setClipProperty", payload: { id: "clip-a", patch: { trackId: "video-2" } } })).toThrow(/not editable/);
+        expect(() => registry.apply(golden.base, { op: "setClipProperty", payload: { id: "clip-a", patch: { startMs: 100 } } })).toThrow(/not editable/);
+        expect(() => registry.apply(golden.base, { op: "setClipProperty", payload: { id: "clip-a", patch: {} } })).toThrow(/must not be empty/);
+        expect(() => registry.apply(golden.base, { op: "setClipProperty", payload: { id: "nope", patch: { volume: 0.5 } } })).toThrow(/does not exist/);
+    });
+
+    test("addSubtitle rejects non-subtitle kind; removeSubtitle rejects non-subtitle clip", () => {
+        expect(() => registry.apply(golden.base, { op: "addSubtitle", payload: { clip: { id: "x", kind: "video", nodeId: "n", trackId: "video-1", startMs: 0, durationMs: 1000 } } })).toThrow(/must be "subtitle"/);
+        expect(() => registry.apply(golden.base, { op: "removeSubtitle", payload: { id: "clip-a" } })).toThrow(/not a subtitle clip/);
+        expect(() => registry.apply(golden.base, { op: "removeSubtitle", payload: { id: "nope" } })).toThrow(/does not exist/);
+    });
+
+    test("rebuildSubtitleClips rejects bad entries, non-subtitle track, and no subtitle track", () => {
+        const entries = (extra: Record<string, unknown>) => [{ index: 0, startMs: 0, endMs: 1000, text: "ok", ...extra }];
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: entries({ index: -1 }) } })).toThrow(/non-negative integer/);
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: entries({ endMs: 0 }) } })).toThrow(/endMs must be greater than startMs/);
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: entries({ text: 42 }) } })).toThrow(/text must be a string/);
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: [...entries({}), ...entries({ index: 0 })] } })).toThrow(/duplicate entry index/);
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: [], trackId: "video-1" } })).toThrow(/not a subtitle track/);
+        const noSubtitle = { ...golden.base, tracks: golden.base.tracks.filter((t) => t.kind !== "subtitle") };
+        expect(() => registry.apply(noSubtitle, { op: "rebuildSubtitleClips", payload: { nodeId: "node-a", entries: [] } })).toThrow(/no subtitle track/);
+    });
+
+    test("rebuildSubtitleClips requires a non-empty nodeId", () => {
+        expect(() => registry.apply(golden.base, { op: "rebuildSubtitleClips", payload: { nodeId: "", entries: [] } })).toThrow(/nodeId/);
+    });
+});
+
+describe("editor command registry (plugin extension)", () => {
+    test("plugins can register custom ops and override builtin ops", () => {
+        const registry = createEditorCommandRegistry();
+        registry.register("pluginStamp", (state, payload) => {
+            const { tag } = payload as { tag: string };
+            return { ...state, clips: state.clips.map((c) => (c.id === tag ? { ...c, title: `stamped:${tag}` } : c)) };
+        });
+        const stamped = registry.apply(golden.base, { op: "pluginStamp", payload: { tag: "clip-a" } });
+        expect(stamped.clips.find((c) => c.id === "clip-a")?.title).toBe("stamped:clip-a");
+        expect(registry.knownOps()).toContain("pluginStamp");
+
+        // 覆盖内建 op：注册同名 handler 后以新语义执行（宿主不阻止，插件目录测试负责语义回归）
+        const before = registry.apply(golden.base, { op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        registry.register("moveClip", (state, payload) => {
+            const { id, startMs } = payload as { id: string; startMs: number };
+            return { ...state, clips: state.clips.map((c) => (c.id === id ? { ...c, startMs: startMs + 1000 } : c)) };
+        });
+        const after = registry.apply(golden.base, { op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        expect(before.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        expect(after.clips.find((c) => c.id === "clip-a")?.startMs).toBe(3000);
+    });
+
+    test("shared singleton registry is stable across getters", () => {
+        expect(getEditorCommandRegistry()).toBe(getEditorCommandRegistry());
+        expect(getEditorCommandRegistry().knownOps()).toContain("trimClip");
+    });
+});
+
+describe("editor command registry (addTrack)", () => {
+    const registry = createEditorCommandRegistry();
+
+    test("adds a track with deterministic id/order/label and keeps existing state", () => {
+        const before = JSON.stringify(golden.base);
+        const result = registry.apply(golden.base, { op: "addTrack", payload: { kind: "audio" } });
+        const added = result.tracks[result.tracks.length - 1];
+        expect(added.kind).toBe("audio");
+        expect(added.order).toBe(Math.max(...golden.base.tracks.map((t) => t.order)) + 1);
+        expect(added.label).toBeTruthy();
+        expect(added.id).toBeTruthy();
+        expect(result.tracks.length).toBe(golden.base.tracks.length + 1);
+        expect(result.clips).toEqual(golden.base.clips);
+        expect(JSON.stringify(golden.base)).toBe(before);
+    });
+
+    test("same input always appends the same track (determinism for undo/redo replay)", () => {
+        const first = registry.apply(golden.base, { op: "addTrack", payload: { kind: "video" } });
+        const second = registry.apply(golden.base, { op: "addTrack", payload: { kind: "video" } });
+        expect(first).toEqual(second);
+    });
+
+    test("rejects unknown kinds", () => {
+        expect(() => registry.apply(golden.base, { op: "addTrack", payload: { kind: "burn" } })).toThrow(/kind/);
+    });
+});
+
+describe("editor command registry (removeTrack)", () => {
+    const registry = createEditorCommandRegistry();
+
+    test("removes the track and cascades its clips, keeps the rest", () => {
+        const base = golden.base;
+        // 先加一条 audio 轨作为可删目标（默认夹具每 kind 仅 1 条，受最后一条守卫保护）。
+        const withExtra = registry.apply(base, { op: "addTrack", payload: { kind: "audio" } });
+        const victim = withExtra.tracks[withExtra.tracks.length - 1];
+        const seeded = {
+            ...withExtra,
+            clips: [...withExtra.clips, { ...withExtra.clips[0], id: "clip-on-removed", trackId: victim.id }],
+        };
+        const result = registry.apply(seeded, { op: "removeTrack", payload: { trackId: victim.id } });
+        expect(result.tracks.some((t) => t.id === victim.id)).toBe(false);
+        expect(result.clips.some((c) => c.trackId === victim.id)).toBe(false);
+        expect(result.clips.some((c) => c.id === "clip-on-removed")).toBe(false);
+        expect(result.tracks.length).toBe(withExtra.tracks.length - 1);
+        expect(result.clips.length).toBe(seeded.clips.length - 1);
+    });
+
+    test("refuses to remove the last track of a kind", () => {
+        const base = golden.base;
+        const target = base.tracks.find((t) => base.tracks.filter((x) => x.kind === t.kind).length === 1);
+        expect(target).toBeTruthy();
+        expect(() => registry.apply(base, { op: "removeTrack", payload: { trackId: target.id } })).toThrow(/last/);
+    });
+
+    test("rejects an unknown track id", () => {
+        expect(() =>
+            registry.apply(golden.base, { op: "removeTrack", payload: { trackId: "no-such-track" } }),
+        ).toThrow(/track/);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// setTrackFlag
+// ---------------------------------------------------------------------------
+describe("editor command registry (setTrackFlag)", () => {
+    const registry = createEditorCommandRegistry();
+
+    test("sets visible/muted on the target track only (fail-closed on flag whitelist)", () => {
+        const base = golden.base;
+        const targetId = base.tracks[0].id;
+        const result = registry.apply(base, { op: "setTrackFlag", payload: { trackId: targetId, flag: "visible", value: false } });
+        const target = result.tracks.find((t) => t.id === targetId)!;
+        expect(target.visible).toBe(false);
+        // 非目标轨道不受影响。
+        for (const t of result.tracks) {
+            if (t.id !== targetId) expect(t.visible).not.toBe(false);
+        }
+        // 输入不被修改（apply 返回新状态，不改动传入 base）。
+        expect(base.tracks.find((t) => t.id === targetId)!.visible).toBeUndefined();
+    });
+
+    test("sets muted flag independently of visible", () => {
+        const result = registry.apply(golden.base, {
+            op: "setTrackFlag",
+            payload: { trackId: golden.base.tracks[0].id, flag: "muted", value: true },
+        });
+        expect(result.tracks[0].muted).toBe(true);
+    });
+
+    test("rejects unknown track, unknown flag, and non-boolean value", () => {
+        expect(() =>
+            registry.apply(golden.base, { op: "setTrackFlag", payload: { trackId: "no-such-track", flag: "visible", value: false } }),
+        ).toThrow(/track/);
+        expect(() =>
+            registry.apply(golden.base, { op: "setTrackFlag", payload: { trackId: golden.base.tracks[0].id, flag: "locked", value: true } }),
+        ).toThrow(/flag/);
+        expect(() =>
+            registry.apply(golden.base, { op: "setTrackFlag", payload: { trackId: golden.base.tracks[0].id, flag: "visible", value: "on" } }),
+        ).toThrow(/boolean/);
+    });
+});
diff --git a/web/test/editor-history.test.ts b/web/test/editor-history.test.ts
new file mode 100644
index 000000000..961784620
--- /dev/null
+++ b/web/test/editor-history.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+    canRedo,
+    canUndo,
+    createEditorHistory,
+    HISTORY_LIMIT,
+    pushEditorHistory,
+    redoEditorHistory,
+    undoEditorHistory,
+} from "../src/lib/timeline/editor-history";
+import type { TimelineProject } from "../src/types/timeline";
+
+function project(version: number): TimelineProject {
+    return { version, tracks: [], clips: [], durationMs: 0 };
+}
+
+describe("editor history", () => {
+    test("starts with empty stacks; undo/redo return null", () => {
+        const h = createEditorHistory(project(1));
+        expect(canUndo(h)).toBe(false);
+        expect(canRedo(h)).toBe(false);
+        expect(undoEditorHistory(h)).toBeNull();
+        expect(redoEditorHistory(h)).toBeNull();
+        expect(h.current.version).toBe(1);
+    });
+
+    test("undo walks back through pushed snapshots, then null at bottom", () => {
+        let h = createEditorHistory(project(1));
+        h = pushEditorHistory(h, project(2));
+        h = pushEditorHistory(h, project(3));
+        expect(canUndo(h)).toBe(true);
+
+        h = undoEditorHistory(h)!;
+        expect(h.current.version).toBe(2);
+        expect(canRedo(h)).toBe(true);
+        h = undoEditorHistory(h)!;
+        expect(h.current.version).toBe(1);
+        expect(canUndo(h)).toBe(false);
+        expect(undoEditorHistory(h)).toBeNull();
+    });
+
+    test("redo re-applies undone snapshots, then null at top", () => {
+        let h = createEditorHistory(project(1));
+        h = pushEditorHistory(h, project(2));
+        h = pushEditorHistory(h, project(3));
+        h = undoEditorHistory(h)!;
+        h = undoEditorHistory(h)!;
+        expect(h.current.version).toBe(1);
+
+        h = redoEditorHistory(h)!;
+        expect(h.current.version).toBe(2);
+        h = redoEditorHistory(h)!;
+        expect(h.current.version).toBe(3);
+        expect(canRedo(h)).toBe(false);
+        expect(redoEditorHistory(h)).toBeNull();
+    });
+
+    test("pushing after undo clears the redo branch", () => {
+        let h = createEditorHistory(project(1));
+        h = pushEditorHistory(h, project(2));
+        h = pushEditorHistory(h, project(3));
+        h = undoEditorHistory(h)!;
+        expect(canRedo(h)).toBe(true);
+
+        h = pushEditorHistory(h, project(99));
+        expect(canRedo(h)).toBe(false);
+        expect(redoEditorHistory(h)).toBeNull();
+        expect(h.current.version).toBe(99);
+        expect(h.undoStack.map((s) => s.version)).toEqual([1, 2]);
+    });
+
+    test("keeps at most HISTORY_LIMIT snapshots, dropping the oldest", () => {
+        let h = createEditorHistory(project(0));
+        for (let i = 1; i <= HISTORY_LIMIT + 5; i++) {
+            h = pushEditorHistory(h, project(i));
+        }
+        expect(h.undoStack).toHaveLength(HISTORY_LIMIT);
+        // 最旧 5 个被丢弃：栈底应为 5，栈顶为 204
+        expect(h.undoStack[0].version).toBe(5);
+        expect(h.undoStack.at(-1)!.version).toBe(HISTORY_LIMIT + 4);
+        expect(h.current.version).toBe(HISTORY_LIMIT + 5);
+
+        // 仍可连续撤销 200 次回到栈底
+        let steps = 0;
+        while (canUndo(h)) {
+            h = undoEditorHistory(h)!;
+            steps++;
+        }
+        expect(steps).toBe(HISTORY_LIMIT);
+        expect(h.current.version).toBe(5);
+    });
+
+    test("snapshots are structure-shared: push/undo/redo hand the exact object references", () => {
+        // 历史不做深拷贝：current 与 undo/redo 栈共享同一对象引用（不可变更新契约由命令层保证）
+        const first = project(1);
+        let h = createEditorHistory(first);
+        const second = project(2);
+        h = pushEditorHistory(h, second);
+        expect(h.current).toBe(second);
+        expect(h.undoStack[0]).toBe(first);
+
+        h = undoEditorHistory(h)!;
+        expect(h.current).toBe(first);
+        expect(h.redoStack[0]).toBe(second);
+
+        h = redoEditorHistory(h)!;
+        expect(h.current).toBe(second);
+        expect(h.undoStack[0]).toBe(first);
+    });
+});
diff --git a/web/test/editor-slot-registry.test.ts b/web/test/editor-slot-registry.test.ts
new file mode 100644
index 000000000..913a0efd1
--- /dev/null
+++ b/web/test/editor-slot-registry.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+    getEditorSlots,
+    registerEditorSlot,
+    unregisterEditorSlot,
+} from "../src/lib/plugins/editor-slot-registry";
+
+const render = () => null;
+
+describe("editor slot registry", () => {
+    test("registers a slot and returns it", () => {
+        const unregister = registerEditorSlot({ pluginId: "editor-a", slot: "timeline-panel", render });
+        const slots = getEditorSlots("timeline-panel");
+        expect(slots).toHaveLength(1);
+        expect(slots[0].pluginId).toBe("editor-a");
+        unregister();
+        expect(getEditorSlots("timeline-panel")).toHaveLength(0);
+    });
+
+    test("sorts by priority desc, then registration order asc", () => {
+        const unregs = [
+            registerEditorSlot({ pluginId: "a", slot: "preview-renderer", priority: 1, render }),
+            registerEditorSlot({ pluginId: "b", slot: "preview-renderer", render }),
+            registerEditorSlot({ pluginId: "c", slot: "preview-renderer", priority: 5, render }),
+        ];
+        const slots = getEditorSlots("preview-renderer");
+        expect(slots.map((s) => s.pluginId)).toEqual(["c", "a", "b"]);
+        unregs.forEach((u) => u());
+    });
+
+    test("re-registering same plugin+slot overrides (idempotent, HMR-safe)", () => {
+        const unreg1 = registerEditorSlot({ pluginId: "x", slot: "inspector", render });
+        const unreg2 = registerEditorSlot({ pluginId: "x", slot: "inspector", render });
+        const slots = getEditorSlots("inspector");
+        expect(slots).toHaveLength(1);
+        expect(slots[0].pluginId).toBe("x");
+        // 旧卸载函数不应误删新注册项
+        unreg1();
+        expect(getEditorSlots("inspector")).toHaveLength(1);
+        unreg2();
+        expect(getEditorSlots("inspector")).toHaveLength(0);
+    });
+
+    test("different plugins coexist in the same slot", () => {
+        const unregs = [
+            registerEditorSlot({ pluginId: "p1", slot: "subtitle-tool", render }),
+            registerEditorSlot({ pluginId: "p2", slot: "subtitle-tool", render }),
+        ];
+        expect(getEditorSlots("subtitle-tool")).toHaveLength(2);
+        unregisterEditorSlot("p1", "subtitle-tool");
+        expect(getEditorSlots("subtitle-tool").map((s) => s.pluginId)).toEqual(["p2"]);
+        unregs.forEach((u) => u());
+    });
+
+    test("unknown slot returns empty", () => {
+        expect(getEditorSlots("export-renderer")).toHaveLength(0);
+    });
+});
diff --git a/web/test/editor-store.test.ts b/web/test/editor-store.test.ts
new file mode 100644
index 000000000..675fefaa2
--- /dev/null
+++ b/web/test/editor-store.test.ts
@@ -0,0 +1,228 @@
+import { describe, expect, test } from "bun:test";
+
+import { createEditorStore } from "../src/stores/editor/editor-store";
+import type { SaveTimeline } from "../src/stores/editor/editor-store";
+import type { TimelineProject } from "../src/types/timeline";
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function makeProject(): TimelineProject {
+    return {
+        version: 2,
+        tracks: [
+            { id: "video-1", kind: "video", label: "视频 1", order: 0 },
+            { id: "subtitle-1", kind: "subtitle", label: "字幕 1", order: 1 },
+        ],
+        clips: [
+            { id: "clip-a", kind: "video", nodeId: "node-a", trackId: "video-1", startMs: 0, durationMs: 5000, sourceStartMs: 0, sourceDurationMs: 10000 },
+            { id: "sub-1", kind: "subtitle", nodeId: "node-a", trackId: "subtitle-1", startMs: 500, durationMs: 2000, subtitleEntryIndex: 0, text: "你好" },
+        ],
+        durationMs: 5000,
+    };
+}
+
+describe("editor store (command dispatch)", () => {
+    test("load initializes project and history without saving", async () => {
+        const saves: TimelineProject[] = [];
+        const store = createEditorStore({ saveTimeline: async (p) => void saves.push(p) });
+        store.getState().load(makeProject());
+        expect(store.getState().project?.durationMs).toBe(5000);
+        expect(store.getState().isDirty).toBe(false);
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+        await sleep(10);
+        expect(saves).toHaveLength(0);
+    });
+
+    test("dispatch applies the command, marks dirty, and debounce-saves the latest state", async () => {
+        const saves: TimelineProject[] = [];
+        const store = createEditorStore({ saveTimeline: async (p) => void saves.push(p), debounceMs: 0 });
+        store.getState().load(makeProject());
+
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        expect(store.getState().isDirty).toBe(true);
+        expect(store.getState().history?.undoStack).toHaveLength(1);
+
+        await sleep(10);
+        expect(saves).toHaveLength(1);
+        expect(saves[0].clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        expect(store.getState().isDirty).toBe(false);
+        expect(store.getState().saveError).toBeNull();
+    });
+
+    test("rejected command keeps state and history, surfaces saveError", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        const before = store.getState().project;
+
+        store.getState().dispatch({ op: "unknownOp", payload: {} });
+        expect(store.getState().project).toBe(before);
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+        expect(store.getState().saveError).toMatch(/unknown edit command op "unknownOp"/);
+        expect(store.getState().isDirty).toBe(false);
+    });
+
+    test("undo/redo walk the history and each trigger a save", async () => {
+        const saves: TimelineProject[] = [];
+        const store = createEditorStore({ saveTimeline: async (p) => void saves.push(p), debounceMs: 0 });
+        store.getState().load(makeProject());
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 3000 } });
+        await sleep(10);
+
+        store.getState().undo();
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        store.getState().undo();
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(0);
+        store.getState().undo(); // 栈底，无操作
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(0);
+
+        store.getState().redo();
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        await sleep(10);
+        // 两次 dispatch 合并 1 次保存；undo/undo/redo 同步执行合并 1 次保存
+        expect(saves).toHaveLength(2);
+        expect(saves.at(-1)?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+    });
+
+    test("multiple dispatches within debounce window collapse into one save", async () => {
+        const saves: TimelineProject[] = [];
+        const store = createEditorStore({ saveTimeline: async (p) => void saves.push(p), debounceMs: 60 });
+        store.getState().load(makeProject());
+
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 3000 } });
+        expect(saves).toHaveLength(0); // 防抖窗口内不保存
+
+        await sleep(120);
+        expect(saves).toHaveLength(1);
+        expect(saves[0].clips.find((c) => c.id === "clip-a")?.startMs).toBe(3000);
+
+        // 新一轮变更再次触发一次保存
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 4000 } });
+        await sleep(120);
+        expect(saves).toHaveLength(2);
+        expect(saves[1].clips.find((c) => c.id === "clip-a")?.startMs).toBe(4000);
+    });
+
+    test("save failure marks saveError and keeps dirty; next successful save clears it", async () => {
+        let fail = true;
+        const store = createEditorStore({
+            saveTimeline: async () => {
+                if (fail) throw new Error("backend unreachable");
+            },
+            debounceMs: 0,
+        });
+        store.getState().load(makeProject());
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+        await sleep(10);
+        expect(store.getState().saveError).toBe("backend unreachable");
+        expect(store.getState().isDirty).toBe(true);
+
+        fail = false;
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        await sleep(10);
+        expect(store.getState().saveError).toBeNull();
+        expect(store.getState().isDirty).toBe(false);
+    });
+
+    test("flushSave persists immediately and clears pending debounce", async () => {
+        const saves: TimelineProject[] = [];
+        const store = createEditorStore({ saveTimeline: async (p) => void saves.push(p), debounceMs: 10_000 });
+        store.getState().load(makeProject());
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+
+        await store.getState().flushSave();
+        expect(saves).toHaveLength(1);
+        expect(store.getState().isDirty).toBe(false);
+        // 防抖 timer 已清：再等也不会有第二次
+        await sleep(20);
+        expect(saves).toHaveLength(1);
+    });
+
+    test("load resets history and dirty state", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+        expect(store.getState().history?.undoStack).toHaveLength(1);
+
+        store.getState().load(makeProject());
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+        expect(store.getState().isDirty).toBe(false);
+    });
+});
+
+describe("editor store (gesture preview)", () => {
+    test("preview applies without history; commit pushes once; cancel restores", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        const committed = store.getState().project;
+
+        // 预览：连续两次手势调用（模拟拖拽中），不入历史
+        store.getState().previewGesture({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+        store.getState().previewGesture({ op: "moveClip", payload: { id: "clip-a", startMs: 2000 } });
+        expect(store.getState().inPreview).toBe(true);
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+
+        // 预览期间 dispatch 被拒绝
+        store.getState().dispatch({ op: "moveClip", payload: { id: "clip-a", startMs: 5000 } });
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(2000);
+        expect(store.getState().saveError).toMatch(/gesture preview/);
+
+        // 提交：一次性入历史，可一次 undo 回到手势前
+        store.getState().commitGesture();
+        expect(store.getState().inPreview).toBe(false);
+        expect(store.getState().history?.undoStack).toHaveLength(1);
+        store.getState().undo();
+        expect(store.getState().project).toBe(committed);
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(0);
+    });
+
+    test("cancel discards preview changes", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        const committed = store.getState().project;
+
+        store.getState().previewGesture({ op: "moveClip", payload: { id: "clip-a", startMs: 1000 } });
+        expect(store.getState().project?.clips.find((c) => c.id === "clip-a")?.startMs).toBe(1000);
+        store.getState().cancelGesture();
+        expect(store.getState().inPreview).toBe(false);
+        expect(store.getState().project).toBe(committed);
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+    });
+
+    test("rejected preview command does not enter preview", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        const before = store.getState().project;
+
+        store.getState().previewGesture({ op: "unknownOp", payload: {} });
+        expect(store.getState().inPreview).toBe(false);
+        expect(store.getState().project).toBe(before);
+        expect(store.getState().saveError).toMatch(/unknown edit command op/);
+    });
+
+    test("selectClip toggles selection without touching history or dirty state", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        expect(store.getState().selectedClipId).toBeNull();
+
+        store.getState().selectClip("clip-a");
+        expect(store.getState().selectedClipId).toBe("clip-a");
+        expect(store.getState().isDirty).toBe(false);
+        expect(store.getState().history?.undoStack).toHaveLength(0);
+
+        store.getState().selectClip(null);
+        expect(store.getState().selectedClipId).toBeNull();
+    });
+
+    test("load resets selection", async () => {
+        const store = createEditorStore({ saveTimeline: async () => undefined, debounceMs: 0 });
+        store.getState().load(makeProject());
+        store.getState().selectClip("clip-a");
+        store.getState().load(makeProject());
+        expect(store.getState().selectedClipId).toBeNull();
+    });
+});
diff --git a/web/test/fixtures/ai-commands.golden.json b/web/test/fixtures/ai-commands.golden.json
new file mode 100644
index 000000000..640b08459
--- /dev/null
+++ b/web/test/fixtures/ai-commands.golden.json
@@ -0,0 +1,18 @@
+{
+  "$comment": "AI 命令 schema 黄金文件（Runbook M6.1）：schemaVersion 与 op 集必须与 ai-command-schema.ts 及 M2.1 命令注册表一致。修改命令语义必须同步更新此夹具，防止 AI 提示词契约与 reducer 漂移。",
+  "schemaVersion": 1,
+  "ops": [
+    "addClip",
+    "moveClip",
+    "trimClip",
+    "splitClip",
+    "removeClip",
+    "setClipProperty",
+    "addSubtitle",
+    "removeSubtitle",
+    "rebuildSubtitleClips",
+    "addTrack",
+    "removeTrack",
+    "setTrackFlag"
+  ]
+}
diff --git a/web/test/fixtures/commands.golden.json b/web/test/fixtures/commands.golden.json
new file mode 100644
index 000000000..0c02d9d21
--- /dev/null
+++ b/web/test/fixtures/commands.golden.json
@@ -0,0 +1,266 @@
+{
+  "$comment": "编辑器命令黄金文件（Runbook M2.1 / 方案 §7.1）：命令序列 → 期望状态快照。修改命令语义必须同步更新此夹具，防止 reducer 漂移。",
+  "base": {
+    "version": 2,
+    "tracks": [
+      { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+      { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+      { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+      { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+    ],
+    "clips": [
+      { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+      { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+      { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+      { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+    ],
+    "durationMs": 8000
+  },
+  "cases": [
+    {
+      "name": "add-clip-appends-and-recomputes-duration",
+      "commands": [
+        { "op": "addClip", "payload": { "clip": { "id": "clip-d", "kind": "video", "nodeId": "node-d", "trackId": "video-1", "startMs": 8000, "durationMs": 2000, "sourceStartMs": 0, "sourceDurationMs": 2000 } } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" },
+          { "id": "clip-d", "kind": "video", "nodeId": "node-d", "trackId": "video-1", "startMs": 8000, "durationMs": 2000, "sourceStartMs": 0, "sourceDurationMs": 2000 }
+        ],
+        "durationMs": 10000
+      }
+    },
+    {
+      "name": "move-clip-keeps-duration",
+      "commands": [
+        { "op": "moveClip", "payload": { "id": "clip-a", "startMs": 2000 } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 2000, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "move-clip-across-tracks",
+      "commands": [
+        { "op": "moveClip", "payload": { "id": "clip-b", "startMs": 3000, "trackId": "video-2" } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-2", "startMs": 3000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 6000
+      }
+    },
+    {
+      "name": "trim-clip-duration-within-source",
+      "commands": [
+        { "op": "trimClip", "payload": { "id": "clip-b", "durationMs": 2000 } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 2000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 7000
+      }
+    },
+    {
+      "name": "trim-clip-start-and-source",
+      "commands": [
+        { "op": "trimClip", "payload": { "id": "clip-b", "startMs": 5500, "durationMs": 2000, "sourceStartMs": 3000 } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5500, "durationMs": 2000, "sourceStartMs": 3000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 7500
+      }
+    },
+    {
+      "name": "split-clip-in-two-deterministic-ids",
+      "commands": [
+        { "op": "splitClip", "payload": { "id": "clip-a", "splitAtMs": 3000 } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 3000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-a:split:3000", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 3000, "durationMs": 2000, "sourceStartMs": 3000, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "remove-clip-recomputes-duration",
+      "commands": [
+        { "op": "removeClip", "payload": { "id": "clip-c" } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "set-clip-property-whitelist-fields",
+      "commands": [
+        { "op": "setClipProperty", "payload": { "id": "clip-a", "patch": { "volume": 0.5, "fadeInMs": 200, "fadeOutMs": 400 } } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 0.5, "fadeInMs": 200, "fadeOutMs": 400 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "add-subtitle-clip",
+      "commands": [
+        { "op": "addSubtitle", "payload": { "clip": { "id": "sub-2", "kind": "subtitle", "nodeId": "node-b", "trackId": "subtitle-1", "startMs": 5200, "durationMs": 1800, "subtitleEntryIndex": 1, "text": "副标题字幕" } } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 },
+          { "id": "sub-1", "kind": "subtitle", "nodeId": "node-a", "trackId": "subtitle-1", "startMs": 500, "durationMs": 2000, "subtitleEntryIndex": 0, "text": "你好，影策" },
+          { "id": "sub-2", "kind": "subtitle", "nodeId": "node-b", "trackId": "subtitle-1", "startMs": 5200, "durationMs": 1800, "subtitleEntryIndex": 1, "text": "副标题字幕" }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "remove-subtitle-clip",
+      "commands": [
+        { "op": "removeSubtitle", "payload": { "id": "sub-1" } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          { "id": "video-1", "kind": "video", "label": "视频 1", "order": 0 },
+          { "id": "audio-1", "kind": "audio", "label": "音频 1", "order": 1 },
+          { "id": "subtitle-1", "kind": "subtitle", "label": "字幕 1", "order": 2 },
+          { "id": "video-2", "kind": "video", "label": "视频 2", "order": 3 }
+        ],
+        "clips": [
+          { "id": "clip-a", "kind": "video", "nodeId": "node-a", "trackId": "video-1", "startMs": 0, "durationMs": 5000, "sourceStartMs": 0, "sourceDurationMs": 10000, "volume": 1, "fadeInMs": 0, "fadeOutMs": 0 },
+          { "id": "clip-b", "kind": "video", "nodeId": "node-b", "trackId": "video-1", "startMs": 5000, "durationMs": 3000, "sourceStartMs": 2000, "sourceDurationMs": 8000 },
+          { "id": "clip-c", "kind": "audio", "nodeId": "node-audio", "trackId": "audio-1", "startMs": 1000, "durationMs": 4000, "sourceStartMs": 0, "sourceDurationMs": 4000, "volume": 0.8 }
+        ],
+        "durationMs": 8000
+      }
+    },
+    {
+      "name": "rebuild-subtitle-clips-replaces-stale-snapshots",
+      "commands": [
+        { "op": "rebuildSubtitleClips", "payload": { "nodeId": "node-a", "entries": [ { "index": 0, "startMs": 500, "endMs": 2500, "text": "你好，影策" }, { "index": 1, "startMs": 3000, "endMs": 4200, "text": "第二句字幕" } ] } }
+      ],
+      "expected": {
+        "version": 2,
+        "tracks": [
+          {"id": "video-1","kind": "video","label": "视频 1","order": 0},
+          {"id": "audio-1","kind": "audio","label": "音频 1","order": 1},
+          {"id": "subtitle-1","kind": "subtitle","label": "字幕 1","order": 2},
+          {"id": "video-2","kind": "video","label": "视频 2","order": 3}
+        ],
+        "clips": [
+          {"id": "clip-a","kind": "video","nodeId": "node-a","trackId": "video-1","startMs": 0,"durationMs": 5000,"sourceStartMs": 0,"sourceDurationMs": 10000,"volume": 1,"fadeInMs": 0,"fadeOutMs": 0},
+          {"id": "clip-b","kind": "video","nodeId": "node-b","trackId": "video-1","startMs": 5000,"durationMs": 3000,"sourceStartMs": 2000,"sourceDurationMs": 8000},
+          {"id": "clip-c","kind": "audio","nodeId": "node-audio","trackId": "audio-1","startMs": 1000,"durationMs": 4000,"sourceStartMs": 0,"sourceDurationMs": 4000,"volume": 0.8},
+          {"id": "node-a:subtitle:0","kind": "subtitle","nodeId": "node-a","trackId": "subtitle-1","startMs": 500,"durationMs": 2000,"subtitleEntryIndex": 0,"text": "你好，影策"},
+          {"id": "node-a:subtitle:1","kind": "subtitle","nodeId": "node-a","trackId": "subtitle-1","startMs": 3000,"durationMs": 1200,"subtitleEntryIndex": 1,"text": "第二句字幕"}
+        ],
+        "durationMs": 8000
+      }
+    }
+
+  ]
+}
diff --git a/web/test/mock-transcription.test.ts b/web/test/mock-transcription.test.ts
new file mode 100644
index 000000000..80a8d0694
--- /dev/null
+++ b/web/test/mock-transcription.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+
+import { mockTranscriptionEntries } from "@/lib/timeline/mock-transcription";
+
+describe("mockTranscriptionEntries", () => {
+    test("生成结果确定性：同输入同输出", () => {
+        expect(mockTranscriptionEntries("采访素材 A", 12_000)).toEqual(mockTranscriptionEntries("采访素材 A", 12_000));
+    });
+
+    test("条目区间单调递增且落在时长内", () => {
+        const entries = mockTranscriptionEntries("测试素材", 12_000);
+        expect(entries.length).toBeGreaterThan(0);
+        for (let i = 0; i < entries.length; i += 1) {
+            const e = entries[i];
+            expect(e.startMs).toBeGreaterThanOrEqual(0);
+            expect(e.endMs).toBeLessThanOrEqual(12_000);
+            expect(e.endMs).toBeGreaterThan(e.startMs);
+            if (i > 0) expect(e.startMs).toBeGreaterThanOrEqual(entries[i - 1].endMs);
+        }
+    });
+
+    test("空标题回退默认文本；过短时长返回空或受步长约束", () => {
+        const entries = mockTranscriptionEntries("", 12_000);
+        expect(entries.length).toBeGreaterThan(0);
+        expect(entries[0].text).not.toBe("");
+    });
+});
diff --git a/web/test/plugin-permission-check.test.ts b/web/test/plugin-permission-check.test.ts
new file mode 100644
index 000000000..f829c467a
--- /dev/null
+++ b/web/test/plugin-permission-check.test.ts
@@ -0,0 +1,134 @@
+import { afterAll, describe, expect, it } from "bun:test";
+
+import {
+    EDITOR_SLOT_REQUIRED_PERMISSION,
+    assertEditorPermission,
+    checkEditorPermission,
+    pluginMayRenderEditorSlot,
+    pluginPermissions,
+    requiredPermissionForEditorSlot,
+} from "@/lib/plugins/plugin-permission-check";
+import { registerPlugin, unregisterPlugin } from "@/lib/plugins/plugin-registry";
+import type { RegisteredPlugin } from "@/lib/plugins/plugin-types";
+
+const ALL_SLOTS = [
+    "timeline-panel",
+    "preview-renderer",
+    "inspector",
+    "asset-ingest",
+    "subtitle-tool",
+    "transcription-provider",
+    "export-renderer",
+    "ai-assistant",
+] as const;
+
+function fakePlugin(id: string, permissions: string[], slots: string[]): RegisteredPlugin {
+    return {
+        manifest: {
+            apiVersion: "yingce.plugin/v2",
+            id,
+            name: id,
+            version: "0.0.1",
+            description: "M5 测试插件",
+            author: "test",
+            surfaces: ["fullscreen"],
+            permissions,
+            trusted: false,
+            runtime: { backend: "trusted-backend", web: "declarative" },
+            contributes: { editorSlots: slots.map((slot) => ({ slot })) },
+        },
+    };
+}
+
+const FAKE_READ_ONLY_ID = "m5-test-read-only";
+const FAKE_FULL_ID = "m5-test-full";
+
+afterAll(() => {
+    unregisterPlugin(FAKE_READ_ONLY_ID);
+    unregisterPlugin(FAKE_FULL_ID);
+});
+
+describe("M5 权限表", () => {
+    it("8 个插槽每个都有精确的必需权限", () => {
+        // Record<EditorSlotKind, ...> 类型已保证键完整；运行期再兜底验证值与域合法。
+        const expected: Record<(typeof ALL_SLOTS)[number], string> = {
+            "timeline-panel": "timeline.command",
+            "preview-renderer": "timeline.read",
+            inspector: "timeline.command",
+            "asset-ingest": "timeline.command",
+            "subtitle-tool": "timeline.command",
+            "transcription-provider": "timeline.command",
+            "export-renderer": "export.run",
+            "ai-assistant": "timeline.read",
+        };
+        for (const slot of ALL_SLOTS) {
+            expect(EDITOR_SLOT_REQUIRED_PERMISSION[slot]).toBe(expected[slot]);
+            expect(requiredPermissionForEditorSlot(slot)).toMatch(/^(timeline\.read|timeline\.command|export\.run)$/);
+        }
+    });
+});
+
+describe("checkEditorPermission（fail-closed）", () => {
+    it("空权限集拒绝", () => {
+        expect(checkEditorPermission(null, "timeline.read")).toBe(false);
+        expect(checkEditorPermission(new Set<string>(), "timeline.read")).toBe(false);
+    });
+    it("声明含必需权限则放行，缺则拒", () => {
+        expect(checkEditorPermission(new Set(["timeline.command"]), "timeline.command")).toBe(true);
+        expect(checkEditorPermission(new Set(["timeline.read"]), "timeline.command")).toBe(false);
+    });
+});
+
+describe("pluginMayRenderEditorSlot", () => {
+    it("未注册插件 fail-closed 拒渲染", () => {
+        expect(pluginMayRenderEditorSlot("m5-test-ghost", "inspector")).toEqual({
+            allowed: false,
+            reason: "plugin-not-registered",
+            missing: null,
+        });
+    });
+    it("注册但缺权限 → 拒渲染并指出缺失权限", () => {
+        // 贡献 preview-renderer（只需 timeline.read）但想渲染 inspector（需 timeline.command）
+        registerPlugin(fakePlugin(FAKE_READ_ONLY_ID, ["timeline.read"], ["preview-renderer"]));
+        expect(pluginMayRenderEditorSlot(FAKE_READ_ONLY_ID, "inspector")).toEqual({
+            allowed: false,
+            reason: "missing-permission",
+            missing: "timeline.command",
+        });
+        // 只读插槽（preview-renderer）它反而有权限 → 放行，证明不是全量封杀
+        expect(pluginMayRenderEditorSlot(FAKE_READ_ONLY_ID, "preview-renderer").allowed).toBe(true);
+    });
+    it("权限齐备 → 放行", () => {
+        registerPlugin(
+            fakePlugin(FAKE_FULL_ID, ["timeline.read", "timeline.command", "export.run"], ["export-renderer"]),
+        );
+        for (const slot of ALL_SLOTS) {
+            expect(pluginMayRenderEditorSlot(FAKE_FULL_ID, slot).allowed).toBe(true);
+        }
+    });
+});
+
+describe("assertEditorPermission（命令代发断言）", () => {
+    it("未注册 → 抛错", () => {
+        expect(() => assertEditorPermission("m5-test-ghost", "timeline.command")).toThrow(/未注册/);
+    });
+    it("缺权限 → 抛错", () => {
+        expect(() => assertEditorPermission(FAKE_READ_ONLY_ID, "timeline.command")).toThrow(/缺少 timeline\.command/);
+    });
+    it("权限齐备 → 通过（不抛）", () => {
+        expect(() => assertEditorPermission(FAKE_FULL_ID, "export.run")).not.toThrow();
+    });
+});
+
+describe("editor-shell 真实回归（M5.2 接入后编辑器不得自我封锁）", () => {
+    // import 副作用注册 editor-shell；其 manifest 权限必须覆盖全部 8 个插槽的最小权限表。
+    it("editor-shell 全部 8 个插槽均可渲染", async () => {
+        await import("@/lib/plugins/builtin/editor/editor-shell");
+        const permissions = pluginPermissions("editor-shell");
+        expect(permissions).not.toBeNull();
+        for (const slot of ALL_SLOTS) {
+            const verdict = pluginMayRenderEditorSlot("editor-shell", slot);
+            expect(verdict.allowed, `editor-shell 渲染 ${slot} 应被允许`).toBe(true);
+        }
+    });
+});
diff --git a/web/test/timeline-summary.test.ts b/web/test/timeline-summary.test.ts
new file mode 100644
index 000000000..b2093c030
--- /dev/null
+++ b/web/test/timeline-summary.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { formatMs, summarizeTimeline } from "@/lib/timeline/timeline-summary";
+import type { TimelineProject } from "@/types/timeline";
+
+const commandsGolden = JSON.parse(
+    readFileSync(join(import.meta.dir, "fixtures/commands.golden.json"), "utf8"),
+) as { base: TimelineProject };
+
+describe("formatMs", () => {
+    test("毫秒转 m:ss", () => {
+        expect(formatMs(0)).toBe("0:00");
+        expect(formatMs(59999)).toBe("0:59");
+        expect(formatMs(60000)).toBe("1:00");
+        expect(formatMs(65000)).toBe("1:05");
+        expect(formatMs(600000 + 12000)).toBe("10:12");
+    });
+    test("负数钳制为 0", () => {
+        expect(formatMs(-500)).toBe("0:00");
+    });
+    test("小数取整", () => {
+        // Math.round(ms) 到毫秒再向下取秒：1500.6→1501ms→0:01；1501.9→1502ms→0:01
+        expect(formatMs(1500.6)).toBe("0:01");
+    });
+});
+
+describe("summarizeTimeline", () => {
+    test("确定性：同输入两次输出一致", () => {
+        expect(summarizeTimeline(commandsGolden.base)).toBe(summarizeTimeline(commandsGolden.base));
+    });
+    test("含时长、轨道数与片段统计", () => {
+        const s = summarizeTimeline(commandsGolden.base);
+        expect(s).toContain("总时长 0:08");
+        expect(s).toContain("4 条轨道");
+        expect(s).toContain("4 个片段");
+        expect(s).toContain("字幕 1");
+    });
+    test("轨道按 order 排序且逐行列 id/kind/label", () => {
+        const s = summarizeTimeline(commandsGolden.base);
+        const video1 = s.indexOf("video-1");
+        const audio1 = s.indexOf("audio-1");
+        const subtitle1 = s.indexOf("subtitle-1");
+        const video2 = s.indexOf("video-2");
+        expect(video1).toBeGreaterThan(-1);
+        expect(audio1).toBeGreaterThan(video1);
+        expect(subtitle1).toBeGreaterThan(audio1);
+        expect(video2).toBeGreaterThan(subtitle1);
+        expect(s).toContain("视频轨");
+        expect(s).toContain("音频轨");
+        expect(s).toContain("字幕轨");
+    });
+    test("片段逐行列出 id/kind/时间区间，文本被截断到安全长度", () => {
+        const s = summarizeTimeline(commandsGolden.base);
+        expect(s).toContain("clip-a");
+        expect(s).toContain("clip-b");
+        expect(s).toContain("clip-c");
+        expect(s).toContain("sub-1");
+        expect(s).toContain("0-5000ms");
+        expect(s).toContain("轨道 video-1");
+        expect(s).toContain("轨道 subtitle-1");
+    });
+    test("字幕 clip 计入字数统计", () => {
+        const s = summarizeTimeline(commandsGolden.base);
+        expect(s).toMatch(/字幕共 \d+ 字。/);
+    });
+    test("空时间线给出明确提示", () => {
+        const empty: TimelineProject = { version: 2, tracks: [], clips: [], durationMs: 0 };
+        const s = summarizeTimeline(empty);
+        expect(s).toContain("0 条轨道");
+        expect(s).toContain("（空时间线）");
+    });
+    test("片段总数超限时折叠（防上下文撑爆）", async () => {
+        const summaryModule = await import("@/lib/timeline/timeline-summary");
+        const manyClips = Array.from({ length: summaryModule.SUMMARY_MAX_CLIP_LINES + 10 }, (_, i) => ({
+            id: `c${i}`,
+            kind: "video" as const,
+            nodeId: `n${i}`,
+            trackId: "video-1",
+            startMs: i * 1000,
+            durationMs: 500,
+            sourceStartMs: 0,
+            sourceDurationMs: 500,
+        }));
+        const big: TimelineProject = {
+            version: 2,
+            tracks: [{ id: "video-1", kind: "video", label: "视频 1", order: 0 }],
+            clips: manyClips,
+            durationMs: manyClips.length * 1000,
+        };
+        const s = summarizeTimeline(big);
+        const counted = s.match(/^  - clip /gm)?.length ?? 0;
+        expect(counted).toBe(summaryModule.SUMMARY_MAX_CLIP_LINES);
+        expect(s).toContain("…其余 10 个片段省略");
+    });
+});
diff --git a/web/test/timeline-view.test.ts b/web/test/timeline-view.test.ts
new file mode 100644
index 000000000..d8725fba3
--- /dev/null
+++ b/web/test/timeline-view.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  getTimelinePxPerMs,
+  getTimelineVisualEndMs,
+  getTimelineTrackWidth,
+} from "../src/lib/timeline/timeline-view";
+
+describe("timeline-view pxPerMs 独立性", () => {
+  it("pxPerMs 仅由缩放级别决定，不随时长漂移", () => {
+    expect(getTimelinePxPerMs(1)).toBeCloseTo(0.096, 6);
+    expect(getTimelinePxPerMs(2)).toBeCloseTo(0.192, 6);
+    expect(getTimelinePxPerMs(1)).toBe(getTimelinePxPerMs(1));
+  });
+
+  it("拖动末片段（visualEndMs 增长）时 pxPerMs 保持恒定，轨道随内容等比扩展", () => {
+    const pxBefore = getTimelinePxPerMs(1);
+    const endBefore = getTimelineVisualEndMs([
+      { startMs: 0, durationMs: 1000 },
+      { startMs: 2000, durationMs: 500 },
+    ]);
+    // 模拟末片段向右拖 1 秒：startMs 2000 -> 3000
+    const endAfter = getTimelineVisualEndMs([
+      { startMs: 0, durationMs: 1000 },
+      { startMs: 3000, durationMs: 500 },
+    ]);
+    const pxAfter = getTimelinePxPerMs(1);
+
+    expect(endAfter).toBeGreaterThan(endBefore);
+    expect(pxAfter).toBe(pxBefore);
+    // 手势映射 deltaMs = deltaPx / pxPerMs，pxPerMs 恒定意味着同一位移映射到同一毫秒数
+    const deltaPx = 96;
+    expect(deltaPx / pxBefore).toBeCloseTo(deltaPx / pxAfter, 6);
+  });
+
+  it("面板公式：轨道宽度随时长等比扩展（pxPerMs 恒定）", () => {
+    // 面板内部公式：trackWidth = max(viewport, ceil(visualEndMs * pxPerMs))
+    const pxPerMs = getTimelinePxPerMs(1);
+    const trackW = (endMs: number) => Math.max(0, Math.ceil(endMs * pxPerMs));
+    // 时长 1500 -> 3500，宽度按同比例放大（等比），而非阶梯跳变
+    expect(trackW(3500) / trackW(1500)).toBeGreaterThan(2);
+  });
+});