From 21ac5642e891bb642d0ac9414f810b026ff5c973 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BA=94=E9=A6=99=E4=B8=B8=E5=AD=90?= <15518898337@163.com>
Date: Thu, 11 Jun 2026 00:50:18 +0800
Subject: [PATCH] =?UTF-8?q?fix:=20=E5=AE=8C=E5=96=84=E6=8B=BC=E6=B6=88?=
 =?UTF-8?q?=E6=B6=88=E6=A8=A1=E6=9D=BF=E8=BF=90=E8=A1=8C=E8=A7=84=E5=88=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .hermes/shared-memory/decision-log.md         |   6 +-
 .hermes/shared-memory/pitfalls.md             |  32 +
 ...€�玩法创作】拼消消玩法模æ�¿PRD-2026-05-30.md |  30 +-
 ...法创作】拼消消玩法模�技术方案-2026-05-30.md |  24 +-
 ...�玩法创作】平�入�与玩法链路-2026-05-15.md |  16 +-
 .../crates/api-server/src/puzzle_clear.rs     | 794 +++++++++++++++++-
 .../module-puzzle-clear/src/application.rs    | 279 +++++-
 .../spacetime-module/src/puzzle_clear.rs      |  43 +-
 .../PlatformEntryFlowShellImpl.tsx            |  44 +-
 .../PuzzleClearWorkspace.test.tsx             |  90 +-
 .../PuzzleClearWorkspace.tsx                  | 179 ++--
 .../PuzzleClearResultView.test.tsx            |  44 +-
 .../PuzzleClearResultView.tsx                 | 139 ++-
 .../PuzzleClearRuntimeShell.test.tsx          | 108 ++-
 .../PuzzleClearRuntimeShell.tsx               |  83 +-
 src/index.css                                 |  53 +-
 src/index.test.ts                             |  29 +
 .../puzzleClearLocalRuntime.test.ts           | 136 ++-
 .../puzzle-clear/puzzleClearLocalRuntime.ts   | 140 ++-
 19 files changed, 1952 insertions(+), 317 deletions(-)

diff --git a/.hermes/shared-memory/decision-log.md b/.hermes/shared-memory/decision-log.md
index 68d8cd56..9e13545d 100644
--- a/.hermes/shared-memory/decision-log.md
+++ b/.hermes/shared-memory/decision-log.md
@@ -16,10 +16,10 @@
 
 ---
 
-## 2026-06-03 拼消消收敛为�关 6x6 与 4-sheet 素�策略
+## 2026-06-03 拼消消收敛为 4 关 6x6 与 4-sheet 素�策略
 
 - 背景：最� 4 关 / 135 次消除 / �张大 atlas 方案生图数�和空间一致性�本过高，真实 image2 结果容易被布局�示�诱导�带文字�边框或编�的说明图，�适��行� 1x1 切片。
-- 决策：拼消消�行�收敛为�关 `6x6 / 35 次消除 / 600 秒`，直接解� `1x2`�`1x3`�`2x2`�`2x3`；素�生�改为 4 张 `1024x1536` 竖版 sheet，�张按 `4x6`��格 `256x256` 切片，�由�务端�� `10x10 / 2560x2560` 最终 atlas。形状�比固定为 `1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`，总计 35 个��图案组和 95 个 1x1 �牌切片。
+- 决策：拼消消�行�收敛为 4 关 `6x6` �进规则：第 1 关目标 15�300 秒�仅 `1x2`；第 2 关目标 20�300 秒�解� `1x2/1x3`；第 3 关目标 30�420 秒�解� `1x2/1x3/2x2`；第 4 关目标 35�600 秒�解�全部 `1x2/1x3/2x2/2x3`。目标消除数就是本关实际��图案组总数，胜利�件永远是消除完本关全部�牌；棋盘放�下的牌进入顶部准备区，牌�足棋盘格数时�留空格并露出背景图。素�生��使用 4 张 `1024x1536` 竖版 sheet，�张按 `4x6`��格 `256x256` 切片，�由�务端�� `10x10 / 2560x2560` 最终 atlas。形状�比固定为 `1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`，总计 35 个��图案组和 95 个 1x1 �牌切片。
 - 影�范围：`module-puzzle-clear` 关�与图案组规划�api-server 拼消消素�生�编排��端�稿试玩本地 runtime�结果页 atlas 预览�拼消消 PRD / 技术方案 / 平�链路文档。
 - 验�方�：`cargo test -p module-puzzle-clear --manifest-path server-rs/Cargo.toml`�`cargo test -p api-server puzzle_clear --manifest-path server-rs/Cargo.toml -- --nocapture`�`npm run test -- src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts`�`npm run test -- src/components/puzzle-clear-result/PuzzleClearResultView.test.tsx src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`。
 - 关�文档：`docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md`�`docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`�`docs/��端架构】server-rs与SpacetimeDB数�契约-2026-05-15.md`。
@@ -28,7 +28,7 @@
 
 - 背景：拼消消以拼图交�手感为基础，但核心规则从“拼完整�图过关��为“拼�多个��图案组��个消除�，�时需�顶部补牌�防死局���定局部拼接组和正�统计，�能继续�用拼图�行�规则本体。
 - 决策：`puzzle-clear` 作为独立玩法域接入，公开作���缀固定为 `PC-`；创作链路采用表� / 图片输入工作� -> 独立生�页 -> 结果页 -> 试玩 -> �布 -> 统一作�详情 -> 正� runtime。领域规则�在 `module-puzzle-clear`，SpacetimeDB 新增 `puzzle_clear_*` 表 / procedure / view，并接入统一 `public_work_gallery_entry` / `public_work_detail_entry`；�端�表现�端 snapshot/action 结果，�把胜负�补牌或消除�决���端事实�。
-- 补充约�：�稿编译和�布都必须拒�缺失或 `placeholder` atlas / card assets，��许�端 facade 或 SpacetimeDB ��临时素�；当��关正� runtime 终�事件使用 `run-finished`�`level-failed`，并写入包� `status`�`level`�`clears`�`clearDelta`�`elapsedMs` 的结果 JSON。
+- 补充约�：�稿编译和�布都必须拒�缺失或 `placeholder` atlas / card assets，��许�端 facade 或 SpacetimeDB ��临时素�；正� runtime 终�事件使用 `run-finished`�`level-failed`，并写入包� `status`�`level`�`clears`�`clearDelta`�`elapsedMs` 的结果 JSON。
 - 补充约�：拼消消结果页�稿试玩使用�端本地 `runtimeMode=draft` snapshot，�调用 `/api/runtime/puzzle-clear/runs`，�写正� run 统计；公开详情和推��正��行继续走�端 `/api/runtime/puzzle-clear/*`，客户端需�区分创作详情 `/api/creation/puzzle-clear/works/{profileId}` 与公开�行�详情 `/api/runtime/puzzle-clear/works/{profileId}`。
 - 影�范围：`CONTEXT.md`�拼消消 PRD / 技术方案�平�玩法链路文档�`shared-contracts` / `packages/shared`�`api-server`�`spacetime-module`�`spacetime-client`�作�架 / 广场 / 统一作�详情 / runtime �端分�。
 - 验�方�：PRD 和技术方案必须覆盖资产槽��素�工作表风险�切片验����语义�API 命�空间和验�命令；实现侧至少�行 `npm run spacetime:generate`�`npm run check:spacetime-schema`�`npm run check:spacetime-runtime-access`�`npm run check:server-rs-ddd`�`npm run typecheck`�`npm run check:encoding`�相关�端测试和 `cargo test -p module-puzzle-clear --manifest-path server-rs/Cargo.toml`。
diff --git a/.hermes/shared-memory/pitfalls.md b/.hermes/shared-memory/pitfalls.md
index f5fd1ae3..4163c3ac 100644
--- a/.hermes/shared-memory/pitfalls.md
+++ b/.hermes/shared-memory/pitfalls.md
@@ -120,6 +120,22 @@
 - 验�：`npm run test -- src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`，�览器里确认局部拼�会闪�完整消除会放大淡出�补牌在淡出�段�开始掉�。
 - 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/index.css`�`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`。
 
+## 拼消消补牌下��层�能比动画���载
+
+- 现象：�牌补牌下�时看起��是闪一下就切到目标格，下滑过程�连贯，途中还会闪出白色底。
+- 原因：补牌�层的清�时间�按消除动画固定时长计算，没有覆盖�张�自己的下�延迟�下��离时长和收尾缓冲；�时下��层曾带 `bg-white` / `border-white` 外壳，动画起点�明度和�亮滤镜会把外壳闪�白�。
+- 处�：下��片按�离写入 `--puzzle-clear-drop-duration`，清�定时器� `delay + duration + settle buffer` 的最大值；CSS 下�动画使用 `translate3d`�轻微过冲和回弹，�层���明�无边框�无亮度��，�渲染真实�片图。
+- 验�：`npm run test -- src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx src/index.test.ts`；�览器里完整消除�新补入�牌应有连续下滑和轻微��感，过程中�应出现白色闪�。
+- 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/index.css`�`src/index.test.ts`�`docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md`。
+
+## 拼消消替�飞行层�飞目标�且�能带白底
+
+- 现象：按下�牌�拖动覆盖�一张�并完�替�时，被替�的��在新�置先闪一下白底，然��显示正确图�。
+- 原因：替�飞行层如果�用被拖动的��，并且容器本身带 `background: white` / 白色边框，就会和拖拽 ghost ���在目标格附近；真正应该回到�空�的目标�没有覆盖��空槽，视觉上就会露出白壳或白底。
+- 处�：拖拽 ghost �负责���到目标格；`swapFlight` 必须使用被覆盖的 `target.card`，从目标格飞回�空�。飞行层容器���明�无边框，阴影�加在真实�图上。
+- 验�：`npm run test -- src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx src/index.test.ts` 覆盖目标�图片进入 `puzzle-clear-swap-flight`，并断言 `.puzzle-clear-swap-flight` ��出现白底或白边。
+- 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/index.css`�`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`�`src/index.test.ts`。
+
 ## 首页推�分��数�能�件性调用 hook
 
 - 现象：桌�首页或移动首页在 HMR�断点切�或�新渲染�直接报 React hook 顺�错误，页��在“正在加载内容�。
@@ -1825,6 +1841,22 @@
 - 验�：�览器拖拽时能看到跟手 ghost���空槽��点飞入和整组拼接层；`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx` 应覆盖这些行为。
 - 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`�`src/index.css`。
 
+## 拼消消整组拖拽越界��端回弹，���无效 swap
+
+- 现象：正�拼消消 runtime 玩到已有局部拼接组�，把整组拖到棋盘边缘外侧，�端弹出“puzzle-clear �标无效�，�端日志里对应 `/api/runtime/puzzle-clear/runs/{runId}/swap`。
+- 原因：�端 `move_locked_group` 会按整组平移�的�个格��边界校验；�端早期�校验�手目标格存在，没有校验整组的其它格�是�会越界，因此会把�端必然拒�的动作�出去。
+- 处�：拖动带 `lockedGroupId` 的拼接组时，�端先用当� board snapshot 计算 `rowDelta/colDelta`，确认组内所有格�平移��在棋盘内；越界时�播放回弹，�调用 `onSwapCards`。�端继续�留最终规则�决；`puzzle-clear �标无效`�缺��� playing�超时这类玩法动作校验错误应映射为 400，��误判为网关问题。
+- 验�：`npm run test -- src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx` 覆盖“已拼接局部拖到会越界的�置时�回弹��交�端动作�；`cargo check -p api-server --manifest-path server-rs/Cargo.toml` 通过。
+- 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx`�`server-rs/crates/module-puzzle-clear/src/application.rs`�`server-rs/crates/api-server/src/puzzle_clear.rs`。
+
+## 拼消消多行局部拼��按连通�整体�定和拖起
+
+- 现象：`2x2` 或 `2x3` 图案拼� L 形�转角或多行局部�，玩家拖起已拼�组时会看到有一张�没有被拿起，�留在格�层里，并被格�白底或�定组覆盖层压�。
+- 原因：��定局部拼接组如果�按 `partY/partX` 排��的线性相邻关系判断，会�掉 2D 形状里的分� / 转角连通�；�端如果���起点和线性邻格，也会让未写入�一 `lockedGroupId` 的�继续按普通格�层渲染。
+- 处�：本地�稿 runtime 和 Rust `module-puzzle-clear` 都�按�组�牌“素��标相邻且棋盘格相邻�的连通�识别��定组，`1x3`�`2x2`�`2x3` 的局部拼�必须整体写入�一个 `lockedGroupId`。�端拖起�定组时，活动组覆盖层��渲染；组内所有�格标记为 `drag-group-source`，格�层�渲染�图，��留�明空槽，�图�出现在 `document.body` portal 里的 drag ghost。
+- 验�：`npm run test -- src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts`�`cargo test -p module-puzzle-clear --manifest-path server-rs/Cargo.toml`。
+- 关�：`src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx`�`src/services/puzzle-clear/puzzleClearLocalRuntime.ts`�`server-rs/crates/module-puzzle-clear/src/application.rs`�`src/index.css`。
+
 ## 拼消消空格�必须�许��，�能当���交互死格
 
 - 现象：�行到�一关�，棋盘里出现空格�，用户能看�空洞但拖�进去，也点�动。
diff --git a/docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md b/docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md
index 6adfb9a7..8c6e1a41 100644
--- a/docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md
+++ b/docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md
@@ -17,8 +17,8 @@
 - 工作�模�：表� / 图片输入创作工作�。
 - 创作链路：入� -> 工作� -> 生�页 -> 结果页 -> 试玩 -> �布 -> �行�。
 - �图资产槽�：
-  - `board-background` / `ui-background` / `中央场地底图` / `boardBackgroundPrompt` 优先�空值时回退 `themePrompt`，并支�用户上传图 / 写回 `draft.boardBackgroundAsset`�`draft.boardBackgroundPrompt`�`work.boardBackgroundAsset` 与 `work.boardBackgroundPrompt` / �许历�图 / �许 AI �绘。
-  - 中央场地底图的字段�沿用平�表��径，实际作用是玩家�步消除清空中央棋盘�慢慢看到的主题目标图；AI 生�尺寸必须与中央棋盘一致，使用 1:1 正方形画�。prompt 必须强绑定主题�画�精致�强表现力并一眼体现主题，带�探索��开全貌和追求目标完�的感�；�得继续�求“画�干净�或“适�作为�牌棋盘底图�。
+  - `board-background` / `ui-background` / `背景图` / `boardBackgroundPrompt` 优先�空值时回退 `themePrompt`，并支�用户上传图片或填写画��述生图 / 写回 `draft.boardBackgroundAsset`�`draft.boardBackgroundPrompt`�`work.boardBackgroundAsset` 与 `work.boardBackgroundPrompt` / �许历�图 / �许 AI �绘。
+  - 背景图实际作用是玩家�步消除清空中央棋盘�慢慢看到的主题目标图；AI 生�尺寸必须与中央棋盘一致，使用 1:1 正方形画�。prompt 必须强绑定主题�画�精致�强表现力并一眼体现主题，带�探索��开全貌和追求目标完�的感�；�得继续�求“画�干净�或“适�作为�牌棋盘底图�。
 - 系列素�槽�：
   - `batchId=puzzle-clear-pattern-atlas-v1`。
   - `sheetSpec`：4 张素�工作表，�张 `1024x1536` 竖版，��按 `4 列 x 6 行` �切，�个 1x1 �元为 `256x256`；�务端�把切片��一张 `10x10 / 2560x2560` 最终 atlas。��图案组总数为 `35`，形状�比 `1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`，总计 `95` 个 1x1 �牌切片。
@@ -36,12 +36,12 @@
 
 | 字段 | 契约字段 | 默认值 | 校验 | �库 |
 | --- | --- | --- | --- | --- |
-| 作�标题 | `workTitle` | 空 | 必填，1-30 字 | session draft / work profile |
-| 简介 | `workDescription` | 空 | 0-120 字 | session draft / work profile |
-| 主题� | `themePrompt` | 空 | 必填，1-80 字 | 生� prompt 与�稿 |
-| 场地底图主题� | `boardBackgroundPrompt` | 空 | 0-80 字；为空时底图生�回退 `themePrompt` | session draft / work profile / 主题目标图生� prompt |
-| 中央场地底图 | `boardBackgroundAsset` | 空 | 上传或 AI 生�至少一� | �图资产槽� |
-| AI 生�底图 | `generateBoardBackground` | `true` | boolean | 生�编排�数 |
+| �牌素�主题 | `themePrompt` | 空 | 必填，1-80 字 | 生� prompt 与�稿；工作�内部派生�稿��标题，��用户展示作�标题输入 |
+| 画��述 | `boardBackgroundPrompt` | 空 | 0-80 字；为空时背景图生�回退 `themePrompt` | session draft / work profile / 主题目标图生� prompt |
+| 背景图 | `boardBackgroundAsset` | 空 | 上传图片或 AI 生�至少一� | �图资产槽� |
+| AI 生�背景图 | `generateBoardBackground` | `true` | boolean | 生�编排�数 |
+
+作�标题 `workTitle` 与简介 `workDescription` �属于工作�游�内容�置；�布�检查环节必须让用户填写 / 修改标题与简介，�存为 `update-work-meta` ���布。工作�阶段�展示玩法标题��牌素�主题和背景图�置；背景图�以上传图片，也�以填写画��述�使用 AI 生�，��在�一界�混排�布元信�。
 
 规则�数�开放创作者编辑：棋盘尺寸�倒计时�消除次数�形状解��防死局�牌和��定规则固定。
 
@@ -49,20 +49,24 @@
 
 | 关� | 棋盘 | 目标消除 | 倒计时 | 解�形状 |
 | --- | --- | --- | --- | --- |
-| 1 | 6x6 | 35 | 10 分钟 | 1x2�1x3�2x2�2x3 |
+| 1 | 6x6 | 15 | 5 分钟 | 1x2 |
+| 2 | 6x6 | 20 | 5 分钟 | 1x2�1x3 |
+| 3 | 6x6 | 30 | 7 分钟 | 1x2�1x3�2x2 |
+| 4 | 6x6 | 35 | 10 分钟 | 1x2�1x3�2x2�2x3 |
 
-- 开局�个�格�从背�翻�正�。
+- 开局�放入本关目标消除数对应的全部�牌；棋盘放�下的牌进入顶部准备区，牌�足棋盘格数时空格�留。
+- �个有�牌的�格�从背�翻�正�。
 - �消除图由横�或纵���图案组组�，最�消除��为两张图拼接。
 - 完�一个��图案组�，该组所有 1x1 �牌碎片消除。
-- 消除�空�按列由顶部�牌准备区下�补�。
+- 消除�空�按列由顶部�牌准备区下�补�；若顶部没有新牌，则空格留在场上并露出背景图。
 - �次补牌至少��掉��中有一张�以与场上剩余�张�拼接，防止死局。
 - � 2 格消除时，若场上已有局部完�的��定拼接组，补牌�得破�它。
 - ��定拼接组�整体拖动；玩家用外部�格撞入组内�格时，�交�该格，组其余部分�留，组状�退回�完�。
-- 超时�判当�关失败，��试当�关；完� 35 次目标并清空当�棋盘�整局完�。
+- 超时�判当�关失败，��试当�关；胜利�件永远是消除完本关全部�牌，达到目标消除数且棋盘与顶部准备区都没有剩余�牌�进入下一关，完�第 4 关全部�牌�整局完�。
 
 ## 结果页
 
-结果页展示：素� atlas�中央场地底图��布状��试玩入�和失败�试。结果页�写功能说明类文案，�开放规则编辑器，�新增排行榜�置。
+结果页展示：素� atlas�背景图��布状��试玩入�和失败�试。点击�布时弹出�布�检查��，收集作�标题和简介并�存作�信����布。结果页�写功能说明类文案，�开放规则编辑器，�新增排行榜�置。
 
 ## 统计
 
diff --git a/docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md b/docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md
index b66efa99..6bdb65ed 100644
--- a/docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md
+++ b/docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md
@@ -28,17 +28,19 @@
 | 形状 | 数� | �组�元数 | 解� |
 | --- | ---: | ---: | --- |
 | 1x2 | 23 | 2 | 第 1 关 |
-| 1x3 | 5 | 3 | 第 1 关 |
-| 2x2 | 4 | 4 | 第 1 关 |
-| 2x3 | 3 | 6 | 第 1 关 |
+| 1x3 | 5 | 3 | 第 2 关 |
+| 2x2 | 4 | 4 | 第 3 关 |
+| 2x3 | 3 | 6 | 第 4 关 |
 
 �程：
 
 ```text
