diff --git a/docs/openapi/genarrative-external-v1.openapi.json b/docs/openapi/genarrative-external-v1.openapi.json
index 2bff16c14..5c3559d43 100644
--- a/docs/openapi/genarrative-external-v1.openapi.json
+++ b/docs/openapi/genarrative-external-v1.openapi.json
@@ -2569,7 +2569,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "图片 Data URL。quick-edit 最多 9 张，其它模式最多使用前 5 张。"
+              "description": "当前账号的 objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS 再提交。禁止 Data URL / Blob URL。普通生成最多使用前 5 张，数组上限为 9。"
             },
             "maxItems": 9
           },
@@ -2691,7 +2691,7 @@
           },
           "sourceImageSrc": {
             "type": "string",
-            "description": "待重绘/调整的图片 Data URL。"
+            "description": "待重绘/调整图片的稳定引用：当前账号的 objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。"
           },
           "projectId": {
             "type": [
@@ -2763,7 +2763,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "图片 Data URL、asset://、OSS object key 或公网 URL。"
+              "description": "当前账号的 objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。"
             },
             "maxItems": 8
           },
@@ -2892,13 +2892,13 @@
         "properties": {
           "referenceImageSrc": {
             "type": "string",
-            "description": "规范图/参考图 Data URL 或 objectKey；上传参考图优先提交 objectKey。"
+            "description": "图标规范的稳定引用：当前账号的 objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。"
           },
           "referenceImageSrcs": {
             "type": "array",
             "items": {
               "type": "string",
-              "description": "额外图标素材参考图 Data URL 或 objectKey；上传参考图优先提交 objectKey。"
+              "description": "额外图标素材参考图的稳定引用：objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。最多 8 张。"
             },
             "maxItems": 8
           },
@@ -2988,7 +2988,7 @@
         "properties": {
           "sourceImageSrc": {
             "type": "string",
-            "description": "UI 设计图 Data URL 或 objectKey。"
+            "description": "带红框标注的 UI 设计图稳定引用：当前账号的 objectKey、项目资源 ID 或素材 ID；浏览器内合成后必须先上传 OSS 再提交。禁止 Data URL / Blob URL。"
           },
           "screenColor": {
             "type": [
@@ -3006,7 +3006,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "额外 UI 素材参考图 Data URL 或 objectKey；上传参考图优先提交 objectKey。"
+              "description": "额外 UI 素材参考图的稳定引用：objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。最多 5 张。"
             },
             "maxItems": 5
           },
@@ -3273,7 +3273,8 @@
             "type": "string"
           },
           "sourceImageSrc": {
-            "type": "string"
+            "type": "string",
+            "description": "角色源图的稳定引用：当前账号的 objectKey、项目资源 ID 或素材 ID；本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。"
           },
           "sourceWidth": {
             "type": "integer",
@@ -3557,7 +3558,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "公网 URL、asset://、OSS object key 或图片 Data URL。仅 Seedance 2.0 系列支持。"
+              "description": "公网 URL、asset://、当前账号的 objectKey、项目资源 ID 或素材 ID。本地临时图必须先上传 OSS。禁止 Data URL / Blob URL。仅 Seedance 2.0 系列支持。"
             },
             "maxItems": 9
           },
@@ -3565,7 +3566,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "公网 URL、asset:// 或 OSS object key。仅 Seedance 2.0 系列支持。"
+              "description": "公网 URL、asset://、当前账号的 objectKey、项目资源 ID 或素材 ID。本地临时视频必须先上传 OSS。禁止 Data URL / Blob URL。仅 Seedance 2.0 系列支持。"
             },
             "maxItems": 3
           },
@@ -3573,7 +3574,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "description": "公网 URL、asset://、OSS object key 或音频 Data URL。仅 Seedance 2.0 系列支持。"
+              "description": "公网 URL、asset://、当前账号的 objectKey、项目资源 ID 或素材 ID。本地临时音频必须先上传 OSS。禁止 Data URL / Blob URL。仅 Seedance 2.0 系列支持。"
             },
             "maxItems": 3
           },
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 94e45925d..8276f29eb 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -15,6 +15,7 @@
 ```
 
 ---
+
 ## 2026-07-18 图片生成 K 档由 provider 直接生成
 
 - 背景：旧 gpt-image-2 尺寸表会把 2K 竖版回落到 `1024x1536`，图标入口又使用固定 `360x360 / 512x512` 占位；角色去背景结果变小时还会直接放大整张透明成品，导致 UI 显示的 2K 与模型实际生成清晰度不一致。
@@ -23,6 +24,21 @@
 - 验证方式：前端尺寸矩阵和入口占位测试、api-server 生成参数与 alpha 合成测试、platform-image 最终 request body 测试、类型检查、Rust check、编码和 diff 门禁。
 - 关联文档：`docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md`、`docs/【编辑器】画板图标素材生成入口设计-2026-06-15.md`、`docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md`。
 
+## 2026-07-18 阿里云 URL 抠图链路按外部调用阶段审计
+
+- 背景：阿里云 URL 抠图先从源 OSS GET，再解码、校验尺寸、归一化并上传临时 OSS；此前解码和尺寸失败仍使用普通 `InvalidRequest`，被错误标记为 `externalCallAttempted=false`，无法满足阿里云失败统一审计约定。
+- 决策：真正开始外部调用前的本地预检不写 `external_api_call_failure`；源 OSS GET 成功后发生的解码、尺寸、归一化、临时上传、阿里云请求和结果处理失败均进入审计。`platform-matting` 使用结构化 `LocalProcessing` 分类和 `failureStage`，由 api-server 映射为 `source_decode`、`source_validate`、`source_normalize`、`temp_upload`、`result_decode` 等阶段，不再把这些错误统称为“发请求前本地预检”。
+- 影响范围：`server-rs/crates/platform-matting/src/lib.rs`、`server-rs/crates/api-server/src/aliyun_matting.rs`、`server-rs/crates/api-server/src/external_api_audit.rs`、`server-rs/crates/api-server/src/editor_project.rs`、后端架构文档。
+- 验证方式：运行 `cargo test -p platform-matting --manifest-path server-rs/Cargo.toml`、阿里云抠图与外部审计定向测试、`cargo check -p api-server --manifest-path server-rs/Cargo.toml`、`npm run check:encoding` 和 `git diff --check`。
+
+## 2026-07-18 手动去背景稳定媒体引用校验收口
+
+- 背景：当前分支与 `master` 分别增加手动去背景专用 Data URL 校验和编辑器通用稳定媒体引用校验，直接叠加会让 API 与 worker 重复执行语义相同的 helper，并造成 `data:` / `blob:` 覆盖范围和错误文案漂移。
+- 决策：删除手动去背景专用校验。HTTP API 在入队前统一调用 `ensure_editor_reference_image_source_is_stable`，立即拒绝 `data:` / `blob:`；worker 不重复调用该入口校验，只通过 `resolve_editor_reference_object_key_for_owner` 完成稳定引用解析和 owner 归属校验。底层 `resolve_editor_reference_object_key` 在尝试 object key、项目资源 ID 或素材 ID 解析前统一拒绝内联媒体，作为历史任务和内部直接调用的最终边界。
+- 影响范围：`server-rs/crates/api-server/src/editor_project.rs`、图片画布手动去背景测试和图片画布技术方案；不改变队列 DTO、BgFilter `image_url` 协议或 SpacetimeDB 的编辑器任务 payload 门禁。
+- 验证方式：覆盖 API 入队前拒绝 `data:` / `blob:`、解析器拒绝内联媒体、worker 只调用稳定引用解析与归属校验；运行 api-server 编辑器定向测试、`cargo check -p api-server --manifest-path server-rs/Cargo.toml`、`npm run check:encoding` 和 `git diff --check`。
+- 关联文档：`docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md`、`docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md`。
+
 ## 2026-07-17 画布 Agent 普通消息不提供客户端停止
 
 - 背景：普通消息进入 LLM 前，后端已经把用户消息写入 OSS；前端中断 fetch 只能停止本地等待，不能保证后端停止规划，且会保留无法与后端消息对齐的 optimistic message。
@@ -47,6 +63,13 @@
 - 验证方式：后端定向测试断言三类任务正常成功都落透明主图与右侧 provider 原图、`generatedLayerId` 仍指向透明主图，图标 / UI 拆分素材继续排列在原图右侧，同时保留 source-only 失败降级测试；并运行 `cargo check -p api-server --manifest-path server-rs/Cargo.toml`、`npm run check:encoding` 和 `git diff --check`。
 - 关联文档：`docs/technical/【后端架构】外部生成Worker化方案-2026-06-03.md`、`docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md`。
 
+## 2026-07-17 生成后抠图原图以 OSS 作为内存生命周期边界
+
+- 背景：角色形象、图标图集、UI 素材图集和角色动作抽取帧的带背景原图虽然已先落私有 OSS，但 api-server 仍可能把原图字节保留到 BgFilter / 阿里云 / 本地 fallback 结束，造成并发任务下的内存峰值叠加。
+- 决策：目标链路的带背景原图上传 OSS 时消费 `DownloadedImage` 或动作帧字节所有权，不为上传克隆整张字节缓冲；上传完成后不再跨 BgFilter 调用常驻。手动去背景直接复用已有 OSS object key，不下载原图。BgFilter 只读取 600 秒签名 URL；进入阿里云 fallback 时由 `platform-matting` 新 URL 接口下载原图、上传 `AuthorizeFileUpload` 临时对象，并在开始阿里云推理前结束下载缓冲作用域；阿里云继续失败时，api-server 再从私有 OSS 独立下载原图供本地键色，产出后释放本次原图下载缓冲。
+- 边界：不改变接口 DTO、资源记录、画布原图展示、图集切分行为和降级顺序；“释放”指 Rust 所有权和 `Vec<u8>` 析构，RSS 不保证同步下降。
+- 验证方式：`platform-matting` 测试覆盖 URL 下载缓冲在临时上传后结束、降尺寸 Alpha 回贴；`api-server` 结构测试覆盖带背景原图 owned 上传、URL 阿里云 fallback、本地重新下载与原图释放；随后运行两个 crate 的测试与编译检查。
+
 ## 2026-07-17 图片改造保持源图与所选清晰度
 
 - 背景：图片画布从已生成的 2K 角色图重新打开生成器时，面板恢复逻辑会优先采用新建面板的 1K 默认值；即使用户重新选择 2K，角色透明化链路也可能接受 BgFilter / 阿里云返回的 1K 后处理图，并因 `nanobanana2` 使用标量清晰度档位而跳过几何尺寸恢复，最终把 2K provider 原图降为 1K 透明图。
@@ -55,6 +78,21 @@
 - 验证方式：覆盖“持久化 2K 角色图重开仍为 2K”“普通图片 / 角色 / 图标 / UI 改造的 2K 占位与目标一致”“普通生图、规范图和角色图生成中占位不回退 1K”“UI 提取和旧修改入口的完成占位使用业务目标尺寸”以及“较小去背结果只提供 alpha、最终 RGB 仍来自 2K provider 原图”的前后端定向测试，并运行前端类型检查、`cargo check -p api-server --manifest-path server-rs/Cargo.toml`、`npm run check:encoding` 和 `git diff --check`。
 - 关联文档：`docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md`、`docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md`。
 
+## 2026-07-15 BgFilter 输入改用私有 OSS 短期签名 URL
+
+- 背景：角色形象、图标图集、UI 素材图集、角色动作抽取帧和手动去背景在调用 BgFilter 前都已有私有 OSS object key；继续由 api-server 下载或保留图片并作为 multipart `file` 再上传，会重复传输图片字节并占用 API 进程网络与内存。
+- 决策：上述抠图链路统一复用 object key，签发 600 秒 OSS GET URL，并通过 BgFilter multipart 的 `image_url` 字段提交；请求中不再携带 `file`。签名 URL 只交给 BgFilter，不写日志或持久化。2026-07-17 起，生成原图和动作帧上传后不再保留图片字节；进入“阿里云通用抠图 → 本地键色”兜底链时按阶段从私有 OSS 重新下载。
+- 影响范围：`server-rs/crates/api-server/src/editor_project.rs`、`server-rs/crates/api-server/src/character_animation_assets.rs`、相关测试与文档；不改变 BgFilter endpoint、鉴权、`screen_color`、`seg_model`、输出校验、熔断规则、阿里云上传协议或降级顺序。
+- 验证方式：定向测试必须断言 BgFilter 请求函数包含 `image_url` 与 600 秒 OSS 换签，不包含 multipart `file` 或源图字节读取；随后运行 `cargo check -p api-server --manifest-path server-rs/Cargo.toml`。
+
+## 2026-07-15 阿里云通用抠图上传切换到 AuthorizeFileUpload 正式链路
+
+- 背景：`platform-matting` 原先通过 `viapiutils/GetOssStsToken` 获取临时 AK/SK，再向固定 `viapi-customer-temp` 共享桶执行 OSS V1 PUT。阿里云官方文档将该显式生成 URL 的共享临时桶通道标记为不保证 SLA、仅便于调试且不推荐生产使用；动作视频逐帧抠图会把这条风险放大到每任务 32 至 48 次。
+- 决策：非上海地域图片字节统一按新版官方 SDK `AdvanceRequest` 的实际协议处理：调用 `openplatform.aliyuncs.com` 的 `AuthorizeFileUpload` 获取单对象 `Bucket`、`Endpoint`、`AccessKeyId`、`EncodedPolicy`、`Signature` 与 `ObjectKey`；再以 multipart Policy POST 上传到动态返回的上海临时 OSS，表单字段为 `OSSAccessKeyId`（= AccessKeyId）、`policy`（= EncodedPolicy）、`Signature`、`key`（= ObjectKey）、`success_action_status=201` 与 `file`，最后把临时对象 URL 交给 `SegmentCommonImage`。移除 `GetOssStsToken`、固定 `viapi-customer-temp`、AccessKeySecret/SecurityToken 临时凭证组合和 OSS V1 SHA-1 签名；Policy POST 仍需要授权响应中的 `AccessKeyId`，不再下发可独立签名的完整临时密钥。图片归一化、结果下载、原尺寸 Alpha 回贴和上层降级顺序保持不变。该链路仍会让图片字节经过执行任务的 api-server / worker 并上传临时 OSS，不把它描述成阿里云服务端直接抓取任意公网 URL。
+- 影响范围：`server-rs/crates/platform-matting`、阿里云抠图冒烟示例、后端架构与开发运维文档；不改变 api-server DTO、动作拆帧、BgFilter 或业务降级契约。
+- 验证方式：`cargo test -p platform-matting --manifest-path server-rs/Cargo.toml`、`cargo check -p api-server --manifest-path server-rs/Cargo.toml`，并用真实图片运行 `segment_smoke`，确认授权上传 host 来自动态上海 OSS 且 `SegmentCommonImage` 成功返回。
+- 关联文档：`docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md`、`docs/【开发运维】本地开发验证与生产运维-2026-05-15.md`、阿里云“通用图像分割”与“文件 URL 处理”官方文档。
+
 ## 2026-07-15 角色动作 BgFilter 请求超时按帧数扩展
 
 - 背景：角色动作全部序列帧会并发进入 BgFilter，而服务端可能在自身进程内排队；固定 `180000ms` 会把排队时间和单帧推理共用同一预算，靠后的请求可能在服务仍正常处理时被 api-server 提前取消。
@@ -73,6 +111,8 @@
 
 ## 2026-07-14 手动去背景迁移到 BgFilter complex 模式
 
+> 后续更正：本条关于 multipart 图片文件输入的描述已由 2026-07-15「BgFilter 输入改用私有 OSS 短期签名 URL」和 2026-07-17「生成后抠图原图以 OSS 作为内存生命周期边界」取代；当前手动路径不下载原图，只提交 `image_url`。下文保留作历史记录。
+
 - 背景：图片画布手动“去除背景”此前单独代理 BiRefNet 服务；BgFilter 已增加 `background_mode=complex`，可直接处理非纯色背景，继续保留独立服务会形成重复的上游、配置和错误处理链路。
 - 决策：`POST /api/editor/images/background-removals` 保持前端与 BFF 契约不变，worker 改用现有 BgFilter 地址、token、超时和共享 HTTP client。multipart 提交图片文件、`background_mode=complex`、`seg_model=birefnet` 与 `cross_check=off`，不提交 `screen_color`。标准纯色背景的角色形象、图标 spritesheet、UI 素材提取和角色动作逐帧抠图继续使用 `background_mode=flat`。删除独立 BiRefNet base URL / timeout 配置；旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 仅作为 `GENARRATIVE_EDITOR_BGFILTER_TOKEN` 的兼容回退别名。
 - 影响范围：图片画布手动去背景 worker、BgFilter HTTP 协议、api-server 配置、资源元数据、前端 provider 展示和相关文档。
@@ -264,6 +304,8 @@
 
 ## 2026-07-05 BgFilter 失败时本地纯色去背兜底
 
+> 后续更正：本条关于手动去背景仍使用独立 BiRefNet BFF 的描述已由 2026-07-14「手动去背景迁移到 BgFilter complex 模式」、2026-07-15 OSS 签名 URL 决策和 2026-07-17 内存生命周期决策取代。下文保留作历史记录。
+
 - 背景：曾用一次性 BgFilter live probe 稳定复现 BgFilter 对 2K 输入返回 `HTTP 500 {"detail":"inference failed"}`，浏览器生成链路会因此收到“BgFilter 服务返回非成功状态”。
 - 决策：角色形象生成、图标 spritesheet 生成和 UI 设计图素材提取仍优先调用独立 BgFilter；若 BgFilter 请求失败、返回非成功状态、返回空图片或非法图片，api-server 记录 warning 后使用本地 `editor_green_screen` 按解析后的纯色背景执行确定性去背兜底，不中断生成。手动任意图片去背景仍只走独立 BiRefNet BFF，不使用该兜底。
 - 更正（截至 2026-07-10 实现）：BgFilter 失败/熔断后不再直接本地兜底，而是先走阿里云通用抠图，仅阿里云也失败才本地 `editor_green_screen` 键色兜底；口径统一见 2026-07-09「角色动作视频…阿里云抠帧」决策，并已扩展到本条的角色形象/图标/UI 三条静态生图链路。
@@ -273,6 +315,8 @@
 
 ## 2026-07-03 图片画布生成纯色背景资产接入 BgFilter
 
+> 后续更正：本条关于 multipart `file`、手动去背景独立 BiRefNet 配置以及 BgFilter 失败后直接本地兜底的描述，已分别由 2026-07-14、2026-07-15 OSS 签名 URL 决策和 2026-07-17 内存生命周期决策取代。下文保留作历史记录。
+
 - 背景：独立 BgFilter 服务已部署在 image host，并提供 `POST /bgfilter/remove-background`，支持显式 `screen_color` 和 `seg_model`。手动去背景已有独立 BiRefNet BFF，不能把两个服务的配置或语义混在一起。
 - 决策：角色形象生成、图标 spritesheet 生成和 UI 设计图素材提取在保存带纯色背景源图后，统一调用 BgFilter 生成透明 PNG；请求 multipart 字段为 `file`、`screen_color=<screenColor>` 和内部固定的 `seg_model=birefnet`。`segModel` 虽是后端可识别的内部兼容字段（另保留 `anime-seg`），但不向用户或外部 OpenAPI 暴露：当前 BgFilter 的内存与并发容量不适合由调用方自由切换模型。BgFilter 使用独立配置 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN`、`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS`，默认 base URL 为 `http://58.87.105.82/bgfilter`，默认请求超时 `180000ms`，token 未配置时复用 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN`。手动 `POST /api/editor/images/background-removals` 继续使用独立 BiRefNet 配置 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_BASE_URL`，不受 BgFilter 影响。BgFilter 参数里的 `seg_model=birefnet` 只表示 BgFilter 内部分割后端，不等于手动去背景的独立 BiRefNet 服务。若 BgFilter 失败，api-server 对这些标准纯色背景生成图使用本地 `editor_green_screen` 兜底；连续失败达到 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_FAILURE_THRESHOLD`（默认 `3`）后，`GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_COOLDOWN_SECONDS`（默认 `300`）内直接本地兜底。角色动作背景色和抠帧口径已由 2026-07-09 决策取代：角色动作同样使用多色自动决策，抽帧后优先阿里云通用抠图，失败再按选定背景色本地兜底。更正（截至 2026-07-10 实现）：BgFilter 失败与熔断期本条描述的「直接本地兜底」已过时——角色形象/图标/UI 三条静态生图链路同样先走阿里云通用抠图，仅阿里云也失败才本地 `editor_green_screen` 兜底。
 - 影响范围：`server-rs/crates/api-server/src/config.rs`、`server-rs/crates/api-server/src/editor_project.rs`、图片画布 MVP 文档和角色形象生成设计文档。
@@ -330,6 +374,8 @@
 
 ## 2026-06-29 图片画布手动抠图走远端 BiRefNet BFF
 
+> 后续更正：本条独立 BiRefNet 服务、专用 base URL 以及 api-server 下载并解析原图的实现，已由 2026-07-14「手动去背景迁移到 BgFilter complex 模式」、2026-07-15 OSS 签名 URL 决策和 2026-07-17 内存生命周期决策取代。下文保留作历史记录。
+
 - 背景：用户手动“去除背景”面对任意图片，前端 `chromaKey` 和标准绿幕后处理不适合复杂人物、自然背景或非纯色背景；远端 image host 已部署 BiRefNet 服务，需要让手动抠图走高质量模型，同时避免把服务令牌暴露到浏览器。
 - 决策：画布手动“去除背景”默认调用登录态同源 BFF `POST /api/editor/images/background-removals`。api-server 解析当前图片后代理到 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_BASE_URL/remove-background`，默认指向 `http://58.87.105.82/remove-background`，可选 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 只在服务端注入。api-server 对上游结果做字节和尺寸上限保护，并先落 OSS / asset object 再返回给前端。编辑器自己生成的标准绿幕资产不属于该决策，见 2026-06-30 绿幕契约收口。
 - 影响范围：api-server 编辑器图片接口、图片画布手动去背景、画布右上角任务侧栏、图片画布 MVP 技术文档。
@@ -467,6 +513,8 @@
 
 ## 2026-06-30 图片画布标准绿幕契约收口
 
+> 后续更正：本条关于生成资产只使用本地透明化、手动路径继续使用独立 BiRefNet 的描述，已由 2026-07-14、2026-07-15 OSS 签名 URL 决策和 2026-07-17 内存生命周期决策取代；当前 flat 链路为 `BgFilter → 阿里云 → 本地键色`。下文保留作历史记录。
+
 - 背景：角色形象、图标 spritesheet、UI 提取 spritesheet 和角色动作帧都要求模型生成标准绿幕，但提示词片段和后处理入口分散在多个模块中，容易把标准绿幕资产误接到远端 BiRefNet。
 - 决策：编辑器标准绿幕提示词和本地确定性绿幕透明化统一收口到 `server-rs/crates/api-server/src/editor_green_screen.rs`。手动 `POST /api/editor/images/background-removals` 继续面向用户任意图片并走 BiRefNet；编辑器自己生成的标准绿幕资产统一复用 `platform-image::generated_asset_sheets` 的本地透明化能力，不再依赖 BiRefNet。角色图、图标 spritesheet、UI 提取 spritesheet 和角色动作抽帧源图必须在绿幕透明化前先保存一份带绿幕原图到 OSS，便于追溯和重处理。
 - 影响范围：`editor_project.rs` 的角色图 / 图标图集 / UI 提取图集、`character_animation_assets.rs` 的编辑器角色动作帧、编辑器绿幕相关文档。
@@ -2427,7 +2475,7 @@
 ## 2026-05-07 server-rs Cargo 依赖集中到 workspace
 
 - 背景：`server-rs` 多 crate 已稳定成 DDD workspace，成员 `Cargo.toml` 中重复散写第三方版本和本地 path 依赖，升级 SpacetimeDB SDK、`serde`、`reqwest`、`tokio` 等依赖时容易漂移。
-- 决策：`server-rs/Cargo.toml` 的 `[workspace.dependencies]` 统一维护第三方依赖版本和 workspace 内部 crate path；成员 crate 默认使用 `{ workspace = true }`，只保留自身 feature、optional 或 target-specific 差异；OSS 与阿里云 OpenAPI 签名统一走 `sha2::Sha256` 对应的 V4/V3 口径。例外：`platform-matting` 向 VIAPI 官方临时 OSS 桶上传抠图输入时，因该临时桶接口要求 OSS V1 头签名，允许在该 crate 内部受限使用 `sha1` / `Hmac<sha1::Sha1>` 生成 V1 签名；该例外不得扩展到自有 OSS、通用阿里云 OpenAPI 或其它新链路。
+- 决策：`server-rs/Cargo.toml` 的 `[workspace.dependencies]` 统一维护第三方依赖版本和 workspace 内部 crate path；成员 crate 默认使用 `{ workspace = true }`，只保留自身 feature、optional 或 target-specific 差异；OSS 与阿里云 OpenAPI 签名统一走 `sha2::Sha256` 对应的 V4/V3 口径。2026-07-15 起，`platform-matting` 已移除 VIAPI 共享临时桶的 OSS V1 SHA-1 例外，改用 `AuthorizeFileUpload` 返回的 Policy POST 授权；后续不得恢复 crate 内 SHA-1 签名。
 - 影响范围：`server-rs/Cargo.toml`、所有 `server-rs/crates/*/Cargo.toml`、`platform-oss`、`platform-auth`、后续新增 Rust crate 或新增 Rust 依赖的开发流程。
 - 验证方式：修改 Cargo 配置后先执行 `cargo metadata --manifest-path server-rs\Cargo.toml --format-version 1 --no-deps`，再按影响范围执行 `cargo check`、DDD 边界检查和编码检查。
 - 关联文档：`docs/technical/RUST_WORKSPACE_DEPENDENCY_CONSOLIDATION_2026-05-07.md`。
diff --git a/docs/project-memory/shared-memory/pitfalls.md b/docs/project-memory/shared-memory/pitfalls.md
index 6362bfae8..5146ff880 100644
--- a/docs/project-memory/shared-memory/pitfalls.md
+++ b/docs/project-memory/shared-memory/pitfalls.md
@@ -122,8 +122,8 @@
 ## 画板参考图 objectKey 必须先做归属校验
 
 - 现象：画板生成、快速编辑、图标素材或 UI 素材提取如果允许直接提交 generated objectKey，用户只要知道其他账号的私有 objectKey，就可能让 api-server 签名读取并送给外部生成供应商。
-- 原因：Data URL 参考图可以直接解析，但 objectKey 是服务端私有对象引用；只校验 generated 前缀、mime 和大小不能证明它属于当前账号。
-- 处理：所有编辑器参考图入口统一走 `parse_editor_reference_image(state, owner_user_id, source)`；objectKey 分支必须先在当前账号的项目资源、素材库资产或 `asset_object` 中匹配 owner / bucket / key，再读取 OSS。图标素材等额外参考图必须真实传到 provider，不只写 metadata；图片快速编辑当前不开放额外参考图，若后续重开入口也必须沿用同一归属校验。
+- 原因：Data URL/Blob URL 只允许停留在浏览器临时态，正式编辑器引用必须先上传并经统一 resolver 校验归属。
+- 处理：所有私有对象引用在读取字节或签发 URL 前统一走 `resolve_editor_reference_object_key_for_owner(state, owner_user_id, source)`，先在当前账号的项目资源、素材库资产或 `asset_object` 中匹配 owner / bucket / key。只有确实需要图片字节的入口（生成 / 重绘 / 图标 / UI 提取等交给 provider 的路径）再走 `parse_editor_reference_image`（内部仍先 resolve，再下载 OSS 字节）；手动去背景等只签发短期 URL 的入口不要 `parse` 整图。图标素材等额外参考图必须真实传到 provider，不只写 metadata；图片快速编辑当前不开放额外参考图，若后续重开入口也必须沿用同一归属校验。
 - 验证：`cargo test -p api-server --manifest-path server-rs/Cargo.toml editor_reference`，并用前端 workflow 测试覆盖 `referenceImageSrcs` 进入图标生成请求；若快速编辑重开额外参考图，再补对应请求覆盖。
 - 关联：`server-rs/crates/api-server/src/editor_project.rs`、`server-rs/crates/spacetime-client/src/assets.rs`、`src/components/image-editor/useImageCanvasGenerationSubmissionWorkflow.ts`。
 
