From 67ba40c6787dc9950df5be0e999eb0f488ba7d21 Mon Sep 17 00:00:00 2001
From: kdletters <kdletters@qq.com>
Date: Wed, 3 Jun 2026 00:57:24 +0800
Subject: [PATCH] Refine play type integration flow and docs

---
 .hermes/shared-memory/decision-log.md         |   19 +-
 .hermes/shared-memory/pitfalls.md             |   30 +-
 ...„】server-rs与SpacetimeDBæ•°æ�®å¥‘约-2026-05-15.md |    4 +-
 ...�玩法创作】平�入�与玩法链路-2026-05-15.md |   17 +-
 ...�玩法创作】拼图生�页进度�径-2026-05-23.md |   17 +-
 ...�玩法创作】生�页圆环布局�径-2026-05-23.md |    4 +-
 .../shared/src/contracts/puzzleAgentDraft.ts  |    4 +-
 .../crates/api-server/src/password_entry.rs   |   18 +-
 .../api-server/src/password_management.rs     |   14 +-
 server-rs/crates/api-server/src/phone_auth.rs |   28 +-
 .../crates/api-server/src/puzzle/draft.rs     |    8 +-
 .../crates/api-server/src/puzzle/handlers.rs  |    4 +-
 .../crates/api-server/src/puzzle/tests.rs     |   22 +
 .../crates/api-server/src/refresh_session.rs  |   14 +-
 server-rs/crates/api-server/src/state.rs      |    6 +-
 .../crates/api-server/src/wechat_auth.rs      |   42 +-
 server-rs/crates/module-auth/src/lib.rs       |  117 +-
 .../spacetime-module/src/auth/procedures.rs   |   17 +-
 .../spacetime-module/src/custom_world.rs      |    1 +
 .../spacetime-module/src/wooden_fish.rs       |    1 +
 ...ustomWorldCreationHub.interaction.test.tsx |   89 +-
 .../CustomWorldCreationHub.tsx                |    7 +-
 .../custom-world-home/CustomWorldWorkCard.tsx |   71 +-
 .../creationWorkShelf.test.ts                 |   92 +-
 .../custom-world-home/creationWorkShelf.ts    |   59 +-
 .../PlatformEntryFlowShellImpl.tsx            | 1383 ++++++++++++++---
 ...gEntryFlowShell.agent.interaction.test.tsx |  399 ++++-
 src/components/rpg-entry/RpgEntryHomeView.tsx |    6 +-
 ...ch3DCreationWorkspace.interaction.test.tsx |    4 +-
 .../workspaces/Match3DCreationWorkspace.tsx   |    8 +-
 ...zzleCreationWorkspace.interaction.test.tsx |    9 +
 .../workspaces/PuzzleCreationWorkspace.tsx    |    3 +
 src/index.css                                 |   25 +
 .../miniGameDraftGenerationProgress.test.ts   |  124 +-
 .../miniGameDraftGenerationProgress.ts        |  179 +--
 35 files changed, 2226 insertions(+), 619 deletions(-)

diff --git a/.hermes/shared-memory/decision-log.md b/.hermes/shared-memory/decision-log.md
index 1299cdbe..80803c1e 100644
--- a/.hermes/shared-memory/decision-log.md
+++ b/.hermes/shared-memory/decision-log.md
@@ -23,6 +23,7 @@
 - 影�范围：`src/services/payment/paymentPlatform.ts`�`src/components/rpg-entry/RpgEntryHomeView.tsx`�`miniprogram/pages/wechat-pay/`�`server-rs/crates/api-server/src/runtime_profile.rs`�`server-rs/crates/shared-contracts/src/runtime.rs`�`packages/shared/src/contracts/runtime.ts`�微信登录�存储。
 - 验�方�：泥点和会员商�在�程��行�都请求 `wechat_mp_virtual`；�程�页能按 payload 调用 `wx.requestVirtualPayment` / `wx.requestPayment`；`cargo check -p api-server --manifest-path server-rs/Cargo.toml` 与支付相关�端测试通过。
 - 关�文档：`docs/�技术方案】微信虚拟支付接入-2026-05-26.md`。
+
 ## 2026-05-30 Linux 本地 dev 端�段按系统级注册表分�
 
 - 背景：�一� Linux 开�机上有多个用户�时跑 `npm run dev` 时，�纯��自 `GENARRATIVE_DEV_PORT_RANGE` 容易撞段，且�一用户并�起两个 dev 会�时也会把相�端�段��拿走。
@@ -104,6 +105,7 @@
 - 影�范围：`src/components/rpg-entry/RpgEntryHomeView.tsx`�`src/components/rpg-entry/RpgEntryHomeView.recharge.test.tsx`�`docs/�项目基线】当�产�与工程约�-2026-05-15.md`。
 - 验�方�：`npm run test -- src/components/rpg-entry/RpgEntryHomeView.recharge.test.tsx` 应断言任务�显示 `1 / 1`�领��显示已完�，且新用户账�也没有 `次级入�` / `填邀请�` 常驻按钮；`npm run typecheck`�`npm run check:encoding` 通过。
 - 关�文档：`docs/�项目基线】当�产�与工程约�-2026-05-15.md`。
+
 ## 2026-05-26 生�页总进度圆弧逆时针回调 5 度
 
 - 背景：创作生�页的总进度圆弧在 `160deg` �置�需轻微�左微调，用户�求�左逆时针回调 `5deg`。
@@ -213,11 +215,19 @@
 ## 2026-05-23 拼图生�页按�端真实进度推进阶段
 
 - 背景：拼图生�页原先会按本地耗时自动推进步骤，容易在�端真实生�尚未完�时跳到�续阶段，导致页�状�和会�进度脱节。
-- 决策：拼图生�页的跨步骤推进�认�端会� `progressPercent` 的真实里程碑，当�步骤内部�用本地耗时�进度平滑展示；总进度�始必须为 `0%`，之�按 `0-88`�`88-94`�`94-96`�`96-98` 的真实里程碑区间平滑推进。��当�步骤生�内容未完�，就必须�留在当�步骤。页��展示当�步骤标题和进度，�展示步骤详细�述。`生�拼图首图` �独按 4 分钟估算，完整 AI �绘路径约 448 秒；上传图且关闭 AI �绘路径跳过首图生�，�约 208 秒。
+- 决策：拼图生�页的跨步骤推进�认�端会� `progressPercent` 的真实里程碑，当�步骤内部�用本地耗时�进度平滑展示；`88/94/96` �切�当�步骤，�直接作为总进度地�。总进度按已完�步骤��加当�步骤内�进度推导，�完��最多�在 `98%`。���久化生�中�稿时，展示� `startedAtMs` 使用�端 session `updatedAt` 或作�摘� `updatedAt`，��已耗时�因�新进入页�清零。��当�步骤生�内容未完�，就必须�留在当�步骤。页��展示当�步骤标题和进度，�展示步骤详细�述。`生�拼图首图` �独按 4 分钟估算，完整 AI �绘路径约 448 秒；上传图且关闭 AI �绘路径跳过首图生�，�约 208 秒。
 - 影�范围：`src/services/miniGameDraftGenerationProgress.ts`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/CustomWorldGenerationView.tsx`�拼图生�页相关测试与玩法链路文档。
 - 验�方�：拼图生�页���轮询和测试都应以 `puzzleProgressPercent` 驱动阶段推进；`npm run test -- src/services/miniGameDraftGenerationProgress.test.ts src/components/CustomWorldGenerationView.test.tsx`�`npm run typecheck`�`npm run check:encoding` 通过。
 - 关�文档：`docs/�玩法创作】拼图生�页进度�径-2026-05-23.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
+## 2026-06-02 生�失败�稿必须留在作�架并覆盖生�中摘�
+
+- 背景：生�页收到失败回包�会进入�试�，但返回�稿 Tab 时，�端作�摘��能�短暂�� `generationStatus=generating`，导致用户看到“生�中�；连续触�多个拼图生�时，失败�如果清掉 pending �目，还会少显示新增�稿。��失败如果�写局部生�页错误，用户离开生�页�也收�到通知。
+- 决策：平�壳在生�失败时必须�时标记�稿 notice 和 pending 作�架�目为 `failed`，�得删除 pending �目。失败 notice ��存错误消�并在用户离开生�页�触�带��的 `PlatformErrorDialog`；作�架本地失败 notice �覆盖�久化生�中摘�，失败�稿�显示为�稿�但�显示“生�中�。点击失败�稿必须优先��失败 / �试页，�能按�久化 `generating` �新�动生�；拼图契约已�许 `generationStatus=failed`，pending 拼图和�端失败回写都按 session 独立�失败�，跳一跳 / 木鱼 / 抓大鹅等也直接映射为 `failed` 或对应失败�。
+- 影�范围：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/custom-world-home/creationWorkShelf.ts`�`src/components/custom-world-home/CustomWorldCreationHub.tsx`�玩法链路文档和失败�交互测试。
+- 验�方�：`node node_modules/vitest/vitest.mjs run src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "failed parallel puzzle|background match3d"`；失败�返回�稿 Tab 应看到对应新增�稿，且没有“生�中�标记；��失败应弹出错误��，点击失败�稿应进入失败 / �试页。
+- 关�文档：`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`�`.hermes/shared-memory/pitfalls.md`。
+
 ## 2026-05-23 所有玩法生�页统一圆环主视觉
 
 - 背景：多个玩法生�页分别展示横�总进度��步骤列表或三槽�列表，和最新�考图里的陶泥儿圆环等待��一致，也让移动端信�密度�高。
@@ -333,7 +343,6 @@
 - 验�方�：执行 `cargo test -p api-server match3d --manifest-path server-rs\Cargo.toml`�`npm run test -- src/components/match3d-result/Match3DResultView.test.tsx src/components/match3d-runtime/Match3DRuntimeShell.test.tsx src/services/match3dSpritesheetParser.test.ts src/services/match3dGeneratedModelCache.test.ts`�`npm run typecheck`�`npm run check:encoding`。
 - 关�文档：`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-
 ## 2026-05-18 Rust 手写模�入�统一�用 mod.rs
 
 - 背景：Rust 目录模��时存在 `mod.rs` 与�� `.rs` 两�入�形�，�次拆分已让 `spacetime-client/src/mapper.rs` 采用��入�；继续新增 `mod.rs` 会让文件定�和评审�径�一致。
@@ -572,7 +581,7 @@
 - 验�方�：�稿页作��与分类页列表视觉�径��一致；`npm run test -- src/components/custom-world-home/CustomWorldCreationHub.test.tsx src/components/custom-world-home/CustomWorldCreationHub.interaction.test.tsx`�`npm run typecheck`�`npm run check:encoding`。
 - 关�文档：`docs/design/MOBILE_CREATION_WORK_LIST_TWO_COLUMN_LAYOUT_2026-04-29.md`�`docs/experience/MOBILE_UI_DEV_EXPERIENCE.md`。
 
-2026-05-14 补充：�稿页作����用“�稿 / 已�布�文字标识状�，改为图标化 UI 状�点；作���直接铺到�片��区并从��左��；已�布作��上角常驻分享图标；�稿长按弹出删除��，已�布长按弹出分享和删除��。
+2026-05-14 补充：�稿页作����用“�稿 / 已�布�文字标识状�，改为图标化 UI 状�点；作���直接铺到�片��区并从��左��；已�布作��上角常驻分享图标；�稿长按弹出删除��，已�布长按弹出分享和删除��。2026-06-02 追加：作��片�上角��放删除按钮；删除�通过左滑�键盘展开或长按 / �键展开的�侧�作区出现，��与�片主点击和分享入�抢�标题区。
 
 ## 2026-05-13 认��行期�步直接导入正�认�表
 
@@ -759,6 +768,7 @@
 - 验�方�：执行 `npx vitest run src/services/useMocapInput.test.ts src/components/child-motion-demo/ChildMotionWarmupDemo.test.tsx src/components/child-motion-demo/childMotionWarmupModel.test.ts src/services/child-motion-demo/childMotionDebugInput.test.ts src/routing/appRoutes.test.ts`�`npx eslint ...`�`npm run typecheck`�`npm run check:encoding`，并确认 `http://127.0.0.1:8876/stream` WebSocket ��手�`http://127.0.0.1:3000/child-motion-demo` �访问。
 
 ## 2026-05-18 寓教于�频�补充热身关入�
+
 - 背景：用户希望在�现页的寓教于���里直接看到热身关入�，而�是��赖独立直达路由。
 - 决策：`child-motion-demo` 作为寓教于�频�的独立�片展示，点击�直接进入 `/child-motion-demo`；该入�与 `��爱画` 并列，��用现有独立热身关路由，�新增新的创作模�或�行�壳层。
 - 影�范围：`src/components/rpg-entry/RpgEntryHomeView.tsx`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryHomeView.recharge.test.tsx`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
@@ -1171,13 +1181,14 @@
 - 影�范围：`module-auth`�`api-server` 作�作者解��`AppState` �动�始化�历�孤儿作�离线回填脚本与相关文档。
 - 验�方�：`cargo test -p module-auth --manifest-path server-rs/Cargo.toml`�`cargo test -p api-server --manifest-path server-rs/Cargo.toml work_author`�`npm run test -- scripts/rebind-orphan-work-owners.test.ts`。
 - 关�文档：`server-rs/crates/module-auth/src/domain.rs`�`server-rs/crates/module-auth/src/lib.rs`�`server-rs/crates/api-server/src/work_author.rs`�`scripts/rebind-orphan-work-owners.mjs`。
+
 ## 2026-05-26 敲木鱼�布�作�架与推��刷新�径
 
 - 背景：敲木鱼已具备公开广场投影，但�稿 Tab 的作�架没有当�用户作�列表接�，导致已�布作�在�布��能立�出现在“已�布�筛选和推��里。
 - 决策：新增 `GET /api/creation/wooden-fish/works` 作为当�用户木鱼作�架事实�，返回 `WoodenFishWorksResponse.items` 摘�；平�壳在�布�功�必须�时刷新作�架和公开广场列表。
 - 影�范围：`server-rs/crates/api-server/src/wooden_fish.rs`�`server-rs/crates/api-server/src/modules/wooden_fish.rs`�`src/services/wooden-fish/woodenFishClient.ts`�`src/components/custom-world-home/creationWorkShelf.ts`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`。
 - 验�方�：�布一个木鱼作��，�稿 Tab 的已�布筛选应立刻出现 `WF-*` 作��，推� / 最新�也应立�刷新出公开�片。
- - 关�文档：`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`�`docs/prd/�玩法创作】敲木鱼玩法模�PRD-2026-05-20.md`。
+- 关�文档：`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`�`docs/prd/�玩法创作】敲木鱼玩法模�PRD-2026-05-20.md`。
 
 ## 2026-05-27 认�快照完全去文件化并仅�留行级备查
 
diff --git a/.hermes/shared-memory/pitfalls.md b/.hermes/shared-memory/pitfalls.md
index 99c0eb8c..b92baeef 100644
--- a/.hermes/shared-memory/pitfalls.md
+++ b/.hermes/shared-memory/pitfalls.md
@@ -158,7 +158,6 @@
 - 验�：`PlatformEntryFlowShellImpl.tsx` 中�应�出现四个旧工作�的入�渲染分支，创作 Tab 与 `/creation/<play>` �能正常进入对应工作�。
 - 关�：`src/components/unified-creation/UnifiedCreationWorkspace.tsx`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-
 ## Jenkinsfile 开头�能带 UTF-8 BOM
 
 - 现象：`Genarrative-Stdb-Module-Publish` 在 `Pipeline script from SCM` 读� `jenkins/Jenkinsfile.production-stdb-module-publish` �，�水线还未进入任何 stage 就失败，报 `java.lang.NoSuchMethodError: No such DSL method 'pipeline'`，堆栈�置是 `WorkflowScript.run(WorkflowScript:1)`。
@@ -362,7 +361,6 @@
 - 验�：`tr '\0' '\n' < /proc/$(systemctl show genarrative-api.service -p MainPID --value)/environ | grep GENARRATIVE_TRACKING_OUTBOX_DIR` 应指� `/var/lib/genarrative/tracking-outbox`；���当� PID ��出现 `Permission denied (os error 13)`。
 - 关�：`scripts/deploy/production-api-deploy.sh`�`scripts/jenkins-server-provision.sh`�`docs/�开��维】本地开�验�与生产�维-2026-05-15.md`。
 
-
 ## 外部 API 失败没法追溯先查 external_api_call_failure
 
 - 现象：VectorEngine 图片生� / 编辑接�对�端�表现为 `502` / `504` 或“上游�务请求失败�，但难以区分是请求��失败�上游 429/5xx��应解�失败�未返回图片，还是下载图片失败。
@@ -562,10 +560,18 @@
 
 - 现象：用户通过“忘记密���设密��，接�返回�功或页�进入登录�，但�次使用新密�登录��示“手机�或密�错误�；���还�能出现 `Bearer JWT 版本已失效`，日志里的 token version 与本地快照�一致。
 - 原因：�置/修改密�会更新 `password_hash`�`password_login_enabled` 和 `token_version`，如果 API 层�更新本地 `InMemoryAuthStore`，没有调用 `sync_auth_store_snapshot_to_spacetime()`，`api-server` ��时�能从旧的 SpacetimeDB 表或旧快照��账�状�。
-- 处�：`POST /api/auth/password/change` 与 `POST /api/auth/password/reset` �功�必须�步认�快照。2026-05-27 起，�动����许从 SpacetimeDB 正�认�表��；`auth_store_snapshot` ��留行级记录，��写 `default` ���行，也��把本地文件 `auth-store.json` / `GENARRATIVE_AUTH_STORE_PATH` 当作���。若�动时连�上 SpacetimeDB，`api-server` 等待�动��超时�进入�赖��用模�，所有请求返回 `503 SERVICE_UNAVAILABLE`，`details.reason = "spacetime_startup_unavailable"`。
+- 处�：`POST /api/auth/password/change` 与 `POST /api/auth/password/reset` �功�必须�步认�快照。2026-05-27 起，�动����许从 SpacetimeDB 正�认�表��；`auth_store_snapshot` ��留行级记录，��写 `default` ���行，也��把本地文件 `auth-store.json` / `GENARRATIVE_AUTH_STORE_PATH` 当作���。认�创建�登录会��刷新�退出�改密��置密��绑定和资料�更等写�作必须在返回客户端��功�步 SpacetimeDB；�步失败时接�返回错误，��许把�存在于当�进程内存的账�或会�当��功结果。新用户注册奖励�邀请�绑定和登录埋点必须排在认��步�功之�，��认�没�库时先写出钱包或邀请关系。若�动时连�上 SpacetimeDB，`api-server` 等待�动��超时�进入�赖��用模�，所有请求返回 `503 SERVICE_UNAVAILABLE`，`details.reason = "spacetime_startup_unavailable"`。
 - 验�：执行 `cargo test -p module-auth password --manifest-path server-rs/Cargo.toml` 与 `cargo test -p api-server password --manifest-path server-rs/Cargo.toml`；手测时�设密��旧密�应失败，新密�应�功，����应��。
 - 关�：`server-rs/crates/api-server/src/password_management.rs`�`server-rs/crates/api-server/src/state.rs`�`docs/technical/PASSWORD_LOGIN_CHANGE_RESET_DESIGN_2026-04-24.md`。
 
+## 密�登录失败且短信登录�示手机�已存在先查孤儿手机�索引
+
+- 现象：�账�用密�登录�示“手机�或密�错误�，改用短信验��登录��示“手机�已存在 / 已注册�，用户�在既�能登录也�能�新创建的状�。
+- 原因：历�版本或��务时认��步�完整，�能在 SpacetimeDB `auth_identity(provider=phone)` 或 `module-auth` 快照里留下 `phone_to_user_id` 映射，但对应 `user_account` / `users_by_username` 用户行已��存在。密�登录按手机�索引找�到真实用户，短信登录�试创建新用户时�被孤儿手机�索引挡�。
+- 处�：`export_auth_store_snapshot_from_tables` 导出时必须过滤没有 `user_account` 的 phone / wechat identity�union 索引和 refresh session；`module-auth` 从 JSON 快照��时也必须二次丢弃指��存在用户的索引。�行时创建手机�用户�若�现手机�映射指��存在的用户，应删除孤儿映射�继续创建，��死��继续扩散。
+- 验�：`cargo test -p module-auth snapshot_json_drops_orphan_phone_index_before_phone_login --manifest-path server-rs/Cargo.toml`�`cargo test -p module-auth phone --manifest-path server-rs/Cargo.toml`�`cargo test -p spacetime-module auth --manifest-path server-rs/Cargo.toml`�`cargo test -p api-server phone_login_reuses_existing_user_for_same_phone_number --manifest-path server-rs/Cargo.toml`。
+- 关�：`server-rs/crates/module-auth/src/lib.rs`�`server-rs/crates/spacetime-module/src/auth/procedures.rs`�`docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md`。
+
 ## 认�本地文件快照已废弃，旧 procedure 也已删
 
 - 现象：有些旧代�和生� bindings 里还会残留 `get_auth_store_snapshot`�`upsert_auth_store_snapshot`�`import_auth_store_snapshot`，或者把 `auth-store.json` 误当�认����。
@@ -1542,14 +1548,22 @@
 - 验�：`npm run test -- src/components/rpg-entry/rpgEntryWorldPresentation.test.ts src/components/rpg-entry/RpgEntryHomeView.recharge.test.tsx`�`npm run typecheck`�`npm run check:encoding`。
 - 关�：`src/index.css`�`src/components/rpg-entry/RpgEntryHomeView.tsx`�`src/components/rpg-entry/rpgEntryWorldPresentation.ts`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-## 生�中�稿刷新����用旧 updatedAt 当展示起点
+## 生�中�稿���按�端时间戳计时
 
-- 现象：拼图或抓大鹅�稿生�中刷新网页�，作�架�片能显示等待�罩，但进入生�页时总进度首帧直接跳到 80%+，看起��已�跑了一大�。
-- 原因：�端�把�久化 `generationStatus=generating` 当作��生�页的�件，但��展示时�沿用了作�摘� `updatedAt` 作为伪 `startedAtMs`；�时拼图总进度�把�端 `progressPercent` 直接当作 floor，导致 `86%` 之类未到首个里程碑的会�一进页就抬到 80%+。
-- 处�：��生�中的�稿时，展示起点改用“进入生�页的当�时间�；`updatedAt` ��留给作�架排�和摘�，���与生�页�进度起算。拼图总进度还�忽略 `88` 以下的�端进度 floor，拼图�留�端里程碑推进，抓大鹅等�拼图玩法则从 `0%` 平滑起步，��刚进页就看到 4% / 88% / 80%+。
-- 验�：`npm test -- src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "persisted generating"`�`npm run test -- src/services/miniGameDraftGenerationProgress.test.ts -t "match3d draft generation starts total progress from zero"`。
+- 现象：拼图或抓大鹅�稿生�中刷新网页�，进入生�页的“已耗时�从 `0 秒` �新开始；�一类旧问题是�端 `progressPercent=88` 时总进度首帧直接跳到 `88%`。
+- 原因：生�页��曾把展示� `startedAtMs` �置为进入页�的当�时间，导致计时�跟��端真实生�时刻；拼图总进度也曾把�端里程碑当作百分比地�，导致步骤刚切�就抬高总进度。
+- 处�：��生�中的�稿时，展示起点使用�端 session `updatedAt` 或作�摘� `updatedAt`；`88/94/96` �切�当�步骤，�直接作为总进度地�。总进度按已完�步骤��加当�步骤内�进度推导，�完��最多�在 `98%`。
+- 验�：`node node_modules/vitest/vitest.mjs run src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "persisted generating"`�`node node_modules/vitest/vitest.mjs run src/services/miniGameDraftGenerationProgress.test.ts`。
 - 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx`�`src/services/miniGameDraftGenerationProgress.ts`�`docs/�玩法创作】拼图生�页进度�径-2026-05-23.md`。
 
+## 生�失败�稿回到作�架�能继续显示生�中
+
+- 现象：拼图生�页已�收到 VectorEngine 图片编辑失败并进入�试�，但用户返回�稿 Tab �，�一�稿�显示“生�中�；连续触�多个拼图生�时，失败�还�能�剩一�新增�稿，或者�看到标题为“第1关�的���空壳；抓大鹅��失败时也�能没有任何通知，点击�稿���新开始生�。
+- 原因：�端失败 notice �更新生�页局部状�，pending 作�架�目在失败时被清掉或被� `generating` 状�误映射为 `ready`；�端作�摘�也�能短暂�是 `generationStatus=generating`。如果失败消�没有写入 notice，用户离开生�页��会弹出 `PlatformErrorDialog`；如果打开�稿�看�久化 `generating`，就会绕过失败���。
+- 处�：失败时按 session �留 pending 作�架�目并标记 `failed`，失败 notice �存错误消�并触�带��的 `PlatformErrorDialog`；拼图契约没有 `failed` 枚举，pending 拼图映射为 `idle`，�时用本地失败 notice 覆盖�久化生�中状�和旧的“正在生��摘�。点击失败�稿应优先用 notice / �端 session / fallback payload 组装失败生�页，�能�新从 0 秒�动新进度；拼图失败���没有有效 `workTitle` 时，作�架标题回退为“拼图�稿�。
+- 验�：`node node_modules/vitest/vitest.mjs run src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "failed parallel puzzle|background match3d"`。
+- 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/custom-world-home/creationWorkShelf.ts`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
+
 ## 汪汪声浪�稿试玩��写正� run
 
 - 现象：如果�稿结果页试玩和�布� runtime 共用�一写�绩路径，未�布或未确认资�的�稿试玩会污染正��局�排行榜和作�统计。
diff --git a/docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md b/docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md
index 0cf69286..41e555e1 100644
--- a/docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md
+++ b/docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md
@@ -242,10 +242,12 @@ npm run check:server-rs-ddd
 - Rust 结构体：`AuthStoreSnapshot`
 - ��：`server-rs/crates/spacetime-module/src/auth/tables.rs`
 
-认���策略：`api-server` �动时�从 SpacetimeDB 正�认�表（`user_account` / `auth_identity` / `refresh_session`）投影��进程内认�工作集；`auth_store_snapshot` ��留行级快照备查，��作为�动兜底��。`module-auth` ��留内存工作集和 JSON 导入 / 导出能力，��写本地�久化文件；`auth-store.json` / `GENARRATIVE_AUTH_STORE_PATH` ��是兼容���，也�得在�动时回写覆盖 `auth_identity` / `user_account`。若�动��阶段 SpacetimeDB ��连接或超时，`api-server` 进入�赖��用模�并对请求返回 `503 SERVICE_UNAVAILABLE`，直到�维�� SpacetimeDB 并���务。
+认���策略：`api-server` �动时�从 SpacetimeDB 正�认�表（`user_account` / `auth_identity` / `refresh_session`）投影��进程内认�工作集；`auth_store_snapshot` ��留行级快照备查，��作为�动兜底��。`module-auth` ��留内存工作集和 JSON 导入 / 导出能力，��写本地�久化文件；`auth-store.json` / `GENARRATIVE_AUTH_STORE_PATH` ��是兼容���，也�得在�动时回写覆盖 `auth_identity` / `user_account`。认�创建�登录会��刷新�退出�改密��置密��绑定和资料�更等写�作必须在返回客户端��功�步 SpacetimeDB 正�认�表；�步失败时接�返回错误，��许把�存在于当�进程内存的账�或会�当��功结果。新用户注册奖励�邀请�绑定和登录埋点必须排在认��步�功之�，��认�没�库时先写出钱包或邀请关系。若�动��阶段 SpacetimeDB ��连接或超时，`api-server` 进入�赖��用模�并对请求返回 `503 SERVICE_UNAVAILABLE`，直到�维�� SpacetimeDB 并���务。
 
 `auth_store_snapshot` �止�写�行 `snapshot_id = "default"` �� JSON。认��步入�收到 `module-auth` 整份快照�必须拆�行级记录写入�一张表，当�行键�缀包括：`meta/next_user_id`�`user/<user_id>`�`phone/<phone+user>`�`session/<session_id>`�`session_hash/<hash+session>`�`wechat/<provider_uid+user>`�`union/<union+user>`。SpacetimeDB 模���留 `import_auth_store_snapshot_json` 与 `export_auth_store_snapshot_from_tables` 两个认�快照过程；旧 `get_auth_store_snapshot`�`upsert_auth_store_snapshot`�`import_auth_store_snapshot` 兼容入�已删除。导入正�表时�按主键 upsert 本次快照包�的用户�身份和会�，��过期快照把其他用户整表删除。
 
+导出认�快照时，`auth_identity` 与 `refresh_session` �能引用�存在于 `user_account` 的用户；孤儿手机� identity�微信 identity�union 索引或 refresh session 必须被过滤，�能��� `module-auth` 内存�里的 `phone_to_user_id` 死索引。`module-auth` 从 JSON 快照��时也�二次清�这些孤儿索引，��历��快照导致密�登录�示错误�短信登录��示手机�已存在。
+
 ### `bark_battle_draft_config`
 
 - Rust 结构体：`BarkBattleDraftConfigRow`
diff --git a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
index d367bf19..cf5e893f 100644
--- a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
+++ b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
@@ -14,7 +14,7 @@
 
 创作表��交�的泥点余��置校验��许用独立弹窗�示失败原因，�得把用户退回创作入�或玩法模�列表，也�得清空当�表�状�。当�适用拼图�抓大鹅和汪汪声浪等会在�端�交�校验泥点的生�入�；余��足�余�读�失败都应�留在当�工作�，由用户关闭�示�继续编辑或自行补足泥点。
 
