fix: decouple puzzle draft generation lifecycle

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,
   ]);

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);
+  });
+});

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
+  );
+}