diff --git a/docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md b/docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md
index 045ca04b2..1ce81749b 100644
--- a/docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md
+++ b/docs/technical/【前端架构】图片画布编辑器MVP接入方案-2026-06-11.md
@@ -21,10 +21,10 @@
 - 生成资源右上角显示元数据按钮，点击打开独立元数据窗口。图片信息页不展示后端组装后的生图 Prompt，也不提供复制 Prompt；只展示该图片生成时用户在面板里提交的输入快照，包括普通生成提示词、规范表单字段、角色设定、图标素材描述、快速编辑提示词、重绘提示词，以及角色规范 / 常规参考图 / 图标规范 / 编辑参考图等参考图卡片，并提供“复制信息”复制当前可见字段。参考图输入快照只保存 `refType/refId` 行引用，其中 `refType="project-resource"` 指向 `editor_project_resource.resourceId`，`refType="asset"` 指向 `editor_asset.assetId`；不得把图片 Data URL、普通 URL 或 `objectKey` 写入 `generationInputs.references`。旧数据或上传图片没有输入快照时显示 `-`，禁止回退展示内部 Prompt。
 - 对生成资源执行重绘时，在右侧创建新的生成结果图层，并自动调整视图显示原图和新图；重绘面板不因提交成功自动关闭，便于连续改提示词。重绘 / 改造输入框只允许从 `generationInputs.fields` 中恢复用户可见输入快照，例如普通生成提示词、视频描述、音效 `prompt`、背景音乐 `gpt_description_prompt`、角色设定、UI 用户输入、图标素材描述、规范表单和宣发素材字段；禁止回退展示资源 `prompt` / `actualPrompt` 中的后端拼接 Prompt、固定生成模板或模型默认提示词。没有用户输入快照的旧图层打开改造时保持空输入，等待用户重新填写。
 - 图片生成 / 修改统一经 api-server BFF 接入 VectorEngine。普通生成、生成规范和重绘保留既有 `gpt-image-2` 路径；图片快速编辑统一打开框选区域 + 单提示词 + 模型选择面板，默认沿用原图模型，不展示参考图或比例 / 尺寸控件；其中生成规范类图片固定 `16:9`、`2K`、`gpt-image-2`，面板底部用与可编辑面板一致的比例 / 尺寸 / 模型胶囊按钮展示固定参数，但按钮为禁用态，不允许在该面板改比例、尺寸或模型。`生成角色形象` 与 `生成图标素材` 支持 `nanobanana2`（`gemini-3.1-flash-image-preview`）和 `gpt-image-2`，默认 `nanobanana2`，并在两类面板之间沿用用户上次选择的模型；两类面板不展示抠图背景色或抠图模型选择；前端用户路径固定提交 `screenColor=auto` 和 `segModel=birefnet`，由后端自动决策具体抠图背景色，`anime-seg` 作为内部保留能力不在用户界面暴露。`nanobanana2` 走 `/v1beta/models/{model}:generateContent`，请求体写入 `generationConfig.imageConfig.aspectRatio/imageSize`；`gpt-image-2` 走 `/v1/images/generations` 或 `/v1/images/edits`，请求体按 VectorEngine 文档映射 `size`。宣发素材三个工作流（游戏首图、详情五图、运营海报）固定使用 `gpt-image-2`，面板模型胶囊为禁用态，不提供 `nanobanana2` 入口；前端按 workflow 同时提交 `outputSize`、`aspectRatio` 和 `imageSize`，其中游戏首图为 `720x540 / 4:3`、详情单图为 `720x1280 / 9:16`、运营海报为 `1280x720 / 16:9`；后端收到 `kind: "publication-material"` 时也强制归一为 `gpt-image-2` 生成和计费，生成回填图层优先使用生成占位的 `originalWidth/originalHeight`，即使上游回包尺寸漂移也不得把宣发素材卡片变成随机 `1:1` 或 `4:3`。纯文本生成走 `/api/editor/images/generations`，重绘在前端优先复用当前图层 objectKey；尚未登记的本地图片先上传 OSS，再把 objectKey 交给同一图片生成 BFF，并在原图右侧生成一张新图；普通图层重绘作为 `quick-edit` 参考图提交，角色图层重绘必须按 `kind: "character"` 提交，继续套用角色生成器提示词限定、透明 PNG 后处理和角色资产持久化。`生成视频` 走 `/api/editor/videos/generations`，前端模型入口仅展示 Seedance 2.0 Fast / Seedance 2.0 / Kling 3.0 / Kling 3.0 Omni，不展示 Veo 入口，默认 Seedance 2.0 Fast；视频参数按当前正式面板支持的比例、时长、清晰度和声音开关提交，且 Seedance Fast 与 Seedance 标准版必须按各自真实模型 ID 独立映射，不得混用。生成结果以视频图层加入画布。纯文本生成入口采用 Lovart 式画布内占位图 + 锚定生成输入框：点击生成图片后以当前视口世界中心为目标，经统一 placement 避让后创建选中的灰色占位框，输入框跟随占位框显示；普通图片、角色、图标图集、UI 设计图及其重绘 / 改造入口必须在比例或清晰度恢复、切换时同步把占位框 `width/height/originalWidth/originalHeight` 更新为目标像素尺寸，生成中不得继续显示默认 1K 框；UI 素材提取的 1K / 2K 图集占位和旧图片修改入口也分别使用本次目标尺寸与源图真实尺寸。待生成、生成中和失败后保留的占位图都必须继续支持拖动，生成完成时真实生成图或视频落在最新占位框位置，输入框继续跟随新生成图层；占位图失焦时隐藏高亮边框、左上角生成器名称和右上角原始尺寸，重新聚焦时再显示，且名称 / 尺寸在画布缩小时按 viewport 反向缩放保持屏幕尺寸稳定；点击所有图片 / 视频生成入口并确认请求开始后，必须隐藏对应设置面板，只保留画布内占位图或原图预览，并在预览上显示 Lovart 式生成中遮罩，避免“面板仍占屏”或“预览一起消失”。图片快速编辑和重绘在调用图片 BFF 前必须把当前图层图片解析为已上传的 objectKey 或资源 ID；浏览器临时图片需先上传 OSS；视频素材快速编辑走视频生成 BFF，不允许走图片模型；角色动作的 `生成动画` 仍固定使用 `seedance2.0-fast` 动作 / 视频模型，角色动作素材的 `快速编辑` 按当前帧图片走图片编辑。前端不持有 provider 密钥；上游失败或配置缺失时恢复当前生成设置面板展示失败，不创建 mock 成功图。
-- 图片画布抠图统一使用 BgFilter 服务 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL/remove-background`，默认 `http://58.87.105.82/bgfilter/remove-background`，默认请求超时 `180000ms`（BgFilter CPU 推理）。手动去除背景面向用户任意图片，仍走登录态同源 BFF `POST /api/editor/images/background-removals` 和外部生成队列；worker 固定提交 `background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不提交 `screen_color`。首次请求失败后立即重试 `1` 次，两次都失败则返回最终错误；manual complex 不接入依赖纯色键值的阿里云 / 本地键色降级链，也不改变 flat 链路的熔断状态。手动与标准纯色背景两类模式共用 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN`、`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 和共享 HTTP client；BgFilter token 未配置时只兼容回退读取旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN`。所有令牌都只在服务端注入，前端不持有令牌。worker 对上游结果做响应字节和图片尺寸上限保护，并先落 OSS / asset object；接口只返回 `queueState`，有项目上下文时前端同时创建去背景生成占位并把 `canvasCompletion` 交给后端，完成后由后端写入结果图层和最新项目快照。
+- 图片画布抠图统一使用 BgFilter 服务 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL/remove-background`，默认 `http://58.87.105.82/bgfilter/remove-background`，默认请求超时 `180000ms`（BgFilter CPU 推理）。手动去除背景面向用户任意图片，仍走登录态同源 BFF `POST /api/editor/images/background-removals` 和外部生成队列；API 在入队前拒绝 `data:` / `blob:` 内联媒体，worker 将稳定引用解析为当前账号已登记的 OSS object key 并校验归属后签发 600 秒 URL，固定提交 `image_url`、`background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不下载原图，也不提交 `file` 或 `screen_color`。首次请求失败后立即重试 `1` 次，两次都失败则返回最终错误；manual complex 不接入依赖纯色键值的阿里云 / 本地键色降级链，也不改变 flat 链路的熔断状态。手动与标准纯色背景两类模式共用 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN`、`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 和共享 HTTP client；BgFilter token 未配置时只兼容回退读取旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN`。所有令牌都只在服务端注入，前端不持有令牌。worker 对上游结果做响应字节和图片尺寸上限保护，并先落 OSS / asset object；接口只返回 `queueState`，有项目上下文时前端同时创建去背景生成占位并把 `canvasCompletion` 交给后端，完成后由后端写入结果图层和最新项目快照。
 - 编辑器自己生成的标准纯色背景抠图资产在保存源图后统一调用 BgFilter `background_mode=flat`。角色形象生成、图标 spritesheet 生成、UI 设计图素材提取和角色动作的前端用户路径都固定把 `screenColor=auto` 注入请求体，但用户可见 `generationInputs.fields` 不再记录 `抠图背景色` 或 `抠图模型`；api-server 在组装 prompt 前调用背景决策模块，从 12 个候选色中选择具体 hex，最多重试 3 次，失败后兜底 `#CFEFFF`。后端仍保留手动 hex 解析能力供内部兼容。最终生图 prompt、动作视频实色背景和 BgFilter `screen_color` multipart 字段只接收解析后的具体 hex，不透传 `auto`。四条 flat 路径同时把默认 `segModel=birefnet` 传为 `seg_model`，并显式传 `cross_check`：角色形象生成和角色动作逐帧去背传 `on`，图标 spritesheet 和 UI 设计图素材提取传 `off`，不依赖 BgFilter 服务端默认值；后端仍保留识别 `anime-seg` 的内部兼容能力，但前端用户入口不展示也不提交 `seg_model`、`background_mode` 或 `cross_check`。flat 请求首次失败后立即重试 `1` 次；第二次仍失败、返回非成功状态、空图片或非法图片时，以及连续失败达到 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_FAILURE_THRESHOLD=3` 后的 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_COOLDOWN_SECONDS=300` 秒熔断期，api-server 都先调用阿里云通用抠图，只有阿里云失败才用本地 `editor_green_screen` 按同一 `screenColor` 兜底去背。角色动作生成的序列帧背景色已与生图统一：后端把源角色图合成到视觉决策出的具体 hex 后再图生视频；抽帧后逐帧进入同一条 `BgFilter（background_mode=flat，cross_check=on）→ 阿里云 → 本地键色` 链路。
-- 角色动作逐帧抠图在 api-server 内复用共享 BgFilter HTTP Client；每一次 HTTP attempt 使用“`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 基准值 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`，角色形象单图、图标、UI 和手动去背景仍使用基准值。该值是单个请求从发起到响应体读取完成的 timeout，不是整批帧或整项角色动作任务超时；单帧首次失败立即重试 `1` 次并重新计时，第二次仍失败才进入阿里云/本地降级链，整项任务另受 worker long-job 预算约束。全部 `32 / 40 / 48` 帧按“对应绿幕源图落 OSS → BgFilter/降级 → 透明帧落 OSS”连续加入无序在途流水线，允许响应乱序完成并在最终返回前按 `frameIndex` 恢复顺序；任一帧最终失败时仍排空全部已启动请求，整个动作任务失败退款，不发布缺帧动画。
-- 多产物生成以后端项目快照为唯一画布真相：同一任务实际产生的原始产物、抠图 / 透明化结果和拆分结果都要先登记为 `editor_project_resource`。角色形象、图标 spritesheet 和 UI 素材提取的纯色背景原图不能只留在 OSS。透明后处理成功时，处理结果保持主图层和 `generatedLayerId` 锚点，三类任务同时把 provider 原图作为第二个图层放在透明主结果右侧，图标和 UI 的实际拆分素材从 provider 原图右侧开始放置。透明背景处理最终失败时，只把已保存的原图作为主图完成占位，不放透明处理图，图标和 UI 不继续拆分。source-only fallback 的前端只消费后端返回的 `project` / `resource` 快照，不按缺失字段自行构造透明图、切片或图层；任务以 `completed + warning` 收口。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。通用 `warning.reason` 是可直接展示的完整原因，并优先于 `sliceWarning`；既有 `sliceWarning.reason` 只表示透明图成功后的自动拆分失败，保留后端原始诊断，inline 前端仅在展示时补充“图集已生成，但自动拆分未完成：”提示，queue worker 则把它归一为 BFF `warning` 字符串后由前端直接展示。无项目上下文时不创建项目资源或画布图层。
+- 角色动作逐帧抠图在 api-server 内复用共享 BgFilter HTTP Client；每一次 HTTP attempt 使用“`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 基准值 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`，角色形象单图、图标、UI 和手动去背景仍使用基准值。该值是单个请求从发起到响应体读取完成的 timeout，不是整批帧或整项角色动作任务超时；单帧首次失败立即重试 `1` 次并重新签发 OSS URL、重新计时，第二次仍失败才按 object key 进入阿里云/本地降级链，整项任务另受 worker long-job 预算约束。全部 `32 / 40 / 48` 帧按“对应绿幕源图上传 OSS 并释放原帧字节 → 以签名 URL 调 BgFilter/按 object key 降级 → 透明帧落 OSS”连续加入无序在途流水线，允许响应乱序完成并在最终返回前按 `frameIndex` 恢复顺序；任一帧最终失败时仍排空全部已启动请求，整个动作任务失败退款，不发布缺帧动画。
+- 多产物生成以后端项目快照为唯一画布真相：同一任务实际产生的原始产物、抠图 / 透明化结果和拆分结果都要先登记为 `editor_project_resource`，再通过一次 `canvasCompletion` 原子写入画布。角色形象、图标 spritesheet 和 UI 素材提取的纯色背景原图不能只留在 OSS。透明后处理成功时，处理结果保持主图层和 `generatedLayerId` 锚点，三类任务同时把 provider 原图作为第二个图层放在透明主结果右侧，图标和 UI 的实际拆分素材从 provider 原图右侧开始放置。透明背景处理最终失败时，只把已保存的原图作为唯一主图完成占位，不放透明处理图，图标和 UI 不继续拆分。source-only fallback 的前端只消费后端返回的 `project` / `resource` 快照，不按缺失字段自行构造透明图、切片或图层；任务以 `completed + warning` 收口。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。通用 `warning.reason` 是可直接展示的完整原因，并优先于 `sliceWarning`；既有 `sliceWarning.reason` 只表示透明图成功后的自动拆分失败，保留后端原始诊断，inline 前端仅在展示时补充“图集已生成，但自动拆分未完成：”提示，queue worker 则把它归一为 BFF `warning` 字符串后由前端直接展示。无项目上下文时不创建项目资源或画布图层。
 - 图片快速编辑面板只保留一个提示词输入框和模型选择，不展示额外参考图或比例 / 尺寸控件；原图 / 原素材作为 `/api/editor/images/edits` 的 `sourceImageSrc` 直接提交，不作为 `referenceImageSrcs`。完整图标图集 `icon-spritesheet` 支持快速编辑，拆分后的单个 `icon` 不提供该入口，前后端必须使用同一素材类型规则。打开快速编辑时画布必须自动平移缩放，让原素材完整落在可视区上半部分，底部面板固定出现在素材下方且不遮挡内容，竖屏 UI 素材也必须完整展示。快速编辑右侧显示矩形、椭圆、画笔框选工具，但进入时不默认启用；点击工具后显示选中态，再点同一工具取消启用。完成框选后，画布红色细框显示连续序号，提示词可按这些编号填写每个区域怎么改。点击 `修改` 后仍停留在当前快速编辑面板显示修改中，不创建独立 `Quick Edit Generator` 画布占位；生成成功后直接用结果覆盖原图图层，失败时保留当前面板并在错误红框中显示具体错误文案。
 - 底部生成类按钮每次点击都必须创建独立的画布生成对象；新建规范、角色形象或图标素材时，只切换当前编辑面板，不得销毁此前尚未生成或已生成后的其它生成对象状态。归档为非当前编辑对象的生成占位仍可拖动、删除和等待异步完成，完成 / 失败回写必须按生成对象 ID 读取最新占位状态，不能使用提交瞬间的旧快照。
 - 画布右上角提供自动隐藏任务侧栏。列表为空且侧栏关闭时只保留图标开关；生成或去背景任务进入时默认打开；用户可手动切换开关状态。进行中阶段只使用外部生成 BFF 返回的 `phaseDetail`：调用或等待图片 / 视频生成服务时显示“正在生成”，进入 BgFilter、逐帧抠图或手动去背景时显示“正在处理”；前端不得按耗时或任务类型猜测阶段。
@@ -87,8 +87,8 @@
 - `POST /api/editor/assets`：批量或单个创建账号级素材，登录态上传必须写入 OSS / asset object 引用和 `/<objectKey>` 轻量路径，不允许把 Data URL / signed URL 写入素材库。
 - `PATCH /api/editor/assets/{assetId}`：重命名素材或移动素材到文件夹。
 - `DELETE /api/editor/assets/{assetId}`：删除素材。已放入画布的 project resource 不被级联删除，避免旧画布丢图。
