From dcbf02bbda4227045ab08a789146e2294232656b Mon Sep 17 00:00:00 2001
From: kdletters <kdletters@qq.com>
Date: Fri, 5 Jun 2026 22:49:07 +0800
Subject: [PATCH 1/2] =?UTF-8?q?fix:=20=E5=A4=B1=E8=B4=A5=E8=8D=89=E7=A8=BF?=
 =?UTF-8?q?=E9=87=8D=E8=AF=95=E5=A4=8D=E7=94=A8=E5=8E=9F=E4=BC=9A=E8=AF=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .hermes/shared-memory/pitfalls.md             |  10 +-
 ...�玩法创作】平�入�与玩法链路-2026-05-15.md |   2 +-
 .../PlatformEntryFlowShellImpl.tsx            |  42 ++--
 ...gEntryFlowShell.agent.interaction.test.tsx | 216 ++++++++++++++++++
 4 files changed, 255 insertions(+), 15 deletions(-)

diff --git a/.hermes/shared-memory/pitfalls.md b/.hermes/shared-memory/pitfalls.md
index 694eb853..e0a1b1c8 100644
--- a/.hermes/shared-memory/pitfalls.md
+++ b/.hermes/shared-memory/pitfalls.md
@@ -1601,10 +1601,18 @@
 
 - 现象：拼图生�页已�收到 VectorEngine 图片编辑失败并进入�试�，但用户返回�稿 Tab �，�一�稿�显示“生�中�；连续触�多个拼图生�时，失败�还�能�剩一�新增�稿，或者�看到标题为“第1关�的���空壳；抓大鹅��失败时也�能没有任何通知，点击�稿���新开始生�。
 - 原因：�端失败 notice �更新生�页局部状�，pending 作�架�目在失败时被清掉或被� `generating` 状�误映射为 `ready`；�端作�摘�也�能短暂�是 `generationStatus=generating`。如果失败消�没有写入 notice，用户离开生�页��会弹出 `PlatformErrorDialog`；如果打开�稿�看�久化 `generating`，就会绕过失败���。