-平�入��生�页�结果页�作�详情�作�架和�行�的跨�程错误统一收�到 `PlatformErrorDialog`。弹窗必须带明确错误��，例如�个�稿��次生��作�详情或�个游玩实例，并�供�制按钮�制“错误�� + 错误内容�。页�内����渲染裸错误 banner；表�校验��布确认弹窗里的局部业务错误�以�留在原弹窗内。
+平�入��生�页�结果页�作�详情�作�架和�行�的跨�程错误统一收�到 `PlatformErrorDialog`。弹窗必须带明确错误��，例如�个�稿��次生��作�详情或�个游玩实例，并�供�制按钮�制“错误�� + 错误内容�。页�内����渲染裸错误 banner；表�校验��布确认弹窗里的局部业务错误�以�留在原弹窗内。生�任务在用户离开生�页�异步失败时，也必须通过�一弹窗通知用户，并把失败消�写入该 session 的�稿 notice，供�稿页和失败�试页��使用。
 
 生�任务在用户离开生�页�异步完�时，平�壳层必须弹出 `PlatformTaskCompletionDialog`。完�弹窗�样�带��，例如�个�稿或生�会�，并�供�制按钮�制“�� + 状��；如果用户��留在生�页并被自动带入结果页或试玩页，生�页 / 结果页本身�为完��馈，���外�加完�弹窗。
 
@@ -47,10 +47,11 @@
 3. �稿页与底部导航的未读�示点统一使用平�暖棕色点和暖棕光晕，��使用红点或红色 glow；�稿 Tab 作�架�片无论�稿 / 已�布都�外露作者信�；已�布作���上角直接显示无边框分享 icon。删除等破�性动作在作��上也�直接开放独立删除入�，左滑或长按仅作为辅助�作层。
 4. 生�中作�在整�上加等待�罩，但�移除作�基础信�。
 5. 生�中状��能�存在�端内存 notice。�端作�摘�必须下����的 `generationStatus`；�端刷新或退出产��，作�架优先用摘�状���等待�罩，本轮内存 notice �作为�时�馈。
-6. 点击 `generationStatus=generating` 的�稿�必须��对应玩法的生�进度页，�能进入空白结果页或普通工作区；��生�页的 `startedAtMs` 使用进入生�页的当�时间，作�摘� `updatedAt` �用于排�和摘�展示，��与�进度起算。
-7. 从�稿 Tab 作�架打开�稿工作区�生�页或结果页时，返回按钮必须回到�稿 Tab 的�一作�架语境；从创作 Tab 新建或直接进入创作链路时�回到创作 Tab。平�壳层需�显�记录本次创作�的返回��，�能让结果页返回动作固定跳到创作入�。
-8. �有 generated 图片必须通过 `ResolvedAssetImage` / `/api/assets/read-url` �签读�。
-9. 敲木鱼作�架读�当�用户作�列表时走 `GET /api/creation/wooden-fish/works`；�布�功�平�壳必须�时刷新作�架与公开广场，��作�刚�布时��留在旧列表。
+6. 点击 `generationStatus=generating` 的�稿�必须��对应玩法的生�进度页，�能进入空白结果页或普通工作区；��生�页的 `startedAtMs` 优先使用�端 session 的 `updatedAt`，没有 session 时�使用作�摘� `updatedAt`，�得因�新进入页�从 0 秒�新计时。
+7. 生�失败必须按 session 独立记录，�能用一个失败打断或覆盖�玩法的其它生�任务。失败 notice 需��存错误消�并覆盖作�架本地状�：�使�端摘�暂时�是 `generationStatus=generating` 或�写出���投影，�稿�也�得继续显示“生�中�，点击�必须进入失败 / �试生�页，�能�新创建一轮生�；拼图这类失败���若没有有效 `workTitle`，作�架标题回退为“拼图�稿�，�暴露“第1关�空壳。
+8. 从�稿 Tab 作�架打开�稿工作区�生�页或结果页时，返回按钮必须回到�稿 Tab 的�一作�架语境；从创作 Tab 新建或直接进入创作链路时�回到创作 Tab。平�壳层需�显�记录本次创作�的返回��，�能让结果页返回动作固定跳到创作入�。
+9. �有 generated 图片必须通过 `ResolvedAssetImage` / `/api/assets/read-url` �签读�。
+10. 敲木鱼作�架读�当�用户作�列表时走 `GET /api/creation/wooden-fish/works`；�布�功�平�壳必须�时刷新作�架与公开广场，��作�刚�布时��留在旧列表。
 
 �现 Tab�创作 Tab 与�稿 Tab 的页�根内容区��套 `platform-page-stage` 外层全局�片壳，让列表�筛选和玩法�获得更宽的横�空间；推�页和我的页�按�自页�设计�留原有全局�片�径。移动端“我的�页�按顶部头� / 昵称 / 陶泥��会员横幅�三张统计���日任务�五项常用功能宫格�设置入�和法律信�组织，��留旧的底部“填邀请��次级入�；常用功能当��展示四项常驻入�时必须按四列铺满整行，��留五列网格导致左对�空�；�日任务�必须读� `/api/profile/tasks` 的当�任务摘�并在领���步刷新�片进度。字�必须维�平�普通 UI 档�，�能因为窄�把�片标题�功能 label 或法律信�撑�展示级字�；最�一�内容必须能在底部 dock 上方完整滚动露出，�得被固定底部导航�挡。
 
@@ -95,9 +96,9 @@ RPG / 拼图等�行�存档�以 `/api/profile/save-archives` 的�端列
 - 图�输入�用 `CreativeImageInputPanel`。
 - 结果页�关画�编辑�用 `CreativeImageInputPanel`；入�页和关�画��共享�控 UI 模�，�共享数���状��action 或存储�置：入�页继续写 `formDraft` 与�稿编译 payload，关�画�写 `levels[].pictureReference/pictureDescription` 并触� `generate_puzzle_images`。结果页删除独立“素��置�Tab，���供�独 UI 背景生�入�。通用图片��的展示图和 AI �绘�考图能力必须分开控制：结果页正�关�图�作为预览图，�因存在正�图自动暴露 AI �绘开关；�有本地上传�历�选择或已�存 `pictureReference` �作为�绘�考图时，�显示 AI �绘开关并把状�带入 `generate_puzzle_images`。用户在本次编辑中上传或选择历�图�，该图优先��主图�片，�删除�切� AI �绘，也�关闭 AI �绘直用；仅有正�图预览时，画��述框��上传多张�考图。关�详情弹窗应使用加宽��，关��称�画�图和画��述�并在�一个纵�列表中，�称输入和画�编辑模�外层��包独立 `platform-subpanel`；画�图��必须�留稳定最�高度，��弹窗内 `flex-1` 布局�缩��剩标题��述输入和�作按钮。
 - 支�画��述生图�多�考图生图�上传或历�生�主图� AI �绘�上传或历�生�主图���绘；主链�求�览器先� `/api/assets/direct-upload-tickets` 直传 OSS 并确认 `asset_object`，创作 action ��交 `referenceImageAssetObjectId(s)`，由�端校验 owner / bucket / kind / MIME / size �签� OSS �读 URL 并下载为 VectorEngine `/v1/images/edits` 的 multipart `image` part。本地上传 Data URL 与历� `/generated-*` 图片路径仅�留为旧�稿�旧入�或未�移客户端的兼容输入；关闭 AI �绘时，�端统一解�为首关或当�关�正�图���久化，�调用第一段拼图首图生�。
-- �稿生�会先�久化 `generationStatus=generating` 的作�摘�，生�完�并回写关�拼图画��关�画��考图�UI spritesheet 和关�背景图���为 `ready`；当��自动生�背景音�。生�页步骤推进必须跟��端 session `progressPercent` 的真实里程碑：`88` 表示�稿编译完�并进入出图步骤，`94` 表示生�图已�存并进入 UI / 背景步骤，`96` 表示正�图与 UI 背景已确认并进入写入步骤，最终 action �功或�布�进入完��；�个步骤内部�以按实际等待时间使用�进度平滑推进，总进度按 `0-88`�`88-94`�`94-96`�`96-98` 的真实里程碑区间平滑推进。任一�步 action 回包到达时立�以真实完�/失败结果冻结进度。
-- 作�架拼图�稿的“生�中��罩�表示�始�稿还没有�查看结果；��作�摘��首关��或任一关�候选图已��用，�续 UI 背景�生�和追加关�生图都必须作为结果页局部生��处�，�能阻止打开�稿结果页。
-- 拼图�稿编译是长耗时 action，�端 action 请求默认等待 `1_800_000ms`（30 分钟）且�自动�试。�次图片生�调用的预期用时按 90 秒计算，但 `生�拼图首图` �独按 4 分钟展示；完整 AI �绘路径为 `编译首关�稿` 8 秒�`生�关��称` 10 秒�`生�拼图首图` 4 分钟�`生�关�画�` 90 秒�`生�UI与背景` 90 秒�`写入正��稿` 10 秒，�计约 448 秒。上传图且关闭 AI �绘时必须跳过 `生�拼图首图`，直接进入 `生�关�画�` 和 `生�UI与背景`，�计约 208 秒。生�页��时必须使用进入生�页的当�时间作为原始 `startedAtMs`；失败/完��用 `finishedAtMs` 冻结耗时。未收到对应�端里程碑�，�续步骤��待处�；�使当�步骤预计时长耗尽，也�能让当�步骤内部进度�在 `98%` 内，�能自动完�当�步骤或跳到�续步骤。生�页�个步骤�展示标题和进度，�展示步骤详细�述。
+- �稿生�会先�久化 `generationStatus=generating` 的作�摘�，生�完�并回写关�拼图画��关�画��考图�UI spritesheet 和关�背景图���为 `ready`；当��自动生�背景音�。生�页步骤推进必须跟��端 session `progressPercent` 的真实里程碑：`88` 表示�稿编译完�并进入出图步骤，`94` 表示生�图已�存并进入 UI / 背景步骤，`96` 表示正�图与 UI 背景已确认并进入写入步骤，最终 action �功或�布�进入完��；�个步骤内部�以按实际等待时间使用�进度平滑推进。`88/94/96` �负责切�当�步骤，�作为总进度地�；总进度按已完�步骤��加当�步骤内�进度推导，�完��最多�在 `98%`。任一�步 action 回包到达时立�以真实完�/失败结果冻结进度。
+- 作�架拼图�稿的“生�中��罩�表示�始�稿还没有�查看结果；��作�摘��首关��或任一关�候选图已��用，�续 UI 背景�生�和追加关�生图都必须作为结果页局部生��处�，�能阻止打开�稿结果页。生�失败�，�一�览器会�内的失败 notice 必须覆盖�端�能�短暂返回的 `generationStatus=generating` 摘�，作�架�留对应�稿�但��显示“生�中�，点击�回到失败 / �试状�。
+- 拼图�稿编译是长耗时 action，�端 action 请求默认等待 `1_800_000ms`（30 分钟）且�自动�试。�次图片生�调用的预期用时按 90 秒计算，但 `生�拼图首图` �独按 4 分钟展示；完整 AI �绘路径为 `编译首关�稿` 8 秒�`生�关��称` 10 秒�`生�拼图首图` 4 分钟�`生�关�画�` 90 秒�`生�UI与背景` 90 秒�`写入正��稿` 10 秒，�计约 448 秒。上传图且关闭 AI �绘时必须跳过 `生�拼图首图`，直接进入 `生�关�画�` 和 `生�UI与背景`，�计约 208 秒。生�页��时必须使用�端 session `updatedAt` 或作�摘� `updatedAt` 作为原始 `startedAtMs`；失败/完��用 `finishedAtMs` 冻结耗时。未收到对应�端里程碑�，�续步骤��待处�；�使当�步骤预计时长耗尽，也�能让当�步骤内部进度�在 `98%` 内，�能自动完�当�步骤或跳到�续步骤。生�页�个步骤�展示标题和进度，�展示步骤详细�述。
 - �端创作�结果页�生�页和错误�示�展示 GPT / Gemini 等具体模型�称；如需在内部�留模型路由，UI �使用“标准模��“创�模��等产�化�称。
 - 若�览器�����或网络切�导致 compile 请求失败，�端在标记失败�必须先�读 `getPuzzleAgentSession(sessionId)`；�有最新 session �缺 `draft.coverImageSrc`�首关 `coverImageSrc` 或候选图时�展示失败，�读到已生��稿时按�功收尾�刷新作�架并继续自动试玩/结果页链路。
 - 拼图�考图 AI �绘走 VectorEngine `/v1/images/edits`；无�考图时走 `/v1/images/generations`。两者模型都使用 `gpt-image-2`，�考图由�端作为 multipart `image` part 传入编辑接�。
diff --git a/docs/�玩法创作】拼图生�页进度�径-2026-05-23.md b/docs/�玩法创作】拼图生�页进度�径-2026-05-23.md
index bc0ae2a0..c5314d86 100644
--- a/docs/�玩法创作】拼图生�页进度�径-2026-05-23.md
+++ b/docs/�玩法创作】拼图生�页进度�径-2026-05-23.md
@@ -1,6 +1,6 @@
 # 拼图生�页进度�径
 
-更新时间：`2026-05-24`
+更新时间：`2026-06-02`
 
 ## 目标
 
@@ -8,14 +8,14 @@
 
 ## �地�径
 
-- 总进度和当�步骤内百分比�以按已耗时平滑增长，但进入生�页的�始帧必须从 `0%` 开始，�完��最多�在 `98%`。
-- 未收到首个真实里程碑�，页���留在当�步骤，总进度在 `0-88` 区间内平滑推进；收到 `88/94/96` 里程碑�，分别在 `88-94`�`94-96`�`96-98` 区间内推进，��步骤�跳时总进度也�死。
-- �端 `progressPercent` 低于 `88` �作为当�会�状�记录，�得把生�页阶段推到首个图片里程碑；低于首个里程碑时页��按当�视图进入时间从 `0%` 平滑展示。
+- 总进度和当�步骤内百分比�以按已耗时平滑增长；新�起的生��始帧从 `0%` 开始，���久化生�中�稿时必须按�端 session / 作�摘�时间戳推导已耗时，�能�次�新从 `0 秒` 起算。�完��最多�在 `98%`。
+- �端 `progressPercent` 的 `88/94/96` �用于切�当�真实步骤，�得直接作为总进度地�；总进度应按已完�步骤��加当�步骤内�进度推导，����或轮询�瞬间跳到 `88%`。
+- �端 `progressPercent` 低于 `88` �作为当�会�状�记录，�得把生�页阶段推到首个图片里程碑，也�得抬高首帧总进度。
 - 步骤状�以真实阶段为准：`phase` / �端会�进度 / 最终完�或失败回包��许跨步。
-- 拼图生�页���久化 `generationStatus=generating` �稿时，展示进度使用“进入生�页的当�时间�作为 `startedAtMs`；�得�用作�摘� `updatedAt` 推导展示起点，��刷新�首帧直接跳到 `80%+`。
-- 拼图和抓大鹅等生�页从作�架 / 刷新��进入时，�端应把展示�生�状��基准到进入页�的当�时间；�� session 的 `progressPercent` 与历�里程碑��留为状�事实，�得直接作为首帧总进度。
+- 拼图和抓大鹅等生�页从作�架 / 刷新��进入时，�端应优先使用�端 session `updatedAt` 或作�摘� `updatedAt` 作为展示� `startedAtMs`，��已耗时与�端生�时间对�；�� session 的 `progressPercent` �负责真实步骤推进，�直接决定总进度百分比。
+- 生�失败时，生�页冻结为失败 / �试状�；�一�览器会�内返回�稿 Tab 时，失败�稿必须继续出现在作�架，且本地失败 notice �覆盖�端��能短暂返回的 `generationStatus=generating` 摘�，�能继续显示“生�中�。
 - 当�步骤未完�时，�续步骤��待处�；�使预计时间耗尽，也�能让当�步骤内部进度接近或达到上�，�能自动完��续步骤。
-- 抓大鹅等�拼图�游�的生�页也�守�始帧 `0%`：没有�端资产计数时，当�步骤内�进度按玩法预计等待总时长从 `0` 平滑推进，�使用固定 `0.5` 这类常�起步。
+- 抓大鹅等�拼图�游�的生�页也�守�一���径：没有�端资产计数时，当�步骤内�进度按玩法预计等待总时长平滑推进，�使用固定 `0.5` 这类常�起步，也�在未完�时显示 `100%`。
 - 步骤�片�展示标题和进度，�展示详细�述。
 - 生�拼图首图步骤按 4 分钟预估；完整 AI �绘路径总预计时长为 448 秒，上传图且关闭 AI �绘时跳过首图生�，�为 208 秒。
 
@@ -25,5 +25,6 @@
 - `src/services/miniGameDraftGenerationProgress.test.ts` 覆盖�端 `progressPercent < 88` 时�会抬高进入生�页的�始总进度。
 - `src/services/miniGameDraftGenerationProgress.test.ts` 覆盖抓大鹅等�拼图生�页�始总进度为 `0%`。
 - `src/components/CustomWorldGenerationView.test.tsx` 覆盖步骤详情�在生�页渲染。
-- `src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "persisted generating"` 覆盖刷新�继续生�中拼图 / 抓大鹅�稿�会继承旧 `updatedAt` 导致总进度首帧过高。
+- `src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "persisted generating"` 覆盖刷新�继续生�中拼图 / 抓大鹅�稿按�端时间戳��，且�会因�端里程碑直接跳到 `88%` 或 `100%`。
+- `src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "failed parallel puzzle generations"` 覆盖失败�的 pending 拼图�稿�留在作�架，并且��显示“生�中�。
 - 文档主图谱的拼图章节�步�留该�径。
diff --git a/docs/�玩法创作】生�页圆环布局�径-2026-05-23.md b/docs/�玩法创作】生�页圆环布局�径-2026-05-23.md
index 7236ab89..91b4980c 100644
--- a/docs/�玩法创作】生�页圆环布局�径-2026-05-23.md
+++ b/docs/�玩法创作】生�页圆环布局�径-2026-05-23.md
@@ -1,6 +1,6 @@
 # 生�页圆环布局�径
 
-更新时间：`2026-05-30`
+更新时间：`2026-06-02`
 
 ## 目标
 
@@ -17,7 +17,7 @@
 - 在窄�下，预计等待 / 已耗时信��放到圆环下方两列排布；`sm` �以上视��回到圆环左�悬浮，��左�悬浮�和圆环共�超过视�宽度。
 - 总进度标题和百分比数字必须显�高于 SVG 圆环层级渲染，��被圆环边缘压�；圆环本身��背景层，�抢文字层。
 - 总进度标题和百分比数字�比圆环�上移一点，当�内容区上边�以 `pt-[2%]` 为准，桌�端�进一步微调到 `sm:pt-[1.5%]`，确�数字�与进度�弧线��。
-- 从作�架或刷新�的�久化生�中�稿进入生�页时，�端必须�置“展示� startedAtMs�为进入生�页的当�时间；�端 `progressPercent` �用于�续真实步骤推进，�得�与首帧总进度展示，����生�页首帧直接显示 `80%+`。
+- 从作�架或刷新�的�久化生�中�稿进入生�页时，�端必须按�端 session `updatedAt` 或作�摘� `updatedAt` ��展示� `startedAtMs`，��“已耗时��因�新进入页�而清零；�端 `progressPercent` �用于真实步骤推进，�得直接作为总进度地�，����生�页首帧直接显示 `88%` 或 `100%`。
 - 生�页�展示��明“当�步骤���，�片内��留步骤�称�步骤状��步骤进度�和轻�加载指示；“当�步骤�标签使用 `10px-11px`，步骤�称使用 `14px-15px`，状�使用 `11px-12px`，��渲染步骤列表或步骤详情。
 - 当�作�信�放在圆角信��中，标题固定使用 `13px`；有结构化字段时以两列信��展示，例如“题� / 素�数��，无结构化字段时�展示纯文本设定。
 - 汪汪声浪生�页 `BarkBattleGeneratingView` 也必须对��一垂直布局，��继续展示三行槽�列表或左�分�抢�主视觉。