-- `POST /api/editor/images/generations`：按提示词调用 VectorEngine 生成图片。带 `model / aspectRatio / imageSize` 的用户生成必须把当前 K 档对应的真实像素直接传给 provider，前端占位与该请求尺寸使用同一映射；不得先请求固定 1K 再放大为 2K。角色生成可携带 `screenColor`、`segModel` 和 `referenceImageSrcs`；api-server 先保存带纯色背景源图，再调用 BgFilter 并传入 `screen_color=<screenColor>`、`seg_model=<segModel>`，透明处理成功时生成透明 PNG，最终失败时按前述多产物降级规则以原图主结果和通用 `warning` 收口。角色、图标图集和 UI 图集的透明处理正常成功但返回尺寸与 provider 原图不同时，只重采样透明图的 alpha 蒙版并应用回 provider 原图的原始分辨率 RGB，不放大低分辨率后处理成品。宣发素材携带 `kind: "publication-material"` 时固定归一为 `gpt-image-2`，不支持 `nanobanana2`，并继续按固定交付像素处理。`nanobanana2` 参考图作为 `inline_data` 进入 `generateContent`，`gpt-image-2` 参考图进入 edits；`nanobanana2` 的 `512 / 1024 / 2K` 是标量清晰度档位，后端保留 provider 输出几何尺寸，不按 `宽x高` 解析。从既有图层重新打开生成器且没有仍存活的对话框快照时，前端按该图层真实 `originalWidth / originalHeight` 恢复比例和清晰度，不得回落到新建面板的 1K 默认值。普通重绘继续走该接口并把当前图层图片作为参考图；图片快速编辑不走该接口。请求可携带 `projectId`、`assetFolderId`、`assetKind`、`generationInputs` 和 `sourceResourceId`，后端生成完成后在响应中返回实际产物的 project / resource / asset 快照。
-- `POST /api/editor/images/background-removals`：接收当前图片源，校验登录态后无条件创建外部生成任务，响应只返回 `queueState`。worker 由 api-server 解析图片文件，并通过共享 BgFilter HTTP client 调用 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL/remove-background`；multipart 固定为 `file + background_mode=complex + seg_model=birefnet + cross_check=off`，不包含 `screen_color`，首次失败立即重试 `1` 次，两次都失败返回最终错误。请求可携带 `projectId`、`targetLayerId`、`assetFolderId`、`assetLabel`、`sourceResourceId` 和 `canvasCompletion`，有 `canvasCompletion` 时完成后按生成占位写入结果图层，否则沿用旧的目标图层替换路径。令牌只在服务端通过 `GENARRATIVE_EDITOR_BGFILTER_TOKEN` 注入，未配置时兼容回退旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN`。
+- `POST /api/editor/images/generations`：按提示词调用 VectorEngine 生成图片。带 `model / aspectRatio / imageSize` 的用户生成必须把当前 K 档对应的真实像素直接传给 provider，前端占位与该请求尺寸使用同一映射；不得先请求固定 1K 再放大为 2K。普通图片的 provider 回图先留在内存，尺寸变换成功后只上传变换结果，变换失败则只上传 provider 原图，主结果只写一次 OSS 且不额外创建“原始输出”。角色生成可携带 `model`、`screenColor`、`segModel`、`aspectRatio`、`imageSize` 和 `referenceImageSrcs`；api-server 先保存带纯色背景源图，再调用 BgFilter 并传入 `screen_color=<screenColor>`、`seg_model=<segModel>`，透明处理成功时生成透明 PNG，最终失败时按前述多产物降级规则以原图主结果和通用 `warning` 收口。角色、图标图集和 UI 图集的透明处理正常成功但返回尺寸与 provider 原图不同时，只重采样透明图的 alpha 蒙版并应用回 provider 原图的原始分辨率 RGB，不放大低分辨率后处理成品。宣发素材携带 `kind: "publication-material"` 时固定归一为 `gpt-image-2`，不支持 `nanobanana2`，并继续按固定交付像素处理。`nanobanana2` 参考图作为 `inline_data` 进入 `generateContent`，`gpt-image-2` 参考图进入 edits；`nanobanana2` 的 `512 / 1024 / 2K` 是标量清晰度档位，后端保留 provider 输出几何尺寸，不按 `宽x高` 解析。从既有图层重新打开生成器且没有仍存活的对话框快照时，前端按该图层真实 `originalWidth / originalHeight` 恢复比例和清晰度，不得回落到新建面板的 1K 默认值。普通重绘继续走该接口并把当前图层图片作为参考图；图片快速编辑不走该接口。请求可携带 `projectId`、`assetFolderId`、`assetKind`、`generationInputs` 和 `sourceResourceId`，后端生成完成后在响应中返回实际产物的 project / resource / asset 快照。
+- `POST /api/editor/images/background-removals`：接收当前图片的 `objectKey`、`resourceId` 或 `assetId` 候选引用，登录态和稳定引用入口校验通过后创建外部生成任务，响应只返回 `queueState`。worker 才负责引用解析和归属校验，不下载原图；调用共享 BgFilter HTTP client 前签发 600 秒 OSS URL，multipart 固定为 `image_url + background_mode=complex + seg_model=birefnet + cross_check=off`，不包含 `file` 或 `screen_color`，首次失败立即重试 `1` 次，两次都失败返回最终错误。请求可携带 `projectId`、`targetLayerId`、`assetFolderId`、`assetLabel`、`sourceResourceId` 和 `canvasCompletion`，有 `canvasCompletion` 时完成后按生成占位写入结果图层，否则沿用旧的目标图层替换路径。令牌只在服务端通过 `GENARRATIVE_EDITOR_BGFILTER_TOKEN` 注入，未配置时兼容回退旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN`。
 - `POST /api/editor/icon-spritesheets/generations`：按图标规范图和素材描述数组生成 spritesheet；api-server 先保存带纯色背景 spritesheet 源图，透明处理成功后再保存透明 spritesheet 并尝试拆分。请求支持 `model`、`screenColor`、`segModel`、`aspectRatio`、`imageSize`、`priceMudPoints`、`projectId`、`assetFolderId` 和 `generationInputs`；`priceMudPoints` 必须来自编辑器生成计费配置中对应生图模型的尺寸档位（如 `nanobanana2` 的 `0.5K / 1K / 2K` 或 `gpt-image-2` 的 `1K / 2K`），后端用 `editor_generation_config` 校验后才调用上游；`nanobanana2` 走原生 `generateContent` 并写入 `generationConfig.imageConfig.aspectRatio/imageSize`，`0.5K` 传 `"512"`；`gpt-image-2` 走 `/v1/images/edits`。透明处理最终失败时只保存并返回原图主结果，不生成透明图或切片；透明图成功但拆分失败时保留整张透明图并返回 `sliceWarning`。响应只返回实际产物对应的 project / resource / asset 快照及可选通用 `warning`。
 - `POST /api/editor/ui-designs/assets/extractions`：前端把红色框选轮廓绘入本地临时图后，先将该图上传 OSS 并确认 asset object，再以返回的 `objectKey` 作为参考图入队；Data URL / Blob URL 只允许停留在上传前的浏览器临时态。接口固定 `gpt-image-2` 和自动决策纯色背景素材提取提示词生成素材 spritesheet；api-server 先保存带纯色背景 spritesheet 源图，透明处理成功后再保存透明 spritesheet 并按连通域尝试拆分为 `素材 1..N`，返回结构复用图标 spritesheet 响应。请求必须携带 `screenColor`、`segModel`、`aspectRatio: "1:1"`、`imageSize: "1K" | "2K"` 和 `priceMudPoints`；框选数量不超过 6 个时前端按 `1:1·1K` 与 gpt-image-2 1K 价格提交，超过 6 个时按 `1:1·2K` 与 2K 价格提交。后端必须在调用上游前校验比例、尺寸和泥点价格，只允许 `1:1 / 1K / 2K`。透明处理最终失败时只保存并返回原图主结果，不生成透明图或切片；透明图成功但拆分失败时保留整张透明图并返回 `sliceWarning`。请求可携带 `projectId`、`assetFolderId`、`generationInputs` 和 `spritesheetLabel`，响应只返回实际产物对应的 project / resource / asset 快照及可选通用 `warning`；前端按后端快照落画布，不补造缺失产物。
 - `POST /api/editor/images/edits`：按提示词和当前图片的已登记 `objectKey` / `resourceId` 修改图片，返回新的生成图片元数据；图片快速编辑当前只提交 `sourceImageSrc`，不提交隐藏的 `referenceImageSrcs`，并随用户当前选择提交 `model / aspectRatio / imageSize / size`。api-server 必须先归一模型再选择 VectorEngine 协议：`nanobanana2` 调用 `/v1beta/models/{model}:generateContent` 并把原图作为 `inline_data`、比例和清晰度写入 `generationConfig.imageConfig`；`gpt-image-2` 调用 `/v1/images/edits` multipart。gpt-image-2 路径在 provider 边界把目标尺寸和所有 multipart 参考图临时补齐到 16 的倍数，回图后在内存恢复业务目标尺寸；nanobanana2 路径保留 provider 按比例和清晰度返回的几何尺寸。成功时只上传最终结果，尺寸恢复失败时只上传 provider 原图；无论是否发生尺寸恢复都只创建一个 project resource / 账号素材，不显示重复“原始输出”。16 对齐尺寸不得泄漏到正常完成的最终响应、资源或图层 Resolution；变换失败降级时以实际 provider 原图尺寸为准。本地红框标记图必须先上传再提交 objectKey；请求携带 project / asset 上下文时由后端创建新 resource / asset，前端只消费响应快照。
@@ -138,7 +138,7 @@
 - 上传按钮和拖拽上传都支持多文件；底部工具栏的上传入口选择文件后直接进入“上传素材”并在当前画布视口中心创建画布图层，素材栏文件夹内的上传入口只写入对应素材文件夹、不自动入画布；拖到文件夹或该文件夹内素材时进入目标文件夹；拖到画布时进入“上传素材”并在投放点创建画布图层。上传图片必须在创建占位素材、画布图层和账号级素材记录前先读取原图 Resolution，图层宽高、`originalWidth/originalHeight` 和素材库 `width/height` 都使用图片本身尺寸；上传视频同样在创建素材和图层前读取视频 metadata 宽高，保证单层下载或 ZIP 导出的真实视频文件重新导入后仍按文件自身尺寸入画布；仅在无法解析尺寸时才使用对应媒体兜底尺寸。
 - 音频 / 视频素材卡和画布媒体图层必须提供稳定的非文字视觉预览：优先使用 `thumbnailSrc` / 视频 `poster`，没有真实首帧或音频封面时使用由媒体类型、素材名和地址派生的确定性视觉底图。视频图层使用原生 `<video controls preload="metadata" playsInline>` 播放，外层图层仍承接选择和拖拽语义；音频图层播放前继续通过 `/api/assets/read-url` 换签。画布素材导出按 `mediaType` 保留真实媒体格式：图片进入 `images/`，音频 / 视频进入 `media/`，文件扩展名从响应 MIME、`objectKey` 或源 URL 推断，不得把音频 / 视频导出成 PNG。
 - 画布素材 ZIP 的 `metadata.json` 只保存前端信息弹窗和导出文件列表可见的展示快照：项目标题、导出时间、图层标题、文件路径、类型、生成输入、模型显示名、Task 短 ID、Object 显示值、Resolution / 时长和导出错误。导出的生成输入只保留用户实际填写或选择的内容；系统默认兜底提示词、固定工作流提示词、内置图标描述、UI 提取素材固定提示词等内置提示词即使存在于历史 `generationInputs`，也不得写入导出元数据。不得把 `projectId`、`layerId`、`resourceId`、`sourceAssetId`、`sourceResourceId`、原始 `prompt` / `actualPrompt` / `provider` 或画布坐标、锁定、隐藏等布局状态写入导出元数据；Object 字段仅沿用信息弹窗当前可见值。
-- `生成角色动作` 的完成结果按序列帧素材处理：图层主 `src` 使用 `frames[0].imageSrc`，`mediaType` 固定为 `image-sequence`，`assetKind` 固定为 `character-animation`，完整帧列表写入 `imageSequenceFrames`；`previewVideoPath` 只保留为上游预览视频来源，不作为画布主媒体。下载和 ZIP 导出必须因此得到序列帧 ZIP / frames 目录，不能回退为预览视频或首帧 PNG；后端抽帧后先保存带绿幕帧源图，再走绿幕透明化后处理并落盘透明帧素材。
+- `生成角色动作` 的完成结果按序列帧素材处理：图层主 `src` 使用 `frames[0].imageSrc`，`mediaType` 固定为 `image-sequence`，`assetKind` 固定为 `character-animation`，完整帧列表写入 `imageSequenceFrames`；`previewVideoPath` 只保留为上游预览视频来源，不作为画布主媒体。下载和 ZIP 导出必须因此得到序列帧 ZIP / frames 目录，不能回退为预览视频或首帧 PNG；后端抽帧后逐帧保存带绿幕源图，上传时消费并释放原帧字节，再用该对象的 600 秒 OSS URL 完成透明化并落盘透明帧素材。
 - 素材面板支持按素材名、文件夹名、生成信息、模型、任务和媒体类型搜索，并支持选择模式框选，一次选中多个素材，并可批量移动或删除上传素材。
 - 图层面板支持按图层名、生成信息、模型、任务和媒体类型搜索；支持选择多个图层后创建图层组，组名和 groupId 随画布布局保存。
 - 小地图支持拖拽视口框，拖动时画布 viewport 跟随移动；`pointermove` 更新必须通过 `requestAnimationFrame` 合帧，结束拖拽时 flush 最后一帧，避免高频 pointermove 直接压垮 React 渲染和项目持久化链路。
diff --git a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
index a5bc0abfc..61815353a 100644
--- a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
+++ b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
@@ -238,14 +238,16 @@ npm run check:server-rs-ddd
 6. 编辑器图片生成 / 图片修改 / 图标 spritesheet / UI 设计图提取素材 / 视频 / 角色动作 / 音效 / 背景音乐必须在后端计算模型价格后使用 `execute_billable_asset_operation_with_cost` 预扣泥点；预扣失败必须 fail-closed，不得继续提交 VectorEngine、Ark、Suno 或 Vidu 上游任务。
 7. 队列任务按 `job_id + claim_attempt` 使用独立 consume/refund ledger。新 attempt 结算旧 attempt 时必须先写 `asset_operation_wallet_settlement`：旧 consume 已存在则原子退款，尚不存在则写取消 intent；迟到 consume 在同一 SpacetimeDB 事务内看到 intent 后必须失败关闭。重复 consume/refund 只有用户、金额、来源和配对 ledger 全部一致时才可视为幂等成功。lease 过期时只有 `attempt < max_attempts` 才能递增并重领；最终 attempt 已耗尽时，claim transaction 必须直接把 job 收口为 `failed`、清理 lease、写失败事件并结算当前 attempt，不能再把任务返回 worker 或调用 provider。
 8. 音频生成的编辑器链路虽然任务提交和结果发布分离，仍必须把提交时后端计算出的模型价格写入 `AudioAssetBindingTarget.billing_points_cost`，最终发布落资产时按该价格扣费；创作音频目标未提供该字段时才使用旧的创作音频固定成本。
-9. 编辑器进入外部生成持久队列的图片生成、图片修改、去背景、图标 spritesheet、UI 设计图提取、角色动作和视频参考图，只允许提交已登记的 generated `objectKey`、`resourceId` 或 `assetId`；任务 `request_payload_json` / `result_payload_json` 任意层级都禁止 `data:` / `blob:`，并受统一字节上限保护。objectKey 必须归属于当前账号的 `editor_project_resource`、`editor_asset` 或 `asset_object`，后端通过归属校验后才签名读取 OSS。本地红框序号标注图必须先上传并确认对象，再把 objectKey 入队；不得把既有 objectKey 下载成 Data URL 后写入任务。图标素材和 UI 素材提取的额外参考图必须真正传入 provider，不得只写入 `generationInputs` 展示快照；图片快速编辑当前不开放额外参考图。UI 素材提取额外参考图上限为 5 张，普通图片生成上限 5 张，图标素材上限 8 张额外参考图。同步且不持久化的历史兼容入口即使仍能解析 Data URL，也不能把该值转存到工程、素材、元数据、审计或任务表。
+9. 编辑器进入外部生成持久队列的图片生成、图片修改、去背景、图标 spritesheet、UI 设计图提取、角色动作和视频参考图，调用方必须提交 `objectKey` / `resourceId` / `assetId` 候选引用；BFF 只做内联媒体与 payload 门禁，登记状态和归属由 worker 统一解析。任务 `request_payload_json` / `result_payload_json` 任意层级都禁止 `data:` / `blob:`，并受统一字节上限保护。无效普通字符串可以入队，但必须在签名和 provider 调用前失败；本次不增加 API 侧数据库查询或同步 owner 校验。若以后要求无效引用同步返回 400，应作为独立改造。objectKey 最终必须归属于当前账号的 `editor_project_resource`、`editor_asset` 或 `asset_object`，由 worker 在解析后、签名读取 OSS 前完成归属校验。本地红框序号标注图必须先上传并确认对象，再把 objectKey 入队；不得把既有 objectKey 下载成 Data URL 后写入任务。图标素材和 UI 素材提取的额外参考图必须真正传入 provider，不得只写入 `generationInputs` 展示快照；图片快速编辑当前不开放额外参考图。UI 素材提取额外参考图上限为 5 张，普通图片生成上限 5 张，图标素材上限 8 张额外参考图。同步且不持久化的历史兼容入口即使仍能解析 Data URL，也不能把该值转存到工程、素材、元数据、审计或任务表。
 
 ## 外部服务与资产
 
 - LLM：通用 LLM 门面继续使用 `GENARRATIVE_LLM_*`；创意 Agent `gpt-5.4-mini` Chat Completions 文本链路已于 2026-06 从 APIMart 迁移到 VectorEngine，使用 `VECTOR_ENGINE_BASE_URL` / `VECTOR_ENGINE_API_KEY` 构造 OpenAI-compatible client，`api-server` 会把未带 `/v1` 的 VectorEngine base URL 规范化到 `/v1` 后请求 `/chat/completions`。通用 `/api/llm/chat/completions` 代理使用 `GENARRATIVE_LLM_PROVIDER=openai-compatible`、`GENARRATIVE_LLM_BASE_URL=https://api.vectorengine.cn/v1`、`GENARRATIVE_LLM_MODEL=gpt-5.4-mini`；未单独配置 `GENARRATIVE_LLM_API_KEY` 时可复用 `VECTOR_ENGINE_API_KEY`。`APIMART_BASE_URL` / `APIMART_API_KEY` 只作为历史残留，不再作为创意 Agent gpt-5.4-mini 客户端来源；后续排障时优先确认 VectorEngine `/v1/models`、`/v1/chat/completions` 和 `/v1/responses` 可用性。
 - 图片生成：VectorEngine `gpt-image-2` 图片 provider 归属 `platform-image`，密钥只在后端环境变量中；`api-server` 内的 `openai_image_generation.rs` 只是兼容调用面和外部失败审计桥接，不再承载 provider 协议实现。实际外部生成运行记录统一落 `tracking_event`，`event_key = external_generation_run`，metadata 记录开始 / 结束时间、耗时、状态、成功标记、失败原因、provider task id 和结果摘要，不再写回过时的 `ai_task`。DashScope 只按仍在使用的历史能力单独处理，不作为 GPT-image-2 兜底。VectorEngine `/v1/images/generations` 和 `/v1/images/edits` 上游 POST 使用 `libcurl` 发送；`reqwest` 只保留给参考图 URL 下载和响应中图片 URL 下载。`/v1/images/edits` 的 multipart 参考图必须作为 libcurl 文件上传 part 发送，字段名为 `image`，实现上使用 `Form::buffer(file_name, bytes)` 并设置 `Content-Type`；不能只用 `contents(...).filename(...)`，否则上游会把请求转码为缺少图片并返回 `image is required`。`request_send` 阶段的 curl timeout / connect error 按可重试传输错误处理，最多尝试 5 次，并使用指数退避加短抖动；排障时优先看 `attempt`、`max_attempts`、`retry_delay_ms`、`reference_image_bytes_total` 和 `request_params`，不要把 `SendRequest` 当成上游业务错误。
-- 编辑器抠图服务：手动 `POST /api/editor/images/background-removals` 与角色形象生成、图标 spritesheet 生成、UI 设计图素材提取、角色动作抽帧后的透明化统一走 BgFilter，配置为 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN` 和 `GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS`，默认 base URL 为 `http://58.87.105.82/bgfilter`，默认请求超时为 `180000ms`（BgFilter 当前为 CPU 推理，单次抠图较慢，必须留足超时）；旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 只作为 BgFilter token 的兼容回退别名，原手动去背景专用 base URL / timeout 配置已经删除。手动去背景固定传 `background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不传 `screen_color`；标准纯色背景四条链路固定传 `background_mode=flat`，并显式传 `screen_color=<screenColor>`、`seg_model=<segModel>` 和 `cross_check=<on|off>`，其中角色形象生成和角色动作逐帧去背传 `cross_check=on`，图标 spritesheet 生成和 UI 设计图素材提取传 `cross_check=off`。前端用户路径不展示抠图模型、模式或 cross-check，固定提交默认 `birefnet`，后端仍识别内部保留的 `anime-seg`；这些参数只属于后端内部供应商策略，不进入前端或外部 OpenAPI。标准纯色背景 BgFilter 调用失败，或连续失败达到 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_FAILURE_THRESHOLD`（默认 `3`）并在 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_COOLDOWN_SECONDS`（默认 `300`）内打开熔断时，继续复用“阿里云通用抠图 → 本地 `editor_green_screen` 键色扣除”兜底链，熔断期不得直接退化到本地兜底。角色动作视频生成的背景色已与生图链路统一：`screenColor=auto` 时由视觉 LLM（`gpt-5-mini`，Responses 协议、low 推理档）读源角色图自动决策，并经硬过滤器剔除与前景 / 皮肤撞色的候选，手动 hex 则尊重用户选择；透明源角色图在提交 Ark 图生视频前先合成到选定背景色实色，使视频背景等于抠图键色；抽帧后逐帧固定使用 `seg_model=birefnet`、`cross_check=on` 进入上述三段式链路。阿里云通用抠图配置为 `GENARRATIVE_ALIYUN_MATTING_ENABLED`、`GENARRATIVE_ALIYUN_MATTING_ENDPOINT`、`GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_ID`、`GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_SECRET` 和 `GENARRATIVE_ALIYUN_MATTING_REQUEST_TIMEOUT_MS`；未配置专用 AK/SK 时可复用 `ALIBABA_CLOUD_ACCESS_KEY_ID` / `ALIBABA_CLOUD_ACCESS_KEY_SECRET`，默认 endpoint 为 `imageseg.cn-shanghai.aliyuncs.com`。标准纯色背景链路的 BgFilter 与阿里云抠图失败都写入 `external_api_call_failure` 审计。
-- BgFilter 连接复用、重试与动作帧流水线：api-server 必须在 `AppState` 复用同一个 BgFilter HTTP Client 及 keep-alive 连接池。`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 是所有路径的基准请求超时；角色动作逐帧 BgFilter 的每一次 HTTP attempt 使用“基准超时 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`，角色形象单图、图标、UI 和手动去背景仍使用基准值。api-server 只在共享 Client 的单次 RequestBuilder 上覆盖该值；它覆盖从请求发起到响应体读取完成，是单次 attempt 的总 deadline，不是整批帧或 worker job 超时，重试会重新获得同样的 deadline，整项任务仍受 worker long-job 预算约束。flat 与 complex 请求首次失败后都立即重试 `1` 次；标准纯色背景 flat 请求第二次仍失败才进入“阿里云通用抠图 → 本地键色”降级链，手动 complex 请求第二次仍失败则返回最终错误，不接入依赖纯色键值的降级链，也不改变 flat 路径的熔断状态。角色动作全部 `32 / 40 / 48` 帧按“单帧绿幕源图先落 OSS → BgFilter/降级 → 透明帧落 OSS”独立流水化，使用覆盖本次全部帧的无序在途集合连续发射，不在 api-server 增加供应商进程锁或固定小并发窗口；返回结果携带原始帧序并在收口时排序。任一帧最终失败时必须先排空全部已启动 Future，再让整个动作任务失败退款，不能发布缺帧动画。
+- 抠图输入以私有 OSS 作为内存生命周期边界：生成原图和角色动作抽取帧上传时消费图片字节所有权，上传完成后不保留原图缓冲；手动去背景直接解析并校验已有 OSS object key，不下载原图。BgFilter 必须为 object key 签发 600 秒 GET URL 并通过 multipart `image_url` 提交，不用 `file` 重传；flat 链路进入阿里云 fallback 时由 `platform-matting` URL 接口单独下载并上传 `AuthorizeFileUpload` 临时对象，在推理前释放下载缓冲，继续 fallback 到本地键色时再单独下载一次原图，本地产出后释放本次原图下载缓冲。签名 URL 不得写入日志、审计或持久化。
+- 阿里云通用抠图的非上海地域输入不得使用 `viapiutils/GetOssStsToken`、固定 `viapi-customer-temp` 或 OSS V1 PUT。`platform-matting` 必须按官方新版 SDK Advance 协议调用 `AuthorizeFileUpload`，使用动态返回的单对象 Policy 执行 multipart POST，再把临时上海 OSS URL 交给 `SegmentCommonImage`；输入归一化、结果下载与原尺寸 Alpha 回贴继续留在同一适配器内。该协议仍上传图片字节，不等同于阿里云服务端直接抓取任意公网 URL，也不改变上层 BgFilter → 阿里云 → 本地降级顺序。
+- 编辑器抠图服务：手动 `POST /api/editor/images/background-removals` 与角色形象生成、图标 spritesheet 生成、UI 设计图素材提取、角色动作抽帧后的透明化统一走 BgFilter，配置为 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN` 和 `GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS`，默认 base URL 为 `http://58.87.105.82/bgfilter`，默认请求超时为 `180000ms`（BgFilter 当前为 CPU 推理，单次抠图较慢，必须留足超时）；旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 只作为 BgFilter token 的兼容回退别名，原手动去背景专用 base URL / timeout 配置已经删除。手动去背景固定传 `image_url`、`background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不传 `file` 或 `screen_color`；该 API 接收 `objectKey`、`resourceId` 或 `assetId` 候选引用；BFF 入队前统一拒绝 `data:` / `blob:`；worker 不重复入口校验，只调用 `resolve_editor_reference_object_key_for_owner`，底层 resolver 在解析引用前拒绝内联媒体，并在签名前完成登记状态和 owner 校验；直接签发 OSS URL，不下载原图。标准纯色背景四条链路固定传 `background_mode=flat`，并显式传 `image_url`、`screen_color=<screenColor>`、`seg_model=<segModel>` 和 `cross_check=<on|off>`，其中角色形象生成和角色动作逐帧去背传 `cross_check=on`，图标 spritesheet 生成和 UI 设计图素材提取传 `cross_check=off`。前端用户路径不展示抠图模型、模式或 cross-check，固定提交默认 `birefnet`，后端仍识别内部保留的 `anime-seg`；这些参数只属于后端内部供应商策略，不进入前端或外部 OpenAPI。标准纯色背景 BgFilter 调用失败，或连续失败达到 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_FAILURE_THRESHOLD`（默认 `3`）并在 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_COOLDOWN_SECONDS`（默认 `300`）内打开熔断时，继续复用“阿里云通用抠图 → 本地 `editor_green_screen` 键色扣除”兜底链，熔断期不得直接退化到本地兜底。角色动作视频生成的背景色已与生图链路统一：`screenColor=auto` 时由视觉 LLM（`gpt-5-mini`，Responses 协议、low 推理档）读源角色图自动决策，并经硬过滤器剔除与前景 / 皮肤撞色的候选，手动 hex 则尊重用户选择；透明源角色图在提交 Ark 图生视频前先合成到选定背景色实色，使视频背景等于抠图键色；抽帧后每帧先上传私有 OSS 并释放原帧缓冲，再以该 object key 的签名 URL 固定使用 `seg_model=birefnet`、`cross_check=on` 进入上述三段式链路。阿里云通用抠图配置为 `GENARRATIVE_ALIYUN_MATTING_ENABLED`、`GENARRATIVE_ALIYUN_MATTING_ENDPOINT`、`GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_ID`、`GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_SECRET` 和 `GENARRATIVE_ALIYUN_MATTING_REQUEST_TIMEOUT_MS`；未配置专用 AK/SK 时可复用 `ALIBABA_CLOUD_ACCESS_KEY_ID` / `ALIBABA_CLOUD_ACCESS_KEY_SECRET`，默认 endpoint 为 `imageseg.cn-shanghai.aliyuncs.com`。标准纯色背景链路中，BgFilter 调用失败和阿里云抠图链路已开始后的失败（包括源 OSS GET 成功后的解码、尺寸校验和归一化失败）都写入 `external_api_call_failure` 审计；真正开始外部调用前的本地预检不写该审计，并在 `failureStage` 中保留 `source_decode`、`source_validate` 等阶段。
+- BgFilter 连接复用、重试与动作帧流水线：api-server 必须在 `AppState` 复用同一个 BgFilter HTTP Client 及 keep-alive 连接池。`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 是所有路径的基准请求超时；角色动作逐帧 BgFilter 的每一次 HTTP attempt 使用“基准超时 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`，角色形象单图、图标、UI 和手动去背景仍使用基准值。api-server 只在共享 Client 的单次 RequestBuilder 上覆盖该值；它覆盖从请求发起到响应体读取完成，是单次 attempt 的总 deadline，不是整批帧或 worker job 超时，重试会重新签发 600 秒 OSS URL 并获得同样的 request deadline，整项任务仍受 worker long-job 预算约束。flat 与 complex 请求首次失败后都立即重试 `1` 次；标准纯色背景 flat 请求第二次仍失败才进入“阿里云通用抠图 → 本地键色”降级链，手动 complex 请求第二次仍失败则返回最终错误，不接入依赖纯色键值的降级链，也不改变 flat 路径的熔断状态。角色动作全部 `32 / 40 / 48` 帧按“单帧绿幕源图 owned 上传 OSS 并释放原帧 → 以签名 URL 调 BgFilter/按 object key 降级 → 透明帧落 OSS”独立流水化，使用覆盖本次全部帧的无序在途集合连续发射，不在 api-server 增加供应商进程锁或固定小并发窗口；返回结果携带原始帧序并在收口时排序。任一帧最终失败时必须先排空全部已启动 Future，再让整个动作任务失败退款，不能发布缺帧动画。
 - Match3D 物品 sheet：关卡整图完成后走 VectorEngine `/v1/images/edits` multipart `image`，模型为 `gpt-image-2`，`2K 1:1` 输出 `10*10` spritesheet；物品 sheet prompt 固定要求单一纯绿色 `#00FF00 / RGB(0,255,0)` 绿幕背景，后端上传 OSS 前必须把绿幕扣成透明 PNG，并把透明整图写入 `itemSpritesheetImageSrc/itemSpritesheetImageObjectKey`。后端优先按透明 alpha 连通域从该 sheet 识别真实素材矩形并持久化 20 个物品、每个 5 个形态；识别数量不足时才回退 `10*10` 固定网格。通用系列素材图集的行列索引按每行 2 个物品计算，必须落在 `1..=10`，难度只决定运行态加载 3 / 9 / 15 / 20 种。
 - Match3D UI spritesheet 和背景派生图：关卡整图作为参考图并发生成 `1K 1:1` UI spritesheet 与 `1K 9:16` 背景图，模型均为 `gpt-image-2`。UI spritesheet prompt 固定要求单一纯绿色 `#00FF00 / RGB(0,255,0)` 绿幕背景，后端上传 OSS 前必须把绿幕扣成透明 PNG；背景图必须合成为全画幅不透明 PNG。
 - Match3D 1:1 容器 UI：VectorEngine `/v1/images/edits` multipart 参考图。该容器参考图是后端生图协议输入，必须通过 `include_bytes!` 随 `api-server` 编译进二进制，避免 API 单独发布或运行目录缺少 `public/` 时生成失败。