-- 处�：失败时按 session �留 pending 作�架�目并标记 `failed`，失败 notice �存错误消�并触�带��的 `PlatformErrorDialog`；拼图契约没有 `failed` 枚举，pending 拼图映射为 `idle`，�时用本地失败 notice 覆盖�久化生�中状�和旧的“正在生��摘�。点击失败�稿应优先用 notice / �端 session / fallback payload 组装失败生�页，�能�新从 0 秒�动新进度；拼图失败���没有有效 `workTitle` 时，作�架标题回退为“拼图�稿�。
+- 处�：失败时按 session �留 pending 作�架�目并标记 `failed`，失败 notice �存错误消�并触�带��的 `PlatformErrorDialog`；拼图契约没有 `failed` 枚举，pending 拼图映射为 `idle`，�时用本地失败 notice 覆盖�久化生�中状�和旧的“正在生��摘�。点击失败�稿应优先用 notice / �端 session / fallback payload 组装失败生�页，�能�新从 0 秒�动新进度；失败页点击�新生�必须优先�用当� `sessionId` 执行编译 action，�得因存在表�缓存 payload 就调用 create-session。拼图失败���没有有效 `workTitle` 时，作�架标题回退为“拼图�稿�。
 - 验�：`node node_modules/vitest/vitest.mjs run src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "failed parallel puzzle|background match3d"`。
 - 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/custom-world-home/creationWorkShelf.ts`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
+## 生�失败�试��走新建�稿
+
+- 现象：拼图或抓大鹅生�失败�，在失败页点击“�新生��，作�架里多出一份新的�稿，原失败�稿�留在列表里。
+- 原因：�试 handler 曾优先读�缓存的表� payload 并调用 create-session 路径；失败�稿按 session 留在作�架是正确行为，于是�试动作�外创建了第二份�稿。
+- 处�：��当�失败页还能��到原 `sessionId`，�试就走该 session 的 compile action；�有没有��� session 时，��许用表� payload �新创建�稿。
+- 验�：`npm run test -- src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "failed .* draft retry reuses current session"`。
+- 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
+
 ## 汪汪声浪�稿试玩��写正� run
 
 - 现象：如果�稿结果页试玩和�布� runtime 共用�一写�绩路径，未�布或未确认资�的�稿试玩会污染正��局�排行榜和作�统计。
diff --git a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
index 063f48f8..0258cda0 100644
--- a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
+++ b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
@@ -54,7 +54,7 @@
 4. 生�中作�在整�上加等待�罩，但�移除作�基础信�。
 5. 生�中状��能�存在�端内存 notice。�端作�摘�必须下����的 `generationStatus`；�端刷新或退出产��，作�架优先用摘�状���等待�罩，本轮内存 notice �作为�时�馈。
 6. 点击 `generationStatus=generating` 的�稿�必须��对应玩法的生�进度页，�能进入空白结果页或普通工作区；��生�页的 `startedAtMs` 优先使用�端 session 的 `updatedAt`，没有 session 时�使用作�摘� `updatedAt`，�得因�新进入页�从 0 秒�新计时。
-7. 生�失败必须按 session 独立记录，�能用一个失败打断或覆盖�玩法的其它生�任务。失败 notice 需��存错误消�并覆盖作�架本地状�：�使�端摘�暂时�是 `generationStatus=generating` 或�写出���投影，�稿�也�得继续显示“生�中�，点击�必须进入失败 / �试生�页，�能�新创建一轮生�；拼图这类失败���若没有有效 `workTitle`，作�架标题回退为“拼图�稿�，�暴露“第1关�空壳。
+7. 生�失败必须按 session 独立记录，�能用一个失败打断或覆盖�玩法的其它生�任务。失败 notice 需��存错误消�并覆盖作�架本地状�：�使�端摘�暂时�是 `generationStatus=generating` 或�写出���投影，�稿�也�得继续显示“生�中�，点击�必须进入失败 / �试生�页，�能�新创建一轮生�。失败页点击�新生�时必须优先�用当���� `sessionId` 执行编译 action；�有没有��� session 时��许回退到新建�稿。拼图这类失败���若没有有效 `workTitle`，作�架标题回退为“拼图�稿�，�暴露“第1关�空壳。
 8. 从�稿 Tab 作�架打开�稿工作区�生�页或结果页时，返回按钮必须回到�稿 Tab 的�一作�架语境；从创作 Tab 新建或直接进入创作链路时�回到创作 Tab。平�壳层需�显�记录本次创作�的返回��，�能让结果页返回动作固定跳到创作入�。
 9. �有 generated 图片必须通过 `ResolvedAssetImage` / `/api/assets/read-url` �签读�。
 10. 敲木鱼作�架读�当�用户作�列表时走 `GET /api/creation/wooden-fish/works`；�布�功�平�壳必须�时刷新作�架与公开广场，��作�刚�布时��留在旧列表。
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index b4d77e98..86e77d3c 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -9449,20 +9449,26 @@ export function PlatformEntryFlowShellImpl({
   const executeSquareHoleAction = squareHoleFlow.executeAction;
 
   const retryMatch3DDraftGeneration = useCallback(() => {
-    if (match3dFormDraftPayload && !match3dSession?.draft?.profileId) {
-      void createMatch3DDraftFromForm(match3dFormDraftPayload);
+    if (match3dSession?.sessionId) {
+      const retryPayload =
+        match3dFormDraftPayload ??
+        buildMatch3DFormPayloadFromSession(match3dSession);
+      void executeMatch3DAction({
+        action: 'match3d_compile_draft',
+        generateClickSound: retryPayload.generateClickSound,
+      });
       return;
     }
 
-    void executeMatch3DAction({
-      action: 'match3d_compile_draft',
-      generateClickSound: match3dFormDraftPayload?.generateClickSound,
-    });
+    if (match3dFormDraftPayload) {
+      void createMatch3DDraftFromForm(match3dFormDraftPayload);
+      return;
+    }
   }, [
     createMatch3DDraftFromForm,
     executeMatch3DAction,
     match3dFormDraftPayload,
-    match3dSession?.draft?.profileId,
+    match3dSession,
   ]);
 
   const retrySquareHoleAssetGeneration = useCallback(() => {
@@ -10336,15 +10342,25 @@ export function PlatformEntryFlowShellImpl({
   );
 
   const retryPuzzleDraftGeneration = useCallback(() => {
-    if (puzzleFormDraftPayload) {
-      void createPuzzleDraftFromForm(puzzleFormDraftPayload);
+    if (puzzleSession?.sessionId) {
+      const retryPayload =
+        puzzleFormDraftPayload ??
+        buildPuzzleFormPayloadFromSession(puzzleSession);
+      void executePuzzleAction(
+        buildPuzzleCompileActionFromFormPayload(retryPayload),
+      );
       return;
     }
 
-    void executePuzzleAction(
-      buildPuzzleCompileActionFromFormPayload(puzzleFormDraftPayload),
-    );
-  }, [createPuzzleDraftFromForm, executePuzzleAction, puzzleFormDraftPayload]);
+    if (puzzleFormDraftPayload) {
+      void createPuzzleDraftFromForm(puzzleFormDraftPayload);
+    }
+  }, [
+    createPuzzleDraftFromForm,
+    executePuzzleAction,
+    puzzleFormDraftPayload,
+    puzzleSession,
+  ]);
 
   const retryVisualNovelDraftGeneration = useCallback(() => {
     if (!visualNovelFormDraftPayload) {
diff --git a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
index 64d065a3..d1323f12 100644
--- a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
+++ b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
@@ -4228,6 +4228,115 @@ test('background match3d draft failure notifies and reopens failed retry page',
   expect(match3dCreationClient.executeAction).toHaveBeenCalledTimes(1);
 });
 
+test('failed match3d draft retry reuses current session instead of creating another draft', async () => {
+  const user = userEvent.setup();
+  const failedSession = buildMockMatch3DAgentSession({
+    sessionId: 'match3d-retry-failed-session',
+    draft: null,
+    stage: 'collecting_config',
+    updatedAt: '2026-05-18T12:05:00.000Z',
+  });
+  const persistedFailedWork: Match3DWorkSummary = {
+    workId: 'match3d-retry-failed-work',
+    profileId: 'match3d-retry-failed-profile',
+    ownerUserId: 'user-1',
+    sourceSessionId: failedSession.sessionId,
+    gameName: '�试抓鹅',
+    themeText: '霓虹水果摊',
+    summary: '抓大鹅素�生�失败，��新打开处�。',
+    tags: ['水果', '抓大鹅'],
+    coverImageSrc: null,
+    referenceImageSrc: null,
+    clearCount: 12,
+    difficulty: 4,
+    publicationStatus: 'draft',
+    playCount: 0,
+    updatedAt: '2026-05-18T12:05:00.000Z',
+    publishedAt: null,
+    publishReady: false,
+    generationStatus: 'generating',
+    generatedItemAssets: [],
+  };
+  let rejectCompile!: (reason?: unknown) => void;
+  vi.mocked(match3dCreationClient.createSession).mockResolvedValue({
+    session: failedSession,
+  });
+  vi.mocked(match3dCreationClient.executeAction).mockReturnValueOnce(
+    new Promise((_, reject) => {
+      rejectCompile = reject;
+    }),
+  );
+  vi.mocked(match3dCreationClient.getSession).mockResolvedValue({
+    session: failedSession,
+  });
+
+  render(<TestWrapper withAuth />);
+
+  await openCreateTemplateHub(user);
+  await user.click(await findCreationTypeButton('抓大鹅'));
+  await user.click(
+    await screen.findByRole('button', { name: '生�抓大鹅�稿' }),
+  );
+  await screen.findByRole('progressbar', { name: '抓大鹅�稿生�进度' });
+  await user.click(screen.getByRole('button', { name: '返回创作中心' }));
+  await openDraftHub(user);
+  vi.mocked(listMatch3DWorks).mockResolvedValue({
+    items: [persistedFailedWork],
+  });
+
+  await act(async () => {
+    rejectCompile(new Error('抓大鹅素��务失败'));
+    await Promise.resolve();
+  });
+  const failureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  await user.click(within(failureDialog).getByRole('button', { name: '关闭' }));
+
+  const draftPanel = getPlatformTabPanel('saves');
+  await user.click(
+    await within(draftPanel).findByRole('button', {
+      name: /继续创作《(?:�试抓鹅|抓大鹅�稿)》/u,
+    }),
+  );
+  const reopenedFailureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  await user.click(
+    within(reopenedFailureDialog).getByRole('button', { name: '关闭' }),
+  );
+  vi.mocked(match3dCreationClient.executeAction).mockResolvedValueOnce({
+    session: buildMockMatch3DAgentSession({
+      sessionId: failedSession.sessionId,
+      stage: 'draft_ready',
+      draft: {
+        profileId: persistedFailedWork.profileId,
+        gameName: persistedFailedWork.gameName,
+        themeText: persistedFailedWork.themeText,
+        summary: persistedFailedWork.summary,
+        tags: persistedFailedWork.tags,
+        coverImageSrc: null,
+        referenceImageSrc: null,
+        clearCount: persistedFailedWork.clearCount,
+        difficulty: persistedFailedWork.difficulty,
+        generatedItemAssets: [],
+      },
+    }),
+  });
+
+  await user.click(await screen.findByRole('button', { name: '�新生��稿' }));
+
+  await waitFor(() => {
+    expect(match3dCreationClient.executeAction).toHaveBeenCalledTimes(2);
+  });
+  expect(match3dCreationClient.createSession).toHaveBeenCalledTimes(1);
+  expect(match3dCreationClient.executeAction).toHaveBeenNthCalledWith(
+    2,
+    failedSession.sessionId,
+    expect.objectContaining({ action: 'match3d_compile_draft' }),
+  );
+});
+
 test('running match3d persisted draft reopens progress instead of unfinished result', async () => {
   const user = userEvent.setup();
   const runningSession = buildMockMatch3DAgentSession({
@@ -4921,6 +5030,113 @@ test('failed parallel puzzle generations stay as separate non-generating drafts'
     .toBeTruthy();
 });
 
+test('failed puzzle draft retry reuses current session instead of creating another draft', async () => {
+  const user = userEvent.setup();
+  const failedSession = buildMockPuzzleAgentSession({
+    sessionId: 'puzzle-retry-failed-session',
+    draft: null,
+    stage: 'collecting_anchors',
+    updatedAt: '2026-05-18T12:00:00.000Z',
+  });
+  const persistedFailedWork: PuzzleWorkSummary = {
+    workId: `puzzle-work-${failedSession.sessionId}`,
+    profileId: `puzzle-profile-${failedSession.sessionId}`,
+    ownerUserId: 'user-1',
+    sourceSessionId: failedSession.sessionId,
+    authorDisplayName: '测试玩家',
+    workTitle: '',
+    workDescription: '一套雨夜猫街主题拼图。',
+    levelName: '第1关',
+    summary: '一套雨夜猫街主题拼图。',
+    themeTags: [],
+    coverImageSrc: null,
+    coverAssetId: null,
+    publicationStatus: 'draft',
+    updatedAt: '2026-05-18T12:00:00.000Z',
+    publishedAt: null,
+    playCount: 0,
+    remixCount: 0,
+    likeCount: 0,
+    publishReady: false,
+    generationStatus: 'failed',
+    levels: [],
+  };
+  let rejectCompile!: (reason?: unknown) => void;
+  vi.mocked(createPuzzleAgentSession).mockResolvedValue({
+    session: failedSession,
+  });
+  vi.mocked(getPuzzleAgentSession).mockResolvedValue({
+    session: failedSession,
+  });
+  vi.mocked(executePuzzleAgentAction).mockReturnValueOnce(
+    new Promise((_, reject) => {
+      rejectCompile = reject;
+    }),
+  );
+
+  render(<TestWrapper withAuth />);
+
+  await openCreateTemplateHub(user);
+  await user.click(await findCreationTypeButton('拼图'));
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
+  await screen.findByRole('progressbar', { name: '拼图图片生�进度' });
+  await user.click(screen.getByRole('button', { name: '返回创作中心' }));
+  await openDraftHub(user);
+  vi.mocked(listPuzzleWorks).mockResolvedValue({
+    items: [persistedFailedWork],
+  });
+
+  await act(async () => {
+    rejectCompile(new Error('拼图图片生�失败'));
+    await Promise.resolve();
+  });
+  const failureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  await user.click(within(failureDialog).getByRole('button', { name: '关闭' }));
+
+  const draftPanel = getPlatformTabPanel('saves');
+  await user.click(
+    await within(draftPanel).findByRole('button', {
+      name: /继续创作《[^》]+》/u,
+    }),
+  );
+  const reopenedFailureDialog = await screen.findByRole('dialog', {
+    name: '�生错误',
+  });
+  await user.click(
+    within(reopenedFailureDialog).getByRole('button', { name: '关闭' }),
+  );
+  vi.mocked(executePuzzleAgentAction).mockResolvedValueOnce({
+    operation: {
+      operationId: 'compile-puzzle-retry',
+      type: 'compile_puzzle_draft',
+      status: 'completed',
+      phaseLabel: '已完�',
+      phaseDetail: '�稿已生�',
+      progress: 1,
+    },
+    session: buildMockPuzzleAgentSession({
+      sessionId: failedSession.sessionId,
+      stage: 'ready_to_publish',
+      progressPercent: 100,
+      draft: buildReadyPuzzleDraft(),
+    }),
+  });
+
+  await user.click(await screen.findByRole('button', { name: '�新生�图片' }));
+
+  await waitFor(() => {
+    expect(executePuzzleAgentAction).toHaveBeenCalledTimes(2);
+  });
+  expect(createPuzzleAgentSession).toHaveBeenCalledTimes(1);
+  expect(executePuzzleAgentAction).toHaveBeenNthCalledWith(
+    2,
+    failedSession.sessionId,
+    expect.objectContaining({ action: 'compile_puzzle_draft' }),
+  );
+});
+
 test('running puzzle draft opens generation progress from draft tab', async () => {
   const user = userEvent.setup();
   const runningSession = buildMockPuzzleAgentSession({

From 8e1a62d1305bb2691e69a8c8da859e17b6ef6a1e Mon Sep 17 00:00:00 2001
From: kdletters <61648117+kdletters@users.noreply.github.com>
Date: Fri, 5 Jun 2026 23:21:55 +0800
Subject: [PATCH 2/2] fix: decouple puzzle draft generation lifecycle

---
 ...��维】本地开�验�与生产�维-2026-05-15.md |   2 +
 server-rs/crates/api-server/src/puzzle.rs     |  70 ++++++++-
 .../crates/api-server/src/puzzle/draft.rs     |  11 +-
 .../crates/api-server/src/puzzle/handlers.rs  | 137 +++++++++++++++---
 .../crates/api-server/src/puzzle/tests.rs     |  35 +++++
 .../PlatformEntryFlowShellImpl.tsx            |  63 +++++++-
 .../puzzleDraftGenerationState.test.ts        |  40 +++++
 .../puzzleDraftGenerationState.ts             |  20 +++
 8 files changed, 350 insertions(+), 28 deletions(-)
 create mode 100644 src/components/platform-entry/puzzleDraftGenerationState.test.ts
 create mode 100644 src/components/platform-entry/puzzleDraftGenerationState.ts

diff --git a/docs/�开��维】本地开�验�与生产�维-2026-05-15.md b/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
index e2e05bd8..05ed0fe5 100644
--- a/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
+++ b/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
@@ -71,6 +71,8 @@ spacetime sql <database> "SELECT * FROM puzzle_gallery_card_view LIMIT 1" --serv
 
 VectorEngine 图片生� / 编辑在 `request_send` 阶段出现 `timeout` 或 `connect` 错误时，`platform-image` 会对�一请求最多�� 3 次；multipart 图片编辑�次�试都会�新构造 form，���用已消费的 body。日志中 `VectorEngine 图片请求��失败，准备�试` 表示本次失败已进入下一次�试；最终�失败时�会写入 `external_api_call_failure` 并返回 504。排查生产失败时应�时统计 retry �的�试日志和最终 audit，��把一次用户请求内的多次��误判�多个用户请求。
 
+拼图入�直创的 `compile_puzzle_draft` 是长耗时链路：�端会先快速编译�稿并返回 `image_refining` / `generating` 快照，然�在 api-server ��任务中完�首图�UI 资产�OSS �久化�作�投影�计费退款和失败�回写。生产排查�程� `Failed to fetch` 时，若 Nginx access log 里 action POST 是 `499`�`upstream_status=-`，说明客户端或 WebView 先断开；此时�应�把长 POST 是�返回作为生��败��，而应继续按实际 `session_id` 查��任务日志�VectorEngine provider 日志�`external_api_call_failure` 和�续 GET 轮询结果。�一用户�能先轮询旧的 `puzzle-session-*`，�� POST 新建实际生� session；必须用 action POST 的 `request_id` 和 `/api/runtime/puzzle/agent/sessions/<session_id>/actions` 路径对�真实失败请求，��被�端显示的“���稿�误导。
+
 查看本地 Rust / SpacetimeDB 日志：
 
 ```bash