-主题� / 场地底图主题� / 用户底图 -> 4 张 sheet �标规划 -> gpt-image-2 生�素�工作表 -> 按 4x6 �切 1x1 -> ��最终 atlas -> atlas 与�牌切片�久化 -> OSS / asset_object / bind -> session draft 回写
+�牌素�主题 / 背景图画��述 / 用户背景图 -> 4 张 sheet �标规划 -> gpt-image-2 生�素�工作表 -> 按 4x6 �切 1x1 -> ��最终 atlas -> atlas 与�牌切片�久化 -> OSS / asset_object / bind -> session draft 回写
 ```
 
-中央场地底图的 prompt ��固定为：若用户填写 `boardBackgroundPrompt`，AI 生�底图�读�该字段；若该字段为空，�回退读� `themePrompt`。用户直接上传底图资产时��用主题��写该资产，�执行平�资产�久化与�签。中央场地底图在�行��是普通棋盘衬底，而是玩家��消除�牌�露出的主题目标图；生�请求使用与中央棋盘一致的 1:1 正方形尺寸，prompt 必须强调探索��开全貌�追求完�目标�精致主题主视觉和强主题表现，�写“画�干净�或“适�作为�牌棋盘底图�。
+背景图的 prompt ��固定为：若用户填写 `boardBackgroundPrompt`，AI 生�背景图�读�该字段；若该字段为空，�回退读� `themePrompt`。用户直接上传背景图资产时��用主题��写该资产，�执行平�资产�久化与�签。背景图在�行��是整页氛围背景，而是玩家��消除�牌�露出的主题目标图；生�请求使用与中央棋盘一致的 1:1 正方形尺寸，prompt 必须强调探索��开全貌�追求完�目标�精致主题主视觉和强主题表现，�写“画�干净�或“适�作为�牌棋盘底图�。
+
+工作� UI 对�拼图创作�程：左上角�留返回按钮，下方展示大标题“拼消消创作�；工作��收集游�内容�置，包括�牌素�主题和背景图�置。背景图�置通过�一个�图槽�表达“上传图片 / 填写画��述�两�输入方�，槽�标题显示为“背景图�，�述输入显示为“画��述�，工作�内容区��套�外外层信�框。作�标题与简介属于�布元信�，�在工作�出现；�端创建�稿时�按主题派生内部��标题，结果页点击�布时弹出�布�检查��，先通过 `update-work-meta` �存标题 / 简介，�调用�布接�。
 
 ### 素�工作表风险与切片验�
 
@@ -65,13 +67,13 @@
 
 `module-puzzle-clear` 已固定以下规则：
 
-- 关��置：�关 `6x6/35`，600 秒。
+- 关��置：4 关，棋盘�为 `6x6`；第 1 关目标 15�300 秒�仅 `1x2`；第 2 关目标 20�300 秒�解� `1x2/1x3`；第 3 关目标 30�420 秒�解� `1x2/1x3/2x2`；第 4 关目标 35�600 秒�解�全部 `1x2/1x3/2x2/2x3`。
 - 图案组�比：`1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`。
-- 开局�机铺满并��至少一步�解。
-- 补牌按列�力下�；补牌����至少一步�解。
+- 开局�放入本关目标消除数对应的全部�牌；棋盘放�下的牌进入顶部准备区，牌�足棋盘格数时空格�留；开局���至少一步�解。
+- 补牌按列�力下�；顶部没有新牌时空格留在场上并露出背景图；补牌�若场上�有�牌则��至少一步�解。
 - 完整图案组消除并清空对应格。
 - ��定拼接组�由玩家主动交� / 撞入打散，补牌�破�。
-- 超时失败�作用于当��关，��试；完� 35 次消除目标并清空棋盘�整局完�。
+- 超时失败�作用于当�关，��试；胜利�件永远是消除完本关全部�牌，达到目标消除数且棋盘与顶部准备区都没有剩余�牌�进入下一关，第 4 关全部�牌消除�整局完�。
 
 ## API 命�空间
 
@@ -94,7 +96,7 @@ api-server 路由熔断使用 SpacetimeDB 创作入��置 `puzzle-clear`，
 
 正� `published` run 记录开局�全局完��当�关失败�耗时和消除统计。runtime action 返回的终�事件包括：
 
-- `run-finished`：第 1 关完�并结�整局，结果 JSON 至少包� `status`�`level`�`clears`�`clearDelta`�`elapsedMs`。
+- `run-finished`：第 4 关完�并结�整局，结果 JSON 至少包� `status`�`level`�`clears`�`clearDelta`�`elapsedMs`。
 - `level-failed`：当�关超时失败，结果 JSON 至少包� `status`�`level`�`clears`�`clearDelta`�`elapsedMs`。
 
 �稿试玩�消费�一份 snapshot/action 结果�表现，�写正�统计。
@@ -108,7 +110,7 @@ api-server 路由熔断使用 SpacetimeDB 创作入��置 `puzzle-clear`，
 - `puzzle-clear-result` -> `/creation/puzzle-clear/result`
 - `puzzle-clear-runtime` -> `/runtime/puzzle-clear`
 
-runtime 移动端优先，首�结构为顶部倒计时 / �关铭牌�顶部列准备区�棋盘�失败 / 完�弹层。棋盘主网格���定组覆盖层和消除 / 掉�覆盖层统一使用 1.5px 格间�。动画包括开场翻转�局部正确拼�高光�完整消除放大淡出和列补牌延迟下�，��有下一关切�。消除和补牌动画�能作为当��端 snapshot 的表现层覆盖；已有场上�片因�力下沉�的最终格�得被旧消除�标或掉�覆盖层��，��出现“下方空�但上方�片未下��的视觉�象；新补入�牌应等完整消除淡出进入尾段��播放下��馈。
+runtime 移动端优先，首�结构为顶部倒计时 / 关�铭牌�顶部列准备区�棋盘�失败 / 完�弹层。棋盘主网格���定组覆盖层和消除 / 掉�覆盖层统一使用 1.5px 格间�。动画包括开场翻转�局部正确拼�高光�完整消除放大淡出�列补牌延迟下�和关�完��的下一关切�。消除和补牌动画�能作为当��端 snapshot 的表现层覆盖；已有场上�片因�力下沉�的最终格�得被旧消除�标或掉�覆盖层��，��出现“下方空�但上方�片未下��的视觉�象；新补入�牌应等完整消除淡出进入尾段��播放下��馈。列补牌下�的过渡层生命周期必须覆盖 `delay + duration + settle buffer`，并按下��离延长动画时长，���层在延迟�刚出现就被�载；下��层�得带白色背景�白色边框或�亮滤镜，�片图本身负责视觉主体，��下滑时白闪。拖拽覆盖替�时，拖动�由拖拽 ghost �到目标格，被覆盖的目标��使用替�飞行层回到�空�；替�飞行层�样�得带白底�白边或白色外壳，��目标�在新�置先闪白�显示。
 
 ## 验�计划
 
diff --git a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
index 3a6fb116..e0f6b8a2 100644
--- a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
+++ b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
@@ -193,20 +193,20 @@ RPG / 拼图等�行�存档�以 `/api/profile/save-archives` 的�端列
 创作入� -> 轻表�工作� -> 生�过程页 -> 结果页 -> 试玩 -> �布 -> 统一作�详情 -> 正��行�
 ```
 
-工作�字段固定为作�标题�简介�主题��场地底图主题� `boardBackgroundPrompt`�中央场地底图槽��是� AI 生�底图。中央场地底图必须�用 `CreativeImageInputPanel`，支�上传�历�图和 AI �绘；若用户填写 `boardBackgroundPrompt`，AI 生�底图�读�该字段，字段为空时�回退读� `themePrompt`；用户上传底图时��用主题��写该资产。中央场地底图的字段��留平��径，但实际语义是玩家�步消除清空棋盘�露出的主题目标图，生�尺寸必须与中央棋盘一致，按 1:1 正方形出图；prompt 必须强绑定主题�画�精致�强表现力并一眼体现主题，���求“画�干净�或“适�作为�牌棋盘底图�。�行�必须把中央场地底图作为棋盘内部��底图使用，�能�级�整页氛围背景；�牌消除�产生的空�和拖拽��应露出该棋盘底图。��背�背景 v1 使用默认��图，�作为创作者�置项。规则�数�开放编辑：�关 `6x6`��局 10 分钟�35 次目标消除�形状解��防死局�牌和��定规则�由�端规则集固定。
+工作�字段固定为�牌素�主题 `themePrompt`�背景图画��述 `boardBackgroundPrompt`�背景图槽�和是� AI 生�背景图；作�标题与简介�在工作�填写，�布�检查环节�存为作�信����布。背景图必须�用 `CreativeImageInputPanel`，支�上传�历�图和 AI �绘；工作�界�用�一槽�表达“上传图片 / 填写画��述�两�输入方�，槽�标题显示为“背景图�，�述输入显示为“画��述�，内容区��套�外外层信�框。若用户填写 `boardBackgroundPrompt`，AI 生�背景图�读�该字段，字段为空时�回退读� `themePrompt`；用户上传背景图时��用主题��写该资产。背景图的实际语义是玩家�步消除清空棋盘�露出的主题目标图，生�尺寸必须与中央棋盘一致，按 1:1 正方形出图；prompt 必须强绑定主题�画�精致�强表现力并一眼体现主题，���求“画�干净�或“适�作为�牌棋盘底图�。�行�必须把背景图作为棋盘内部��底图使用，�能�级�整页氛围背景；�牌消除�产生的空�和拖拽��应露出该棋盘底图。��背�背景 v1 使用默认��图，�作为创作者�置项。规则�数�开放编辑：4 关棋盘�为 `6x6`；第 1 关目标 15�5 分钟�仅 `1x2`，第 2 关目标 20�5 分钟�解� `1x2/1x3`，第 3 关目标 30�7 分钟�解� `1x2/1x3/2x2`，第 4 关目标 35�10 分钟�解� `1x2/1x3/2x2/2x3`；防死局�牌和��定规则�由�端规则集固定。
 
-素�生�使用拼消消专用编排，但必须�用 `platform-image`�VectorEngine `gpt-image-2`�OSS�`asset_object`��签和失败审计。素�目标是 4 张 `1024x1536` 竖版工作表，�张��按 `4 列 x 6 行` �切，�格 `256x256`；�务端从工作表切出总计 95 个 1x1 �牌碎片，���一张 `10x10 / 2560x2560` 最终 atlas。��图案组总数固定为 35，形状�比固定为 `1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`。�务端先预排�个��图案组的 sheet 布局�最终 atlas �标和形状，�按�标切� 1x1 �牌碎片作为�行�素�；sheet 生图 prompt �能�求��图案组�按�� 4x6 �等切� 1x1 方形�份，�能让模型在�图案上绘制切分线�边框�网格线�编�或�切�考线。当��有�关，�关内��图案���。�稿编译和�布都必须使用 api-server 已�久化的真实 atlas / card assets，拒�缺失�空对象键或 `placeholder` ��素�，��许 `spacetime-client` 或 SpacetimeDB 侧��临时素�绕过平�图片底座。
+素�生�使用拼消消专用编排，但必须�用 `platform-image`�VectorEngine `gpt-image-2`�OSS�`asset_object`��签和失败审计。素�目标是 4 张 `1024x1536` 竖版工作表，�张��按 `4 列 x 6 行` �切，�格 `256x256`；�务端从工作表切出总计 95 个 1x1 �牌碎片，���一张 `10x10 / 2560x2560` 最终 atlas。��图案组总数固定为 35，形状�比固定为 `1x2=23`�`1x3=5`�`2x2=4`�`2x3=3`。�务端先预排�个��图案组的 sheet 布局�最终 atlas �标和形状，�按�标切� 1x1 �牌碎片作为�行�素�；sheet 生图 prompt �能�求��图案组�按�� 4x6 �等切� 1x1 方形�份，�能让模型在�图案上绘制切分线�边框�网格线�编�或�切�考线。4 关�用�一套 atlas，根�关�解�形状和目标数选择�用图案组；�关内��图案���。�稿编译和�布都必须使用 api-server 已�久化的真实 atlas / card assets，拒�缺失�空对象键或 `placeholder` ��素�，��许 `spacetime-client` 或 SpacetimeDB 侧��临时素�绕过平�图片底座。
 
 �行�规则：
 
-1. �关固定为 `6x6 / 35次消除`。
-2. �局固定 10 分钟；超时�判当�关失败，��试当�关。
-3. 当�关直接出现 `1x2`�`1x3`�`2x2` 和 `2x3`。
-4. 开局棋盘�机铺满并��至少一步�解；补牌�也必须由�端��至少一步�解。
-5. 顶部�牌准备区按纵列补�，�列有空格时该列�牌从顶部下�。
+1. 4 关棋盘�固定为 `6x6`。
+2. 第 1 / 2 / 3 / 4 关目标分别为 `15 / 20 / 30 / 35` 次消除，�时分别为 `5 / 5 / 7 / 10` 分钟；超时�判当�关失败，��试当�关。
+3. 第 1 关仅出现 `1x2`；第 2 关出现 `1x2`�`1x3`；第 3 关出现 `1x2`�`1x3`�`2x2`；第 4 关出现 `1x2`�`1x3`�`2x2`�`2x3`。
+4. 开局�放入本关目标消除数对应的全部�牌，棋盘放�下的牌进入顶部准备区，牌�足棋盘格数时空格�留；开局���至少一步�解。
+5. 顶部�牌准备区按纵列补�，�列有空格时该列�牌从顶部下�；顶部没有新牌时空格留在场上并露出背景图。胜利�件永远是消除完本关全部�牌，达到目标消除数且棋盘与顶部准备区都没有剩余�牌��进入下一关。
 6. � 2 格消除时，补牌�得破�已完�局部；�有玩家主动交�或撞入��许打散��定拼接组。
 7. 正� runtime �消费�端 snapshot 与 action 结果；�端负责开局翻转�拖拽�掉��消除和弹层动画。
-   拖拽手感必须对�拼图模�：开局��片�翻转一次，交����得�新翻牌；按�����片立�跟�鼠标或手指，��置�时留出空槽；放下时被替��片�快速飞�对应空�；已完�局部拼接组�以连续整体呈现并�作为整组拖起。拖拽浮层必须挂到页�级 `document.body` portal，��平�壳层 transform 让 `position: fixed` 和 `clientX/clientY` �标系错�。
+   拖拽手感必须对�拼图模�：开局��片�翻转一次，交����得�新翻牌；按�����片立�跟�鼠标或手指，��置�时留出空槽；放下时被替��片�快速飞�对应空�；已完�局部拼接组�以连续整体呈现并�作为整组拖起。��定局部拼接组按�组�牌“素��标相邻且棋盘格相邻�的连通�识别，`1x3`�`2x2`�`2x3` 的转角或多行局部拼�也必须整体写入�一个 `lockedGroupId`，�能���线性排��相邻的一段。拖拽浮层必须挂到页�级 `document.body` portal，��平�壳层 transform 让 `position: fixed` 和 `clientX/clientY` �标系错�；整组拖起期间活动组�能由 portal ghost 展示�图，棋盘格�层标记为拖拽��并���明空槽，�定组覆盖层�得继续渲染正在拖的组。整组拖拽�点必须先以�端当� board snapshot 校验整组平移�的所有格��在棋盘内，越界时�回弹��交 `swap`；�端��留最终规则�决。
 8. 正� `published` run 的终�事件使用 `run-finished` 和 `level-failed`，事件结果 JSON 至少包� `status`�`level`�`clears`�`clearDelta` 和 `elapsedMs`，供基础统计与排障回读。
 
 新增阶段为 `puzzle-clear-workspace`�`puzzle-clear-generating`�`puzzle-clear-result` 和 `puzzle-clear-runtime`；路由为 `/creation/puzzle-clear`�`/creation/puzzle-clear/generating`�`/creation/puzzle-clear/result` 与 `/runtime/puzzle-clear`。API 命�空间为 `/api/creation/puzzle-clear/*` 与 `/api/runtime/puzzle-clear/*`。验�命令� `docs/prd/�玩法创作】拼消消玩法模�PRD-2026-05-30.md` 与 `docs/technical/�玩法创作】拼消消玩法模�技术方案-2026-05-30.md`。