diff --git a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
index 9903561f0..5f19e904f 100644
--- a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
+++ b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
@@ -68,7 +68,11 @@ HTTP 角色的 `GENARRATIVE_SPACETIME_POOL_SIZE` 只表示 procedure / reducer 
 lease 过期后不代表任务一定再次执行：claim transaction 只有在 `attempt < max_attempts` 时才会递增 attempt 并返回 worker；如果过期的是最终 attempt，则直接把 job 收口为 `failed`、清理 lease，并按入队冻结价格为当前 attempt 原子退款或写 cancellation intent。该终态任务不会再次进入 provider executor，迟到 consume 会被 settlement intent 拒绝。
 
 图片画布角色图、图标素材、UI 素材提取和角色动作逐帧去背景时优先调用 BgFilter；当前全部调用都显式传 `background_mode=flat`，保持单一纯色背景抠图语义。默认 `GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS=180000`，该值是所有路径的基准请求超时；角色动作逐帧请求的每一次 HTTP attempt 额外增加 `2000ms × 本次实际帧数`，默认 `32 / 40 / 48` 帧对应 `244000 / 260000 / 276000ms`，角色形象单图、图标、UI 和手动去背景继续使用基准值。该 request timeout 不是整批帧或整项任务超时，首次失败后的重试会重新计时；角色动作整项任务仍受默认 `GENARRATIVE_EXTERNAL_GENERATION_WORKER_LONG_JOB_TIMEOUT_SECONDS=1800` 预算约束，排查时以 `editor_bgfilter_request_start.timeout_ms` 确认实际值。连续失败达到 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_FAILURE_THRESHOLD=3` 后熔断 `GENARRATIVE_EDITOR_BGFILTER_CIRCUIT_COOLDOWN_SECONDS=300` 秒。BgFilter 调用失败和熔断期均先走阿里云通用抠图，只有阿里云失败才走本地幕布色去背景兜底。阿里云这层默认 `GENARRATIVE_ALIYUN_MATTING_ENABLED=true`，但必须在 `api-server.env` 填入 `GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_ID` / `GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_SECRET`（或标准 SDK 命名 `ALIBABA_CLOUD_ACCESS_KEY_ID` / `ALIBABA_CLOUD_ACCESS_KEY_SECRET`）才会真正启用；AccessKey 缺失时启动日志会打印「阿里云抠图 AccessKey 未配置，跳过抠图客户端初始化」，抠图直接塌成 BgFilter→本地两级，`npm run check:api-server-env` 也会给出对应告警。修改这些变量后需要重启对应 `api-server` / worker 进程；排查时先从 worker 启动日志确认 lease 和 job timeout，再看带 `background_mode=flat` 的 `editor_bgfilter_request_start`、`editor_bgfilter_fallback_to_aliyun_matting`、`editor_bgfilter_circuit_open_fallback_to_aliyun_matting`，以及阿里云失败后的 `editor_aliyun_matting_fallback_to_local_screen_background_removal` 日志。
-手动 `POST /api/editor/images/background-removals` 同样调用 BgFilter，但固定传 `background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不传背景色；首次失败后立即重试 `1` 次，两次都失败则返回最终错误。它不进入只适用于已知纯色背景的阿里云 / 本地键色兜底链，也不改变 flat 路径的熔断状态。标准纯色背景四条链路仍固定传 `background_mode=flat`。两种模式统一使用 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN`、`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 和共享 HTTP client；旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 只保留为 token 兼容别名。
+手动 `POST /api/editor/images/background-removals` 同样调用 BgFilter，但 worker 只解析并校验已有 OSS object key，直接签发 600 秒 URL，不下载原图；multipart 固定传 `image_url`、`background_mode=complex`、`seg_model=birefnet`、`cross_check=off`，不传 `file` 或背景色。首次失败后立即重试 `1` 次，两次都失败则返回最终错误。它不进入只适用于已知纯色背景的阿里云 / 本地键色兜底链，也不改变 flat 路径的熔断状态。标准纯色背景四条链路仍固定传 `background_mode=flat`。两种模式统一使用 `GENARRATIVE_EDITOR_BGFILTER_BASE_URL`、`GENARRATIVE_EDITOR_BGFILTER_TOKEN`、`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 和共享 HTTP client；旧 `GENARRATIVE_EDITOR_BACKGROUND_REMOVAL_TOKEN` 只保留为 token 兼容别名。
+
+阿里云通用抠图的非上海地域输入使用 `AuthorizeFileUpload → Policy POST → SegmentCommonImage` 正式链路，上传 Bucket / Endpoint / ObjectKey 由阿里云动态返回；不得恢复 `GetOssStsToken`、固定 `viapi-customer-temp`、临时 AK/SK 或 OSS V1 PUT。该切换不新增环境变量；真实链路冒烟可运行 `cargo run -p platform-matting --example segment_smoke --manifest-path server-rs/Cargo.toml -- <图片路径>`，预期日志中的输入 host 为授权响应返回的上海 OSS host，并完成结果下载。图片字节仍经过执行任务的 api-server / worker，排障时不要把 Advance 路径误判为阿里云直接抓取任意公网 URL。
+
+BgFilter 对已经落入私有 OSS 的生成原图、动作抽取帧和手动去背景源图直接使用 600 秒签名 URL：`api-server` 的 multipart 提交 `image_url` 及对应模式参数，不再提交 `file`，也不会在 BgFilter 调用前重新下载 OSS 对象。生成原图和动作帧上传完成后应已消费并释放字节所有权；手动路径从始至终不读取原图字节。flat 路径的 BgFilter 失败或熔断打开后，阿里云 fallback 才单独下载源对象并上传动态临时桶，临时上传完成即释放本次下载缓冲；阿里云继续失败时本地 fallback 再独立下载，并在本地处理产出后释放本次原图缓冲。排障日志只应出现 object key 与签名有效期，不得记录带 `x-oss-*` 查询参数的完整 URL。这里的释放是 Rust 缓冲析构，不以操作系统 RSS 立即下降作为判据。
 
 `我的` 页签或排障面板展示队列等待时，只读取 BFF 队列接口：`GET /api/runtime/external-generation/queue-overview` 查看当前用户可见队列概览，`GET /api/runtime/external-generation/jobs/{jobId}` 查看单 job 状态。生成页 / 进度页不承接队列概览，只展示当前玩法业务进度；队列接口只提供等待 / 运行 / 失败 / 完成状态补充，最终草稿、作品和结果页仍要轮询对应玩法 session/detail 接口收敛到 ready 或 failed；不要直接查询 `external_generation_job` private table，也不要把 worker 内部 payload 暴露到前端。
 
diff --git a/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md b/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
index 6a29a90b2..6aeb9e5aa 100644
--- a/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
+++ b/docs/【编辑器】宣发素材工具演示入口设计-2026-06-17.md
@@ -55,7 +55,7 @@ Prompt 输入摘要与 Prompt 约束只作为内部生成契约维护，不在 U
 - 宣发素材请求携带 `kind: publication-material`，前端提交和后端 handler 都固定归一为 `gpt-image-2`；即使旧前端或外部请求传入 `nanobanana2`，后端也按 `gpt-image-2` 生成和计费，但价格仍来自运行时模型定价配置，不写死数值。
 - `publication-detail-gallery` 不再携带 `candidateCount: 5`；后端仍兼容多候选请求，但当前宣发素材入口不主动批量生成。
 - 尺寸请求和成品交付规格必须使用明确像素值：游戏首图 `720x540`、详情图 `720x1280`、运营海报 `1280x720`。这些值是画布图层与成品的业务规格；由于三种规格并非都满足 `gpt-image-2` 的上游尺寸约束，VectorEngine 适配层会在发送前等比归一到合法请求尺寸（最大边 `3840`、两边为 `16` 的倍数、长短边比不超过 `3:1`、总像素 `655360..8294400`），不能将上游归一后的尺寸当作宣发成品规格。只有 `16:9`、`9:16`、`2k` 等比例 / 档位别名才走 provider 预设映射。
-- 参考图在提交 `/api/editor/images/generations` 前由前端压缩成适合生成理解的图片 Data URL，避免原图 Data URL 撑爆 JSON 请求体；后端该路由保留 `12MB` body limit 作为兼容兜底。
+- 参考图在提交 `/api/editor/images/generations` 前必须先落稳定引用：本地图先上传 OSS 并确认 asset object，提交时使用 `objectKey`、项目资源 ID 或素材 ID；禁止把 Data URL / Blob URL 写入生成请求或外部生成队列载荷。浏览器内可对临时图做压缩等处理，但压缩结果也必须上传后再提交。
 - 扣费通过现有钱包资产操作封装执行；上游生成失败或未返回图片时按现有补偿逻辑退款。
 - 生成成功后，成品作为图片画布生成图层加入画布，并保留游戏输入和参考图摘要供图层信息使用。
 
diff --git a/docs/【编辑器】画板UI设计图生成入口设计-2026-06-17.md b/docs/【编辑器】画板UI设计图生成入口设计-2026-06-17.md
index 416fdd5fb..31a91bead 100644
--- a/docs/【编辑器】画板UI设计图生成入口设计-2026-06-17.md
+++ b/docs/【编辑器】画板UI设计图生成入口设计-2026-06-17.md
@@ -54,14 +54,14 @@
 - 框选状态参考微信截图工具栏布局，默认矩形框选，并支持矩形框选、椭圆框选和画笔自由框选三种工具。
 - 用户可在同一张 UI 设计图上多次框选；未至少框选一个区域时，工具栏 `提取` 按钮不可点击。
 - 可上传普通参考图辅助 UI 素材提取，用于约束被框选素材的风格、配色或材质；普通参考图会以 `objectKey` 随合成后的红框 UI 设计图一起提交。
-- 点击 `提取` 后，前端把所有框选的红色轮廓绘入原 UI 设计图，生成合成图片 Data URL，再提交到 `POST /api/editor/ui-designs/assets/extractions`。
+- 点击 `提取` 后，前端把所有框选的红色轮廓绘入原 UI 设计图生成合成图；Data URL / Blob URL 只允许停留在浏览器临时态，必须先上传 OSS 并确认 asset object，再以返回的 `objectKey`（或项目资源 / 素材 ID）作为 `sourceImageSrc` 提交到 `POST /api/editor/ui-designs/assets/extractions`。
 - 后端固定使用 `gpt-image-2` 图片编辑链路，并固定提示词：
 
 ```text
 仅提取被红色框框选的素材并整理成spritesheet，图集背景必须使用后端自动决策出的抠图背景色。纯色背景必须平整无纹理、无渐变、无阴影、无地面、无环境、无道具，方便后续扣除背景；素材自身不要出现与背景色相同或相近的描边、底板、投影或反光。
 ```
 
-- 后端收到 spritesheet 后先把带解析后纯色背景的源图写入 OSS、项目资源和账号素材库，再调用 BgFilter，固定传 `background_mode=flat`、`cross_check=off` 并按默认 `segModel=birefnet` 透明化。透明背景处理正常成功时，透明 spritesheet 同样先进入 OSS、项目资源和账号素材库，再复用图标素材的连通域拆分能力；调用方未指定素材文件夹时落默认“项目”文件夹。透明背景处理最终失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建透明图集，也不继续拆分。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。
+- 后端收到 spritesheet 后先把带解析后纯色背景的源图 owned 上传私有 OSS（消费图片字节所有权，上传完成后释放原图缓冲，不克隆保留），写入项目资源和账号素材库；随后只持 object key。每次 BgFilter attempt 重新签发 600 秒 GET URL，multipart 固定传 `image_url`、`screen_color=<screenColor>`、`seg_model=<segModel>`、`background_mode=flat` 和 `cross_check=off`，不包含 `file`，默认 `segModel=birefnet`。BgFilter 主路径不重新下载原图；首次失败后立即重试 `1` 次（重试同样重新换签），第二次仍失败进入“阿里云通用抠图（按签名 URL 单独下载）→ 本地键色（再按 object key 独立下载一次原图并在产出后释放）”降级链。透明背景处理正常成功时，透明 spritesheet 同样先进入 OSS、项目资源和账号素材库，再复用图标素材的连通域拆分能力；调用方未指定素材文件夹时落默认“项目”文件夹。透明背景处理最终失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建透明图集，也不继续拆分。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。
 - UI 素材自动拆分只在透明图集成功后执行，与图标图集一致，属于 best-effort 附加动作。未知素材数量时按从上到下、从左到右自动命名为 `素材 1`、`素材 2`；识别或切片持久化失败仍返回整张透明图集和 `sliceWarning`，前端显示非阻断 warning toast，用户可手动重试。`sliceWarning` 与透明背景最终失败使用的通用 `warning` 互斥，前者只表示透明图集成功但自动拆分失败，`sliceWarning.reason` 原始契约保持不变。
 - 正常透明化成功时，前端先把透明 spritesheet 作为 `assetKind: "icon-spritesheet"` 图集图层放在 UI 设计图右侧，再把拆分成功的独立素材作为 `assetKind: "icon"` 图标图层继续放到画布；透明背景处理最终失败时只消费后端快照中的 provider 原图。透明图集图层提供 `拆分图集` 工具栏按钮，可使用相同连通域规则重新拆分。
 
diff --git a/docs/【编辑器】画板图标素材生成入口设计-2026-06-15.md b/docs/【编辑器】画板图标素材生成入口设计-2026-06-15.md
index 041607f94..9e1fc8946 100644
--- a/docs/【编辑器】画板图标素材生成入口设计-2026-06-15.md
+++ b/docs/【编辑器】画板图标素材生成入口设计-2026-06-15.md
@@ -12,7 +12,7 @@
 - 点击后立即在画布中心创建图标素材占位图，不复用普通“单张空白图片”图标；占位图表现为一叠空白素材图标卡片。
 - 图标素材占位图必须按当前模型、比例和 K 档对应的真实 provider 请求像素初始化；切换参数后继续保持占位尺寸与请求尺寸一致，不得用固定 `360x360 / 512x512` 框代替生成目标。
 - 图标素材面板锚定在占位图下方，和现有生成输入框同一层级展示。
-- 透明背景处理正常成功后删除占位态，把后端返回的透明 spritesheet 作为 `assetKind: "icon-spritesheet"` 的图集图层放到画布，并把按 alpha 连通域成功拆出的 `assetKind: "icon"` 素材铺到图集右侧；透明背景处理最终失败时，后端完成快照只用 provider 原图替换占位态。
+- 透明背景处理正常成功后删除占位态：透明 spritesheet 作为主图（`assetKind: "icon-spritesheet"`，`generatedLayerId` 锚点）放入画布，provider 带背景原图作为第二个同类型图层放在透明主图右侧，按 alpha 连通域成功拆出的 `assetKind: "icon"` 素材从原图右侧继续铺放；透明背景处理最终失败时，后端完成快照只用 provider 原图替换占位态。
 - 选中 `assetKind: "icon-spritesheet"` 图层时，图片浮动工具栏显示 `拆分图集`；手动拆分只追加独立素材，不复制原图集。
 - 图标规范图写入 `assetKind: "icon-spec"`，用于刷新后保留标签和限制点选来源。
 
@@ -38,7 +38,7 @@
 
 - 前端提交到 `POST /api/editor/icon-spritesheets/generations`。
 - 请求字段：
-  - `referenceImageSrc`：图标规范 Data URL。
+  - `referenceImageSrc`：图标规范的稳定引用（当前账号的 `objectKey`、项目资源 ID 或素材 ID）；本地临时图必须先上传 OSS，禁止 Data URL / Blob URL。
   - `iconDescriptions`：过滤空文本后的图标描述数组，`1..100`。
   - `model`：支持 `gemini-3.1-flash-image-preview`（UI 显示 `nanobanana2`）和 `gpt-image-2`，默认 `nanobanana2`。
   - `aspectRatio`：按 `x:y` 展示，选项跟随模型。
@@ -59,17 +59,17 @@
 
 ## 去背与保存
 
-- 后端收到 spritesheet 后先把带解析后纯色背景的源图写入 OSS，再调用 BgFilter 透明化；BgFilter multipart 固定传 `background_mode=flat`、`cross_check=off`，请求字段同时包含 `screenColor` 和 `segModel`。前端用户路径固定提交 `screenColor=auto` 与默认 `birefnet`，后端仍识别内部保留的 `anime-seg`，但这些内部参数不对用户可见。
-- 透明背景处理正常成功时，带背景原图和去背后的透明 spritesheet 都先写入 OSS、项目资源和账号素材库，再按 alpha 连通域和素材描述顺序执行附加拆分；若 BgFilter 返回较小图集，只把 alpha 蒙版重采样到 provider 原图尺寸并应用回原始高分辨率 RGB，不放大低分辨率后处理成品。调用方未指定素材文件夹时统一落默认“项目”文件夹。每个成功切片单独写入 OSS、项目资源和账号素材库，`sourceResourceId` 指向透明图集资源。透明背景处理最终失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建透明图集，也不继续拆分，`iconImageSrcs=[]`。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。
+- 后端收到 spritesheet 后先把带解析后纯色背景的源图写入私有 OSS，并在上传完成后释放原图缓冲，再签发 600 秒 GET URL 调用 BgFilter 透明化；BgFilter multipart 固定传 `image_url`、`screen_color=<screenColor>`、`seg_model=<segModel>`、`background_mode=flat` 和 `cross_check=off`，不包含 `file`。前端用户路径固定提交 `screenColor=auto` 与默认 `segModel=birefnet`，后端仍识别内部保留的 `anime-seg`，但这些内部参数不对用户可见。
+- 透明背景处理正常成功时，带背景原图和去背后的透明 spritesheet 都先写入 OSS、项目资源和账号素材库，再按 alpha 连通域和素材描述顺序执行附加拆分；若 BgFilter 返回较小图集，只把 alpha 蒙版重采样到 provider 原图尺寸并应用回原始高分辨率 RGB，不放大低分辨率后处理成品。画布完成快照同时写入透明主图与右侧 provider 原图（二者均已登记为 project resource / 账号素材），`generatedLayerId` 仍锚定透明主图；成功拆出的切片从 provider 原图右侧继续排列。调用方未指定素材文件夹时统一落默认“项目”文件夹。每个成功切片单独写入 OSS、项目资源和账号素材库，`sourceResourceId` 指向透明图集资源。透明背景处理最终失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建透明图集，也不继续拆分，`iconImageSrcs=[]`。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。
 - 自动拆分只在透明图集成功后执行，属于 best-effort 附加动作，不参与图集生成的成功判定。连通域识别或切片持久化失败时，接口仍返回并回填整张透明图集，`iconImageSrcs=[]`，并通过 `sliceWarning.code/reason` 暴露非阻断原因；`sliceWarning` 与透明背景最终失败使用的通用 `warning` 互斥，前者只表示透明图集成功但自动拆分失败，`sliceWarning.reason` 原始契约保持不变。前端在 inline、worker 队列完成和刷新恢复三条路径统一显示对应 warning toast，用户可在图集工具栏手动重试。
 - 响应通过 `iconImageSrcs` 返回成功切片素材；自动生成使用用户输入的素材描述命名，UI 设计提取和手动拆分按从上到下、从左到右自动命名为 `素材 N`。
 - 手动拆分调用 `POST /api/editor/icon-spritesheets/slices`，只允许读取当前用户项目中的 `icon-spritesheet` 资源，不调用图片生成 provider，不扣除泥点。输入限制为单边最多 `4096` 像素、总像素最多 `2048×2048`，单次最多持久化 `64` 个切片；超限在任何切片写入前拒绝。
 
 ## 前端铺放规则
 
-- spritesheet 图集放在原占位图位置附近。
-- 自动拆分素材从图集右侧开始换行铺放；手动拆分使用相同布局，但保留原图集不变。
-- 生成成功后关闭图标素材面板，选中 spritesheet 图集，并打开图层面板。
+- 透明 spritesheet 主图放在原占位图位置附近；provider 带背景原图放在透明主图右侧。
+- 自动拆分素材从 provider 原图右侧开始换行铺放；手动拆分使用相同布局，但保留原图集不变。
+- 生成成功后关闭图标素材面板，选中透明 spritesheet 主图，并打开图层面板。
 
 ## 验收
 
@@ -78,7 +78,7 @@
 - 默认 6 个素材描述会进入 prompt；用户在单个文本框中继续输入时最多解析 100 个素材描述。
 - 默认打开图标素材面板时选中 `nanobanana2 / 1:1 / 1K`；模型切换后，角色和图标素材面板之间沿用上次选择的模型。
 - 图标素材生成请求必须带 `model`、`aspectRatio` 和 `imageSize`；`nanobanana2` 请求体必须包含 `generationConfig.imageConfig.aspectRatio/imageSize`，`gpt-image-2` 请求必须包含文档映射后的 `size`。
-- 图标素材生成可以上传普通参考图；提交时图标规范图仍走 `referenceImageSrc`，普通参考图走 `referenceImageSrcs`，上传参考图优先提交 `objectKey`，并写入 `generationInputs.references`。
-- 透明背景处理和自动拆分都成功后，画布同时出现透明 spritesheet 图集和按描述命名的独立图标图层；透明图集成功但拆分失败时只出现透明图集，透明背景处理最终失败时只出现 provider 原图。
-- 选中图集图层时显示 `拆分图集`；点击后源图集显示扫描蒙层与 `拆图中` 状态，工具栏按钮同步切换为旋转图标和 `拆图中` 并禁用重复提交。完成后恢复工具栏，不新增第二张图集，只在原图集右侧追加自动识别的独立素材，并同步写入素材库。
+- 图标素材生成可以上传普通参考图；提交时图标规范图仍走 `referenceImageSrc`，普通参考图走 `referenceImageSrcs`，二者都必须是稳定引用（`objectKey` / 项目资源 ID / 素材 ID），禁止 Data URL / Blob URL，并写入 `generationInputs.references`。
+- 透明背景处理和自动拆分都成功后，画布同时出现透明 spritesheet 主图、其右侧的 provider 原图，以及从原图右侧铺开的按描述命名的独立图标图层；透明图集成功但拆分失败时仍出现透明主图与右侧原图，透明背景处理最终失败时只出现 provider 原图。
+- 选中透明图集图层时显示 `拆分图集`；点击后源图集显示扫描蒙层与 `拆图中` 状态，工具栏按钮同步切换为旋转图标和 `拆图中` 并禁用重复提交。完成后恢复工具栏，不新增第二张图集，只在 provider 原图右侧追加自动识别的独立素材，并同步写入素材库。
 - 生成图标素材提交体包含按模型和尺寸计算的 `priceMudPoints`；`nanobanana2 1K` 应为 `12`，`gpt-image-2 1K` 应为 `3`，`gpt-image-2 2K` 应为 `5`。若前端传入与后端计费配置不一致的值，后端返回 `priceMudPoints` 校验错误，不继续调用上游生成。
diff --git a/docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md b/docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md
index c01911268..057f22910 100644
--- a/docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md
+++ b/docs/【编辑器】画板角色形象生成入口设计-2026-06-15.md
@@ -65,7 +65,7 @@
 角色设定：<用户输入的角色设定>
 ```
 
-- 角色图生成完成后，编辑器后端必须先把带自动决策纯色背景的源图写入 OSS，再调用共享 BgFilter 服务透明化：multipart 字段包含 `file`、`screen_color=<screenColor>`、`seg_model=<segModel>`、`background_mode=flat` 和 `cross_check=on`，用户路径默认并只提交 `seg_model=birefnet`；`flat` 明确表示单一纯色背景抠图模式，`birefnet` 是 BgFilter 管线内部后端。首次请求失败后立即重试 `1` 次，第二次仍失败进入“阿里云通用抠图 → 本地键色”降级链。角色图 prompt 按 `screenColor` 写入颜色名称、hex 和 RGB。该流程不再调用 RPG / 资产工坊的角色主图专用 `character_visual_assets` 后处理，也不复用手动去背景的 `background_mode=complex` 路径。透明背景处理正常成功时，输出透明背景 PNG，随后写入 OSS 私有对象并确认 `asset_object`；接口回包返回透明 PNG Data URL 及 `objectKey` / `assetObjectId`，画布同时写入透明主结果和 provider 原图，生成器 `generatedLayerId` 锚定透明主结果，provider 原图作为第二个图层放在其右侧。三段透明背景处理最终仍失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建不存在的透明处理图；通用 `warning.code/reason` 携带完整降级原因。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。前端创建图层和画板资源记录时必须保存最终回包对应的媒体引用。
+- 角色图生成完成后，编辑器后端必须先把带自动决策纯色背景的源图 owned 上传私有 OSS（消费图片字节所有权，上传完成后释放原图缓冲），再对 object key 签发 600 秒 GET URL 调用共享 BgFilter 服务透明化。BgFilter 主路径不重新下载原图；每次 HTTP attempt 重新换签，multipart 字段包含 `image_url`、`screen_color=<screenColor>`、`seg_model=<segModel>`、`background_mode=flat` 和 `cross_check=on`，不包含 `file`，用户路径默认并只提交 `seg_model=birefnet`；`flat` 明确表示单一纯色背景抠图模式，`birefnet` 是 BgFilter 管线内部后端。首次请求失败后立即重试 `1` 次，第二次仍失败进入“阿里云通用抠图（按签名 URL 单独下载）→ 本地键色（再按 object key 独立下载一次原图并在产出后释放）”降级链。角色图 prompt 按 `screenColor` 写入颜色名称、hex 和 RGB。该流程不再调用 RPG / 资产工坊的角色主图专用 `character_visual_assets` 后处理，也不复用手动去背景的 `background_mode=complex` 路径。透明背景处理正常成功时，输出透明背景 PNG，随后写入 OSS 私有对象并确认 `asset_object`；接口回包返回 `imageSrc: "/<objectKey>"`、`objectKey`、`assetObjectId` 及资源快照，画布同时写入透明主结果和 provider 原图，生成器 `generatedLayerId` 锚定透明主结果，provider 原图作为第二个图层放在其右侧。三段透明背景处理最终仍失败、但 provider 原图已经持久化时，任务以 `completed + warning` 收口，只把 provider 原图作为唯一主图放入画布，`generatedLayerId` 指向原图，不创建不存在的透明处理图；通用 `warning.code/reason` 携带完整降级原因。该收口只捕获透明背景处理本身的最终失败；phase 上报、provider 原图持久化、透明处理图持久化和 `canvasCompletion` 写回错误仍正常传播，不能被原图降级吞掉。前端创建图层和画板资源记录时必须保存最终回包对应的媒体引用。
 - 对 `assetKind: "character"` 的角色图层执行 `重绘` 时，前端仍使用原图作为参考图，但请求 `kind` 必须传 `character`，让后端继续套用上述角色提示词限定、角色图后处理和角色资产持久化；透明背景正常成功与最终失败保留 provider 原图的收口规则和角色新生成一致。普通图片图层重绘仍保持 `kind: "quick-edit"`。
 
 ## 生成规范参考图
@@ -162,7 +162,7 @@
 
 - 视频生成完成后，后端先把带纯色背景的预览视频登记为 OSS 私有对象、`asset_object`、项目资源和账号素材，再按面板选择抽取对应帧数：`32`、`40` 或 `48`。未传 `assetFolderId` 时进入默认“项目”素材文件夹；后续抽帧或抠图失败不能抹掉这份已经生成成功的可恢复视频。
 - 抽帧采样必须按目标帧数预留视频尾部安全步长，例如 `32帧·4秒` 最后一帧采 `3.875s`，避免 FFmpeg 在尾点附近返回成功但输出 `0` 帧。
-- 每帧必须先把带自动决策纯色背景的源图写入 OSS，再走 `BgFilter（background_mode=flat、seg_model=birefnet、cross_check=on）→ 阿里云通用抠图 → 本地 editor_green_screen`，并按同一次生成已选定的 `screenColor` 去背。BgFilter 每一次 HTTP attempt 的 timeout 使用“`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 基准值 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`；首次失败后重试 `1` 次。
+- 每帧绿幕源图字节由上传 owned 消费（`frame.bytes` 移入 put，上传完成后释放原帧缓冲，不克隆保留）；后续只持 object key。每次 BgFilter attempt 重新签发 600 秒 GET URL，multipart 仅传 `image_url`（加 `background_mode=flat`、`seg_model=birefnet`、`cross_check=on` 与同一次生成已选定的 `screenColor`），不传 `file`。BgFilter 主路径不重新下载原帧；失败后走 `阿里云通用抠图（按签名 URL 单独下载）→ 本地 editor_green_screen（再按 object key 独立下载一次并在产出后释放）`。BgFilter 每一次 HTTP attempt 的 timeout 使用“`GENARRATIVE_EDITOR_BGFILTER_REQUEST_TIMEOUT_MS` 基准值 + `2000ms × 本次实际帧数`”，默认 `32 / 40 / 48` 帧分别为 `244000 / 260000 / 276000ms`；首次失败后重试 `1` 次。
 - 全部 `32 / 40 / 48` 帧以覆盖本次所有帧的无序在途集合连续发射，允许乱序完成并最终按 `frameIndex` 排序；任一帧最终失败时先排空全部已启动 Future，再让整项任务失败退款，不发布缺帧动画。
 - 抽帧结果写入 OSS，并返回帧路径、帧尺寸、帧数、fps、预览视频路径、模型、价格和实际 prompt。
 - 画板前端回填角色动作结果时，必须以 `frames[0].imageSrc` 创建 `mediaType: "image-sequence"`、`assetKind: "character-animation"` 图层，并把完整 `frames` 保存为图层 `imageSequenceFrames`；`previewVideoPath` 只保留为上游预览视频来源，不作为画布主媒体。