diff --git a/server-rs/crates/api-server/src/puzzle.rs b/server-rs/crates/api-server/src/puzzle.rs
index b4fe7b41..be4b8cb0 100644
--- a/server-rs/crates/api-server/src/puzzle.rs
+++ b/server-rs/crates/api-server/src/puzzle.rs
@@ -1,5 +1,6 @@
 use std::{
-    collections::BTreeMap,
+    collections::{BTreeMap, HashSet},
+    sync::{Mutex, OnceLock},
     time::{Instant, SystemTime, UNIX_EPOCH},
 };
 
@@ -130,6 +131,73 @@ const PUZZLE_UI_BACKGROUND_PROMPT_FALLBACK_MARKER: &str =
 const PUZZLE_VECTOR_ENGINE_SQUARE_IMAGE_SIZE: &str = "1024x1024";
 const PUZZLE_VECTOR_ENGINE_PORTRAIT_IMAGE_SIZE: &str = "1024x1536";
 
+static PUZZLE_BACKGROUND_COMPILE_TASKS: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
+
+fn puzzle_background_compile_tasks() -> &'static Mutex<HashSet<String>> {
+    PUZZLE_BACKGROUND_COMPILE_TASKS.get_or_init(|| Mutex::new(HashSet::new()))
+}
+
+fn try_register_puzzle_background_compile_task(session_id: &str) -> bool {
+    match puzzle_background_compile_tasks().lock() {
+        Ok(mut tasks) => tasks.insert(session_id.to_string()),
+        Err(error) => {
+            tracing::warn!(
+                provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                session_id,
+                error = %error,
+                "拼图��生�任务注册表�已��，�许本次任务继续"
+            );
+            true
+        }
+    }
+}
+
+fn unregister_puzzle_background_compile_task(session_id: &str) {
+    match puzzle_background_compile_tasks().lock() {
+        Ok(mut tasks) => {
+            tasks.remove(session_id);
+        }
+        Err(error) => {
+            tracing::warn!(
+                provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                session_id,
+                error = %error,
+                "拼图��生�任务注册表解�失败，忽略清�"
+            );
+        }
+    }
+}
+
+fn has_puzzle_cover_image_src(value: &Option<String>) -> bool {
+    value
+        .as_deref()
+        .map(str::trim)
+        .is_some_and(|value| !value.is_empty())
+}
+
+fn mark_puzzle_initial_generation_started_snapshot(
+    mut session: PuzzleAgentSessionRecord,
+) -> PuzzleAgentSessionRecord {
+    session.stage = "image_refining".to_string();
+    session.progress_percent = session.progress_percent.max(88);
+    if let Some(draft) = session.draft.as_mut() {
+        let draft_needs_cover = !has_puzzle_cover_image_src(&draft.cover_image_src);
+        if let Some(primary_level) = draft.levels.first_mut() {
+            if !has_puzzle_cover_image_src(&primary_level.cover_image_src) {
+                primary_level.generation_status = "generating".to_string();
+            }
+            draft.generation_status = primary_level.generation_status.clone();
+            draft.candidates = primary_level.candidates.clone();
+            draft.selected_candidate_id = primary_level.selected_candidate_id.clone();
+            draft.cover_image_src = primary_level.cover_image_src.clone();
+            draft.cover_asset_id = primary_level.cover_asset_id.clone();
+        } else if draft_needs_cover {
+            draft.generation_status = "generating".to_string();
+        }
+    }
+    session
+}
+
 pub(crate) fn format_puzzle_reference_image_upload_bytes(bytes: usize) -> String {
     format!("{:.1}MB", bytes as f64 / 1024.0 / 1024.0)
 }