diff --git a/server-rs/crates/api-server/src/puzzle_clear.rs b/server-rs/crates/api-server/src/puzzle_clear.rs
index 1221df47..0aff7483 100644
--- a/server-rs/crates/api-server/src/puzzle_clear.rs
+++ b/server-rs/crates/api-server/src/puzzle_clear.rs
@@ -25,6 +25,8 @@ use shared_kernel::{build_prefixed_uuid_id, format_timestamp_micros};
 use spacetime_client::SpacetimeClientError;
 use std::{
     collections::BTreeMap,
+    env, fs,
+    path::{Path as FsPath, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -38,8 +40,8 @@ use crate::{
     },
     http_error::AppError,
     openai_image_generation::{
-        DownloadedOpenAiImage, build_openai_image_http_client, create_openai_image_generation,
-        require_openai_image_settings,
+        DownloadedOpenAiImage, build_openai_image_http_client, build_openai_image_request_body,
+        create_openai_image_generation, require_openai_image_settings,
     },
     request_context::RequestContext,
     state::AppState,
@@ -599,6 +601,721 @@ struct PuzzleClearGeneratedSheet {
     image: DownloadedOpenAiImage,
 }
 
+#[derive(Clone, Debug)]
+struct PuzzleClearImageDebugRun {
+    root: PathBuf,
+    run_id: String,
+}
+
+impl PuzzleClearImageDebugRun {
+    fn record_spec(
+        &self,
+        sheet_specs: &[PuzzleClearAtlasSheetSpec],
+        groups: &[PuzzleClearPatternGroup],
+    ) {
+        let sheets = sheet_specs
+            .iter()
+            .map(|spec| {
+                json!({
+                    "sheetId": spec.sheet_id,
+                    "layout": spec.layout.iter().map(|row| row.to_vec()).collect::<Vec<_>>(),
+                    "layoutPrompt": spec.layout_prompt,
+                })
+            })
+            .collect::<Vec<_>>();
+        let groups = groups
+            .iter()
+            .map(|group| {
+                json!({
+                    "groupId": group.group_id.as_str(),
+                    "shape": group.shape.as_str(),
+                    "width": group.width,
+                    "height": group.height,
+                    "atlasX": group.atlas_x,
+                    "atlasY": group.atlas_y,
+                    "atlasWidth": group.atlas_width,
+                    "atlasHeight": group.atlas_height,
+                })
+            })
+            .collect::<Vec<_>>();
+        self.write_json(
+            "specs/puzzle-clear-debug-spec.json",
+            &json!({
+                "cellSize": PUZZLE_CLEAR_ATLAS_CELL_SIZE,
+                "sheetColumns": PUZZLE_CLEAR_SHEET_COLUMNS,
+                "sheetRows": PUZZLE_CLEAR_SHEET_ROWS,
+                "finalAtlasColumns": PUZZLE_CLEAR_FINAL_ATLAS_COLUMNS,
+                "finalAtlasRows": PUZZLE_CLEAR_FINAL_ATLAS_ROWS,
+                "sheets": sheets,
+                "groups": groups,
+            }),
+            "记录拼消消调试规格失败",
+        );
+    }
+
+    fn record_board_background_request(&self, prompt: &str) {
+        self.write_text(
+            "prompts/board-background.txt",
+            prompt,
+            "记录拼消消底图 prompt 失败",
+        );
+        self.write_json(
+            "requests/board-background.json",
+            &json!({
+                "endpoint": "/v1/images/generations",
+                "body": build_openai_image_request_body(
+                    prompt,
+                    Some("文字�水��按钮�教程浮层�明显网格"),
+                    PUZZLE_CLEAR_BOARD_BACKGROUND_GENERATION_SIZE,
+                    1,
+                    &[],
+                ),
+            }),
+            "记录拼消消底图 request 失败",
+        );
+    }
+
+    fn record_board_background_image(
+        &self,
+        task_id: &str,
+        actual_prompt: Option<&str>,
+        image: &DownloadedOpenAiImage,
+    ) {
+        let extension = puzzle_clear_debug_image_extension(image);
+        self.write_bytes(
+            format!("background/board-background.{extension}"),
+            image.bytes.as_slice(),
+            "记录拼消消底图图片失败",
+        );
+        self.write_json(
+            "responses/board-background.json",
+            &json!({
+                "taskId": task_id,
+                "actualPrompt": actual_prompt,
+                "image": {
+                    "mimeType": image.mime_type.as_str(),
+                    "extension": image.extension.as_str(),
+                    "byteLength": image.bytes.len(),
+                },
+            }),
+            "记录拼消消底图 response 摘�失败",
+        );
+    }
+
+    fn record_board_background_error(&self, error: &AppError) {
+        self.write_json(
+            "responses/board-background.error.json",
+            &puzzle_clear_debug_error_json(error),
+            "记录拼消消底图错误失败",
+        );
+    }
+
+    fn record_sheet_request(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        attempt_index: usize,
+        prompt: &str,
+    ) {
+        let attempt_id = puzzle_clear_debug_attempt_id(attempt_index);
+        self.write_text(
+            format!("prompts/{}.txt", sheet_spec.sheet_id),
+            prompt,
+            "记录拼消消 sheet prompt 失败",
+        );
+        self.write_json(
+            format!("requests/{}-{attempt_id}.json", sheet_spec.sheet_id),
+            &json!({
+                "endpoint": "/v1/images/generations",
+                "sheetId": sheet_spec.sheet_id,
+                "attempt": attempt_index + 1,
+                "body": build_openai_image_request_body(
+                    prompt,
+                    Some(PUZZLE_CLEAR_ATLAS_NEGATIVE_PROMPT),
+                    PUZZLE_CLEAR_ATLAS_GENERATION_SIZE,
+                    1,
+                    &[],
+                ),
+            }),
+            "记录拼消消 sheet request 失败",
+        );
+    }
+
+    fn record_sheet_generation_error(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        attempt_index: usize,
+        error: &AppError,
+    ) {
+        let attempt_id = puzzle_clear_debug_attempt_id(attempt_index);
+        self.write_json(
+            format!("responses/{}-{attempt_id}.error.json", sheet_spec.sheet_id),
+            &json!({
+                "sheetId": sheet_spec.sheet_id,
+                "attempt": attempt_index + 1,
+                "stage": "generation",
+                "error": puzzle_clear_debug_error_json(error),
+            }),
+            "记录拼消消 sheet 生�错误失败",
+        );
+    }
+
+    fn record_sheet_attempt_image(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        attempt_index: usize,
+        task_id: &str,
+        actual_prompt: Option<&str>,
+        image: &DownloadedOpenAiImage,
+    ) {
+        let attempt_id = puzzle_clear_debug_attempt_id(attempt_index);
+        let extension = puzzle_clear_debug_image_extension(image);
+        self.write_bytes(
+            format!("sheets/{}-{attempt_id}.{extension}", sheet_spec.sheet_id),
+            image.bytes.as_slice(),
+            "记录拼消消 sheet 原图失败",
+        );
+        self.write_json(
+            format!("responses/{}-{attempt_id}.json", sheet_spec.sheet_id),
+            &json!({
+                "sheetId": sheet_spec.sheet_id,
+                "attempt": attempt_index + 1,
+                "taskId": task_id,
+                "actualPrompt": actual_prompt,
+                "image": {
+                    "mimeType": image.mime_type.as_str(),
+                    "extension": image.extension.as_str(),
+                    "byteLength": image.bytes.len(),
+                },
+            }),
+            "记录拼消消 sheet response 摘�失败",
+        );
+    }
+
+    fn record_sheet_quality(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        attempt_index: usize,
+        task_id: &str,
+        image: &DownloadedOpenAiImage,
+        quality_error: Option<&AppError>,
+    ) {
+        let attempt_id = puzzle_clear_debug_attempt_id(attempt_index);
+        match build_puzzle_clear_sheet_quality_debug_report(
+            sheet_spec,
+            attempt_index,
+            task_id,
+            image,
+            quality_error,
+        ) {
+            Ok(report) => {
+                self.write_json(
+                    format!("reports/{}-{attempt_id}.quality.json", sheet_spec.sheet_id),
+                    &report,
+                    "记录拼消消 sheet 质�报告失败",
+                );
+            }
+            Err(error) => self.write_json(
+                format!("reports/{}-{attempt_id}.quality-error.json", sheet_spec.sheet_id),
+                &puzzle_clear_debug_error_json(&error),
+                "记录拼消消 sheet 质�报告错误失败",
+            ),
+        }
+        self.write_sheet_cells(sheet_spec, attempt_index, image);
+    }
+
+    fn record_sheet_accepted(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        task_id: &str,
+        image: &DownloadedOpenAiImage,
+    ) {
+        let extension = puzzle_clear_debug_image_extension(image);
+        self.write_bytes(
+            format!("accepted/{}.{extension}", sheet_spec.sheet_id),
+            image.bytes.as_slice(),
+            "记录拼消消 accepted sheet 失败",
+        );
+        self.write_json(
+            format!("accepted/{}.json", sheet_spec.sheet_id),
+            &json!({
+                "sheetId": sheet_spec.sheet_id,
+                "taskId": task_id,
+                "accepted": true,
+                "image": {
+                    "mimeType": image.mime_type.as_str(),
+                    "extension": image.extension.as_str(),
+                    "byteLength": image.bytes.len(),
+                },
+            }),
+            "记录拼消消 accepted sheet 摘�失败",
+        );
+    }
+
+    fn record_atlas_image(
+        &self,
+        image: &DownloadedOpenAiImage,
+        generated_sheets: &[PuzzleClearGeneratedSheet],
+    ) {
+        self.write_bytes(
+            "atlas/puzzle-clear-atlas.png",
+            image.bytes.as_slice(),
+            "记录拼消消最终 atlas 失败",
+        );
+        self.write_json(
+            "atlas/puzzle-clear-atlas.json",
+            &json!({
+                "image": {
+                    "mimeType": image.mime_type.as_str(),
+                    "extension": image.extension.as_str(),
+                    "byteLength": image.bytes.len(),
+                },
+                "acceptedSheets": generated_sheets
+                    .iter()
+                    .map(|sheet| json!({
+                        "sheetId": sheet.spec.sheet_id,
+                        "taskId": sheet.task_id.as_str(),
+                    }))
+                    .collect::<Vec<_>>(),
+            }),
+            "记录拼消消最终 atlas 摘�失败",
+        );
+    }
+
+    fn record_summary_success(
+        &self,
+        session_id: &str,
+        profile_id: &str,
+        sheet_count: usize,
+        card_count: usize,
+    ) {
+        self.write_text(
+            "summary.md",
+            format!(
+                concat!(
+                    "# 拼消消 runtime 生图调试\n\n",
+                    "- runId: `{}`\n",
+                    "- sessionId: `{}`\n",
+                    "- profileId: `{}`\n",
+                    "- status: `ready`\n",
+                    "- acceptedSheets: `{}`\n",
+                    "- cardCount: `{}`\n\n",
+                    "关键查看顺�：\n\n",
+                    "1. `prompts/` 和 `requests/`：真实请求内容。\n",
+                    "2. `sheets/`：�次 attempt 的原始 sheet。\n",
+                    "3. `reports/*.quality.json`：�格质�指标和 hard/advisory findings。\n",
+                    "4. `cells/<sheet-attempt>/contact-sheet.png`：4x6 �切总览。\n",
+                    "5. `accepted/`：最终通过门�的 sheet。\n",
+                    "6. `atlas/puzzle-clear-atlas.png`：最终 atlas 预览。\n"
+                ),
+                self.run_id, session_id, profile_id, sheet_count, card_count
+            ),
+            "记录拼消消调试 summary 失败",
+        );
+    }
+
+    fn write_sheet_cells(
+        &self,
+        sheet_spec: &PuzzleClearAtlasSheetSpec,
+        attempt_index: usize,
+        image: &DownloadedOpenAiImage,
+    ) {
+        let attempt_id = puzzle_clear_debug_attempt_id(attempt_index);
+        let result = (|| -> Result<(), AppError> {
+            let source = image::load_from_memory(image.bytes.as_slice()).map_err(|error| {
+                AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                    "provider": PUZZLE_CLEAR_CREATION_PROVIDER,
+                    "message": format!("拼消消素� {} 调试�切解�失败：{error}", sheet_spec.sheet_id),
+                }))
+            })?;
+            let source_width = source.width();
+            let source_height = source.height();
+            let mut contact = image::RgbaImage::from_pixel(
+                PUZZLE_CLEAR_ATLAS_CELL_SIZE * PUZZLE_CLEAR_SHEET_COLUMNS,
+                PUZZLE_CLEAR_ATLAS_CELL_SIZE * PUZZLE_CLEAR_SHEET_ROWS,
+                image::Rgba([255, 255, 255, 0]),
+            );
+            for row in 0..PUZZLE_CLEAR_SHEET_ROWS {
+                for col in 0..PUZZLE_CLEAR_SHEET_COLUMNS {
+                    let group_id = sheet_spec.layout[row as usize][col as usize];
+                    let bounds =
+                        puzzle_clear_sheet_cell_bounds(row, col, source_width, source_height);
+                    let cropped = source
+                        .crop_imm(bounds.x0, bounds.y0, bounds.width(), bounds.height())
+                        .resize_exact(
+                            PUZZLE_CLEAR_ATLAS_CELL_SIZE,
+                            PUZZLE_CLEAR_ATLAS_CELL_SIZE,
+                            image::imageops::FilterType::Lanczos3,
+                        )
+                        .to_rgba8();
+                    let mut cursor = std::io::Cursor::new(Vec::new());
+                    image::DynamicImage::ImageRgba8(cropped.clone())
+                        .write_to(&mut cursor, image::ImageFormat::Png)
+                        .map_err(|error| {
+                            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                                "provider": PUZZLE_CLEAR_CREATION_PROVIDER,
+                                "message": format!("拼消消素� {} 调试�切写入失败：{error}", sheet_spec.sheet_id),
+                            }))
+                        })?;
+                    self.write_bytes(
+                        format!(
+                            "cells/{}-{attempt_id}/r{:02}-c{:02}-{}.png",
+                            sheet_spec.sheet_id,
+                            row + 1,
+                            col + 1,
+                            sanitize_puzzle_clear_debug_segment(group_id, "cell"),
+                        ),
+                        cursor.into_inner().as_slice(),
+                        "记录拼消消 sheet �切格失败",
+                    );
+                    image::imageops::overlay(
+                        &mut contact,
+                        &cropped,
+                        i64::from(col * PUZZLE_CLEAR_ATLAS_CELL_SIZE),
+                        i64::from(row * PUZZLE_CLEAR_ATLAS_CELL_SIZE),
+                    );
+                }
+            }
+            let mut cursor = std::io::Cursor::new(Vec::new());
+            image::DynamicImage::ImageRgba8(contact)
+                .write_to(&mut cursor, image::ImageFormat::Png)
+                .map_err(|error| {
+                    AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                        "provider": PUZZLE_CLEAR_CREATION_PROVIDER,
+                        "message": format!("拼消消素� {} 调试 contact sheet 写入失败：{error}", sheet_spec.sheet_id),
+                    }))
+                })?;
+            self.write_bytes(
+                format!("cells/{}-{attempt_id}/contact-sheet.png", sheet_spec.sheet_id),
+                cursor.into_inner().as_slice(),
+                "记录拼消消 sheet contact sheet 失败",
+            );
+            Ok(())
+        })();
+        if let Err(error) = result {
+            self.write_json(
+                format!("cells/{}-{attempt_id}/error.json", sheet_spec.sheet_id),
+                &puzzle_clear_debug_error_json(&error),
+                "记录拼消消 sheet �切错误失败",
+            );
+        }
+    }
+
+    fn write_text(
+        &self,
+        relative_path: impl AsRef<FsPath>,
+        content: impl AsRef<str>,
+        action: &'static str,
+    ) {
+        self.write_result(action, || {
+            let target = self.root.join(relative_path.as_ref());
+            if let Some(parent) = target.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            fs::write(target, content.as_ref().as_bytes())
+        });
+    }
+
+    fn write_json(&self, relative_path: impl AsRef<FsPath>, value: &Value, action: &'static str) {
+        self.write_result(action, || {
+            let target = self.root.join(relative_path.as_ref());
+            if let Some(parent) = target.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            let mut bytes = serde_json::to_vec_pretty(value)
+                .map_err(|error| std::io::Error::new(std::io::ErrorKind::Other, error))?;
+            bytes.push(b'\n');
+            fs::write(target, bytes)
+        });
+    }
+
+    fn write_bytes(
+        &self,
+        relative_path: impl AsRef<FsPath>,
+        bytes: &[u8],
+        action: &'static str,
+    ) {
+        self.write_result(action, || {
+            let target = self.root.join(relative_path.as_ref());
+            if let Some(parent) = target.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            fs::write(target, bytes)
+        });
+    }
+
+    fn write_result(
+        &self,
+        action: &'static str,
+        operation: impl FnOnce() -> std::io::Result<()>,
+    ) {
+        if let Err(error) = operation() {
+            tracing::warn!(
+                provider = PUZZLE_CLEAR_CREATION_PROVIDER,
+                run_id = self.run_id,
+                debug_path = %self.root.display(),
+                error = %error,
+                action,
+                "拼消消本地生图调试包写入失败，已忽略"
+            );
+        }
+    }
+}
+
+fn maybe_create_puzzle_clear_image_debug_run(
+    session_id: &str,
+    profile_id: &str,
+    theme_prompt: &str,
+) -> Option<PuzzleClearImageDebugRun> {
+    if !puzzle_clear_image_debug_enabled() {
+        return None;
+    }
+    let base_dir = puzzle_clear_image_debug_runs_dir();
+    let run_id = env::var("PUZZLE_CLEAR_IMAGE_DEBUG_RUN_ID")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| {
+            format!(
+                "runtime-{}-{}-{}",
+                sanitize_puzzle_clear_debug_segment(session_id, "session"),
+                sanitize_puzzle_clear_debug_segment(profile_id, "profile"),
+                current_utc_micros()
+            )
+        });
+    let run_id = sanitize_puzzle_clear_debug_segment(run_id.as_str(), "runtime");
+    let root = base_dir.join(run_id.as_str());
+    if let Err(error) = fs::create_dir_all(&root) {
+        tracing::warn!(
+            provider = PUZZLE_CLEAR_CREATION_PROVIDER,
+            debug_path = %root.display(),
+            error = %error,
+            "拼消消本地生图调试包�始化失败，已关闭本次记录"
+        );
+        return None;
+    }
+    let debug_run = PuzzleClearImageDebugRun { root, run_id };
+    debug_run.write_json(
+        "manifest.json",
+        &json!({
+            "runId": debug_run.run_id.as_str(),
+            "source": "api-server-runtime",
+            "playType": "puzzle-clear",
+            "sessionId": session_id,
+            "profileId": profile_id,
+            "themePrompt": theme_prompt,
+            "createdAt": format_timestamp_micros(current_utc_micros()),
+            "env": {
+                "PUZZLE_CLEAR_IMAGE_DEBUG_ENABLED": "1",
+                "PUZZLE_CLEAR_IMAGE_DEBUG_DIR": puzzle_clear_image_debug_runs_dir().display().to_string(),
+            },
+        }),
+        "记录拼消消调试 manifest 失败",
+    );
+    if let Err(error) = fs::write(
+        puzzle_clear_image_debug_runs_dir().join("latest-runtime.txt"),
+        debug_run.root.to_string_lossy().as_bytes(),
+    ) {
+        tracing::warn!(
+            provider = PUZZLE_CLEAR_CREATION_PROVIDER,
+            error = %error,
+            "拼消消本地生图调试包 latest-runtime.txt 写入失败，已忽略"
+        );
+    }
+    tracing::info!(
+        provider = PUZZLE_CLEAR_CREATION_PROVIDER,
+        run_id = debug_run.run_id.as_str(),
+        debug_path = %debug_run.root.display(),
+        "拼消消本地生图调试包已开�"
+    );
+    Some(debug_run)
+}
+
+fn puzzle_clear_image_debug_enabled() -> bool {
+    env::var("PUZZLE_CLEAR_IMAGE_DEBUG_ENABLED")
+        .ok()
+        .map(|value| {
+            matches!(
+                value.trim().to_ascii_lowercase().as_str(),
+                "1" | "true" | "yes" | "on"
+            )
+        })
+        .unwrap_or(false)
+}
+
+fn puzzle_clear_image_debug_runs_dir() -> PathBuf {
+    env::var("PUZZLE_CLEAR_IMAGE_DEBUG_DIR")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            puzzle_clear_repo_root()
+                .join(".app")
+                .join("puzzle-clear-image-debug")
+                .join("runs")
+        })
+}
+
+fn puzzle_clear_repo_root() -> PathBuf {
+    let current_dir = env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    for candidate in current_dir.ancestors() {
+        if candidate.join("server-rs").is_dir() && candidate.join("package.json").is_file() {
+            return candidate.to_path_buf();
+        }
+    }
+    current_dir
+}
+
+fn puzzle_clear_debug_attempt_id(attempt_index: usize) -> String {
+    format!("attempt-{:02}", attempt_index + 1)
+}
+
+fn puzzle_clear_debug_image_extension(image: &DownloadedOpenAiImage) -> String {
+    sanitize_puzzle_clear_debug_segment(
+        image
+            .extension
+            .trim()
+            .trim_start_matches('.')
+            .to_ascii_lowercase()
+            .as_str(),
+        "png",
+    )
+}
+
+fn sanitize_puzzle_clear_debug_segment(raw: &str, fallback: &str) -> String {
+    let mut value = String::new();
+    for character in raw.chars() {
+        if character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.') {
+            value.push(character);
+        } else {
+            value.push('-');
+        }
+    }
+    let value = value.trim_matches('-').trim_matches('.').to_string();
+    if value.is_empty() {
+        fallback.to_string()
+    } else {
+        value
+    }
+}
+
+fn puzzle_clear_debug_error_json(error: &AppError) -> Value {
+    json!({
+        "statusCode": error.status_code().as_u16(),
+        "code": error.code(),
+        "message": error.body_text(),
+        "details": error.details(),
+    })
+}
+
+fn build_puzzle_clear_sheet_quality_debug_report(
+    sheet_spec: &PuzzleClearAtlasSheetSpec,
+    attempt_index: usize,
+    task_id: &str,
+    image: &DownloadedOpenAiImage,
+    quality_error: Option<&AppError>,
+) -> Result<Value, AppError> {
+    let source = image::load_from_memory(image.bytes.as_slice()).map_err(|error| {
+        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": PUZZLE_CLEAR_CREATION_PROVIDER,
+            "message": format!("拼消消素� {} 调试质�报告解�失败：{error}", sheet_spec.sheet_id),
+        }))
+    })?;
+    let source_width = source.width();
+    let source_height = source.height();
+    let mut hard_findings = Vec::new();
+    let mut advisory_findings = Vec::new();
+    let mut cells = Vec::new();
+    for row in 0..PUZZLE_CLEAR_SHEET_ROWS {
+        for col in 0..PUZZLE_CLEAR_SHEET_COLUMNS {
+            let group_id = sheet_spec.layout[row as usize][col as usize];
+            let bounds = puzzle_clear_sheet_cell_bounds(row, col, source_width, source_height);
+            let quality =
+                analyze_puzzle_clear_sheet_cell_quality(&source, sheet_spec, row, col, bounds);
+            let cell_label = format!("第{}行第{}列", row + 1, col + 1);
+            let mut cell_findings = Vec::new();
+            let mut cell_advisory_findings = Vec::new();
+
+            if group_id == PUZZLE_CLEAR_SHEET_UNUSED_CELL {
+                if quality.foreground_ratio > PUZZLE_CLEAR_SHEET_BLANK_MAX_FOREGROUND_RATIO {
+                    let finding = format!("{cell_label} 空白格有主体");
+                    hard_findings.push(finding.clone());
+                    cell_findings.push(finding);
+                }
+            } else if group_id != PUZZLE_CLEAR_SHEET_FILLER_CELL {
+                if quality.foreground_ratio < PUZZLE_CLEAR_SHEET_MIN_FOREGROUND_RATIO {
+                    let finding = format!("{cell_label} 主体过少");
+                    hard_findings.push(finding.clone());
+                    cell_findings.push(finding);
+                }
+                if quality.strongest_internal_seam_ratio
+                    > PUZZLE_CLEAR_SHEET_INTERNAL_SEAM_RATIO_THRESHOLD
+                {
+                    let finding = format!("{cell_label} �格内部疑似拼接线");
+                    hard_findings.push(finding.clone());
+                    cell_findings.push(finding);
+                }
+                if quality.exposed_edge_count >= 2
+                    && quality.strongest_edge_ratio
+                        > PUZZLE_CLEAR_SHEET_STRONG_EDGE_RATIO_THRESHOLD
+                {
+                    let finding = format!("{cell_label} 主体贴到��图案边界");
+                    advisory_findings.push(finding.clone());
+                    cell_advisory_findings.push(finding);
+                }
+            }
+
+            cells.push(json!({
+                "row": row + 1,
+                "col": col + 1,
+                "groupId": group_id,
+                "discarded": is_puzzle_clear_sheet_discarded_cell(group_id),
+                "bounds": {
+                    "x0": bounds.x0,
+                    "y0": bounds.y0,
+                    "x1": bounds.x1,
+                    "y1": bounds.y1,
+                },
+                "foregroundRatio": quality.foreground_ratio,
+                "exposedEdgeCount": quality.exposed_edge_count,
+                "strongestEdgeRatio": quality.strongest_edge_ratio,
+                "strongestInternalSeamRatio": quality.strongest_internal_seam_ratio,
+                "hardFindings": cell_findings,
+                "advisoryFindings": cell_advisory_findings,
+            }));
+        }
+    }
+
+    Ok(json!({
+        "sheetId": sheet_spec.sheet_id,
+        "attempt": attempt_index + 1,
+        "taskId": task_id,
+        "accepted": quality_error.is_none(),
+        "image": {
+            "width": source_width,
+            "height": source_height,
+            "mimeType": image.mime_type.as_str(),
+            "extension": image.extension.as_str(),
+            "byteLength": image.bytes.len(),
+        },
+        "thresholds": {
+            "foregroundDiff": PUZZLE_CLEAR_SHEET_FOREGROUND_DIFF_THRESHOLD,
+            "minForegroundRatio": PUZZLE_CLEAR_SHEET_MIN_FOREGROUND_RATIO,
+            "blankMaxForegroundRatio": PUZZLE_CLEAR_SHEET_BLANK_MAX_FOREGROUND_RATIO,
+            "edgeRatio": PUZZLE_CLEAR_SHEET_EDGE_RATIO_THRESHOLD,
+            "strongEdgeRatio": PUZZLE_CLEAR_SHEET_STRONG_EDGE_RATIO_THRESHOLD,
+            "internalSeamDiff": PUZZLE_CLEAR_SHEET_INTERNAL_SEAM_DIFF_THRESHOLD,
+            "internalSeamRatio": PUZZLE_CLEAR_SHEET_INTERNAL_SEAM_RATIO_THRESHOLD,
+            "internalSeamSideContrast": PUZZLE_CLEAR_SHEET_INTERNAL_SEAM_SIDE_CONTRAST_THRESHOLD,
+            "internalSeamSideTextureMax": PUZZLE_CLEAR_SHEET_INTERNAL_SEAM_SIDE_TEXTURE_MAX,
+        },
+        "hardFindings": hard_findings,
+        "advisoryFindings": advisory_findings,
+        "qualityError": quality_error.map(puzzle_clear_debug_error_json),
+        "cells": cells,
+    }))
+}
+
 async fn maybe_prepare_puzzle_clear_assets_inner(
     state: &AppState,
     request_context: &RequestContext,
@@ -633,8 +1350,13 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
         .map(ToString::to_string)
         .unwrap_or_else(|| {
             build_prefixed_uuid_id(module_puzzle_clear::PUZZLE_CLEAR_PROFILE_ID_PREFIX)
-        });
+    });
     payload.profile_id = Some(profile_id.clone());