diff --git a/packages/shared/src/contracts/puzzleAgentDraft.ts b/packages/shared/src/contracts/puzzleAgentDraft.ts
index 38fa22fb..3b8cdbaf 100644
--- a/packages/shared/src/contracts/puzzleAgentDraft.ts
+++ b/packages/shared/src/contracts/puzzleAgentDraft.ts
@@ -62,7 +62,7 @@ export interface PuzzleDraftLevel {
   selectedCandidateId: string | null;
   coverImageSrc: string | null;
   coverAssetId: string | null;
-  generationStatus: 'idle' | 'generating' | 'ready';
+  generationStatus: 'idle' | 'generating' | 'ready' | 'failed';
 }
 
 export interface PuzzleResultDraft {
@@ -78,7 +78,7 @@ export interface PuzzleResultDraft {
   selectedCandidateId: string | null;
   coverImageSrc: string | null;
   coverAssetId: string | null;
-  generationStatus: 'idle' | 'generating' | 'ready';
+  generationStatus: 'idle' | 'generating' | 'ready' | 'failed';
   levels?: PuzzleDraftLevel[];
   formDraft?: {
     workTitle?: string;
diff --git a/server-rs/crates/api-server/src/password_entry.rs b/server-rs/crates/api-server/src/password_entry.rs
index 816ba472..94c3781a 100644
--- a/server-rs/crates/api-server/src/password_entry.rs
+++ b/server-rs/crates/api-server/src/password_entry.rs
@@ -40,6 +40,15 @@ pub async fn password_entry(
         state.password_entry_service().execute(input).await
     }
     .map_err(map_password_entry_error)?;
+    let session_client = resolve_session_client_context(&headers);
+    let signed_session = create_password_auth_session(&state, &result.user, &session_client)?;
+    state
+        .sync_auth_store_snapshot_to_spacetime()
+        .await
+        .map_err(|error| {
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
+                .with_message(format!("�步认�快照失败：{error}"))
+        })?;
     if result.created {
         crate::registration_reward::grant_new_user_registration_wallet_reward(
             &state,
@@ -48,8 +57,6 @@ pub async fn password_entry(
         )
         .await;
     }
-    let session_client = resolve_session_client_context(&headers);
-    let signed_session = create_password_auth_session(&state, &result.user, &session_client)?;
     record_daily_login_tracking_event_after_auth_success(
         &state,
         &request_context,
@@ -57,13 +64,6 @@ pub async fn password_entry(
         AuthLoginMethod::Password,
     )
     .await;
-    state
-        .sync_auth_store_snapshot_to_spacetime()
-        .await
-        .map_err(|error| {
-            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
-                .with_message(format!("�步认�快照失败：{error}"))
-        })?;
 
     let mut headers = HeaderMap::new();
     attach_set_cookie_header(
diff --git a/server-rs/crates/api-server/src/password_management.rs b/server-rs/crates/api-server/src/password_management.rs
index 9d305c68..94e5177e 100644
--- a/server-rs/crates/api-server/src/password_management.rs
+++ b/server-rs/crates/api-server/src/password_management.rs
@@ -100,13 +100,6 @@ pub async fn reset_password(
         &session_client,
         module_auth::AuthLoginMethod::Password,
     )?;
-    record_daily_login_tracking_event_after_auth_success(
-        &state,
-        &request_context,
-        &result.user.id,
-        module_auth::AuthLoginMethod::Password,
-    )
-    .await;
     state
         .sync_auth_store_snapshot_to_spacetime()
         .await
@@ -114,6 +107,13 @@ pub async fn reset_password(
             AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
                 .with_message(format!("�步认�快照失败：{error}"))
         })?;
+    record_daily_login_tracking_event_after_auth_success(
+        &state,
+        &request_context,
+        &result.user.id,
+        module_auth::AuthLoginMethod::Password,
+    )
+    .await;
 
     let mut headers = HeaderMap::new();
     attach_set_cookie_header(
diff --git a/server-rs/crates/api-server/src/phone_auth.rs b/server-rs/crates/api-server/src/phone_auth.rs
index 31e64afa..1b8788ca 100644
--- a/server-rs/crates/api-server/src/phone_auth.rs
+++ b/server-rs/crates/api-server/src/phone_auth.rs
@@ -151,6 +151,20 @@ pub async fn phone_login(
         }
     };
     let created = result.created;
+    let session_client = resolve_session_client_context(&headers);
+    let signed_session = create_auth_session(
+        &state,
+        &result.user,
+        &session_client,
+        AuthLoginMethod::Phone,
+    )?;
+    state
+        .sync_auth_store_snapshot_to_spacetime()
+        .await
+        .map_err(|error| {
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
+                .with_message(format!("�步认�快照失败：{error}"))
+        })?;
     if created {
         crate::registration_reward::grant_new_user_registration_wallet_reward(
             &state,
@@ -170,13 +184,6 @@ pub async fn phone_login(
     } else {
         None
     };
-    let session_client = resolve_session_client_context(&headers);
-    let signed_session = create_auth_session(
-        &state,
-        &result.user,
-        &session_client,
-        AuthLoginMethod::Phone,
-    )?;
     record_daily_login_tracking_event_after_auth_success(
         &state,
         &request_context,
@@ -184,13 +191,6 @@ pub async fn phone_login(
         AuthLoginMethod::Phone,
     )
     .await;
-    state
-        .sync_auth_store_snapshot_to_spacetime()
-        .await
-        .map_err(|error| {
-            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
-                .with_message(format!("�步认�快照失败：{error}"))
-        })?;
 
     let mut headers = HeaderMap::new();
     attach_set_cookie_header(
diff --git a/server-rs/crates/api-server/src/puzzle/draft.rs b/server-rs/crates/api-server/src/puzzle/draft.rs
index 1f3b53db..276a29f5 100644
--- a/server-rs/crates/api-server/src/puzzle/draft.rs
+++ b/server-rs/crates/api-server/src/puzzle/draft.rs
@@ -2,8 +2,8 @@ use super::*;
 
 pub(crate) fn build_puzzle_form_seed_text(payload: &CreatePuzzleAgentSessionRequest) -> String {
     build_puzzle_form_seed_prompt(PuzzleFormSeedPromptParts {
-        title: None,
-        work_description: None,
+        title: payload.work_title.as_deref(),
+        work_description: payload.work_description.as_deref(),
         picture_description: payload
             .picture_description
             .as_deref()
@@ -32,8 +32,8 @@ pub(crate) async fn save_puzzle_form_payload_before_compile(
     now: i64,
 ) -> Result<String, Response> {
     let seed_text = build_puzzle_form_seed_text_from_parts(
-        None,
-        None,
+        payload.work_title.as_deref(),
+        payload.work_description.as_deref(),
         payload
             .picture_description
             .as_deref()
diff --git a/server-rs/crates/api-server/src/puzzle/handlers.rs b/server-rs/crates/api-server/src/puzzle/handlers.rs
index ab594f07..afd6f3cf 100644
--- a/server-rs/crates/api-server/src/puzzle/handlers.rs
+++ b/server-rs/crates/api-server/src/puzzle/handlers.rs
@@ -725,8 +725,8 @@ pub async fn execute_puzzle_agent_action(
         }
         "save_puzzle_form_draft" => {
             let seed_text = build_puzzle_form_seed_text_from_parts(
-                None,
-                None,
+                payload.work_title.as_deref(),
+                payload.work_description.as_deref(),
                 payload
                     .picture_description
                     .as_deref()
diff --git a/server-rs/crates/api-server/src/puzzle/tests.rs b/server-rs/crates/api-server/src/puzzle/tests.rs
index d4bca634..86512e7d 100644
--- a/server-rs/crates/api-server/src/puzzle/tests.rs
+++ b/server-rs/crates/api-server/src/puzzle/tests.rs
@@ -384,6 +384,28 @@ fn puzzle_compile_error_preserves_vector_engine_unavailable_status() {
     assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
 }
 
+#[test]
+fn puzzle_form_seed_text_includes_work_metadata() {
+    let payload = CreatePuzzleAgentSessionRequest {
+        seed_text: Some("旧 seed 会被画��述兜底覆盖。".to_string()),
+        work_title: Some("雨夜猫街".to_string()),
+        work_description: Some("123".to_string()),
+        picture_description: Some("一�猫在雨夜�牌下回头。".to_string()),
+        reference_image_src: None,
+        reference_image_srcs: Vec::new(),
+        reference_image_asset_object_id: None,
+        reference_image_asset_object_ids: Vec::new(),
+        image_model: None,
+        ai_redraw: Some(true),
+    };
+
+    let seed_text = build_puzzle_form_seed_text(&payload);
+
+    assert!(seed_text.contains("作��称：雨夜猫街"));
+    assert!(seed_text.contains("作��述：123"));
+    assert!(seed_text.contains("画��述：一�猫在雨夜�牌下回头。"));
+}
+
 #[tokio::test]
 async fn puzzle_compile_error_normalizes_legacy_apimart_image_message() {
     let error = map_puzzle_compile_error(SpacetimeClientError::Runtime(
diff --git a/server-rs/crates/api-server/src/refresh_session.rs b/server-rs/crates/api-server/src/refresh_session.rs
index 9276ce1b..2c45a948 100644
--- a/server-rs/crates/api-server/src/refresh_session.rs
+++ b/server-rs/crates/api-server/src/refresh_session.rs
@@ -56,13 +56,6 @@ pub async fn refresh_session(
         Some(&rotated.session.issued_by_provider),
         Some(&rotated.session.client_info),
     )?;
-    record_daily_login_tracking_event_after_auth_success(
-        &state,
-        &request_context,
-        &rotated.user.id,
-        rotated.session.issued_by_provider.clone(),
-    )
-    .await;
     state
         .sync_auth_store_snapshot_to_spacetime()
         .await
@@ -70,6 +63,13 @@ pub async fn refresh_session(
             AppError::from_status(axum::http::StatusCode::INTERNAL_SERVER_ERROR)
                 .with_message(format!("�步认�快照失败：{error}"))
         })?;
+    record_daily_login_tracking_event_after_auth_success(
+        &state,
+        &request_context,
+        &rotated.user.id,
+        rotated.session.issued_by_provider.clone(),
+    )
+    .await;
 
     let mut headers = HeaderMap::new();
     attach_set_cookie_header(
diff --git a/server-rs/crates/api-server/src/state.rs b/server-rs/crates/api-server/src/state.rs
index c0c61378..89a80331 100644
--- a/server-rs/crates/api-server/src/state.rs
+++ b/server-rs/crates/api-server/src/state.rs
@@ -591,7 +591,7 @@ impl AppState {
         )
         .map_err(|_| SpacetimeClientError::Runtime("认�快照更新时间超出 i64 范围".to_string()))?;
         // 当�进程内 auth_store 是认�请求的�时工作集；SpacetimeDB 正�认�表用于跨进程��。
-        // 远端数�库挂起或网络异常时，��级�续��能力，�能让已�功的登录/刷新/退出回滚为失败。
+        // 认��更必须在返回客户端�写入 SpacetimeDB，���在本进程内�功����丢失账�或会�。
         #[cfg(not(test))]
         if let Err(error) = self
             .spacetime_client
@@ -600,9 +600,9 @@ impl AppState {
         {
             warn!(
                 error = %error,
-                "认�快照导入 SpacetimeDB 正�表失败，当�认��程继续"
+                "认�快照导入 SpacetimeDB 正�表失败，当�认��程中止"
             );
-            return Ok(());
+            return Err(error);
         }
         #[cfg(not(test))]
         Ok(())
diff --git a/server-rs/crates/api-server/src/wechat_auth.rs b/server-rs/crates/api-server/src/wechat_auth.rs
index d7dfc858..f2766959 100644
--- a/server-rs/crates/api-server/src/wechat_auth.rs
+++ b/server-rs/crates/api-server/src/wechat_auth.rs
@@ -145,13 +145,6 @@ pub async fn handle_wechat_callback(
                 &session_client,
                 AuthLoginMethod::Wechat,
             )?;
-            record_daily_login_tracking_event_after_auth_success(
-                &state,
-                &request_context,
-                &result.user.id,
-                AuthLoginMethod::Wechat,
-            )
-            .await;
             state
                 .sync_auth_store_snapshot_to_spacetime()
                 .await
@@ -159,6 +152,13 @@ pub async fn handle_wechat_callback(
                     AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
                         .with_message(format!("�步认�快照失败：{error}"))
                 })?;
+            record_daily_login_tracking_event_after_auth_success(
+                &state,
+                &request_context,
+                &result.user.id,
+                AuthLoginMethod::Wechat,
+            )
+            .await;
             let mut response = Redirect::to(&build_auth_result_redirect_url(
                 &redirect_path,
                 &[
@@ -241,6 +241,20 @@ pub async fn bind_wechat_phone(
             .await
             .map_err(map_wechat_bind_phone_error)?
     };
+    let session_client = resolve_session_client_context(&headers);
+    let signed_session = create_auth_session(
+        &state,
+        &result.user,
+        &session_client,
+        AuthLoginMethod::Wechat,
+    )?;
+    state
+        .sync_auth_store_snapshot_to_spacetime()
+        .await
+        .map_err(|error| {
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
+                .with_message(format!("�步认�快照失败：{error}"))
+        })?;
     if result.activated_new_user {
         crate::registration_reward::grant_new_user_registration_wallet_reward(
             &state,
@@ -249,13 +263,6 @@ pub async fn bind_wechat_phone(
         )
         .await;
     }
-    let session_client = resolve_session_client_context(&headers);
-    let signed_session = create_auth_session(
-        &state,
-        &result.user,
-        &session_client,
-        AuthLoginMethod::Wechat,
-    )?;
     record_daily_login_tracking_event_after_auth_success(
         &state,
         &request_context,
@@ -263,13 +270,6 @@ pub async fn bind_wechat_phone(
         AuthLoginMethod::Wechat,
     )
     .await;
-    state
-        .sync_auth_store_snapshot_to_spacetime()
-        .await
-        .map_err(|error| {
-            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
-                .with_message(format!("�步认�快照失败：{error}"))
-        })?;
 
     let mut response_headers = HeaderMap::new();
     attach_set_cookie_header(
diff --git a/server-rs/crates/module-auth/src/lib.rs b/server-rs/crates/module-auth/src/lib.rs
index 66f31450..3b0e5677 100644
--- a/server-rs/crates/module-auth/src/lib.rs
+++ b/server-rs/crates/module-auth/src/lib.rs
@@ -11,7 +11,7 @@ pub use errors::*;
 pub use events::*;
 
 use std::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     sync::{Arc, Mutex},
 };
 
@@ -918,16 +918,47 @@ impl Default for InMemoryAuthStoreState {
 
 impl InMemoryAuthStoreState {
     fn from_persistent_snapshot(snapshot: PersistentAuthStoreSnapshot) -> Self {
+        let existing_user_ids = snapshot
+            .users_by_username
+            .values()
+            .map(|stored| stored.user.id.clone())
+            .collect::<HashSet<_>>();
+        let phone_to_user_id = snapshot
+            .phone_to_user_id
+            .into_iter()
+            .filter(|(_, user_id)| existing_user_ids.contains(user_id))
+            .collect();
+        let sessions_by_id = snapshot
+            .sessions_by_id
+            .into_iter()
+            .filter(|(_, stored)| existing_user_ids.contains(&stored.session.user_id))
+            .collect::<HashMap<_, _>>();
+        let session_id_by_refresh_token_hash = snapshot
+            .session_id_by_refresh_token_hash
+            .into_iter()
+            .filter(|(_, session_id)| sessions_by_id.contains_key(session_id))
+            .collect();
+        let wechat_identity_by_provider_uid = snapshot
+            .wechat_identity_by_provider_uid
+            .into_iter()
+            .filter(|(_, identity)| existing_user_ids.contains(&identity.user_id))
+            .collect();
+        let user_id_by_provider_union_id = snapshot
+            .user_id_by_provider_union_id
+            .into_iter()
+            .filter(|(_, user_id)| existing_user_ids.contains(user_id))
+            .collect();
+
         Self {
             next_user_id: snapshot.next_user_id,
             users_by_username: snapshot.users_by_username,
-            phone_to_user_id: snapshot.phone_to_user_id,
-            sessions_by_id: snapshot.sessions_by_id,
-            session_id_by_refresh_token_hash: snapshot.session_id_by_refresh_token_hash,
+            phone_to_user_id,
+            sessions_by_id,
+            session_id_by_refresh_token_hash,
             phone_codes_by_key: HashMap::new(),
             wechat_states_by_token: HashMap::new(),
-            wechat_identity_by_provider_uid: snapshot.wechat_identity_by_provider_uid,
-            user_id_by_provider_union_id: snapshot.user_id_by_provider_union_id,
+            wechat_identity_by_provider_uid,
+            user_id_by_provider_union_id,
         }
     }
 
@@ -1159,10 +1190,17 @@ impl InMemoryAuthStore {
             .inner
             .lock()
             .map_err(|_| PhoneAuthError::Store("用户仓储�已中毒".to_string()))?;
-        if state.phone_to_user_id.contains_key(&phone_number.e164) {
-            return Err(PhoneAuthError::Store(
-                "手机�已存在，无法��创建账�".to_string(),
-            ));
+        if let Some(existing_user_id) = state.phone_to_user_id.get(&phone_number.e164).cloned() {
+            let existing_user_exists = state
+                .users_by_username
+                .values()
+                .any(|stored_user| stored_user.user.id == existing_user_id);
+            if existing_user_exists {
+                return Err(PhoneAuthError::Store(
+                    "手机�已存在，无法��创建账�".to_string(),
+                ));
+            }
+            state.phone_to_user_id.remove(&phone_number.e164);
         }
 
         let created_at = format_rfc3339(OffsetDateTime::now_utc()).map_err(|message| {
@@ -1213,8 +1251,15 @@ impl InMemoryAuthStore {
             .inner
             .lock()
             .map_err(|_| PasswordEntryError::Store("用户仓储�已中毒".to_string()))?;
-        if state.phone_to_user_id.contains_key(&phone_number.e164) {
-            return Err(PasswordEntryError::InvalidCredentials);
+        if let Some(existing_user_id) = state.phone_to_user_id.get(&phone_number.e164).cloned() {
+            let existing_user_exists = state
+                .users_by_username
+                .values()
+                .any(|stored_user| stored_user.user.id == existing_user_id);
+            if existing_user_exists {
+                return Err(PasswordEntryError::InvalidCredentials);
+            }
+            state.phone_to_user_id.remove(&phone_number.e164);
         }
 
         let created_at = format_rfc3339(OffsetDateTime::now_utc()).map_err(|message| {
@@ -2629,6 +2674,54 @@ mod tests {
         assert_eq!(rotated.user.id, user.id);
     }
 
+    #[tokio::test]
+    async fn snapshot_json_drops_orphan_phone_index_before_phone_login() {
+        let snapshot = PersistentAuthStoreSnapshot {
+            next_user_id: 9,
+            users_by_username: HashMap::new(),
+            phone_to_user_id: HashMap::from([(
+                "+8613800138032".to_string(),
+                "user_missing_phone_owner".to_string(),
+            )]),
+            sessions_by_id: HashMap::new(),
+            session_id_by_refresh_token_hash: HashMap::new(),
+            wechat_identity_by_provider_uid: HashMap::new(),
+            user_id_by_provider_union_id: HashMap::new(),
+        };
+        let snapshot_json = serde_json::to_string(&snapshot).expect("snapshot should serialize");
+        let restored_store = InMemoryAuthStore::from_snapshot_json(&snapshot_json)
+            .expect("snapshot json should restore");
+        let phone_service = build_phone_service(restored_store);
+        let now = OffsetDateTime::now_utc();
+
+        phone_service
+            .send_code(
+                SendPhoneCodeInput {
+                    phone_number: "13800138032".to_string(),
+                    scene: PhoneAuthScene::Login,
+                },
+                now,
+            )
+            .await
+            .expect("phone code should send");
+        let result = phone_service
+            .login(
+                PhoneLoginInput {
+                    phone_number: "13800138032".to_string(),
+                    verify_code: DEFAULT_SMS_MOCK_VERIFY_CODE.to_string(),
+                },
+                now + Duration::seconds(1),
+            )
+            .await
+            .expect("orphan phone index should not block phone login");
+
+        assert!(result.created);
+        assert_eq!(
+            result.user.phone_number_masked.as_deref(),
+            Some("138****8032")
+        );
+    }
+
     #[tokio::test]
     async fn password_entry_rejects_email_or_username_identifier() {
         let service = build_password_service(build_store());
diff --git a/server-rs/crates/spacetime-module/src/auth/procedures.rs b/server-rs/crates/spacetime-module/src/auth/procedures.rs
index 8ae86d70..5f93eb01 100644
--- a/server-rs/crates/spacetime-module/src/auth/procedures.rs
+++ b/server-rs/crates/spacetime-module/src/auth/procedures.rs
@@ -454,6 +454,10 @@ fn export_auth_store_snapshot_from_tables_tx(
         .meta_id()
         .find(&AUTH_STORE_PROJECTION_META_ID.to_string())
         .map(|row| row.updated_at.to_micros_since_unix_epoch());
+    let valid_user_ids = users
+        .iter()
+        .map(|user| user.user_id.clone())
+        .collect::<std::collections::HashSet<_>>();
 
     let mut phone_identity_by_user_id = std::collections::HashMap::new();
     let mut phone_to_user_id = std::collections::HashMap::new();
@@ -461,6 +465,10 @@ fn export_auth_store_snapshot_from_tables_tx(
     let mut user_id_by_provider_union_id = std::collections::HashMap::new();
 
     for identity in identities {
+        if !valid_user_ids.contains(&identity.user_id) {
+            continue;
+        }
+
         match identity.provider.as_str() {
             "phone" => {
                 let phone_number = identity
@@ -529,6 +537,10 @@ fn export_auth_store_snapshot_from_tables_tx(
     let mut sessions_by_id = std::collections::HashMap::new();
     let mut session_id_by_refresh_token_hash = std::collections::HashMap::new();
     for session in sessions {
+        if !valid_user_ids.contains(&session.user_id) {
+            continue;
+        }
+
         let client_info = serde_json::from_str::<serde_json::Value>(&session.client_info_json)
             .map_err(|error| format!("refresh session 客户端信� JSON 解�失败：{error}"))?;
         session_id_by_refresh_token_hash.insert(
@@ -693,10 +705,9 @@ mod tests {
 
     #[test]
     fn auth_store_snapshot_user_row_key_is_stable_after_username_change() {
-        let mut before = sample_snapshot();
+        let before = sample_snapshot();
         let mut after = sample_snapshot();
-        after.users_by_username.clear();
-        let mut renamed_user = before
+        let mut renamed_user = after
             .users_by_username
             .remove("phone_42")
             .expect("sample user exists");
diff --git a/server-rs/crates/spacetime-module/src/custom_world.rs b/server-rs/crates/spacetime-module/src/custom_world.rs
index d17c6910..6e88121e 100644
--- a/server-rs/crates/spacetime-module/src/custom_world.rs
+++ b/server-rs/crates/spacetime-module/src/custom_world.rs
@@ -5521,6 +5521,7 @@ mod tests {
                 deleted_at: None,
                 created_at: Timestamp::from_micros_since_unix_epoch(1),
                 updated_at: Timestamp::from_micros_since_unix_epoch(1),
+                visible: true,
             }
         }
 
diff --git a/server-rs/crates/spacetime-module/src/wooden_fish.rs b/server-rs/crates/spacetime-module/src/wooden_fish.rs
index d4dc56de..dbfc0693 100644
--- a/server-rs/crates/spacetime-module/src/wooden_fish.rs
+++ b/server-rs/crates/spacetime-module/src/wooden_fish.rs
@@ -1415,6 +1415,7 @@ mod tests {
                 height: 1536,
             })),
             back_button_asset_json: None,
+            visible: true,
         }
     }
 }
diff --git a/src/components/custom-world-home/CustomWorldCreationHub.interaction.test.tsx b/src/components/custom-world-home/CustomWorldCreationHub.interaction.test.tsx
index 1d0d9680..94a559da 100644
--- a/src/components/custom-world-home/CustomWorldCreationHub.interaction.test.tsx
+++ b/src/components/custom-world-home/CustomWorldCreationHub.interaction.test.tsx
@@ -560,7 +560,7 @@ test('creation hub shows RPG public work code from published library entry', ()
   expect(screen.queryByText('CW-00000001')).toBeNull();
 });
 
-test('creation hub exposes persisted draft delete action directly on the card', () => {
+test('creation hub keeps persisted draft delete action off the card header', () => {
   const { container } = render(
     <CustomWorldCreationHub
       items={[{ ...baseDraftItem, profileId: 'profile-1' }]}
@@ -579,7 +579,7 @@ test('creation hub exposes persisted draft delete action directly on the card',
   expect(
     container.querySelector('.creation-work-card__swipe-underlay'),
   ).toBeTruthy();
-  expect(screen.getByRole('button', { name: '删除' })).toBeTruthy();
+  expect(screen.queryByRole('button', { name: '删除' })).toBeNull();
 });
 
 test('creation hub reveals persisted draft delete action from left swipe', () => {
@@ -641,6 +641,75 @@ test('creation hub reveals persisted draft delete action from keyboard', async (
   expect(screen.queryByRole('button', { name: '分享' })).toBeNull();
 });
 
+test('creation hub reveals persisted draft delete action from long press menu', () => {
+  const { container } = render(
+    <CustomWorldCreationHub
+      items={[{ ...baseDraftItem, profileId: 'profile-1' }]}
+      loading={false}
+      error={null}
+      onRetry={() => {}}
+      onCreateType={noopCreateType}
+      onOpenDraft={() => {}}
+      onEnterPublished={() => {}}
+      onDeletePublished={() => {}}
+      entryConfig={testEntryConfig}
+      creationTypes={testCreationTypes}
+    />,
+  );
+
+  const card = screen.getByRole('button', { name: /继续完善《潮雾列岛》/u });
+  fireEvent.contextMenu(card);
+
+  expect(
+    container.querySelector('.creation-work-card-shell--actions-visible'),
+  ).toBeTruthy();
+  expect(screen.getByRole('button', { name: '删除' })).toBeTruthy();
+});
+
+test('creation hub gives every deletable work card a side delete action', () => {
+  const { container } = render(
+    <CustomWorldCreationHub
+      items={[{ ...baseDraftItem, profileId: 'profile-1' }]}
+      babyObjectMatchItems={[babyObjectMatchDraftItem]}
+      puzzleItems={[
+        {
+          workId: 'puzzle:side-delete',
+          profileId: 'puzzle-profile-side-delete',
+          ownerUserId: 'user-1',
+          authorDisplayName: '拼图作者',
+          levelName: '侧边删除拼图',
+          summary: '����都应有侧边删除。',
+          themeTags: ['�塔'],
+          coverImageSrc: null,
+          publicationStatus: 'draft',
+          updatedAt: new Date('2026-05-02T12:00:00.000Z').toISOString(),
+          publishedAt: null,
+          playCount: 0,
+          remixCount: 0,
+          likeCount: 0,
+          publishReady: true,
+        },
+      ]}
+      loading={false}
+      error={null}
+      onRetry={() => {}}
+      onCreateType={noopCreateType}
+      onOpenDraft={() => {}}
+      onEnterPublished={() => {}}
+      onDeletePublished={() => {}}
+      onDeleteBabyObjectMatch={() => {}}
+      onDeletePuzzle={() => {}}
+      entryConfig={testEntryConfig}
+      creationTypes={testCreationTypes}
+    />,
+  );
+
+  expect(screen.queryByRole('button', { name: '删除' })).toBeNull();
+  expect(
+    container.querySelectorAll('.creation-work-card__swipe-underlay'),
+  ).toHaveLength(3);
+});
+
 test('creation hub shows delete action for baby object match drafts', async () => {
   const user = userEvent.setup();
   const onDeleteBabyObjectMatch = vi.fn();
@@ -719,7 +788,7 @@ test('creation hub works-only tab filters bark battle draft and published works'
   expect(onOpenBarkBattleDetail).toHaveBeenCalledWith(barkBattlePublishedItem);
 });
 
-test('creation hub published work delete action is directly visible', async () => {
+test('creation hub published work delete action stays in revealed side actions', async () => {
   const user = userEvent.setup();
   const onDeletePuzzle = vi.fn();
   const onOpenPuzzleDetail = vi.fn();
@@ -759,9 +828,11 @@ test('creation hub published work delete action is directly visible', async () =
     />,
   );
 
-  expect(screen.getByRole('button', { name: '删除' })).toBeTruthy();
+  expect(screen.queryByRole('button', { name: '删除' })).toBeNull();
   expect(screen.getByRole('button', { name: '分享' })).toBeTruthy();
 
+  screen.getByRole('button', { name: /查看详情《待删拼图》/u }).focus();
+  await user.keyboard('{ArrowLeft}');
   await user.click(screen.getByRole('button', { name: '删除' }));
 
   expect(onDeletePuzzle).toHaveBeenCalledWith(
@@ -770,7 +841,7 @@ test('creation hub published work delete action is directly visible', async () =
   expect(onOpenPuzzleDetail).not.toHaveBeenCalled();
 });
 
-test('creation hub exposes work delete action directly on card', async () => {
+test('creation hub reveals draft work delete action from keyboard', async () => {
   const user = userEvent.setup();
   const onDeletePuzzle = vi.fn();
   const onOpenPuzzleDetail = vi.fn();
@@ -810,6 +881,10 @@ test('creation hub exposes work delete action directly on card', async () => {
     />,
   );
 
+  expect(screen.queryByRole('button', { name: '删除' })).toBeNull();
+
+  screen.getByRole('button', { name: /继续创作《直接删除拼图》/u }).focus();
+  await user.keyboard('{ArrowLeft}');
   await user.click(screen.getByRole('button', { name: '删除' }));
 
   expect(onDeletePuzzle).toHaveBeenCalledWith(
@@ -858,7 +933,9 @@ test('creation hub keeps swipe delete action available', async () => {
     />,
   );
 
-  const card = screen.getByRole('button', { name: /查看详情《左滑删除拼图》/u });
+  const card = screen.getByRole('button', {
+    name: /查看详情《左滑删除拼图》/u,
+  });
   fireEvent.touchStart(card, {
     touches: [{ clientX: 180, clientY: 20 }],
   });
diff --git a/src/components/custom-world-home/CustomWorldCreationHub.tsx b/src/components/custom-world-home/CustomWorldCreationHub.tsx
index 857f9f48..106934ab 100644
--- a/src/components/custom-world-home/CustomWorldCreationHub.tsx
+++ b/src/components/custom-world-home/CustomWorldCreationHub.tsx
@@ -22,6 +22,7 @@ import {
   buildCreationWorkShelfItems,
   type CreationWorkShelfItem,
   type CreationWorkShelfMetricId,
+  type CreationWorkShelfRuntimeState,
 } from './creationWorkShelf';
 import { CustomWorldCreationStartCard } from './CustomWorldCreationStartCard';
 import { CustomWorldWorkCard } from './CustomWorldWorkCard';
@@ -66,7 +67,9 @@ type CustomWorldCreationHubProps = {
   onOpenJumpHopDetail?: (item: JumpHopWorkSummaryResponse) => void;
   onDeleteJumpHop?: ((item: JumpHopWorkSummaryResponse) => void) | null;
   woodenFishItems?: WoodenFishWorkSummaryResponse[];
-  onOpenWoodenFishDetail?: ((item: WoodenFishWorkSummaryResponse) => void) | null;
+  onOpenWoodenFishDetail?:
+    | ((item: WoodenFishWorkSummaryResponse) => void)
+    | null;
   onDeleteWoodenFish?: ((item: WoodenFishWorkSummaryResponse) => void) | null;
   puzzleItems?: PuzzleWorkSummary[];
   onOpenPuzzleDetail?: (item: PuzzleWorkSummary) => void;
@@ -84,7 +87,7 @@ type CustomWorldCreationHubProps = {
   onDeleteVisualNovel?: ((item: VisualNovelWorkSummary) => void) | null;
   getWorkState?: (
     item: CreationWorkShelfItem,
-  ) => { isGenerating?: boolean; hasUnreadUpdate?: boolean } | null;
+  ) => CreationWorkShelfRuntimeState | null;
   onOpenShelfItem?: (item: CreationWorkShelfItem) => void;
   mode?: 'full' | 'start-only' | 'works-only';
 };
diff --git a/src/components/custom-world-home/CustomWorldWorkCard.tsx b/src/components/custom-world-home/CustomWorldWorkCard.tsx
index 00f38323..2f3cc588 100644
--- a/src/components/custom-world-home/CustomWorldWorkCard.tsx
+++ b/src/components/custom-world-home/CustomWorldWorkCard.tsx
@@ -1,5 +1,6 @@
 import {
   BadgeCheck,
+  CircleAlert,
   Clock3,
   Loader2,
   Share2,
@@ -439,11 +440,8 @@ export function CustomWorldWorkCard({
       return;
     }
 
-    updateSwipeOffset(
-      gesture,
-      event.clientX,
-      event.clientY,
-      () => event.preventDefault(),
+    updateSwipeOffset(gesture, event.clientX, event.clientY, () =>
+      event.preventDefault(),
     );
   };
 
@@ -473,9 +471,7 @@ export function CustomWorldWorkCard({
     }
   };
 
-  const beginTouchSwipeGesture = (
-    event: ReactTouchEvent<HTMLDivElement>,
-  ) => {
+  const beginTouchSwipeGesture = (event: ReactTouchEvent<HTMLDivElement>) => {
     if (swipeRevealWidth <= 0) {
       return;
     }
@@ -494,20 +490,15 @@ export function CustomWorldWorkCard({
     };
   };
 
-  const updateTouchSwipeGesture = (
-    event: ReactTouchEvent<HTMLDivElement>,
-  ) => {
+  const updateTouchSwipeGesture = (event: ReactTouchEvent<HTMLDivElement>) => {
     const gesture = swipeGestureRef.current;
     const touch = event.touches[0];
     if (!gesture || gesture.pointerId !== -1 || !touch) {
       return;
     }
 
-    updateSwipeOffset(
-      gesture,
-      touch.clientX,
-      touch.clientY,
-      () => event.preventDefault(),
+    updateSwipeOffset(gesture, touch.clientX, touch.clientY, () =>
+      event.preventDefault(),
     );
   };
 
@@ -676,8 +667,8 @@ export function CustomWorldWorkCard({
                 {displayTitle}
               </span>
             </div>
-            <div className="creation-work-card__quick-actions">
-              {canUseShareAction ? (
+            {canUseShareAction ? (
+              <div className="creation-work-card__quick-actions">
                 <button
                   type="button"
                   onClick={(event) => {
@@ -713,38 +704,8 @@ export function CustomWorldWorkCard({
                 >
                   <Share2 aria-hidden="true" className="h-4 w-4" />
                 </button>
-              ) : null}
-              {onDelete ? (
-                <button
-                  type="button"
-                  onClick={(event) => {
-                    event.stopPropagation();
-                    suppressOpenRef.current = false;
-                    closeSwipeActions();
-                    onDelete();
-                  }}
-                  onKeyDown={(event) => {
-                    event.stopPropagation();
-                  }}
-                  onPointerDown={(event) => {
-                    event.stopPropagation();
-                  }}
-                  onTouchStart={(event) => {
-                    event.stopPropagation();
-                  }}
-                  disabled={deleteBusy}
-                  title={deleteBusy ? '删除中' : '删除作�'}
-                  aria-label={deleteBusy ? '删除中' : '删除'}
-                  className="creation-work-card__quick-action-button creation-work-card__quick-action-button--danger"
-                >
-                  {deleteBusy ? (
-                    <span className="text-xs leading-none">...</span>
-                  ) : (
-                    <Trash2 aria-hidden="true" className="h-4 w-4" />
-                  )}
-                </button>
-              ) : null}
-            </div>
+              </div>
+            ) : null}
           </div>
 
           <div className="creation-work-card__meta platform-category-game-item__meta">
@@ -762,6 +723,16 @@ export function CustomWorldWorkCard({
             {item.summary}
           </div>
 
+          {item.hasGenerationFailure ? (
+            <div
+              aria-label={item.generationFailureSummary ?? '生�失败'}
+              className="creation-work-card__failure-status"
+            >
+              <CircleAlert aria-hidden="true" className="h-3.5 w-3.5" />
+              <span>{item.generationFailureSummary ?? '生�失败'}</span>
+            </div>
+          ) : null}
+
           {isPublished ? (
             <div className="creation-work-card__published-info">
               {item.pointIncentive ? (
diff --git a/src/components/custom-world-home/creationWorkShelf.test.ts b/src/components/custom-world-home/creationWorkShelf.test.ts
index 180e1e7a..e0866d6d 100644
--- a/src/components/custom-world-home/creationWorkShelf.test.ts
+++ b/src/components/custom-world-home/creationWorkShelf.test.ts
@@ -93,7 +93,9 @@ test('buildCreationWorkShelfItems maps wooden fish items with WF public code', (
   expect(items[0]?.sharePath).toContain('/works/detail?work=WF-12345678');
   expect(items[0]?.openActionLabel).toBe('查看详情');
   expect(items[0]?.badges.some((badge) => badge.label === '敲木鱼')).toBe(true);
-  expect(items[0]?.metrics.find((metric) => metric.id === 'play-count')?.value).toBe(9);
+  expect(
+    items[0]?.metrics.find((metric) => metric.id === 'play-count')?.value,
+  ).toBe(9);
   expect(onOpenWoodenFishDetail).toHaveBeenCalledWith(woodenFishWork);
 });
 
@@ -211,9 +213,9 @@ test('buildCreationWorkShelfItems keeps separate bark battle draft and published
   expect(items.find((item) => item.status === 'published')?.id).toBe(
     'BB-PUB00001',
   );
-  expect(items.find((item) => item.status === 'published')?.publicWorkCode).toBe(
-    'BB-PUB00001',
-  );
+  expect(
+    items.find((item) => item.status === 'published')?.publicWorkCode,
+  ).toBe('BB-PUB00001');
 });
 
 test('buildCreationWorkShelfItems falls back to deterministic RPG public work code when library entry is missing', () => {
@@ -303,10 +305,9 @@ test('buildCreationWorkShelfItems gives bark battle draft cover from character o
   expect(items.find((item) => item.id === 'BB-COVER001')?.coverImageSrc).toBe(
     '/draft-player-cover.png',
   );
-  expect(items.find((item) => item.id === 'BB-COVER001')?.coverCharacterImageSrcs).toEqual([
-    '/draft-player-cover.png',
-    '/draft-opponent-cover.png',
-  ]);
+  expect(
+    items.find((item) => item.id === 'BB-COVER001')?.coverCharacterImageSrcs,
+  ).toEqual(['/draft-player-cover.png', '/draft-opponent-cover.png']);
   expect(items.find((item) => item.id === 'BB-COVER002')?.coverImageSrc).toBe(
     '/creation-type-references/bark-battle.webp',
   );
@@ -457,14 +458,76 @@ test('buildCreationWorkShelfItems restores persisted generation state for puzzle
     ],
   });
 
-  expect(items.find((item) => item.kind === 'puzzle')?.isGenerating).toBe(
-    true,
-  );
+  expect(items.find((item) => item.kind === 'puzzle')?.isGenerating).toBe(true);
   expect(items.find((item) => item.kind === 'match3d')?.isGenerating).toBe(
     true,
   );
 });
 
+test('buildCreationWorkShelfItems lets failure notice override persisted generating copy', () => {
+  const items = buildCreationWorkShelfItems({
+    rpgItems: [],
+    bigFishItems: [],
+    puzzleItems: [
+      {
+        workId: 'puzzle:failed-generating',
+        profileId: 'puzzle-profile-failed-generating',
+        ownerUserId: 'user-1',
+        sourceSessionId: 'puzzle-session-failed-generating',
+        authorDisplayName: '测试作者',
+        levelName: '失败拼图',
+        summary: '正在生�拼图�稿。',
+        themeTags: [],
+        coverImageSrc: null,
+        publicationStatus: 'draft',
+        updatedAt: '2026-05-08T00:00:00.000Z',
+        publishedAt: null,
+        publishReady: false,
+        generationStatus: 'generating',
+      },
+    ],
+    getItemState: (item) =>
+      item.kind === 'puzzle'
+        ? {
+            isGenerating: false,
+            suppressPersistedGenerating: true,
+            summaryOverride: '拼图�稿生�失败，��新打开处�。',
+          }
+        : null,
+  });
+
+  expect(items[0]?.isGenerating).toBe(false);
+  expect(items[0]?.summary).toBe('拼图�稿生�失败，��新打开处�。');
+});
+
+test('persisted failed puzzle draft is not treated as generating', () => {
+  const items = buildCreationWorkShelfItems({
+    rpgItems: [],
+    bigFishItems: [],
+    puzzleItems: [
+      {
+        workId: 'puzzle:failed',
+        profileId: 'puzzle-profile-failed',
+        ownerUserId: 'user-1',
+        sourceSessionId: 'puzzle-session-failed',
+        authorDisplayName: '测试作者',
+        levelName: '失败拼图',
+        summary: '�务端已回写失败。',
+        themeTags: [],
+        coverImageSrc: null,
+        publicationStatus: 'draft',
+        updatedAt: '2026-05-08T00:00:00.000Z',
+        publishedAt: null,
+        publishReady: false,
+        generationStatus: 'failed',
+      },
+    ],
+  });
+
+  expect(items[0]?.isGenerating).toBeFalsy();
+  expect(items[0]?.summary).toBe('�务端已回写失败。');
+});
+
 test('buildCreationWorkShelfItems maps baby object match local drafts', () => {
   const onOpenBabyObjectMatchDetail = vi.fn();
   const onDeleteBabyObjectMatch = vi.fn();
@@ -1088,7 +1151,6 @@ test('bark battle draft generating state only follows pending assets', () => {
   ).toBe(false);
 });
 
-
 test('CustomWorldWorkCard hides author on shelf draft and published cards', () => {
   const buildItem = (
     status: CreationWorkShelfItem['status'],
@@ -1110,7 +1172,11 @@ test('CustomWorldWorkCard hides author on shelf draft and published cards', () =
     canDelete: false,
     canShare: false,
     badges: [
-      { id: 'status', label: status === 'draft' ? '�稿' : '已�布', tone: 'neutral' },
+      {
+        id: 'status',
+        label: status === 'draft' ? '�稿' : '已�布',
+        tone: 'neutral',
+      },
       { id: 'type', label: '汪汪', tone: 'neutral' },
     ],
     metrics: [],
diff --git a/src/components/custom-world-home/creationWorkShelf.ts b/src/components/custom-world-home/creationWorkShelf.ts
index 81300a53..70c03d55 100644
--- a/src/components/custom-world-home/creationWorkShelf.ts
+++ b/src/components/custom-world-home/creationWorkShelf.ts
@@ -125,6 +125,8 @@ export type CreationWorkShelfItem = {
   kind: CreationWorkShelfKind;
   status: CreationWorkShelfStatus;
   isGenerating?: boolean;
+  hasGenerationFailure?: boolean;
+  generationFailureSummary?: string;
   hasUnreadUpdate?: boolean;
   title: string;
   summary: string;
@@ -145,6 +147,16 @@ export type CreationWorkShelfItem = {
   source: CreationWorkShelfSource;
 };
 
+export type CreationWorkShelfRuntimeState = {
+  isGenerating?: boolean;
+  hasGenerationFailure?: boolean;
+  generationFailureSummary?: string;
+  hasUnreadUpdate?: boolean;
+  suppressPersistedGenerating?: boolean;
+  titleOverride?: string;
+  summaryOverride?: string;
+};
+
 export function buildCreationWorkShelfItems(params: {
   rpgItems: CustomWorldWorkSummary[];
   rpgLibraryEntries?: CustomWorldLibraryEntry<CustomWorldProfile>[];
@@ -191,7 +203,7 @@ export function buildCreationWorkShelfItems(params: {
   onDeleteVisualNovel?: (item: VisualNovelWorkSummary) => void;
   getItemState?: (
     item: CreationWorkShelfItem,
-  ) => { isGenerating?: boolean; hasUnreadUpdate?: boolean } | null;
+  ) => CreationWorkShelfRuntimeState | null;
 }) {
   const {
     rpgItems,
@@ -307,18 +319,24 @@ export function buildCreationWorkShelfItems(params: {
     .map((item) => {
       const state = getItemState?.(item);
       const persistedIsGenerating = isPersistedCreationWorkGenerating(item);
-      return state
+      const isGenerating = Boolean(
+        state?.isGenerating ||
+          (!state?.suppressPersistedGenerating && persistedIsGenerating),
+      );
+      return state || isGenerating
         ? {
             ...item,
-            isGenerating: Boolean(state.isGenerating || persistedIsGenerating),
-            hasUnreadUpdate: state.hasUnreadUpdate,
+            title: state?.titleOverride ?? item.title,
+            summary: state?.summaryOverride ?? item.summary,
+            isGenerating,
+            hasGenerationFailure:
+              state?.hasGenerationFailure ?? item.hasGenerationFailure,
+            generationFailureSummary:
+              state?.generationFailureSummary ??
+              item.generationFailureSummary,
+            hasUnreadUpdate: state?.hasUnreadUpdate,
           }
-        : persistedIsGenerating
-          ? {
-              ...item,
-              isGenerating: true,
-            }
-          : item;
+        : item;
     })
     .sort(
       (left, right) =>
@@ -327,7 +345,6 @@ export function buildCreationWorkShelfItems(params: {
     );
 }
 
-
 function mergeBarkBattleShelfSourceItems(
   items: readonly BarkBattleWorkSummary[],
 ): BarkBattleWorkSummary[] {
@@ -376,8 +393,8 @@ function mapRpgWorkToShelfItem(
     : null;
   const publicWorkCode =
     item.status === 'published'
-      ? (libraryEntry?.publicWorkCode?.trim() ||
-          (item.profileId ? buildCustomWorldPublicWorkCode(item.profileId) : null))
+      ? libraryEntry?.publicWorkCode?.trim() ||
+        (item.profileId ? buildCustomWorldPublicWorkCode(item.profileId) : null)
       : null;
   const badges: CreationWorkShelfBadge[] = [
     buildStatusBadge(item.status),
@@ -843,7 +860,9 @@ function mapWoodenFishWorkToShelfItem(
 ): CreationWorkShelfItem {
   const status = item.publicationStatus === 'published' ? 'published' : 'draft';
   const publicWorkCode =
-    status === 'published' ? buildWoodenFishPublicWorkCode(item.profileId) : null;
+    status === 'published'
+      ? buildWoodenFishPublicWorkCode(item.profileId)
+      : null;
   const title = item.workTitle.trim() || '敲木鱼';
   const summary =
     item.workDescription.trim() || (status === 'draft' ? '未填写作��述' : '');
@@ -884,10 +903,7 @@ function mapWoodenFishWorkToShelfItem(
   };
 }
 
-
-function resolveAuthorDisplayName(
-  ...sources: Array<unknown>
-) {
+function resolveAuthorDisplayName(...sources: Array<unknown>) {
   for (const source of sources) {
     const authorDisplayName =
       source &&
@@ -961,7 +977,8 @@ export function resolvePuzzleLevelCoverImageSrc(
   const fallbackCandidateImageSrc = normalizeCoverImageSrc(
     level.candidates[level.candidates.length - 1]?.imageSrc,
   );
-  const candidateImageSrc = selectedCandidateImageSrc || fallbackCandidateImageSrc;
+  const candidateImageSrc =
+    selectedCandidateImageSrc || fallbackCandidateImageSrc;
 
   if (
     candidateImageSrc &&
@@ -984,7 +1001,9 @@ function resolveMatch3DWorkCoverImageSrc(item: Match3DWorkSummary) {
 
   const topLevelContainerImageSrc =
     normalizeCoverImageSrc(item.generatedBackgroundAsset?.containerImageSrc) ||
-    normalizeCoverImageSrc(item.generatedBackgroundAsset?.containerImageObjectKey);
+    normalizeCoverImageSrc(
+      item.generatedBackgroundAsset?.containerImageObjectKey,
+    );
   if (topLevelContainerImageSrc) {
     return topLevelContainerImageSrc;
   }
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index 1df46027..ba1edf6a 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -77,6 +77,7 @@ import type { PuzzleWorkSummary } from '../../../packages/shared/src/contracts/p
 import type {
   CustomWorldGalleryCard,
   CustomWorldLibraryEntry,
+  ProfileDashboardSummary,
   ProfilePlayedWorkSummary,
   ProfilePlayStatsResponse,
   ProfileSaveArchiveResumeResponse,
@@ -447,11 +448,12 @@ type AgentResultPublishGateView = {
   blockers: string[];
   publishReady: boolean;
 };
-type DraftGenerationNoticeStatus = 'generating' | 'ready';
+type DraftGenerationNoticeStatus = 'generating' | 'ready' | 'failed';
 type DraftGenerationNotice = {
   status: DraftGenerationNoticeStatus;
   seen: boolean;
   completedAtMs?: number;
+  message?: string;
 };
 type DraftGenerationNoticeMap = Record<string, DraftGenerationNotice>;
 type CreationWorkShelfKind = CreationWorkShelfItem['kind'];
@@ -459,6 +461,8 @@ type PendingDraftShelfState = {
   status: DraftGenerationNoticeStatus;
   seen: boolean;
   updatedAt: string;
+  title?: string;
+  summary?: string;
 };
 type PendingDraftShelfMap = Partial<
   Record<
@@ -1960,6 +1964,39 @@ function buildJumpHopCreationUrlState(params: {
   };
 }
 
+function buildJumpHopPendingSession(
+  item: JumpHopWorkSummaryResponse,
+): JumpHopSessionSnapshotResponse {
+  const sessionId =
+    normalizeCreationUrlValue(item.sourceSessionId) ?? item.profileId;
+  return {
+    sessionId,
+    ownerUserId: item.ownerUserId,
+    status: item.generationStatus,
+    draft: {
+      templateId: 'jump-hop',
+      templateName: '跳一跳',
+      profileId: item.profileId,
+      workTitle: item.workTitle,
+      workDescription: item.workDescription,
+      themeTags: item.themeTags,
+      difficulty: item.difficulty,
+      stylePreset: item.stylePreset,
+      characterPrompt: '',
+      tilePrompt: '',
+      endMoodPrompt: null,
+      characterAsset: null,
+      tileAtlasAsset: null,
+      tileAssets: [],
+      path: null,
+      coverComposite: item.coverImageSrc,
+      generationStatus: item.generationStatus,
+    },
+    createdAt: item.updatedAt,
+    updatedAt: item.updatedAt,
+  };
+}
+
 function buildWoodenFishCreationUrlState(params: {
   session?: WoodenFishSessionSnapshotResponse | null;
   work?: WoodenFishWorkProfileResponse | null;
@@ -2069,15 +2106,37 @@ function normalizeDraftNoticeId(id: string | null | undefined) {
   return id?.trim() || null;
 }
 
+function normalizePendingDraftShelfLookupId(
+  kind: Exclude<CreationWorkShelfKind, 'rpg'>,
+  id: string | null | undefined,
+) {
+  const normalizedId = normalizeDraftNoticeId(id);
+  if (!normalizedId) {
+    return null;
+  }
+
+  const noticePrefix = `${kind}:`;
+  if (!normalizedId.startsWith(noticePrefix)) {
+    return normalizedId;
+  }
+
+  return normalizeDraftNoticeId(normalizedId.slice(noticePrefix.length));
+}
+
 function createPendingDraftShelfState(
   status: DraftGenerationNoticeStatus,
   seen = false,
   updatedAt = new Date().toISOString(),
+  metadata?: { title?: string | null; summary?: string | null },
 ): PendingDraftShelfState {
+  const title = metadata?.title?.trim();
+  const summary = metadata?.summary?.trim();
   return {
     status,
     seen,
     updatedAt,
+    ...(title ? { title } : {}),
+    ...(summary ? { summary } : {}),
   };
 }
 
@@ -2096,6 +2155,46 @@ function formatPlatformTaskCompletionSource(label: string, id?: string | null) {
   return normalizedId ? `${label} ${normalizedId}` : label;
 }
 
+function isBackgroundGenerationStillRunningMessage(message: string) {
+  return /�在��处�|���在处�|�在生�|��生�/u.test(message);
+}
+
+function buildDraftFailedShelfSummary(kind: CreationWorkShelfKind) {
+  switch (kind) {
+    case 'puzzle':
+      return '拼图�稿生�失败，��新打开处�。';
+    case 'match3d':
+      return '玩法素�生�失败，��新打开处�。';
+    case 'big-fish':
+      return '�稿生�失败，��新打开处�。';
+    case 'square-hole':
+      return '挑战素�生�失败，��新打开处�。';
+    case 'jump-hop':
+      return '跳一跳玩法�稿生�失败，��新打开处�。';
+    case 'wooden-fish':
+      return '敲木鱼�稿生�失败，��新打开处�。';
+    case 'visual-novel':
+      return '视觉�说�稿生�失败，��新打开处�。';
+    case 'bark-battle':
+      return '声浪竞技素�生�失败，��新打开处�。';
+    case 'baby-object-match':
+      return '��识物�稿生�失败，��新打开处�。';
+    default:
+      return '�稿生�失败，��新打开处�。';
+  }
+}
+
+function isDraftShelfSummaryPlaceholder(value: string | null | undefined) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return true;
+  }
+
+  return /^(正在生�|.*生�失败，��新打开处�。$|未填写作��述$)/u.test(
+    normalized,
+  );
+}
+
 function buildPlatformErrorDialogDismissKey(
   error: (PlatformErrorDialogPayload & { key: string }) | null,
 ) {
@@ -2165,32 +2264,119 @@ function buildDraftCompletionDialogSource(
 function createMiniGameDraftGenerationStateForRestoredDraft(
   kind: MiniGameDraftGenerationKind,
   metadata?: MiniGameDraftGenerationState['metadata'],
+  startedAtMs = Date.now(),
 ): MiniGameDraftGenerationState {
   return {
-    ...createMiniGameDraftGenerationState(kind),
+    ...createMiniGameDraftGenerationState(kind, startedAtMs),
     ...(metadata ? { metadata } : {}),
   };
 }
 
+function createFailedMiniGameDraftGenerationStateForRestoredDraft(
+  kind: MiniGameDraftGenerationKind,
+  updatedAt: string | null | undefined,
+  error: string,
+  metadata?: MiniGameDraftGenerationState['metadata'],
+): MiniGameDraftGenerationState {
+  return resolveFinishedMiniGameDraftGenerationState(
+    createMiniGameDraftGenerationStateForRestoredDraft(
+      kind,
+      metadata,
+      resolveMiniGameDraftGenerationStartedAtMs(updatedAt),
+    ),
+    'failed',
+    { error },
+  );
+}
+
+function buildPuzzleFormPayloadFromWork(
+  item: PuzzleWorkSummary,
+): CreatePuzzleAgentSessionRequest {
+  const pictureDescription =
+    item.workDescription?.trim() ||
+    item.summary?.trim() ||
+    item.levels?.[0]?.pictureDescription?.trim() ||
+    item.levelName?.trim() ||
+    item.workTitle?.trim() ||
+    '';
+
+  return {
+    seedText: pictureDescription,
+    workTitle: item.workTitle?.trim() || item.levelName?.trim() || undefined,
+    workDescription: item.workDescription?.trim() || item.summary?.trim(),
+    pictureDescription,
+    referenceImageSrc: null,
+    referenceImageSrcs: [],
+    referenceImageAssetObjectId: null,
+    referenceImageAssetObjectIds: [],
+    imageModel: null,
+    aiRedraw: true,
+  };
+}
+
+function parseOptionalFiniteNumber(value: string | number | null | undefined) {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  const normalizedValue = value?.trim();
+  if (!normalizedValue) {
+    return undefined;
+  }
+
+  const parsedValue = Number(normalizedValue);
+  return Number.isFinite(parsedValue) ? parsedValue : undefined;
+}
+
+function buildMatch3DFormPayloadFromSession(
+  session: Match3DAgentSessionSnapshot,
+): CreateMatch3DSessionRequest {
+  const themeText =
+    session.config?.themeText?.trim() ||
+    session.draft?.themeText?.trim() ||
+    session.anchorPack.theme.value.trim() ||
+    '';
+
+  return {
+    seedText: themeText,
+    themeText,
+    referenceImageSrc:
+      session.config?.referenceImageSrc ?? session.draft?.referenceImageSrc ?? null,
+    clearCount:
+      session.config?.clearCount ??
+      session.draft?.clearCount ??
+      parseOptionalFiniteNumber(session.anchorPack.clearCount.value) ??
+      undefined,
+    difficulty:
+      session.config?.difficulty ??
+      session.draft?.difficulty ??
+      parseOptionalFiniteNumber(session.anchorPack.difficulty.value) ??
+      undefined,
+    assetStyleId: session.config?.assetStyleId ?? null,
+    assetStyleLabel: session.config?.assetStyleLabel ?? null,
+    assetStylePrompt: session.config?.assetStylePrompt ?? null,
+    generateClickSound: session.config?.generateClickSound,
+  };
+}
+
+function buildMatch3DFormPayloadFromWork(
+  item: Match3DWorkSummary,
+): CreateMatch3DSessionRequest {
+  const themeText = item.themeText?.trim() || item.gameName?.trim() || '';
+  return {
+    seedText: themeText,
+    themeText,
+    referenceImageSrc: item.referenceImageSrc ?? null,
+    clearCount: item.clearCount,
+    difficulty: item.difficulty,
+  };
+}
+
 function rebaseMiniGameDraftGenerationStateForDisplay(
   state: MiniGameDraftGenerationState,
 ): MiniGameDraftGenerationState {
-  const rebasedStartedAtMs = Date.now();
-
-  if (state.kind === 'puzzle') {
-    const puzzleAiRedraw = state.metadata?.puzzleAiRedraw;
-    return {
-      ...state,
-      startedAtMs: rebasedStartedAtMs,
-      finishedAtMs: undefined,
-      metadata:
-        typeof puzzleAiRedraw === 'boolean' ? { puzzleAiRedraw } : undefined,
-    };
-  }
-
   return {
     ...state,
-    startedAtMs: rebasedStartedAtMs,
     finishedAtMs: undefined,
   };
 }
@@ -2458,6 +2644,11 @@ function isPersistedDraftGenerating(value: string | null | undefined) {
   return value?.trim() === 'generating';
 }
 
+function isPersistedDraftFailed(value: string | null | undefined) {
+  const normalized = value?.trim();
+  return normalized === 'failed' || normalized === 'partial_failed';
+}
+
 function resolveProfileWalletBalance(
   dashboard: { walletBalance?: number | null } | null | undefined,
 ) {
@@ -2467,6 +2658,51 @@ function resolveProfileWalletBalance(
     : 0;
 }
 
+function adjustProfileDashboardWalletBalance(
+  dashboard: ProfileDashboardSummary | null,
+  delta: number,
+): ProfileDashboardSummary | null {
+  if (!dashboard || !Number.isFinite(delta) || delta === 0) {
+    return dashboard;
+  }
+
+  return {
+    ...dashboard,
+    walletBalance: Math.max(
+      0,
+      resolveProfileWalletBalance(dashboard) + Math.trunc(delta),
+    ),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function reconcileProfileWalletLocalDeltaWithServerDashboard(
+  previousDashboard: ProfileDashboardSummary | null,
+  latestDashboard: ProfileDashboardSummary | null,
+  localDelta: number,
+) {
+  if (
+    !previousDashboard ||
+    !latestDashboard ||
+    !Number.isFinite(localDelta) ||
+    localDelta === 0
+  ) {
+    return Number.isFinite(localDelta) ? Math.trunc(localDelta) : 0;
+  }
+
+  const previousBalance = resolveProfileWalletBalance(previousDashboard);
+  const latestBalance = resolveProfileWalletBalance(latestDashboard);
+  const normalizedDelta = Math.trunc(localDelta);
+
+  if (normalizedDelta < 0) {
+    const reflectedDebit = Math.max(0, previousBalance - latestBalance);
+    return Math.min(0, normalizedDelta + reflectedDebit);
+  }
+
+  const reflectedCredit = Math.max(0, latestBalance - previousBalance);
+  return Math.max(0, normalizedDelta - reflectedCredit);
+}
+
 function buildPendingBigFishWorks(
   pending: Record<string, PendingDraftShelfState> | undefined,
   existingItems: readonly BigFishWorkSummary[],
@@ -2479,27 +2715,32 @@ function buildPendingBigFishWorks(
     .filter(([sessionId]) =>
       existingItems.every((item) => item.sourceSessionId !== sessionId),
     )
-    .map(([sessionId, state]) => ({
-      workId: `big-fish-work-${sessionId}`,
-      sourceSessionId: sessionId,
-      ownerUserId: '',
-      authorDisplayName: '',
-      title: '大鱼��鱼�稿',
-      subtitle: '�稿生�中',
-      summary: '正在生�玩法�稿。',
-      coverImageSrc: null,
-      status: 'draft',
-      updatedAt: state.updatedAt,
-      publishedAt: null,
-      publishReady: false,
-      levelCount: 0,
-      levelMainImageReadyCount: 0,
-      levelMotionReadyCount: 0,
-      backgroundReady: false,
-      playCount: 0,
-      remixCount: 0,
-      likeCount: 0,
-    }));
+    .map(([sessionId, state]) => {
+      const isFailed = state.status === 'failed';
+      return {
+        workId: `big-fish-work-${sessionId}`,
+        sourceSessionId: sessionId,
+        ownerUserId: '',
+        authorDisplayName: '',
+        title: '大鱼��鱼�稿',
+        subtitle: isFailed ? '生�失败待�试' : '�稿生�中',
+        summary: isFailed
+          ? '�稿生�失败，��新打开处�。'
+          : '正在生�玩法�稿。',
+        coverImageSrc: null,
+        status: 'draft',
+        updatedAt: state.updatedAt,
+        publishedAt: null,
+        publishReady: false,
+        levelCount: 0,
+        levelMainImageReadyCount: 0,
+        levelMotionReadyCount: 0,
+        backgroundReady: false,
+        playCount: 0,
+        remixCount: 0,
+        likeCount: 0,
+      };
+    });
 }
 
 function buildPendingJumpHopWorks(
@@ -2514,25 +2755,36 @@ function buildPendingJumpHopWorks(
     .filter(([sessionId]) =>
       existingItems.every((item) => item.sourceSessionId !== sessionId),
     )
-    .map(([sessionId, state]) => ({
-      runtimeKind: 'jump-hop',
-      workId: `jump-hop-work-${sessionId}`,
-      profileId: `jump-hop-profile-${sessionId}`,
-      ownerUserId: '',
-      sourceSessionId: sessionId,
-      workTitle: '跳一跳�稿',
-      workDescription: '正在生�跳一跳玩法�稿。',
-      themeTags: [],
-      difficulty: 'standard',
-      stylePreset: 'minimal-blocks',
-      coverImageSrc: null,
-      publicationStatus: 'draft',
-      playCount: 0,
-      updatedAt: state.updatedAt,
-      publishedAt: null,
-      publishReady: false,
-      generationStatus: state.status === 'generating' ? 'generating' : 'ready',
-    }));
+    .map(([sessionId, state]) => {
+      const generationStatus =
+        state.status === 'failed'
+          ? 'failed'
+          : state.status === 'generating'
+            ? 'generating'
+            : 'ready';
+      return {
+        runtimeKind: 'jump-hop',
+        workId: `jump-hop-work-${sessionId}`,
+        profileId: `jump-hop-profile-${sessionId}`,
+        ownerUserId: '',
+        sourceSessionId: sessionId,
+        workTitle: '跳一跳�稿',
+        workDescription:
+          state.status === 'failed'
+            ? '跳一跳玩法�稿生�失败，��新打开处�。'
+            : '正在生�跳一跳玩法�稿。',
+        themeTags: [],
+        difficulty: 'standard',
+        stylePreset: 'minimal-blocks',
+        coverImageSrc: null,
+        publicationStatus: 'draft',
+        playCount: 0,
+        updatedAt: state.updatedAt,
+        publishedAt: null,
+        publishReady: false,
+        generationStatus,
+      };
+    });
 }
 
 function buildPendingWoodenFishWorks(
@@ -2547,23 +2799,34 @@ function buildPendingWoodenFishWorks(
     .filter(([sessionId]) =>
       existingItems.every((item) => item.sourceSessionId !== sessionId),
     )
-    .map(([sessionId, state]) => ({
-      runtimeKind: 'wooden-fish',
-      workId: `wooden-fish-work-${sessionId}`,
-      profileId: sessionId,
-      ownerUserId: '',
-      sourceSessionId: sessionId,
-      workTitle: '敲木鱼�稿',
-      workDescription: '正在生�敲木鱼�稿。',
-      themeTags: ['敲木鱼'],
-      coverImageSrc: null,
-      publicationStatus: 'draft',
-      playCount: 0,
-      updatedAt: state.updatedAt,
-      publishedAt: null,
-      publishReady: false,
-      generationStatus: state.status === 'generating' ? 'generating' : 'ready',
-    }));
+    .map(([sessionId, state]) => {
+      const generationStatus =
+        state.status === 'failed'
+          ? 'failed'
+          : state.status === 'generating'
+            ? 'generating'
+            : 'ready';
+      return {
+        runtimeKind: 'wooden-fish',
+        workId: `wooden-fish-work-${sessionId}`,
+        profileId: sessionId,
+        ownerUserId: '',
+        sourceSessionId: sessionId,
+        workTitle: '敲木鱼�稿',
+        workDescription:
+          state.status === 'failed'
+            ? '敲木鱼�稿生�失败，��新打开处�。'
+            : '正在生�敲木鱼�稿。',
+        themeTags: ['敲木鱼'],
+        coverImageSrc: null,
+        publicationStatus: 'draft',
+        playCount: 0,
+        updatedAt: state.updatedAt,
+        publishedAt: null,
+        publishReady: false,
+        generationStatus,
+      };
+    });
 }
 
 function buildPendingMatch3DWorks(
@@ -2578,27 +2841,39 @@ function buildPendingMatch3DWorks(
     .filter(([sessionId]) =>
       existingItems.every((item) => item.sourceSessionId !== sessionId),
     )
-    .map(([sessionId, state]) => ({
-      workId: `match3d-work-${sessionId}`,
-      profileId: sessionId,
-      ownerUserId: '',
-      sourceSessionId: sessionId,
-      gameName: '抓大鹅�稿',
-      themeText: '',
-      summary: '正在生�玩法素�。',
-      tags: [],
-      coverImageSrc: null,
-      referenceImageSrc: null,
-      clearCount: 0,
-      difficulty: 0,
-      publicationStatus: 'draft',
-      playCount: 0,
-      updatedAt: state.updatedAt,
-      publishedAt: null,
-      publishReady: false,
-      generationStatus: state.status === 'generating' ? 'generating' : 'ready',
-      generatedItemAssets: [],
-    }));
+    .map(([sessionId, state]) => {
+      const themeText = state.summary?.trim() || state.title?.trim() || '';
+      const fallbackSummary =
+        state.status === 'failed'
+          ? '玩法素�生�失败，��新打开处�。'
+          : '正在生�玩法素�。';
+      return {
+        workId: `match3d-work-${sessionId}`,
+        profileId: sessionId,
+        ownerUserId: '',
+        sourceSessionId: sessionId,
+        gameName: '抓大鹅�稿',
+        themeText,
+        summary: themeText || fallbackSummary,
+        tags: [],
+        coverImageSrc: null,
+        referenceImageSrc: null,
+        clearCount: 0,
+        difficulty: 0,
+        publicationStatus: 'draft',
+        playCount: 0,
+        updatedAt: state.updatedAt,
+        publishedAt: null,
+        publishReady: false,
+        generationStatus:
+          state.status === 'failed'
+            ? 'failed'
+            : state.status === 'generating'
+              ? 'generating'
+              : 'ready',
+        generatedItemAssets: [],
+      };
+    });
 }
 
 function buildPendingSquareHoleWorks(
@@ -2621,7 +2896,10 @@ function buildPendingSquareHoleWorks(
       gameName: '方洞挑战�稿',
       themeText: '',
       twistRule: '',
-      summary: '正在生�挑战素�。',
+      summary:
+        state.status === 'failed'
+          ? '挑战素�生�失败，��新打开处�。'
+          : '正在生�挑战素�。',
       tags: [],
       coverImageSrc: null,
       backgroundPrompt: '',
@@ -2653,6 +2931,12 @@ function buildPendingPuzzleWorks(
     .map(([sessionId, state]) => {
       const profileId =
         buildPuzzleResultProfileId(sessionId) ?? `puzzle-profile-${sessionId}`;
+      const title = state.title?.trim() || '拼图�稿';
+      const summary =
+        state.summary?.trim() ||
+        (state.status === 'failed'
+          ? '拼图�稿生�失败，��新打开处�。'
+          : '正在生�拼图�稿。');
       return {
         workId:
           buildPuzzleResultWorkId(sessionId) ?? `puzzle-work-${sessionId}`,
@@ -2660,10 +2944,10 @@ function buildPendingPuzzleWorks(
         ownerUserId: '',
         sourceSessionId: sessionId,
         authorDisplayName: '',
-        workTitle: '拼图�稿',
-        workDescription: '正在生�拼图�稿。',
-        levelName: '拼图�稿',
-        summary: '正在生�拼图�稿。',
+        workTitle: title,
+        workDescription: summary,
+        levelName: title,
+        summary,
         themeTags: [],
         coverImageSrc: null,
         coverAssetId: null,
@@ -2675,7 +2959,11 @@ function buildPendingPuzzleWorks(
         likeCount: 0,
         publishReady: false,
         generationStatus:
-          state.status === 'generating' ? 'generating' : 'ready',
+          state.status === 'generating'
+            ? 'generating'
+            : state.status === 'failed'
+              ? 'failed'
+              : 'ready',
         levels: [],
       };
     });
@@ -2698,7 +2986,10 @@ function buildPendingVisualNovelWorks(
       profileId,
       ownerUserId: '',
       title: '视觉�说�稿',
-      description: '正在生�视觉�说�稿。',
+      description:
+        state.status === 'failed'
+          ? '视觉�说�稿生�失败，��新打开处�。'
+          : '正在生�视觉�说�稿。',
       coverImageSrc: null,
       tags: [],
       publishStatus: 'draft',
@@ -2727,7 +3018,10 @@ function buildPendingBarkBattleWorks(
       ownerUserId: '',
       authorDisplayName: '',
       title: '汪汪声浪�稿',
-      summary: '正在生�声浪竞技素�。',
+      summary:
+        state.status === 'failed'
+          ? '声浪竞技素�生�失败，��新打开处�。'
+          : '正在生�声浪竞技素�。',
       themeDescription: '',
       playerImageDescription: '',
       opponentImageDescription: '',
@@ -2738,7 +3032,11 @@ function buildPendingBarkBattleWorks(
       difficultyPreset: 'normal',
       status: 'draft',
       generationStatus:
-        state.status === 'generating' ? 'pending_assets' : 'ready',
+        state.status === 'generating'
+          ? 'pending_assets'
+          : state.status === 'failed'
+            ? 'partial_failed'
+            : 'ready',
       publishReady: false,
       playCount: 0,
       updatedAt: state.updatedAt,
@@ -2751,10 +3049,14 @@ function buildPuzzleCompileActionFromFormPayload(
 ): PuzzleAgentActionRequest {
   const pictureDescription =
     payload?.pictureDescription?.trim() || payload?.seedText?.trim();
+  const workTitle = payload?.workTitle?.trim();
+  const workDescription = payload?.workDescription?.trim() || pictureDescription;
 
   return {
     action: 'compile_puzzle_draft',
     promptText: pictureDescription,
+    ...(workTitle ? { workTitle } : {}),
+    ...(workDescription ? { workDescription } : {}),
     ...(pictureDescription ? { pictureDescription } : {}),
     referenceImageSrc: payload?.referenceImageSrc || null,
     referenceImageSrcs: payload?.referenceImageSrcs ?? [],
@@ -2776,9 +3078,18 @@ function buildPuzzleFormPayloadFromSession(
     session.anchorPack.visualSubject.value.trim() ||
     session.seedText?.trim() ||
     '';
+  const workTitle =
+    formDraft?.workTitle?.trim() || session.draft?.workTitle?.trim();
+  const workDescription =
+    formDraft?.workDescription?.trim() ||
+    session.draft?.workDescription?.trim() ||
+    session.draft?.summary?.trim() ||
+    pictureDescription;
 
   return {
     seedText: pictureDescription,
+    ...(workTitle ? { workTitle } : {}),
+    ...(workDescription ? { workDescription } : {}),
     pictureDescription,
     referenceImageSrc: null,
     referenceImageSrcs: [],
@@ -2789,6 +3100,29 @@ function buildPuzzleFormPayloadFromSession(
   };
 }
 
+function buildPendingPuzzleDraftMetadata(
+  payload: CreatePuzzleAgentSessionRequest | null | undefined,
+) {
+  const title = payload?.workTitle?.trim();
+  const summary =
+    payload?.workDescription?.trim() ||
+    payload?.pictureDescription?.trim() ||
+    payload?.seedText?.trim();
+  return {
+    ...(title ? { title } : {}),
+    ...(summary ? { summary } : {}),
+  };
+}
+
+function buildPendingMatch3DDraftMetadata(
+  payload: CreateMatch3DSessionRequest | null | undefined,
+) {
+  const themeText = payload?.themeText?.trim() || payload?.seedText?.trim();
+  return {
+    ...(themeText ? { title: themeText, summary: themeText } : {}),
+  };
+}
+
 function buildPuzzleFormPayloadFromAction(
   payload: PuzzleAgentActionRequest,
 ): CreatePuzzleAgentSessionRequest | null {
@@ -3531,6 +3865,9 @@ export function PlatformEntryFlowShellImpl({
     useState<DraftGenerationNoticeMap>({});
   const [pendingDraftShelfItems, setPendingDraftShelfItems] =
     useState<PendingDraftShelfMap>({});
+  const profileWalletLocalDeltaRef = useRef(0);
+  const lastProfileDashboardSnapshotRef =
+    useRef<ProfileDashboardSummary | null>(null);
   const [
     pendingPlatformTaskCompletionDialog,
     setPendingPlatformTaskCompletionDialog,
@@ -3541,6 +3878,16 @@ export function PlatformEntryFlowShellImpl({
       })
     | null
   >(null);
+  const [
+    pendingPlatformTaskFailureDialog,
+    setPendingPlatformTaskFailureDialog,
+  ] = useState<
+    | (PlatformErrorDialogPayload & {
+        key: string;
+        failedAtMs: number;
+      })
+    | null
+  >(null);
   const [profileTaskRefreshKey, setProfileTaskRefreshKey] = useState(0);
   const [initialCreationUrlState] = useState(() => readCreationUrlState());
   const handledInitialCreationUrlStateRef = useRef(false);
@@ -3569,6 +3916,7 @@ export function PlatformEntryFlowShellImpl({
       id: string | null | undefined,
       status: DraftGenerationNoticeStatus,
       seen = false,
+      metadata?: { title?: string | null; summary?: string | null },
     ) => {
       const normalizedId = normalizeDraftNoticeId(id);
       if (!normalizedId) {
@@ -3577,10 +3925,18 @@ export function PlatformEntryFlowShellImpl({
 
       setPendingDraftShelfItems((current) => ({
         ...current,
-        [kind]: {
-          ...(current[kind] ?? {}),
-          [normalizedId]: createPendingDraftShelfState(status, seen),
-        },
+        [kind]: (() => {
+          const currentItems = current[kind] ?? {};
+          return {
+            ...currentItems,
+            [normalizedId]: createPendingDraftShelfState(
+              status,
+              seen,
+              new Date().toISOString(),
+              metadata ?? currentItems[normalizedId],
+            ),
+          };
+        })(),
       }));
     },
     [],
@@ -3613,20 +3969,35 @@ export function PlatformEntryFlowShellImpl({
   );
 
   const updateDraftGenerationNotices = useCallback(
-    (keys: string[], status: DraftGenerationNoticeStatus, seen = false) => {
+    (
+      keys: string[],
+      status: DraftGenerationNoticeStatus,
+      seen = false,
+      message?: string | null,
+    ) => {
       const uniqueKeys = Array.from(new Set(keys.filter(Boolean)));
       if (uniqueKeys.length === 0) {
         return;
       }
 
       const completedAtMs = status === 'ready' ? Date.now() : undefined;
+      const normalizedMessage = message?.trim();
       setDraftGenerationNotices((current) => {
         const next = { ...current };
         for (const key of uniqueKeys) {
           next[key] =
             completedAtMs === undefined
-              ? { status, seen }
-              : { status, seen, completedAtMs };
+              ? {
+                  status,
+                  seen,
+                  ...(normalizedMessage ? { message: normalizedMessage } : {}),
+                }
+              : {
+                  status,
+                  seen,
+                  completedAtMs,
+                  ...(normalizedMessage ? { message: normalizedMessage } : {}),
+                };
         }
         return next;
       });
@@ -3666,15 +4037,38 @@ export function PlatformEntryFlowShellImpl({
     },
     [draftGenerationNotices],
   );
+  const getPendingDraftShelfState = useCallback(
+    (kind: Exclude<CreationWorkShelfKind, 'rpg'>, keys: string[]) => {
+      const entries = pendingDraftShelfItems[kind];
+      if (!entries) {
+        return null;
+      }
+
+      for (const key of keys) {
+        const normalizedKey = normalizePendingDraftShelfLookupId(kind, key);
+        const pending = normalizedKey ? entries[normalizedKey] : null;
+        if (pending) {
+          return pending;
+        }
+      }
+      return null;
+    },
+    [pendingDraftShelfItems],
+  );
   const markDraftGenerating = useCallback(
     (kind: CreationWorkShelfKind, ids: Array<string | null | undefined>) => {
       setPendingPlatformTaskCompletionDialog(null);
+      setPendingPlatformTaskFailureDialog(null);
       updateDraftGenerationNotices(
         collectDraftNoticeKeys(kind, ids),
         'generating',
       );
     },
-    [setPendingPlatformTaskCompletionDialog, updateDraftGenerationNotices],
+    [
+      setPendingPlatformTaskCompletionDialog,
+      setPendingPlatformTaskFailureDialog,
+      updateDraftGenerationNotices,
+    ],
   );
   const markDraftReady = useCallback(
     (
@@ -3682,6 +4076,7 @@ export function PlatformEntryFlowShellImpl({
       ids: Array<string | null | undefined>,
       viewedImmediately: boolean,
     ) => {
+      setPendingPlatformTaskFailureDialog(null);
       updateDraftGenerationNotices(
         collectDraftNoticeKeys(kind, ids),
         'ready',
@@ -3696,17 +4091,54 @@ export function PlatformEntryFlowShellImpl({
         completedAtMs,
       });
     },
-    [setPendingPlatformTaskCompletionDialog, updateDraftGenerationNotices],
+    [
+      setPendingPlatformTaskCompletionDialog,
+      setPendingPlatformTaskFailureDialog,
+      updateDraftGenerationNotices,
+    ],
+  );
+  const markDraftFailed = useCallback(
+    (
+      kind: CreationWorkShelfKind,
+      ids: Array<string | null | undefined>,
+      errorMessage?: string | null,
+      showFailureDialog = true,
+    ) => {
+      setPendingPlatformTaskCompletionDialog(null);
+      const noticeKeys = collectDraftNoticeKeys(kind, ids);
+      updateDraftGenerationNotices(noticeKeys, 'failed', false, errorMessage);
+      const normalizedErrorMessage = errorMessage?.trim();
+      if (normalizedErrorMessage && showFailureDialog) {
+        const failedAtMs = Date.now();
+        setPendingPlatformTaskFailureDialog({
+          key: `draft-failure:${kind}:${noticeKeys.join('|')}:${failedAtMs}`,
+          source: buildDraftCompletionDialogSource(kind, ids),
+          message: normalizedErrorMessage,
+          failedAtMs,
+        });
+      }
+    },
+    [
+      setPendingPlatformTaskCompletionDialog,
+      setPendingPlatformTaskFailureDialog,
+      updateDraftGenerationNotices,
+    ],
   );
   const markPendingDraftGenerating = useCallback(
     (
       kind: Exclude<CreationWorkShelfKind, 'rpg'>,
       id: string | null | undefined,
+      metadata?: { title?: string | null; summary?: string | null },
     ) => {
       setPendingPlatformTaskCompletionDialog(null);
-      updatePendingDraftShelfItem(kind, id, 'generating');
+      setPendingPlatformTaskFailureDialog(null);
+      updatePendingDraftShelfItem(kind, id, 'generating', false, metadata);
     },
-    [setPendingPlatformTaskCompletionDialog, updatePendingDraftShelfItem],
+    [
+      setPendingPlatformTaskCompletionDialog,
+      setPendingPlatformTaskFailureDialog,
+      updatePendingDraftShelfItem,
+    ],
   );
   const markPendingDraftReady = useCallback(
     (
@@ -3718,6 +4150,15 @@ export function PlatformEntryFlowShellImpl({
     },
     [updatePendingDraftShelfItem],
   );
+  const markPendingDraftFailed = useCallback(
+    (
+      kind: Exclude<CreationWorkShelfKind, 'rpg'>,
+      id: string | null | undefined,
+    ) => {
+      updatePendingDraftShelfItem(kind, id, 'failed', false);
+    },
+    [updatePendingDraftShelfItem],
+  );
   const getMatch3DBackgroundCompileTask = useCallback(
     (sessionId: string | null | undefined) => {
       const normalizedSessionId = normalizeDraftNoticeId(sessionId);
@@ -3758,13 +4199,60 @@ export function PlatformEntryFlowShellImpl({
     };
   }, []);
 
+  useEffect(() => {
+    profileWalletLocalDeltaRef.current = 0;
+    lastProfileDashboardSnapshotRef.current = null;
+  }, [authUi?.user?.id]);
+
+  const getPlatformProfileDashboardWithLocalWalletDelta = useCallback(
+    async (options?: Parameters<typeof getPlatformProfileDashboard>[0]) => {
+      const latestDashboard = await getPlatformProfileDashboard(options);
+      const reconciledDelta =
+        reconcileProfileWalletLocalDeltaWithServerDashboard(
+          lastProfileDashboardSnapshotRef.current,
+          latestDashboard,
+          profileWalletLocalDeltaRef.current,
+        );
+      lastProfileDashboardSnapshotRef.current = latestDashboard;
+      profileWalletLocalDeltaRef.current = reconciledDelta;
+      return adjustProfileDashboardWalletBalance(
+        latestDashboard,
+        reconciledDelta,
+      );
+    },
+    [],
+  );
+
   const platformBootstrap = usePlatformEntryBootstrap({
     user: authUi?.user,
     canAccessProtectedData: authUi?.canAccessProtectedData,
-    getProfileDashboard: getPlatformProfileDashboard,
+    getProfileDashboard: getPlatformProfileDashboardWithLocalWalletDelta,
     handleContinueGame,
     hasInitialAgentSession,
   });
+  const {
+    canReadProtectedData: canRefreshPlatformDashboard,
+    refreshProfileDashboard,
+  } = platformBootstrap;
+  const refreshPlatformDashboardSilently = useCallback(() => {
+    if (!canRefreshPlatformDashboard) {
+      return;
+    }
+    void refreshProfileDashboard().catch(() => undefined);
+  }, [canRefreshPlatformDashboard, refreshProfileDashboard]);
+  const adjustProfileWalletBalanceLocally = useCallback(
+    (delta: number) => {
+      if (!Number.isFinite(delta) || delta === 0) {
+        return;
+      }
+
+      profileWalletLocalDeltaRef.current += Math.trunc(delta);
+      platformBootstrap.setProfileDashboard((current) =>
+        adjustProfileDashboardWalletBalance(current, delta),
+      );
+    },
+    [platformBootstrap],
+  );
   const entryNavigation = usePlatformEntryNavigation({
     setSelectionStage,
     setSelectedDetailEntry,
@@ -3850,6 +4338,14 @@ export function PlatformEntryFlowShellImpl({
     },
     [draftGenerationNotices],
   );
+  const isDraftNoticeFailed = useCallback(
+    (kind: CreationWorkShelfKind, ids: Array<string | null | undefined>) => {
+      return collectDraftNoticeKeys(kind, ids).some(
+        (key) => draftGenerationNotices[key]?.status === 'failed',
+      );
+    },
+    [draftGenerationNotices],
+  );
   const isDraftNoticeReadyUnread = useCallback(
     (kind: CreationWorkShelfKind, ids: Array<string | null | undefined>) => {
       return collectDraftNoticeKeys(kind, ids).some((key) => {
@@ -3862,7 +4358,7 @@ export function PlatformEntryFlowShellImpl({
   const ensureEnoughDraftGenerationPointsFromServer = useCallback(
     async (pointsCost: number) => {
       try {
-        const latestDashboard = await getPlatformProfileDashboard(
+        const latestDashboard = await getPlatformProfileDashboardWithLocalWalletDelta(
           RECOMMEND_RUNTIME_BACKGROUND_AUTH_OPTIONS,
         );
         platformBootstrap.setProfileDashboard(latestDashboard);
@@ -3885,7 +4381,7 @@ export function PlatformEntryFlowShellImpl({
         return false;
       }
     },
-    [platformBootstrap],
+    [getPlatformProfileDashboardWithLocalWalletDelta, platformBootstrap],
   );
 
   const resolveBigFishErrorMessage = useCallback(
@@ -4700,9 +5196,52 @@ export function PlatformEntryFlowShellImpl({
   );
   const getCreationWorkShelfState = useCallback(
     (item: CreationWorkShelfItem) => {
-      const notice = getDraftGenerationNotice(
-        getGenerationNoticeShelfKeys(item),
-      );
+      const noticeKeys = getGenerationNoticeShelfKeys(item);
+      const notice = getDraftGenerationNotice(noticeKeys);
+      if (notice?.status === 'failed') {
+        const failedSummary = buildDraftFailedShelfSummary(item.source.kind);
+        const pending =
+          item.source.kind === 'rpg'
+            ? null
+            : getPendingDraftShelfState(item.source.kind, noticeKeys);
+        const pendingSummary = pending?.summary?.trim();
+        return {
+          isGenerating: false,
+          hasGenerationFailure: true,
+          generationFailureSummary: failedSummary,
+          hasUnreadUpdate: false,
+          suppressPersistedGenerating: true,
+          titleOverride:
+            item.source.kind === 'puzzle' &&
+            item.status === 'draft' &&
+            !item.source.item.workTitle?.trim()
+              ? '拼图�稿'
+              : undefined,
+          summaryOverride: isDraftShelfSummaryPlaceholder(item.summary)
+            ? (pendingSummary ?? failedSummary)
+            : undefined,
+        };
+      }
+      if (
+        item.source.kind === 'puzzle' &&
+        isPersistedDraftFailed(item.source.item.generationStatus)
+      ) {
+        const failedSummary = buildDraftFailedShelfSummary('puzzle');
+        return {
+          isGenerating: false,
+          hasGenerationFailure: true,
+          generationFailureSummary: failedSummary,
+          hasUnreadUpdate: false,
+          suppressPersistedGenerating: true,
+          titleOverride:
+            item.status === 'draft' && !item.source.item.workTitle?.trim()
+              ? '拼图�稿'
+              : undefined,
+          summaryOverride: isDraftShelfSummaryPlaceholder(item.summary)
+            ? failedSummary
+            : undefined,
+        };
+      }
       const isNoticeGenerating =
         notice?.status === 'generating' &&
         (item.source.kind !== 'puzzle' ||
@@ -4712,7 +5251,7 @@ export function PlatformEntryFlowShellImpl({
         hasUnreadUpdate: notice?.status === 'ready' && !notice.seen,
       };
     },
-    [getDraftGenerationNotice],
+    [getDraftGenerationNotice, getPendingDraftShelfState],
   );
   const visibleDraftNoticeKeys = useMemo(
     () => [
@@ -4831,9 +5370,17 @@ export function PlatformEntryFlowShellImpl({
         ? puzzleGenerationState
         : selectionStage === 'match3d-generating'
           ? match3dGenerationState
-          : selectionStage === 'baby-object-match-generating'
-            ? babyObjectMatchGenerationState
-            : null;
+          : selectionStage === 'big-fish-generating'
+            ? bigFishGenerationState
+            : selectionStage === 'square-hole-generating'
+              ? squareHoleGenerationState
+              : selectionStage === 'jump-hop-generating'
+                ? jumpHopGenerationState
+                : selectionStage === 'wooden-fish-generating'
+                  ? woodenFishGenerationState
+                  : selectionStage === 'baby-object-match-generating'
+                    ? babyObjectMatchGenerationState
+                    : null;
     const shouldTickProgress =
       selectionStage === 'visual-novel-generating'
         ? visualNovelGenerationStartedAtMs != null &&
@@ -4855,11 +5402,15 @@ export function PlatformEntryFlowShellImpl({
     return () => window.clearInterval(timerId);
   }, [
     babyObjectMatchGenerationState,
+    bigFishGenerationState,
+    jumpHopGenerationState,
     match3dGenerationState,
     puzzleGenerationState,
     selectionStage,
+    squareHoleGenerationState,
     visualNovelGenerationPhase,
     visualNovelGenerationStartedAtMs,
+    woodenFishGenerationState,
   ]);
 
   const runProtectedAction = useCallback(
@@ -5147,7 +5698,7 @@ export function PlatformEntryFlowShellImpl({
       setSelectionStage('big-fish-generating');
       setBigFishGenerationState(createMiniGameDraftGenerationState('big-fish'));
     },
-    onActionError: ({ payload, errorMessage }) => {
+    onActionError: ({ payload, errorMessage, session }) => {
       if (payload.action !== 'big_fish_compile_draft') {
         return;
       }
@@ -5158,6 +5709,13 @@ export function PlatformEntryFlowShellImpl({
             })
           : current,
       );
+      markPendingDraftFailed('big-fish', session.sessionId);
+      markDraftFailed(
+        'big-fish',
+        [`big-fish-work-${session.sessionId}`, session.sessionId],
+        errorMessage,
+      );
+      void refreshBigFishShelf();
     },
   });
 
@@ -5299,6 +5857,29 @@ export function PlatformEntryFlowShellImpl({
       if (payload.action !== 'match3d_compile_draft') {
         return;
       }
+      if (isBackgroundGenerationStillRunningMessage(errorMessage)) {
+        try {
+          const { session: latestSession } =
+            await match3dCreationClient.getSession(session.sessionId);
+          setSession(latestSession);
+          const profileId =
+            latestSession.draft?.profileId ?? latestSession.publishedProfileId;
+          if (profileId) {
+            const { item } = await getMatch3DWorkDetail(profileId);
+            setMatch3DProfile(normalizeMatch3DWorkForRuntimeUi(item));
+          }
+          markPendingDraftGenerating('match3d', latestSession.sessionId);
+          markDraftGenerating('match3d', [
+            latestSession.draft?.profileId,
+            latestSession.publishedProfileId,
+            latestSession.sessionId,
+          ]);
+          await refreshMatch3DShelf().catch(() => undefined);
+          return;
+        } catch {
+          await refreshMatch3DShelf().catch(() => undefined);
+        }
+      }
       setMatch3DGenerationState((current) =>
         current
           ? resolveFinishedMiniGameDraftGenerationState(current, 'failed', {
@@ -5306,6 +5887,12 @@ export function PlatformEntryFlowShellImpl({
             })
           : current,
       );
+      markPendingDraftFailed('match3d', session.sessionId);
+      markDraftFailed(
+        'match3d',
+        [session.draft?.profileId, session.publishedProfileId, session.sessionId],
+        errorMessage,
+      );
       try {
         const { session: latestSession } =
           await match3dCreationClient.getSession(session.sessionId);
@@ -5498,6 +6085,17 @@ export function PlatformEntryFlowShellImpl({
           setSquareHoleProfile(
             buildSquareHoleProfileFromSession(response.session),
           );
+          markPendingDraftFailed('square-hole', response.session.sessionId);
+          markDraftFailed(
+            'square-hole',
+            [
+              response.session.draft?.profileId,
+              response.session.publishedProfileId,
+              response.session.sessionId,
+            ],
+            errorMessage,
+          );
+          void refreshSquareHoleShelf().catch(() => undefined);
           if (shouldOpenResult) {
             setSelectionStage('square-hole-result');
           }
@@ -5556,7 +6154,7 @@ export function PlatformEntryFlowShellImpl({
         }
       }
     },
-    onActionError: ({ payload, errorMessage }) => {
+    onActionError: ({ payload, errorMessage, session }) => {
       if (
         payload.action === 'square_hole_compile_draft' ||
         payload.action === 'square_hole_generate_visual_assets'
@@ -5571,6 +6169,13 @@ export function PlatformEntryFlowShellImpl({
         if (selectionStageRef.current === 'square-hole-generating') {
           setSelectionStage('square-hole-generating');
         }
+        markPendingDraftFailed('square-hole', session.sessionId);
+        markDraftFailed(
+          'square-hole',
+          [session.draft?.profileId, session.publishedProfileId, session.sessionId],
+          errorMessage,
+        );
+        void refreshSquareHoleShelf().catch(() => undefined);
       }
     },
   });
@@ -5630,8 +6235,12 @@ export function PlatformEntryFlowShellImpl({
 
       if (
         payload.action === 'publish_puzzle_work' ||
-        payload.action === 'generate_puzzle_tags'
+        payload.action === 'generate_puzzle_tags' ||
+        payload.action === 'compile_puzzle_draft' ||
+        payload.action === 'generate_puzzle_images' ||
+        payload.action === 'generate_puzzle_ui_background'
       ) {
+        refreshPlatformDashboardSilently();
         await Promise.allSettled([
           refreshPuzzleShelf(),
           refreshPuzzleGallery(),
@@ -5750,7 +6359,13 @@ export function PlatformEntryFlowShellImpl({
         session.publishedProfileId,
         buildPuzzleResultProfileId(session.sessionId),
       ]);
-      markPendingDraftGenerating('puzzle', session.sessionId);
+      markPendingDraftGenerating(
+        'puzzle',
+        session.sessionId,
+        buildPendingPuzzleDraftMetadata(
+          formPayload ?? buildPuzzleFormPayloadFromSession(session),
+        ),
+      );
       selectionStageRef.current = 'puzzle-generating';
       activePuzzleGenerationSessionIdRef.current = session.sessionId;
       setSelectionStage('puzzle-generating');
@@ -5773,6 +6388,7 @@ export function PlatformEntryFlowShellImpl({
       if (payload.action !== 'compile_puzzle_draft') {
         return;
       }
+      refreshPlatformDashboardSilently();
       const formPayload =
         buildPuzzleFormPayloadFromAction(payload) ??
         puzzleBackgroundCompileTasks[session.sessionId]?.payload ??
@@ -5804,6 +6420,18 @@ export function PlatformEntryFlowShellImpl({
           error: errorMessage,
         },
       }));
+      markPendingDraftFailed('puzzle', session.sessionId);
+      markDraftFailed(
+        'puzzle',
+        [
+          session.sessionId,
+          buildPuzzleResultWorkId(session.sessionId),
+          session.publishedProfileId,
+          buildPuzzleResultProfileId(session.sessionId),
+        ],
+        errorMessage,
+      );
+      void refreshPuzzleShelf();
       setPuzzleGenerationState((current) =>
         current ? failedGenerationState : current,
       );
@@ -6121,6 +6749,11 @@ export function PlatformEntryFlowShellImpl({
       source: string;
       message: string | null | undefined;
     }> = [
+      {
+        key: pendingPlatformTaskFailureDialog?.key ?? 'draft-failure',
+        source: pendingPlatformTaskFailureDialog?.source ?? '创作�稿',
+        message: pendingPlatformTaskFailureDialog?.message,
+      },
       {
         key: 'creation-entry-config',
         source: '创作入��置',
@@ -6308,6 +6941,7 @@ export function PlatformEntryFlowShellImpl({
     match3dGenerationViewSession?.sessionId,
     match3dRun?.runId,
     match3dSession?.sessionId,
+    pendingPlatformTaskFailureDialog,
     platformBootstrap.platformError,
     publicWorkDetailError,
     puzzleCreationError,
@@ -6384,6 +7018,10 @@ export function PlatformEntryFlowShellImpl({
       platformBootstrap.setPlatformError(null);
       return;
     }
+    if (currentPlatformErrorDialog.key.startsWith('draft-failure:')) {
+      setPendingPlatformTaskFailureDialog(null);
+      return;
+    }
     if (currentPlatformErrorDialog.key === 'rpg-creation-type') {
       sessionController.setCreationTypeError(null);
       return;
@@ -6458,6 +7096,7 @@ export function PlatformEntryFlowShellImpl({
     sessionController,
     setBigFishError,
     setMatch3DError,
+    setPendingPlatformTaskFailureDialog,
     setPuzzleError,
     setSquareHoleError,
     setVisualNovelError,
@@ -6690,6 +7329,14 @@ export function PlatformEntryFlowShellImpl({
 
   const openPuzzleWorkspace = useCallback(() => {
     markCreationFlowReturnToCreate();
+    setPuzzleSession(null);
+    setPuzzleFormDraftPayload(null);
+    setPuzzleOperation(null);
+    setPuzzleGenerationState(null);
+    setPuzzleRun(null);
+    setSelectedPuzzleDetail(null);
+    setPuzzleRuntimeAuthMode('default');
+    activePuzzleGenerationSessionIdRef.current = null;
     enterCreateTab();
     setShowCreationTypeModal(false);
     setPuzzleCreationError(null);
@@ -6697,6 +7344,7 @@ export function PlatformEntryFlowShellImpl({
     setSelectionStage('puzzle-agent-workspace');
   }, [
     enterCreateTab,
+    setPuzzleSession,
     setPuzzleCreationError,
     setPuzzleError,
     setSelectionStage,
@@ -6819,9 +7467,10 @@ export function PlatformEntryFlowShellImpl({
       setPuzzleFormDraftPayload(payload);
       setPuzzleCreationError(null);
       setPuzzleError(null);
+      const shouldConsumePuzzleDraftPoints = payload.aiRedraw !== false;
 
       if (
-        payload.aiRedraw !== false &&
+        shouldConsumePuzzleDraftPoints &&
         !(await preflightPuzzleDraftGeneration())
       ) {
         return;
@@ -6862,7 +7511,14 @@ export function PlatformEntryFlowShellImpl({
         nextSession.publishedProfileId,
         buildPuzzleResultProfileId(nextSession.sessionId),
       ]);
-      markPendingDraftGenerating('puzzle', nextSession.sessionId);
+      markPendingDraftGenerating(
+        'puzzle',
+        nextSession.sessionId,
+        buildPendingPuzzleDraftMetadata(payload),
+      );
+      if (shouldConsumePuzzleDraftPoints) {
+        adjustProfileWalletBalanceLocally(-PUZZLE_DRAFT_GENERATION_POINT_COST);
+      }
       selectionStageRef.current = 'puzzle-generating';
       activePuzzleGenerationSessionIdRef.current = nextSession.sessionId;
       setSelectionStage('puzzle-generating');
@@ -6969,12 +7625,16 @@ export function PlatformEntryFlowShellImpl({
         if (recovered) {
           return;
         }
+        if (shouldConsumePuzzleDraftPoints) {
+          adjustProfileWalletBalanceLocally(PUZZLE_DRAFT_GENERATION_POINT_COST);
+        }
         const failedGenerationState =
           resolveFinishedMiniGameDraftGenerationState(
             generationState,
             'failed',
             { error: errorMessage },
           );
+        const openFailure = isViewingPuzzleGeneration(nextSession.sessionId);
         setPuzzleBackgroundCompileTasks((current) => ({
           ...current,
           [nextSession.sessionId]: {
@@ -6984,15 +7644,33 @@ export function PlatformEntryFlowShellImpl({
             error: errorMessage,
           },
         }));
-        if (isViewingPuzzleGeneration(nextSession.sessionId)) {
+        markPendingDraftFailed('puzzle', nextSession.sessionId);
+        markDraftFailed(
+          'puzzle',
+          [
+            nextSession.sessionId,
+            buildPuzzleResultWorkId(nextSession.sessionId),
+            nextSession.publishedProfileId,
+            buildPuzzleResultProfileId(nextSession.sessionId),
+          ],
+          errorMessage,
+          !openFailure,
+        );
+        void refreshPuzzleShelf();
+        if (openFailure) {
           setPuzzleError(errorMessage);
           setPuzzleGenerationState(failedGenerationState);
         }
+      } finally {
+        refreshPlatformDashboardSilently();
       }
     },
     [
+      adjustProfileWalletBalanceLocally,
       markDraftGenerating,
+      markDraftFailed,
       markDraftReady,
+      markPendingDraftFailed,
       markPendingDraftGenerating,
       markPendingDraftReady,
       isViewingPuzzleGeneration,
@@ -7000,6 +7678,7 @@ export function PlatformEntryFlowShellImpl({
       puzzleFlow,
       refreshPuzzleShelf,
       recoverCompletedPuzzleDraftGeneration,
+      refreshPlatformDashboardSilently,
       resolvePuzzleErrorMessage,
       setPuzzleError,
       setSelectionStage,
@@ -7051,7 +7730,12 @@ export function PlatformEntryFlowShellImpl({
         nextSession.publishedProfileId,
         nextSession.sessionId,
       ]);
-      markPendingDraftGenerating('match3d', nextSession.sessionId);
+      markPendingDraftGenerating(
+        'match3d',
+        nextSession.sessionId,
+        buildPendingMatch3DDraftMetadata(payload),
+      );
+      adjustProfileWalletBalanceLocally(-MATCH3D_DRAFT_GENERATION_POINT_COST);
       selectionStageRef.current = 'match3d-generating';
       activeMatch3DGenerationSessionIdRef.current = nextSession.sessionId;
       setSelectionStage('match3d-generating');
@@ -7157,12 +7841,51 @@ export function PlatformEntryFlowShellImpl({
           error,
           '执行抓大鹅�作失败。',
         );
+        if (isBackgroundGenerationStillRunningMessage(errorMessage)) {
+          try {
+            const { session: latestSession } =
+              await match3dCreationClient.getSession(nextSession.sessionId);
+            markPendingDraftGenerating('match3d', latestSession.sessionId);
+            markDraftGenerating('match3d', [
+              latestSession.draft?.profileId,
+              latestSession.publishedProfileId,
+              latestSession.sessionId,
+            ]);
+            setMatch3DBackgroundCompileTasks((current) => ({
+              ...current,
+              [nextSession.sessionId]: {
+                session: latestSession,
+                payload,
+                generationState,
+                error: errorMessage,
+              },
+            }));
+            if (isViewingMatch3DGeneration(nextSession.sessionId)) {
+              setMatch3DError(errorMessage);
+              setMatch3DSession(latestSession);
+              setMatch3DGenerationState(generationState);
+              const profileId =
+                latestSession.draft?.profileId ??
+                latestSession.publishedProfileId;
+              if (profileId) {
+                const { item } = await getMatch3DWorkDetail(profileId);
+                setMatch3DProfile(normalizeMatch3DWorkForRuntimeUi(item));
+              }
+            }
+            await refreshMatch3DShelf().catch(() => undefined);
+            return;
+          } catch {
+            await refreshMatch3DShelf().catch(() => undefined);
+          }
+        }
+        adjustProfileWalletBalanceLocally(MATCH3D_DRAFT_GENERATION_POINT_COST);
         const failedGenerationState =
           resolveFinishedMiniGameDraftGenerationState(
             generationState,
             'failed',
             { error: errorMessage },
           );
+        const openFailure = isViewingMatch3DGeneration(nextSession.sessionId);
         setMatch3DBackgroundCompileTasks((current) => ({
           ...current,
           [nextSession.sessionId]: {
@@ -7172,13 +7895,34 @@ export function PlatformEntryFlowShellImpl({
             error: errorMessage,
           },
         }));
-        if (isViewingMatch3DGeneration(nextSession.sessionId)) {
+        markPendingDraftFailed('match3d', nextSession.sessionId);
+        markDraftFailed(
+          'match3d',
+          [
+            nextSession.draft?.profileId,
+            nextSession.publishedProfileId,
+            nextSession.sessionId,
+          ],
+          errorMessage,
+          !openFailure,
+        );
+        if (openFailure) {
           setMatch3DError(errorMessage);
           setMatch3DGenerationState(failedGenerationState);
         }
         try {
           const { session: latestSession } =
             await match3dCreationClient.getSession(nextSession.sessionId);
+          markDraftFailed(
+            'match3d',
+            [
+              latestSession.draft?.profileId,
+              latestSession.publishedProfileId,
+              latestSession.sessionId,
+            ],
+            errorMessage,
+            !openFailure,
+          );
           setMatch3DBackgroundCompileTasks((current) => ({
             ...current,
             [nextSession.sessionId]: {
@@ -7188,7 +7932,7 @@ export function PlatformEntryFlowShellImpl({
               error: errorMessage,
             },
           }));
-          if (isViewingMatch3DGeneration(nextSession.sessionId)) {
+          if (openFailure) {
             setMatch3DSession(latestSession);
             const profileId =
               latestSession.draft?.profileId ??
@@ -7202,17 +7946,23 @@ export function PlatformEntryFlowShellImpl({
         } catch {
           await refreshMatch3DShelf().catch(() => undefined);
         }
+      } finally {
+        refreshPlatformDashboardSilently();
       }
     },
     [
+      adjustProfileWalletBalanceLocally,
       match3dRuntimeAdapter,
       isViewingMatch3DGeneration,
       markDraftGenerating,
+      markDraftFailed,
       markDraftReady,
+      markPendingDraftFailed,
       markPendingDraftGenerating,
       markPendingDraftReady,
       preflightMatch3DDraftGeneration,
       refreshMatch3DShelf,
+      refreshPlatformDashboardSilently,
       resolveMatch3DErrorMessage,
       setIsStreamingMatch3DReply,
       setMatch3DError,
@@ -7381,6 +8131,9 @@ export function PlatformEntryFlowShellImpl({
         const response = await executePuzzleAgentAction(session.sessionId, {
           action: 'save_puzzle_form_draft',
           promptText: payload.pictureDescription ?? null,
+          workTitle: payload.workTitle,
+          workDescription:
+            payload.workDescription ?? payload.pictureDescription ?? '',
           pictureDescription: payload.pictureDescription ?? '',
           referenceImageSrc: payload.referenceImageSrc ?? null,
           referenceImageSrcs: payload.referenceImageSrcs ?? [],
@@ -7502,6 +8255,7 @@ export function PlatformEntryFlowShellImpl({
     setDraftGenerationNotices({});
     setPendingDraftShelfItems({});
     setPendingPlatformTaskCompletionDialog(null);
+    setPendingPlatformTaskFailureDialog(null);
     resetRpgSessionViewState();
     setRpgGeneratedCustomWorldProfile(null);
     setRpgCustomWorldError(null);
@@ -8699,7 +9453,10 @@ export function PlatformEntryFlowShellImpl({
       created: JumpHopSessionResponse,
       payload?: JumpHopWorkspaceCreateRequest,
     ) => {
-      const generationState = createMiniGameDraftGenerationState('jump-hop');
+      const generationState = createMiniGameDraftGenerationState(
+        'jump-hop',
+        resolveMiniGameDraftGenerationStartedAtMs(created.session.updatedAt),
+      );
       setJumpHopError(null);
       setJumpHopSession(created.session);
       writeCreationUrlState(
@@ -8710,6 +9467,11 @@ export function PlatformEntryFlowShellImpl({
       setJumpHopGenerationState(generationState);
       setIsJumpHopBusy(true);
       setSelectionStage('jump-hop-generating');
+      markDraftGenerating('jump-hop', [
+        created.session.sessionId,
+        created.session.draft?.profileId,
+      ]);
+      markPendingDraftGenerating('jump-hop', created.session.sessionId);
 
       try {
         const response = await jumpHopClient.executeAction(
@@ -8777,10 +9539,22 @@ export function PlatformEntryFlowShellImpl({
             { error: errorMessage },
           ),
         );
+        markPendingDraftFailed('jump-hop', created.session.sessionId);
+        markDraftFailed(
+          'jump-hop',
+          [created.session.sessionId, created.session.draft?.profileId],
+          errorMessage,
+        );
+        void refreshJumpHopShelf().catch(() => undefined);
         try {
           const latest = await jumpHopClient.getSession(
             created.session.sessionId,
           );
+          markDraftFailed(
+            'jump-hop',
+            [latest.session.sessionId, latest.session.draft?.profileId],
+            errorMessage,
+          );
           setJumpHopSession(latest.session);
           setJumpHopWork(null);
           writeCreationUrlState(
@@ -8797,7 +9571,15 @@ export function PlatformEntryFlowShellImpl({
         setIsJumpHopBusy(false);
       }
     },
-    [createReadyJumpHopGenerationState, setSelectionStage],
+    [
+      createReadyJumpHopGenerationState,
+      markDraftFailed,
+      markDraftGenerating,
+      markPendingDraftFailed,
+      markPendingDraftGenerating,
+      refreshJumpHopShelf,
+      setSelectionStage,
+    ],
   );
 
   const retryJumpHopDraftGeneration = useCallback(() => {
@@ -9158,10 +9940,33 @@ export function PlatformEntryFlowShellImpl({
             { error: errorMessage },
           ),
         );
+        markPendingDraftFailed('wooden-fish', created.session.sessionId);
+        markDraftFailed(
+          'wooden-fish',
+          [created.session.sessionId, created.session.draft?.profileId],
+          errorMessage,
+        );
+        setWoodenFishWorks((current) =>
+          current.map((item) =>
+            item.sourceSessionId === created.session.sessionId
+              ? {
+                  ...item,
+                  generationStatus: 'failed',
+                  updatedAt: new Date().toISOString(),
+                }
+              : item,
+          ),
+        );
+        void refreshWoodenFishShelf().catch(() => undefined);
         try {
           const latest = await woodenFishClient.getSession(
             created.session.sessionId,
           );
+          markDraftFailed(
+            'wooden-fish',
+            [latest.session.sessionId, latest.session.draft?.profileId],
+            errorMessage,
+          );
           setWoodenFishSession(latest.session);
           setWoodenFishWork(null);
           writeCreationUrlState(
@@ -9180,8 +9985,10 @@ export function PlatformEntryFlowShellImpl({
     },
     [
       createReadyWoodenFishGenerationState,
+      markDraftFailed,
       markDraftGenerating,
       markDraftReady,
+      markPendingDraftFailed,
       markPendingDraftGenerating,
       markPendingDraftReady,
       refreshWoodenFishShelf,
@@ -9479,9 +10286,22 @@ export function PlatformEntryFlowShellImpl({
         puzzleFlow.setSession(response.session);
       } catch (error) {
         setPuzzleError(resolvePuzzleErrorMessage(error, '执行拼图�作失败。'));
+      } finally {
+        if (
+          payload.action === 'generate_puzzle_images' ||
+          payload.action === 'generate_puzzle_ui_background'
+        ) {
+          refreshPlatformDashboardSilently();
+        }
       }
     },
-    [puzzleFlow, puzzleSession, resolvePuzzleErrorMessage, setPuzzleError],
+    [
+      puzzleFlow,
+      puzzleSession,
+      refreshPlatformDashboardSilently,
+      resolvePuzzleErrorMessage,
+      setPuzzleError,
+    ],
   );
 
   const retryPuzzleDraftGeneration = useCallback(() => {
@@ -11913,13 +12733,10 @@ export function PlatformEntryFlowShellImpl({
 
   const openJumpHopDraft = useCallback(
     async (item: JumpHopWorkSummaryResponse) => {
-      markDraftNoticeSeen(
-        collectDraftNoticeKeys('jump-hop', [
-          item.workId,
-          item.profileId,
-          item.sourceSessionId,
-        ]),
-      );
+      const noticeIds = [item.workId, item.profileId, item.sourceSessionId];
+      const hasFailedNotice = isDraftNoticeFailed('jump-hop', noticeIds);
+      const sessionId = normalizeCreationUrlValue(item.sourceSessionId);
+      markDraftNoticeSeen(collectDraftNoticeKeys('jump-hop', noticeIds));
 
       if (item.publicationStatus === 'published') {
         void openJumpHopPublicWorkDetail(item.profileId);
@@ -11929,6 +12746,37 @@ export function PlatformEntryFlowShellImpl({
       setJumpHopError(null);
       setPublicWorkDetailError(null);
       setIsJumpHopBusy(true);
+      if (
+        hasFailedNotice &&
+        sessionId === jumpHopSession?.sessionId &&
+        jumpHopGenerationState?.phase === 'failed'
+      ) {
+        enterCreateTab();
+        setSelectionStage('jump-hop-generating');
+        setIsJumpHopBusy(false);
+        return;
+      }
+
+      if (item.generationStatus === 'generating' && !hasFailedNotice) {
+        const pendingSession = buildJumpHopPendingSession(item);
+        setJumpHopSession(pendingSession);
+        setJumpHopRun(null);
+        setJumpHopWork(null);
+        setJumpHopGenerationState(
+          createMiniGameDraftGenerationState(
+            'jump-hop',
+            resolveMiniGameDraftGenerationStartedAtMs(item.updatedAt),
+          ),
+        );
+        writeCreationUrlState(
+          buildJumpHopCreationUrlState({ session: pendingSession }),
+        );
+        enterCreateTab();
+        setSelectionStage('jump-hop-generating');
+        setIsJumpHopBusy(false);
+        return;
+      }
+
       try {
         const detail = await jumpHopClient.getWorkDetail(item.profileId);
         setJumpHopSession(null);
@@ -11947,9 +12795,13 @@ export function PlatformEntryFlowShellImpl({
     },
     [
       enterCreateTab,
+      isDraftNoticeFailed,
+      jumpHopGenerationState?.phase,
+      jumpHopSession?.sessionId,
       markDraftNoticeSeen,
-      openPublicWorkDetail,
+      openJumpHopPublicWorkDetail,
       setSelectionStage,
+      writeCreationUrlState,
     ],
   );
 
@@ -11977,13 +12829,11 @@ export function PlatformEntryFlowShellImpl({
 
   const openWoodenFishDraft = useCallback(
     async (item: WoodenFishWorkSummaryResponse) => {
-      markDraftNoticeSeen(
-        collectDraftNoticeKeys('wooden-fish', [
-          item.workId,
-          item.profileId,
-          item.sourceSessionId,
-        ]),
-      );
+      const noticeIds = [item.workId, item.profileId, item.sourceSessionId];
+      const hasFailedNotice = isDraftNoticeFailed('wooden-fish', noticeIds);
+      const sessionId =
+        normalizeCreationUrlValue(item.sourceSessionId) ?? item.profileId;
+      markDraftNoticeSeen(collectDraftNoticeKeys('wooden-fish', noticeIds));
 
       if (item.publicationStatus === 'published') {
         void openWoodenFishPublicWorkDetail(item.profileId);
@@ -11993,11 +12843,28 @@ export function PlatformEntryFlowShellImpl({
       setWoodenFishError(null);
       setPublicWorkDetailError(null);
       setIsWoodenFishBusy(true);
-      if (item.generationStatus === 'generating') {
+      if (
+        hasFailedNotice &&
+        sessionId === woodenFishSession?.sessionId &&
+        woodenFishGenerationState?.phase === 'failed'
+      ) {
+        enterCreateTab();
+        setSelectionStage('wooden-fish-generating');
+        setIsWoodenFishBusy(false);
+        return;
+      }
+
+      if (item.generationStatus === 'generating' && !hasFailedNotice) {
         const pendingSession = buildWoodenFishPendingSession(item);
         setWoodenFishSession(pendingSession);
         setWoodenFishRun(null);
         setWoodenFishWork(null);
+        setWoodenFishGenerationState(
+          createMiniGameDraftGenerationState(
+            'wooden-fish',
+            resolveMiniGameDraftGenerationStartedAtMs(item.updatedAt),
+          ),
+        );
         writeCreationUrlState(
           buildWoodenFishCreationUrlState({ session: pendingSession }),
         );
@@ -12029,15 +12896,20 @@ export function PlatformEntryFlowShellImpl({
           resolveRpgCreationErrorMessage(error, '读�敲木鱼�稿失败。'),
         );
         enterCreateTab();
-        setSelectionStage('wooden-fish-generating');
+        setSelectionStage(
+          hasFailedNotice ? 'wooden-fish-workspace' : 'wooden-fish-generating',
+        );
       } finally {
         setIsWoodenFishBusy(false);
       }
     },
     [
       enterCreateTab,
+      isDraftNoticeFailed,
       markDraftNoticeSeen,
       openWoodenFishPublicWorkDetail,
+      woodenFishGenerationState?.phase,
+      woodenFishSession?.sessionId,
       writeCreationUrlState,
       setSelectionStage,
     ],
@@ -12173,6 +13045,8 @@ export function PlatformEntryFlowShellImpl({
         buildPuzzleResultWorkId(item.sourceSessionId),
         buildPuzzleResultProfileId(item.sourceSessionId),
       ]);
+      const failedNotice = getDraftGenerationNotice(noticeKeys);
+      const isPersistedFailed = isPersistedDraftFailed(item.generationStatus);
       const hasGeneratingNotice = isDraftNoticeGenerating('puzzle', [
         item.workId,
         item.profileId,
@@ -12180,9 +13054,21 @@ export function PlatformEntryFlowShellImpl({
         buildPuzzleResultWorkId(item.sourceSessionId),
         buildPuzzleResultProfileId(item.sourceSessionId),
       ]);
+      const hasFailedNotice = isDraftNoticeFailed('puzzle', [
+        item.workId,
+        item.profileId,
+        item.sourceSessionId,
+        buildPuzzleResultWorkId(item.sourceSessionId),
+        buildPuzzleResultProfileId(item.sourceSessionId),
+      ]);
+      const noticeErrorMessage =
+        failedNotice?.status === 'failed'
+          ? (failedNotice.message ?? buildDraftFailedShelfSummary('puzzle'))
+          : buildDraftFailedShelfSummary('puzzle');
       const isMarkedGenerating =
-        (hasGeneratingNotice && !resolvePuzzleWorkCoverImageSrc(item)) ||
-        isPersistedPuzzleDraftGenerating(item);
+        !hasFailedNotice &&
+        ((hasGeneratingNotice && !resolvePuzzleWorkCoverImageSrc(item)) ||
+          isPersistedPuzzleDraftGenerating(item));
       setPuzzleOperation(null);
       setPuzzleRun(null);
       setPuzzleRuntimeAuthMode('default');
@@ -12202,6 +13088,67 @@ export function PlatformEntryFlowShellImpl({
       );
       const activeGenerationState =
         backgroundTask?.generationState ?? puzzleGenerationViewState;
+      const failedGenerationState =
+        backgroundTask?.generationState.phase === 'failed'
+          ? backgroundTask.generationState
+          : item.sourceSessionId === puzzleSession?.sessionId &&
+              activeGenerationState?.phase === 'failed'
+            ? activeGenerationState
+            : hasFailedNotice || isPersistedFailed
+              ? createFailedMiniGameDraftGenerationStateForRestoredDraft(
+                  'puzzle',
+                  item.updatedAt,
+                  noticeErrorMessage,
+                  { puzzleAiRedraw: true },
+                )
+              : null;
+
+      if ((hasFailedNotice || isPersistedFailed) && failedGenerationState) {
+        let failedSession = backgroundTask?.session ?? null;
+        let failedPayload = backgroundTask?.payload ?? null;
+        const failedError =
+          backgroundTask?.error ?? failedNotice?.message ?? noticeErrorMessage;
+        if (!failedSession) {
+          try {
+            const { session: latestSession } = await getPuzzleAgentSession(
+              item.sourceSessionId,
+            );
+            failedSession = latestSession;
+            failedPayload = buildPuzzleFormPayloadFromSession(latestSession);
+          } catch {
+            failedPayload = buildPuzzleFormPayloadFromWork(item);
+          }
+        }
+        if (!failedPayload) {
+          failedPayload = failedSession
+            ? buildPuzzleFormPayloadFromSession(failedSession)
+            : buildPuzzleFormPayloadFromWork(item);
+        }
+        if (backgroundTask) {
+          puzzleFlow.setSession(backgroundTask.session);
+        } else if (failedSession) {
+          puzzleFlow.setSession(failedSession);
+        }
+        setPuzzleFormDraftPayload(failedPayload);
+        setPuzzleError(failedError);
+        if (failedSession) {
+          setPuzzleBackgroundCompileTasks((current) => ({
+            ...current,
+            [failedSession!.sessionId]: {
+              session: failedSession!,
+              payload: failedPayload!,
+              generationState: failedGenerationState,
+              error: failedError,
+            },
+          }));
+        }
+        enterCreateTab();
+        selectionStageRef.current = 'puzzle-generating';
+        activePuzzleGenerationSessionIdRef.current = item.sourceSessionId;
+        setPuzzleGenerationState(failedGenerationState);
+        setSelectionStage('puzzle-generating');
+        return;
+      }
 
       if (
         item.sourceSessionId === puzzleSession?.sessionId &&
@@ -12258,26 +13205,34 @@ export function PlatformEntryFlowShellImpl({
             item.sourceSessionId,
           );
           const payload = buildPuzzleFormPayloadFromSession(latestSession);
-          const generationState =
-            createMiniGameDraftGenerationStateForRestoredDraft('puzzle', {
-              puzzleAiRedraw: payload.aiRedraw ?? true,
-              puzzleProgressPercent:
-                latestSession.draft && !latestSession.draft.formDraft
-                  ? latestSession.progressPercent
-                  : undefined,
-            });
+          const startedAtMs = resolveMiniGameDraftGenerationStartedAtMs(
+            latestSession.updatedAt,
+          );
+          const baseGenerationState =
+            createMiniGameDraftGenerationStateForRestoredDraft(
+              'puzzle',
+              {
+                puzzleAiRedraw: payload.aiRedraw ?? true,
+                puzzleProgressPercent:
+                  latestSession.draft && !latestSession.draft.formDraft
+                    ? latestSession.progressPercent
+                    : undefined,
+              },
+              startedAtMs,
+            );
+          const generationState = mergePuzzleSessionProgressIntoGenerationState(
+            baseGenerationState,
+            latestSession,
+          );
           puzzleFlow.setSession(latestSession);
           setPuzzleFormDraftPayload(payload);
-          setPuzzleGenerationState(
-            rebaseMiniGameDraftGenerationStateForDisplay(generationState),
-          );
+          setPuzzleGenerationState(generationState);
           setPuzzleBackgroundCompileTasks((current) => ({
             ...current,
             [latestSession.sessionId]: {
               session: latestSession,
               payload,
-              generationState:
-                rebaseMiniGameDraftGenerationStateForDisplay(generationState),
+              generationState,
               error: null,
             },
           }));
@@ -12317,6 +13272,8 @@ export function PlatformEntryFlowShellImpl({
     [
       enterCreateTab,
       getPuzzleBackgroundCompileTask,
+      getDraftGenerationNotice,
+      isDraftNoticeFailed,
       isDraftNoticeGenerating,
       markDraftNoticeSeen,
       openPuzzleDetail,
@@ -12362,18 +13319,43 @@ export function PlatformEntryFlowShellImpl({
         return;
       }
 
+      const failedNotice = getDraftGenerationNotice(noticeKeys);
+      const hasFailedNotice = isDraftNoticeFailed('match3d', [
+        item.workId,
+        item.profileId,
+        item.sourceSessionId,
+      ]);
+      const noticeErrorMessage =
+        failedNotice?.status === 'failed'
+          ? (failedNotice.message ?? buildDraftFailedShelfSummary('match3d'))
+          : buildDraftFailedShelfSummary('match3d');
       const isMarkedGenerating =
-        isDraftNoticeGenerating('match3d', [
+        !hasFailedNotice &&
+        (isDraftNoticeGenerating('match3d', [
           item.workId,
           item.profileId,
           item.sourceSessionId,
-        ]) || isPersistedDraftGenerating(item.generationStatus);
+        ]) ||
+          isPersistedDraftGenerating(item.generationStatus));
 
       const backgroundTask = getMatch3DBackgroundCompileTask(
         item.sourceSessionId,
       );
       const activeGenerationState =
         backgroundTask?.generationState ?? match3dGenerationViewState;
+      const failedGenerationState =
+        backgroundTask?.generationState.phase === 'failed'
+          ? backgroundTask.generationState
+          : item.sourceSessionId === match3dSession?.sessionId &&
+              activeGenerationState?.phase === 'failed'
+            ? activeGenerationState
+            : hasFailedNotice
+              ? createFailedMiniGameDraftGenerationStateForRestoredDraft(
+                  'match3d',
+                  item.updatedAt,
+                  noticeErrorMessage,
+                )
+              : null;
 
       if (hasUnreadReadyNotice) {
         try {
@@ -12406,6 +13388,52 @@ export function PlatformEntryFlowShellImpl({
         }
       }
 
+      if (failedGenerationState) {
+        let failedSession = backgroundTask?.session ?? null;
+        let failedPayload = backgroundTask?.payload ?? null;
+        const failedError =
+          backgroundTask?.error ?? failedNotice?.message ?? noticeErrorMessage;
+        if (!failedSession) {
+          try {
+            const { session: latestSession } =
+              await match3dCreationClient.getSession(item.sourceSessionId);
+            failedSession = latestSession;
+            failedPayload = buildMatch3DFormPayloadFromSession(latestSession);
+          } catch {
+            failedPayload = buildMatch3DFormPayloadFromWork(item);
+          }
+        }
+        if (!failedPayload) {
+          failedPayload = failedSession
+            ? buildMatch3DFormPayloadFromSession(failedSession)
+            : buildMatch3DFormPayloadFromWork(item);
+        }
+        if (backgroundTask) {
+          setMatch3DSession(backgroundTask.session);
+        } else if (failedSession) {
+          setMatch3DSession(failedSession);
+        }
+        setMatch3DFormDraftPayload(failedPayload);
+        setMatch3DError(failedError);
+        if (failedSession) {
+          setMatch3DBackgroundCompileTasks((current) => ({
+            ...current,
+            [failedSession!.sessionId]: {
+              session: failedSession!,
+              payload: failedPayload!,
+              generationState: failedGenerationState,
+              error: failedError,
+            },
+          }));
+        }
+        enterCreateTab();
+        selectionStageRef.current = 'match3d-generating';
+        activeMatch3DGenerationSessionIdRef.current = item.sourceSessionId;
+        setMatch3DGenerationState(failedGenerationState);
+        setSelectionStage('match3d-generating');
+        return;
+      }
+
       if (
         item.sourceSessionId === match3dSession?.sessionId &&
         isMiniGameDraftGenerating(activeGenerationState)
@@ -12462,9 +13490,14 @@ export function PlatformEntryFlowShellImpl({
           setMatch3DSession(latestSession);
           setMatch3DFormDraftPayload(null);
           setMatch3DProfile(null);
-          const generationState = rebaseMiniGameDraftGenerationStateForDisplay(
-            createMiniGameDraftGenerationStateForRestoredDraft('match3d'),
-          );
+          const generationState =
+            createMiniGameDraftGenerationStateForRestoredDraft(
+              'match3d',
+              undefined,
+              resolveMiniGameDraftGenerationStartedAtMs(
+                latestSession.updatedAt,
+              ),
+            );
           setMatch3DGenerationState(generationState);
           enterCreateTab();
           selectionStageRef.current = 'match3d-generating';
@@ -12506,6 +13539,8 @@ export function PlatformEntryFlowShellImpl({
     [
       enterCreateTab,
       getMatch3DBackgroundCompileTask,
+      getDraftGenerationNotice,
+      isDraftNoticeFailed,
       isDraftNoticeGenerating,
       isDraftNoticeReadyUnread,
       markDraftNoticeSeen,
diff --git a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
index 602d9470..1b5750f6 100644
--- a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
+++ b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
@@ -88,9 +88,7 @@ import {
 } from '../../services/edutainment-baby-object';
 import { jumpHopClient } from '../../services/jump-hop/jumpHopClient';
 import { match3dCreationClient } from '../../services/match3d-creation';
-import {
-  createServerMatch3DRuntimeAdapter,
-} from '../../services/match3d-runtime';
+import { createServerMatch3DRuntimeAdapter } from '../../services/match3d-runtime';
 import {
   deleteMatch3DWork,
   getMatch3DWorkDetail,
@@ -172,6 +170,7 @@ import {
 } from '../../services/square-hole-works';
 import { listVisualNovelGallery } from '../../services/visual-novel-runtime';
 import { listVisualNovelWorks } from '../../services/visual-novel-works';
+import { woodenFishClient } from '../../services/wooden-fish/woodenFishClient';
 import { type CustomWorldProfile, WorldType } from '../../types';
 import {
   AuthUiContext,
@@ -759,6 +758,22 @@ vi.mock('../../services/visual-novel-works', () => ({
   updateVisualNovelWork: vi.fn(),
 }));
 
+vi.mock('../../services/wooden-fish/woodenFishClient', () => ({
+  woodenFishClient: {
+    checkpointRun: vi.fn(),
+    createSession: vi.fn(),
+    executeAction: vi.fn(),
+    finishRun: vi.fn(),
+    getGalleryDetail: vi.fn(),
+    getSession: vi.fn(),
+    getWorkDetail: vi.fn(),
+    listGallery: vi.fn(),
+    listWorks: vi.fn(),
+    publishWork: vi.fn(),
+    startRun: vi.fn(),
+  },
+}));
+
 vi.mock('../../services/visual-novel-creation', () => ({
   compileVisualNovelWorkProfile: vi.fn(),
   createVisualNovelSession: vi.fn(),
@@ -2672,6 +2687,12 @@ beforeEach(() => {
   vi.mocked(deleteRpgEntryWorldProfile).mockResolvedValue([]);
   vi.mocked(listVisualNovelGallery).mockResolvedValue({ works: [] });
   vi.mocked(listVisualNovelWorks).mockResolvedValue({ works: [] });
+  vi.mocked(woodenFishClient.listGallery).mockResolvedValue({
+    items: [],
+    hasMore: false,
+    nextCursor: null,
+  });
+  vi.mocked(woodenFishClient.listWorks).mockResolvedValue({ items: [] });
   vi.mocked(listLocalBabyObjectMatchDrafts).mockResolvedValue([]);
   vi.mocked(deleteLocalBabyObjectMatchDraft).mockResolvedValue([]);
   vi.mocked(jumpHopClient.listGallery).mockResolvedValue({
@@ -3825,9 +3846,9 @@ test('bark battle form checks mud points before creating image assets', async ()
   ).toBeTruthy();
   expect(screen.getByText('汪汪声浪�置表�')).toBeTruthy();
   expect(screen.queryByRole('tablist', { name: '玩法模�分类' })).toBeNull();
-  expect((screen.getByLabelText('汪汪作�标题') as HTMLInputElement).value).toBe(
-    '自定义声浪�',
-  );
+  expect(
+    (screen.getByLabelText('汪汪作�标题') as HTMLInputElement).value,
+  ).toBe('自定义声浪�');
   expect(createBarkBattleDraft).not.toHaveBeenCalled();
   expect(generateAllBarkBattleImageAssets).not.toHaveBeenCalled();
 });
@@ -3975,6 +3996,106 @@ test('running match3d form generation can return to draft tab and reopen progres
   });
 });
 
+test('background match3d draft failure notifies and reopens failed retry page', async () => {
+  const user = userEvent.setup();
+  const runningSession = buildMockMatch3DAgentSession({
+    sessionId: 'match3d-background-failed-session',
+    draft: null,
+    stage: 'collecting_config',
+  });
+  const persistedFailedWork: Match3DWorkSummary = {
+    workId: 'match3d-background-failed-work',
+    profileId: 'match3d-background-failed-profile',
+    ownerUserId: 'user-1',
+    sourceSessionId: runningSession.sessionId,
+    gameName: '失败中的抓鹅',
+    themeText: '泥塑水果摊',
+    summary: '正在生�玩法素�。',
+    tags: ['水果', '抓大鹅'],
+    coverImageSrc: null,
+    referenceImageSrc: null,
+    clearCount: 12,
+    difficulty: 4,
+    publicationStatus: 'draft',
+    playCount: 0,
+    updatedAt: '2026-05-18T12:05:00.000Z',
+    publishedAt: null,
+    publishReady: false,
+    generationStatus: 'generating',
+    generatedItemAssets: [],
+  };
+  let rejectCompile!: (reason?: unknown) => void;
+  vi.mocked(match3dCreationClient.createSession).mockResolvedValue({
+    session: runningSession,
+  });
+  vi.mocked(match3dCreationClient.executeAction).mockReturnValue(
+    new Promise((_, reject) => {
+      rejectCompile = reject;
+    }),
+  );
+  vi.mocked(match3dCreationClient.getSession).mockResolvedValue({
+    session: buildMockMatch3DAgentSession({
+      sessionId: runningSession.sessionId,
+      stage: 'collecting_config',
+      draft: null,
+      updatedAt: '2026-05-18T12:05:00.000Z',
+    }),
+  });
+
+  render(<TestWrapper withAuth />);
+
+  await openCreateTemplateHub(user);
+  await user.click(await findCreationTypeButton('抓大鹅'));
+  await user.click(
+    await screen.findByRole('button', { name: '生�抓大鹅�稿' }),
+  );
+  expect(
+    await screen.findByRole('progressbar', {
+      name: '抓大鹅�稿生�进度',
+    }),
+  ).toBeTruthy();
+
+  await user.click(screen.getByRole('button', { name: '返回创作中心' }));
+  await openDraftHub(user);
+  await expectDraftHubGeneratingBadgeCountAtLeast(1);
+  vi.mocked(listMatch3DWorks).mockResolvedValue({
+    items: [persistedFailedWork],
+  });
+
+  await act(async () => {
+    rejectCompile(new Error('抓大鹅素��务失败'));
+    await Promise.resolve();
+  });
+
+  const failureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  expect(within(failureDialog).getByText(/抓大鹅素��务失败/u)).toBeTruthy();
+  await user.click(within(failureDialog).getByRole('button', { name: '关闭' }));
+
+  const draftPanel = getPlatformTabPanel('saves');
+  const reopenButton = await within(draftPanel).findByRole('button', {
+    name: /继续创作《(?:失败中的抓鹅|抓大鹅�稿)》/u,
+  });
+  expect(within(draftPanel).getByText('赛�水果摊')).toBeTruthy();
+  await user.click(reopenButton);
+
+  expect(await screen.findByText(/生�失败/u)).toBeTruthy();
+  const reopenedFailureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  await user.click(
+    within(reopenedFailureDialog).getByRole('button', { name: '关闭' }),
+  );
+  await waitFor(() => {
+    expect(screen.queryByRole('dialog', { name: '�生错误' })).toBeNull();
+  });
+  expect(
+    await screen.findByRole('button', { name: '�新生��稿' }),
+  ).toBeTruthy();
+  expect(match3dCreationClient.executeAction).toHaveBeenCalledTimes(1);
+});
+
 test('running match3d persisted draft reopens progress instead of unfinished result', async () => {
   const user = userEvent.setup();
   const runningSession = buildMockMatch3DAgentSession({
@@ -4065,9 +4186,6 @@ test('running match3d persisted draft reopens progress instead of unfinished res
     }),
   ).toBeTruthy();
   expect(screen.queryByText('抓大鹅结果页')).toBeNull();
-  expect(match3dCreationClient.getSession).toHaveBeenCalledWith(
-    'match3d-running-persisted-session',
-  );
 });
 
 test('persisted generating match3d draft opens generation progress after refresh', async () => {
@@ -4135,12 +4253,14 @@ test('persisted generating match3d draft opens generation progress after refresh
       name: '抓大鹅�稿生�进度',
     }),
   ).toBeTruthy();
-  expect(
+  const restoredProgressValue = Number(
     screen
       .getByRole('progressbar', { name: '抓大鹅�稿生�进度' })
       .getAttribute('aria-valuenow'),
-  ).toBe('0');
-  expect(screen.getByText('0%')).toBeTruthy();
+  );
+  expect(restoredProgressValue).toBeGreaterThan(0);
+  expect(restoredProgressValue).toBeLessThan(100);
+  expect(screen.getByText(`${restoredProgressValue}%`)).toBeTruthy();
   expect(screen.queryByText('抓大鹅结果页')).toBeNull();
   expect(getMatch3DWorkDetail).not.toHaveBeenCalledWith(
     'match3d-profile-generating',
@@ -4432,9 +4552,7 @@ test('running puzzle form generation creates a new puzzle draft on same template
 
   await openCreateTemplateHub(user);
   await user.click(await findCreationTypeButton('拼图'));
-  await user.click(
-    await screen.findByRole('button', { name: '生��稿' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
   expect(
     await screen.findByRole('progressbar', {
       name: '拼图图片生�进度',
@@ -4458,7 +4576,9 @@ test('running puzzle form generation creates a new puzzle draft on same template
   expect((secondGenerateButton as HTMLButtonElement).disabled).toBe(false);
   await user.click(secondGenerateButton);
 
-  expect(createPuzzleAgentSession).toHaveBeenCalledTimes(1);
+  await waitFor(() => {
+    expect(createPuzzleAgentSession).toHaveBeenCalledTimes(2);
+  });
   expect(executePuzzleAgentAction).toHaveBeenCalledTimes(2);
   expect(executePuzzleAgentAction).toHaveBeenNthCalledWith(
     1,
@@ -4467,7 +4587,7 @@ test('running puzzle form generation creates a new puzzle draft on same template
   );
   expect(executePuzzleAgentAction).toHaveBeenNthCalledWith(
     2,
-    'puzzle-session-1',
+    'puzzle-parallel-session-2',
     expect.objectContaining({ action: 'compile_puzzle_draft' }),
   );
 
@@ -4479,7 +4599,11 @@ test('running puzzle form generation creates a new puzzle draft on same template
   await user.click(screen.getByRole('button', { name: '返回创作中心' }));
   await openDraftHub(user);
   await waitFor(() => {
-    expect(screen.getAllByText('拼图�稿').length).toBeGreaterThanOrEqual(2);
+    expect(
+      within(getPlatformTabPanel('saves')).getAllByRole('button', {
+        name: /继续创作《[^》]+》，生�中/u,
+      }).length,
+    ).toBeGreaterThanOrEqual(2);
   });
   await expectDraftHubGeneratingBadgeCountAtLeast(2);
 
@@ -4513,6 +4637,158 @@ test('running puzzle form generation creates a new puzzle draft on same template
   });
 });
 
+test('failed parallel puzzle generations stay as separate non-generating drafts', async () => {
+  const user = userEvent.setup();
+  const firstSession = buildMockPuzzleAgentSession({
+    sessionId: 'puzzle-parallel-failed-session-1',
+  });
+  const secondSession = buildMockPuzzleAgentSession({
+    sessionId: 'puzzle-parallel-failed-session-2',
+  });
+  let rejectFirstCompile!: (reason?: unknown) => void;
+  let rejectSecondCompile!: (reason?: unknown) => void;
+  vi.mocked(createPuzzleAgentSession)
+    .mockResolvedValueOnce({
+      session: firstSession,
+    })
+    .mockResolvedValueOnce({
+      session: secondSession,
+    });
+  vi.mocked(executePuzzleAgentAction)
+    .mockReturnValueOnce(
+      new Promise((_, reject) => {
+        rejectFirstCompile = reject;
+      }),
+    )
+    .mockReturnValueOnce(
+      new Promise((_, reject) => {
+        rejectSecondCompile = reject;
+      }),
+    );
+
+  render(<TestWrapper withAuth />);
+
+  await openCreateTemplateHub(user);
+  await user.click(await findCreationTypeButton('拼图'));
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
+  expect(
+    await screen.findByRole('progressbar', {
+      name: '拼图图片生�进度',
+    }),
+  ).toBeTruthy();
+  await user.click(screen.getByRole('button', { name: '返回创作中心' }));
+  expect(await screen.findByText('18泥点')).toBeTruthy();
+
+  await openCreateTemplateHub(user);
+  await user.click(await findCreationTypeButton('拼图'));
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
+  await waitFor(() => {
+    expect(createPuzzleAgentSession).toHaveBeenCalledTimes(2);
+  });
+  expect(executePuzzleAgentAction).toHaveBeenCalledTimes(2);
+
+  await clickFirstButtonByName(user, '返回');
+  expect(await screen.findByText('16泥点')).toBeTruthy();
+  await openDraftHub(user);
+  const draftPanel = getPlatformTabPanel('saves');
+  await waitFor(() => {
+    expect(
+      within(draftPanel).getAllByRole('button', {
+        name: /继续创作《[^》]+》，生�中/u,
+      }).length,
+    ).toBeGreaterThanOrEqual(2);
+  });
+  await expectDraftHubGeneratingBadgeCountAtLeast(2);
+
+  vi.mocked(listPuzzleWorks).mockResolvedValue({
+    items: [
+      {
+        workId: `puzzle-work-${firstSession.sessionId}`,
+        profileId: `puzzle-profile-${firstSession.sessionId}`,
+        ownerUserId: 'user-1',
+        sourceSessionId: firstSession.sessionId,
+        authorDisplayName: '测试玩家',
+        workTitle: '',
+        workDescription: '一套雨夜猫街主题拼图。',
+        levelName: '第1关',
+        summary: '一套雨夜猫街主题拼图。',
+        themeTags: [],
+        coverImageSrc: null,
+        coverAssetId: null,
+        publicationStatus: 'draft',
+        updatedAt: '2026-05-18T12:00:00.000Z',
+        publishedAt: null,
+        playCount: 0,
+        remixCount: 0,
+        likeCount: 0,
+        publishReady: false,
+        generationStatus: 'failed',
+        levels: [],
+      },
+      {
+        workId: `puzzle-work-${secondSession.sessionId}`,
+        profileId: `puzzle-profile-${secondSession.sessionId}`,
+        ownerUserId: 'user-1',
+        sourceSessionId: secondSession.sessionId,
+        authorDisplayName: '测试玩家',
+        workTitle: '',
+        workDescription: '一套雨夜猫街主题拼图。',
+        levelName: '第1关',
+        summary: '一套雨夜猫街主题拼图。',
+        themeTags: [],
+        coverImageSrc: null,
+        coverAssetId: null,
+        publicationStatus: 'draft',
+        updatedAt: '2026-05-18T12:00:01.000Z',
+        publishedAt: null,
+        playCount: 0,
+        remixCount: 0,
+        likeCount: 0,
+        publishReady: false,
+        generationStatus: 'failed',
+        levels: [],
+      },
+    ],
+  });
+
+  await act(async () => {
+    rejectFirstCompile(
+      new Error(
+        '拼图 VectorEngine 图片编辑失败：创建图片编辑任务失败：error sending request for url (https://api.vectorengine.cn/v1/images/edits)',
+      ),
+    );
+    rejectSecondCompile(
+      new Error(
+        '拼图 VectorEngine 图片编辑失败：创建图片编辑任务失败：error sending request for url (https://api.vectorengine.cn/v1/images/edits)',
+      ),
+    );
+    await Promise.resolve();
+  });
+
+  await waitFor(() => {
+    expect(
+      within(draftPanel).getAllByRole('button', {
+        name: /继续创作《[^》]+》/u,
+      }).length,
+    ).toBeGreaterThanOrEqual(2);
+    expect(within(draftPanel).queryAllByLabelText('生�中')).toHaveLength(0);
+  });
+  expect(await screen.findByText('20泥点')).toBeTruthy();
+  expect(within(draftPanel).queryByText('第1关')).toBeNull();
+  expect(
+    within(draftPanel).getAllByText('拼图�稿生�失败，��新打开处�。')
+      .length,
+  ).toBeGreaterThanOrEqual(2);
+  expect(
+    within(draftPanel).getAllByText('一套雨夜猫街主题拼图。').length,
+  ).toBeGreaterThanOrEqual(2);
+  const failureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  expect(within(failureDialog).getByText(/拼图 VectorEngine 图片编辑失败/u))
+    .toBeTruthy();
+});
+
 test('running puzzle draft opens generation progress from draft tab', async () => {
   const user = userEvent.setup();
   const runningSession = buildMockPuzzleAgentSession({
@@ -4548,9 +4824,7 @@ test('running puzzle draft opens generation progress from draft tab', async () =
 
   await openCreateTemplateHub(user);
   await user.click(await findCreationTypeButton('拼图'));
-  await user.click(
-    await screen.findByRole('button', { name: '生��稿' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
   expect(
     await screen.findByRole('progressbar', {
       name: '拼图图片生�进度',
@@ -4562,7 +4836,7 @@ test('running puzzle draft opens generation progress from draft tab', async () =
   await expectDraftHubGeneratingBadgeCountAtLeast(1);
 
   await user.click(
-    screen.getByRole('button', { name: /继续创作《拼图�稿》/u }),
+    screen.getByRole('button', { name: /继续创作《[^》]+》，生�中/u }),
   );
 
   expect(
@@ -4602,9 +4876,7 @@ test('puzzle form checks mud points before creating a draft', async () => {
 
   await openCreateTemplateHub(user);
   await user.click(await findCreationTypeButton('拼图'));
-  await user.click(
-    await screen.findByRole('button', { name: '生��稿' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
 
   const noticeDialog = await screen.findByRole('dialog', { name: '泥点�足' });
   expect(
@@ -4894,7 +5166,9 @@ test('match3d result back returns to draft hub when opened from shelf', async ()
     within(draftPanel).getByRole('tablist', { name: '作�筛选' }),
   ).toBeTruthy();
   expect(within(draftPanel).getByText('自动试玩抓大鹅')).toBeTruthy();
-  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe('true');
+  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe(
+    'true',
+  );
   expect(screen.queryByText('抓大鹅结果页')).toBeNull();
 });
 
@@ -5221,13 +5495,9 @@ test('completed match3d draft notice first opens trial then reopens result', asy
     name: '生�完�',
   });
   expect(
-    within(completionDialog).getByText(
-      /抓大鹅�稿 match3d-notice-session-1/u,
-    ),
-  ).toBeTruthy();
-  expect(
-    within(completionDialog).getByText(/生�任务已完�/u),
+    within(completionDialog).getByText(/抓大鹅�稿 match3d-notice-session-1/u),
   ).toBeTruthy();
+  expect(within(completionDialog).getByText(/生�任务已完�/u)).toBeTruthy();
   expect(
     within(completionDialog).getByRole('button', { name: '�制内容' }),
   ).toBeTruthy();
@@ -5445,9 +5715,7 @@ test('puzzle draft generation auto starts trial and runtime back opens draft res
 
   await openCreateTemplateHub(user);
   await user.click(await findCreationTypeButton('拼图'));
-  await user.click(
-    await screen.findByRole('button', { name: '生��稿' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
 
   await waitFor(() => {
     expect(updatePuzzleWork).toHaveBeenCalledWith(
@@ -5534,9 +5802,7 @@ test('embedded puzzle form recovers when compile request times out after backend
 
   await openCreateTemplateHub(user);
   await user.click(await findCreationTypeButton('拼图'));
-  await user.click(
-    await screen.findByRole('button', { name: '生��稿' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
 
   await waitFor(() => {
     expect(getPuzzleAgentSession).toHaveBeenCalledWith(
@@ -6685,7 +6951,10 @@ test('home recommendation puzzle next level switches to similar work detail', as
     nextLevelId: 'puzzle-level-2',
     recommendedNextWorks: [],
   };
-  const startedRun = buildMockPuzzleRun(entryWork.profileId, entryWork.levelName);
+  const startedRun = buildMockPuzzleRun(
+    entryWork.profileId,
+    entryWork.levelName,
+  );
   const similarRun = {
     ...buildMockPuzzleRun(similarWork.profileId, similarWork.levelName),
     runId: clearedRun.runId,
@@ -6719,7 +6988,9 @@ test('home recommendation puzzle next level switches to similar work detail', as
   vi.mocked(submitPuzzleLeaderboard).mockResolvedValue({
     run: clearedRunWithSameWorkNext,
   });
-  let resolveAdvancePuzzleNextLevel!: (value: { run: PuzzleRunSnapshot }) => void;
+  let resolveAdvancePuzzleNextLevel!: (value: {
+    run: PuzzleRunSnapshot;
+  }) => void;
   vi.mocked(advancePuzzleNextLevel).mockReturnValue(
     new Promise((resolve) => {
       resolveAdvancePuzzleNextLevel = resolve;
@@ -6753,10 +7024,9 @@ test('home recommendation puzzle next level switches to similar work detail', as
   await user.click(within(dialog).getByRole('button', { name: '下一关' }));
 
   await waitFor(() => {
-    expect(advancePuzzleNextLevel).toHaveBeenCalledWith(
-      clearedRun.runId,
-      { preferSimilarWork: true },
-    );
+    expect(advancePuzzleNextLevel).toHaveBeenCalledWith(clearedRun.runId, {
+      preferSimilarWork: true,
+    });
   });
   expect(screen.getByTestId('puzzle-board')).toBeTruthy();
   expect(screen.queryByText('加载中...')).toBeNull();
@@ -7457,8 +7727,8 @@ test('embedded puzzle form maps raw bearer token errors to user-facing auth copy
   expect(createPuzzleAgentSession).toHaveBeenCalledTimes(1);
   expect(createCreativeAgentSession).not.toHaveBeenCalled();
   expect(
-    await screen.findByText('当�登录状�已失效，请�新登录�继续。'),
-  ).toBeTruthy();
+    await screen.findAllByText('当�登录状�已失效，请�新登录�继续。'),
+  ).not.toHaveLength(0);
   expect(screen.queryByText('缺少 Authorization Bearer Token')).toBeNull();
 });
 
@@ -7572,7 +7842,9 @@ test('puzzle draft result back button returns to draft hub when opened from shel
     within(draftPanel).getByRole('tablist', { name: '作�筛选' }),
   ).toBeTruthy();
   expect(within(draftPanel).getByText('雨夜猫塔')).toBeTruthy();
-  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe('true');
+  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe(
+    'true',
+  );
   expect(screen.queryByText('拼图工作区：missing-session')).toBeNull();
   expect(
     screen.queryByText('雨夜里有一�会�光的猫站在�迹�阶上。'),
@@ -7635,14 +7907,14 @@ test('persisted generating puzzle draft opens generation progress after refresh'
       name: '拼图图片生�进度',
     }),
   ).toBeTruthy();
-  expect(
-    Number(
-      screen
-        .getByRole('progressbar', { name: '拼图图片生�进度' })
-        .getAttribute('aria-valuenow'),
-    ),
-  ).toBe(0);
-  expect(screen.getByText('0%')).toBeTruthy();
+  const restoredProgressValue = Number(
+    screen
+      .getByRole('progressbar', { name: '拼图图片生�进度' })
+      .getAttribute('aria-valuenow'),
+  );
+  expect(restoredProgressValue).toBeGreaterThan(0);
+  expect(restoredProgressValue).toBeLessThan(100);
+  expect(screen.getByText(`${restoredProgressValue}%`)).toBeTruthy();
   expect(screen.queryByText('拼图结果页')).toBeNull();
 });
 
@@ -7736,7 +8008,9 @@ test('puzzle compile timeout shows failure dialog when reread session is still g
   await user.click(await screen.findByRole('button', { name: '生��稿' }));
 
   const dialog = await screen.findByRole('dialog', { name: '�生错误' });
-  expect(within(dialog).getByText('拼图�稿 puzzle-session-timeout')).toBeTruthy();
+  expect(
+    within(dialog).getByText('拼图�稿 puzzle-session-timeout'),
+  ).toBeTruthy();
   expect(
     within(dialog).getByText(
       '拼图共创�作超时，请确认�行时�端已�动��试。',
@@ -9818,8 +10092,12 @@ test('agent draft result back button returns to draft hub without syncing result
   await waitFor(() => {
     expect(draftPanel.getAttribute('aria-hidden')).toBe('false');
   });
-  expect(within(draftPanel).getByRole('tablist', { name: '作�筛选' })).toBeTruthy();
-  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe('true');
+  expect(
+    within(draftPanel).getByRole('tablist', { name: '作�筛选' }),
+  ).toBeTruthy();
+  expect(getPlatformTabPanel('create').getAttribute('aria-hidden')).toBe(
+    'true',
+  );
 
   expect(
     vi
@@ -10915,8 +11193,9 @@ test('creation hub published work card reveals delete action after card action r
   publishedCard.focus();
   await user.keyboard('{ArrowLeft}');
 
-  expect(screen.getByRole('button', { name: '删除' })).toBeTruthy();
-  await user.click(screen.getByRole('button', { name: '删除' }));
+  const deleteButtons = screen.getAllByRole('button', { name: '删除' });
+  expect(deleteButtons.length).toBeGreaterThan(0);
+  await user.click(deleteButtons[0]!);
 
   const dialog = await screen.findByRole('dialog', { name: '删除作�' });
   expect(dialog.parentElement?.className).toContain('platform-theme--light');
diff --git a/src/components/rpg-entry/RpgEntryHomeView.tsx b/src/components/rpg-entry/RpgEntryHomeView.tsx
index 47b0e4b8..6d5a5a8d 100644
--- a/src/components/rpg-entry/RpgEntryHomeView.tsx
+++ b/src/components/rpg-entry/RpgEntryHomeView.tsx
@@ -7059,7 +7059,8 @@ export function RpgEntryHomeView({
                     <Settings className="h-5 w-5" />
                   </button>
                 </div>
-              ) : isAuthenticated && activeTab === 'create' ? (
+              ) : isAuthenticated &&
+                (activeTab === 'create' || activeTab === 'saves') ? (
                 <button
                   type="button"
                   onClick={openUserSurface}
@@ -7224,7 +7225,8 @@ export function RpgEntryHomeView({
               </div>
 
               <div className="flex items-center gap-3">
-                {isAuthenticated && activeTab === 'create' ? (
+                {isAuthenticated &&
+                (activeTab === 'create' || activeTab === 'saves') ? (
                   <button
                     type="button"
                     onClick={openUserSurface}
diff --git a/src/components/unified-creation/workspaces/Match3DCreationWorkspace.interaction.test.tsx b/src/components/unified-creation/workspaces/Match3DCreationWorkspace.interaction.test.tsx
index d0df0934..a36992ad 100644
--- a/src/components/unified-creation/workspaces/Match3DCreationWorkspace.interaction.test.tsx
+++ b/src/components/unified-creation/workspaces/Match3DCreationWorkspace.interaction.test.tsx
@@ -131,7 +131,9 @@ test('match3d workspace can defer visible chrome to the unified creation page',
   expect(workspace?.className).not.toContain('overflow-hidden');
   expect(workspace?.className).not.toContain('platform-remap-surface');
   expect(screen.queryByRole('heading', { name: '想�个什么玩法？' })).toBeNull();
-  expect(screen.getByLabelText('想�一个什么题�的抓大鹅？')).toBeTruthy();
+  const themeInput = screen.getByLabelText('想�一个什么题�的抓大鹅？');
+  expect(themeInput).toBeTruthy();
+  expect(themeInput.className).not.toContain('h-full');
 });
 
 test('match3d workspace omits legacy asset style fields from entry payload', () => {
diff --git a/src/components/unified-creation/workspaces/Match3DCreationWorkspace.tsx b/src/components/unified-creation/workspaces/Match3DCreationWorkspace.tsx
index 9cbb6cc1..916dd9eb 100644
--- a/src/components/unified-creation/workspaces/Match3DCreationWorkspace.tsx
+++ b/src/components/unified-creation/workspaces/Match3DCreationWorkspace.tsx
@@ -239,7 +239,7 @@ export function Match3DCreationWorkspace({
                 : 'min-h-0 flex-1 grid-rows-[minmax(0,1fr)_auto] lg:grid-rows-1'
             } ${isBusy ? 'opacity-55' : ''}`}
           >
-            <label className="block min-h-0">
+            <label className={unifiedChrome ? 'block' : 'block min-h-0'}>
               <span className="mb-2 block text-sm font-black text-[var(--platform-text-strong)]">
                 想�一个什么题�的抓大鹅？
               </span>
@@ -254,7 +254,11 @@ export function Match3DCreationWorkspace({
                     themeText: event.target.value,
                   }))
                 }
-                className="h-full min-h-[7.75rem] w-full resize-none rounded-[1.15rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-4 py-3 text-base leading-6 text-[var(--platform-text-strong)] outline-none transition focus:border-[var(--platform-surface-hover-border)] focus:bg-white focus:ring-2 focus:ring-[var(--platform-warm-border)] sm:min-h-[9rem] lg:min-h-[14rem]"
+                className={`w-full resize-none rounded-[1.15rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-4 py-3 text-base leading-6 text-[var(--platform-text-strong)] outline-none transition focus:border-[var(--platform-surface-hover-border)] focus:bg-white focus:ring-2 focus:ring-[var(--platform-warm-border)] ${
+                  unifiedChrome
+                    ? 'min-h-[11rem] sm:min-h-[12rem]'
+                    : 'h-full min-h-[7.75rem] sm:min-h-[9rem] lg:min-h-[14rem]'
+                }`}
                 aria-label="想�一个什么题�的抓大鹅？"
               />
             </label>
diff --git a/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.interaction.test.tsx b/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.interaction.test.tsx
index 77bc7f91..0ed7ebc0 100644
--- a/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.interaction.test.tsx
+++ b/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.interaction.test.tsx
@@ -202,6 +202,7 @@ test('puzzle workspace submits the work form instead of agent chat', () => {
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '一�猫在雨夜�牌下回头。',
+    workDescription: '一�猫在雨夜�牌下回头。',
     pictureDescription: '一�猫在雨夜�牌下回头。',
     referenceImageSrc: null,
     referenceImageSrcs: [],
@@ -367,6 +368,7 @@ test('puzzle workspace selects a history image from the upload card', async () =
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '�留历�图里的主体，改�晴天花园。',
+    workDescription: '�留历�图里的主体，改�晴天花园。',
     pictureDescription: '�留历�图里的主体，改�晴天花园。',
     referenceImageSrc: null,
     referenceImageSrcs: [],
@@ -425,6 +427,7 @@ test('puzzle workspace falls back to compile action for restored sessions', () =
   expect(onCreateFromForm).not.toHaveBeenCalled();
   expect(onExecuteAction).toHaveBeenCalledWith({
     action: 'compile_puzzle_draft',
+    workDescription: '潮雾中的�塔与断桥',
     pictureDescription: '潮雾中的�塔与断桥',
     promptText: '潮雾中的�塔与断桥',
     referenceImageSrc: null,
@@ -528,6 +531,7 @@ test('puzzle workspace restores form draft fields and autosaves edits', () => {
 
   expect(onAutoSaveForm).toHaveBeenCalledWith({
     seedText: '旧街�牌下的猫和�光雨伞。',
+    workDescription: '旧街�牌下的猫和�光雨伞。',
     pictureDescription: '旧街�牌下的猫和�光雨伞。',
     referenceImageSrc: null,
     referenceImageSrcs: [],
@@ -576,6 +580,7 @@ test('puzzle workspace hides prompt and cost when AI redraw is off', async () =>
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: 'first-level.png',
+    workDescription: 'first-level.png',
     pictureDescription: 'first-level.png',
     referenceImageSrc: 'data:image/png;base64,uploaded-square',
     referenceImageSrcs: [],
@@ -632,6 +637,7 @@ test('puzzle workspace submits history image when AI redraw is off', async () =>
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '历�素� · image.png',
+    workDescription: '历�素� · image.png',
     pictureDescription: '历�素� · image.png',
     referenceImageSrc: '/generated-puzzle-assets/history/image.png',
     referenceImageSrcs: [],
@@ -674,6 +680,7 @@ test('puzzle workspace submits uploaded reference image as data URL when AI redr
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '�留上传画�的主体和构图，改�雨夜�街。',
+    workDescription: '�留上传画�的主体和构图，改�雨夜�街。',
     pictureDescription: '�留上传画�的主体和构图，改�雨夜�街。',
     referenceImageSrc: 'data:image/png;base64,uploaded-square',
     referenceImageSrcs: [],
@@ -764,6 +771,7 @@ test('puzzle workspace uploads prompt references as asset object ids', async ()
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '一�猫在雨夜�牌下回头。',
+    workDescription: '一�猫在雨夜�牌下回头。',
     pictureDescription: '一�猫在雨夜�牌下回头。',
     referenceImageSrc: null,
     referenceImageSrcs: [
@@ -852,6 +860,7 @@ test('puzzle workspace uploads prompt reference images from the description box'
 
   expect(onCreateFromForm).toHaveBeenCalledWith({
     seedText: '一�猫在雨夜�牌下回头。',
+    workDescription: '一�猫在雨夜�牌下回头。',
     pictureDescription: '一�猫在雨夜�牌下回头。',
     referenceImageSrc: null,
     referenceImageSrcs: [
diff --git a/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.tsx b/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.tsx
index f18be461..74c184a6 100644
--- a/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.tsx
+++ b/src/components/unified-creation/workspaces/PuzzleCreationWorkspace.tsx
@@ -321,6 +321,7 @@ export function PuzzleCreationWorkspace({
   const autosavePayload = useMemo(
     () => ({
       seedText: pictureDescription,
+      workDescription: pictureDescription,
       pictureDescription,
       referenceImageSrc: mainReferenceImageSrcForPayload,
       referenceImageSrcs: promptReferenceImageSrcsForPayload,
@@ -551,6 +552,7 @@ export function PuzzleCreationWorkspace({
       : pictureDescription || formState.referenceImageLabel || '上传拼图图片';
     const payload = {
       seedText: payloadPictureDescription,
+      workDescription: payloadPictureDescription,
       pictureDescription: payloadPictureDescription,
       referenceImageSrc: mainReferenceImageSrcForPayload,
       referenceImageSrcs: promptReferenceImageSrcsForPayload,
@@ -571,6 +573,7 @@ export function PuzzleCreationWorkspace({
     onExecuteAction({
       action: 'compile_puzzle_draft',
       promptText: payloadPictureDescription,
+      workDescription: payloadPictureDescription,
       pictureDescription: payloadPictureDescription,
       referenceImageSrc: mainReferenceImageSrcForPayload,
       referenceImageSrcs: promptReferenceImageSrcsForPayload,
diff --git a/src/index.css b/src/index.css
index d877fcad..a342db73 100644
--- a/src/index.css
+++ b/src/index.css
@@ -2119,6 +2119,31 @@ html[data-mobile-keyboard-open='true'] .platform-mobile-bottom-dock {
   white-space: normal;
 }
 
+.creation-work-card__failure-status {
+  display: inline-flex;
+  width: fit-content;
+  max-width: 100%;
+  min-width: 0;
+  align-items: center;
+  gap: 0.26rem;
+  overflow: hidden;
+  border: 1px solid color-mix(in srgb, #c7653d 48%, transparent);
+  border-radius: 9999px;
+  background: color-mix(in srgb, #c7653d 12%, transparent);
+  padding: 0.22rem 0.52rem;
+  color: color-mix(in srgb, #c7653d 86%, var(--platform-text-strong));
+  font-size: 0.68rem;
+  font-weight: 800;
+  line-height: 1.1;
+}
+
+.creation-work-card__failure-status span {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .creation-work-card__published-info {
   display: grid;
   min-width: 0;
diff --git a/src/services/miniGameDraftGenerationProgress.test.ts b/src/services/miniGameDraftGenerationProgress.test.ts
index e1aeb76a..fbdab7dd 100644
--- a/src/services/miniGameDraftGenerationProgress.test.ts
+++ b/src/services/miniGameDraftGenerationProgress.test.ts
@@ -36,9 +36,7 @@ describe('miniGameDraftGenerationProgress', () => {
     expect(progress?.steps[0]?.detail).toBe(
       '建立����稿，整�首关�述与关�结构，约 8 秒。',
     );
-    expect(progress?.steps[2]?.detail).toBe(
-      '生� 1:1 拼图首图，预计 4 分钟。',
-    );
+    expect(progress?.steps[2]?.detail).toBe('生� 1:1 拼图首图，预计 4 分钟。');
     expect(progress?.estimatedRemainingMs).toBe(446_500);
     expect(progress?.overallProgress).toBe(0);
     expect(progress?.steps[0]?.completed).toBeGreaterThan(0);
@@ -72,7 +70,7 @@ describe('miniGameDraftGenerationProgress', () => {
       error: null,
     };
 
-    const progress = buildMiniGameDraftGenerationProgress(state, 7000);
+    const progress = buildMiniGameDraftGenerationProgress(state, 130_000);
 
     expect(progress?.overallProgress).toBeGreaterThan(0);
     expect(progress?.overallProgress).toBeLessThan(88);
@@ -105,8 +103,8 @@ describe('miniGameDraftGenerationProgress', () => {
     expect(longRunningProgress?.phaseId).toBe('compile');
     expect(longRunningProgress?.steps[0]?.status).toBe('active');
     expect(longRunningProgress?.steps[1]?.status).toBe('pending');
-    expect(longRunningProgress?.overallProgress).toBeLessThanOrEqual(98);
-    expect(longRunningProgress?.overallProgress).toBeGreaterThan(40);
+    expect(longRunningProgress?.overallProgress).toBeLessThan(5);
+    expect(longRunningProgress?.overallProgress).toBeGreaterThan(0);
     expect(realProgress?.phaseId).toBe('puzzle-cover-image');
     expect(realProgress?.steps[1]?.status).toBe('completed');
     expect(realProgress?.steps[2]?.status).toBe('active');
@@ -145,7 +143,10 @@ describe('miniGameDraftGenerationProgress', () => {
     };
 
     const progress = buildMiniGameDraftGenerationProgress(state, 20_000);
-    const writeBackProgress = buildMiniGameDraftGenerationProgress(state, 206_000);
+    const writeBackProgress = buildMiniGameDraftGenerationProgress(
+      state,
+      206_000,
+    );
 
     expect(progress?.steps.map((step) => step.label)).toEqual([
       '编译首关�稿',
@@ -175,13 +176,14 @@ describe('miniGameDraftGenerationProgress', () => {
 
     expect(progress?.phaseId).toBe('compile');
     expect(progress?.overallProgress).toBeLessThan(88);
-    expect(progress?.overallProgress).toBeGreaterThan(80);
+    expect(progress?.overallProgress).toBeLessThan(5);
+    expect(progress?.overallProgress).toBeGreaterThan(0);
     expect(progress?.estimatedRemainingMs).toBe(0);
     expect(progress?.steps[0]?.status).toBe('active');
     expect(progress?.steps[0]?.completed).toBe(0.98);
-    expect(progress?.steps.slice(1).every((step) => step.status === 'pending')).toBe(
-      true,
-    );
+    expect(
+      progress?.steps.slice(1).every((step) => step.status === 'pending'),
+    ).toBe(true);
   });
 
   test('puzzle draft generation advances steps from backend progress percent only', () => {
@@ -221,9 +223,11 @@ describe('miniGameDraftGenerationProgress', () => {
     );
 
     expect(imageProgress?.phaseId).toBe('puzzle-cover-image');
+    expect(imageProgress?.overallProgress).toBeLessThan(88);
     expect(imageProgress?.steps[2]?.status).toBe('active');
     expect(imageProgress?.steps[3]?.status).toBe('pending');
     expect(uiProgress?.phaseId).toBe('puzzle-ui-assets');
+    expect(uiProgress?.overallProgress).toBeLessThan(94);
     expect(uiProgress?.steps[4]?.status).toBe('active');
     expect(uiProgress?.steps[5]?.status).toBe('pending');
     expect(writeProgress?.phaseId).toBe('puzzle-select-image');
@@ -249,6 +253,7 @@ describe('miniGameDraftGenerationProgress', () => {
     const progress = buildMiniGameDraftGenerationProgress(state, 121_000);
 
     expect(progress?.phaseId).toBe('puzzle-cover-image');
+    expect(progress?.overallProgress).toBeLessThan(88);
     expect(progress?.steps[2]?.status).toBe('active');
     expect(progress?.steps[2]?.completed).toBeLessThan(0.02);
   });
@@ -619,55 +624,58 @@ describe('miniGameDraftGenerationProgress', () => {
   });
 
   test('puzzle generation anchors expose form payload as the display source', () => {
-    const entries = buildPuzzleGenerationAnchorEntries({
-      sessionId: 'puzzle-session-1',
-      currentTurn: 1,
-      progressPercent: 0,
-      stage: 'collecting_anchors',
-      anchorPack: {
-        themePromise: {
-          key: 'themePromise',
-          label: '题�承诺',
-          value: '雨夜猫街',
-          status: 'locked',
-        },
-        visualSubject: {
-          key: 'visualSubject',
-          label: '画�主体',
-          value: '一�猫在雨夜�牌下回头。',
-          status: 'locked',
-        },
-        visualMood: {
-          key: 'visualMood',
-          label: '视觉气质',
-          value: '清晰�适�拼图切�',
-          status: 'inferred',
-        },
-        compositionHooks: {
-          key: 'compositionHooks',
-          label: '拼图记忆点',
-          value: '主体轮廓�色�分区�局部细节',
-          status: 'inferred',
-        },
-        tagsAndForbidden: {
-          key: 'tagsAndForbidden',
-          label: '标签与�忌',
-          value: '猫咪�雨夜�拼图；�止标题字',
-          status: 'inferred',
+    const entries = buildPuzzleGenerationAnchorEntries(
+      {
+        sessionId: 'puzzle-session-1',
+        currentTurn: 1,
+        progressPercent: 0,
+        stage: 'collecting_anchors',
+        anchorPack: {
+          themePromise: {
+            key: 'themePromise',
+            label: '题�承诺',
+            value: '雨夜猫街',
+            status: 'locked',
+          },
+          visualSubject: {
+            key: 'visualSubject',
+            label: '画�主体',
+            value: '一�猫在雨夜�牌下回头。',
+            status: 'locked',
+          },
+          visualMood: {
+            key: 'visualMood',
+            label: '视觉气质',
+            value: '清晰�适�拼图切�',
+            status: 'inferred',
+          },
+          compositionHooks: {
+            key: 'compositionHooks',
+            label: '拼图记忆点',
+            value: '主体轮廓�色�分区�局部细节',
+            status: 'inferred',
+          },
+          tagsAndForbidden: {
+            key: 'tagsAndForbidden',
+            label: '标签与�忌',
+            value: '猫咪�雨夜�拼图；�止标题字',
+            status: 'inferred',
+          },
         },
+        draft: null,
+        messages: [],
+        lastAssistantReply: null,
+        publishedProfileId: null,
+        suggestedActions: [],
+        resultPreview: null,
+        updatedAt: '2026-04-29T00:00:00.000Z',
       },
-      draft: null,
-      messages: [],
-      lastAssistantReply: null,
-      publishedProfileId: null,
-      suggestedActions: [],
-      resultPreview: null,
-      updatedAt: '2026-04-29T00:00:00.000Z',
-    }, {
-      seedText: '一�猫在雨夜�牌下回头。',
-      pictureDescription: '一�猫在雨夜�牌下回头。',
-      referenceImageSrc: null,
-    });
+      {
+        seedText: '一�猫在雨夜�牌下回头。',
+        pictureDescription: '一�猫在雨夜�牌下回头。',
+        referenceImageSrc: null,
+      },
+    );
 
     expect(entries).toEqual([
       {
diff --git a/src/services/miniGameDraftGenerationProgress.ts b/src/services/miniGameDraftGenerationProgress.ts
index d92c383a..c3b1e997 100644
--- a/src/services/miniGameDraftGenerationProgress.ts
+++ b/src/services/miniGameDraftGenerationProgress.ts
@@ -216,7 +216,10 @@ function resolvePuzzleBackendProgressPercent(
   state: MiniGameDraftGenerationState,
 ) {
   const progressPercent = state.metadata?.puzzleProgressPercent;
-  if (typeof progressPercent !== 'number' || !Number.isFinite(progressPercent)) {
+  if (
+    typeof progressPercent !== 'number' ||
+    !Number.isFinite(progressPercent)
+  ) {
     return null;
   }
 
@@ -571,13 +574,13 @@ export function createMiniGameDraftGenerationState(
           ? 'square-hole-draft'
           : kind === 'match3d'
             ? 'match3d-work-title'
-          : kind === 'baby-object-match'
-            ? 'baby-object-draft'
-          : kind === 'jump-hop'
-            ? 'jump-hop-draft'
-            : kind === 'wooden-fish'
-              ? 'wooden-fish-draft'
-              : 'compile',
+            : kind === 'baby-object-match'
+              ? 'baby-object-draft'
+              : kind === 'jump-hop'
+                ? 'jump-hop-draft'
+                : kind === 'wooden-fish'
+                  ? 'wooden-fish-draft'
+                  : 'compile',
     startedAtMs,
     completedAssetCount: 0,
     totalAssetCount: 0,
@@ -784,10 +787,7 @@ function resolvePuzzleActiveStepElapsedProgressRatio(
   // 中文注释：未收到�端真实里程碑时，跨步骤必须��；
   // 但当�步骤内的�进度�按整段等待时间继续��走，��短步骤几秒��死。
   const fallbackDurationMs = Math.max(1, resolvePuzzleEstimatedWaitMs(state));
-  return Math.max(
-    0,
-    Math.min(0.98, elapsedMs / fallbackDurationMs),
-  );
+  return Math.max(0, Math.min(0.98, elapsedMs / fallbackDurationMs));
 }
 
 function resolveElapsedActiveStepProgressRatio(
@@ -809,53 +809,7 @@ function resolveElapsedActiveStepProgressRatio(
                 ? WOODEN_FISH_ESTIMATED_WAIT_MS
                 : 1;
 
-  return Math.max(
-    0,
-    Math.min(0.98, elapsedMs / Math.max(1, estimatedWaitMs)),
-  );
-}
-
-function resolvePuzzleOverallProgress(
-  state: MiniGameDraftGenerationState,
-  activeStepProgressRatio: number,
-) {
-  const backendProgressPercent = resolvePuzzleBackendProgressPercent(state);
-  // 中文注释：88 以下的�端进度��留为会�事实，��与首帧总进度抬�。
-  // 生�页��时必须先从 0% 起步，�由当�步骤内的�进度平滑推进。
-  const backendProgressFloor =
-    backendProgressPercent != null &&
-    backendProgressPercent >= PUZZLE_COMPILE_MILESTONE_PROGRESS
-      ? backendProgressPercent
-      : 0;
-  const range =
-    state.phase === 'puzzle-select-image'
-      ? {
-          start: PUZZLE_UI_MILESTONE_PROGRESS,
-          end: PUZZLE_NON_READY_MAX_PROGRESS,
-        }
-      : state.phase === 'puzzle-ui-assets'
-        ? {
-            start: PUZZLE_IMAGE_MILESTONE_PROGRESS,
-            end: PUZZLE_UI_MILESTONE_PROGRESS,
-          }
-        : state.phase === 'puzzle-cover-image' ||
-            state.phase === 'puzzle-level-scene'
-          ? {
-              start: PUZZLE_COMPILE_MILESTONE_PROGRESS,
-              end: PUZZLE_IMAGE_MILESTONE_PROGRESS,
-            }
-          : {
-              start: 0,
-              end: PUZZLE_COMPILE_MILESTONE_PROGRESS,
-            };
-  const fakeProgress =
-    range.start + (range.end - range.start) * activeStepProgressRatio;
-  const nextProgress = Math.min(
-    PUZZLE_NON_READY_MAX_PROGRESS,
-    Math.max(range.start, backendProgressFloor, fakeProgress),
-  );
-
-  return nextProgress;
+  return Math.max(0, Math.min(0.98, elapsedMs / Math.max(1, estimatedWaitMs)));
 }
 
 export function buildMiniGameDraftGenerationProgress(
@@ -867,7 +821,8 @@ export function buildMiniGameDraftGenerationProgress(
   }
 
   const effectiveNowMs =
-    typeof state.finishedAtMs === 'number' && Number.isFinite(state.finishedAtMs)
+    typeof state.finishedAtMs === 'number' &&
+    Number.isFinite(state.finishedAtMs)
       ? state.finishedAtMs
       : nowMs;
   const elapsedMs = Math.max(0, effectiveNowMs - state.startedAtMs);
@@ -894,42 +849,42 @@ export function buildMiniGameDraftGenerationProgress(
             ...state,
             phase: woodenFishTimeline.phase,
           }
-      : state.kind === 'big-fish' &&
-          state.phase !== 'failed' &&
-          state.phase !== 'ready'
-        ? {
-            ...state,
-            phase: resolveBigFishPhaseByElapsedMs(elapsedMs),
-          }
-        : state.kind === 'square-hole' &&
+        : state.kind === 'big-fish' &&
             state.phase !== 'failed' &&
             state.phase !== 'ready'
           ? {
               ...state,
-              phase: resolveSquareHolePhaseByElapsedMs(elapsedMs),
+              phase: resolveBigFishPhaseByElapsedMs(elapsedMs),
             }
-          : state.kind === 'match3d' &&
+          : state.kind === 'square-hole' &&
               state.phase !== 'failed' &&
               state.phase !== 'ready'
             ? {
                 ...state,
-                phase: resolveMatch3DPhaseByElapsedMs(elapsedMs, state.phase),
+                phase: resolveSquareHolePhaseByElapsedMs(elapsedMs),
               }
-            : state.kind === 'baby-object-match' &&
+            : state.kind === 'match3d' &&
                 state.phase !== 'failed' &&
                 state.phase !== 'ready'
               ? {
                   ...state,
-                  phase: resolveBabyObjectMatchPhaseByElapsedMs(elapsedMs),
+                  phase: resolveMatch3DPhaseByElapsedMs(elapsedMs, state.phase),
                 }
-              : state.kind === 'jump-hop' &&
+              : state.kind === 'baby-object-match' &&
                   state.phase !== 'failed' &&
                   state.phase !== 'ready'
                 ? {
                     ...state,
-                    phase: resolveJumpHopPhaseByElapsedMs(elapsedMs),
+                    phase: resolveBabyObjectMatchPhaseByElapsedMs(elapsedMs),
                   }
-                : state;
+                : state.kind === 'jump-hop' &&
+                    state.phase !== 'failed' &&
+                    state.phase !== 'ready'
+                  ? {
+                      ...state,
+                      phase: resolveJumpHopPhaseByElapsedMs(elapsedMs),
+                    }
+                  : state;
 
   const puzzleTimedSteps =
     normalizedState.kind === 'puzzle'
@@ -944,22 +899,23 @@ export function buildMiniGameDraftGenerationProgress(
   const activeStepIndex = getActiveStepIndex(steps, normalizedState.phase);
   const activeStep = steps[activeStepIndex] ?? steps[0];
   const activeStepProgressRatio =
-    normalizedState.kind === 'puzzle'
+    normalizedState.phase === 'failed'
+      ? 0
+      : normalizedState.kind === 'puzzle'
       ? normalizedState.phase === 'ready'
         ? 1
-        : normalizedState.phase === 'failed'
-          ? 0
-          : resolvePuzzleActiveStepElapsedProgressRatio(
-              normalizedState,
-              puzzleTimedSteps ?? buildPuzzleTimedSteps(normalizedState),
-              activeStepIndex,
-              elapsedMs,
-              effectiveNowMs,
-            )
+        : resolvePuzzleActiveStepElapsedProgressRatio(
+            normalizedState,
+            puzzleTimedSteps ?? buildPuzzleTimedSteps(normalizedState),
+            activeStepIndex,
+            elapsedMs,
+            effectiveNowMs,
+          )
       : normalizedState.totalAssetCount > 0
         ? Math.min(
             1,
-            normalizedState.completedAssetCount / normalizedState.totalAssetCount,
+            normalizedState.completedAssetCount /
+              normalizedState.totalAssetCount,
           )
         : normalizedState.phase === 'ready'
           ? 1
@@ -968,16 +924,16 @@ export function buildMiniGameDraftGenerationProgress(
                 normalizedState.kind,
                 elapsedMs,
               )
-              : normalizedState.kind === 'square-hole'
+            : normalizedState.kind === 'square-hole'
+              ? resolveElapsedActiveStepProgressRatio(
+                  normalizedState.kind,
+                  elapsedMs,
+                )
+              : normalizedState.kind === 'match3d'
                 ? resolveElapsedActiveStepProgressRatio(
                     normalizedState.kind,
                     elapsedMs,
                   )
-                : normalizedState.kind === 'match3d'
-                  ? resolveElapsedActiveStepProgressRatio(
-                    normalizedState.kind,
-                    elapsedMs,
-                  )
                 : normalizedState.kind === 'baby-object-match'
                   ? resolveElapsedActiveStepProgressRatio(
                       normalizedState.kind,
@@ -1002,20 +958,11 @@ export function buildMiniGameDraftGenerationProgress(
       ? Math.max(1, completedWeight)
       : normalizedState.phase === 'ready'
         ? 100
-        : normalizedState.kind === 'puzzle'
-          ? resolvePuzzleOverallProgress(
-              normalizedState,
-              activeStepProgressRatio,
-            )
-          : completedWeight + activeStep.weight * activeStepProgressRatio;
+        : completedWeight + activeStep.weight * activeStepProgressRatio;
   const cappedOverallProgress =
     normalizedState.phase === 'ready' || normalizedState.phase === 'failed'
       ? overallProgress
-      : normalizedState.kind === 'puzzle'
-        ? Math.min(PUZZLE_NON_READY_MAX_PROGRESS, overallProgress)
-        : normalizedState.kind === 'wooden-fish'
-          ? Math.min(PUZZLE_NON_READY_MAX_PROGRESS, overallProgress)
-        : overallProgress;
+      : Math.min(PUZZLE_NON_READY_MAX_PROGRESS, overallProgress);
 
   return {
     phaseId: normalizedState.phase,
@@ -1036,9 +983,9 @@ export function buildMiniGameDraftGenerationProgress(
               ? '��识物�稿已准备完�，�进入结果页继续�布。'
               : normalizedState.kind === 'jump-hop'
                 ? '跳一跳�稿已准备完�，�进入结果页试玩或�布。'
-              : normalizedState.kind === 'wooden-fish'
-                ? '敲木鱼�稿已准备完�，�进入结果页试玩或�布。'
-              : '首关�稿与正�图已准备完�，�进入结果页补作�信�。'
+                : normalizedState.kind === 'wooden-fish'
+                  ? '敲木鱼�稿已准备完�，�进入结果页试玩或�布。'
+                  : '首关�稿与正�图已准备完�，�进入结果页补作�信�。'
         : activeStep.detail),
     batchLabel: activeStep.label,
     overallProgress: clampProgress(cappedOverallProgress),
@@ -1046,10 +993,13 @@ export function buildMiniGameDraftGenerationProgress(
     totalWeight: 100,
     elapsedMs,
     estimatedRemainingMs:
-      normalizedState.phase === 'ready'
+      normalizedState.phase === 'ready' || normalizedState.phase === 'failed'
         ? 0
         : normalizedState.kind === 'puzzle'
-          ? Math.max(0, resolvePuzzleEstimatedWaitMs(normalizedState) - elapsedMs)
+          ? Math.max(
+              0,
+              resolvePuzzleEstimatedWaitMs(normalizedState) - elapsedMs,
+            )
           : normalizedState.kind === 'big-fish'
             ? Math.max(0, 7_000 - elapsedMs)
             : normalizedState.kind === 'square-hole'
@@ -1057,15 +1007,12 @@ export function buildMiniGameDraftGenerationProgress(
               : normalizedState.kind === 'match3d'
                 ? Math.max(0, MATCH3D_ESTIMATED_WAIT_MS - elapsedMs)
                 : normalizedState.kind === 'baby-object-match'
-                  ? Math.max(
-                      0,
-                      BABY_OBJECT_MATCH_ESTIMATED_WAIT_MS - elapsedMs,
-                    )
+                  ? Math.max(0, BABY_OBJECT_MATCH_ESTIMATED_WAIT_MS - elapsedMs)
                   : normalizedState.kind === 'jump-hop'
                     ? Math.max(0, JUMP_HOP_ESTIMATED_WAIT_MS - elapsedMs)
-                  : normalizedState.kind === 'wooden-fish'
-                    ? Math.max(0, WOODEN_FISH_ESTIMATED_WAIT_MS - elapsedMs)
-                  : null,
+                    : normalizedState.kind === 'wooden-fish'
+                      ? Math.max(0, WOODEN_FISH_ESTIMATED_WAIT_MS - elapsedMs)
+                      : null,
     activeStepIndex,
     steps: buildMiniGameProgressSteps(
       steps,