diff --git a/server-rs/Cargo.lock b/server-rs/Cargo.lock
index d3058ee33..fefa47d57 100644
--- a/server-rs/Cargo.lock
+++ b/server-rs/Cargo.lock
@@ -4495,18 +4495,15 @@ dependencies = [
 name = "platform-matting"
 version = "0.1.0"
 dependencies = [
- "base64 0.22.1",
  "dotenvy",
  "hex",
  "hmac",
- "httpdate",
  "image",
  "platform-oss",
  "reqwest 0.12.28",
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sha1",
  "sha2",
  "time",
  "tokio",
diff --git a/server-rs/crates/api-server/src/aliyun_matting.rs b/server-rs/crates/api-server/src/aliyun_matting.rs
index 60f5a9921..e961513e6 100644
--- a/server-rs/crates/api-server/src/aliyun_matting.rs
+++ b/server-rs/crates/api-server/src/aliyun_matting.rs
@@ -1,21 +1,20 @@
 //! 阿里云通用抠图在 api-server 侧的适配层。
 //!
-//! 输入 URL 策略：抠图服务只认上海地域 OSS URL，而我们没有上海地域自有 OSS，
-//! 统一由 platform-matting 上传 VIAPI 官方临时桶（1 天自动过期，无需清理）。
+//! 输入统一由 platform-matting 通过 AuthorizeFileUpload 单对象 Policy 上传动态临时 OSS。
 
 use axum::http::StatusCode;
 use platform_matting::MattingError;
-use serde_json::json;
+use serde_json::{Value, json};
 
 use crate::{
     http_error::AppError, openai_image_generation::DownloadedOpenAiImage, state::AppState,
 };
 
-/// 图片字节 → 阿里云通用抠图 → 原尺寸透明 PNG。
-/// 未配置抠图客户端时返回错误，由调用方决定是否降级本地算法。
-pub(crate) async fn segment_image_with_aliyun_matting(
+/// 私有 OSS 签名 URL → 延迟下载 → 阿里云临时桶 → 原尺寸透明 PNG。
+/// 下载和临时上传由 platform-matting 收口，源图缓冲不会跨越整次阿里云推理常驻。
+pub(crate) async fn segment_image_url_with_aliyun_matting(
     state: &AppState,
-    image: &DownloadedOpenAiImage,
+    image_url: &str,
     log_label: &str,
 ) -> Result<DownloadedOpenAiImage, AppError> {
     let matting_client = state
@@ -25,7 +24,7 @@ pub(crate) async fn segment_image_with_aliyun_matting(
     let file_name = format!("{log_label}.png");
     let started_at = std::time::Instant::now();
     let output_bytes = matting_client
-        .segment_image_to_transparent_png(image.bytes.as_slice(), &file_name)
+        .segment_image_url_to_transparent_png(image_url, &file_name)
         .await
         .map_err(|error| {
             aliyun_matting_failure_to_app_error(&error, started_at.elapsed().as_millis() as u64)
@@ -34,7 +33,7 @@ pub(crate) async fn segment_image_with_aliyun_matting(
         provider = "aliyun-matting",
         log_label,
         elapsed_ms = started_at.elapsed().as_millis() as u64,
-        "阿里云通用抠图完成"
+        "阿里云通用抠图 URL 输入完成"
     );
 
     Ok(DownloadedOpenAiImage {
@@ -48,18 +47,36 @@ pub(crate) async fn segment_image_with_aliyun_matting(
 ///
 /// 分类（是否外部调用、超时、传输层故障、上游 HTTP 状态）由 platform-matting 在错误发生处
 /// 结构化捕获，这里只做协议中立的读取，不再从中文 message 反推——外部供应商协议归属留在
-/// platform-* 层。`InvalidConfig` / `InvalidRequest` / `Sign` 是发请求前的本地预检失败，
-/// `external_call_attempted()` 为 false，据此跳过外部失败审计。
+/// platform-* 层。`InvalidConfig` / `InvalidRequest` / `Sign` 是尚未开始外部调用的本地预检失败；
+/// URL 链路在 OSS GET 成功后发生的解码、尺寸或其它本地处理失败由 `LocalProcessing` 表示，
+/// 仍然需要进入外部失败审计，但不得包装成可重试的上游 5xx。
 fn aliyun_matting_failure_to_app_error(error: &MattingError, latency_ms: u64) -> AppError {
     let message = error.message();
     if !error.external_call_attempted() {
-        // 本地预检失败（未配置 / 图片解码失败 / 尺寸过小 / 签名构造失败），未触达阿里云。
+        // 本地预检失败（未配置 / 尚未下载源图前的参数或签名错误），未触达外部调用链路。
         return AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY).with_details(json!({
             "provider": "aliyun-matting",
             "message": message,
             "timeout": false,
             "transport": false,
+            "localProcessing": false,
             "externalCallAttempted": false,
+            "failureStage": error.failure_stage(),
+            "latencyMs": latency_ms,
+            "rawExcerpt": message.chars().take(500).collect::<String>(),
+        }));
+    }
+    // 外部调用已开始，但失败在本地解码 / 校验 / 归一等阶段：要审计，不能标成上游 5xx / 可重试。
+    if matches!(error, MattingError::LocalProcessing(_)) {
+        return AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY).with_details(json!({
+            "provider": "aliyun-matting",
+            "message": message,
+            "timeout": false,
+            "transport": false,
+            "localProcessing": true,
+            "upstreamStatus": Value::Null,
+            "externalCallAttempted": true,
+            "failureStage": error.failure_stage(),
             "latencyMs": latency_ms,
             "rawExcerpt": message.chars().take(500).collect::<String>(),
         }));
@@ -75,7 +92,10 @@ fn aliyun_matting_failure_to_app_error(error: &MattingError, latency_ms: u64) ->
         "message": message,
         "timeout": timeout,
         "transport": error.is_transport(),
+        "localProcessing": false,
         "upstreamStatus": error.upstream_status(),
+        "externalCallAttempted": true,
+        "failureStage": error.failure_stage(),
         "latencyMs": latency_ms,
         "rawExcerpt": message.chars().take(500).collect::<String>(),
     }))
@@ -86,6 +106,7 @@ fn aliyun_matting_unconfigured_error() -> AppError {
         "provider": "aliyun-matting",
         "message": "阿里云抠图客户端未配置或未启用。",
         "externalCallAttempted": false,
+        "failureStage": "preflight",
     }))
 }
 
@@ -100,6 +121,21 @@ mod tests {
         assert!(!crate::external_api_audit::matting_failure_external_call_attempted(&error));
     }
 
+    #[test]
+    fn url_input_path_delegates_download_and_temp_upload_to_platform_matting() {
+        let source = include_str!("aliyun_matting.rs");
+        let start = source
+            .find("pub(crate) async fn segment_image_url_with_aliyun_matting")
+            .expect("URL input adapter should exist");
+        let tail = &source[start..];
+        let end = tail
+            .find("/// 把 platform-matting 的错误映射")
+            .expect("URL input adapter should end before error mapper");
+        let body = &tail[..end];
+
+        assert!(body.contains("segment_image_url_to_transparent_png"));
+    }
+
     #[test]
     fn local_preflight_failures_do_not_count_as_external_call() {
         for error in [
@@ -108,7 +144,7 @@ mod tests {
             ),
             MattingError::InvalidRequest("解析待抠图图片失败：invalid png".to_string()),
             MattingError::InvalidConfig("endpoint 为空".to_string()),
-            MattingError::Sign("初始化 OSS V1 签名器失败".to_string()),
+            MattingError::Sign("构造 AuthorizeFileUpload 签名失败".to_string()),
         ] {
             let mapped = aliyun_matting_failure_to_app_error(&error, 3);
 
@@ -129,6 +165,79 @@ mod tests {
         }
     }
 
+    #[test]
+    fn local_processing_after_source_download_is_audited_with_failure_stage() {
+        for (error, expected_stage) in [
+            (
+                MattingError::InvalidRequest("解析待抠图图片失败：invalid png".to_string())
+                    .with_failure_stage("source_decode"),
+                "source_decode",
+            ),
+            (
+                MattingError::InvalidRequest("待抠图图片尺寸 16x16 过小".to_string())
+                    .with_failure_stage("source_validate"),
+                "source_validate",
+            ),
+        ] {
+            let mapped = aliyun_matting_failure_to_app_error(&error, 3);
+
+            assert!(crate::external_api_audit::matting_failure_external_call_attempted(&mapped));
+            // 本地处理失败要审计，但 HTTP 包装不得落成可重试 5xx。
+            assert_eq!(mapped.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
+            let details = mapped.details().expect("details present");
+            assert_eq!(
+                details
+                    .get("externalCallAttempted")
+                    .and_then(|v| v.as_bool()),
+                Some(true)
+            );
+            assert_eq!(
+                details.get("localProcessing").and_then(|v| v.as_bool()),
+                Some(true)
+            );
+            assert_eq!(
+                details.get("transport").and_then(|v| v.as_bool()),
+                Some(false)
+            );
+            assert!(
+                details
+                    .get("upstreamStatus")
+                    .is_none_or(|value| value.is_null())
+            );
+            assert_eq!(
+                details.get("failureStage").and_then(|v| v.as_str()),
+                Some(expected_stage)
+            );
+            assert_eq!(
+                crate::external_api_audit::matting_failure_audit_failure_stage(
+                    &mapped,
+                    "aliyun_segment",
+                ),
+                expected_stage
+            );
+            assert_eq!(
+                crate::external_api_audit::matting_failure_audit_status_code(&mapped),
+                None,
+                "本地处理失败没有上游 HTTP 状态，不能回退包装码"
+            );
+            let draft = crate::external_api_audit::build_matting_external_api_failure_draft(
+                "aliyun-matting",
+                "imageseg.example".to_string(),
+                "editor-screen-background-removal",
+                expected_stage,
+                crate::external_api_audit::matting_failure_audit_status_code(&mapped),
+                crate::external_api_audit::matting_failure_audit_timeout(&mapped),
+                crate::external_api_audit::matting_failure_audit_is_transport(&mapped),
+                crate::external_api_audit::matting_failure_audit_latency_ms(&mapped),
+                mapped.message().to_string(),
+                crate::external_api_audit::matting_failure_audit_raw_excerpt(&mapped),
+                &crate::external_api_audit::ExternalApiAuditContext::default(),
+            );
+            assert_eq!(draft.status_class, Some("local"));
+            assert!(!draft.retryable);
+        }
+    }
+
     #[test]
     fn upstream_transport_failure_maps_to_retryable_transport() {
         let error = MattingError::upstream_transport_error(
diff --git a/server-rs/crates/api-server/src/character_animation_assets.rs b/server-rs/crates/api-server/src/character_animation_assets.rs
index d1e8e4bb6..b925e07d3 100644
--- a/server-rs/crates/api-server/src/character_animation_assets.rs
+++ b/server-rs/crates/api-server/src/character_animation_assets.rs
@@ -79,7 +79,6 @@ use crate::{
         resolve_editor_screen_background_color,
     },
     http_error::AppError,
-    openai_image_generation::DownloadedOpenAiImage,
     platform_errors::map_oss_error,
     prompt::role_asset_studio::{
         build_role_asset_workflow, normalize_animation_prompt_text_by_key,
@@ -2418,7 +2417,7 @@ async fn process_and_persist_editor_character_animation_frame(
     audit: &crate::external_api_audit::ExternalApiAuditContext,
 ) -> Result<ProcessedEditorCharacterAnimationFrame, AppError> {
     // 中文注释：每一帧只要求自己的绿幕源图先落 OSS，不再等待整批源图全部上传完成。
-    put_character_animation_object(
+    let source_put = put_character_animation_object(
         state,
         LegacyAssetPrefix::Animations,
         vec![
@@ -2432,7 +2431,7 @@ async fn process_and_persist_editor_character_animation_frame(
             frame.extension
         ),
         frame.mime_type.clone(),
-        frame.bytes.clone(),
+        frame.bytes,
         build_asset_metadata(
             EDITOR_CHARACTER_ANIMATION_ASSET_KIND,
             owner_user_id,
@@ -2444,14 +2443,9 @@ async fn process_and_persist_editor_character_animation_frame(
     )
     .await?;
 
-    let image = DownloadedOpenAiImage {
-        bytes: frame.bytes,
-        mime_type: frame.mime_type,
-        extension: frame.extension,
-    };
     let removed = remove_editor_generated_screen_background_with_bgfilter_with_request_timeout(
         state,
-        &image,
+        source_put.object_key.as_str(),
         screen_color,
         EDITOR_BGFILTER_DEFAULT_SEG_MODEL,
         EDITOR_BGFILTER_CROSS_CHECK_ENABLED,
@@ -6223,6 +6217,7 @@ mod tests {
                 "put_character_animation_object",
                 "green-screen-frame",
                 "remove_editor_generated_screen_background_with_bgfilter_with_request_timeout",
+                "source_put.object_key.as_str()",
                 "bgfilter_request_timeout_ms",
                 "finalize_animation_frame_payload",
                 "put_character_animation_object",
@@ -6244,6 +6239,13 @@ mod tests {
                 "finalize_animation_frame_payload",
             ],
         );
+        let frame_pipeline = source
+            .split_once("async fn process_and_persist_editor_character_animation_frame")
+            .and_then(|(_, tail)| tail.split_once("async fn publish_animation_set"))
+            .map(|(body, _)| body)
+            .expect("frame pipeline function should exist");
+        assert!(!frame_pipeline.contains("frame.bytes.clone()"));
+        assert!(!frame_pipeline.contains("DownloadedOpenAiImage"));
     }
 
     #[test]
diff --git a/server-rs/crates/api-server/src/editor_project.rs b/server-rs/crates/api-server/src/editor_project.rs
index 5b4436f55..a87179325 100644
--- a/server-rs/crates/api-server/src/editor_project.rs
+++ b/server-rs/crates/api-server/src/editor_project.rs
@@ -129,6 +129,7 @@ const EDITOR_LEGACY_GREEN_SCREEN_SOURCE_ASSET_KIND: &str = "editor_green_screen_
 const EDITOR_PROVIDER_SOURCE_SLOT: &str = "provider_source";
 pub(crate) const EDITOR_BGFILTER_DEFAULT_SEG_MODEL: &str = "birefnet";
 const EDITOR_BGFILTER_SEG_MODEL_ANIME_SEG: &str = "anime-seg";
+const EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS: u64 = 600;
 const EDITOR_BGFILTER_BACKGROUND_MODE_FLAT: &str = "flat";
 const EDITOR_BGFILTER_BACKGROUND_MODE_COMPLEX: &str = "complex";
 pub(crate) const EDITOR_BGFILTER_CROSS_CHECK_ENABLED: bool = true;
@@ -1752,7 +1753,7 @@ pub(crate) async fn generate_editor_image_for_owner(
             state,
             caller.owner_user_id.as_str(),
             generated.task_id.as_str(),
-            &image,
+            image,
             submitted_prompt.as_str(),
             generated.actual_prompt.as_deref(),
             storage_profile.asset_kind,
@@ -1802,7 +1803,7 @@ pub(crate) async fn generate_editor_image_for_owner(
         };
         let removal = remove_editor_generated_screen_background_with_bgfilter(
             state,
-            &image,
+            source_object_key.as_str(),
             screen_color.expect("character generation should have screen color"),
             seg_model.expect("character generation should have BgFilter seg model"),
             EDITOR_BGFILTER_CROSS_CHECK_ENABLED,
@@ -1854,7 +1855,14 @@ pub(crate) async fn generate_editor_image_for_owner(
         };
         let removal_provider = removal.provider;
         let (restored_removal_image, postprocess_dimension_error) =
-            apply_editor_postprocessed_alpha_to_provider_source_or_original(&image, removal.image);
+            apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original(
+                state,
+                source_object_key.as_str(),
+                provider_width,
+                provider_height,
+                removal.image,
+            )
+            .await;
         if let Some(error) = postprocess_dimension_error {
             tracing::warn!(
                 task_id = %generated.task_id,
@@ -2653,11 +2661,47 @@ fn apply_editor_postprocessed_alpha_to_provider_source(
     }))
 }
 
-fn apply_editor_postprocessed_alpha_to_provider_source_or_original(
-    provider_source: &DownloadedOpenAiImage,
+async fn apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original(
+    state: &AppState,
+    provider_source_object_key: &str,
+    provider_width: u32,
+    provider_height: u32,
     postprocessed: DownloadedOpenAiImage,
 ) -> (DownloadedOpenAiImage, Option<AppError>) {
-    match apply_editor_postprocessed_alpha_to_provider_source(provider_source, &postprocessed) {
+    let postprocessed_dimensions =
+        image::ImageReader::new(Cursor::new(postprocessed.bytes.as_slice()))
+            .with_guessed_format()
+            .map_err(|error| {
+                AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                    "provider": "editor-image-postprocess",
+                    "message": format!("无法识别透明后处理图格式：{error}"),
+                }))
+            })
+            .and_then(|reader| {
+                reader.into_dimensions().map_err(|error| {
+                    AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                        "provider": "editor-image-postprocess",
+                        "message": format!("无法读取透明后处理图尺寸：{error}"),
+                    }))
+                })
+            });
+    match postprocessed_dimensions {
+        Ok((postprocessed_width, postprocessed_height))
+            if postprocessed_width == provider_width && postprocessed_height == provider_height =>
+        {
+            return (postprocessed, None);
+        }
+        Ok(_) => {}
+        Err(error) => return (postprocessed, Some(error)),
+    }
+
+    // 中文注释：provider 原图已在 BgFilter 调用前交给 OSS 并释放；只有输出尺寸漂移时才短时回读原图回贴 alpha。
+    let provider_source =
+        match download_editor_persisted_image_object(state, provider_source_object_key).await {
+            Ok(provider_source) => provider_source,
+            Err(error) => return (postprocessed, Some(error)),
+        };
+    match apply_editor_postprocessed_alpha_to_provider_source(&provider_source, &postprocessed) {
         Ok(Some(restored)) => (restored, None),
         Ok(None) => (postprocessed, None),
         Err(error) => (postprocessed, Some(error)),
@@ -3071,21 +3115,18 @@ pub(crate) async fn remove_editor_image_background_for_owner(
     caller: EditorGenerationCaller,
     payload: EditorBackgroundRemovalRequest,
 ) -> Result<Json<Value>, AppError> {
-    ensure_editor_reference_image_source_is_stable(
-        payload.source_image_src.as_str(),
-        "editor-background-removal",
-        "sourceImageSrc",
-        "待去除背景图片",
-    )?;
     let started_at = Instant::now();
     caller.report_processing_phase(state).await?;
-    let source_image = parse_editor_reference_image(
+    let source_object_key = resolve_editor_reference_object_key_for_owner(
         state,
         caller.owner_user_id.as_str(),
         payload.source_image_src.as_str(),
     )
     .await?;
-    let removed = request_editor_background_removal_image_with_retry(state, source_image).await?;
+    validate_editor_background_removal_source(state, source_object_key.as_str()).await?;
+    let removed =
+        request_editor_background_removal_image_with_retry(state, source_object_key.as_str())
+            .await?;
     let task_id = normalize_optional_string(payload.task_id.clone())
         .unwrap_or_else(|| format!("background-removal-{}", current_utc_micros()));
     let persisted = persist_editor_generated_image(
@@ -3179,14 +3220,129 @@ struct EditorBackgroundRemovalImage {
     height: u32,
 }
 
+async fn validate_editor_background_removal_source(
+    state: &AppState,
+    source_object_key: &str,
+) -> Result<(), AppError> {
+    let oss_client = state.oss_client().ok_or_else(|| {
+        AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
+            "provider": "aliyun-oss",
+            "reason": "OSS 未完成环境变量配置",
+        }))
+    })?;
+    let http_client = reqwest::Client::new();
+    let head = oss_client
+        .head_object(
+            &http_client,
+            OssHeadObjectRequest {
+                object_key: source_object_key.to_string(),
+            },
+        )
+        .await
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    if head.content_length > EDITOR_REFERENCE_IMAGE_MAX_SIZE_BYTES {
+        return Err(editor_reference_image_too_large());
+    }
+
+    let content_type =
+        normalize_editor_background_removal_source_mime_type(head.content_type.as_deref())
+            .ok_or_else(|| {
+                editor_background_removal_source_unsupported(
+                    "图片参考图的 Content-Type 不是支持的图片类型。",
+                )
+            })?;
+    let signed_url = sign_editor_private_object_read_url(
+        state,
+        source_object_key,
+        EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
+    )?;
+    let probe_end = EDITOR_BACKGROUND_REMOVAL_SOURCE_PROBE_BYTES.saturating_sub(1);
+    let response = http_client
+        .get(signed_url)
+        .header(reqwest::header::RANGE, format!("bytes=0-{probe_end}"))
+        .send()
+        .await
+        .map_err(|error| {
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": "aliyun-oss",
+                "message": format!("读取图片参考图文件头失败：{error}"),
+            }))
+        })?;
+    if response.status() != StatusCode::PARTIAL_CONTENT {
+        return Err(
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": "aliyun-oss",
+                "message": "OSS 未按 Range 返回图片文件头。",
+                "status": response.status().as_u16(),
+            })),
+        );
+    }
+    if response
+        .content_length()
+        .is_none_or(|size| size > EDITOR_BACKGROUND_REMOVAL_SOURCE_PROBE_BYTES)
+    {
+        return Err(
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": "aliyun-oss",
+                "message": "OSS 返回的图片文件头大小异常。",
+            })),
+        );
+    }
+    let probe = response.bytes().await.map_err(|error| {
+        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": "aliyun-oss",
+            "message": format!("读取图片参考图文件头失败：{error}"),
+        }))
+    })?;
+    validate_editor_background_removal_source_content(content_type, probe.as_ref())
+}
+
+fn validate_editor_background_removal_source_content(
+    content_type: &str,
+    bytes: &[u8],
+) -> Result<(), AppError> {
+    let detected_type = infer_editor_reference_image_mime_type(bytes).ok_or_else(|| {
+        editor_background_removal_source_unsupported("图片参考图文件魔数不是支持的图片类型。")
+    })?;
+    if detected_type != content_type {
+        return Err(editor_background_removal_source_unsupported(
+            "图片参考图的 Content-Type 与文件魔数不一致。",
+        ));
+    }
+    Ok(())
+}
+
+fn normalize_editor_background_removal_source_mime_type(
+    content_type: Option<&str>,
+) -> Option<&'static str> {
+    let mime_type = content_type?.split(';').next()?.trim();
+    if mime_type.eq_ignore_ascii_case("image/png") {
+        Some("image/png")
+    } else if mime_type.eq_ignore_ascii_case("image/jpeg") {
+        Some("image/jpeg")
+    } else if mime_type.eq_ignore_ascii_case("image/webp") {
+        Some("image/webp")
+    } else {
+        None
+    }
+}
+
+fn editor_background_removal_source_unsupported(message: &str) -> AppError {
+    AppError::from_status(StatusCode::UNSUPPORTED_MEDIA_TYPE).with_details(json!({
+        "provider": "editor-reference-image",
+        "field": "sourceImageSrc",
+        "message": message,
+    }))
+}
+
 async fn request_editor_background_removal_image_with_retry(
     state: &AppState,
-    source_image: OpenAiReferenceImage,
+    source_object_key: &str,
 ) -> Result<EditorBackgroundRemovalImage, AppError> {
     let max_attempts = EDITOR_BGFILTER_RETRY_COUNT + 1;
     let mut final_error = None;
     for attempt in 1..=max_attempts {
-        match request_editor_background_removal_image(state, source_image.clone()).await {
+        match request_editor_background_removal_image(state, source_object_key).await {
             Ok(removed) => return Ok(removed),
             Err(error) => {
                 let will_retry = attempt < max_attempts;
@@ -3219,7 +3375,7 @@ pub(crate) struct EditorScreenBackgroundRemovalOutput {
 
 pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter(
     state: &AppState,
-    image: &DownloadedOpenAiImage,
+    source_object_key: &str,
     screen_color: EditorScreenBackgroundColor,
     seg_model: &str,
     cross_check: bool,
@@ -3227,7 +3383,7 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter(
 ) -> Result<EditorScreenBackgroundRemovalOutput, AppError> {
     remove_editor_generated_screen_background_with_bgfilter_with_request_timeout(
         state,
-        image,
+        source_object_key,
         screen_color,
         seg_model,
         cross_check,
@@ -3239,7 +3395,7 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter(
 
 pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with_request_timeout(
     state: &AppState,
-    image: &DownloadedOpenAiImage,
+    source_object_key: &str,
     screen_color: EditorScreenBackgroundColor,
     seg_model: &str,
     cross_check: bool,
@@ -3257,7 +3413,13 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with
             cooldown_ms = remaining.as_millis() as u64,
             "editor_bgfilter_circuit_open_fallback_to_aliyun_matting"
         );
-        return fallback_editor_screen_background_removal(state, image, screen_color, audit).await;
+        return fallback_editor_screen_background_removal(
+            state,
+            source_object_key,
+            screen_color,
+            audit,
+        )
+        .await;
     }
 
     let max_attempts = EDITOR_BGFILTER_RETRY_COUNT + 1;
@@ -3265,7 +3427,7 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with
     for attempt in 1..=max_attempts {
         match request_editor_generated_screen_background_with_bgfilter(
             state,
-            image,
+            source_object_key,
             screen_color,
             seg_model,
             cross_check,
@@ -3305,6 +3467,7 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with
                     "bgfilter_segment",
                     crate::external_api_audit::matting_failure_audit_status_code(&error),
                     crate::external_api_audit::matting_failure_audit_timeout(&error),
+                    crate::external_api_audit::matting_failure_audit_is_transport(&error),
                     crate::external_api_audit::matting_failure_audit_latency_ms(&error),
                     error.message().to_string(),
                     crate::external_api_audit::matting_failure_audit_raw_excerpt(&error),
@@ -3328,27 +3491,42 @@ pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with
             error_details = ?error.details(),
             "editor_bgfilter_fallback_to_aliyun_matting"
         );
-        return fallback_editor_screen_background_removal(state, image, screen_color, audit).await;
+        return fallback_editor_screen_background_removal(
+            state,
+            source_object_key,
+            screen_color,
+            audit,
+        )
+        .await;
     }
 
-    fallback_editor_screen_background_removal(state, image, screen_color, audit).await
+    fallback_editor_screen_background_removal(state, source_object_key, screen_color, audit).await
 }
 
 /// BgFilter 不可用（熔断打开或调用失败）时的统一兜底链：先阿里云通用抠图，失败再退本地键色扣除。
 /// 熔断打开路径与 BgFilter 调用失败路径共用此链，确保 cooldown 内仍是「阿里云 → 本地」而非直接本地。
 async fn fallback_editor_screen_background_removal(
     state: &AppState,
-    image: &DownloadedOpenAiImage,
+    source_object_key: &str,
     screen_color: EditorScreenBackgroundColor,
     audit: &crate::external_api_audit::ExternalApiAuditContext,
 ) -> Result<EditorScreenBackgroundRemovalOutput, AppError> {
-    match crate::aliyun_matting::segment_image_with_aliyun_matting(
+    let aliyun_result = match sign_editor_private_object_read_url(
         state,
-        image,
-        "editor-screen-background",
-    )
-    .await
-    {
+        source_object_key,
+        EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
+    ) {
+        Ok(source_url) => {
+            crate::aliyun_matting::segment_image_url_with_aliyun_matting(
+                state,
+                source_url.as_str(),
+                "editor-screen-background",
+            )
+            .await
+        }
+        Err(error) => Err(error),
+    };
+    match aliyun_result {
         Ok(image) => Ok(EditorScreenBackgroundRemovalOutput {
             image,
             provider: "Aliyun Matting",
@@ -3369,21 +3547,28 @@ async fn fallback_editor_screen_background_removal(
                     "aliyun-matting",
                     state.config.aliyun_matting_endpoint.clone(),
                     "editor-screen-background-removal",
-                    "aliyun_segment",
+                    crate::external_api_audit::matting_failure_audit_failure_stage(
+                        &error,
+                        "aliyun_segment",
+                    ),
                     crate::external_api_audit::matting_failure_audit_status_code(&error),
                     crate::external_api_audit::matting_failure_audit_timeout(&error),
+                    crate::external_api_audit::matting_failure_audit_is_transport(&error),
                     crate::external_api_audit::matting_failure_audit_latency_ms(&error),
                     error.message().to_string(),
                     crate::external_api_audit::matting_failure_audit_raw_excerpt(&error),
                 )
                 .await;
             }
-            remove_editor_generated_green_screen_background(image, screen_color).map(|image| {
-                EditorScreenBackgroundRemovalOutput {
-                    image,
-                    provider: "Genarrative Local",
-                    model: "screen-color-keying".to_string(),
-                }
+            let source_image =
+                download_editor_persisted_image_object(state, source_object_key).await?;
+            let output =
+                remove_editor_generated_green_screen_background(&source_image, screen_color);
+            drop(source_image);
+            output.map(|image| EditorScreenBackgroundRemovalOutput {
+                image,
+                provider: "Genarrative Local",
+                model: "screen-color-keying".to_string(),
             })
         }
     }
@@ -3442,47 +3627,36 @@ fn reset_editor_bgfilter_circuit_for_tests() {
 
 async fn request_editor_generated_screen_background_with_bgfilter(
     state: &AppState,
-    image: &DownloadedOpenAiImage,
+    source_object_key: &str,
     screen_color: EditorScreenBackgroundColor,
     seg_model: &str,
     cross_check: bool,
     request_timeout_ms: u64,
 ) -> Result<DownloadedOpenAiImage, AppError> {
     let url = editor_bgfilter_endpoint(state)?;
+    let signed_image_url = sign_editor_private_object_read_url(
+        state,
+        source_object_key,
+        EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
+    )?;
     let call_id = format!("bgfilter-call-{}", current_utc_micros());
     let request_started_at = Instant::now();
     let timeout_ms = request_timeout_ms.max(1);
-    let input_bytes = image.bytes.len();
-    let source_mime_type = image.mime_type.clone();
-    let source_file_name = format!(
-        "editor-generated-source.{}",
-        image.extension.trim_start_matches('.')
-    );
     tracing::info!(
         %call_id,
         upstream_url = %url,
-        file_name = %source_file_name,
-        mime_type = %source_mime_type,
+        source_object_key,
+        image_url_expire_seconds = EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
         screen_color = screen_color.hex,
         seg_model,
         background_mode = EDITOR_BGFILTER_BACKGROUND_MODE_FLAT,
         cross_check,
-        input_bytes,
         timeout_ms,
         "editor_bgfilter_request_start"
     );
     let http_client = state.editor_bgfilter_http_client();
-    let file_part = reqwest::multipart::Part::bytes(image.bytes.clone())
-        .file_name(source_file_name)
-        .mime_str(source_mime_type.as_str())
-        .map_err(|error| {
-            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                "provider": "bgfilter",
-                "message": format!("图片 MIME 类型无效：{error}"),
-            }))
-        })?;
     let form = reqwest::multipart::Form::new()
-        .part("file", file_part)
+        .text("image_url", signed_image_url.clone())
         .text("screen_color", screen_color.hex.to_string())
         .text("seg_model", seg_model.to_string())
         .text("background_mode", EDITOR_BGFILTER_BACKGROUND_MODE_FLAT)
@@ -3520,6 +3694,7 @@ async fn request_editor_generated_screen_background_with_bgfilter(
             .text()
             .await
             .unwrap_or_else(|error| format!("读取上游错误失败：{error}"));
+        let message = sanitize_editor_bgfilter_upstream_message(&message, &signed_image_url);
         tracing::warn!(
             %call_id,
             upstream_status = status.as_u16(),
@@ -3598,7 +3773,6 @@ async fn request_editor_generated_screen_background_with_bgfilter(
         upstream_screen_color = upstream_screen_color.as_deref().unwrap_or(""),
         upstream_seg_model = upstream_seg_model.as_deref().unwrap_or(""),
         upstream_cross_check = upstream_cross_check.as_deref().unwrap_or(""),
-        input_bytes,
         output_bytes = image.bytes.len(),
         elapsed_ms = request_started_at.elapsed().as_millis() as u64,
         upstream_elapsed_ms,
@@ -3610,38 +3784,30 @@ async fn request_editor_generated_screen_background_with_bgfilter(
 
 async fn request_editor_background_removal_image(
     state: &AppState,
-    source_image: OpenAiReferenceImage,
+    source_object_key: &str,
 ) -> Result<EditorBackgroundRemovalImage, AppError> {
     let url = editor_bgfilter_endpoint(state)?;
+    let signed_image_url = sign_editor_private_object_read_url(
+        state,
+        source_object_key,
+        EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
+    )?;
     let call_id = format!("background-removal-call-{}", current_utc_micros());
     let request_started_at = Instant::now();
     let timeout_ms = state.config.editor_bgfilter_request_timeout_ms.max(1);
-    let input_bytes = source_image.bytes.len();
-    let source_file_name = source_image.file_name.clone();
-    let source_mime_type = source_image.mime_type.clone();
     tracing::info!(
         %call_id,
         upstream_url = %url,
-        file_name = %source_file_name,
-        mime_type = %source_mime_type,
+        source_object_key,
+        image_url_expire_seconds = EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS,
         background_mode = EDITOR_BGFILTER_BACKGROUND_MODE_COMPLEX,
         cross_check = EDITOR_BGFILTER_CROSS_CHECK_DISABLED,
-        input_bytes,
         timeout_ms,
         "editor_background_removal_request_start"
     );
     let http_client = state.editor_bgfilter_http_client();
-    let file_part = reqwest::multipart::Part::bytes(source_image.bytes)
-        .file_name(source_image.file_name)
-        .mime_str(source_image.mime_type.as_str())
-        .map_err(|error| {
-            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                "provider": "bgfilter",
-                "message": format!("图片 MIME 类型无效：{error}"),
-            }))
-        })?;
     let form = reqwest::multipart::Form::new()
-        .part("file", file_part)
+        .text("image_url", signed_image_url.clone())
         .text("background_mode", EDITOR_BGFILTER_BACKGROUND_MODE_COMPLEX)
         .text("seg_model", EDITOR_BGFILTER_DEFAULT_SEG_MODEL)
         .text(
@@ -3674,6 +3840,7 @@ async fn request_editor_background_removal_image(
             .text()
             .await
             .unwrap_or_else(|error| format!("读取上游错误失败：{error}"));
+        let message = sanitize_editor_bgfilter_upstream_message(&message, &signed_image_url);
         tracing::warn!(
             %call_id,
             upstream_status = status.as_u16(),
@@ -3722,7 +3889,6 @@ async fn request_editor_background_removal_image(
         status = status.as_u16(),
         width = decoded.width(),
         height = decoded.height(),
-        input_bytes,
         output_bytes = image.bytes.len(),
         elapsed_ms = request_started_at.elapsed().as_millis() as u64,
         upstream_elapsed_ms,
@@ -3752,6 +3918,34 @@ fn editor_bgfilter_endpoint(state: &AppState) -> Result<String, AppError> {
     ))
 }
 
+fn sign_editor_private_object_read_url(
+    state: &AppState,
+    object_key: &str,
+    expire_seconds: u64,
+) -> Result<String, AppError> {
+    let oss_client = state.oss_client().ok_or_else(|| {
+        AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
+            "provider": "aliyun-oss",
+            "reason": "OSS 未完成环境变量配置",
+        }))
+    })?;
+    oss_client
+        .sign_get_object_url(OssSignedGetObjectUrlRequest {
+            object_key: object_key.to_string(),
+            expire_seconds: Some(expire_seconds),
+        })
+        .map(|signed| signed.signed_url)
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))
+}
+
+fn sanitize_editor_bgfilter_upstream_message(message: &str, signed_image_url: &str) -> String {
+    let sanitized = message.replace(signed_image_url, "[signed OSS URL redacted]");
+    if sanitized.to_ascii_lowercase().contains("x-oss-") {
+        return "BgFilter 服务返回错误（OSS 签名 URL 已脱敏）".to_string();
+    }
+    sanitized.chars().take(500).collect()
+}
+
 fn parse_editor_bgfilter_seg_model(value: Option<&str>) -> Result<&'static str, AppError> {
     let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) else {
         return Ok(EDITOR_BGFILTER_DEFAULT_SEG_MODEL);
@@ -4243,7 +4437,7 @@ pub(crate) async fn generate_editor_icon_spritesheet_for_owner(
         state,
         caller.owner_user_id.as_str(),
         generated.task_id.as_str(),
-        &image,
+        image,
         prompt.as_str(),
         generated.actual_prompt.as_deref(),
         EDITOR_ICON_SPRITESHEET_ASSET_KIND,
@@ -4252,6 +4446,7 @@ pub(crate) async fn generate_editor_icon_spritesheet_for_owner(
     )
     .await?;
     let source_image_src = editor_media_src_from_object_key(source_persisted.object_key.as_str());
+    let source_object_key = source_persisted.object_key.clone();
     let source_record = persist_editor_provider_source_resource(
         state,
         source_persisted,
@@ -4284,7 +4479,7 @@ pub(crate) async fn generate_editor_icon_spritesheet_for_owner(
     };
     let removal = remove_editor_generated_screen_background_with_bgfilter(
         state,
-        &image,
+        source_object_key.as_str(),
         screen_color,
         seg_model,
         EDITOR_BGFILTER_CROSS_CHECK_DISABLED,
@@ -4336,7 +4531,14 @@ pub(crate) async fn generate_editor_icon_spritesheet_for_owner(
     };
     let removal_provider = removal.provider;
     let (image, postprocess_dimension_error) =
-        apply_editor_postprocessed_alpha_to_provider_source_or_original(&image, removal.image);
+        apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original(
+            state,
+            source_object_key.as_str(),
+            source_width,
+            source_height,
+            removal.image,
+        )
+        .await;
     if let Some(error) = postprocess_dimension_error {
         tracing::warn!(
             task_id = %generated.task_id,
@@ -4988,7 +5190,7 @@ pub(crate) async fn extract_editor_ui_design_assets_for_owner(
         state,
         caller.owner_user_id.as_str(),
         generated.task_id.as_str(),
-        &image,
+        image,
         prompt.as_str(),
         generated.actual_prompt.as_deref(),
         EDITOR_UI_DESIGN_SPRITESHEET_ASSET_KIND,
@@ -4997,6 +5199,7 @@ pub(crate) async fn extract_editor_ui_design_assets_for_owner(
     )
     .await?;
     let source_image_src = editor_media_src_from_object_key(source_persisted.object_key.as_str());
+    let source_object_key = source_persisted.object_key.clone();
     let source_record = persist_editor_provider_source_resource(
         state,
         source_persisted,
@@ -5029,7 +5232,7 @@ pub(crate) async fn extract_editor_ui_design_assets_for_owner(
     };
     let removal = remove_editor_generated_screen_background_with_bgfilter(
         state,
-        &image,
+        source_object_key.as_str(),
         screen_color,
         seg_model,
         EDITOR_BGFILTER_CROSS_CHECK_DISABLED,
@@ -5081,7 +5284,14 @@ pub(crate) async fn extract_editor_ui_design_assets_for_owner(
     };
     let removal_provider = removal.provider;
     let (image, postprocess_dimension_error) =
-        apply_editor_postprocessed_alpha_to_provider_source_or_original(&image, removal.image);
+        apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original(
+            state,
+            source_object_key.as_str(),
+            source_width,
+            source_height,
+            removal.image,
+        )
+        .await;
     if let Some(error) = postprocess_dimension_error {
         tracing::warn!(
             task_id = %generated.task_id,
@@ -7097,6 +7307,71 @@ pub(crate) async fn persist_editor_generated_image(
     file_stem: &str,
     slot: &str,
     provider: &str,
+) -> Result<PersistedEditorGeneratedImage, AppError> {
+    persist_editor_generated_image_data(
+        state,
+        owner_user_id,
+        task_id,
+        GeneratedImageAssetDataUrl {
+            format: normalize_generated_image_asset_mime(image.mime_type.as_str()),
+            bytes: image.bytes.clone(),
+        },
+        prompt,
+        actual_prompt,
+        asset_kind,
+        path_kind,
+        file_stem,
+        slot,
+        provider,
+    )
+    .await
+}
+
+async fn persist_editor_generated_image_owned(
+    state: &AppState,
+    owner_user_id: &str,
+    task_id: &str,
+    image: DownloadedOpenAiImage,
+    prompt: &str,
+    actual_prompt: Option<&str>,
+    asset_kind: &str,
+    path_kind: &str,
+    file_stem: &str,
+    slot: &str,
+    provider: &str,
+) -> Result<PersistedEditorGeneratedImage, AppError> {
+    let image_data = GeneratedImageAssetDataUrl {
+        format: normalize_generated_image_asset_mime(image.mime_type.as_str()),
+        bytes: image.bytes,
+    };
+    persist_editor_generated_image_data(
+        state,
+        owner_user_id,
+        task_id,
+        image_data,
+        prompt,
+        actual_prompt,
+        asset_kind,
+        path_kind,
+        file_stem,
+        slot,
+        provider,
+    )
+    .await
+}
+
+async fn persist_editor_generated_image_data(
+    state: &AppState,
+    owner_user_id: &str,
+    task_id: &str,
+    image: GeneratedImageAssetDataUrl,
+    prompt: &str,
+    actual_prompt: Option<&str>,
+    asset_kind: &str,
+    path_kind: &str,
+    file_stem: &str,
+    slot: &str,
+    provider: &str,
 ) -> Result<PersistedEditorGeneratedImage, AppError> {
     let oss_client = state.oss_client().ok_or_else(|| {
         AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
@@ -7113,10 +7388,7 @@ pub(crate) async fn persist_editor_generated_image(
                 sanitize_editor_storage_segment(task_id, "task"),
             ],
             file_stem: sanitize_editor_storage_segment(file_stem, "image"),
-            image: GeneratedImageAssetDataUrl {
-                format: normalize_generated_image_asset_mime(image.mime_type.as_str()),
-                bytes: image.bytes.clone(),
-            },
+            image,
             access: OssObjectAccess::Private,
             metadata: GeneratedImageAssetAdapterMetadata {
                 asset_kind: Some(asset_kind.to_string()),
@@ -7192,14 +7464,14 @@ async fn persist_editor_provider_source_image(
     state: &AppState,
     owner_user_id: &str,
     task_id: &str,
-    image: &DownloadedOpenAiImage,
+    image: DownloadedOpenAiImage,
     prompt: &str,
     actual_prompt: Option<&str>,
     asset_kind: &str,
     path_kind: &str,
     file_stem: &str,
 ) -> Result<PersistedEditorGeneratedImage, AppError> {
-    persist_editor_generated_image(
+    persist_editor_generated_image_owned(
         state,
         owner_user_id,
         task_id,
@@ -7251,12 +7523,18 @@ async fn persist_editor_provider_source_resource(
 
 const EDITOR_REFERENCE_IMAGE_READ_EXPIRE_SECONDS: u64 = 300;
 const EDITOR_REFERENCE_IMAGE_MAX_SIZE_BYTES: u64 = 32 * 1024 * 1024;
+const EDITOR_BACKGROUND_REMOVAL_SOURCE_PROBE_BYTES: u64 = 16;
 const EDITOR_BACKGROUND_REMOVAL_MAX_RESPONSE_BYTES: usize = 32 * 1024 * 1024;
 const EDITOR_BACKGROUND_REMOVAL_MAX_IMAGE_DIMENSION: u32 = 8192;
 
 fn is_editor_inline_media_source(source: &str) -> bool {
-    let normalized = source.trim_start().to_ascii_lowercase();
-    normalized.starts_with("data:") || normalized.starts_with("blob:")
+    source
+        .trim_start()
+        .as_bytes()
+        .get(..5)
+        .is_some_and(|prefix| {
+            prefix.eq_ignore_ascii_case(b"data:") || prefix.eq_ignore_ascii_case(b"blob:")
+        })
 }
 
 fn ensure_editor_reference_image_source_is_stable(
@@ -7294,18 +7572,8 @@ pub(crate) async fn parse_editor_reference_image(
     owner_user_id: &str,
     source: &str,
 ) -> Result<OpenAiReferenceImage, AppError> {
-    let trimmed = source.trim();
-    if is_editor_inline_media_source(trimmed) {
-        return Err(
-            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                "provider": "editor-reference-image",
-                "field": "sourceImageSrc",
-                "message": "图片参考图必须先上传 OSS，并使用 objectKey、项目资源 ID 或素材 ID 引用。",
-            })),
-        );
-    }
     let object_key =
-        resolve_editor_reference_object_key_for_owner(state, owner_user_id, trimmed).await?;
+        resolve_editor_reference_object_key_for_owner(state, owner_user_id, source).await?;
     read_editor_reference_image_object(state, object_key.as_str()).await
 }
 
@@ -7349,6 +7617,12 @@ async fn resolve_editor_reference_object_key(
     owner_user_id: &str,
     source: &str,
 ) -> Result<String, AppError> {
+    ensure_editor_reference_image_source_is_stable(
+        source,
+        "editor-reference-image",
+        "sourceImageSrc",
+        "图片参考图",
+    )?;
     match normalize_editor_reference_object_key(source) {
         Ok(object_key) => Ok(object_key),
         Err(error) => {
@@ -7547,7 +7821,7 @@ async fn read_editor_reference_image_object(
             expire_seconds: Some(EDITOR_REFERENCE_IMAGE_READ_EXPIRE_SECONDS),
         })
         .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
-    let response = reqwest::Client::new()
+    let mut response = reqwest::Client::new()
         .get(signed.signed_url.as_str())
         .send()
         .await
@@ -7579,12 +7853,18 @@ async fn read_editor_reference_image_object(
         .and_then(|value| value.to_str().ok())
         .and_then(normalize_editor_reference_image_mime_type)
         .map(ToOwned::to_owned);
-    let bytes = response.bytes().await.map_err(|error| {
+    let mut bytes = Vec::new();
+    while let Some(chunk) = response.chunk().await.map_err(|error| {
         AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
             "provider": "aliyun-oss",
             "message": format!("读取图片参考图内容失败：{error}"),
         }))
-    })?;
+    })? {
+        if bytes.len().saturating_add(chunk.len()) as u64 > EDITOR_REFERENCE_IMAGE_MAX_SIZE_BYTES {
+            return Err(editor_reference_image_too_large());
+        }
+        bytes.extend_from_slice(chunk.as_ref());
+    }
     if bytes.is_empty() {
         return Err(
             AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
@@ -7594,11 +7874,8 @@ async fn read_editor_reference_image_object(
             })),
         );
     }
-    if bytes.len() as u64 > EDITOR_REFERENCE_IMAGE_MAX_SIZE_BYTES {
-        return Err(editor_reference_image_too_large());
-    }
     let mime_type = content_type_mime
-        .or_else(|| infer_editor_reference_image_mime_type(bytes.as_ref()).map(ToOwned::to_owned))
+        .or_else(|| infer_editor_reference_image_mime_type(bytes.as_slice()).map(ToOwned::to_owned))
         .ok_or_else(|| {
             AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                 "provider": "editor-reference-image",
@@ -7610,12 +7887,24 @@ async fn read_editor_reference_image_object(
         .to_string();
     let extension = editor_reference_image_extension(mime_type.as_str());
     Ok(OpenAiReferenceImage {
-        bytes: bytes.to_vec(),
+        bytes,
         mime_type,
         file_name: format!("editor-reference.{extension}"),
     })
 }
 
+async fn download_editor_persisted_image_object(
+    state: &AppState,
+    object_key: &str,
+) -> Result<DownloadedOpenAiImage, AppError> {
+    let image = read_editor_reference_image_object(state, object_key).await?;
+    Ok(DownloadedOpenAiImage {
+        extension: editor_reference_image_extension(image.mime_type.as_str()).to_string(),
+        mime_type: image.mime_type,
+        bytes: image.bytes,
+    })
+}
+
 fn normalize_editor_reference_image_mime_type(content_type: &str) -> Option<&str> {
     let mime_type = content_type.split(';').next()?.trim();
     mime_type.starts_with("image/").then_some(mime_type)
@@ -7890,6 +8179,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn bgfilter_upstream_message_redacts_signed_oss_url() {
+        let signed_url = "https://dev-bucket.oss-cn-beijing.aliyuncs.com/generated/input.png?x-oss-signature=secret&x-oss-expires=600";
+        let message = format!("invalid image_url: {signed_url}; code=fetch_failed");
+
+        let sanitized = sanitize_editor_bgfilter_upstream_message(&message, signed_url);
+
+        assert!(!sanitized.contains("x-oss-signature"));
+        assert!(!sanitized.contains("secret"));
+        assert!(sanitized.contains("[signed OSS URL redacted]"));
+        assert!(sanitized.contains("fetch_failed"));
+
+        let escaped_message = format!("invalid image_url: {}", signed_url.replace('&', "\\u0026"));
+        let escaped_sanitized =
+            sanitize_editor_bgfilter_upstream_message(&escaped_message, signed_url);
+        assert!(!escaped_sanitized.contains("x-oss-"));
+        assert!(!escaped_sanitized.contains("secret"));
+    }
+
     #[test]
     fn bgfilter_body_read_timeout_maps_to_gateway_timeout_and_transport() {
         let error = editor_image_removal_body_read_error(
@@ -9757,11 +10065,23 @@ mod tests {
     }
 
     #[test]
-    fn editor_reference_image_data_url_is_not_an_object_reference() {
-        let error = normalize_editor_reference_object_key("data:image/png;base64,AAAA")
-            .expect_err("inline image should require upload before generation");
+    fn editor_reference_inline_media_is_not_an_object_reference() {
+        for inline_source in ["data:image/png;base64,AAAA", "blob:browser-only"] {
+            let error = normalize_editor_reference_object_key(inline_source)
+                .expect_err("inline image should require upload before generation");
+            assert!(error.body_text().contains("objectKey"));
+        }
 
-        assert!(error.body_text().contains("objectKey"));
+        let source = include_str!("editor_project.rs");
+        assert_function_contains_in_order(
+            source,
+            "async fn resolve_editor_reference_object_key(",
+            "async fn find_editor_reference_object_key_by_registered_id",
+            &[
+                "ensure_editor_reference_image_source_is_stable",
+                "normalize_editor_reference_object_key",
+            ],
+        );
     }
 
     #[test]
@@ -9944,6 +10264,49 @@ mod tests {
         assert_eq!(infer_editor_reference_image_mime_type(b"not image"), None);
     }
 
+    #[test]
+    fn editor_background_removal_source_requires_supported_content_type_and_matching_magic() {
+        assert_eq!(
+            normalize_editor_background_removal_source_mime_type(Some("IMAGE/PNG; charset=utf-8")),
+            Some("image/png")
+        );
+        assert_eq!(
+            normalize_editor_background_removal_source_mime_type(Some("image/gif")),
+            None
+        );
+        assert_eq!(
+            normalize_editor_background_removal_source_mime_type(Some("application/pdf")),
+            None
+        );
+        assert_eq!(
+            normalize_editor_background_removal_source_mime_type(None),
+            None
+        );
+
+        assert!(
+            validate_editor_background_removal_source_content(
+                "image/png",
+                b"\x89PNG\r\n\x1a\nrest"
+            )
+            .is_ok()
+        );
+        assert_eq!(
+            validate_editor_background_removal_source_content(
+                "image/png",
+                &[0xff, 0xd8, 0xff, 0xe0]
+            )
+            .expect_err("mismatched image content should be rejected")
+            .status_code(),
+            StatusCode::UNSUPPORTED_MEDIA_TYPE
+        );
+        assert_eq!(
+            validate_editor_background_removal_source_content("image/png", b"not image")
+                .expect_err("non-image content should be rejected")
+                .status_code(),
+            StatusCode::UNSUPPORTED_MEDIA_TYPE
+        );
+    }
+
     #[test]
     fn editor_character_postprocess_fallback_response_keeps_source_and_warning() {
         let response = EditorImageGenerationResponse {
@@ -10442,18 +10805,17 @@ mod tests {
         let state = AppState::new(AppConfig {
             editor_bgfilter_base_url: base_url,
             editor_bgfilter_request_timeout_ms: 20,
+            oss_bucket: Some("genarrative-assets".to_string()),
+            oss_endpoint: Some("oss-cn-beijing.aliyuncs.com".to_string()),
+            oss_access_key_id: Some("test-ak".to_string()),
+            oss_access_key_secret: Some("test-sk".to_string()),
             ..AppConfig::default()
         })
         .expect("state should build");
-        let source_image = DownloadedOpenAiImage {
-            bytes: encode_test_png(2, 2),
-            mime_type: "image/png".to_string(),
-            extension: "png".to_string(),
-        };
 
         let removed = request_editor_generated_screen_background_with_bgfilter(
             &state,
-            &source_image,
+            "generated-character-drafts/editor/source.png",
             parse_editor_screen_background_color(Some("#CFEFFF"))
                 .expect("screen color should parse"),
             EDITOR_BGFILTER_DEFAULT_SEG_MODEL,
@@ -10480,18 +10842,20 @@ mod tests {
             editor_bgfilter_base_url: base_url,
             editor_bgfilter_token: Some("manual-complex-token".to_string()),
             editor_bgfilter_request_timeout_ms: 5_000,
+            oss_bucket: Some("genarrative-assets".to_string()),
+            oss_endpoint: Some("oss-cn-beijing.aliyuncs.com".to_string()),
+            oss_access_key_id: Some("test-ak".to_string()),
+            oss_access_key_secret: Some("test-sk".to_string()),
             ..AppConfig::default()
         })
         .expect("state should build");
-        let source_image = OpenAiReferenceImage {
-            bytes: encode_test_png(2, 2),
-            mime_type: "image/png".to_string(),
-            file_name: "manual-source.png".to_string(),
-        };
 
-        let removed = request_editor_background_removal_image_with_retry(&state, source_image)
-            .await
-            .expect("BgFilter PNG response should decode");
+        let removed = request_editor_background_removal_image_with_retry(
+            &state,
+            "generated-character-drafts/editor/manual-source.png",
+        )
+        .await
+        .expect("BgFilter PNG response should decode");
         let request = request_receiver
             .recv_timeout(Duration::from_secs(1))
             .expect("mock server should capture request");
@@ -10503,7 +10867,10 @@ mod tests {
         assert!(
             lowercase_request.contains("\r\nx-genarrative-image-token: manual-complex-token\r\n")
         );
-        assert!(request_text.contains("name=\"file\"; filename=\"manual-source.png\""));
+        assert!(request_text.contains("name=\"image_url\""));
+        assert!(request_text.contains("genarrative-assets.oss-cn-beijing.aliyuncs.com"));
+        assert!(lowercase_request.contains("x-oss-signature-version"));
+        assert!(!request_text.contains("name=\"file\""));
         assert!(request_text.contains("name=\"background_mode\"\r\n\r\ncomplex\r\n"));
         assert!(request_text.contains("name=\"seg_model\"\r\n\r\nbirefnet\r\n"));
         assert!(request_text.contains("name=\"cross_check\"\r\n\r\noff\r\n"));
@@ -10648,6 +11015,8 @@ mod tests {
             "struct EditorBackgroundRemovalImage",
             &[
                 "caller.report_processing_phase(state).await?",
+                "resolve_editor_reference_object_key_for_owner",
+                "validate_editor_background_removal_source",
                 "request_editor_background_removal_image_with_retry",
             ],
         );
@@ -10704,8 +11073,10 @@ mod tests {
             "async fn fallback_editor_screen_background_removal",
             "async fn request_editor_generated_screen_background_with_bgfilter",
             &[
-                "segment_image_with_aliyun_matting",
+                "segment_image_url_with_aliyun_matting",
+                "download_editor_persisted_image_object",
                 "remove_editor_generated_green_screen_background",
+                "drop(source_image)",
             ],
         );
         assert_function_contains(
@@ -10714,6 +11085,9 @@ mod tests {
             "async fn request_editor_background_removal_image(",
             &[
                 "editor_bgfilter_endpoint",
+                "sign_editor_private_object_read_url",
+                "EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS",
+                "\"image_url\"",
                 "request_timeout_ms.max(1)",
                 "state.editor_bgfilter_http_client()",
                 ".timeout(Duration::from_millis(timeout_ms))",
@@ -10730,7 +11104,11 @@ mod tests {
             source,
             "async fn request_editor_generated_screen_background_with_bgfilter",
             "async fn request_editor_background_removal_image(",
-            &["reqwest::Client::builder"],
+            &[
+                ".part(\"file\"",
+                "reqwest::multipart::Part::bytes",
+                "reqwest::Client::builder",
+            ],
         );
         assert_function_contains(
             source,
@@ -10738,6 +11116,9 @@ mod tests {
             "fn editor_bgfilter_endpoint",
             &[
                 "editor_bgfilter_endpoint",
+                "sign_editor_private_object_read_url",
+                "EDITOR_MATTING_SOURCE_URL_EXPIRE_SECONDS",
+                "\"image_url\"",
                 "editor_bgfilter_request_timeout_ms.max(1)",
                 "state.editor_bgfilter_http_client()",
                 "editor_bgfilter_token",
@@ -10754,7 +11135,12 @@ mod tests {
             source,
             "async fn request_editor_background_removal_image(",
             "fn editor_bgfilter_endpoint",
-            &["\"screen_color\"", "reqwest::Client::builder"],
+            &[
+                "\"screen_color\"",
+                ".part(\"file\"",
+                "reqwest::multipart::Part::bytes",
+                "reqwest::Client::builder",
+            ],
         );
         assert_function_not_contains(
             source,
@@ -11069,7 +11455,7 @@ mod tests {
             &[
                 "let max_attempts = EDITOR_BGFILTER_RETRY_COUNT + 1",
                 "for attempt in 1..=max_attempts",
-                "request_editor_background_removal_image(state, source_image.clone())",
+                "request_editor_background_removal_image(state, source_object_key)",
                 "let will_retry = attempt < max_attempts",
                 "if will_retry",
                 "continue",
@@ -11078,6 +11464,110 @@ mod tests {
         );
     }
 
+    #[test]
+    fn editor_matting_releases_source_buffers_at_oss_boundaries() {
+        let source = include_str!("editor_project.rs");
+        for (start, end) in [
+            (
+                "pub(crate) async fn generate_editor_image_for_owner",
+                "fn normalize_editor_image_generation_size",
+            ),
+            (
+                "pub(crate) async fn generate_editor_icon_spritesheet_for_owner",
+                "pub async fn extract_editor_ui_design_assets",
+            ),
+            (
+                "pub(crate) async fn extract_editor_ui_design_assets_for_owner",
+                "pub(crate) fn editor_project_payload_from_record",
+            ),
+        ] {
+            assert_function_contains_in_order(
+                source,
+                start,
+                end,
+                &[
+                    "persist_editor_provider_source_image",
+                    "remove_editor_generated_screen_background_with_bgfilter",
+                    "apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original",
+                    "persist_editor_generated_image",
+                ],
+            );
+        }
+        assert_function_contains(
+            source,
+            "async fn persist_editor_provider_source_image",
+            "async fn persist_editor_provider_source_resource",
+            &["persist_editor_generated_image_owned"],
+        );
+        assert_function_contains_in_order(
+            source,
+            "async fn apply_editor_postprocessed_alpha_from_persisted_provider_source_or_original",
+            "fn restore_editor_generated_image_output_dimensions",
+            &[
+                "into_dimensions",
+                "return (postprocessed, None)",
+                "download_editor_persisted_image_object",
+                "apply_editor_postprocessed_alpha_to_provider_source",
+            ],
+        );
+        for (start, end) in [
+            (
+                "pub(crate) async fn generate_editor_icon_spritesheet_for_owner",
+                "pub async fn extract_editor_ui_design_assets",
+            ),
+            (
+                "pub(crate) async fn extract_editor_ui_design_assets_for_owner",
+                "pub(crate) fn editor_project_payload_from_record",
+            ),
+        ] {
+            assert_function_contains(
+                source,
+                start,
+                end,
+                &["bytes: image.bytes.clone()", "slice_source"],
+            );
+            assert_function_not_contains(
+                source,
+                start,
+                end,
+                &[
+                    "download_editor_persisted_image_object",
+                    "drop(slice_source)",
+                ],
+            );
+        }
+        assert_function_not_contains(
+            source,
+            "pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter(",
+            "pub(crate) async fn remove_editor_generated_screen_background_with_bgfilter_with_request_timeout",
+            &["fallback_image", "DownloadedOpenAiImage"],
+        );
+        assert_function_contains(
+            source,
+            "async fn persist_editor_generated_image_owned",
+            "async fn persist_editor_generated_image_data",
+            &["bytes: image.bytes"],
+        );
+        assert_function_not_contains(
+            source,
+            "async fn persist_editor_generated_image_owned",
+            "async fn persist_editor_generated_image_data",
+            &["image.bytes.clone()"],
+        );
+        assert_function_contains(
+            source,
+            "async fn read_editor_reference_image_object",
+            "async fn download_editor_persisted_image_object",
+            &["response.chunk().await", "bytes.extend_from_slice"],
+        );
+        assert_function_not_contains(
+            source,
+            "async fn read_editor_reference_image_object",
+            "async fn download_editor_persisted_image_object",
+            &["response.bytes().await", "bytes.to_vec()"],
+        );
+    }
+
     #[test]
     fn editor_paid_image_postprocess_keeps_provider_outputs_recoverable() {
         let source = include_str!("editor_project.rs");
diff --git a/server-rs/crates/api-server/src/external_api_audit.rs b/server-rs/crates/api-server/src/external_api_audit.rs
index e62d3a0fb..0039f7b0a 100644
--- a/server-rs/crates/api-server/src/external_api_audit.rs
+++ b/server-rs/crates/api-server/src/external_api_audit.rs
@@ -159,6 +159,7 @@ pub(crate) async fn record_matting_external_api_failure(
     failure_stage: &'static str,
     status_code: Option<u16>,
     timeout: bool,
+    transport: bool,
     latency_ms: Option<u64>,
     error_message: String,
     raw_excerpt: Option<String>,
@@ -170,6 +171,7 @@ pub(crate) async fn record_matting_external_api_failure(
         failure_stage,
         status_code,
         timeout,
+        transport,
         latency_ms,
         error_message,
         raw_excerpt,
@@ -178,31 +180,41 @@ pub(crate) async fn record_matting_external_api_failure(
     record_external_api_failure(state, draft).await;
 }
 
+/// 构建抠图失败审计 draft。`transport` 必须由调用方从错误结构化字段读取，
+/// 不能用 `status_code.is_none()` 反推——本地处理失败同样没有上游 HTTP 状态。
 #[allow(clippy::too_many_arguments)]
-fn build_matting_external_api_failure_draft(
+pub(crate) fn build_matting_external_api_failure_draft(
     provider: &'static str,
     endpoint: String,
     operation: &'static str,
     failure_stage: &'static str,
     status_code: Option<u16>,
     timeout: bool,
+    transport: bool,
     latency_ms: Option<u64>,
     error_message: String,
     raw_excerpt: Option<String>,
     context: &ExternalApiAuditContext,
 ) -> ExternalApiFailureDraft {
-    // status_code=None ⟺ statusClass=transport（见 status_class）：DNS / 连接重置 / 读体中断 / 超时
-    // 这类传输层失败没有上游 HTTP 状态。它们必须与 "transport failures actionable" 语义一致，
-    // 记为 retryable=true，否则 statusClass=transport 却 retryable=false 会误导告警 / 重试分析。
-    let has_transport_error = status_code.is_none();
+    // 传输层：无上游 HTTP 状态 + timeout/transport 标记 → statusClass=transport、retryable=true。
+    // 本地处理：无上游 HTTP 状态且非 transport → statusClass=local、retryable=false。
+    // 不得把「status_code=None」一律当成 transport，否则 LocalProcessing 会污染可重试 5xx 分析。
+    let is_transport_failure = timeout || transport;
+    let resolved_status_class = if is_transport_failure && status_code.is_none() {
+        "transport"
+    } else if status_code.is_none() {
+        "local"
+    } else {
+        status_class(status_code)
+    };
     ExternalApiFailureDraft::new(provider, endpoint, operation, failure_stage, error_message)
         .with_status_code(status_code)
-        .with_optional_status_class(Some(status_class(status_code)))
+        .with_optional_status_class(Some(resolved_status_class))
         .with_timeout(timeout)
         .with_retryable(is_retryable_external_api_failure(
             status_code,
             timeout,
-            has_transport_error,
+            is_transport_failure,
         ))
         .with_latency_ms(latency_ms)
         .with_raw_excerpt(raw_excerpt)
@@ -210,21 +222,31 @@ fn build_matting_external_api_failure_draft(
 }
 
 pub(crate) fn matting_failure_audit_status_code(error: &AppError) -> Option<u16> {
-    error
+    // 真实上游 HTTP 状态优先；本地处理 / 传输层都没有可写的上游 status。
+    if let Some(status) = error
         .details()
         .and_then(|details| details.get("upstreamStatus"))
         .and_then(Value::as_u64)
         .and_then(|value| u16::try_from(value).ok())
-        .or_else(|| {
-            if matting_failure_audit_is_transport(error) {
-                None
-            } else {
-                Some(error.status_code().as_u16())
-            }
-        })
+    {
+        return Some(status);
+    }
+    if matting_failure_audit_is_local_processing(error) || matting_failure_audit_is_transport(error)
+    {
+        return None;
+    }
+    Some(error.status_code().as_u16())
 }
 
-fn matting_failure_audit_is_transport(error: &AppError) -> bool {
+pub(crate) fn matting_failure_audit_is_local_processing(error: &AppError) -> bool {
+    error
+        .details()
+        .and_then(|details| details.get("localProcessing"))
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+}
+
+pub(crate) fn matting_failure_audit_is_transport(error: &AppError) -> bool {
     matting_failure_audit_timeout(error)
         || error
             .details()
@@ -256,6 +278,30 @@ pub(crate) fn matting_failure_external_call_attempted(error: &AppError) -> bool
         .unwrap_or(true)
 }
 
+pub(crate) fn matting_failure_audit_failure_stage(
+    error: &AppError,
+    fallback: &'static str,
+) -> &'static str {
+    let stage = error
+        .details()
+        .and_then(|details| details.get("failureStage"))
+        .and_then(Value::as_str);
+    match stage {
+        Some("preflight") => "preflight",
+        Some("source_download") => "source_download",
+        Some("source_decode") => "source_decode",
+        Some("source_validate") => "source_validate",
+        Some("source_normalize") => "source_normalize",
+        Some("temp_upload") => "temp_upload",
+        Some("aliyun_segment") => "aliyun_segment",
+        Some("result_download") => "result_download",
+        Some("result_decode") => "result_decode",
+        Some("result_validate") => "result_validate",
+        Some("result_encode") => "result_encode",
+        _ => fallback,
+    }
+}
+
 pub(crate) fn matting_failure_audit_raw_excerpt(error: &AppError) -> Option<String> {
     error
         .details()
@@ -575,7 +621,7 @@ mod tests {
 
     #[test]
     fn matting_failure_draft_marks_non_timeout_transport_retryable() {
-        // status_code=None、timeout=false 的非超时 transport 失败（DNS / 连接重置 / 读体中断）：
+        // status_code=None、timeout=false、transport=true 的非超时传输故障：
         // statusClass 必须是 transport 且 retryable=true，否则与 "transport failures actionable" 冲突。
         let draft = build_matting_external_api_failure_draft(
             "bgfilter",
@@ -584,6 +630,7 @@ mod tests {
             "bgfilter_segment",
             None,
             false,
+            true,
             Some(67),
             "请求 BgFilter 服务失败：dns error".to_string(),
             Some("dns error".to_string()),
@@ -599,6 +646,29 @@ mod tests {
         );
     }
 
+    #[test]
+    fn matting_failure_draft_marks_local_processing_non_retryable() {
+        // 本地处理失败没有上游 HTTP 状态，也不是 transport；不得记成可重试 5xx/transport。
+        let draft = build_matting_external_api_failure_draft(
+            "aliyun-matting",
+            "imageseg.example".to_string(),
+            "editor-screen-background-removal",
+            "source_decode",
+            None,
+            false,
+            false,
+            Some(3),
+            "解析待抠图图片失败：invalid png".to_string(),
+            Some("invalid png".to_string()),
+            &ExternalApiAuditContext::default(),
+        );
+
+        assert_eq!(draft.status_code, None);
+        assert_eq!(draft.status_class, Some("local"));
+        assert!(!draft.timeout);
+        assert!(!draft.retryable);
+    }
+
     #[test]
     fn matting_failure_draft_keeps_client_error_non_retryable() {
         // 真实上游 4xx（非 429 / 408）不是传输故障，仍应 retryable=false，不能被误判为可重试。
@@ -609,6 +679,7 @@ mod tests {
             "aliyun_segment",
             Some(400),
             false,
+            false,
             Some(12),
             "通用抠图接口返回失败（HTTP 400，Code=InvalidImage）：bad image".to_string(),
             None,
diff --git a/server-rs/crates/platform-matting/Cargo.toml b/server-rs/crates/platform-matting/Cargo.toml
index 87a387af0..eacc33dad 100644
--- a/server-rs/crates/platform-matting/Cargo.toml
+++ b/server-rs/crates/platform-matting/Cargo.toml
@@ -5,13 +5,10 @@ version.workspace = true
 license.workspace = true
 
 [dependencies]
-base64 = { workspace = true }
 hmac = { workspace = true }
 hex = { workspace = true }
-httpdate = { workspace = true }
 image = { workspace = true, features = ["png", "jpeg", "webp"] }
-sha1 = { workspace = true }
-reqwest = { workspace = true, features = ["json", "rustls-tls"] }
+reqwest = { workspace = true, features = ["json", "multipart", "rustls-tls"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_urlencoded = { workspace = true }
diff --git a/server-rs/crates/platform-matting/examples/segment_smoke.rs b/server-rs/crates/platform-matting/examples/segment_smoke.rs
index a0c817402..ba684b9a5 100644
--- a/server-rs/crates/platform-matting/examples/segment_smoke.rs
+++ b/server-rs/crates/platform-matting/examples/segment_smoke.rs
@@ -1,9 +1,12 @@
-//! 通用抠图冒烟验证：本地图片 → OSS → SegmentCommonImage → 下载结果。
+//! 通用抠图冒烟验证：本地图片 → AuthorizeFileUpload 临时对象 → SegmentCommonImage → 下载结果。
 //!
 //! 运行（在 server-rs 目录下）：
 //! cargo run -p platform-matting --example segment_smoke -- "C:\path\to\input.png"
 //!
-//! 依赖仓库根目录 .env.local（OSS bucket/endpoint）与 .env.secrets.local（AK/SK）。
+//! 依赖仓库根目录 .env / .env.local / .env.secrets.local 中的 AK/SK
+//!（`GENARRATIVE_ALIYUN_MATTING_*` 或 `ALIBABA_CLOUD_ACCESS_KEY_*`）；
+//! 可选 `GENARRATIVE_ALIYUN_MATTING_ENDPOINT`。临时 OSS bucket/endpoint 由
+//! AuthorizeFileUpload 动态下发，不依赖自有 OSS 配置。
 
 use std::path::{Path, PathBuf};
 
@@ -67,17 +70,16 @@ async fn main() {
     let http_client = reqwest::Client::new();
 
     // --- 调用通用抠图 ---
-    // key 优先级：VIAPI 专用 → 官方 SDK 标准命名（#IMAGE_CALL）→ 短信 key 兜底。
+    // key 优先级与 api-server 配置保持一致：抠图专用 → 官方 SDK 标准命名。
     let (matting_key_id, matting_key_secret) = [
         (
-            "ALIYUN_IMAGESEG_ACCESS_KEY_ID",
-            "ALIYUN_IMAGESEG_ACCESS_KEY_SECRET",
+            "GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_ID",
+            "GENARRATIVE_ALIYUN_MATTING_ACCESS_KEY_SECRET",
         ),
         (
             "ALIBABA_CLOUD_ACCESS_KEY_ID",
             "ALIBABA_CLOUD_ACCESS_KEY_SECRET",
         ),
-        ("ALIYUN_SMS_ACCESS_KEY_ID", "ALIYUN_SMS_ACCESS_KEY_SECRET"),
     ]
     .iter()
     .find_map(|(id_name, secret_name)| {
@@ -91,7 +93,7 @@ async fn main() {
     })
     .expect("未找到可用的抠图 AccessKey 环境变量");
     let matting_config = MattingConfig::new(
-        std::env::var("ALIYUN_IMAGESEG_ENDPOINT")
+        std::env::var("GENARRATIVE_ALIYUN_MATTING_ENDPOINT")
             .unwrap_or_else(|_| DEFAULT_IMAGESEG_ENDPOINT.to_string()),
         matting_key_id,
         matting_key_secret,
@@ -99,12 +101,12 @@ async fn main() {
     .expect("抠图配置应有效");
     let matting_client = MattingClient::new(matting_config).expect("抠图客户端应可构建");
 
-    // 本地 OSS 在北京地域，抠图服务要求上海地域，走 VIAPI 官方临时桶上传。
+    // 非上海地域输入按新版官方 SDK 的 AdvanceRequest 口径申请单对象 Policy 后上传。
     let temp_url = matting_client
         .upload_temp_image(input_bytes, "segment-input.png", "image/png")
         .await
-        .expect("上传 VIAPI 临时桶应成功");
-    println!("[2/5] 已上传 VIAPI 临时桶");
+        .expect("上传 AuthorizeFileUpload 临时对象应成功");
+    println!("[2/5] 已上传 AuthorizeFileUpload 临时对象");
     println!("[3/5] 输入图 URL host：{}", host_of(&temp_url));
 
     let result = matting_client
diff --git a/server-rs/crates/platform-matting/src/lib.rs b/server-rs/crates/platform-matting/src/lib.rs
index 854fafb19..b4f78d192 100644
--- a/server-rs/crates/platform-matting/src/lib.rs
+++ b/server-rs/crates/platform-matting/src/lib.rs
@@ -18,14 +18,12 @@ pub const DEFAULT_IMAGESEG_ENDPOINT: &str = "imageseg.cn-shanghai.aliyuncs.com";
 const IMAGESEG_API_VERSION: &str = "2019-12-30";
 const SEGMENT_COMMON_IMAGE_ACTION: &str = "SegmentCommonImage";
 
-// VIAPI 官方临时上传通道：抠图输入统一先传官方临时桶（1 天自动过期，无需清理；
-// 全用户共享 QPS）。抠图服务只认上海地域 OSS URL，而我们没有上海地域自有 OSS。
-// 文档：https://help.aliyun.com/document_detail/155645.html
-const VIAPI_UTILS_ENDPOINT: &str = "viapiutils.cn-shanghai.aliyuncs.com";
-const VIAPI_UTILS_VERSION: &str = "2020-04-01";
-const GET_OSS_STS_TOKEN_ACTION: &str = "GetOssStsToken";
-const VIAPI_TEMP_BUCKET: &str = "viapi-customer-temp";
-const VIAPI_TEMP_OSS_HOST: &str = "viapi-customer-temp.oss-cn-shanghai.aliyuncs.com";
+// VIAPI 新版官方 SDK 的 AdvanceRequest 上传通道：先向 Open Platform 申请单对象
+// Policy，再 multipart POST 到授权返回的上海地域临时 OSS。
+const OPEN_PLATFORM_ENDPOINT: &str = "openplatform.aliyuncs.com";
+const AUTHORIZE_FILE_UPLOAD_ACTION: &str = "AuthorizeFileUpload";
+const AUTHORIZE_FILE_UPLOAD_VERSION: &str = "2019-12-19";
+const IMAGESEG_PRODUCT: &str = "imageseg";
 
 pub const DEFAULT_MATTING_REQUEST_TIMEOUT_MS: u64 = 30_000;
 
@@ -142,10 +140,20 @@ pub struct SegmentCommonImageResult {
 pub enum MattingError {
     InvalidConfig(String),
     InvalidRequest(String),
+    LocalProcessing(LocalProcessingFailure),
     Sign(String),
     Upstream(UpstreamFailure),
 }
 
+/// 外部调用已经开始，但本地处理阶段失败。
+///
+/// 这类错误仍然需要进入外部失败审计，但不能被误标成上游 HTTP / 传输故障。
+#[derive(Debug)]
+pub struct LocalProcessingFailure {
+    message: String,
+    failure_stage: &'static str,
+}
+
 /// 结构化的上游调用失败分类。协议层归属（是否传输层故障、是否超时、上游 HTTP 状态）由
 /// platform-matting 在错误发生处直接捕获，调用方（api-server BFF）不再从中文 message 反推。
 #[derive(Debug)]
@@ -157,6 +165,7 @@ pub struct UpstreamFailure {
     transport: bool,
     /// 上游返回的 HTTP 状态码；`None` 表示没拿到状态（传输层故障或响应体不可用）。
     upstream_status: Option<u16>,
+    failure_stage: &'static str,
 }
 
 impl MattingError {
@@ -165,14 +174,17 @@ impl MattingError {
             Self::InvalidConfig(message) | Self::InvalidRequest(message) | Self::Sign(message) => {
                 message
             }
+            Self::LocalProcessing(failure) => &failure.message,
             Self::Upstream(failure) => &failure.message,
         }
     }
 
-    /// 是否真正向阿里云发起过外部调用。`InvalidConfig` / `InvalidRequest` / `Sign` 都是发请求前的
-    /// 本地预检失败，未触达上游。
+    /// 是否已经开始外部调用链路。
+    ///
+    /// `LocalProcessing` 表示外部调用已经开始，但解码、尺寸校验或其它本地处理失败；它不能
+    /// 与真正发请求前的 `InvalidConfig` / `InvalidRequest` / `Sign` 混为一谈。
     pub fn external_call_attempted(&self) -> bool {
-        matches!(self, Self::Upstream(_))
+        matches!(self, Self::LocalProcessing(_) | Self::Upstream(_))
     }
 
     /// 上游调用是否为传输层超时。
@@ -193,6 +205,35 @@ impl MattingError {
         }
     }
 
+    /// 失败发生阶段，供 api-server 生成准确的外部失败审计 metadata。
+    pub fn failure_stage(&self) -> &'static str {
+        match self {
+            Self::InvalidConfig(_) | Self::InvalidRequest(_) | Self::Sign(_) => "preflight",
+            Self::LocalProcessing(failure) => failure.failure_stage,
+            Self::Upstream(failure) => failure.failure_stage,
+        }
+    }
+
+    /// 将一个已经发生外部调用后的本地错误转换为可审计的处理失败。
+    pub fn with_failure_stage(self, failure_stage: &'static str) -> Self {
+        match self {
+            Self::InvalidConfig(message) | Self::InvalidRequest(message) | Self::Sign(message) => {
+                Self::LocalProcessing(LocalProcessingFailure {
+                    message,
+                    failure_stage,
+                })
+            }
+            Self::LocalProcessing(mut failure) => {
+                failure.failure_stage = failure_stage;
+                Self::LocalProcessing(failure)
+            }
+            Self::Upstream(mut failure) => {
+                failure.failure_stage = failure_stage;
+                Self::Upstream(failure)
+            }
+        }
+    }
+
     /// 传输层故障构造器：请求已发出但没拿到有效 HTTP 响应（连接、读体、超时）。
     pub fn upstream_transport_error(message: String, timeout: bool) -> Self {
         Self::Upstream(UpstreamFailure {
@@ -200,6 +241,7 @@ impl MattingError {
             timeout,
             transport: true,
             upstream_status: None,
+            failure_stage: "aliyun_segment",
         })
     }
 
@@ -210,6 +252,7 @@ impl MattingError {
             timeout: false,
             transport: false,
             upstream_status: Some(status),
+            failure_stage: "aliyun_segment",
         })
     }
 
@@ -221,6 +264,7 @@ impl MattingError {
             timeout: false,
             transport: false,
             upstream_status,
+            failure_stage: "aliyun_segment",
         })
     }
 }
@@ -383,74 +427,158 @@ impl MattingClient {
         })
     }
 
-    /// 图片字节 → 通用抠图 → 原尺寸透明 PNG 字节。
+    /// 私有 OSS 签名 URL → 下载 → AuthorizeFileUpload 临时对象 → 通用抠图 → 透明 PNG。
     ///
-    /// - 输入统一上传 VIAPI 官方临时桶（1 天自动过期，无需清理）后作为 ImageURL 送抠。
-    /// - 分辨率守卫：任一边 >= 2000 时先等比缩小送抠，抠完只取结果 alpha 上采样回贴
-    ///   原图 RGB，保证输出与输入同尺寸、画质无损。
-    pub async fn segment_image_to_transparent_png(
+    /// 源图下载缓冲和解码图只活到临时对象上传完成；若输入发生过降尺寸，结果返回后再单独下载
+    /// 一次源图完成 Alpha 回贴，避免在整个阿里云推理期间常驻原图内存。
+    pub async fn segment_image_url_to_transparent_png(
         &self,
-        bytes: &[u8],
+        source_url: &str,
         file_name: &str,
     ) -> Result<Vec<u8>, MattingError> {
-        let source = decode_source_image(bytes)?;
-        let source_rgba = source.to_rgba8();
-        let (source_width, source_height) = source_rgba.dimensions();
-
-        // 阿里云要求每条边 > 32px；过小的图直接拒绝，让调用方走本地兜底，省一次注定 4xx 的往返。
-        if source_width <= MIN_INPUT_EDGE || source_height <= MIN_INPUT_EDGE {
-            return Err(MattingError::InvalidRequest(format!(
-                "待抠图图片尺寸 {source_width}x{source_height} 过小，阿里云通用抠图要求每条边大于 {MIN_INPUT_EDGE} 像素"
-            )));
+        let source_url = source_url.trim();
+        if source_url.is_empty() {
+            return Err(MattingError::InvalidRequest(
+                "待抠图源图 URL 不能为空".to_string(),
+            ));
         }
 
-        // 归一化成阿里云 SegmentCommonImage 接受的输入：统一 8 位 RGBA PNG（消除 MIME 名不副实
-        // 与不支持位深/格式的问题）、最长边 ≤1999、体积 ≤3MB。返回实际上传尺寸，用于判断结果
-        // 是否需要 alpha 上采样回原尺寸。
-        let (upload_bytes, upload_dims) = normalize_matting_input_png(&source)?;
-        let downscaled = upload_dims != (source_width, source_height);
-        let image_url = self
-            .upload_temp_image(upload_bytes, file_name, "image/png")
-            .await?;
+        let (source_dims, upload_dims, image_url) = {
+            let source_bytes = self
+                .download_source_image(source_url)
+                .await
+                .map_err(|error| error.with_failure_stage("source_download"))?;
+            let source = decode_source_image(&source_bytes)
+                .map_err(|error| error.with_failure_stage("source_decode"))?;
+            let source_dims = (source.width(), source.height());
+            validate_source_dimensions(source_dims)
+                .map_err(|error| error.with_failure_stage("source_validate"))?;
+            let (upload_bytes, upload_dims) = normalize_matting_input_png(&source)
+                .map_err(|error| error.with_failure_stage("source_normalize"))?;
+            let image_url = self
+                .upload_temp_image(upload_bytes, file_name, "image/png")
+                .await
+                .map_err(|error| error.with_failure_stage("temp_upload"))?;
+            (source_dims, upload_dims, image_url)
+        };
 
+        let result_image = self
+            .segment_uploaded_input_to_rgba(image_url, source_dims, upload_dims)
+            .await?;
+        if upload_dims == source_dims {
+            return encode_rgba_png(&result_image)
+                .map_err(|error| error.with_failure_stage("result_encode"));
+        }
+
+        // 只有降尺寸送抠时才重新下载源图恢复原始 RGB；第一次下载缓冲已在上传临时对象后释放。
+        let source_rgba = {
+            let source_bytes = self
+                .download_source_image(source_url)
+                .await
+                .map_err(|error| error.with_failure_stage("source_download"))?;
+            let source = decode_source_image(&source_bytes)
+                .map_err(|error| error.with_failure_stage("source_decode"))?;
+            if (source.width(), source.height()) != source_dims {
+                return Err(MattingError::upstream_response_error(
+                    "待抠图源图在处理期间尺寸发生变化".to_string(),
+                    None,
+                )
+                .with_failure_stage("source_validate"));
+            }
+            source.to_rgba8()
+        };
+        compose_source_with_result_alpha(source_rgba, result_image)
+            .map_err(|error| error.with_failure_stage("result_encode"))
+    }
+
+    async fn segment_uploaded_input_to_rgba(
+        &self,
+        image_url: String,
+        source_dims: (u32, u32),
+        upload_dims: (u32, u32),
+    ) -> Result<image::RgbaImage, MattingError> {
         let result = self
             .segment_common_image(SegmentCommonImageRequest {
                 image_url,
                 // 默认 ReturnForm：原尺寸 + 透明背景，无需本地合成。
                 return_form: None,
             })
-            .await?;
-        let result_bytes = self.download_result_image(&result.image_url).await?;
-        let result_image = decode_result_image(&result_bytes)?.to_rgba8();
+            .await
+            .map_err(|error| error.with_failure_stage("aliyun_segment"))?;
+        let result_image = {
+            let result_bytes = self
+                .download_result_image(&result.image_url)
+                .await
+                .map_err(|error| error.with_failure_stage("result_download"))?;
+            decode_result_image(&result_bytes)
+                .map_err(|error| error.with_failure_stage("result_decode"))?
+                .to_rgba8()
+        };
+        if upload_dims == source_dims && result_image.dimensions() != source_dims {
+            return Err(MattingError::upstream_response_error(
+                format!(
+                    "抠图结果尺寸 {}x{} 与输入 {}x{} 不一致",
+                    result_image.width(),
+                    result_image.height(),
+                    source_dims.0,
+                    source_dims.1
+                ),
+                None,
+            )
+            .with_failure_stage("result_validate"));
+        }
+        Ok(result_image)
+    }
 
-        if !downscaled {
-            if result_image.dimensions() != (source_width, source_height) {
-                return Err(MattingError::upstream_response_error(
-                    format!(
-                        "抠图结果尺寸 {}x{} 与输入 {}x{} 不一致",
-                        result_image.width(),
-                        result_image.height(),
-                        source_width,
-                        source_height
-                    ),
-                    None,
-                ));
+    async fn download_source_image(&self, url: &str) -> Result<Vec<u8>, MattingError> {
+        let mut response = self.client.get(url).send().await.map_err(|error| {
+            MattingError::upstream_transport_error(
+                format!(
+                    "下载待抠图源图失败（transport={}, timeout={}, connect={}）",
+                    classify_reqwest_error(&error),
+                    error.is_timeout(),
+                    error.is_connect()
+                ),
+                error.is_timeout(),
+            )
+        })?;
+        let status = response.status();
+        if !status.is_success() {
+            return Err(MattingError::upstream_http_error(
+                format!("下载待抠图源图失败（HTTP {}）", status.as_u16()),
+                status.as_u16(),
+            ));
+        }
+        if response
+            .content_length()
+            .is_some_and(|length| length > MAX_RESULT_RESPONSE_BYTES as u64)
+        {
+            return Err(source_response_too_large_error());
+        }
+        let mut bytes = Vec::new();
+        while let Some(chunk) = response.chunk().await.map_err(|error| {
+            MattingError::upstream_transport_error(
+                format!(
+                    "读取待抠图源图失败（transport={}, timeout={}, connect={}）",
+                    classify_reqwest_error(&error),
+                    error.is_timeout(),
+                    error.is_connect()
+                ),
+                error.is_timeout(),
+            )
+        })? {
+            if bytes.len().saturating_add(chunk.len()) > MAX_RESULT_RESPONSE_BYTES {
+                return Err(source_response_too_large_error());
             }
-            return encode_rgba_png(&result_image);
+            bytes.extend_from_slice(chunk.as_ref());
         }
-
-        // 缩图送抠的场景：只取结果 alpha，上采样回原尺寸后贴回原图 RGB。
-        let alpha_mask = image::DynamicImage::ImageRgba8(result_image).resize_exact(
-            source_width,
-            source_height,
-            image::imageops::FilterType::Triangle,
-        );
-        let alpha_mask = alpha_mask.to_rgba8();
-        let mut output = source_rgba;
-        for (target, mask) in output.pixels_mut().zip(alpha_mask.pixels()) {
-            target.0[3] = target.0[3].min(mask.0[3]);
+        if bytes.is_empty() {
+            return Err(MattingError::upstream_response_error(
+                "待抠图源图为空".to_string(),
+                Some(status.as_u16()),
+            ));
         }
-        encode_rgba_png(&output)
+        Ok(bytes)
     }
 
     async fn download_result_image(&self, url: &str) -> Result<Vec<u8>, MattingError> {
@@ -490,8 +618,8 @@ impl MattingClient {
         Ok(bytes)
     }
 
-    /// 把本地图片字节上传到 VIAPI 官方临时桶，返回可直接作为 ImageURL 的公网地址。
-    /// 抠图输入的统一上传通道（我们没有上海地域自有 OSS，临时桶 1 天自动过期无需清理）。
+    /// 按 VIAPI 新版官方 SDK 的 AdvanceRequest 协议，把本地图片字节上传到授权的
+    /// 上海地域临时 OSS，返回可直接作为 ImageURL 的公网地址。
     pub async fn upload_temp_image(
         &self,
         bytes: Vec<u8>,
@@ -501,162 +629,92 @@ impl MattingClient {
         if bytes.is_empty() {
             return Err(MattingError::InvalidRequest("上传内容不能为空".to_string()));
         }
-        let sts = self.get_oss_sts_token().await?;
         let file_name = file_name.trim().trim_matches('/');
         if file_name.is_empty() {
             return Err(MattingError::InvalidRequest(
                 "file_name 不能为空".to_string(),
             ));
         }
-        // 阿里云要求 ImageURL 不含中文/非 ASCII 字符；object 叶子名只保留 URL 安全的 ASCII 字符，
-        // 唯一性由前缀 uuid 保证。
-        let safe_file_name: String = file_name
-            .chars()
-            .map(|c| {
-                if c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-') {
-                    c
-                } else {
-                    '_'
-                }
-            })
-            .collect();
-        let object_key = format!(
-            "{}/{}/{}",
-            self.config.access_key_id,
-            uuid::Uuid::new_v4().simple(),
-            safe_file_name
-        );
-        let date = httpdate::fmt_http_date(std::time::SystemTime::now());
-        // OSS V1 头签名（带 STS security token）。
-        let string_to_sign = format!(
-            "PUT\n\n{content_type}\n{date}\nx-oss-security-token:{}\n/{VIAPI_TEMP_BUCKET}/{object_key}",
-            sts.security_token
-        );
-        let signature =
-            hmac_sha1_base64(sts.access_key_secret.as_bytes(), string_to_sign.as_bytes())?;
-        let authorization = format!("OSS {}:{}", sts.access_key_id, signature);
-
-        let target_url = format!("https://{VIAPI_TEMP_OSS_HOST}/{object_key}");
+        let authorized = self.authorize_file_upload().await?;
+        let upload_host = format!("{}.{}", authorized.bucket, authorized.endpoint);
+        let target_url = format!("https://{upload_host}");
+        let file_part = reqwest::multipart::Part::bytes(bytes)
+            .file_name(file_name.to_string())
+            .mime_str(content_type)
+            .map_err(|error| {
+                MattingError::InvalidRequest(format!("上传内容类型不合法：{error}"))
+            })?;
+        let form = reqwest::multipart::Form::new()
+            .text("OSSAccessKeyId", authorized.access_key_id.clone())
+            .text("policy", authorized.encoded_policy.clone())
+            .text("Signature", authorized.signature.clone())
+            .text("key", authorized.object_key.clone())
+            .text("success_action_status", "201")
+            .part("file", file_part);
         let response = self
             .client
-            .put(&target_url)
-            .header(reqwest::header::CONTENT_TYPE, content_type)
-            .header(reqwest::header::DATE, &date)
-            .header("x-oss-security-token", &sts.security_token)
-            .header(reqwest::header::AUTHORIZATION, &authorization)
-            .body(bytes)
+            .post(&target_url)
+            .multipart(form)
             .send()
             .await
             .map_err(|error| {
                 MattingError::upstream_transport_error(
-                    format!("上传 VIAPI 临时桶请求失败：{error}"),
+                    format!("上传 AuthorizeFileUpload 临时对象请求失败：{error}"),
                     error.is_timeout(),
                 )
             })?;
         let status = response.status();
         if !status.is_success() {
             let body = response.text().await.unwrap_or_default();
-            // OSS 签名类错误体会回显 StringToSign（含 x-oss-security-token 明文）、StringToSignBytes
-            // 和 SignatureProvided；脱敏后再记录，避免 STS 临时凭证进审计元数据与日志。
             return Err(MattingError::upstream_http_error(
                 format!(
-                    "上传 VIAPI 临时桶失败（HTTP {}）：{}",
+                    "上传 AuthorizeFileUpload 临时对象失败（HTTP {}）：{}",
                     status.as_u16(),
-                    sanitize_oss_upload_error_body(&body, &sts.security_token)
+                    sanitize_policy_upload_error_body(&body, &authorized)
                 ),
                 status.as_u16(),
             ));
         }
 
-        Ok(target_url)
+        Ok(format!(
+            "https://{upload_host}/{}",
+            encode_oss_object_key(&authorized.object_key)
+        ))
     }
 
-    async fn get_oss_sts_token(&self) -> Result<ViapiStsToken, MattingError> {
-        let mut form = BTreeMap::new();
-        form.insert("Action".to_string(), GET_OSS_STS_TOKEN_ACTION.to_string());
-        form.insert("Format".to_string(), "json".to_string());
-        form.insert("Version".to_string(), VIAPI_UTILS_VERSION.to_string());
-        let payload = build_aliyun_form_body(&form);
-        let headers = self.build_acs3_headers(
-            VIAPI_UTILS_ENDPOINT,
-            GET_OSS_STS_TOKEN_ACTION,
-            VIAPI_UTILS_VERSION,
-            &payload,
+    async fn authorize_file_upload(&self) -> Result<AuthorizedFileUpload, MattingError> {
+        let canonical_query = format!("Product={IMAGESEG_PRODUCT}");
+        let headers = self.build_acs3_headers_for_request(
+            OPEN_PLATFORM_ENDPOINT,
+            AUTHORIZE_FILE_UPLOAD_ACTION,
+            AUTHORIZE_FILE_UPLOAD_VERSION,
+            "GET",
+            &canonical_query,
+            "",
         )?;
 
         let response = self
             .client
-            .post(format!("https://{VIAPI_UTILS_ENDPOINT}/"))
+            .get(format!(
+                "https://{OPEN_PLATFORM_ENDPOINT}/?{canonical_query}"
+            ))
             .headers(headers)
-            .header(
-                reqwest::header::CONTENT_TYPE,
-                "application/x-www-form-urlencoded",
-            )
-            .body(payload)
             .send()
             .await
             .map_err(|error| {
                 MattingError::upstream_transport_error(
-                    format!("GetOssStsToken 请求失败：{error}"),
+                    format!("AuthorizeFileUpload 请求失败：{error}"),
                     error.is_timeout(),
                 )
             })?;
         let http_status = response.status();
         let body_text = response.text().await.map_err(|error| {
             MattingError::upstream_transport_error(
-                format!("GetOssStsToken 响应读取失败：{error}"),
+                format!("AuthorizeFileUpload 响应读取失败：{error}"),
                 error.is_timeout(),
             )
         })?;
-        let body: serde_json::Value = serde_json::from_str(&body_text).map_err(|error| {
-            MattingError::upstream_response_error(
-                format!(
-                    "GetOssStsToken 响应不是合法 JSON：{error}；原始响应：{}",
-                    truncate_for_log(&body_text)
-                ),
-                Some(http_status.as_u16()),
-            )
-        })?;
-        if http_status != StatusCode::OK {
-            return Err(MattingError::upstream_http_error(
-                format!(
-                    "GetOssStsToken 返回失败（HTTP {}，Code={}）：{}",
-                    http_status.as_u16(),
-                    body.get("Code")
-                        .and_then(|value| value.as_str())
-                        .unwrap_or("unknown"),
-                    body.get("Message")
-                        .and_then(|value| value.as_str())
-                        .unwrap_or("unknown")
-                ),
-                http_status.as_u16(),
-            ));
-        }
-        let data = body.get("Data").ok_or_else(|| {
-            MattingError::upstream_response_error(
-                format!(
-                    "GetOssStsToken 响应缺少 Data；原始响应：{}",
-                    truncate_for_log(&body_text)
-                ),
-                Some(http_status.as_u16()),
-            )
-        })?;
-        let read_field = |name: &str| -> Result<String, MattingError> {
-            data.get(name)
-                .and_then(|value| value.as_str())
-                .map(|value| value.to_string())
-                .ok_or_else(|| {
-                    MattingError::upstream_response_error(
-                        format!("GetOssStsToken 响应缺少 Data.{name}"),
-                        Some(http_status.as_u16()),
-                    )
-                })
-        };
-        Ok(ViapiStsToken {
-            access_key_id: read_field("AccessKeyId")?,
-            access_key_secret: read_field("AccessKeySecret")?,
-            security_token: read_field("SecurityToken")?,
-        })
+        parse_authorized_file_upload_response(&body_text, http_status)
     }
 
     fn build_signature_headers(
@@ -673,6 +731,18 @@ impl MattingClient {
         action: &str,
         version: &str,
         payload: &str,
+    ) -> Result<reqwest::header::HeaderMap, MattingError> {
+        self.build_acs3_headers_for_request(endpoint, action, version, "POST", "", payload)
+    }
+
+    fn build_acs3_headers_for_request(
+        &self,
+        endpoint: &str,
+        action: &str,
+        version: &str,
+        method: &str,
+        canonical_query: &str,
+        payload: &str,
     ) -> Result<reqwest::header::HeaderMap, MattingError> {
         let date = current_aliyun_timestamp();
         let nonce = uuid::Uuid::new_v4().simple().to_string();
@@ -684,8 +754,7 @@ impl MattingClient {
         let signed_headers =
             "host;x-acs-action;x-acs-content-sha256;x-acs-date;x-acs-signature-nonce;x-acs-version";
         let canonical_request = format!(
-            "POST\n/\n\n{}\n{}\n{}",
-            canonical_headers, signed_headers, payload_hash
+            "{method}\n/\n{canonical_query}\n{canonical_headers}\n{signed_headers}\n{payload_hash}"
         );
         let string_to_sign = format!(
             "ACS3-HMAC-SHA256\n{}",
@@ -719,6 +788,33 @@ fn normalize_matting_input_png(
     normalize_matting_input_png_within(source, MAX_INPUT_BYTES)
 }
 
+fn validate_source_dimensions(source_dims: (u32, u32)) -> Result<(), MattingError> {
+    if source_dims.0 <= MIN_INPUT_EDGE || source_dims.1 <= MIN_INPUT_EDGE {
+        return Err(MattingError::InvalidRequest(format!(
+            "待抠图图片尺寸 {}x{} 过小，阿里云通用抠图要求每条边大于 {MIN_INPUT_EDGE} 像素",
+            source_dims.0, source_dims.1
+        )));
+    }
+    Ok(())
+}
+
+fn compose_source_with_result_alpha(
+    mut source_rgba: image::RgbaImage,
+    result_image: image::RgbaImage,
+) -> Result<Vec<u8>, MattingError> {
+    let (source_width, source_height) = source_rgba.dimensions();
+    let alpha_mask = image::DynamicImage::ImageRgba8(result_image).resize_exact(
+        source_width,
+        source_height,
+        image::imageops::FilterType::Triangle,
+    );
+    let alpha_mask = alpha_mask.to_rgba8();
+    for (target, mask) in source_rgba.pixels_mut().zip(alpha_mask.pixels()) {
+        target.0[3] = target.0[3].min(mask.0[3]);
+    }
+    encode_rgba_png(&source_rgba)
+}
+
 /// `normalize_matting_input_png` 的可注入体积上限版本，便于单测用小阈值触发降尺寸循环。
 fn normalize_matting_input_png_within(
     source: &image::DynamicImage,
@@ -773,6 +869,13 @@ fn result_response_too_large_error() -> MattingError {
     )
 }
 
+fn source_response_too_large_error() -> MattingError {
+    MattingError::upstream_response_error(
+        format!("待抠图源图响应过大，超过 {MAX_RESULT_RESPONSE_BYTES} 字节上限"),
+        None,
+    )
+}
+
 /// 解码待抠图源图时套上尺寸 / 分配上限。源图直接来自请求体 / 生成产物，缺省
 /// `image::Limits` 无尺寸上限、仅 512MiB alloc 兜底，12MB 请求体即可构造巨幅压缩图
 /// （解压炸弹）在缩图前撑爆内存；逐帧动画并发调用时风险叠加。
@@ -804,18 +907,75 @@ fn decode_image_within_limits(bytes: &[u8]) -> Result<image::DynamicImage, Strin
     reader.decode().map_err(|error| error.to_string())
 }
 
-struct ViapiStsToken {
+#[derive(Debug)]
+struct AuthorizedFileUpload {
+    bucket: String,
+    endpoint: String,
     access_key_id: String,
-    access_key_secret: String,
-    security_token: String,
+    encoded_policy: String,
+    signature: String,
+    object_key: String,
 }
 
-fn hmac_sha1_base64(key: &[u8], content: &[u8]) -> Result<String, MattingError> {
-    use base64::Engine as _;
-    let mut signer = Hmac::<sha1::Sha1>::new_from_slice(key)
-        .map_err(|error| MattingError::Sign(format!("初始化 OSS V1 签名器失败：{error}")))?;
-    signer.update(content);
-    Ok(base64::engine::general_purpose::STANDARD.encode(signer.finalize().into_bytes()))
+fn parse_authorized_file_upload_response(
+    body_text: &str,
+    http_status: StatusCode,
+) -> Result<AuthorizedFileUpload, MattingError> {
+    // 成功响应包含 Policy 与 Signature；解析错误中不能回显原始正文。
+    let body: serde_json::Value = serde_json::from_str(body_text).map_err(|error| {
+        MattingError::upstream_response_error(
+            format!("AuthorizeFileUpload 响应不是合法 JSON：{error}"),
+            Some(http_status.as_u16()),
+        )
+    })?;
+    if http_status != StatusCode::OK {
+        return Err(MattingError::upstream_http_error(
+            format!(
+                "AuthorizeFileUpload 返回失败（HTTP {}，Code={}）：{}",
+                http_status.as_u16(),
+                body.get("Code")
+                    .and_then(|value| value.as_str())
+                    .unwrap_or("unknown"),
+                body.get("Message")
+                    .and_then(|value| value.as_str())
+                    .unwrap_or("unknown")
+            ),
+            http_status.as_u16(),
+        ));
+    }
+    let read_field = |name: &str| -> Result<String, MattingError> {
+        body.get(name)
+            .and_then(|value| value.as_str())
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(str::to_string)
+            .ok_or_else(|| {
+                MattingError::upstream_response_error(
+                    format!("AuthorizeFileUpload 响应缺少 {name}"),
+                    Some(http_status.as_u16()),
+                )
+            })
+    };
+    let bucket = read_field("Bucket")?.trim_matches('/').to_string();
+    let endpoint = read_field("Endpoint")?
+        .trim_start_matches("https://")
+        .trim_start_matches("http://")
+        .trim_matches('/')
+        .to_string();
+    if bucket.is_empty() || endpoint.is_empty() {
+        return Err(MattingError::upstream_response_error(
+            "AuthorizeFileUpload 响应中的 Bucket/Endpoint 不合法".to_string(),
+            Some(http_status.as_u16()),
+        ));
+    }
+    Ok(AuthorizedFileUpload {
+        bucket,
+        endpoint,
+        access_key_id: read_field("AccessKeyId")?,
+        encoded_policy: read_field("EncodedPolicy")?,
+        signature: read_field("Signature")?,
+        object_key: read_field("ObjectKey")?,
+    })
 }
 
 fn describe_result_download_transport_error(error: &reqwest::Error) -> String {
@@ -860,21 +1020,38 @@ fn sanitize_result_download_error_message(message: String) -> String {
     message
 }
 
-/// 脱敏 OSS 上传错误体：OSS 签名类错误会回显 StringToSign（含 `x-oss-security-token` 明文）、
-/// StringToSignBytes（其十六进制）和 SignatureProvided（签名串）。剥掉这三个元素，并把已知的
-/// STS 临时凭证在正文任何位置的出现替换为 `***`，保留 `<Code>` 等可诊断信息后再记录。
-fn sanitize_oss_upload_error_body(body: &str, security_token: &str) -> String {
+/// 脱敏 Policy POST 上传错误体：OSS 签名类错误可能回显 StringToSign、Policy 或签名串。
+/// 剥掉已知签名元素，并替换本次授权材料，保留 `<Code>` 等可诊断信息。
+fn sanitize_policy_upload_error_body(body: &str, authorized: &AuthorizedFileUpload) -> String {
     let mut sanitized = body.to_string();
-    for tag in ["StringToSign", "StringToSignBytes", "SignatureProvided"] {
+    for tag in [
+        "StringToSign",
+        "StringToSignBytes",
+        "SignatureProvided",
+        "Policy",
+    ] {
         sanitized = redact_xml_element(&sanitized, tag);
     }
-    let security_token = security_token.trim();
-    if !security_token.is_empty() {
-        sanitized = sanitized.replace(security_token, "***");
+    for secret in [
+        authorized.access_key_id.as_str(),
+        authorized.encoded_policy.as_str(),
+        authorized.signature.as_str(),
+    ] {
+        if !secret.is_empty() {
+            sanitized = sanitized.replace(secret, "***");
+        }
     }
     truncate_for_log(&sanitized)
 }
 
+fn encode_oss_object_key(object_key: &str) -> String {
+    object_key
+        .split('/')
+        .map(|segment| urlencoding_encode(segment).replace('+', "%20"))
+        .collect::<Vec<_>>()
+        .join("/")
+}
+
 /// 把 `<tag>…</tag>` 的内容替换成 `[redacted]`（tag 内容可跨行）；只有开标签无闭标签时丢弃其后全部内容。
 fn redact_xml_element(text: &str, tag: &str) -> String {
     let open = format!("<{tag}>");
@@ -989,6 +1166,18 @@ mod tests {
         }
     }
 
+    #[test]
+    fn local_processing_after_external_call_is_auditable_with_stage() {
+        let error = MattingError::InvalidRequest("解析待抠图图片失败：invalid png".to_string())
+            .with_failure_stage("source_decode");
+
+        assert!(error.external_call_attempted());
+        assert_eq!(error.failure_stage(), "source_decode");
+        assert!(!error.is_timeout());
+        assert!(!error.is_transport());
+        assert_eq!(error.upstream_status(), None);
+    }
+
     #[test]
     fn upstream_transport_error_classifies_as_transport() {
         let error = MattingError::upstream_transport_error(
@@ -1081,6 +1270,86 @@ mod tests {
         assert!(!date.contains('.'), "x-acs-date 不能带小数秒：{date}");
     }
 
+    #[test]
+    fn authorize_file_upload_response_parses_policy_fields() {
+        let response = r#"{
+            "RequestId":"request-id",
+            "Bucket":"viapi-customer-pop",
+            "Endpoint":"oss-cn-shanghai.aliyuncs.com",
+            "AccessKeyId":"temporary-key-id",
+            "EncodedPolicy":"encoded-policy",
+            "Signature":"policy-signature",
+            "ObjectKey":"imageseg/2026/07/input image.png"
+        }"#;
+
+        let authorized = parse_authorized_file_upload_response(response, StatusCode::OK)
+            .expect("AuthorizeFileUpload response should parse");
+
+        assert_eq!(authorized.bucket, "viapi-customer-pop");
+        assert_eq!(authorized.endpoint, "oss-cn-shanghai.aliyuncs.com");
+        assert_eq!(authorized.access_key_id, "temporary-key-id");
+        assert_eq!(authorized.encoded_policy, "encoded-policy");
+        assert_eq!(authorized.signature, "policy-signature");
+        assert_eq!(authorized.object_key, "imageseg/2026/07/input image.png");
+        assert_eq!(
+            encode_oss_object_key(&authorized.object_key),
+            "imageseg/2026/07/input%20image.png"
+        );
+    }
+
+    #[test]
+    fn authorize_file_upload_response_does_not_echo_sensitive_body_on_parse_error() {
+        let sensitive_body = "not-json encoded-policy policy-signature temporary-key-id";
+
+        let error = parse_authorized_file_upload_response(sensitive_body, StatusCode::OK)
+            .expect_err("invalid response should fail");
+
+        assert!(error.message().contains("响应不是合法 JSON"));
+        assert!(!error.message().contains("encoded-policy"));
+        assert!(!error.message().contains("policy-signature"));
+        assert!(!error.message().contains("temporary-key-id"));
+    }
+
+    #[test]
+    fn authorize_file_upload_headers_sign_get_query() {
+        let config = MattingConfig::new(
+            DEFAULT_IMAGESEG_ENDPOINT.to_string(),
+            "test-key-id".to_string(),
+            "test-key-secret".to_string(),
+        )
+        .expect("config should build");
+        let client = MattingClient::new(config).expect("client should build");
+        let headers = client
+            .build_acs3_headers_for_request(
+                OPEN_PLATFORM_ENDPOINT,
+                AUTHORIZE_FILE_UPLOAD_ACTION,
+                AUTHORIZE_FILE_UPLOAD_VERSION,
+                "GET",
+                "Product=imageseg",
+                "",
+            )
+            .expect("headers should build");
+
+        assert_eq!(
+            headers
+                .get("x-acs-action")
+                .and_then(|value| value.to_str().ok()),
+            Some(AUTHORIZE_FILE_UPLOAD_ACTION)
+        );
+        assert_eq!(
+            headers
+                .get("x-acs-version")
+                .and_then(|value| value.to_str().ok()),
+            Some(AUTHORIZE_FILE_UPLOAD_VERSION)
+        );
+        assert_eq!(
+            headers
+                .get("x-acs-content-sha256")
+                .and_then(|value| value.to_str().ok()),
+            Some(sha256_hex(b"").as_str())
+        );
+    }
+
     #[test]
     fn result_download_error_message_redacts_signed_oss_url() {
         let message = sanitize_result_download_error_message(
@@ -1106,36 +1375,38 @@ mod tests {
     }
 
     #[test]
-    fn oss_upload_error_body_redacts_signature_material_and_token() {
-        let token = "CAISabcSECRETtoken123";
+    fn policy_upload_error_body_redacts_authorization_material() {
+        let authorized = AuthorizedFileUpload {
+            bucket: "viapi-customer-pop".to_string(),
+            endpoint: "oss-cn-shanghai.aliyuncs.com".to_string(),
+            access_key_id: "temporary-key-id".to_string(),
+            encoded_policy: "encoded-policy".to_string(),
+            signature: "policy-signature".to_string(),
+            object_key: "imageseg/input.png".to_string(),
+        };
         let body = format!(
             "<Error><Code>SignatureDoesNotMatch</Code>\
-             <Message>mismatch for {token}</Message>\
-             <SignatureProvided>sigSECRET==</SignatureProvided>\
+             <Message>mismatch for {} and {}</Message>\
+             <Policy>{}</Policy>\
+             <SignatureProvided>{}</SignatureProvided>\
              <StringToSignBytes>50 55 54 0a</StringToSignBytes>\
-             <StringToSign>PUT\nx-oss-security-token:{token}\n/bucket/key</StringToSign></Error>"
+             <StringToSign>POST\npolicy={}</StringToSign></Error>",
+            authorized.access_key_id,
+            authorized.signature,
+            authorized.encoded_policy,
+            authorized.signature,
+            authorized.encoded_policy
         );
 
-        let sanitized = sanitize_oss_upload_error_body(&body, token);
+        let sanitized = sanitize_policy_upload_error_body(&body, &authorized);
 
-        // 敏感串全部消失：StringToSign 明文、其中的 token、十六进制、签名串、以及 Message 里的 token 明文。
-        assert!(
-            !sanitized.contains(token),
-            "STS token 不能残留（含元素外的明文）"
-        );
-        assert!(
-            !sanitized.contains("x-oss-security-token:CAIS"),
-            "StringToSign 明文不能残留"
-        );
-        assert!(
-            !sanitized.contains("sigSECRET"),
-            "SignatureProvided 不能残留"
-        );
+        assert!(!sanitized.contains(&authorized.access_key_id));
+        assert!(!sanitized.contains(&authorized.encoded_policy));
+        assert!(!sanitized.contains(&authorized.signature));
         assert!(
             !sanitized.contains("50 55 54 0a"),
             "StringToSignBytes 不能残留"
         );
-        // 可诊断信息保留。
         assert!(
             sanitized.contains("SignatureDoesNotMatch"),
             "OSS Code 应保留供诊断"
@@ -1219,4 +1490,45 @@ mod tests {
             "降尺寸后仍是 PNG"
         );
     }
+
+    #[test]
+    fn url_input_upload_scope_ends_before_aliyun_inference() {
+        let source = include_str!("lib.rs");
+        let start = source
+            .find("pub async fn segment_image_url_to_transparent_png")
+            .expect("URL input method should exist");
+        let tail = &source[start..];
+        let end = tail
+            .find("async fn segment_uploaded_input_to_rgba")
+            .expect("uploaded input helper should follow URL method");
+        let body = &tail[..end];
+
+        let download = body
+            .find("let source_bytes = self\n                .download_source_image(source_url)")
+            .expect("source should download lazily");
+        let upload = body
+            .find(".upload_temp_image(upload_bytes, file_name, \"image/png\")")
+            .expect("source should upload to temporary OSS");
+        let scope_end = body
+            .find("let result_image = self")
+            .expect("Aliyun inference should start after upload scope");
+        assert!(download < upload && upload < scope_end);
+        assert!(body.contains("let (source_dims, upload_dims, image_url) = {"));
+        assert_eq!(body.matches("download_source_image(source_url)").count(), 2);
+    }
+
+    #[test]
+    fn compose_source_with_result_alpha_preserves_rgb() {
+        let source = image::RgbaImage::from_pixel(2, 2, image::Rgba([10, 20, 30, 180]));
+        let mask = image::RgbaImage::from_pixel(1, 1, image::Rgba([200, 210, 220, 90]));
+
+        let encoded = compose_source_with_result_alpha(source, mask)
+            .expect("alpha composition should encode");
+        let output = image::load_from_memory(&encoded)
+            .expect("output should decode")
+            .to_rgba8();
+
+        assert_eq!(output.dimensions(), (2, 2));
+        assert!(output.pixels().all(|pixel| pixel.0 == [10, 20, 30, 90]));
+    }
 }