diff --git a/server-rs/crates/api-server/src/puzzle/draft.rs b/server-rs/crates/api-server/src/puzzle/draft.rs
index 276a29f5..43bc146d 100644
--- a/server-rs/crates/api-server/src/puzzle/draft.rs
+++ b/server-rs/crates/api-server/src/puzzle/draft.rs
@@ -1177,21 +1177,16 @@ pub(crate) fn find_puzzle_level_for_initial_asset_check<'a>(
         .or_else(|| levels.first())
 }
 
-pub(crate) async fn compile_puzzle_draft_with_initial_cover(
+pub(crate) async fn generate_puzzle_initial_cover_from_compiled_session(
     state: &PuzzleApiState,
     request_context: &RequestContext,
-    session_id: String,
+    compiled_session: PuzzleAgentSessionRecord,
     owner_user_id: String,
     prompt_text: Option<&str>,
     reference_image_src: Option<&str>,
     image_model: Option<&str>,
     now: i64,
 ) -> Result<PuzzleAgentSessionRecord, AppError> {
-    let compiled_session = state
-        .spacetime_client()
-        .compile_puzzle_agent_draft(session_id.clone(), owner_user_id.clone(), now)
-        .await
-        .map_err(map_puzzle_compile_error)?;
     let draft = compiled_session.draft.clone().ok_or_else(|| {
         AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
             "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
@@ -1419,7 +1414,7 @@ pub(crate) async fn compile_puzzle_draft_with_initial_cover(
     match state
         .spacetime_client()
         .select_puzzle_cover_image(PuzzleSelectCoverImageRecordInput {
-            session_id,
+            session_id: compiled_session.session_id.clone(),
             owner_user_id,
             level_id: Some(target_level.level_id),
             candidate_id: selected_candidate_id,
diff --git a/server-rs/crates/api-server/src/puzzle/handlers.rs b/server-rs/crates/api-server/src/puzzle/handlers.rs
index afd6f3cf..873495f7 100644
--- a/server-rs/crates/api-server/src/puzzle/handlers.rs
+++ b/server-rs/crates/api-server/src/puzzle/handlers.rs
@@ -623,7 +623,7 @@ pub async fn execute_puzzle_agent_action(
                     session_id,
                     owner_user_id,
                     error_message,
-                    failed_at_micros: now,
+                    failed_at_micros: current_utc_micros(),
                 })
                 .await;
             if let Err(error) = result {
@@ -668,27 +668,128 @@ pub async fn execute_puzzle_agent_action(
                 Err(response) => return Err(response),
             };
             let session = if ai_redraw {
-                execute_billable_asset_operation_with_cost(
-                    state.root_state(),
-                    &owner_user_id,
-                    "puzzle_initial_image",
-                    &billing_asset_id,
-                    PUZZLE_IMAGE_GENERATION_POINTS_COST,
-                    async {
-                        compile_puzzle_draft_with_initial_cover(
-                            &state,
-                            &request_context,
+                if !try_register_puzzle_background_compile_task(&compile_session_id) {
+                    tracing::info!(
+                        provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                        session_id = %compile_session_id,
+                        owner_user_id = %owner_user_id,
+                        "拼图首图��生�任务已存在，本次 action 直接返回生�中会�"
+                    );
+                    state
+                        .spacetime_client()
+                        .get_puzzle_agent_session(
+                            compile_session_id.clone(),
+                            owner_user_id.clone(),
+                        )
+                        .await
+                        .map(mark_puzzle_initial_generation_started_snapshot)
+                        .map_err(map_puzzle_client_error)
+                } else {
+                    let compiled_session = state
+                        .spacetime_client()
+                        .compile_puzzle_agent_draft(
                             compile_session_id.clone(),
                             owner_user_id.clone(),
-                            prompt_text,
-                            primary_reference_image_src,
-                            payload.image_model.as_deref(),
                             now,
                         )
                         .await
-                    },
-                )
-                .await
+                        .map_err(map_puzzle_compile_error);
+                    match compiled_session {
+                        Ok(compiled_session) => {
+                            let response_session =
+                                mark_puzzle_initial_generation_started_snapshot(
+                                    compiled_session.clone(),
+                                );
+                            let background_state = state.clone();
+                            let background_request_context = request_context.clone();
+                            let background_session_id = compile_session_id.clone();
+                            let background_owner_user_id = owner_user_id.clone();
+                            let background_prompt_text = prompt_text.map(str::to_string);
+                            let background_reference_image_src =
+                                primary_reference_image_src.map(str::to_string);
+                            let background_image_model = payload.image_model.clone();
+                            let background_billing_asset_id =
+                                format!("{background_session_id}:compile_puzzle_draft");
+                            tokio::spawn(async move {
+                                let operation_owner_user_id =
+                                    background_owner_user_id.clone();
+                                let background_root_state =
+                                    background_state.root_state().clone();
+                                let operation_state = background_state.clone();
+                                let result = execute_billable_asset_operation_with_cost(
+                                    &background_root_state,
+                                    &background_owner_user_id,
+                                    "puzzle_initial_image",
+                                    &background_billing_asset_id,
+                                    PUZZLE_IMAGE_GENERATION_POINTS_COST,
+                                    async move {
+                                        generate_puzzle_initial_cover_from_compiled_session(
+                                            &operation_state,
+                                            &background_request_context,
+                                            compiled_session,
+                                            operation_owner_user_id,
+                                            background_prompt_text.as_deref(),
+                                            background_reference_image_src.as_deref(),
+                                            background_image_model.as_deref(),
+                                            current_utc_micros(),
+                                        )
+                                        .await
+                                    },
+                                )
+                                .await;
+                                match result {
+                                    Ok(session) => {
+                                        tracing::info!(
+                                            provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                                            session_id = %session.session_id,
+                                            owner_user_id = %background_owner_user_id,
+                                            "拼图首图��生�任务完�"
+                                        );
+                                    }
+                                    Err(error) => {
+                                        let error_message = error.body_text();
+                                        let failure_result = background_state
+                                            .spacetime_client()
+                                            .mark_puzzle_draft_generation_failed(
+                                                PuzzleDraftCompileFailureRecordInput {
+                                                    session_id: background_session_id.clone(),
+                                                    owner_user_id: background_owner_user_id
+                                                        .clone(),
+                                                    error_message: error_message.clone(),
+                                                    failed_at_micros: current_utc_micros(),
+                                                },
+                                            )
+                                            .await;
+                                        if let Err(mark_error) = failure_result {
+                                            tracing::warn!(
+                                                provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                                                session_id = %background_session_id,
+                                                owner_user_id = %background_owner_user_id,
+                                                message = %mark_error,
+                                                "拼图首图��生�失败�回写失败"
+                                            );
+                                        }
+                                        tracing::warn!(
+                                            provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+                                            session_id = %background_session_id,
+                                            owner_user_id = %background_owner_user_id,
+                                            message = %error_message,
+                                            "拼图首图��生�任务失败"
+                                        );
+                                    }
+                                }
+                                unregister_puzzle_background_compile_task(
+                                    &background_session_id,
+                                );
+                            });
+                            Ok(response_session)
+                        }
+                        Err(error) => {
+                            unregister_puzzle_background_compile_task(&compile_session_id);
+                            Err(error)
+                        }
+                    }
+                }
             } else {
                 compile_puzzle_draft_with_uploaded_cover(
                     &state,
@@ -716,7 +817,7 @@ pub async fn execute_puzzle_agent_action(
                 "compile_puzzle_draft",
                 "首关拼图�稿",
                 if ai_redraw {
-                    "已编译首关�稿�并行生�首关画�和 UI 背景并写入正��稿。"
+                    "已编译首关�稿，并�动首关画�和 UI 资产��生�。"
                 } else {
                     "已编译首关�稿，并直接应用上传图片�生� UI 背景为第一关图片。"
                 },
diff --git a/server-rs/crates/api-server/src/puzzle/tests.rs b/server-rs/crates/api-server/src/puzzle/tests.rs
index 86512e7d..b5b902b9 100644
--- a/server-rs/crates/api-server/src/puzzle/tests.rs
+++ b/server-rs/crates/api-server/src/puzzle/tests.rs
@@ -980,6 +980,41 @@ fn puzzle_work_summary_response_keeps_levels_for_shelf_cover() {
     );
 }
 
+#[test]
+fn puzzle_compile_started_snapshot_marks_primary_level_generating() {
+    let mut session = PuzzleAgentSessionRecord {
+        session_id: "puzzle-session-1".to_string(),
+        seed_text: "画��述：一�猫在雨夜�牌下回头。".to_string(),
+        current_turn: 1,
+        progress_percent: 88,
+        stage: "draft_ready".to_string(),
+        anchor_pack: test_puzzle_anchor_pack_record(),
+        draft: Some(test_puzzle_draft_record()),
+        messages: Vec::new(),
+        last_assistant_reply: None,
+        published_profile_id: None,
+        suggested_actions: Vec::new(),
+        result_preview: None,
+        updated_at: "2024-01-01T00:00:00Z".to_string(),
+    };
+    {
+        let draft = session.draft.as_mut().expect("draft");
+        draft.generation_status = "idle".to_string();
+        draft.levels[0].generation_status = "idle".to_string();
+        draft.levels[0].cover_image_src = None;
+        draft.levels[0].cover_asset_id = None;
+    }
+
+    let session = mark_puzzle_initial_generation_started_snapshot(session);
+    let draft = session.draft.expect("draft");
+
+    assert_eq!(session.stage, "image_refining");
+    assert_eq!(draft.generation_status, "generating");
+    assert_eq!(draft.levels[0].generation_status, "generating");
+    assert!(draft.cover_image_src.is_none());
+    assert!(draft.levels[0].cover_image_src.is_none());
+}
+
 #[test]
 fn puzzle_ui_background_prompt_keeps_generated_slots_out_of_background() {
     let prompt = build_puzzle_ui_background_request_prompt_for_test("雨夜猫街", "雨夜猫街主题背景");
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index 86e77d3c..3c789f71 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -67,6 +67,7 @@ import type {
   PuzzleAgentSessionSnapshot,
   SendPuzzleAgentMessageRequest,
 } from '../../../packages/shared/src/contracts/puzzleAgentSession';
+import { isPuzzleCompileActionReady } from './puzzleDraftGenerationState';
 import type { PuzzleCreativeTemplateSelection } from '../../../packages/shared/src/contracts/puzzleCreativeTemplate';
 import type {
   PuzzleRunSnapshot,
@@ -6251,7 +6252,7 @@ export function PlatformEntryFlowShellImpl({
       sessionController.setCreationTypeError(errorMessage);
       setPuzzleCreationError(errorMessage);
     },
-    onActionComplete: async ({ payload, response, setSession }) => {
+    onActionComplete: async ({ payload, response, session, setSession }) => {
       setPuzzleOperation(response.operation);
       setSession(response.session);
       const formPayload = buildPuzzleFormPayloadFromAction(payload);
@@ -6275,6 +6276,47 @@ export function PlatformEntryFlowShellImpl({
 
       if (payload.action === 'compile_puzzle_draft') {
         const openResult = selectionStageRef.current === 'puzzle-generating';
+        if (!isPuzzleCompileActionReady(response.session)) {
+          const nextPayload =
+            formPayload ?? buildPuzzleFormPayloadFromSession(response.session);
+          const fallbackGenerationState = createPuzzleDraftGenerationStateFromPayload(
+            nextPayload,
+            response.session,
+          );
+          const nextGenerationState = mergePuzzleSessionProgressIntoGenerationState(
+            puzzleGenerationState ?? fallbackGenerationState,
+            response.session,
+          );
+          activePuzzleGenerationSessionIdRef.current = response.session.sessionId;
+          setSelectionStage('puzzle-generating');
+          markDraftGenerating('puzzle', [
+            response.session.sessionId,
+            buildPuzzleResultWorkId(response.session.sessionId),
+            response.session.publishedProfileId,
+            buildPuzzleResultProfileId(response.session.sessionId),
+          ]);
+          markPendingDraftGenerating(
+            'puzzle',
+            response.session.sessionId,
+            buildPendingPuzzleDraftMetadata(nextPayload),
+          );
+          setPuzzleGenerationState(nextGenerationState);
+          setPuzzleBackgroundCompileTasks((current) => {
+            const next = { ...current };
+            if (session.sessionId !== response.session.sessionId) {
+              delete next[session.sessionId];
+            }
+            next[response.session.sessionId] = {
+              session: response.session,
+              payload: nextPayload,
+              generationState: nextGenerationState,
+              error: null,
+            };
+            return next;
+          });
+          void refreshPuzzleShelf();
+          return { openResult: false };
+        }
         setPuzzleGenerationState((current) =>
           current
             ? resolveFinishedMiniGameDraftGenerationState(current, 'ready', {
@@ -7169,6 +7211,22 @@ export function PlatformEntryFlowShellImpl({
           return;
         }
 
+        if (hasRecoverableGeneratedPuzzleDraft(latestSession)) {
+          const payload =
+            puzzleGenerationViewPayload ??
+            buildPuzzleFormPayloadFromSession(latestSession);
+          const generationState =
+            puzzleGenerationViewState ??
+            createPuzzleDraftGenerationStateFromPayload(payload, latestSession);
+          await recoverCompletedPuzzleDraftGeneration({
+            sessionId: latestSession.sessionId,
+            payload,
+            generationState,
+            setSession: setPuzzleSession,
+          });
+          return;
+        }
+
         setPuzzleSession(latestSession);
         setPuzzleBackgroundCompileTasks((current) => {
           const task = current[activePuzzleGenerationSessionId];
@@ -7212,6 +7270,9 @@ export function PlatformEntryFlowShellImpl({
     };
   }, [
     activePuzzleGenerationSessionId,
+    puzzleGenerationViewPayload,
+    puzzleGenerationViewState,
+    recoverCompletedPuzzleDraftGeneration,
     shouldPollPuzzleGenerationSession,
     setPuzzleSession,
   ]);
diff --git a/src/components/platform-entry/puzzleDraftGenerationState.test.ts b/src/components/platform-entry/puzzleDraftGenerationState.test.ts
new file mode 100644
index 00000000..dd4a955c
--- /dev/null
+++ b/src/components/platform-entry/puzzleDraftGenerationState.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+
+import { isPuzzleCompileActionReady } from './puzzleDraftGenerationState';
+import type { PuzzleAgentSessionSnapshot } from '../../../packages/shared/src/contracts/puzzleAgentSession';
+
+describe('isPuzzleCompileActionReady', () => {
+  it('keeps compile action generating until the draft has a cover image', () => {
+    const session = {
+      sessionId: 'puzzle-session-1',
+      draft: {
+        coverImageSrc: null,
+        levels: [
+          {
+            generationStatus: 'generating',
+            coverImageSrc: null,
+          },
+        ],
+      },
+    } as PuzzleAgentSessionSnapshot;
+
+    expect(isPuzzleCompileActionReady(session)).toBe(false);
+  });
+
+  it('treats compile action as ready after the selected cover exists', () => {
+    const session = {
+      sessionId: 'puzzle-session-1',
+      draft: {
+        coverImageSrc: '/generated-puzzle-assets/session/cover.png',
+        levels: [
+          {
+            generationStatus: 'ready',
+            coverImageSrc: '/generated-puzzle-assets/session/cover.png',
+          },
+        ],
+      },
+    } as PuzzleAgentSessionSnapshot;
+
+    expect(isPuzzleCompileActionReady(session)).toBe(true);
+  });
+});
diff --git a/src/components/platform-entry/puzzleDraftGenerationState.ts b/src/components/platform-entry/puzzleDraftGenerationState.ts
new file mode 100644
index 00000000..f00ee282
--- /dev/null
+++ b/src/components/platform-entry/puzzleDraftGenerationState.ts
@@ -0,0 +1,20 @@
+import type { PuzzleAgentSessionSnapshot } from '../../../packages/shared/src/contracts/puzzleAgentSession';
+
+function hasText(value: string | null | undefined) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+export function isPuzzleCompileActionReady(
+  session: PuzzleAgentSessionSnapshot,
+) {
+  const draft = session.draft;
+  if (!draft) {
+    return false;
+  }
+  if (hasText(draft.coverImageSrc)) {
+    return true;
+  }
+  return (
+    draft.levels?.some((level) => hasText(level.coverImageSrc)) === true
+  );
+}