+    let image_debug_run = maybe_create_puzzle_clear_image_debug_run(
+        session_id,
+        profile_id.as_str(),
+        payload.theme_prompt.as_deref().unwrap_or_default(),
+    );
 
     if payload.generate_board_background.unwrap_or(false)
         && payload
@@ -654,6 +1376,7 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
             owner_user_id,
             profile_id.as_str(),
             board_background_prompt.unwrap_or(theme_prompt),
+            image_debug_run.as_ref(),
         )
         .await?;
         payload.board_background_asset = Some(background_asset);
@@ -683,6 +1406,9 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
         .map(|group| (group.group_id.clone(), group))
         .collect::<BTreeMap<_, _>>();
     let sheet_specs = puzzle_clear_atlas_sheet_specs();
+    if let Some(debug_run) = image_debug_run.as_ref() {
+        debug_run.record_spec(&sheet_specs, &groups);
+    }
     let settings = require_openai_image_settings(state)
         .map(|settings| {
             settings.with_external_api_audit_context(
@@ -710,6 +1436,9 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
                 sheet_spec.sheet_id,
                 attempt_index + 1
             );
+            if let Some(debug_run) = image_debug_run.as_ref() {
+                debug_run.record_sheet_request(&sheet_spec, attempt_index, sheet_prompt.as_str());
+            }
             let generated = match create_openai_image_generation(
                 &http_client,
                 &settings,
@@ -727,6 +1456,9 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
                     if attempt_index + 1 < PUZZLE_CLEAR_SHEET_GENERATION_MAX_ATTEMPTS
                         && is_retryable_puzzle_clear_sheet_generation_error(&error) =>
                 {
+                    if let Some(debug_run) = image_debug_run.as_ref() {
+                        debug_run.record_sheet_generation_error(&sheet_spec, attempt_index, &error);
+                    }
                     tracing::warn!(
                         provider = PUZZLE_CLEAR_CREATION_PROVIDER,
                         sheet_id = sheet_spec.sheet_id,
@@ -737,6 +1469,9 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
                     continue;
                 }
                 Err(error) => {
+                    if let Some(debug_run) = image_debug_run.as_ref() {
+                        debug_run.record_sheet_generation_error(&sheet_spec, attempt_index, &error);
+                    }
                     return Err(puzzle_clear_error_response(
                         request_context,
                         PUZZLE_CLEAR_CREATION_PROVIDER,
@@ -745,6 +1480,7 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
                 }
             };
             let task_id = generated.task_id;
+            let actual_prompt = generated.actual_prompt;
             let image = generated.images.into_iter().next().ok_or_else(|| {
                 puzzle_clear_error_response(
                     request_context,
@@ -755,8 +1491,30 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
                     })),
                 )
             })?;
-            match validate_puzzle_clear_sheet_quality(&image, &sheet_spec) {
+            if let Some(debug_run) = image_debug_run.as_ref() {
+                debug_run.record_sheet_attempt_image(
+                    &sheet_spec,
+                    attempt_index,
+                    task_id.as_str(),
+                    actual_prompt.as_deref(),
+                    &image,
+                );
+            }
+            let quality_result = validate_puzzle_clear_sheet_quality(&image, &sheet_spec);
+            if let Some(debug_run) = image_debug_run.as_ref() {
+                debug_run.record_sheet_quality(
+                    &sheet_spec,
+                    attempt_index,
+                    task_id.as_str(),
+                    &image,
+                    quality_result.as_ref().err(),
+                );
+            }
+            match quality_result {
                 Ok(()) => {
+                    if let Some(debug_run) = image_debug_run.as_ref() {
+                        debug_run.record_sheet_accepted(&sheet_spec, task_id.as_str(), &image);
+                    }
                     accepted_sheet = Some(PuzzleClearGeneratedSheet {
                         spec: sheet_spec,
                         prompt: sheet_prompt.clone(),
@@ -821,6 +1579,9 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
         compose_puzzle_clear_final_atlas(&slices, &groups_by_id).map_err(|error| {
             puzzle_clear_error_response(request_context, PUZZLE_CLEAR_CREATION_PROVIDER, error)
         })?;
+    if let Some(debug_run) = image_debug_run.as_ref() {
+        debug_run.record_atlas_image(&atlas_image, &generated_sheets);
+    }
     let atlas_prompt = generated_sheets
         .iter()
         .map(|sheet| format!("{}:\n{}", sheet.spec.sheet_id, sheet.prompt))
@@ -864,6 +1625,14 @@ async fn maybe_prepare_puzzle_clear_assets_inner(
     payload.atlas_asset = Some(atlas_asset);
     payload.pattern_groups = Some(groups);
     payload.card_assets = Some(card_assets);
+    if let Some(debug_run) = image_debug_run.as_ref() {
+        debug_run.record_summary_success(
+            session_id,
+            profile_id.as_str(),
+            generated_sheets.len(),
+            payload.card_assets.as_ref().map_or(0, Vec::len),
+        );
+    }
     tracing::info!(
         provider = PUZZLE_CLEAR_CREATION_PROVIDER,
         session_id,
@@ -1054,8 +1823,12 @@ async fn generate_and_persist_puzzle_clear_board_background(
     owner_user_id: &str,
     profile_id: &str,
     theme_prompt: &str,
+    image_debug_run: Option<&PuzzleClearImageDebugRun>,
 ) -> Result<PuzzleClearImageAsset, Response> {
     let prompt = build_puzzle_clear_board_background_prompt(theme_prompt);
+    if let Some(debug_run) = image_debug_run {
+        debug_run.record_board_background_request(prompt.as_str());
+    }
     let settings = require_openai_image_settings(state)
         .map(|settings| {
             settings.with_external_api_audit_context(
@@ -1082,9 +1855,13 @@ async fn generate_and_persist_puzzle_clear_board_background(
     )
     .await
     .map_err(|error| {
+        if let Some(debug_run) = image_debug_run {
+            debug_run.record_board_background_error(&error);
+        }
         puzzle_clear_error_response(request_context, PUZZLE_CLEAR_CREATION_PROVIDER, error)
     })?;
     let task_id = generated.task_id;
+    let actual_prompt = generated.actual_prompt;
     let image = generated.images.into_iter().next().ok_or_else(|| {
         puzzle_clear_error_response(
             request_context,
@@ -1095,6 +1872,9 @@ async fn generate_and_persist_puzzle_clear_board_background(
             })),
         )
     })?;
+    if let Some(debug_run) = image_debug_run {
+        debug_run.record_board_background_image(task_id.as_str(), actual_prompt.as_deref(), &image);
+    }
     persist_puzzle_clear_generated_image_asset(
         state,
         owner_user_id,
@@ -2140,7 +2920,11 @@ fn map_puzzle_clear_client_error(error: SpacetimeClientError) -> AppError {
             if value.contains("�布需�")
                 || value.contains("�能为空")
                 || value.contains("å¿…é¡»")
-                || value.contains("无�") =>
+                || value.contains("无�")
+                || value.contains("puzzle-clear �标无效")
+                || value.contains("puzzle-clear 目标格�没有�牌")
+                || value.contains("puzzle-clear 当� run �在 playing 状�")
+                || value.contains("puzzle-clear 当�关�已�超时") =>
         {
             StatusCode::BAD_REQUEST
         }
diff --git a/server-rs/crates/module-puzzle-clear/src/application.rs b/server-rs/crates/module-puzzle-clear/src/application.rs
index 29c7e312..e3f8c25c 100644
--- a/server-rs/crates/module-puzzle-clear/src/application.rs
+++ b/server-rs/crates/module-puzzle-clear/src/application.rs
@@ -3,25 +3,55 @@ use std::collections::{BTreeSet, HashMap, VecDeque};
 use shared_kernel::normalize_required_string;
 
 use crate::{
-    PUZZLE_CLEAR_LEVEL_DURATION_SECONDS, PuzzleClearBoard, PuzzleClearCard, PuzzleClearCell,
-    PuzzleClearDeck, PuzzleClearElimination, PuzzleClearError, PuzzleClearLevelConfig,
-    PuzzleClearMove, PuzzleClearOrientation, PuzzleClearPatternGroup, PuzzleClearRunSnapshot,
-    PuzzleClearRunStatus, PuzzleClearShapeKind, PuzzleClearShapeQuota,
+    PuzzleClearBoard, PuzzleClearCard, PuzzleClearCell, PuzzleClearDeck, PuzzleClearElimination,
+    PuzzleClearError, PuzzleClearLevelConfig, PuzzleClearMove, PuzzleClearOrientation,
+    PuzzleClearPatternGroup, PuzzleClearRunSnapshot, PuzzleClearRunStatus, PuzzleClearShapeKind,
+    PuzzleClearShapeQuota,
 };
 
 pub fn puzzle_clear_level_configs() -> Vec<PuzzleClearLevelConfig> {
-    vec![PuzzleClearLevelConfig {
-        level_index: 1,
-        board_size: 6,
-        target_clears: 35,
-        duration_seconds: PUZZLE_CLEAR_LEVEL_DURATION_SECONDS,
-        unlocked_shapes: vec![
-            PuzzleClearShapeKind::OneByTwo,
-            PuzzleClearShapeKind::OneByThree,
-            PuzzleClearShapeKind::TwoByTwo,
-            PuzzleClearShapeKind::TwoByThree,
-        ],
-    }]
+    vec![
+        PuzzleClearLevelConfig {
+            level_index: 1,
+            board_size: 6,
+            target_clears: 15,
+            duration_seconds: 300,
+            unlocked_shapes: vec![PuzzleClearShapeKind::OneByTwo],
+        },
+        PuzzleClearLevelConfig {
+            level_index: 2,
+            board_size: 6,
+            target_clears: 20,
+            duration_seconds: 300,
+            unlocked_shapes: vec![
+                PuzzleClearShapeKind::OneByTwo,
+                PuzzleClearShapeKind::OneByThree,
+            ],
+        },
+        PuzzleClearLevelConfig {
+            level_index: 3,
+            board_size: 6,
+            target_clears: 30,
+            duration_seconds: 420,
+            unlocked_shapes: vec![
+                PuzzleClearShapeKind::OneByTwo,
+                PuzzleClearShapeKind::OneByThree,
+                PuzzleClearShapeKind::TwoByTwo,
+            ],
+        },
+        PuzzleClearLevelConfig {
+            level_index: 4,
+            board_size: 6,
+            target_clears: 35,
+            duration_seconds: 600,
+            unlocked_shapes: vec![
+                PuzzleClearShapeKind::OneByTwo,
+                PuzzleClearShapeKind::OneByThree,
+                PuzzleClearShapeKind::TwoByTwo,
+                PuzzleClearShapeKind::TwoByThree,
+            ],
+        },
+    ]
 }
 
 pub fn puzzle_clear_shape_quotas() -> Vec<PuzzleClearShapeQuota> {
@@ -114,7 +144,7 @@ pub fn create_puzzle_clear_board(
         return Err(PuzzleClearError::InvalidLevel);
     }
     let total = (level.board_size * level.board_size) as usize;
-    if cards.len() < total {
+    if cards.is_empty() {
         return Err(PuzzleClearError::EmptyDeck);
     }
     let mut rng = DeterministicRng::new(seed, &format!("level-{}", level.level_index));
@@ -125,10 +155,12 @@ pub fn create_puzzle_clear_board(
     for row in 0..level.board_size {
         for col in 0..level.board_size {
             let index = (row * level.board_size + col) as usize;
+            let empty_slots = total.saturating_sub(selected.len());
+            let card_index = index.checked_sub(empty_slots);
             cells.push(PuzzleClearCell {
                 row,
                 col,
-                card: selected.get(index).cloned(),
+                card: card_index.and_then(|card_index| selected.get(card_index).cloned()),
                 locked_group_id: None,
             });
         }
@@ -202,7 +234,7 @@ pub fn apply_puzzle_clear_swap(
         .into_iter()
         .find(|config| config.level_index == next.level_index)
         .ok_or(PuzzleClearError::InvalidLevel)?;
-    if next.clears_done >= level.target_clears && !has_remaining_cards(&next.board) {
+    if next.clears_done >= level.target_clears && !has_remaining_cards_in_run(&next) {
         next.status = if next.level_index >= max_puzzle_clear_level_index() {
             PuzzleClearRunStatus::Finished
         } else {
@@ -401,8 +433,13 @@ fn ensure_not_expired(run: &PuzzleClearRunSnapshot, now_ms: u64) -> Result<(), P
 }
 
 fn is_level_expired(run: &PuzzleClearRunSnapshot, now_ms: u64) -> bool {
+    let duration_seconds = puzzle_clear_level_configs()
+        .into_iter()
+        .find(|config| config.level_index == run.level_index)
+        .map(|config| config.duration_seconds)
+        .unwrap_or(600);
     now_ms.saturating_sub(run.level_started_at_ms)
-        > u64::from(PUZZLE_CLEAR_LEVEL_DURATION_SECONDS) * 1000
+        > u64::from(duration_seconds) * 1000
 }
 
 fn validate_board(board: &PuzzleClearBoard) -> Result<(), PuzzleClearError> {
@@ -421,6 +458,15 @@ fn has_remaining_cards(board: &PuzzleClearBoard) -> bool {
     board.cells.iter().any(|cell| cell.card.is_some())
 }
 
+fn has_remaining_cards_in_run(run: &PuzzleClearRunSnapshot) -> bool {
+    has_remaining_cards(&run.board)
+        || run
+            .deck
+            .ready_columns
+            .iter()
+            .any(|column| !column.is_empty())
+}
+
 fn ensure_board_has_playable_move(board: &mut PuzzleClearBoard) -> Result<(), PuzzleClearError> {
     if find_eliminations(board).is_empty() && has_playable_move(board) {
         return Ok(());
@@ -490,15 +536,7 @@ fn find_local_completed_groups(board: &PuzzleClearBoard) -> Vec<PuzzleClearElimi
             if entries.len() < 2 || first.shape == PuzzleClearShapeKind::OneByTwo {
                 return None;
             }
-            let mut ordered = entries.clone();
-            ordered.sort_by_key(|(_, _, card)| (card.part_y, card.part_x));
-            let adjacent = ordered.windows(2).all(|pair| {
-                let a = &pair[0].2;
-                let b = &pair[1].2;
-                manhattan_part_distance(a, b) == 1
-                    && are_neighbors(pair[0].0, pair[0].1, pair[1].0, pair[1].1)
-            });
-            adjacent.then(|| PuzzleClearElimination {
+            is_connected_partial_group(&entries).then(|| PuzzleClearElimination {
                 group_id,
                 positions: entries
                     .into_iter()
@@ -509,6 +547,32 @@ fn find_local_completed_groups(board: &PuzzleClearBoard) -> Vec<PuzzleClearElimi
         .collect()
 }
 
+fn is_connected_partial_group(entries: &[(u32, u32, PuzzleClearCard)]) -> bool {
+    if entries.len() < 2 {
+        return false;
+    }
+    let mut visited = vec![false; entries.len()];
+    let mut stack = vec![0usize];
+    visited[0] = true;
+
+    while let Some(index) = stack.pop() {
+        let current = &entries[index];
+        for (candidate_index, candidate) in entries.iter().enumerate() {
+            if visited[candidate_index] {
+                continue;
+            }
+            if manhattan_part_distance(&current.2, &candidate.2) == 1
+                && are_neighbors(current.0, current.1, candidate.0, candidate.1)
+            {
+                visited[candidate_index] = true;
+                stack.push(candidate_index);
+            }
+        }
+    }
+
+    visited.into_iter().all(|is_visited| is_visited)
+}
+
 fn clear_locked_group(board: &mut PuzzleClearBoard, group_id: &str) {
     for cell in &mut board.cells {
         if cell.locked_group_id.as_deref() == Some(group_id) {
@@ -1177,14 +1241,40 @@ mod tests {
     use super::*;
 
     #[test]
-    fn fixed_level_config_uses_single_six_by_six_level() {
+    fn fixed_level_config_uses_four_six_by_six_levels() {
         let configs = puzzle_clear_level_configs();
 
-        assert_eq!(configs.len(), 1);
-        assert_eq!(configs[0].board_size, 6);
-        assert_eq!(configs[0].target_clears, 35);
+        assert_eq!(configs.len(), 4);
+        assert!(configs.iter().all(|config| config.board_size == 6));
         assert_eq!(
-            configs[0].unlocked_shapes,
+            configs
+                .iter()
+                .map(|config| (
+                    config.level_index,
+                    config.target_clears,
+                    config.duration_seconds
+                ))
+                .collect::<Vec<_>>(),
+            vec![(1, 15, 300), (2, 20, 300), (3, 30, 420), (4, 35, 600)]
+        );
+        assert_eq!(configs[0].unlocked_shapes, vec![PuzzleClearShapeKind::OneByTwo]);
+        assert_eq!(
+            configs[1].unlocked_shapes,
+            vec![
+                PuzzleClearShapeKind::OneByTwo,
+                PuzzleClearShapeKind::OneByThree,
+            ]
+        );
+        assert_eq!(
+            configs[2].unlocked_shapes,
+            vec![
+                PuzzleClearShapeKind::OneByTwo,
+                PuzzleClearShapeKind::OneByThree,
+                PuzzleClearShapeKind::TwoByTwo,
+            ]
+        );
+        assert_eq!(
+            configs[3].unlocked_shapes,
             vec![
                 PuzzleClearShapeKind::OneByTwo,
                 PuzzleClearShapeKind::OneByThree,
@@ -1192,7 +1282,6 @@ mod tests {
                 PuzzleClearShapeKind::TwoByThree,
             ]
         );
-        assert!(configs.iter().all(|config| config.duration_seconds == 600));
     }
 
     #[test]
@@ -1250,6 +1339,23 @@ mod tests {
         assert!(has_playable_move(&board));
     }
 
+    #[test]
+    fn first_level_board_uses_exact_target_cards_and_leaves_empty_cells() {
+        let groups = plan_puzzle_clear_pattern_groups(64).expect("atlas should plan");
+        let cards = build_cards_from_groups(&groups, "/generated-puzzle-clear")
+            .into_iter()
+            .filter(|card| card.shape == PuzzleClearShapeKind::OneByTwo)
+            .take(30)
+            .collect::<Vec<_>>();
+        let board = create_puzzle_clear_board(&puzzle_clear_level_configs()[0], "seed-a", cards)
+            .expect("board should create with empty cells");
+
+        assert_eq!(board.cells.iter().filter(|cell| cell.card.is_some()).count(), 30);
+        assert_eq!(board.cells.iter().filter(|cell| cell.card.is_none()).count(), 6);
+        assert!(find_eliminations(&board).is_empty());
+        assert!(has_playable_move(&board));
+    }
+
     #[test]
     fn one_by_two_neighbors_are_not_half_locked() {
         let board = board_from_cards(
@@ -1350,7 +1456,7 @@ mod tests {
     }
 
     #[test]
-    fn reaching_target_clears_without_empty_board_keeps_playing() {
+    fn reaching_target_clears_does_not_complete_level_with_remaining_cards() {
         let board = board_from_cards(
             3,
             vec![
@@ -1376,7 +1482,7 @@ mod tests {
             100,
         )
         .expect("run should start");
-        run.clears_done = 4;
+        run.clears_done = 14;
         let next = apply_puzzle_clear_swap(
             &run,
             PuzzleClearMove {
@@ -1389,11 +1495,57 @@ mod tests {
         )
         .expect("swap should resolve");
 
-        assert_eq!(next.clears_done, 5);
+        assert_eq!(next.clears_done, 15);
         assert_eq!(next.status, PuzzleClearRunStatus::Playing);
+        assert!(next.finished_at_ms.is_none());
         assert!(next.board.cells.iter().any(|cell| cell.card.is_some()));
     }
 
+    #[test]
+    fn reaching_target_clears_completes_level_after_all_cards_are_removed() {
+        let board = board_from_cards(
+            3,
+            vec![
+                Some(card("play", 0, 0)),
+                None,
+                None,
+                None,
+                Some(card("play", 1, 0)),
+                None,
+                None,
+                None,
+                None,
+            ],
+        );
+        let mut run = start_puzzle_clear_run(
+            "run-target-empty".to_string(),
+            "user-1".to_string(),
+            "profile-1".to_string(),
+            board,
+            PuzzleClearDeck {
+                ready_columns: vec![vec![], vec![], vec![]],
+            },
+            100,
+        )
+        .expect("run should start");
+        run.clears_done = 14;
+        let next = apply_puzzle_clear_swap(
+            &run,
+            PuzzleClearMove {
+                from_row: 1,
+                from_col: 1,
+                to_row: 0,
+                to_col: 1,
+            },
+            200,
+        )
+        .expect("swap should resolve");
+
+        assert_eq!(next.clears_done, 15);
+        assert_eq!(next.status, PuzzleClearRunStatus::LevelCleared);
+        assert!(next.board.cells.iter().all(|cell| cell.card.is_none()));
+    }
+
     #[test]
     fn refill_keeps_locked_partial_group_in_place() {
         let mut board = board_from_cards(
@@ -1737,6 +1889,57 @@ mod tests {
         );
     }
 
+    #[test]
+    fn two_by_two_l_shaped_partial_group_locks_as_one_group() {
+        let board = board_from_cards(
+            3,
+            vec![
+                Some(card_shape("block", PuzzleClearShapeKind::TwoByTwo, 0, 0)),
+                Some(card_shape("block", PuzzleClearShapeKind::TwoByTwo, 1, 0)),
+                Some(card("noise-a", 0, 0)),
+                Some(card_shape("block", PuzzleClearShapeKind::TwoByTwo, 0, 1)),
+                Some(card("noise-b", 0, 0)),
+                Some(card("play", 1, 0)),
+                Some(card("noise-d", 0, 0)),
+                Some(card("play", 0, 0)),
+                Some(card("noise-c", 0, 0)),
+            ],
+        );
+        let run = start_puzzle_clear_run(
+            "run-2x2-partial".to_string(),
+            "user-1".to_string(),
+            "profile-1".to_string(),
+            board,
+            PuzzleClearDeck {
+                ready_columns: vec![vec![], vec![], vec![]],
+            },
+            100,
+        )
+        .expect("run should start");
+
+        let locked = apply_puzzle_clear_swap(
+            &run,
+            PuzzleClearMove {
+                from_row: 1,
+                from_col: 1,
+                to_row: 2,
+                to_col: 0,
+            },
+            200,
+        )
+        .expect("non-clear swap should lock partial group");
+
+        let block_locks = locked
+            .board
+            .cells
+            .iter()
+            .filter(|cell| cell.card.as_ref().is_some_and(|card| card.group_id == "block"))
+            .map(|cell| cell.locked_group_id.as_deref())
+            .collect::<Vec<_>>();
+        assert_eq!(block_locks, vec![Some("block"), Some("block"), Some("block")]);
+        assert_eq!(locked.clears_done, 0);
+    }
+
     #[test]
     fn timeout_fails_only_current_level_and_retry_restarts_it() {
         let board = board_from_cards(
diff --git a/server-rs/crates/spacetime-module/src/puzzle_clear.rs b/server-rs/crates/spacetime-module/src/puzzle_clear.rs
index ce917767..3091fda7 100644
--- a/server-rs/crates/spacetime-module/src/puzzle_clear.rs
+++ b/server-rs/crates/spacetime-module/src/puzzle_clear.rs
@@ -6,8 +6,8 @@ pub use types::*;
 
 use crate::{ProcedureContext, ReducerContext, SpacetimeType, Table, Timestamp, json};
 use module_puzzle_clear::{
-    PUZZLE_CLEAR_LEVEL_DURATION_SECONDS, PuzzleClearBoard, PuzzleClearCard, PuzzleClearDeck,
-    PuzzleClearMove, PuzzleClearRunSnapshot as DomainRunSnapshot, advance_puzzle_clear_level,
+    PuzzleClearBoard, PuzzleClearCard, PuzzleClearDeck, PuzzleClearMove,
+    PuzzleClearRunSnapshot as DomainRunSnapshot, advance_puzzle_clear_level,
     apply_puzzle_clear_swap, create_puzzle_clear_board, fail_puzzle_clear_level_on_timeout,
     parse_puzzle_clear_orientation, parse_puzzle_clear_shape_kind, puzzle_clear_level_configs,
     retry_puzzle_clear_level, start_puzzle_clear_run,
@@ -976,6 +976,7 @@ fn build_level_board_and_deck(
             .collect::<Vec<_>>(),
         seed,
         level.target_clears as usize,
+        &level.unlocked_shapes,
     );
     let board = create_puzzle_clear_board(&level, seed, allowed.clone())
         .map_err(|error| error.to_string())?;
@@ -991,6 +992,7 @@ fn ordered_level_cards(
     cards: Vec<PuzzleClearCard>,
     seed: &str,
     target_groups: usize,
+    unlocked_shapes: &[module_puzzle_clear::PuzzleClearShapeKind],
 ) -> Vec<PuzzleClearCard> {
     let mut groups: BTreeMap<String, Vec<PuzzleClearCard>> = BTreeMap::new();
     for card in cards {
@@ -1008,9 +1010,40 @@ fn ordered_level_cards(
             .unwrap_or_default();
         left_key.cmp(&right_key)
     });
-    grouped
+    let mut selected = Vec::new();
+    let mut selected_group_ids = std::collections::BTreeSet::new();
+    for shape in unlocked_shapes {
+        if selected.len() >= target_groups {
+            break;
+        }
+        let Some(group) = grouped.iter().find(|group| {
+            group
+                .first()
+                .is_some_and(|card| card.shape == *shape && !selected_group_ids.contains(&card.group_id))
+        }) else {
+            continue;
+        };
+        if let Some(first) = group.first() {
+            selected_group_ids.insert(first.group_id.clone());
+            selected.push(group.clone());
+        }
+    }
+    for group in grouped {
+        if selected.len() >= target_groups {
+            break;
+        }
+        let Some(first) = group.first() else {
+            continue;
+        };
+        if selected_group_ids.contains(&first.group_id) {
+            continue;
+        }
+        selected_group_ids.insert(first.group_id.clone());
+        selected.push(group);
+    }
+
+    selected
         .into_iter()
-        .take(target_groups)
         .flat_map(|mut group| {
             group.sort_by_key(|card| (card.part_y, card.part_x));
             group
@@ -1061,7 +1094,7 @@ fn build_runtime_snapshot(
         level_index: snapshot.level_index,
         clears_done: snapshot.clears_done,
         target_clears: level.target_clears,
-        level_duration_seconds: PUZZLE_CLEAR_LEVEL_DURATION_SECONDS,
+        level_duration_seconds: level.duration_seconds,
         level_started_at_ms: snapshot.level_started_at_ms,
         board: PuzzleClearBoardSnapshot {
             rows: snapshot.board.rows,
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index 16d24b6c..88a8c502 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -10399,17 +10399,52 @@ export function PlatformEntryFlowShellImpl({
     setSelectionStage,
   ]);
 
-  const publishPuzzleClearDraft = useCallback(async () => {
+  const publishPuzzleClearDraft = useCallback(async (metadata?: {
+    workTitle: string;
+    workDescription: string;
+  }) => {
     const profileId = puzzleClearWork?.summary.profileId?.trim();
     if (!profileId) {
       setPuzzleClearError('拼消消�稿尚未生���布作�。');
       setSelectionStage('puzzle-clear-result');
-      return;
+      return false;
     }
 
     setIsPuzzleClearBusy(true);
     setPuzzleClearError(null);
     try {
+      let currentWork = puzzleClearWork;
+      const normalizedTitle = metadata?.workTitle.trim() ?? '';
+      const normalizedDescription = metadata?.workDescription.trim() ?? '';
+      if (metadata && normalizedTitle) {
+        const sessionId =
+          puzzleClearSession?.sessionId?.trim() ||
+          puzzleClearWork?.summary.sourceSessionId?.trim() ||
+          '';
+        if (!sessionId) {
+          setPuzzleClearError('拼消消�稿缺少会�信�，暂时无法�存�布资料。');
+          setSelectionStage('puzzle-clear-result');
+          return false;
+        }
+        const updateResponse = await puzzleClearClient.executeAction(sessionId, {
+          actionType: 'update-work-meta',
+          profileId,
+          workTitle: normalizedTitle,
+          workDescription: normalizedDescription,
+        });
+        currentWork = updateResponse.work ?? currentWork;
+        setPuzzleClearSession(updateResponse.session);
+        if (currentWork) {
+          setPuzzleClearWork(currentWork);
+          writeCreationUrlState(
+            buildPuzzleClearCreationUrlState({
+              session: updateResponse.session,
+              work: currentWork,
+            }),
+          );
+        }
+      }
+
       const response = await puzzleClearClient.publishWork(profileId);
       setPuzzleClearWork(response.item);
       setPuzzleClearWorks((current) => [
@@ -10433,17 +10468,20 @@ export function PlatformEntryFlowShellImpl({
         publicWorkCode,
         stage: 'work-detail',
       });
+      return true;
     } catch (error) {
       setPuzzleClearError(
         resolveRpgCreationErrorMessage(error, '�布拼消消作�失败。'),
       );
       setSelectionStage('puzzle-clear-result');
+      return false;
     } finally {
       setIsPuzzleClearBusy(false);
     }
   }, [
     openPublishShareModal,
-    puzzleClearWork?.summary.profileId,
+    puzzleClearSession?.sessionId,
+    puzzleClearWork,
     refreshPuzzleClearGallery,
     refreshPuzzleClearShelf,
     setSelectionStage,
diff --git a/src/components/puzzle-clear-creation/PuzzleClearWorkspace.test.tsx b/src/components/puzzle-clear-creation/PuzzleClearWorkspace.test.tsx
index 3425ddac..d72a28b2 100644
--- a/src/components/puzzle-clear-creation/PuzzleClearWorkspace.test.tsx
+++ b/src/components/puzzle-clear-creation/PuzzleClearWorkspace.test.tsx
@@ -76,7 +76,7 @@ beforeEach(() => {
   vi.mocked(readPuzzleReferenceImageAsDataUrl).mockReset();
 });
 
-test('工作��交结构化表�与底图槽� payload', async () => {
+test('工作���交游�内容�置与底图槽� payload', async () => {
   const response = createSessionResponse();
   const onSubmitted = vi.fn();
   vi.mocked(puzzleClearClient.createSession).mockResolvedValue(response);
@@ -91,19 +91,17 @@ test('工作��交结构化表�与底图槽� payload', async () => {
     />,
   );
 
-  fireEvent.change(screen.getByLabelText('作�标题'), {
-    target: { value: '  星港拼消消  ' },
-  });
-  fireEvent.change(screen.getByLabelText('简介'), {
-    target: { value: '  霓虹星港主题  ' },
-  });
-  fireEvent.change(screen.getByLabelText('主题�'), {
+  expect(screen.getByText('拼消消创作')).not.toBeNull();
+  expect(screen.queryByLabelText('作�标题')).toBeNull();
+  expect(screen.queryByLabelText('简介')).toBeNull();
+
+  fireEvent.change(screen.getByLabelText('�牌素�主题'), {
     target: { value: '  霓虹星港  ' },
   });
-  fireEvent.change(screen.getByLabelText('场地底图'), {
+  fireEvent.change(screen.getByLabelText('画��述'), {
     target: { value: '星港中央棋盘底图' },
   });
-  fireEvent.change(screen.getByLabelText('上传底图'), {
+  fireEvent.change(screen.getByLabelText('上传背景图'), {
     target: {
       files: [
         new File(['fake-image'], 'board.png', {
@@ -122,8 +120,8 @@ test('工作��交结构化表�与底图槽� payload', async () => {
   await waitFor(() =>
     expect(puzzleClearClient.createSession).toHaveBeenCalledWith({
       templateId: 'puzzle-clear',
-      workTitle: '星港拼消消',
-      workDescription: '霓虹星港主题',
+      workTitle: '霓虹星港拼消消',
+      workDescription: '',
       themePrompt: '霓虹星港',
       boardBackgroundPrompt: '星港中央棋盘底图',
       generateBoardBackground: false,
@@ -138,7 +136,7 @@ test('工作��交结构化表�与底图槽� payload', async () => {
     response,
     expect.objectContaining({
       templateId: 'puzzle-clear',
-      workTitle: '星港拼消消',
+      workTitle: '霓虹星港拼消消',
       themePrompt: '霓虹星港',
     }),
   );
@@ -155,7 +153,29 @@ test('工作��渲染�天� Agent 输入', () => {
   expect(screen.queryByText(/��消�|�天|对�|输入想法/u)).toBeNull();
 });
 
-test('关闭 AI 生�底图且未上传底图时��许�交', async () => {
+test('背景图上传区��套外层信�框', () => {
+  const { container } = render(
+    <PuzzleClearWorkspace
+      onBack={vi.fn()}
+      onSubmitted={vi.fn()}
+    />,
+  );
+
+  const uploadInput = screen.getByLabelText('上传背景图', {
+    selector: 'input',
+  });
+  const uploadCard = uploadInput.closest('.puzzle-image-upload-card');
+
+  expect(uploadCard).not.toBeNull();
+  expect(uploadCard?.closest('.platform-subpanel')).toBeNull();
+  expect(container.querySelector('.puzzle-image-upload-card')).toBeTruthy();
+  expect(screen.getByText('背景图')).toBeTruthy();
+  expect(screen.getByText('上传图片/填写画��述')).toBeTruthy();
+  expect(screen.queryByText('中央底图')).toBeNull();
+  expect(screen.queryByLabelText('场地底图画�')).toBeNull();
+});
+
+test('工作��留背景图命�和画��述输入', () => {
   render(
     <PuzzleClearWorkspace
       onBack={vi.fn()}
@@ -163,22 +183,41 @@ test('关闭 AI 生�底图且未上传底图时��许�交', async () => {
     />,
   );
 
-  fireEvent.change(screen.getByLabelText('作�标题'), {
-    target: { value: '星港拼消消' },
-  });
-  fireEvent.change(screen.getByLabelText('主题�'), {
+  expect(screen.getByText('背景图')).toBeTruthy();
+  expect(screen.getByLabelText('画��述')).toBeTruthy();
+  expect(screen.queryByText('上传图�')).toBeNull();
+});
+
+test('工作��仅用主题进入 AI 生��程', async () => {
+  const response = createSessionResponse();
+  vi.mocked(puzzleClearClient.createSession).mockResolvedValue(response);
+
+  render(
+    <PuzzleClearWorkspace
+      onBack={vi.fn()}
+      onSubmitted={vi.fn()}
+    />,
+  );
+
+  fireEvent.change(screen.getByLabelText('�牌素�主题'), {
     target: { value: '霓虹星港' },
   });
-  fireEvent.click(screen.getByRole('checkbox', { name: 'AI 生�底图' }));
 
   expect(
     (screen.getByRole('button', { name: '生�' }) as HTMLButtonElement).disabled,
-  ).toBe(true);
+  ).toBe(false);
 
   fireEvent.click(screen.getByRole('button', { name: '生�' }));
 
   await waitFor(() =>
-    expect(puzzleClearClient.createSession).not.toHaveBeenCalled(),
+    expect(puzzleClearClient.createSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        themePrompt: '霓虹星港',
+        boardBackgroundPrompt: '',
+        generateBoardBackground: true,
+        boardBackgroundAsset: null,
+      }),
+    ),
   );
 });
 
@@ -194,13 +233,10 @@ test('工作�支�原生表��交生�', async () => {
     />,
   );
 
-  fireEvent.change(screen.getByLabelText('作�标题'), {
-    target: { value: '星港拼消消' },
-  });
-  fireEvent.change(screen.getByLabelText('主题�'), {
+  fireEvent.change(screen.getByLabelText('�牌素�主题'), {
     target: { value: '霓虹星港' },
   });
-  fireEvent.change(screen.getByLabelText('场地底图'), {
+  fireEvent.change(screen.getByLabelText('画��述'), {
     target: { value: '星港中央棋盘底图' },
   });
 
@@ -216,7 +252,7 @@ test('工作�支�原生表��交生�', async () => {
     response,
     expect.objectContaining({
       templateId: 'puzzle-clear',
-      workTitle: '星港拼消消',
+      workTitle: '霓虹星港拼消消',
     }),
   );
 });
diff --git a/src/components/puzzle-clear-creation/PuzzleClearWorkspace.tsx b/src/components/puzzle-clear-creation/PuzzleClearWorkspace.tsx
index 75734d04..f9fa8a30 100644
--- a/src/components/puzzle-clear-creation/PuzzleClearWorkspace.tsx
+++ b/src/components/puzzle-clear-creation/PuzzleClearWorkspace.tsx
@@ -21,8 +21,6 @@ type PuzzleClearWorkspaceProps = {
 };
 
 type PuzzleClearWorkspaceFormState = {
-  workTitle: string;
-  workDescription: string;
   themePrompt: string;
   boardBackgroundPrompt: string;
   boardBackgroundAsset: PuzzleClearImageAsset | null;
@@ -31,8 +29,6 @@ type PuzzleClearWorkspaceFormState = {
 };
 
 const DEFAULT_FORM_STATE: PuzzleClearWorkspaceFormState = {
-  workTitle: '',
-  workDescription: '',
   themePrompt: '',
   boardBackgroundPrompt: '',
   boardBackgroundAsset: null,
@@ -56,6 +52,15 @@ function buildLocalBoardBackgroundAsset(
   };
 }
 
+function derivePuzzleClearDraftTitle(themePrompt: string) {
+  const normalizedTheme = themePrompt.trim();
+  if (!normalizedTheme) {
+    return '拼消消�稿';
+  }
+  const suffix = normalizedTheme.endsWith('拼消消') ? '' : '拼消消';
+  return `${normalizedTheme}${suffix}`.slice(0, 30);
+}
+
 export function PuzzleClearWorkspace({
   isBusy = false,
   error = null,
@@ -78,12 +83,8 @@ export function PuzzleClearWorkspace({
 
   const canSubmit = useMemo(
     () =>
-      Boolean(
-        formState.workTitle.trim() &&
-          formState.themePrompt.trim() &&
-          hasBoardBackgroundInput,
-      ),
-    [formState.themePrompt, formState.workTitle, hasBoardBackgroundInput],
+      Boolean(formState.themePrompt.trim() && hasBoardBackgroundInput),
+    [formState.themePrompt, hasBoardBackgroundInput],
   );
 
   const handleSubmit = async () => {
@@ -107,8 +108,8 @@ export function PuzzleClearWorkspace({
           : null);
       const payload: PuzzleClearWorkspaceCreateRequest = {
         templateId: 'puzzle-clear',
-        workTitle: formState.workTitle.trim(),
-        workDescription: formState.workDescription.trim(),
+        workTitle: derivePuzzleClearDraftTitle(formState.themePrompt),
+        workDescription: '',
         themePrompt: formState.themePrompt.trim(),
         boardBackgroundPrompt: formState.boardBackgroundPrompt.trim(),
         generateBoardBackground: formState.generateBoardBackground,
@@ -133,125 +134,76 @@ export function PuzzleClearWorkspace({
       }}
       className="platform-remap-surface mx-auto flex h-full min-h-0 w-full max-w-5xl flex-col px-3 pb-3 pt-3 sm:px-4 sm:pt-4"
     >
-      <div className="mb-3 flex items-center justify-between gap-3">
+      <div className="mb-3 flex shrink-0 items-center justify-between gap-3 sm:mb-4">
         <button
           type="button"
           onClick={onBack}
-          className="platform-button platform-button--ghost min-h-0 px-3 py-2 text-sm"
+          className="platform-button platform-button--ghost min-h-0 px-3 py-1.5 text-[11px]"
         >
-          <ArrowLeft className="h-4 w-4" />
-          返回
+          <span className="inline-flex items-center gap-1.5">
+            <ArrowLeft className="h-3.5 w-3.5" />
+            返回
+          </span>
         </button>
       </div>
 
-      <div className="grid min-h-0 flex-1 gap-3 lg:grid-cols-[minmax(0,0.88fr)_minmax(0,1.12fr)]">
-        <section className="platform-subpanel flex min-h-0 flex-col gap-3 overflow-y-auto rounded-[1.25rem] p-4">
-          <label className="block">
-            <span className="text-xs font-bold tracking-[0.18em] text-[var(--platform-text-soft)]">
-              作�标题
-            </span>
-            <input
-              value={formState.workTitle}
-              maxLength={32}
-              disabled={isBusy || isSubmitting}
-              onChange={(event) =>
-                setFormState((current) => ({
-                  ...current,
-                  workTitle: event.target.value,
-                }))
-              }
-              className="mt-2 w-full rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-3 py-3 text-sm font-semibold text-[var(--platform-text-strong)] outline-none"
-            />
-          </label>
+      <div className="mb-4 shrink-0 sm:mb-5">
+        <div className="flex flex-wrap items-center gap-2">
+          <h1 className="m-0 text-3xl font-black leading-none tracking-normal text-[var(--platform-text-strong)] sm:text-6xl">
+            拼消消创作
+          </h1>
+          <span className="rounded-full border border-emerald-200 bg-emerald-50 px-3 py-1 text-[11px] font-black text-emerald-700">
+            BETA
+          </span>
+        </div>
+      </div>
 
-          <label className="block">
-            <span className="text-xs font-bold tracking-[0.18em] text-[var(--platform-text-soft)]">
-              简介
-            </span>
-            <textarea
-              value={formState.workDescription}
-              maxLength={120}
-              disabled={isBusy || isSubmitting}
-              rows={4}
-              onChange={(event) =>
-                setFormState((current) => ({
-                  ...current,
-                  workDescription: event.target.value,
-                }))
-              }
-              className="mt-2 w-full resize-none rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-3 py-3 text-sm leading-6 text-[var(--platform-text-strong)] outline-none"
-            />
-          </label>
+      <section className="flex min-h-0 flex-1 flex-col gap-4 overflow-y-auto px-1 pb-1">
+        <label className="block">
+          <span className="mb-2 block text-sm font-black text-[var(--platform-text-strong)]">
+            �牌素�主题
+          </span>
+          <input
+            value={formState.themePrompt}
+            maxLength={80}
+            disabled={isBusy || isSubmitting}
+            onChange={(event) =>
+              setFormState((current) => ({
+                ...current,
+                themePrompt: event.target.value,
+              }))
+            }
+            className="w-full rounded-[1.05rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-4 py-3 text-base font-semibold text-[var(--platform-text-strong)] outline-none"
+          />
+        </label>
 
-          <label className="block">
-            <span className="text-xs font-bold tracking-[0.18em] text-[var(--platform-text-soft)]">
-              主题�
-            </span>
-            <input
-              value={formState.themePrompt}
-              maxLength={80}
-              disabled={isBusy || isSubmitting}
-              onChange={(event) =>
-                setFormState((current) => ({
-                  ...current,
-                  themePrompt: event.target.value,
-                }))
-              }
-              className="mt-2 w-full rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-3 py-3 text-sm font-semibold text-[var(--platform-text-strong)] outline-none"
-            />
-          </label>
-
-          <label className="flex items-center justify-between gap-3 rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/72 px-3 py-3">
-            <span className="text-sm font-bold text-[var(--platform-text-strong)]">
-              AI 生�底图
-            </span>
-            <input
-              type="checkbox"
-              checked={formState.generateBoardBackground}
-              disabled={isBusy || isSubmitting}
-              onChange={(event) =>
-                setFormState((current) => ({
-                  ...current,
-                  generateBoardBackground: event.target.checked,
-                }))
-              }
-              className="h-5 w-5 accent-[var(--platform-accent)]"
-            />
-          </label>
-
-          {localError || error ? (
-            <div className="platform-banner platform-banner--danger rounded-2xl text-sm leading-6">
-              {localError ?? error}
-            </div>
-          ) : null}
-        </section>
-
-        <div className="flex min-h-[28rem] min-w-0 flex-col">
+        <div className="min-h-0 min-w-0">
           <CreativeImageInputPanel
+            fillHeight={false}
             disabled={isBusy || isSubmitting}
             isSubmitting={isSubmitting}
             uploadedImageSrc={formState.boardBackgroundImageSrc}
-            uploadedImageAlt="场地底图"
+            uploadedImageAlt="背景图"
             mainImageInputId="puzzle-clear-board-background"
             promptTextareaId="puzzle-clear-board-background-prompt"
             prompt={formState.boardBackgroundPrompt}
-            promptLabel="场地底图"
-            promptRows={5}
+            promptLabel="画��述"
+            promptRows={4}
             aiRedraw={formState.generateBoardBackground}
             promptReferenceImages={[]}
             showSubmitButton={false}
             submitLabel="生�"
             submitDisabled={!canSubmit || isSubmitting || isBusy}
             labels={{
-              imageField: '中央底图',
-              uploadImage: '上传底图',
-              replaceImage: '替�底图',
-              emptyImageHint: '上传图�',
-              removeImage: '移除底图',
-              removeImageConfirmTitle: '移除底图',
-              removeImageConfirmBody: '移除�将使用主题�生�中央场地底图。',
+              imageField: '背景图',
+              uploadImage: '上传背景图',
+              replaceImage: '替�背景图',
+              emptyImageHint: '上传图片/填写画��述',
+              removeImage: '移除背景图',
+              removeImageConfirmTitle: '移除背景图',
+              removeImageConfirmBody: '移除�将使用画��述生�背景图。',
               promptReferenceUpload: '上传�考图',
-              promptReferencePreviewAlt: '场地底图�考',
+              promptReferencePreviewAlt: '背景图�考',
               closePromptReferencePreview: '关闭预览',
             }}
             onMainImageFileSelect={(file) => {
@@ -273,7 +225,7 @@ export function PuzzleClearWorkspace({
                   setLocalError(
                     caughtError instanceof Error
                       ? caughtError.message
-                      : '底图读�失败。',
+                      : '背景图读�失败。',
                   );
                 });
             }}
@@ -282,6 +234,7 @@ export function PuzzleClearWorkspace({
                 ...current,
                 boardBackgroundImageSrc: '',
                 boardBackgroundAsset: null,
+                generateBoardBackground: true,
               }));
             }}
             onAiRedrawChange={(value) =>
@@ -299,7 +252,13 @@ export function PuzzleClearWorkspace({
             onSubmit={handleSubmit}
           />
         </div>
-      </div>
+
+        {localError || error ? (
+          <div className="platform-banner platform-banner--danger rounded-2xl text-sm leading-6">
+            {localError ?? error}
+          </div>
+        ) : null}
+      </section>
 
       <div className="mt-auto flex justify-end gap-2 pb-[max(0.25rem,env(safe-area-inset-bottom))] pt-3">
         <button
diff --git a/src/components/puzzle-clear-result/PuzzleClearResultView.test.tsx b/src/components/puzzle-clear-result/PuzzleClearResultView.test.tsx
index dc8b23ab..0ef0cd0a 100644
--- a/src/components/puzzle-clear-result/PuzzleClearResultView.test.tsx
+++ b/src/components/puzzle-clear-result/PuzzleClearResultView.test.tsx
@@ -130,7 +130,7 @@ function createProfile(
   };
 }
 
-test('结果页展示 atlas�中央底图与�牌预览，并触�试玩��布和图集�试', async () => {
+test('结果页展示 atlas�背景图与�牌预览，并触�试玩��布和图集�试', async () => {
   const onStartTestRun = vi.fn();
   const onPublish = vi.fn();
   const onRegenerateAtlas = vi.fn();
@@ -146,7 +146,7 @@ test('结果页展示 atlas�中央底图与�牌预览，并触�试玩�
     />,
   );
 
-  expect(screen.getByAltText('场地底图').getAttribute('src')).toBe(
+  expect(screen.getByAltText('背景图').getAttribute('src')).toBe(
     '/board-background.png',
   );
   expect(screen.getByAltText('素�图集').getAttribute('src')).toBe('/atlas.png');
@@ -158,13 +158,51 @@ test('结果页展示 atlas�中央底图与�牌预览，并触�试玩�
   await act(async () => {
     fireEvent.click(screen.getByRole('button', { name: /�布/u }));
   });
+  expect(screen.getByRole('dialog', { name: '�布�检查' })).not.toBeNull();
+  fireEvent.change(screen.getByLabelText('作�标题'), {
+    target: { value: '  �布标题  ' },
+  });
+  fireEvent.change(screen.getByLabelText('简介'), {
+    target: { value: '  �布简介  ' },
+  });
+  await act(async () => {
+    fireEvent.click(screen.getAllByRole('button', { name: /�布/u }).at(-1)!);
+  });
   fireEvent.click(screen.getByRole('button', { name: /图集/u }));
 
   expect(onStartTestRun).toHaveBeenCalledTimes(1);
-  expect(onPublish).toHaveBeenCalledTimes(1);
+  expect(onPublish).toHaveBeenCalledWith({
+    workTitle: '�布标题',
+    workDescription: '�布简介',
+  });
   expect(onRegenerateAtlas).toHaveBeenCalledTimes(1);
 });
 
+test('结果页�布�检查�求填写作�标题', async () => {
+  const onPublish = vi.fn();
+  render(
+    <PuzzleClearResultView
+      profile={createProfile()}
+      onBack={vi.fn()}
+      onEdit={vi.fn()}
+      onStartTestRun={vi.fn()}
+      onPublish={onPublish}
+      onRegenerateAtlas={vi.fn()}
+    />,
+  );
+
+  fireEvent.click(screen.getByRole('button', { name: /�布/u }));
+  fireEvent.change(screen.getByLabelText('作�标题'), {
+    target: { value: '   ' },
+  });
+  await act(async () => {
+    fireEvent.click(screen.getAllByRole('button', { name: /�布/u }).at(-1)!);
+  });
+
+  expect(screen.getByText('请填写作�标题。')).not.toBeNull();
+  expect(onPublish).not.toHaveBeenCalled();
+});
+
 test('结果页在素�未�布就绪时�用�布，且�写入规则说明文案', () => {
   render(
     <PuzzleClearResultView
diff --git a/src/components/puzzle-clear-result/PuzzleClearResultView.tsx b/src/components/puzzle-clear-result/PuzzleClearResultView.tsx
index 2677ca5e..db9b5487 100644
--- a/src/components/puzzle-clear-result/PuzzleClearResultView.tsx
+++ b/src/components/puzzle-clear-result/PuzzleClearResultView.tsx
@@ -7,6 +7,11 @@ import type {
 } from '../../../packages/shared/src/contracts/puzzleClear';
 import { ResolvedAssetImage } from '../ResolvedAssetImage';
 
+export type PuzzleClearPublishMeta = {
+  workTitle: string;
+  workDescription: string;
+};
+
 type PuzzleClearResultViewProps = {
   profile: PuzzleClearDraftResponse | PuzzleClearWorkProfileResponse;
   isBusy?: boolean;
@@ -14,7 +19,7 @@ type PuzzleClearResultViewProps = {
   onBack: () => void;
   onEdit: () => void;
   onStartTestRun: () => void;
-  onPublish: () => void;
+  onPublish: (metadata: PuzzleClearPublishMeta) => boolean | Promise<boolean | void> | void;
   onRegenerateAtlas: () => void;
 };
 
@@ -39,6 +44,10 @@ export function PuzzleClearResultView({
   onRegenerateAtlas,
 }: PuzzleClearResultViewProps) {
   const [isPublishing, setIsPublishing] = useState(false);
+  const [publishMeta, setPublishMeta] = useState<PuzzleClearPublishMeta | null>(
+    null,
+  );
+  const [publishMetaError, setPublishMetaError] = useState<string | null>(null);
   const isWorkProfile = isPuzzleClearWorkProfile(profile);
   const draft = getDraft(profile);
   const summary = isWorkProfile ? profile.summary : null;
@@ -54,10 +63,34 @@ export function PuzzleClearResultView({
   const previewCards = cardAssets.slice(0, 24);
   const canPublish = Boolean(isWorkProfile && summary?.publishReady);
 
+  const openPublishDialog = () => {
+    if (!canPublish || isBusy) {
+      return;
+    }
+    setPublishMeta({
+      workTitle: title.slice(0, 30),
+      workDescription: description.slice(0, 120),
+    });
+    setPublishMetaError(null);
+  };
+
   const handlePublish = async () => {
+    const normalizedMeta = {
+      workTitle: publishMeta?.workTitle.trim() ?? '',
+      workDescription: publishMeta?.workDescription.trim() ?? '',
+    };
+    if (!normalizedMeta.workTitle) {
+      setPublishMetaError('请填写作�标题。');
+      return;
+    }
+
     setIsPublishing(true);
     try {
-      await Promise.resolve(onPublish());
+      const result = await Promise.resolve(onPublish(normalizedMeta));
+      if (result !== false) {
+        setPublishMeta(null);
+        setPublishMetaError(null);
+      }
     } finally {
       setIsPublishing(false);
     }
@@ -101,12 +134,12 @@ export function PuzzleClearResultView({
               {boardBackgroundAsset?.imageSrc ? (
                 <ResolvedAssetImage
                   src={boardBackgroundAsset.imageSrc}
-                  alt="场地底图"
+                  alt="背景图"
                   className="aspect-[9/16] h-full w-full object-cover"
                 />
               ) : (
                 <div className="grid aspect-[9/16] place-items-center text-sm text-[var(--platform-text-soft)]">
-                  底图
+                  背景图
                 </div>
               )}
             </div>
@@ -193,7 +226,7 @@ export function PuzzleClearResultView({
               </button>
               <button
                 type="button"
-                onClick={handlePublish}
+                onClick={openPublishDialog}
                 disabled={isBusy || isPublishing || !canPublish}
                 className="platform-button platform-button--secondary min-h-11 justify-center gap-2 px-4 py-3"
               >
@@ -216,6 +249,102 @@ export function PuzzleClearResultView({
           </section>
         </aside>
       </div>
+
+      {publishMeta ? (
+        <div className="platform-modal-backdrop fixed inset-0 z-[80] flex items-center justify-center px-4 py-6">
+          <div
+            role="dialog"
+            aria-modal="true"
+            aria-labelledby="puzzle-clear-publish-meta-title"
+            className="platform-modal-shell platform-remap-surface w-full max-w-md rounded-[1.35rem] p-5 shadow-[0_24px_70px_rgba(15,23,42,0.22)]"
+          >
+            <div
+              id="puzzle-clear-publish-meta-title"
+              className="text-lg font-black text-[var(--platform-text-strong)]"
+            >
+              �布�检查
+            </div>
+            <div className="mt-4 grid gap-3">
+              <label className="block">
+                <span className="mb-2 block text-sm font-black text-[var(--platform-text-strong)]">
+                  作�标题
+                </span>
+                <input
+                  value={publishMeta.workTitle}
+                  maxLength={30}
+                  disabled={isBusy || isPublishing}
+                  onChange={(event) => {
+                    setPublishMeta((current) =>
+                      current
+                        ? {
+                            ...current,
+                            workTitle: event.target.value,
+                          }
+                        : current,
+                    );
+                    setPublishMetaError(null);
+                  }}
+                  className="w-full rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-4 py-3 text-sm font-semibold text-[var(--platform-text-strong)] outline-none"
+                />
+              </label>
+              <label className="block">
+                <span className="mb-2 block text-sm font-black text-[var(--platform-text-strong)]">
+                  简介
+                </span>
+                <textarea
+                  value={publishMeta.workDescription}
+                  maxLength={120}
+                  rows={4}
+                  disabled={isBusy || isPublishing}
+                  onChange={(event) =>
+                    setPublishMeta((current) =>
+                      current
+                        ? {
+                            ...current,
+                            workDescription: event.target.value,
+                          }
+                        : current,
+                    )
+                  }
+                  className="w-full resize-none rounded-[1rem] border border-[var(--platform-subpanel-border)] bg-white/90 px-4 py-3 text-sm leading-6 text-[var(--platform-text-strong)] outline-none"
+                />
+              </label>
+            </div>
+            {publishMetaError ? (
+              <div className="platform-banner platform-banner--danger mt-3 rounded-2xl text-sm leading-6">
+                {publishMetaError}
+              </div>
+            ) : null}
+            <div className="mt-5 grid grid-cols-2 gap-3">
+              <button
+                type="button"
+                disabled={isBusy || isPublishing}
+                onClick={() => setPublishMeta(null)}
+                className="platform-button platform-button--secondary justify-center"
+              >
+                �消
+              </button>
+              <button
+                type="button"
+                disabled={isBusy || isPublishing}
+                onClick={() => {
+                  void handlePublish();
+                }}
+                className={`platform-button platform-button--primary justify-center gap-2 ${
+                  isBusy || isPublishing ? 'cursor-not-allowed opacity-55' : ''
+                }`}
+              >
+                {isPublishing ? (
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                ) : (
+                  <Send className="h-4 w-4" />
+                )}
+                �布
+              </button>
+            </div>
+          </div>
+        </div>
+      ) : null}
     </div>
   );
 }
diff --git a/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx b/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx
index 3fbf02e1..3e6622a7 100644
--- a/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx
+++ b/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.test.tsx
@@ -862,6 +862,38 @@ test('按�已拼接局部时会拿起整个拼接组', () => {
   expect(ghost.getAttribute('style') ?? '').toContain('width: 120px');
 });
 
+test('已拼接局部拖到会越界的�置时�回弹��交�端动作', async () => {
+  const onSwapCards = vi.fn().mockResolvedValue(undefined);
+
+  render(
+    <PuzzleClearRuntimeShell
+      profile={createProfile()}
+      run={createRun()}
+      onSwapCards={onSwapCards}
+      onRetryLevel={vi.fn()}
+      onNextLevel={vi.fn()}
+      onTimeUp={vi.fn()}
+    />,
+  );
+
+  const from = screen.getByLabelText('�片 1-1');
+  const invalidTarget = screen.getByLabelText('�片 1-3');
+
+  fireEvent.pointerDown(from, { pointerId: 1, clientX: 18, clientY: 18 });
+  fireEvent.pointerMove(from, { pointerId: 1, clientX: 120, clientY: 20 });
+  fireEvent.pointerUp(invalidTarget, {
+    pointerId: 1,
+    clientX: 170,
+    clientY: 20,
+  });
+
+  expect(screen.getByTestId('puzzle-clear-drag-ghost').className).toContain(
+    'puzzle-clear-drag-ghost--returning',
+  );
+  await Promise.resolve();
+  expect(onSwapCards).not.toHaveBeenCalled();
+});
+
 test('按�已拼接局部时组内其他格�也会一起进入空槽状�', () => {
   render(
     <PuzzleClearRuntimeShell
@@ -882,8 +914,68 @@ test('按�已拼接局部时组内其他格�也会一起进入空槽状�',
 
   expect(from.className).toContain('puzzle-clear-card--drag-origin-empty');
   expect(neighbor.className).toContain('puzzle-clear-card--drag-group-empty');
+  expect(from.getAttribute('data-puzzle-clear-layer')).toBe('drag-group-source');
+  expect(neighbor.getAttribute('data-puzzle-clear-layer')).toBe('drag-group-source');
   expect(from.querySelector('img')).toBeNull();
   expect(neighbor.querySelector('img')).toBeNull();
+  expect(
+    screen
+      .getByTestId('puzzle-clear-board')
+      .querySelector('[data-testid="puzzle-clear-locked-group-visual"]'),
+  ).toBeNull();
+  expect(screen.getByTestId('puzzle-clear-drag-ghost').querySelectorAll('img')).toHaveLength(2);
+});
+
+test('拖起多格拼�组时格�层��残留被�罩压�的��', () => {
+  const run = cloneRunWithBoard(createRun(), {
+    rows: 3,
+    cols: 3,
+    cells: [
+      { row: 0, col: 0, card: createCard(70, 0, 0), lockedGroupId: 'block' },
+      { row: 0, col: 1, card: createCard(70, 1, 0), lockedGroupId: 'block' },
+      { row: 0, col: 2, card: createCard(72, 0, 0), lockedGroupId: null },
+      { row: 1, col: 0, card: createCard(70, 0, 1), lockedGroupId: 'block' },
+      { row: 1, col: 1, card: createCard(73, 0, 0), lockedGroupId: null },
+      { row: 1, col: 2, card: createCard(74, 0, 0), lockedGroupId: null },
+      { row: 2, col: 0, card: createCard(75, 0, 0), lockedGroupId: null },
+      { row: 2, col: 1, card: createCard(76, 0, 0), lockedGroupId: null },
+      { row: 2, col: 2, card: createCard(77, 0, 0), lockedGroupId: null },
+    ],
+  });
+
+  render(
+    <PuzzleClearRuntimeShell
+      profile={createProfile()}
+      run={run}
+      onSwapCards={vi.fn()}
+      onRetryLevel={vi.fn()}
+      onNextLevel={vi.fn()}
+      onTimeUp={vi.fn()}
+    />,
+  );
+
+  const from = screen.getByLabelText('�片 1-1');
+  fireEvent.pointerDown(from, { pointerId: 1, clientX: 18, clientY: 18 });
+  fireEvent.pointerMove(from, { pointerId: 1, clientX: 82, clientY: 44 });
+
+  const groupCells = [
+    screen.getByLabelText('�片 1-1'),
+    screen.getByLabelText('�片 1-2'),
+    screen.getByLabelText('�片 2-1'),
+  ];
+  for (const cell of groupCells) {
+    expect(cell.getAttribute('data-puzzle-clear-layer')).toBe('drag-group-source');
+    expect(cell.querySelector('img')).toBeNull();
+    expect(cell.className).toMatch(
+      /puzzle-clear-card--(?:drag-origin-empty|drag-group-empty)/u,
+    );
+  }
+  expect(
+    screen
+      .getByTestId('puzzle-clear-board')
+      .querySelector('[data-testid="puzzle-clear-locked-group-visual"]'),
+  ).toBeNull();
+  expect(screen.getByTestId('puzzle-clear-drag-ghost').querySelectorAll('img')).toHaveLength(3);
 });
 
 test('放下�会播放替��点动画', async () => {
@@ -946,13 +1038,15 @@ test('放下�被替�的�片会快速飞回空�', async () => {
   fireEvent.pointerMove(from, { pointerId: 1, clientX: 68, clientY: 20 });
   fireEvent.pointerUp(to, { pointerId: 1, clientX: 112, clientY: 20 });
 
-  expect(screen.getByTestId('puzzle-clear-swap-flight')).toBeTruthy();
-  expect(screen.getByTestId('puzzle-clear-swap-flight').className).toContain(
+  const flight = screen.getByTestId('puzzle-clear-swap-flight');
+  expect(flight).toBeTruthy();
+  expect(flight.className).toContain(
     'puzzle-clear-swap-flight--incoming',
   );
-  expect(screen.getByTestId('puzzle-clear-swap-flight').getAttribute('style') ?? '').toContain(
+  expect(flight.getAttribute('style') ?? '').toContain(
     '--puzzle-clear-flight-delta-x',
   );
+  expect(flight.querySelector('img')?.getAttribute('src')).toBe('/cards/1-1-0.png');
 
   resolveSwapPromise();
   await waitFor(() =>
@@ -1021,6 +1115,14 @@ test('消除�功时会播放消除和掉�过渡动画', async () => {
       .querySelector('.puzzle-clear-transition-piece--drop')
       ?.getAttribute('style') ?? '',
   ).toContain('--puzzle-clear-drop-delay: 520ms');
+  const dropPiece = screen
+    .getByTestId('puzzle-clear-board')
+    .querySelector<HTMLElement>('.puzzle-clear-transition-piece--drop');
+  expect(dropPiece?.getAttribute('style') ?? '').toContain(
+    '--puzzle-clear-drop-duration:',
+  );
+  expect(dropPiece?.className ?? '').not.toContain('bg-white');
+  expect(dropPiece?.className ?? '').not.toContain('border-white');
 });
 
 test('正确局部拼�但未消除时会高光�醒拼�组', async () => {
diff --git a/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx b/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx
index 50afc99b..3db2fca1 100644
--- a/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx
+++ b/src/components/puzzle-clear-runtime/PuzzleClearRuntimeShell.tsx
@@ -83,6 +83,8 @@ type PuzzleClearBoardPreviewState = {
   swapFeedback: PuzzleClearSwapFeedbackState | null;
 };
 
+type PuzzleClearCardLayerState = 'empty' | 'card' | 'locked-group' | 'drag-group-source';
+
 type PuzzleClearSwapFeedbackState = {
   from: PuzzleClearGridPosition;
   to: PuzzleClearGridPosition;
@@ -98,6 +100,7 @@ type PuzzleClearSwapFlightState = {
 
 type PuzzleClearClearTransitionState = {
   transitionKey: number;
+  durationMs: number;
   clearedCells: Array<{
     row: number;
     col: number;
@@ -109,6 +112,7 @@ type PuzzleClearClearTransitionState = {
     card: PuzzleClearCardAsset;
     distance: number;
     delayMs: number;
+    durationMs: number;
     hideBoardCell: boolean;
   }>;
 };
@@ -123,6 +127,9 @@ type PuzzleClearLockedGroupViewModel = PuzzleClearDragGroupState;
 const PUZZLE_CLEAR_CLEAR_TRANSITION_MS = 1120;
 const PUZZLE_CLEAR_REFILL_DROP_DELAY_MS = 520;
 const PUZZLE_CLEAR_DROP_STAGGER_MAX_MS = 180;
+const PUZZLE_CLEAR_DROP_BASE_DURATION_MS = 620;
+const PUZZLE_CLEAR_DROP_DISTANCE_DURATION_MS = 72;
+const PUZZLE_CLEAR_DROP_SETTLE_BUFFER_MS = 120;
 const PUZZLE_CLEAR_MERGE_HIGHLIGHT_MS = 760;
 
 function getRun(
@@ -282,6 +289,29 @@ function cloneDragGroupState(
   };
 }
 
+function canPlacePuzzleClearDraggedGroup(
+  group: PuzzleClearDragGroupState | null | undefined,
+  board: PuzzleClearRuntimeSnapshotResponse['board'] | null | undefined,
+  from: PuzzleClearGridPosition,
+  to: PuzzleClearGridPosition,
+) {
+  if (!group || !board) {
+    return true;
+  }
+  const rowDelta = to.row - from.row;
+  const colDelta = to.col - from.col;
+  return group.cells.every((entry) => {
+    const nextRow = entry.row + rowDelta;
+    const nextCol = entry.col + colDelta;
+    return (
+      nextRow >= 0 &&
+      nextCol >= 0 &&
+      nextRow < board.rows &&
+      nextCol < board.cols
+    );
+  });
+}
+
 function buildPuzzleClearLockedGroupSignatures(
   run: PuzzleClearRuntimeSnapshotResponse,
 ) {
@@ -391,6 +421,9 @@ function buildPuzzleClearClearTransition(
         col: cell.col,
         card: cell.card!,
         distance: movedDistance,
+        durationMs:
+          PUZZLE_CLEAR_DROP_BASE_DURATION_MS +
+          Math.max(0, movedDistance - 1) * PUZZLE_CLEAR_DROP_DISTANCE_DURATION_MS,
         delayMs:
           PUZZLE_CLEAR_REFILL_DROP_DELAY_MS +
           Math.min(
@@ -409,6 +442,7 @@ function buildPuzzleClearClearTransition(
         card: PuzzleClearCardAsset;
         distance: number;
         delayMs: number;
+        durationMs: number;
         hideBoardCell: boolean;
       } => cell !== null,
     )
@@ -425,6 +459,10 @@ function buildPuzzleClearClearTransition(
 
   return {
     transitionKey: Date.now(),
+    durationMs: Math.max(
+      PUZZLE_CLEAR_CLEAR_TRANSITION_MS,
+      ...dropCells.map((cell) => cell.delayMs + cell.durationMs + PUZZLE_CLEAR_DROP_SETTLE_BUFFER_MS),
+    ),
     clearedCells,
     dropCells,
   };
@@ -676,7 +714,7 @@ export function PuzzleClearRuntimeShell({
       clearTransitionTimerRef.current = window.setTimeout(() => {
         clearTransitionTimerRef.current = null;
         setClearTransition(null);
-      }, PUZZLE_CLEAR_CLEAR_TRANSITION_MS);
+      }, transition.durationMs);
       return;
     }
 
@@ -931,7 +969,15 @@ export function PuzzleClearRuntimeShell({
     const target = cells.get(
       getCellKey(releaseTarget.row, releaseTarget.col),
     );
-    if (!target) {
+    if (
+      !target ||
+      !canPlacePuzzleClearDraggedGroup(
+        dragState?.group,
+        board,
+        origin,
+        releaseTarget,
+      )
+    ) {
       setSelectedCell(null);
       setDragState((current) =>
         current
@@ -960,10 +1006,6 @@ export function PuzzleClearRuntimeShell({
       readElementRect(
         cellElementRefMap.current.get(getCellKey(origin.row, origin.col)),
       );
-    const sourceCard =
-      dragState?.card ??
-      cells.get(getCellKey(origin.row, origin.col))?.card ??
-      null;
     setDragState((current) =>
       current
         ? {
@@ -976,11 +1018,11 @@ export function PuzzleClearRuntimeShell({
         }
         : current,
     );
-    if (targetRect && sourceRect && sourceCard) {
+    if (targetRect && sourceRect && target.card) {
       setSwapFlight({
-        card: sourceCard,
-        fromRect: sourceRect,
-        toRect: targetRect,
+        card: target.card,
+        fromRect: targetRect,
+        toRect: sourceRect,
         flightKey: Date.now(),
       });
     }
@@ -1102,6 +1144,13 @@ export function PuzzleClearRuntimeShell({
               const isDraggedGroupCell = draggedGroupCellKeys.has(
                 getCellKey(row, col),
               );
+              const cardLayerState: PuzzleClearCardLayerState = isDraggedGroupCell
+                ? 'drag-group-source'
+                : cell?.lockedGroupId
+                  ? 'locked-group'
+                  : card
+                    ? 'card'
+                    : 'empty';
               const selected =
                 selectedCell?.row === row && selectedCell?.col === col;
               const isSwapFeedbackCell =
@@ -1153,6 +1202,8 @@ export function PuzzleClearRuntimeShell({
                   data-puzzle-clear-cell="true"
                   data-puzzle-clear-row={row}
                   data-puzzle-clear-col={col}
+                  data-puzzle-clear-layer={cardLayerState}
+                  data-puzzle-clear-locked-group-id={cell?.lockedGroupId ?? undefined}
                   draggable={false}
                   onDragStart={(event) => event.preventDefault()}
                   className={`puzzle-clear-card relative z-10 grid min-h-0 touch-none select-none place-items-center overflow-hidden rounded-[0.6rem] border transition ${
@@ -1195,13 +1246,10 @@ export function PuzzleClearRuntimeShell({
                   style={style}
                   aria-label={`�片 ${row + 1}-${col + 1}`}
                 >
-                  {card && !isDraggedGroupCell ? (
+                  {cardLayerState === 'card' ? (
                     <span className="absolute inset-1 rounded-[0.48rem] bg-[var(--puzzle-clear-card-tone)] opacity-45" />
                   ) : null}
-                  {card?.imageSrc &&
-                  !isDragOrigin &&
-                  !isDraggedGroupCell &&
-                  !cell?.lockedGroupId ? (
+                  {cardLayerState === 'card' && card?.imageSrc ? (
                     <ResolvedAssetImage
                       src={card.imageSrc}
                       alt=""
@@ -1210,7 +1258,7 @@ export function PuzzleClearRuntimeShell({
                       className="pointer-events-none relative z-10 h-full w-full select-none rounded-[0.48rem] object-cover"
                     />
                   ) : null}
-                  {isDragOrigin ? (
+                  {isDraggedGroupCell ? (
                     <span className="relative z-10 h-full w-full rounded-[0.48rem] border border-dashed border-white/28 bg-white/8" />
                   ) : null}
                 </button>
@@ -1303,11 +1351,12 @@ export function PuzzleClearRuntimeShell({
                 {clearTransition.dropCells.map((cell) => (
                   <div
                     key={`drop:${clearTransition.transitionKey}:${cell.row}:${cell.col}:${cell.card.cardId}`}
-                    className="puzzle-clear-transition-piece puzzle-clear-transition-piece--drop overflow-hidden rounded-[0.6rem] border border-white/72 bg-white/70"
+                    className="puzzle-clear-transition-piece puzzle-clear-transition-piece--drop overflow-hidden rounded-[0.6rem]"
                     style={{
                       gridColumn: cell.col + 1,
                       gridRow: cell.row + 1,
                       '--puzzle-clear-drop-delay': `${cell.delayMs}ms`,
+                      '--puzzle-clear-drop-duration': `${cell.durationMs}ms`,
                       '--puzzle-clear-drop-start-y': `calc(-120% - ${Math.max(
                         0,
                         cell.distance - 1,
diff --git a/src/index.css b/src/index.css
index 702f1e98..b328f16c 100644
--- a/src/index.css
+++ b/src/index.css
@@ -250,19 +250,30 @@ body {
 @keyframes puzzle-clear-transition-drop {
   0% {
     opacity: 0;
-    transform: translateY(var(--puzzle-clear-drop-start-y, -120%)) scale(0.96);
-    filter: saturate(1.08) brightness(1.03);
+    transform: translate3d(0, var(--puzzle-clear-drop-start-y, -120%), 0)
+      scale(0.985);
+    filter: saturate(1.04) brightness(1);
   }
 
-  55% {
+  10% {
     opacity: 1;
-    transform: translateY(10%) scale(1.02);
-    filter: saturate(1.03) brightness(1.01);
+  }
+
+  72% {
+    opacity: 1;
+    transform: translate3d(0, 7%, 0) scale(1);
+    filter: saturate(1.02) brightness(1);
+  }
+
+  88% {
+    opacity: 1;
+    transform: translate3d(0, -2.5%, 0) scale(1);
+    filter: saturate(1) brightness(1);
   }
 
   100% {
     opacity: 1;
-    transform: translateY(0) scale(1);
+    transform: translate3d(0, 0, 0) scale(1);
     filter: saturate(1) brightness(1);
   }
 }
@@ -317,7 +328,9 @@ body {
   box-shadow: none;
 }
 
+.puzzle-clear-card--drag-group-empty img,
 .puzzle-clear-card--drag-group-empty > span:first-child {
+  visibility: hidden;
   opacity: 0;
 }
 
@@ -327,7 +340,9 @@ body {
   box-shadow: none;
 }
 
+.puzzle-clear-card--drag-origin-empty img,
 .puzzle-clear-card--drag-origin-empty > span:first-child {
+  visibility: hidden;
   opacity: 0;
 }
 
@@ -349,10 +364,16 @@ body {
 
 .puzzle-clear-swap-flight {
   overflow: hidden;
-  border: 1px solid rgba(255, 255, 255, 0.88);
+  border: 0;
   border-radius: 0.6rem;
-  background: white;
-  box-shadow: 0 14px 34px rgba(15, 23, 42, 0.18);
+  background: transparent;
+  box-shadow: 0 12px 24px rgba(15, 23, 42, 0.12);
+  backface-visibility: hidden;
+  contain: paint;
+}
+
+.puzzle-clear-swap-flight img {
+  box-shadow: 0 8px 18px rgba(15, 23, 42, 0.12);
 }
 
 .puzzle-clear-swap-flight--incoming {
@@ -434,10 +455,20 @@ body {
 }
 
 .puzzle-clear-transition-piece--drop {
-  animation: puzzle-clear-transition-drop 460ms cubic-bezier(0.18, 0.82, 0.24, 1)
-    both;
+  animation: puzzle-clear-transition-drop var(--puzzle-clear-drop-duration, 680ms)
+    cubic-bezier(0.16, 0.82, 0.22, 1) both;
   animation-delay: var(--puzzle-clear-drop-delay, 0ms);
+  background: transparent;
+  border: 0;
   will-change: transform, opacity, filter;
+  transform: translate3d(0, var(--puzzle-clear-drop-start-y, -120%), 0)
+    scale(0.985);
+  backface-visibility: hidden;
+  contain: paint;
+}
+
+.puzzle-clear-transition-piece--drop img {
+  box-shadow: 0 8px 18px rgba(15, 23, 42, 0.12);
 }
 
 @keyframes puzzle-clear-card-swap-feedback {
diff --git a/src/index.test.ts b/src/index.test.ts
index 6a54c2f9..ee9ea465 100644
--- a/src/index.test.ts
+++ b/src/index.test.ts
@@ -101,3 +101,32 @@ describe('index stylesheet creation agent hero contrast', () => {
     expect(hintBlock).toContain('rgba(255, 255, 255, 0.72) !important');
   });
 });
+
+describe('index stylesheet puzzle clear drop animation', () => {
+  it('keeps refill card drops transparent and driven by per-card duration', () => {
+    const css = readIndexCss();
+
+    const dropBlock = getCssBlock(css, '.puzzle-clear-transition-piece--drop');
+    expect(dropBlock).toContain(
+      'animation: puzzle-clear-transition-drop var(--puzzle-clear-drop-duration, 680ms)',
+    );
+    expect(dropBlock).toContain('background: transparent;');
+    expect(dropBlock).toContain('border: 0;');
+    expect(dropBlock).toContain('translate3d(0, var(--puzzle-clear-drop-start-y, -120%), 0)');
+
+    const keyframesBlock = getCssBlock(css, '@keyframes puzzle-clear-transition-drop');
+    expect(keyframesBlock).toContain('translate3d(0, 7%, 0)');
+    expect(keyframesBlock).toContain('translate3d(0, -2.5%, 0)');
+    expect(keyframesBlock).not.toContain('brightness(1.03)');
+  });
+
+  it('keeps swap replacement flights transparent instead of flashing a white shell', () => {
+    const css = readIndexCss();
+
+    const swapFlightBlock = getCssBlock(css, '.puzzle-clear-swap-flight');
+    expect(swapFlightBlock).toContain('background: transparent;');
+    expect(swapFlightBlock).toContain('border: 0;');
+    expect(swapFlightBlock).not.toContain('background: white;');
+    expect(swapFlightBlock).not.toContain('rgba(255, 255, 255');
+  });
+});
diff --git a/src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts b/src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts
index 4333cb93..d0d2c2cf 100644
--- a/src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts
+++ b/src/services/puzzle-clear/puzzleClearLocalRuntime.test.ts
@@ -98,6 +98,33 @@ function createDraftWork(): PuzzleClearWorkProfileResponse {
   return createDraftWorkWithCardCount(70);
 }
 
+function createDraftWorkWithAllShapes(): PuzzleClearWorkProfileResponse {
+  const work = createDraftWorkWithCardCount(70);
+  const extraCards = [
+    createCustomCard('tri-a', 'tri-a-0', 0, 0, '1x3'),
+    createCustomCard('tri-a', 'tri-a-1', 1, 0, '1x3'),
+    createCustomCard('tri-a', 'tri-a-2', 2, 0, '1x3'),
+    createCustomCard('block-a', 'block-a-0-0', 0, 0, '2x2'),
+    createCustomCard('block-a', 'block-a-1-0', 1, 0, '2x2'),
+    createCustomCard('block-a', 'block-a-0-1', 0, 1, '2x2'),
+    createCustomCard('block-a', 'block-a-1-1', 1, 1, '2x2'),
+    createCustomCard('wide-a', 'wide-a-0-0', 0, 0, '2x3'),
+    createCustomCard('wide-a', 'wide-a-1-0', 1, 0, '2x3'),
+    createCustomCard('wide-a', 'wide-a-2-0', 2, 0, '2x3'),
+    createCustomCard('wide-a', 'wide-a-0-1', 0, 1, '2x3'),
+    createCustomCard('wide-a', 'wide-a-1-1', 1, 1, '2x3'),
+    createCustomCard('wide-a', 'wide-a-2-1', 2, 1, '2x3'),
+  ];
+  return {
+    ...work,
+    draft: {
+      ...work.draft,
+      cardAssets: [...work.draft.cardAssets, ...extraCards],
+    },
+    cardAssets: [...work.cardAssets, ...extraCards],
+  };
+}
+
 function createDraftWorkWithCardCount(cardCount: number): PuzzleClearWorkProfileResponse {
   const atlasAsset = {
     assetId: 'atlas-1',
@@ -159,12 +186,13 @@ test('�稿试玩创建本地�行�，��求作�先�布', () => {
   expect(run.status).toBe('playing');
   expect(run.board.rows).toBe(6);
   expect(run.board.cols).toBe(6);
-  expect(run.targetClears).toBe(35);
+  expect(run.targetClears).toBe(15);
+  expect(run.levelDurationSeconds).toBe(300);
   expect(run.readyColumns).toHaveLength(run.board.cols);
   expect(isPuzzleClearLocalRuntimeSnapshot(run)).toBe(true);
 });
 
-test('本地�稿�行�支�交���试��关推进和超时失败', () => {
+test('本地�稿�行�支�交���试�推进和超时失败', () => {
   const work = createDraftWork();
   const run = createPuzzleClearLocalRuntimeSnapshot(work);
   const preparedRun = {
@@ -210,33 +238,66 @@ test('本地�稿�行�支�交���试��关推进和超时失败',
   expect(retried.levelIndex).toBe(failed.levelIndex);
 
   const next = advancePuzzleClearLocalLevel(retried, work);
-  expect(next.levelIndex).toBe(1);
+  expect(next.levelIndex).toBe(2);
   expect(next.status).toBe('playing');
-  expect(next.targetClears).toBe(35);
+  expect(next.targetClears).toBe(20);
+  expect(next.levelDurationSeconds).toBe(300);
 });
 
-test('本地�行�固定使用 6x6 棋盘和 35 次消除目标', () => {
+test('本地�行�固定使用 4 关 6x6 棋盘和�关目标', () => {
   const work = createDraftWork();
-  const run = createPuzzleClearLocalRuntimeSnapshot(work, 4);
+  const levels = [1, 2, 3, 4].map((levelIndex) =>
+    createPuzzleClearLocalRuntimeSnapshot(work, levelIndex),
+  );
 
-  expect(run.levelIndex).toBe(1);
-  expect(run.board.rows).toBe(6);
-  expect(run.board.cols).toBe(6);
-  expect(run.targetClears).toBe(35);
+  expect(
+    levels.map((run) => ({
+      levelIndex: run.levelIndex,
+      rows: run.board.rows,
+      cols: run.board.cols,
+      targetClears: run.targetClears,
+      duration: run.levelDurationSeconds,
+    })),
+  ).toEqual([
+    { levelIndex: 1, rows: 6, cols: 6, targetClears: 15, duration: 300 },
+    { levelIndex: 2, rows: 6, cols: 6, targetClears: 20, duration: 300 },
+    { levelIndex: 3, rows: 6, cols: 6, targetClears: 30, duration: 420 },
+    { levelIndex: 4, rows: 6, cols: 6, targetClears: 35, duration: 600 },
+  ]);
 });
 
-test('本地�稿�会�留�关目标所需的 35 个图案组，剩余�进入顶部准备区', () => {
+test('本地�稿第一关�使用刚好 15 组 1x2 图案，牌�足棋盘时留出空格', () => {
   const work = createDraftWorkWithCardCount(80);
   const run = createPuzzleClearLocalRuntimeSnapshot(work);
-  const boardCardCount = run.board.rows * run.board.cols;
+  const boardCardCount = run.board.cells.filter((cell) => cell.card).length;
+  const emptyCellCount = run.board.cells.filter((cell) => !cell.card).length;
   const reserveCardCount = run.readyColumns.flat().length;
 
-  expect(run.board.cells.every((cell) => cell.card?.shape === '1x2')).toBe(true);
-  expect(boardCardCount).toBe(36);
-  expect(reserveCardCount).toBe(34);
+  expect(
+    run.board.cells.every((cell) => !cell.card || cell.card.shape === '1x2'),
+  ).toBe(true);
+  expect(boardCardCount).toBe(30);
+  expect(emptyCellCount).toBe(6);
+  expect(reserveCardCount).toBe(0);
   expect(run.readyColumns).toHaveLength(run.board.cols);
 });
 
+test('本地�稿按关��步解�消除形状', () => {
+  const work = createDraftWorkWithAllShapes();
+  const levelShapeSets = [1, 2, 3, 4].map((levelIndex) => {
+    const run = createPuzzleClearLocalRuntimeSnapshot(work, levelIndex);
+    return new Set(
+      [...run.board.cells.map((cell) => cell.card?.shape), ...run.readyColumns.flat().map((card) => card.shape)]
+        .filter(Boolean),
+    );
+  });
+
+  expect([...levelShapeSets[0]!].sort()).toEqual(['1x2']);
+  expect([...levelShapeSets[1]!].sort()).toEqual(['1x2', '1x3']);
+  expect([...levelShapeSets[2]!].sort()).toEqual(['1x2', '1x3', '2x2']);
+  expect([...levelShapeSets[3]!].sort()).toEqual(['1x2', '1x3', '2x2', '2x3']);
+});
+
 test('本地�稿开局�会直接摆出已完�的图案组', () => {
   const work = createDraftWorkWithCardCount(80);
   const run = createPuzzleClearLocalRuntimeSnapshot(work);
@@ -282,6 +343,44 @@ test('本地�稿第一关�会把 1x2 当���定拼接组留在场上',
   expect(movedNearButIncomplete.clearsDone).toBe(0);
 });
 
+test('本地�稿会把 2x2 的 L 形局部拼�整体��', () => {
+  const work = createDraftWork();
+  const run = createPuzzleClearLocalRuntimeSnapshot(work);
+  const preparedRun = {
+    ...run,
+    board: {
+      rows: 3,
+      cols: 3,
+      cells: [
+        { row: 0, col: 0, card: createCustomCard('block', 'block-0-0', 0, 0, '2x2'), lockedGroupId: null },
+        { row: 0, col: 1, card: createCustomCard('block', 'block-1-0', 1, 0, '2x2'), lockedGroupId: null },
+        { row: 0, col: 2, card: createCustomCard('noise-a', 'noise-a', 0, 0), lockedGroupId: null },
+        { row: 1, col: 0, card: createCustomCard('block', 'block-0-1', 0, 1, '2x2'), lockedGroupId: null },
+        { row: 1, col: 1, card: createCustomCard('noise-b', 'noise-b', 0, 0), lockedGroupId: null },
+        { row: 1, col: 2, card: createCustomCard('noise-c', 'noise-c', 0, 0), lockedGroupId: null },
+        { row: 2, col: 0, card: createCustomCard('noise-d', 'noise-d', 0, 0), lockedGroupId: null },
+        { row: 2, col: 1, card: createCustomCard('play', 'play-0', 0, 0), lockedGroupId: null },
+        { row: 2, col: 2, card: createCustomCard('play', 'play-1', 1, 0), lockedGroupId: null },
+      ],
+    },
+    readyColumns: [[], [], []],
+  };
+
+  const next = swapPuzzleClearLocalCards(preparedRun, {
+    fromRow: 2,
+    fromCol: 1,
+    toRow: 2,
+    toCol: 2,
+  });
+
+  expect(
+    next.board.cells
+      .filter((cell) => cell.card?.groupId === 'block')
+      .map((cell) => cell.lockedGroupId),
+  ).toEqual(['block', 'block', 'block']);
+  expect(next.clearsDone).toBe(0);
+});
+
 test('本地�稿补�时会从其它准备列借牌��出现空格�', () => {
   const work = createDraftWork();
   const run = createPuzzleClearLocalRuntimeSnapshot(work);
@@ -415,7 +514,7 @@ test('本地�稿交��完整 1x2 图案�会消除并从顶部准备区补
   expect(next.readyColumns[1]).toHaveLength(0);
 });
 
-test('本地�稿达到当�关目标但场上�有�牌时�会��完�', () => {
+test('本地�稿达到当�关目标但�有牌时�会完�当�关', () => {
   const work = createDraftWork();
   const run = createPuzzleClearLocalRuntimeSnapshot(work);
   const firstPart = createCustomCard('pair-b', 'pair-b-0', 0, 0);
@@ -465,11 +564,12 @@ test('本地�稿达到当�关目标但场上�有�牌时�会��完
   expect(next.clearsDone).toBe(1);
   expect(next.status).toBe('playing');
   expect(next.finishedAtMs).toBeNull();
+  expect(next.board.cells.some((cell) => cell.card)).toBe(true);
 });
 
-test('本地�稿�有在达到目标且清空棋盘��进入关�完�状�', () => {
+test('本地�稿最�一关达到目标�进入整局完�状�', () => {
   const work = createDraftWork();
-  const run = createPuzzleClearLocalRuntimeSnapshot(work);
+  const run = createPuzzleClearLocalRuntimeSnapshot(work, 4);
   const firstPart = createCustomCard('pair-c', 'pair-c-0', 0, 0);
   const secondPart = createCustomCard('pair-c', 'pair-c-1', 1, 0);
   const preparedRun = {
diff --git a/src/services/puzzle-clear/puzzleClearLocalRuntime.ts b/src/services/puzzle-clear/puzzleClearLocalRuntime.ts
index 42f1d535..9a016dfa 100644
--- a/src/services/puzzle-clear/puzzleClearLocalRuntime.ts
+++ b/src/services/puzzle-clear/puzzleClearLocalRuntime.ts
@@ -6,18 +6,36 @@ import type {
   PuzzleClearWorkProfileResponse,
 } from '../../../packages/shared/src/contracts/puzzleClear';
 
-const PUZZLE_CLEAR_LOCAL_RUNTIME_DURATION_SECONDS = 600;
-const PUZZLE_CLEAR_LOCAL_MAX_LEVEL = 1;
 const PUZZLE_CLEAR_LEVEL_CONFIGS = [
-  { size: 6, targetClears: 35 },
+  {
+    size: 6,
+    targetClears: 15,
+    durationSeconds: 300,
+    unlockedShapes: ['1x2'],
+  },
+  {
+    size: 6,
+    targetClears: 20,
+    durationSeconds: 300,
+    unlockedShapes: ['1x2', '1x3'],
+  },
+  {
+    size: 6,
+    targetClears: 30,
+    durationSeconds: 420,
+    unlockedShapes: ['1x2', '1x3', '2x2'],
+  },
+  {
+    size: 6,
+    targetClears: 35,
+    durationSeconds: 600,
+    unlockedShapes: ['1x2', '1x3', '2x2', '2x3'],
+  },
 ] as const;
 type PuzzleClearLevelConfig = (typeof PUZZLE_CLEAR_LEVEL_CONFIGS)[number];
+const PUZZLE_CLEAR_LOCAL_MAX_LEVEL = PUZZLE_CLEAR_LEVEL_CONFIGS.length;
 const PUZZLE_CLEAR_FALLBACK_LEVEL_CONFIG: PuzzleClearLevelConfig =
   PUZZLE_CLEAR_LEVEL_CONFIGS[PUZZLE_CLEAR_LEVEL_CONFIGS.length - 1]!;
-const PUZZLE_CLEAR_LEVEL_UNLOCKED_SHAPES: readonly PuzzleClearCardAsset['shape'][][] =
-  [
-    ['1x2', '1x3', '2x2', '2x3'],
-  ];
 
 type PuzzleClearLocalRuntimeBoardCell = {
   row: number;
@@ -60,14 +78,7 @@ function resolvePuzzleClearLevelConfig(
 function resolvePuzzleClearLevelUnlockedShapes(
   levelIndex: number,
 ): readonly PuzzleClearCardAsset['shape'][] {
-  const normalizedLevelIndex = Math.min(
-    PUZZLE_CLEAR_LEVEL_UNLOCKED_SHAPES.length - 1,
-    Math.max(0, levelIndex - 1),
-  );
-  return (
-    PUZZLE_CLEAR_LEVEL_UNLOCKED_SHAPES[normalizedLevelIndex] ??
-    PUZZLE_CLEAR_LEVEL_UNLOCKED_SHAPES[PUZZLE_CLEAR_LEVEL_UNLOCKED_SHAPES.length - 1]!
-  );
+  return resolvePuzzleClearLevelConfig(levelIndex).unlockedShapes;
 }
 
 function stablePuzzleClearGroupKey(seed: string, groupId: string) {
@@ -84,8 +95,9 @@ function buildPuzzleClearLevelCards(
   levelIndex: number,
 ) {
   const cards = work.cardAssets.length > 0 ? work.cardAssets : work.draft.cardAssets;
-  const unlockedShapes = new Set(resolvePuzzleClearLevelUnlockedShapes(levelIndex));
-  const targetGroups = resolvePuzzleClearLevelConfig(levelIndex).targetClears;
+  const levelConfig = resolvePuzzleClearLevelConfig(levelIndex);
+  const unlockedShapes = new Set(levelConfig.unlockedShapes);
+  const targetGroups = levelConfig.targetClears;
   const groupedCards = new Map<string, PuzzleClearCardAsset[]>();
 
   for (const card of cards) {
@@ -97,7 +109,7 @@ function buildPuzzleClearLevelCards(
     groupedCards.set(card.groupId, entries);
   }
 
-  return [...groupedCards.entries()]
+  const sortedGroups = [...groupedCards.entries()]
     .map(([groupId, entries]) => ({
       groupId,
       cards: entries.sort((left, right) => left.partY - right.partY || left.partX - right.partX),
@@ -109,9 +121,33 @@ function buildPuzzleClearLevelCards(
         return left.groupId.localeCompare(right.groupId);
       }
       return leftKey < rightKey ? -1 : 1;
-    })
-    .slice(0, targetGroups)
-    .flatMap((group) => group.cards);
+    });
+  const selectedGroups: typeof sortedGroups = [];
+  const selectedGroupIds = new Set<string>();
+
+  for (const shape of levelConfig.unlockedShapes) {
+    const candidate = sortedGroups.find(
+      (group) =>
+        group.cards[0]?.shape === shape && !selectedGroupIds.has(group.groupId),
+    );
+    if (candidate && selectedGroups.length < targetGroups) {
+      selectedGroups.push(candidate);
+      selectedGroupIds.add(candidate.groupId);
+    }
+  }
+
+  for (const group of sortedGroups) {
+    if (selectedGroups.length >= targetGroups) {
+      break;
+    }
+    if (selectedGroupIds.has(group.groupId)) {
+      continue;
+    }
+    selectedGroups.push(group);
+    selectedGroupIds.add(group.groupId);
+  }
+
+  return selectedGroups.flatMap((group) => group.cards);
 }
 
 function shufflePuzzleClearLocalCards(
@@ -141,17 +177,20 @@ function buildLocalRuntimeBoard(
 ) {
   const size = resolvePuzzleClearLevelConfig(levelIndex).size;
   const visibleCards = cards.slice(0, size * size);
+  const totalCells = size * size;
   for (let attempt = 0; attempt < 128; attempt += 1) {
     const attemptSeed = `${seed}:level-${levelIndex}:attempt-${attempt}`;
     const shuffledCards = shufflePuzzleClearLocalCards(visibleCards, attemptSeed);
+    const emptySlots = Math.max(0, totalCells - shuffledCards.length);
     const boardCells: PuzzleClearLocalRuntimeBoardCell[] = [];
     let index = 0;
     for (let row = 0; row < size; row += 1) {
       for (let col = 0; col < size; col += 1) {
+        const cardIndex = index - emptySlots;
         boardCells.push({
           row,
           col,
-          card: cloneCard(shuffledCards[index] ?? null),
+          card: cardIndex >= 0 ? cloneCard(shuffledCards[cardIndex] ?? null) : null,
           lockedGroupId: null,
         });
         index += 1;
@@ -175,10 +214,12 @@ function buildLocalRuntimeBoard(
     cells: Array.from({ length: size * size }, (_, index) => {
       const row = Math.floor(index / size);
       const col = index % size;
+      const emptySlots = Math.max(0, size * size - visibleCards.length);
+      const cardIndex = index - emptySlots;
       return {
         row,
         col,
-        card: cloneCard(visibleCards[index] ?? null),
+        card: cardIndex >= 0 ? cloneCard(visibleCards[cardIndex] ?? null) : null,
         lockedGroupId: null,
       };
     }),
@@ -257,6 +298,33 @@ function partPositionKey(row: number, col: number, partX: number, partY: number)
   return `${row}:${col}:${partX}:${partY}`;
 }
 
+function isPuzzleClearConnectedPartialGroup(
+  entries: Array<{ row: number; col: number; card: PuzzleClearCardAsset }>,
+) {
+  if (entries.length < 2) {
+    return false;
+  }
+  const visited = new Set<number>([0]);
+  const queue = [0];
+  while (queue.length > 0) {
+    const index = queue.shift()!;
+    const current = entries[index]!;
+    entries.forEach((candidate, candidateIndex) => {
+      if (visited.has(candidateIndex)) {
+        return;
+      }
+      if (
+        getPartDistance(current.card, candidate.card) === 1 &&
+        areNeighborCells(current, candidate)
+      ) {
+        visited.add(candidateIndex);
+        queue.push(candidateIndex);
+      }
+    });
+  }
+  return visited.size === entries.length;
+}
+
 function getCardAt(board: PuzzleClearBoardSnapshot, row: number, col: number) {
   return findCell(board, row, col)?.card ?? null;
 }
@@ -331,18 +399,7 @@ function findPuzzleClearLocalCompletedPartialGroups(
     if (!first || first.shape === '1x2' || entries.length < 2) {
       continue;
     }
-    const ordered = [...entries].sort(
-      (left, right) =>
-        left.card.partY - right.card.partY || left.card.partX - right.card.partX,
-    );
-    const adjacent = ordered.slice(1).every((entry, index) => {
-      const previous = ordered[index]!;
-      return (
-        getPartDistance(previous.card, entry.card) === 1 &&
-        areNeighborCells(previous, entry)
-      );
-    });
-    if (adjacent) {
+    if (isPuzzleClearConnectedPartialGroup(entries)) {
       groups.push({
         groupId,
         positions: entries.map((entry) => ({ row: entry.row, col: entry.col })),
@@ -508,6 +565,15 @@ function hasPuzzleClearLocalRemainingCards(board: PuzzleClearBoardSnapshot) {
   return board.cells.some((cell) => Boolean(cell.card));
 }
 
+function hasPuzzleClearLocalRemainingCardsInRun(
+  run: PuzzleClearRuntimeSnapshotResponse,
+) {
+  return (
+    hasPuzzleClearLocalRemainingCards(run.board) ||
+    run.readyColumns.some((column) => column.length > 0)
+  );
+}
+
 function hasPuzzleClearLocalPotentialMove(board: PuzzleClearBoardSnapshot) {
   if (findPuzzleClearLocalEliminations(board).length > 0) {
     return false;
@@ -774,7 +840,7 @@ export function createPuzzleClearLocalRuntimeSnapshot(
     levelIndex: normalizedLevelIndex,
     clearsDone: 0,
     targetClears: levelConfig.targetClears,
-    levelDurationSeconds: PUZZLE_CLEAR_LOCAL_RUNTIME_DURATION_SECONDS,
+    levelDurationSeconds: levelConfig.durationSeconds,
     levelStartedAtMs: Date.now(),
     board,
     readyColumns,
@@ -818,7 +884,7 @@ export function swapPuzzleClearLocalCards(
   markPuzzleClearLocalCompletedGroups(next.board);
   if (
     next.clearsDone >= next.targetClears &&
-    !hasPuzzleClearLocalRemainingCards(next.board)
+    !hasPuzzleClearLocalRemainingCardsInRun(next)
   ) {
     next.status =
       next.levelIndex >= PUZZLE_CLEAR_LOCAL_MAX_LEVEL ? 'finished' : 'level_cleared';