From eb6ab404e2b805276705fe9b8c0688de6d723c60 Mon Sep 17 00:00:00 2001
From: kdletters <kdletters@qq.com>
Date: Mon, 25 May 2026 22:52:38 +0800
Subject: [PATCH] fix: restore puzzle runtime url state

---
 .hermes/shared-memory/pitfalls.md             |  24 +
 ...�玩法创作】平�入�与玩法链路-2026-05-15.md |   3 +
 .../PlatformEntryFlowShellImpl.tsx            | 822 +++++++++++++++++-
 ...atformCreationAgentFlowController.test.tsx | 200 +++++
 .../usePlatformCreationAgentFlowController.ts |  29 +-
 ...gEntryFlowShell.agent.interaction.test.tsx | 371 ++++----
 src/routing/appPageRoutes.test.ts             |  42 +
 src/routing/appPageRoutes.ts                  |  29 +-
 src/services/creationUrlState.test.ts         |  85 ++
 src/services/creationUrlState.ts              | 220 +++++
 src/services/puzzleRuntimeUrlState.test.ts    | 114 +++
 src/services/puzzleRuntimeUrlState.ts         | 155 ++++
 12 files changed, 1917 insertions(+), 177 deletions(-)
 create mode 100644 src/services/creationUrlState.test.ts
 create mode 100644 src/services/creationUrlState.ts
 create mode 100644 src/services/puzzleRuntimeUrlState.test.ts
 create mode 100644 src/services/puzzleRuntimeUrlState.ts

diff --git a/.hermes/shared-memory/pitfalls.md b/.hermes/shared-memory/pitfalls.md
index 682af630..5dc32812 100644
--- a/.hermes/shared-memory/pitfalls.md
+++ b/.hermes/shared-memory/pitfalls.md
@@ -23,6 +23,30 @@
 - 验�：点拼图 / 抓大鹅 / 汪汪声浪�片�，应看到�自既有工作�内容，例如测试中的 `拼图工作区：missing-session`�`抓大鹅工作区：missing-session` 或 `汪汪声浪�置表�`，并且��出现“X 创作入��空白页。
 - 关�：`src/components/platform-entry/platformEntryTypes.ts`�`src/routing/appPageRoutes.ts`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx`。
 
+## 创作�程刷新��必须写�有 query
+
+- 现象：创作生�页或结果页刷新�回到空白工作区�平�首页，或者从作�详情返回时错误�用了别的玩法�稿。
+- 原因：部分创作�程�把 `sessionId` / `profileId` / `draftId` / `workId` 放在�端内存里，没有写进 URL；也曾把写 URL 放在 stage 切��，`writeCreationUrlState` 因为还�在�创作路径而直接跳过。若跨玩法或公开详情继续�留�有 query，还会污染 `/works/detail?work=...`。
+- 处�：创作页�使用�有 query `sessionId`�`profileId`�`draftId`�`workId` �刷新��，��用公开 `work` �数；`pushAppHistoryPath` �在�一创作�内�留这些 query，离开创作�或切到�一个玩法必须清掉；手动 draft 打开�生�完�和�存回调�在路由已�切到 `/creation/<play>` ��调用 `writeCreationUrlState`。
+- 验�：`npm run test -- src/services/creationUrlState.test.ts src/routing/appPageRoutes.test.ts src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx`；手测生�页 / 结果页刷新����一�稿，打开公开作�详情 URL �带�有���数。
+- 关�：`src/services/creationUrlState.ts`�`src/routing/appPageRoutes.ts`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
+
+## 拼图生�页轮询��绑展示 phase 或�稳定 setter
+
+- 现象：拼图创作进入生�中页�，`/api/runtime/puzzle/agent/sessions/{sessionId}` 会在 0.3 到 0.5 秒内被�� GET，看起��轮询风暴，而�是 3 秒一次的正常刷新。
+- 原因：轮询 `useEffect` �时�赖了拼图展示 phase 和会�父组件渲染�化的 `setSession` 函数，导致 `puzzleGenerationState` 的进度�并或页��渲染就会�挂 effect；effect 里�会立�先请求一次 session，于是请求被放大�密集循环。
+- 处�：拼图轮询�绑定 `selectionStage`�`activePuzzleGenerationSessionId` 和“是��在生�中�这个布尔�件；`setSession` 通过 ref ��稳定，�让父组件�新渲染改�轮询器身份。进度 phase �化�更新展示，��建轮询。
+- 验�：`npm run test -- src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "persisted generating puzzle draft"`，并确认��生�中�稿� `getPuzzleAgentSession` �会因为进度刷新继续连�。
+- 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/platform-entry/usePlatformCreationAgentFlowController.ts`�`src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx`。
+
+## 拼图试玩�� query 必须先切到�行�路径�写
+
+- 现象：拼图试玩或正��行�打开�，刷新会�在“正在进入拼图关��，或地���有 `runtimeProfileId`，缺少�稿 `runtimeSessionId`。
+- 原因：`writePuzzleRuntimeUrlState` �会在当�路径已�是 `/runtime/puzzle` 时写入；如果先触�阶段切��写 query，或者�稿作�摘�缺少 `sourceSessionId`，就会把���数写丢。`App.tsx` 的 stage �步也会改 pathname，所以顺��对时容易�留下部分 query。
+- 处�：进入拼图 runtime 时先 `pushAppHistoryPath('/runtime/puzzle')`，� `setSelectionStage('puzzle-runtime')`，最�写 `runtimeProfileId`�`runtimeSessionId`�`runtimeLevelId`�`work`�`mode`；�稿 runtime URL state �许从 `profileId` �推 `puzzle-session-*`，作为 `sourceSessionId` 的兜底。
+- 验�：`npm test -- src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t \"puzzle draft generation auto starts trial and runtime back opens draft result\"`，确认 `window.location.pathname === '/runtime/puzzle'` 且 `window.location.search` �时包� `runtimeProfileId` 和 `runtimeSessionId`。
+- 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/services/puzzleRuntimeUrlState.ts`�`src/routing/appPageRoutes.ts`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
+
 ## �稿页未读点��继续用红色 literal
 
 - 现象：�稿页底部 Tab 和作�架的未读点视觉上��红点，或 glow �带红色阴影，和平�暖棕体系�一致。
diff --git a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
index a538870c..f534dd58 100644
--- a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
+++ b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
@@ -8,6 +8,8 @@
 
 当�创作 Tab �承载赛事 banner�玩法模�分类和两列模��；点击模���直接进入对应玩法已有的入�创作表� stage，���过空白��页，也�把旧表�嵌进创作 Tab 首�。移动端创作 Tab 顶�在 `陶泥儿` �牌�一行显示真实账户泥点数，数��自 `profileDashboard.walletBalance`，�得�把活动奖池当作账�余�展示。首� banner 结构按�考图拆�横��滑动赛事��主体宣传图文区�奖池胶囊�开始 / 结�时间�和�片内分页点；轮播��留 `拼图主题创作赛` 和 `抓大鹅主题创作赛`，两个主题赛事奖池�为 `1000` 泥点数。玩法列表��套外部边框�片，移动端需�压缩横�边�和两列间�；玩法�统一按“上图�左上状�标签（仅�开放�显示）����下 `10-20泥点数`�下方白底标题/�述�结构展示，�片高度��紧凑但标题��述和预估消耗点数都必须��。创作 Tab 根容器��使用 `platform-page-stage` 这类全局内容�片壳，但继续�留 `platform-remap-surface` 作为主题和输入框样�命中钩�。创作首�字�需�对�平�普通 UI 档�：顶�泥点组件�banner 正文�分类 Tab 和玩法�标题 / 副标题 / 消耗说明优先使用 `11px` 到 `14px`，�使用 `text-lg`�`text-xl` 或更大的展示级字�。�稿 Tab 继续承接作�架。RPG�RPG 之外的�玩法入�分别�到既有的 `agent-workspace`�`big-fish-agent-workspace`�`match3d-agent-workspace`�`square-hole-agent-workspace`�`jump-hop-workspace`�`wooden-fish-workspace`�`puzzle-agent-workspace`�`bark-battle-workspace`�`visual-novel-agent-workspace`�`baby-object-match-workspace`，这些入�继续承接�玩法自己的表���稿��和�续编排，�作为创作 Tab 首�内容。
 
+创作���数��留 `sessionId`�`profileId`�`draftId`�`workId` 这四个�有 query。它们��许在�一�创作链路的结果页�生�页�工作�之间�留；切到首页�公开作�详情�runtime 或�一�玩法链路时必须清掉。生�页��时�认当�进入页的时间作为新的 `startedAtMs`，作�摘�里的 `updatedAt` �用于排�与摘�展示，��作为生�进度起点。
+
 `PlatformEntryFlowShellImpl.tsx` �是平�入�编排壳，�续维护时应优先把独立 UI 片段�公开作�映射��稿生� notice 和�行�状� helper 拆到 `src/components/platform-entry/PlatformEntryFlowShellImpl/` 或�目录紧邻 helper 文件。拆分��许改�文件组织，�改�入��置事实��默认导出�props�页�阶段�UI 文案或现有交互；其中拼图首访 onboarding 已拆为 `PlatformEntryFlowShellImpl/PuzzleOnboardingView.tsx`。
 
 移动端底部一级导航是全局平�样�，�按�一玩法分�。当�视觉统一为米白浮动胶囊底座�浅棕分隔线�棕色线性图标�橘色选中�和底部短下划线；中间 `创作` 入���凸起圆形主按钮，但凸起�移�能作用在按钮内容层，�能移动承载分隔线的 Tab 按钮容器，确�创作左�分隔线与其他分隔线垂直�置一致。Tab �称和��性�由现有 `PlatformHomeTab` / 登录�规则决定，样�调整�得改写 Tab 文案或导航状�。
@@ -90,6 +92,7 @@ RPG / 拼图等�行�存档选择入�统一在个人中心 `次级入� >
 - 结果页�许多关�并行编辑和生�；�一关�图片生�完�回包��默更新该关�素�与生��，�得自动打开或切�关�详情��，��打断用户正在编辑的其它关�。
 - 结果页关�图片生��标记对应关�的局部生�进度，��用“新增关���其它关�详情编辑和结果页导航。
 - 结果页�关测试�能把完整�稿�久化，并通过 `levelId` 指定�行�起始关�；�得把�关快照作为整份�稿调用 `updatePuzzleWork`，�则 source session 和作� profile 的 `levels` 会被覆盖��关，退出�进�其它关�会丢失。
+- 拼图试玩和正��行�刷新����用创作�有 query。进入 `/runtime/puzzle` 时必须写入 `runtimeProfileId`��稿 `runtimeSessionId`��选 `runtimeLevelId`�公开作� `work` 和 `mode=draft|published`；进入�行�的导航顺�必须先切到 `/runtime/puzzle`，�写这些 runtime query，��被阶段导航清掉�刷新�在“正在进入拼图关��。
 - 结果页生�关�图时若关��为空，�端必须传 `shouldAutoNameLevel=true`，�端�用首关命�契约先按画��述生�关��，�在图片生��用视觉命�结果精修，并把生��和 UI 背景�示��本次关�快照写回。
 - 拼图�行�背景优先读�当�关� `levelBackgroundImageSrc/levelBackgroundImageObjectKey`，旧数��兼容 `uiBackgroundImageSrc/uiBackgroundImageObjectKey`；本地试玩�直达指定关�和正� `next-level` 推进时，目标关�缺关�背景时必须继承�作�首个�用关�背景，�缺失时�沿用当��行�快照背景或默认 UI。�行�按钮视觉优先读�当�关� `uiSpritesheetImageSrc/uiSpritesheetImageObjectKey`，先按�明 alpha 自动边界检测识别 spritesheet 中的独立按钮展示矩形，�按原图�置从左到��从上到下映射到返回�设置�下一关��示�原图�冻结；�一组件还�按较高 alpha 阈值派生紧致点击热区，�明留白和柔边低 alpha 区域尽���应点击。检测失败时回退旧固定六格�切，缺失时�用现有图标按钮兜底。有 spritesheet 时，返回和设置按钮的点击容器��供�明点击区，���加默认白色圆形底；底部�示�原图�冻结三枚素�按检测矩形的原始宽高比显示，�能强行拉伸�正圆或铺满整列。底部�具区��使用连片胶囊背景，�示�原图�冻结三个按钮�匀分布；�行��展示按钮素�本身，��外�加“�示 / 原图 / 冻结�文字。
 - 拼图�行�棋盘��加分�蒙版��边�阴影�选中底色或�并� SVG 轮廓；拼图片本体需��切为圆角形状，��使用独立圆角�切，�并�使用 SVG 原生 `clipPath` �切整体外轮廓，外凸角和内凹角分别计算�径，内凹角�径�比外凸角更明显以��手机 WebView 中看起��是直角。原图�具�在用户主动确认�打开独立原图查看层，�在当�拼图棋盘上�加原图。
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index 0ccbafd7..773e7cde 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -158,6 +158,19 @@ import {
   streamCreativeAgentMessage,
   streamCreativeDraftEdit,
 } from '../../services/creative-agent';
+import {
+  clearCreationUrlState,
+  type CreationUrlState,
+  isCreationRestorePath,
+  readCreationUrlState,
+  writeCreationUrlState,
+} from '../../services/creationUrlState';
+import {
+  clearPuzzleRuntimeUrlState,
+  readPuzzleRuntimeUrlState,
+  writePuzzleRuntimeUrlState,
+  type PuzzleRuntimeUrlState,
+} from '../../services/puzzleRuntimeUrlState';
 import {
   readCustomWorldAgentUiState,
   shouldRestoreCustomWorldAgentUiState,
@@ -401,7 +414,10 @@ import {
   buildCreationHubFallbackItems,
   resolveRpgCreationErrorMessage,
 } from './platformEntryShared';
-import type { PlatformEntryFlowShellProps } from './platformEntryTypes';
+import type {
+  PlatformEntryFlowShellProps,
+  SelectionStage,
+} from './platformEntryTypes';
 import { PlatformEntryWorldDetailView } from './PlatformEntryWorldDetailView';
 import { PlatformFeedbackView } from './PlatformFeedbackView';
 import { PlatformWorkDetailView } from './PlatformWorkDetailView';
@@ -1700,6 +1716,237 @@ function buildPuzzleResultWorkId(sessionId: string | null | undefined) {
   return `puzzle-work-${stableSuffix}`;
 }
 
+function buildPuzzleSessionIdFromProfileId(
+  profileId: string | null | undefined,
+) {
+  const normalizedProfileId = profileId?.trim();
+  if (!normalizedProfileId?.startsWith('puzzle-profile-')) {
+    return null;
+  }
+
+  const stableSuffix = normalizedProfileId.slice('puzzle-profile-'.length);
+  return stableSuffix ? `puzzle-session-${stableSuffix}` : null;
+}
+
+function normalizeCreationUrlValue(value: string | null | undefined) {
+  return value?.trim() || null;
+}
+
+function hasCreationUrlStateValue(state: CreationUrlState) {
+  return Boolean(
+    normalizeCreationUrlValue(state.sessionId) ||
+      normalizeCreationUrlValue(state.profileId) ||
+      normalizeCreationUrlValue(state.draftId) ||
+      normalizeCreationUrlValue(state.workId),
+  );
+}
+
+function hasPuzzleRuntimeUrlStateValue(state: PuzzleRuntimeUrlState) {
+  return Boolean(
+    normalizeCreationUrlValue(state.runtimeSessionId) ||
+      normalizeCreationUrlValue(state.runtimeProfileId) ||
+      normalizeCreationUrlValue(state.runtimeLevelId) ||
+      normalizeCreationUrlValue(state.publicWorkCode) ||
+      normalizeCreationUrlValue(state.mode),
+  );
+}
+
+function buildPuzzleRuntimeUrlStateKey(state: PuzzleRuntimeUrlState) {
+  return [
+    normalizeCreationUrlValue(state.mode),
+    normalizeCreationUrlValue(state.runtimeSessionId),
+    normalizeCreationUrlValue(state.runtimeProfileId),
+    normalizeCreationUrlValue(state.runtimeLevelId),
+    normalizeCreationUrlValue(state.publicWorkCode),
+  ].join('|');
+}
+
+function buildBigFishCreationUrlState(
+  session: BigFishSessionSnapshotResponse | null,
+): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(session?.sessionId);
+  return {
+    sessionId,
+    workId: sessionId ? `big-fish-work-${sessionId}` : null,
+  };
+}
+
+function buildMatch3DCreationUrlState(
+  session: Match3DAgentSessionSnapshot | null,
+): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(session?.sessionId);
+  const profileId = normalizeCreationUrlValue(
+    session?.draft?.profileId ?? session?.publishedProfileId,
+  );
+  return {
+    sessionId,
+    profileId,
+    workId: profileId,
+  };
+}
+
+function buildSquareHoleCreationUrlState(
+  session: SquareHoleSessionSnapshot | null,
+): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(session?.sessionId);
+  const profileId = normalizeCreationUrlValue(
+    session?.draft?.profileId ?? session?.publishedProfileId,
+  );
+  return {
+    sessionId,
+    profileId,
+    workId: profileId,
+  };
+}
+
+function buildPuzzleCreationUrlState(
+  session: PuzzleAgentSessionSnapshot | null,
+): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(session?.sessionId);
+  const profileId = normalizeCreationUrlValue(
+    session?.publishedProfileId ?? buildPuzzleResultProfileId(sessionId),
+  );
+  return {
+    sessionId,
+    profileId,
+    workId: sessionId ? buildPuzzleResultWorkId(sessionId) : null,
+  };
+}
+
+function buildPuzzleDraftRuntimeUrlState(
+  item: PuzzleWorkSummary,
+  levelId?: string | null,
+): PuzzleRuntimeUrlState {
+  const runtimeSessionId =
+    normalizeCreationUrlValue(item.sourceSessionId) ??
+    buildPuzzleSessionIdFromProfileId(item.profileId);
+
+  return {
+    mode: 'draft',
+    runtimeSessionId,
+    runtimeProfileId: normalizeCreationUrlValue(item.profileId),
+    runtimeLevelId: normalizeCreationUrlValue(levelId),
+  };
+}
+
+function buildPuzzlePublishedRuntimeUrlState(
+  item: PuzzleWorkSummary,
+  levelId?: string | null,
+): PuzzleRuntimeUrlState {
+  return {
+    mode: 'published',
+    runtimeProfileId: normalizeCreationUrlValue(item.profileId),
+    runtimeLevelId: normalizeCreationUrlValue(levelId),
+    publicWorkCode: buildPuzzlePublicWorkCode(item.profileId),
+  };
+}
+
+function openPuzzleRuntimeStage(
+  setSelectionStage: (stage: SelectionStage) => void,
+  state: PuzzleRuntimeUrlState,
+) {
+  pushAppHistoryPath('/runtime/puzzle');
+  setSelectionStage('puzzle-runtime');
+  writePuzzleRuntimeUrlState(state);
+}
+
+function buildPuzzleRuntimeWorkFromSession(
+  session: PuzzleAgentSessionSnapshot,
+  owner: { userId?: string | null; displayName?: string | null },
+): PuzzleWorkSummary | null {
+  const draft = session.draft;
+  const profileId =
+    session.publishedProfileId ?? buildPuzzleResultProfileId(session.sessionId);
+  if (!draft || !profileId || !draft.coverImageSrc?.trim()) {
+    return null;
+  }
+
+  return {
+    workId: buildPuzzleResultWorkId(session.sessionId) ?? profileId,
+    profileId,
+    ownerUserId: owner.userId ?? 'current-user',
+    sourceSessionId: session.sessionId,
+    authorDisplayName: owner.displayName ?? '玩家',
+    workTitle: draft.workTitle,
+    workDescription: draft.workDescription,
+    levelName: draft.levelName,
+    summary: draft.summary,
+    themeTags: draft.themeTags,
+    coverImageSrc: draft.coverImageSrc,
+    coverAssetId: draft.coverAssetId,
+    publicationStatus: 'draft',
+    updatedAt: session.updatedAt,
+    publishedAt: null,
+    playCount: 0,
+    remixCount: 0,
+    likeCount: 0,
+    publishReady: Boolean(session.resultPreview?.publishReady),
+    levels: draft.levels,
+  };
+}
+
+function buildVisualNovelCreationUrlState(
+  session: VisualNovelAgentSessionSnapshot | null,
+): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(session?.sessionId);
+  const profileId = normalizeCreationUrlValue(session?.draft?.profileId);
+  return {
+    sessionId,
+    profileId,
+    workId: profileId ?? sessionId,
+  };
+}
+
+function buildJumpHopCreationUrlState(params: {
+  session?: JumpHopSessionSnapshotResponse | null;
+  work?: JumpHopWorkProfileResponse | null;
+}): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(params.session?.sessionId);
+  const profileId = normalizeCreationUrlValue(
+    params.work?.summary.profileId ?? params.session?.draft?.profileId,
+  );
+  return {
+    sessionId,
+    profileId,
+    workId: normalizeCreationUrlValue(params.work?.summary.workId ?? profileId),
+  };
+}
+
+function buildWoodenFishCreationUrlState(params: {
+  session?: WoodenFishSessionSnapshotResponse | null;
+  work?: WoodenFishWorkProfileResponse | null;
+}): CreationUrlState {
+  const sessionId = normalizeCreationUrlValue(params.session?.sessionId);
+  const profileId = normalizeCreationUrlValue(
+    params.work?.summary.profileId ?? params.session?.draft?.profileId,
+  );
+  return {
+    sessionId,
+    profileId,
+    workId: normalizeCreationUrlValue(params.work?.summary.workId ?? profileId),
+  };
+}
+
+function buildBarkBattleCreationUrlState(
+  draft: BarkBattleDraftConfig | null,
+): CreationUrlState {
+  return {
+    draftId: normalizeCreationUrlValue(draft?.draftId),
+    workId: normalizeCreationUrlValue(draft?.workId ?? draft?.draftId),
+  };
+}
+
+function buildBabyObjectMatchCreationUrlState(
+  draft: BabyObjectMatchDraft | null,
+): CreationUrlState {
+  const profileId = normalizeCreationUrlValue(draft?.profileId);
+  return {
+    profileId,
+    draftId: normalizeCreationUrlValue(draft?.draftId),
+    workId: profileId,
+  };
+}
+
 function buildDraftNoticeKey(kind: CreationWorkShelfKind, id: string) {
   return `${kind}:${id}`;
 }
@@ -2976,6 +3223,12 @@ export function PlatformEntryFlowShellImpl({
     useState<DraftGenerationNoticeMap>({});
   const [pendingDraftShelfItems, setPendingDraftShelfItems] =
     useState<PendingDraftShelfMap>({});
+  const [initialCreationUrlState] = useState(() => readCreationUrlState());
+  const handledInitialCreationUrlStateRef = useRef(false);
+  const [initialPuzzleRuntimeUrlState] = useState(() =>
+    readPuzzleRuntimeUrlState(),
+  );
+  const handledPuzzleRuntimeUrlStateKeyRef = useRef<string | null>(null);
 
   useEffect(() => {
     selectionStageRef.current = selectionStage;
@@ -4176,6 +4429,7 @@ export function PlatformEntryFlowShellImpl({
       setPuzzleOnboardingPhase('input');
       platformBootstrap.setPlatformTab('home');
       setSelectionStage('platform');
+      clearPuzzleRuntimeUrlState();
       void refreshPuzzleShelf();
     } catch (error) {
       setPuzzleOnboardingError(
@@ -4213,6 +4467,7 @@ export function PlatformEntryFlowShellImpl({
     setSelectedPuzzleDetail(null);
     platformBootstrap.setPlatformTab(authUi?.user ? 'home' : 'category');
     setSelectionStage('platform');
+    clearPuzzleRuntimeUrlState();
   }, [authUi?.user, platformBootstrap, setSelectionStage]);
 
   useEffect(() => {
@@ -4265,7 +4520,10 @@ export function PlatformEntryFlowShellImpl({
         setPuzzleRun(startLocalPuzzleRun(item));
         setPuzzleRuntimeAuthMode('default');
         setPuzzleRuntimeReturnStage('platform');
-        setSelectionStage('puzzle-runtime');
+        openPuzzleRuntimeStage(
+          setSelectionStage,
+          buildPuzzleDraftRuntimeUrlState(item, null),
+        );
       }, PUZZLE_ONBOARDING_GENERATED_DELAY_MS);
     } catch (error) {
       setPuzzleOnboardingPhase('input');
@@ -4365,6 +4623,9 @@ export function PlatformEntryFlowShellImpl({
     onSessionOpened: () => {
       setShowCreationTypeModal(false);
     },
+    onSessionChanged: (session) => {
+      writeCreationUrlState(buildBigFishCreationUrlState(session));
+    },
     onActionComplete: ({ payload, response, setSession }) => {
       setSession(response.session);
       if (payload.action === 'big_fish_publish_game') {
@@ -4465,6 +4726,9 @@ export function PlatformEntryFlowShellImpl({
     onSessionOpened: () => {
       setShowCreationTypeModal(false);
     },
+    onSessionChanged: (session) => {
+      writeCreationUrlState(buildMatch3DCreationUrlState(session));
+    },
     onActionComplete: async ({ payload, response, setSession }) => {
       setSession(response.session);
       if (payload.action !== 'match3d_compile_draft') {
@@ -4611,6 +4875,9 @@ export function PlatformEntryFlowShellImpl({
     onSessionOpened: () => {
       setShowCreationTypeModal(false);
     },
+    onSessionChanged: (session) => {
+      writeCreationUrlState(buildSquareHoleCreationUrlState(session));
+    },
     beforeExecuteAction: ({ payload, session }) => {
       if (payload.action === 'square_hole_compile_draft') {
         markDraftGenerating('square-hole', [
@@ -4865,6 +5132,9 @@ export function PlatformEntryFlowShellImpl({
       setPuzzleCreationError(null);
       setShowCreationTypeModal(false);
     },
+    onSessionChanged: (session) => {
+      writeCreationUrlState(buildPuzzleCreationUrlState(session));
+    },
     onOpenError: ({ errorMessage }) => {
       sessionController.setCreationTypeError(errorMessage);
       setPuzzleCreationError(errorMessage);
@@ -4942,7 +5212,10 @@ export function PlatformEntryFlowShellImpl({
             setPuzzleRun(run);
             setPuzzleRuntimeAuthMode('default');
             setPuzzleRuntimeReturnStage('puzzle-result');
-            setSelectionStage('puzzle-runtime');
+            openPuzzleRuntimeStage(
+              setSelectionStage,
+              buildPuzzleDraftRuntimeUrlState(item, null),
+            );
           } catch (error) {
             setPuzzleError(
               resolvePuzzleErrorMessage(error, '�动拼图试玩失败。'),
@@ -5093,6 +5366,9 @@ export function PlatformEntryFlowShellImpl({
     onSessionOpened: () => {
       setShowCreationTypeModal(false);
     },
+    onSessionChanged: (session) => {
+      writeCreationUrlState(buildVisualNovelCreationUrlState(session));
+    },
     onActionComplete: ({ response, setSession }) => {
       setSession(response.session);
       const openResult =
@@ -5287,7 +5563,10 @@ export function PlatformEntryFlowShellImpl({
         setPuzzleRun(run);
         setPuzzleRuntimeAuthMode('default');
         setPuzzleRuntimeReturnStage('puzzle-result');
-        setSelectionStage('puzzle-runtime');
+        openPuzzleRuntimeStage(
+          setSelectionStage,
+          buildPuzzleDraftRuntimeUrlState(item, null),
+        );
       } catch (error) {
         puzzleErrorSetterRef.current(
           resolvePuzzleErrorMessage(error, '�动拼图试玩失败。'),
@@ -5352,7 +5631,6 @@ export function PlatformEntryFlowShellImpl({
     isMiniGameDraftGenerating(
       activePuzzleBackgroundCompileTask?.generationState ?? null,
     );
-  const puzzleGenerationViewPhase = puzzleGenerationViewState?.phase ?? null;
   const shouldPollPuzzleGenerationSession =
     selectionStage === 'puzzle-generating' &&
     activePuzzleGenerationSessionId != null &&
@@ -5417,7 +5695,6 @@ export function PlatformEntryFlowShellImpl({
     };
   }, [
     activePuzzleGenerationSessionId,
-    puzzleGenerationViewPhase,
     shouldPollPuzzleGenerationSession,
     setPuzzleSession,
   ]);
@@ -5798,7 +6075,10 @@ export function PlatformEntryFlowShellImpl({
             setPuzzleRun(run);
             setPuzzleRuntimeAuthMode('default');
             setPuzzleRuntimeReturnStage('puzzle-result');
-            setSelectionStage('puzzle-runtime');
+            openPuzzleRuntimeStage(
+              setSelectionStage,
+              buildPuzzleDraftRuntimeUrlState(item, null),
+            );
           } catch (error) {
             setPuzzleError(
               resolvePuzzleErrorMessage(error, '�动拼图试玩失败。'),
@@ -6167,6 +6447,9 @@ export function PlatformEntryFlowShellImpl({
       try {
         const response = await createBabyObjectMatchDraft(payload);
         setBabyObjectMatchDraft(response.draft);
+        writeCreationUrlState(
+          buildBabyObjectMatchCreationUrlState(response.draft),
+        );
         void refreshBabyObjectMatchShelf();
         setBabyObjectMatchGenerationPhase('ready');
         setBabyObjectMatchGenerationState((current) =>
@@ -6503,6 +6786,7 @@ export function PlatformEntryFlowShellImpl({
     setBigFishRuntimeStartedAt(null);
     setBigFishRuntimeReturnStage('platform');
     setBigFishGenerationState(null);
+    clearCreationUrlState();
     bigFishFlow.leaveFlow();
   }, [bigFishFlow]);
 
@@ -6512,6 +6796,7 @@ export function PlatformEntryFlowShellImpl({
     setMatch3DFormDraftPayload(null);
     setMatch3DGenerationState(null);
     setMatch3DRuntimeReturnStage('match3d-result');
+    clearCreationUrlState();
     match3dFlow.leaveFlow();
   }, [match3dFlow, setMatch3DFormDraftPayload]);
 
@@ -6519,6 +6804,7 @@ export function PlatformEntryFlowShellImpl({
     setSquareHoleRun(null);
     setSquareHoleRuntimeReturnStage('square-hole-result');
     setSquareHoleGenerationState(null);
+    clearCreationUrlState();
     squareHoleFlow.leaveFlow();
   }, [squareHoleFlow]);
 
@@ -6529,6 +6815,7 @@ export function PlatformEntryFlowShellImpl({
     setJumpHopGenerationState(null);
     setJumpHopSession(null);
     setJumpHopError(null);
+    clearCreationUrlState();
     setSelectionStage('platform');
   }, [setSelectionStage]);
 
@@ -6539,6 +6826,7 @@ export function PlatformEntryFlowShellImpl({
     setWoodenFishGenerationState(null);
     setWoodenFishSession(null);
     setWoodenFishError(null);
+    clearCreationUrlState();
     setSelectionStage('platform');
   }, [setSelectionStage]);
 
@@ -6568,6 +6856,7 @@ export function PlatformEntryFlowShellImpl({
     setBarkBattleError(null);
     setBarkBattleGenerationPartialFailed(false);
     setIsBarkBattleBusy(false);
+    clearCreationUrlState();
     selectionStageRef.current = 'platform';
     setSelectionStage('platform');
   }, [setSelectionStage]);
@@ -6584,6 +6873,7 @@ export function PlatformEntryFlowShellImpl({
       try {
         const draft = await createBarkBattleDraft(payload);
         setBarkBattleDraftConfig(draft);
+        writeCreationUrlState(buildBarkBattleCreationUrlState(draft));
         setBarkBattlePublishedConfig(null);
         markDraftGenerating('bark-battle', [draft.workId, draft.draftId]);
         markPendingDraftGenerating('bark-battle', draft.workId ?? draft.draftId);
@@ -6620,6 +6910,7 @@ export function PlatformEntryFlowShellImpl({
   const handleBarkBattleGenerationComplete = useCallback(
     (draft: BarkBattleDraftConfig, partialFailed: boolean) => {
       setBarkBattleDraftConfig(draft);
+      writeCreationUrlState(buildBarkBattleCreationUrlState(draft));
       setBarkBattlePublishedConfig(null);
       setBarkBattleGenerationPartialFailed(partialFailed);
       const generationStatus = resolveBarkBattleDraftGenerationStatus(
@@ -6685,6 +6976,7 @@ export function PlatformEntryFlowShellImpl({
             draft.uiBackgroundImageSrc ?? persistedDraft.uiBackgroundImageSrc,
         };
         setBarkBattleDraftConfig(nextDraft);
+        writeCreationUrlState(buildBarkBattleCreationUrlState(nextDraft));
         updateBarkBattleWorkCaches(
           buildBarkBattleWorkSummaryFromDraft(
             nextDraft,
@@ -6848,6 +7140,8 @@ export function PlatformEntryFlowShellImpl({
     setActiveCreativeAgentSessionId(null);
     setCreativeDraftEditError(null);
     resetRecommendRuntimeSelection();
+    clearCreationUrlState();
+    clearPuzzleRuntimeUrlState();
     puzzleFlow.leaveFlow();
   }, [puzzleFlow, resetRecommendRuntimeSelection]);
 
@@ -6858,6 +7152,7 @@ export function PlatformEntryFlowShellImpl({
     setVisualNovelFormDraftPayload(null);
     setVisualNovelGenerationStartedAtMs(null);
     setVisualNovelGenerationPhase('generating');
+    clearCreationUrlState();
     visualNovelFlow.leaveFlow();
   }, [visualNovelFlow]);
 
@@ -6867,6 +7162,7 @@ export function PlatformEntryFlowShellImpl({
     setBabyObjectMatchGenerationState(null);
     setBabyObjectMatchGenerationPhase('generating');
     setBabyObjectMatchError(null);
+    clearCreationUrlState();
     enterCreateTab();
     selectionStageRef.current = 'platform';
     setSelectionStage('platform');
@@ -6879,6 +7175,9 @@ export function PlatformEntryFlowShellImpl({
       try {
         const response = await saveBabyObjectMatchDraft({ draft });
         setBabyObjectMatchDraft(response.draft);
+        writeCreationUrlState(
+          buildBabyObjectMatchCreationUrlState(response.draft),
+        );
         void refreshBabyObjectMatchShelf();
       } catch (error) {
         setBabyObjectMatchError(
@@ -7518,6 +7817,9 @@ export function PlatformEntryFlowShellImpl({
       const generationState = createMiniGameDraftGenerationState('jump-hop');
       setJumpHopError(null);
       setJumpHopSession(created.session);
+      writeCreationUrlState(
+        buildJumpHopCreationUrlState({ session: created.session }),
+      );
       setJumpHopWork(null);
       setJumpHopRun(null);
       setJumpHopGenerationState(generationState);
@@ -7550,6 +7852,12 @@ export function PlatformEntryFlowShellImpl({
         const readyState = createReadyJumpHopGenerationState(generationState);
         setJumpHopSession(response.session);
         setJumpHopWork(response.work ?? null);
+        writeCreationUrlState(
+          buildJumpHopCreationUrlState({
+            session: response.session,
+            work: response.work,
+          }),
+        );
         setJumpHopGenerationState(readyState);
         setSelectionStage('jump-hop-result');
       } catch (error) {
@@ -7571,9 +7879,15 @@ export function PlatformEntryFlowShellImpl({
           );
           setJumpHopSession(latest.session);
           setJumpHopWork(null);
+          writeCreationUrlState(
+            buildJumpHopCreationUrlState({ session: latest.session }),
+          );
         } catch {
           setJumpHopSession(created.session);
           setJumpHopWork(null);
+          writeCreationUrlState(
+            buildJumpHopCreationUrlState({ session: created.session }),
+          );
         }
       } finally {
         setIsJumpHopBusy(false);
@@ -7620,6 +7934,12 @@ export function PlatformEntryFlowShellImpl({
         );
         setJumpHopSession(response.session);
         setJumpHopWork(response.work ?? jumpHopWork);
+        writeCreationUrlState(
+          buildJumpHopCreationUrlState({
+            session: response.session,
+            work: response.work ?? jumpHopWork,
+          }),
+        );
         setJumpHopGenerationState(
           createReadyJumpHopGenerationState(generationState),
         );
@@ -7809,6 +8129,9 @@ export function PlatformEntryFlowShellImpl({
       const generationState = createMiniGameDraftGenerationState('wooden-fish');
       setWoodenFishError(null);
       setWoodenFishSession(created.session);
+      writeCreationUrlState(
+        buildWoodenFishCreationUrlState({ session: created.session }),
+      );
       setWoodenFishWork(null);
       setWoodenFishRun(null);
       setWoodenFishGenerationState(generationState);
@@ -7839,6 +8162,12 @@ export function PlatformEntryFlowShellImpl({
         );
         setWoodenFishSession(response.session);
         setWoodenFishWork(response.work ?? null);
+        writeCreationUrlState(
+          buildWoodenFishCreationUrlState({
+            session: response.session,
+            work: response.work,
+          }),
+        );
         setWoodenFishGenerationState(
           createReadyWoodenFishGenerationState(generationState),
         );
@@ -7862,9 +8191,15 @@ export function PlatformEntryFlowShellImpl({
           );
           setWoodenFishSession(latest.session);
           setWoodenFishWork(null);
+          writeCreationUrlState(
+            buildWoodenFishCreationUrlState({ session: latest.session }),
+          );
         } catch {
           setWoodenFishSession(created.session);
           setWoodenFishWork(null);
+          writeCreationUrlState(
+            buildWoodenFishCreationUrlState({ session: created.session }),
+          );
         }
       } finally {
         setIsWoodenFishBusy(false);
@@ -7911,6 +8246,12 @@ export function PlatformEntryFlowShellImpl({
         );
         setWoodenFishSession(response.session);
         setWoodenFishWork(response.work ?? woodenFishWork);
+        writeCreationUrlState(
+          buildWoodenFishCreationUrlState({
+            session: response.session,
+            work: response.work ?? woodenFishWork,
+          }),
+        );
         setWoodenFishGenerationState(
           createReadyWoodenFishGenerationState(generationState),
         );
@@ -7970,6 +8311,12 @@ export function PlatformEntryFlowShellImpl({
         });
         setWoodenFishSession(response.session);
         setWoodenFishWork(response.work ?? woodenFishWork);
+        writeCreationUrlState(
+          buildWoodenFishCreationUrlState({
+            session: response.session,
+            work: response.work ?? woodenFishWork,
+          }),
+        );
         return true;
       } catch (error) {
         setWoodenFishError(
@@ -8315,7 +8662,12 @@ export function PlatformEntryFlowShellImpl({
     if (selectionStage === 'big-fish-runtime' && !bigFishRun) {
       setSelectionStage(bigFishSession?.draft ? 'big-fish-result' : 'platform');
     }
-  }, [bigFishRun, bigFishSession, selectionStage, setSelectionStage]);
+  }, [
+    bigFishRun,
+    bigFishSession,
+    selectionStage,
+    setSelectionStage,
+  ]);
 
   useEffect(() => {
     if (selectionStage === 'match3d-result' && !match3dSession?.draft) {
@@ -8326,7 +8678,12 @@ export function PlatformEntryFlowShellImpl({
     if (selectionStage === 'match3d-runtime' && !match3dRun) {
       setSelectionStage(match3dSession?.draft ? 'match3d-result' : 'platform');
     }
-  }, [match3dRun, match3dSession, selectionStage, setSelectionStage]);
+  }, [
+    match3dRun,
+    match3dSession,
+    selectionStage,
+    setSelectionStage,
+  ]);
 
   useEffect(() => {
     if (selectionStage === 'square-hole-result' && !squareHoleSession?.draft) {
@@ -8339,7 +8696,12 @@ export function PlatformEntryFlowShellImpl({
         squareHoleSession?.draft ? 'square-hole-result' : 'platform',
       );
     }
-  }, [selectionStage, setSelectionStage, squareHoleRun, squareHoleSession]);
+  }, [
+    selectionStage,
+    setSelectionStage,
+    squareHoleRun,
+    squareHoleSession,
+  ]);
 
   useEffect(() => {
     if (
@@ -8511,12 +8873,11 @@ export function PlatformEntryFlowShellImpl({
         setPuzzleRuntimeAuthMode(authMode);
         setPuzzleRuntimeReturnStage(returnStage);
         if (!options.embedded) {
-          setSelectionStage('puzzle-runtime');
-          pushAppHistoryPath(
-            buildPublicWorkStagePath(
-              'puzzle-runtime',
-              buildPuzzlePublicWorkCode(item.profileId),
-            ),
+          openPuzzleRuntimeStage(
+            setSelectionStage,
+            authMode === 'isolated'
+              ? buildPuzzlePublishedRuntimeUrlState(item, levelId)
+              : buildPuzzleDraftRuntimeUrlState(item, levelId),
           );
         }
         return true;
@@ -8795,7 +9156,10 @@ export function PlatformEntryFlowShellImpl({
         setPuzzleRun(run);
         setPuzzleRuntimeAuthMode('default');
         setPuzzleRuntimeReturnStage('puzzle-result');
-        setSelectionStage('puzzle-runtime');
+        openPuzzleRuntimeStage(
+          setSelectionStage,
+          buildPuzzleDraftRuntimeUrlState(item, options.levelId ?? null),
+        );
         return true;
       } catch (error) {
         setPuzzleError(resolvePuzzleErrorMessage(error, '�动拼图试玩失败。'));
@@ -8958,6 +9322,152 @@ export function PlatformEntryFlowShellImpl({
     return () => window.clearInterval(timerId);
   }, [puzzleRun, selectionStage]);
 
+  useEffect(() => {
+    if (selectionStage !== 'puzzle-runtime' || puzzleRun) {
+      return;
+    }
+    if (!hasPuzzleRuntimeUrlStateValue(initialPuzzleRuntimeUrlState)) {
+      return;
+    }
+    const runtimeUrlStateKey = buildPuzzleRuntimeUrlStateKey(
+      initialPuzzleRuntimeUrlState,
+    );
+    if (
+      handledPuzzleRuntimeUrlStateKeyRef.current === runtimeUrlStateKey ||
+      isPuzzleBusy
+    ) {
+      return;
+    }
+
+    handledPuzzleRuntimeUrlStateKeyRef.current = runtimeUrlStateKey;
+    let cancelled = false;
+
+    const restorePuzzleRuntime = async () => {
+      const runtimeProfileId = normalizeCreationUrlValue(
+        initialPuzzleRuntimeUrlState.runtimeProfileId,
+      );
+      const runtimeSessionId = normalizeCreationUrlValue(
+        initialPuzzleRuntimeUrlState.runtimeSessionId,
+      );
+      const runtimeLevelId = normalizeCreationUrlValue(
+        initialPuzzleRuntimeUrlState.runtimeLevelId,
+      );
+      const publicWorkCode = normalizeCreationUrlValue(
+        initialPuzzleRuntimeUrlState.publicWorkCode,
+      );
+      const runtimeMode = initialPuzzleRuntimeUrlState.mode ?? null;
+      const isPublishedRuntime = runtimeMode === 'published';
+      if (
+        !isPublishedRuntime &&
+        (platformBootstrap.isLoadingPlatform ||
+          !platformBootstrap.canReadProtectedData)
+      ) {
+        handledPuzzleRuntimeUrlStateKeyRef.current = null;
+        return;
+      }
+      const fallbackStage: PuzzleRuntimeReturnStage =
+        runtimeMode === 'published' ? 'work-detail' : 'puzzle-result';
+
+      const candidateItems = isPublishedRuntime
+        ? puzzleGalleryEntries.length > 0
+          ? puzzleGalleryEntries
+          : await refreshPuzzleGallery()
+        : (
+            puzzleWorks.length > 0
+              ? puzzleWorks
+              : (await listPuzzleWorks().catch(() => ({ items: [] }))).items
+          );
+      const targetItem =
+        runtimeProfileId || runtimeSessionId || publicWorkCode
+          ? candidateItems.find(
+              (item) =>
+                item.profileId === runtimeProfileId ||
+                item.sourceSessionId === runtimeSessionId ||
+                (publicWorkCode
+                  ? isSamePuzzlePublicWorkCode(publicWorkCode, item.profileId)
+                  : false),
+            ) ?? null
+          : null;
+
+      if (!targetItem) {
+        if (runtimeSessionId) {
+          try {
+            const { session } = await getPuzzleAgentSession(runtimeSessionId);
+            const restoredWork = buildPuzzleRuntimeWorkFromSession(session, {
+              userId: authUi?.user?.id ?? 'current-user',
+              displayName: authUi?.user?.displayName ?? '玩家',
+            });
+            if (restoredWork && !cancelled) {
+              setSelectedPuzzleDetail(restoredWork);
+              setPuzzleRun(
+                startLocalPuzzleRun(restoredWork, runtimeLevelId ?? null),
+              );
+              setPuzzleRuntimeAuthMode('default');
+              setPuzzleRuntimeReturnStage(fallbackStage);
+              openPuzzleRuntimeStage(
+                setSelectionStage,
+                buildPuzzleDraftRuntimeUrlState(restoredWork, runtimeLevelId),
+              );
+              return;
+            }
+          } catch {
+            // 读�到�稿时继续回退到平�页，���在空�行�。
+          }
+        }
+
+        if (!cancelled) {
+          setPuzzleError(
+            runtimeMode === 'published'
+              ? '这份拼图�行�缺少���作�，请返回作�详情�新进入。'
+              : '这份拼图试玩缺少����稿，请返回结果页�新进入。',
+          );
+          setPuzzleRuntimeAuthMode('default');
+          setPuzzleRun(null);
+          setSelectionStage('platform');
+          pushAppHistoryPath('/');
+        }
+        return;
+      }
+
+      if (cancelled) {
+        return;
+      }
+
+      setSelectedPuzzleDetail(targetItem);
+      setPuzzleRun(
+        startLocalPuzzleRun(targetItem, runtimeLevelId ?? null),
+      );
+      setPuzzleRuntimeAuthMode(isPublishedRuntime ? 'isolated' : 'default');
+      setPuzzleRuntimeReturnStage(fallbackStage);
+      openPuzzleRuntimeStage(
+        setSelectionStage,
+        isPublishedRuntime
+          ? buildPuzzlePublishedRuntimeUrlState(targetItem, runtimeLevelId)
+          : buildPuzzleDraftRuntimeUrlState(targetItem, runtimeLevelId),
+      );
+    };
+
+    void restorePuzzleRuntime();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    authUi?.user?.displayName,
+    authUi?.user?.id,
+    initialPuzzleRuntimeUrlState,
+    isPuzzleBusy,
+    platformBootstrap.canReadProtectedData,
+    platformBootstrap.isLoadingPlatform,
+    puzzleGalleryEntries,
+    puzzleRun,
+    puzzleRuntimeReturnStage,
+    puzzleWorks,
+    refreshPuzzleGallery,
+    selectionStage,
+    setSelectionStage,
+  ]);
+
   const setPuzzleRuntimePaused = useCallback(
     async (paused: boolean) => {
       if (!puzzleRun?.currentLevel) {
@@ -9255,10 +9765,11 @@ export function PlatformEntryFlowShellImpl({
           ]);
           setSelectedPuzzleDetail(item);
           setPuzzleRun(run);
-          pushAppHistoryPath(
-            buildPublicWorkStagePath(
-              'puzzle-runtime',
-              buildPuzzlePublicWorkCode(item.profileId),
+          openPuzzleRuntimeStage(
+            setSelectionStage,
+            buildPuzzlePublishedRuntimeUrlState(
+              item,
+              run.currentLevel?.levelId ?? null,
             ),
           );
           return;
@@ -10981,7 +11492,7 @@ export function PlatformEntryFlowShellImpl({
         return;
       }
 
-      setBarkBattleDraftConfig({
+      const nextDraft: BarkBattleDraftConfig = {
         draftId: item.draftId ?? item.workId,
         workId: item.workId,
         title: item.title,
@@ -10997,13 +11508,15 @@ export function PlatformEntryFlowShellImpl({
         configVersion: 1,
         rulesetVersion: 'bark-battle-ruleset-v1',
         updatedAt: item.updatedAt,
-      });
+      };
+      setBarkBattleDraftConfig(nextDraft);
       enterCreateTab();
       selectionStageRef.current =
         isPersistedBarkBattleDraftGenerating(item)
           ? 'bark-battle-generating'
           : 'bark-battle-result';
       setSelectionStage(selectionStageRef.current);
+      writeCreationUrlState(buildBarkBattleCreationUrlState(nextDraft));
     },
     [enterCreateTab, markDraftNoticeSeen, openPublicWorkDetail, setSelectionStage],
   );
@@ -11091,10 +11604,273 @@ export function PlatformEntryFlowShellImpl({
       setBabyObjectMatchError(null);
       enterCreateTab();
       setSelectionStage('baby-object-match-result');
+      writeCreationUrlState(buildBabyObjectMatchCreationUrlState(draft));
     },
     [enterCreateTab, markDraftNoticeSeen, setSelectionStage],
   );
 
+  useEffect(() => {
+    if (handledInitialCreationUrlStateRef.current) {
+      return;
+    }
+    if (!isCreationRestorePath(window.location.pathname)) {
+      handledInitialCreationUrlStateRef.current = true;
+      return;
+    }
+    if (!hasCreationUrlStateValue(initialCreationUrlState)) {
+      handledInitialCreationUrlStateRef.current = true;
+      return;
+    }
+    if (platformBootstrap.isLoadingPlatform) {
+      return;
+    }
+    if (!platformBootstrap.canReadProtectedData) {
+      return;
+    }
+
+    handledInitialCreationUrlStateRef.current = true;
+
+    const restoreCreationUrlState = async () => {
+      const path = window.location.pathname;
+      const sessionId = normalizeCreationUrlValue(
+        initialCreationUrlState.sessionId,
+      );
+      const profileId = normalizeCreationUrlValue(
+        initialCreationUrlState.profileId,
+      );
+      const draftId = normalizeCreationUrlValue(initialCreationUrlState.draftId);
+      const workId = normalizeCreationUrlValue(initialCreationUrlState.workId);
+
+      if (path.startsWith('/creation/big-fish')) {
+        const targetSessionId = sessionId ?? workId?.replace(/^big-fish-work-/u, '');
+        if (targetSessionId) {
+          const matchedWork =
+            (
+              bigFishWorks.length > 0
+                ? bigFishWorks
+                : (await listBigFishWorks().catch(() => ({ items: [] }))).items
+            ).find(
+              (item) =>
+                item.sourceSessionId === targetSessionId ||
+                item.workId === workId,
+            ) ?? null;
+          if (matchedWork) {
+            await openBigFishDraft(matchedWork);
+            return;
+          }
+          await bigFishFlow.restoreDraft(targetSessionId);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/match3d')) {
+        const matchedWork =
+          (
+            match3dWorks.length > 0
+              ? match3dWorks
+              : mapMatch3DWorksForRuntimeUi(
+                  (await listMatch3DWorks().catch(() => ({ items: [] }))).items,
+                )
+          ).find(
+            (item) =>
+              item.sourceSessionId === sessionId ||
+              item.profileId === profileId ||
+              item.workId === workId,
+          ) ?? null;
+        if (matchedWork) {
+          await openMatch3DDraft(matchedWork, { forceDraft: true });
+          return;
+        }
+        if (sessionId) {
+          await match3dFlow.restoreDraft(sessionId);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/square-hole')) {
+        const matchedWork =
+          (
+            squareHoleWorks.length > 0
+              ? squareHoleWorks
+              : (await listSquareHoleWorks().catch(() => ({ items: [] }))).items
+          ).find(
+            (item) =>
+              item.sourceSessionId === sessionId ||
+              item.profileId === profileId ||
+              item.workId === workId,
+          ) ?? null;
+        if (matchedWork) {
+          await openSquareHoleDraft(matchedWork, { forceDraft: true });
+          return;
+        }
+        if (sessionId) {
+          await squareHoleFlow.restoreDraft(sessionId);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/puzzle')) {
+        const matchedWork =
+          (
+            puzzleWorks.length > 0
+              ? puzzleWorks
+              : (await listPuzzleWorks().catch(() => ({ items: [] }))).items
+          ).find(
+            (item) =>
+              item.sourceSessionId === sessionId ||
+              item.profileId === profileId ||
+              item.workId === workId,
+          ) ?? null;
+        if (matchedWork) {
+          await openPuzzleDraft(matchedWork);
+          return;
+        }
+        if (sessionId) {
+          await puzzleFlow.restoreDraft(sessionId);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/visual-novel')) {
+        const matchedWork =
+          (
+            visualNovelWorks.length > 0
+              ? visualNovelWorks
+              : (await listVisualNovelWorks().catch(() => ({ works: [] }))).works
+          ).find((item) => item.profileId === profileId) ?? null;
+        if (matchedWork) {
+          await openVisualNovelDraft(matchedWork, { forceDraft: true });
+          return;
+        }
+        if (sessionId) {
+          await visualNovelFlow.restoreDraft(sessionId);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/bark-battle')) {
+        const matchedWork =
+          (
+            barkBattleWorks.length > 0
+              ? barkBattleWorks
+              : (await listBarkBattleWorks().catch(() => ({ items: [] }))).items
+          ).find(
+            (item) => item.workId === workId || item.draftId === draftId,
+          ) ?? null;
+        if (matchedWork) {
+          openBarkBattleDraft(matchedWork, { forceDraft: true });
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/baby-object-match')) {
+        const matchedDraft =
+          (
+            babyObjectMatchDrafts.length > 0
+              ? babyObjectMatchDrafts
+              : await listLocalBabyObjectMatchDrafts().catch(() => [])
+          ).find(
+            (item) =>
+              item.profileId === profileId ||
+              item.draftId === draftId ||
+              item.profileId === workId,
+          ) ?? null;
+        if (matchedDraft) {
+          openBabyObjectMatchDraft(matchedDraft);
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/jump-hop')) {
+        if (!sessionId) {
+          return;
+        }
+        try {
+          const { session } = await jumpHopClient.getSession(sessionId);
+          let work: JumpHopWorkProfileResponse | null = null;
+          if (profileId) {
+            work = (await jumpHopClient.getWorkDetail(profileId)).item;
+          }
+          setJumpHopSession(session);
+          setJumpHopWork(work);
+          writeCreationUrlState(buildJumpHopCreationUrlState({ session, work }));
+          enterCreateTab();
+          setSelectionStage(
+            path.includes('/generating')
+              ? 'jump-hop-generating'
+              : session.draft
+                ? 'jump-hop-result'
+                : 'jump-hop-workspace',
+          );
+        } catch (error) {
+          setJumpHopError(
+            resolveRpgCreationErrorMessage(error, '读�跳一跳创作�稿失败。'),
+          );
+        }
+        return;
+      }
+
+      if (path.startsWith('/creation/wooden-fish')) {
+        if (!sessionId) {
+          return;
+        }
+        try {
+          const { session } = await woodenFishClient.getSession(sessionId);
+          let work: WoodenFishWorkProfileResponse | null = null;
+          if (profileId) {
+            work = (await woodenFishClient.getWorkDetail(profileId)).item;
+          }
+          setWoodenFishSession(session);
+          setWoodenFishWork(work);
+          writeCreationUrlState(
+            buildWoodenFishCreationUrlState({ session, work }),
+          );
+          enterCreateTab();
+          setSelectionStage(
+            path.includes('/generating')
+              ? 'wooden-fish-generating'
+              : session.draft
+                ? 'wooden-fish-result'
+                : 'wooden-fish-workspace',
+          );
+        } catch (error) {
+          setWoodenFishError(
+            resolveRpgCreationErrorMessage(error, '读�敲木鱼创作�稿失败。'),
+          );
+        }
+      }
+    };
+
+    void restoreCreationUrlState();
+  }, [
+    babyObjectMatchDrafts,
+    barkBattleWorks,
+    bigFishFlow,
+    bigFishWorks,
+    enterCreateTab,
+    initialCreationUrlState,
+    jumpHopClient,
+    match3dFlow,
+    match3dWorks,
+    openBabyObjectMatchDraft,
+    openBarkBattleDraft,
+    openBigFishDraft,
+    openMatch3DDraft,
+    openPuzzleDraft,
+    openSquareHoleDraft,
+    openVisualNovelDraft,
+    platformBootstrap.canReadProtectedData,
+    platformBootstrap.isLoadingPlatform,
+    puzzleFlow,
+    puzzleWorks,
+    setSelectionStage,
+    squareHoleFlow,
+    squareHoleWorks,
+    visualNovelFlow,
+    visualNovelWorks,
+    woodenFishClient,
+  ]);
+
   const startBigFishRunFromWork = useCallback(
     async (
       item: BigFishWorkSummary,
diff --git a/src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx b/src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx
index 68f9039b..ded82926 100644
--- a/src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx
+++ b/src/components/platform-entry/usePlatformCreationAgentFlowController.test.tsx
@@ -300,6 +300,161 @@ function ActionCompleteHarness({
   );
 }
 
+function SessionChangeHarness({
+  onSessionChanged,
+}: {
+  onSessionChanged: (session: TestSession | null) => void;
+}) {
+  const flow = usePlatformCreationAgentFlowController<
+    TestSession,
+    Record<string, never>,
+    { session: TestSession },
+    TestMessagePayload,
+    { action: string },
+    { session: TestSession }
+  >({
+    client: {
+      createSession: async () => ({
+        session: {
+          sessionId: 'session-open',
+          messages: [],
+        },
+      }),
+      getSession: async () => ({
+        session: {
+          sessionId: 'session-restore',
+          messages: [],
+        },
+      }),
+      streamMessage: async () => ({
+        sessionId: 'session-open',
+        messages: [],
+      }),
+      executeAction: async () => ({
+        session: {
+          sessionId: 'session-compile',
+          messages: [],
+        },
+      }),
+      selectSession: (response) => response.session,
+    },
+    createPayload: {},
+    workspaceStage: 'match3d-agent-workspace',
+    resultStage: 'match3d-result',
+    platformStage: 'platform',
+    isCompileAction: (payload) => payload.action === 'match3d_compile_draft',
+    resolveErrorMessage: (error, fallback) =>
+      error instanceof Error ? error.message : fallback,
+    errorMessages: {
+      open: '打开失败',
+      restoreMissingSession: '缺少会�',
+      restore: '��失败',
+      submit: '��失败',
+      execute: '执行失败',
+    },
+    enterCreateTab: () => {},
+    setSelectionStage: () => {},
+    onSessionChanged,
+    onActionComplete: ({ response, setSession }) => {
+      setSession(response.session);
+    },
+  });
+
+  return (
+    <div>
+      <button type="button" onClick={() => void flow.openWorkspace({})}>
+        打开
+      </button>
+      <button
+        type="button"
+        onClick={() => void flow.restoreDraft('session-restore')}
+      >
+        ��
+      </button>
+      <button
+        type="button"
+        onClick={() =>
+          void flow.executeAction({ action: 'match3d_compile_draft' })
+        }
+      >
+        编译
+      </button>
+    </div>
+  );
+}
+
+function SessionSetterIdentityHarness({
+  onSetterIdentity,
+}: {
+  onSetterIdentity: (setter: unknown) => void;
+}) {
+  const [renderCount, setRenderCount] = useState(0);
+  const flow = usePlatformCreationAgentFlowController<
+    TestSession,
+    Record<string, never>,
+    { session: TestSession },
+    TestMessagePayload,
+    { action: string },
+    { session: TestSession }
+  >({
+    client: {
+      createSession: async () => ({
+        session: {
+          sessionId: 'session-open',
+          messages: [],
+        },
+      }),
+      getSession: async () => ({
+        session: {
+          sessionId: 'session-restore',
+          messages: [],
+        },
+      }),
+      streamMessage: async () => ({
+        sessionId: 'session-open',
+        messages: [],
+      }),
+      executeAction: async () => ({
+        session: {
+          sessionId: 'session-compile',
+          messages: [],
+        },
+      }),
+      selectSession: (response) => response.session,
+    },
+    createPayload: {},
+    workspaceStage: 'match3d-agent-workspace',
+    resultStage: 'match3d-result',
+    platformStage: 'platform',
+    isCompileAction: () => false,
+    resolveErrorMessage: (error, fallback) =>
+      error instanceof Error ? error.message : fallback,
+    errorMessages: {
+      open: '打开失败',
+      restoreMissingSession: '缺少会�',
+      restore: '��失败',
+      submit: '��失败',
+      execute: '执行失败',
+    },
+    enterCreateTab: () => {},
+    setSelectionStage: () => {},
+    onSessionChanged: () => {},
+  });
+
+  useEffect(() => {
+    onSetterIdentity(flow.setSession);
+  });
+
+  return (
+    <button
+      type="button"
+      onClick={() => setRenderCount((current) => current + 1)}
+    >
+      �渲染 {renderCount}
+    </button>
+  );
+}
+
 test('creation agent flow preserves streamed assistant text when stream fails', async () => {
   const streamMessage = vi.fn(async (_sessionId, _payload, options) => {
     options?.onUpdate?.('先把方洞万能的�差定�。');
@@ -391,3 +546,48 @@ test('creation agent flow suppresses compile result stage for background complet
     'match3d-agent-workspace',
   );
 });
+
+test('creation agent flow notifies session changes after open restore and compile', async () => {
+  const onSessionChanged = vi.fn();
+
+  render(<SessionChangeHarness onSessionChanged={onSessionChanged} />);
+
+  await act(async () => {
+    screen.getByRole('button', { name: '打开' }).click();
+  });
+  await act(async () => {
+    screen.getByRole('button', { name: '��' }).click();
+  });
+  await act(async () => {
+    screen.getByRole('button', { name: '编译' }).click();
+  });
+
+  await waitFor(() => {
+    expect(onSessionChanged).toHaveBeenCalledTimes(3);
+  });
+
+  expect(
+    onSessionChanged.mock.calls.map(([session]) => session?.sessionId),
+  ).toEqual(['session-open', 'session-restore', 'session-compile']);
+});
+
+test('creation agent flow keeps session setter stable across parent rerenders', async () => {
+  const onSetterIdentity = vi.fn();
+
+  render(<SessionSetterIdentityHarness onSetterIdentity={onSetterIdentity} />);
+
+  await waitFor(() => {
+    expect(onSetterIdentity).toHaveBeenCalledTimes(1);
+  });
+  const initialSetter = onSetterIdentity.mock.calls[0]?.[0];
+
+  await act(async () => {
+    screen.getByRole('button', { name: /�渲染/u }).click();
+  });
+
+  await waitFor(() => {
+    expect(onSetterIdentity).toHaveBeenCalledTimes(2);
+  });
+
+  expect(onSetterIdentity.mock.calls[1]?.[0]).toBe(initialSetter);
+});
diff --git a/src/components/platform-entry/usePlatformCreationAgentFlowController.ts b/src/components/platform-entry/usePlatformCreationAgentFlowController.ts
index ba7ab67b..f89b778e 100644
--- a/src/components/platform-entry/usePlatformCreationAgentFlowController.ts
+++ b/src/components/platform-entry/usePlatformCreationAgentFlowController.ts
@@ -1,4 +1,5 @@
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
 
 import type { TextStreamOptions } from '../../services/aiTypes';
 import type { SelectionStage } from './platformEntryTypes';
@@ -75,12 +76,13 @@ type PlatformCreationAgentFlowControllerOptions<
   enterCreateTab: () => void;
   setSelectionStage: (stage: SelectionStage) => void;
   onSessionOpened?: () => void;
+  onSessionChanged?: (session: TSession | null) => void;
   onOpenError?: (params: { error: unknown; errorMessage: string }) => void;
   onActionComplete?: (params: {
     payload: TActionPayload;
     response: TActionResponse;
     session: TSession;
-    setSession: (session: TSession) => void;
+    setSession: Dispatch<SetStateAction<TSession | null>>;
   }) =>
     | Promise<{ openResult?: boolean } | void>
     | { openResult?: boolean }
@@ -94,7 +96,7 @@ type PlatformCreationAgentFlowControllerOptions<
     error: unknown;
     errorMessage: string;
     session: TSession;
-    setSession: (session: TSession) => void;
+    setSession: Dispatch<SetStateAction<TSession | null>>;
   }) => void | Promise<void>;
 };
 
@@ -141,12 +143,27 @@ export function usePlatformCreationAgentFlowController<
     TActionResponse
   >,
 ) {
-  const [session, setSession] = useState<TSession | null>(null);
+  const [session, rawSetSession] = useState<TSession | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [isBusy, setIsBusy] = useState(false);
   const [streamingReplyText, setStreamingReplyText] = useState('');
   const [isStreamingReply, setIsStreamingReply] = useState(false);
   const latestStreamingReplyTextRef = useRef('');
+  const onSessionChangedRef = useRef(options.onSessionChanged);
+
+  useEffect(() => {
+    onSessionChangedRef.current = options.onSessionChanged;
+  }, [options.onSessionChanged]);
+
+  const setSession = useCallback(
+    (nextSessionOrUpdater: SetStateAction<TSession | null>) => {
+      rawSetSession(nextSessionOrUpdater);
+      if (typeof nextSessionOrUpdater !== 'function') {
+        onSessionChangedRef.current?.(nextSessionOrUpdater);
+      }
+    },
+    [],
+  );
 
   const updateStreamingReplyText = useCallback((text: string) => {
     latestStreamingReplyTextRef.current = text;
@@ -174,10 +191,10 @@ export function usePlatformCreationAgentFlowController<
           createPayload ?? options.createPayload,
         );
         const nextSession = options.client.selectSession(response);
-        setSession(nextSession);
         options.enterCreateTab();
         options.onSessionOpened?.();
         options.setSelectionStage(options.workspaceStage);
+        setSession(nextSession);
         return nextSession;
       } catch (caughtError) {
         const errorMessage = options.resolveErrorMessage(
@@ -212,11 +229,11 @@ export function usePlatformCreationAgentFlowController<
       try {
         const response = await options.client.getSession(normalizedSessionId);
         const nextSession = options.client.selectSession(response);
-        setSession(nextSession);
         options.enterCreateTab();
         options.setSelectionStage(
           nextSession.draft ? options.resultStage : options.workspaceStage,
         );
+        setSession(nextSession);
         return nextSession;
       } catch (caughtError) {
         setError(
diff --git a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
index 036b09fe..f533f741 100644
--- a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
+++ b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
@@ -119,10 +119,7 @@ import {
   startLocalPuzzleRun,
   swapLocalPuzzlePieces,
 } from '../../services/puzzle-runtime/puzzleLocalRuntime';
-import {
-  listPuzzleWorks,
-  updatePuzzleWork,
-} from '../../services/puzzle-works';
+import { listPuzzleWorks, updatePuzzleWork } from '../../services/puzzle-works';
 import {
   createRpgCreationSession,
   executeRpgCreationAction,
@@ -212,14 +209,22 @@ async function openCreateTemplateHub(user: ReturnType<typeof userEvent.setup>) {
 
 async function findCreationTypeButton(name: string | RegExp) {
   const matcher =
-    typeof name === 'string' ? new RegExp(name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'u') : name;
-  return within(getPlatformTabPanel('create')).findByRole('button', { name: matcher });
+    typeof name === 'string'
+      ? new RegExp(name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'u')
+      : name;
+  return within(getPlatformTabPanel('create')).findByRole('button', {
+    name: matcher,
+  });
 }
 
 function queryCreationTypeButton(name: string | RegExp) {
   const matcher =
-    typeof name === 'string' ? new RegExp(name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'u') : name;
-  return within(getPlatformTabPanel('create')).queryByRole('button', { name: matcher });
+    typeof name === 'string'
+      ? new RegExp(name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'u')
+      : name;
+  return within(getPlatformTabPanel('create')).queryByRole('button', {
+    name: matcher,
+  });
 }
 
 async function openDraftHub(user: ReturnType<typeof userEvent.setup>) {
@@ -228,9 +233,7 @@ async function openDraftHub(user: ReturnType<typeof userEvent.setup>) {
   await waitFor(() => {
     expect(panel.getAttribute('aria-hidden')).toBe('false');
   });
-  expect(
-    await within(panel).findByRole('tab', { name: /全部/u }),
-  ).toBeTruthy();
+  expect(await within(panel).findByRole('tab', { name: /全部/u })).toBeTruthy();
 }
 
 async function expectDraftHubGeneratingBadgeCountAtLeast(count: number) {
@@ -606,7 +609,12 @@ vi.mock('../../services/match3dGeneratedModelCache', () => ({
     (
       primaryAssets: Match3DWorkSummary['generatedItemAssets'],
       fallbackAssets: Match3DWorkSummary['generatedItemAssets'],
-    ) => (primaryAssets ? [...primaryAssets] : fallbackAssets ? [...fallbackAssets] : []),
+    ) =>
+      primaryAssets
+        ? [...primaryAssets]
+        : fallbackAssets
+          ? [...fallbackAssets]
+          : [],
   ),
   preloadMatch3DGeneratedRuntimeAssets: vi.fn(() => Promise.resolve()),
 }));
@@ -1040,20 +1048,16 @@ vi.mock('../match3d-runtime/Match3DRuntimeShell', () => ({
         }
       </div>
       <div data-testid="match3d-runtime-top-level-background-count">
-        {
-          generatedBackgroundAsset?.imageSrc?.trim() ||
-          generatedBackgroundAsset?.imageObjectKey?.trim()
-            ? 1
-            : 0
-        }
+        {generatedBackgroundAsset?.imageSrc?.trim() ||
+        generatedBackgroundAsset?.imageObjectKey?.trim()
+          ? 1
+          : 0}
       </div>
       <div data-testid="match3d-runtime-top-level-container-ui-count">
-        {
-          generatedBackgroundAsset?.containerImageSrc?.trim() ||
-          generatedBackgroundAsset?.containerImageObjectKey?.trim()
-            ? 1
-            : 0
-        }
+        {generatedBackgroundAsset?.containerImageSrc?.trim() ||
+        generatedBackgroundAsset?.containerImageObjectKey?.trim()
+          ? 1
+          : 0}
       </div>
       <button type="button" onClick={onBack}>
         返回
@@ -1204,11 +1208,16 @@ vi.mock('../../games/bark-battle/ui/BarkBattleRuntimeShell', () => ({
     title?: string;
     workId?: string;
     runtimeMode?: string;
-    publishedConfig?: { workId?: string; playerCharacterImageSrc?: string | null } | null;
+    publishedConfig?: {
+      workId?: string;
+      playerCharacterImageSrc?: string | null;
+    } | null;
     onExit?: () => void;
   }) => (
     <div className="bark-battle-runtime-shell-mock">
-      <div>汪汪声浪�行�：{title ?? '未命�'} / {workId ?? 'missing-work'}</div>
+      <div>
+        汪汪声浪�行�：{title ?? '未命�'} / {workId ?? 'missing-work'}
+      </div>
       <div data-testid="bark-battle-runtime-mode">
         {runtimeMode ?? 'missing-mode'}
       </div>
@@ -1803,7 +1812,8 @@ function buildMockMatch3DRun(profileId: string): Match3DRunSnapshot {
 
 const match3DGeneratedUiAsset = {
   prompt: '果园竖�纯背景',
-  imageSrc: '/generated-match3d-assets/session/profile/background/background.png',
+  imageSrc:
+    '/generated-match3d-assets/session/profile/background/background.png',
   imageObjectKey:
     'generated-match3d-assets/session/profile/background/background.png',
   containerPrompt: '果园浅盘容器',
@@ -2265,7 +2275,8 @@ beforeEach(() => {
       index === 0
         ? {
             ...asset,
-            backgroundMusic: asset.backgroundMusic ?? musicCarrier.backgroundMusic,
+            backgroundMusic:
+              asset.backgroundMusic ?? musicCarrier.backgroundMusic,
           }
         : {
             ...asset,
@@ -2273,7 +2284,7 @@ beforeEach(() => {
             backgroundMusicTitle: null,
             backgroundMusicStyle: null,
             backgroundMusicPrompt: null,
-          }
+          },
     );
   });
   vi.mocked(
@@ -2291,7 +2302,9 @@ beforeEach(() => {
         primary,
       );
     }
-    const fallbackById = new Map(fallback.map((asset) => [asset.itemId, asset]));
+    const fallbackById = new Map(
+      fallback.map((asset) => [asset.itemId, asset]),
+    );
     return match3dGeneratedModelCache.normalizeMatch3DGeneratedItemAssetsForRuntime(
       primary.map((asset) => {
         const fallbackAsset = fallbackById.get(asset.itemId);
@@ -2972,48 +2985,50 @@ beforeEach(() => {
   vi.mocked(generateAllBarkBattleImageAssets).mockResolvedValue({
     assets: {
       'player-character': {
-      imageSrc: '/generated-bark-battle/player.png',
-      assetId: 'asset-player',
-      model: 'gpt-image-2-all',
-      size: '1024*1024',
-      taskId: 'task-player',
-      prompt: 'player',
-    },
+        imageSrc: '/generated-bark-battle/player.png',
+        assetId: 'asset-player',
+        model: 'gpt-image-2-all',
+        size: '1024*1024',
+        taskId: 'task-player',
+        prompt: 'player',
+      },
       'opponent-character': {
-      imageSrc: '/generated-bark-battle/opponent.png',
-      assetId: 'asset-opponent',
-      model: 'gpt-image-2-all',
-      size: '1024*1024',
-      taskId: 'task-opponent',
-      prompt: 'opponent',
-    },
+        imageSrc: '/generated-bark-battle/opponent.png',
+        assetId: 'asset-opponent',
+        model: 'gpt-image-2-all',
+        size: '1024*1024',
+        taskId: 'task-opponent',
+        prompt: 'opponent',
+      },
       'ui-background': {
-      imageSrc: '/generated-bark-battle/background.png',
-      assetId: 'asset-background',
-      model: 'gpt-image-2-all',
-      size: '1024*1792',
-      taskId: 'task-background',
-      prompt: 'background',
+        imageSrc: '/generated-bark-battle/background.png',
+        assetId: 'asset-background',
+        model: 'gpt-image-2-all',
+        size: '1024*1792',
+        taskId: 'task-background',
+        prompt: 'background',
       },
     },
     failures: {},
   });
-  vi.mocked(updateBarkBattleDraftConfig).mockImplementation(async (payload) => ({
-    draftId: payload.draftId,
-    workId: payload.workId ?? 'bark-battle-work-1',
-    title: payload.title,
-    description: payload.description,
-    themeDescription: payload.themeDescription,
-    playerImageDescription: payload.playerImageDescription,
-    opponentImageDescription: payload.opponentImageDescription,
-    playerCharacterImageSrc: payload.playerCharacterImageSrc,
-    opponentCharacterImageSrc: payload.opponentCharacterImageSrc,
-    uiBackgroundImageSrc: payload.uiBackgroundImageSrc,
-    difficultyPreset: payload.difficultyPreset,
-    configVersion: (payload.configVersion ?? 1) + 1,
-    rulesetVersion: payload.rulesetVersion ?? 'bark-battle-ruleset-v1',
-    updatedAt: '2026-05-14T10:01:00.000Z',
-  }));
+  vi.mocked(updateBarkBattleDraftConfig).mockImplementation(
+    async (payload) => ({
+      draftId: payload.draftId,
+      workId: payload.workId ?? 'bark-battle-work-1',
+      title: payload.title,
+      description: payload.description,
+      themeDescription: payload.themeDescription,
+      playerImageDescription: payload.playerImageDescription,
+      opponentImageDescription: payload.opponentImageDescription,
+      playerCharacterImageSrc: payload.playerCharacterImageSrc,
+      opponentCharacterImageSrc: payload.opponentCharacterImageSrc,
+      uiBackgroundImageSrc: payload.uiBackgroundImageSrc,
+      difficultyPreset: payload.difficultyPreset,
+      configVersion: (payload.configVersion ?? 1) + 1,
+      rulesetVersion: payload.rulesetVersion ?? 'bark-battle-ruleset-v1',
+      updatedAt: '2026-05-14T10:01:00.000Z',
+    }),
+  );
   vi.mocked(listBarkBattleWorks).mockResolvedValue({ items: [] });
   vi.mocked(listBarkBattleGallery).mockResolvedValue({ items: [] });
   vi.mocked(publishBarkBattleWork).mockResolvedValue({
@@ -3102,31 +3117,33 @@ beforeEach(() => {
   vi.mocked(listPuzzleWorks).mockResolvedValue({
     items: [],
   });
-  vi.mocked(updatePuzzleWork).mockImplementation(async (profileId, payload) => ({
-    item: {
-      workId: `puzzle-work-${profileId}`,
-      profileId,
-      ownerUserId: mockAuthUser.id,
-      sourceSessionId: null,
-      authorDisplayName: mockAuthUser.displayName,
-      workTitle: payload.workTitle ?? payload.levelName,
-      workDescription: payload.workDescription ?? payload.summary,
-      levelName: payload.levelName,
-      summary: payload.summary,
-      themeTags: payload.themeTags,
-      coverImageSrc: payload.coverImageSrc ?? null,
-      coverAssetId: payload.coverAssetId ?? null,
-      publicationStatus: 'draft',
-      updatedAt: '2026-05-12T10:00:00.000Z',
-      publishedAt: null,
-      playCount: 0,
-      remixCount: 0,
-      likeCount: 0,
-      publishReady: false,
-      levels: payload.levels,
-      anchorPack: buildPuzzleAnchorPack(),
-    },
-  }));
+  vi.mocked(updatePuzzleWork).mockImplementation(
+    async (profileId, payload) => ({
+      item: {
+        workId: `puzzle-work-${profileId}`,
+        profileId,
+        ownerUserId: mockAuthUser.id,
+        sourceSessionId: null,
+        authorDisplayName: mockAuthUser.displayName,
+        workTitle: payload.workTitle ?? payload.levelName,
+        workDescription: payload.workDescription ?? payload.summary,
+        levelName: payload.levelName,
+        summary: payload.summary,
+        themeTags: payload.themeTags,
+        coverImageSrc: payload.coverImageSrc ?? null,
+        coverAssetId: payload.coverAssetId ?? null,
+        publicationStatus: 'draft',
+        updatedAt: '2026-05-12T10:00:00.000Z',
+        publishedAt: null,
+        playCount: 0,
+        remixCount: 0,
+        likeCount: 0,
+        publishReady: false,
+        levels: payload.levels,
+        anchorPack: buildPuzzleAnchorPack(),
+      },
+    }),
+  );
   vi.mocked(listPuzzleGallery).mockResolvedValue({
     items: [],
   });
@@ -3265,12 +3282,17 @@ beforeEach(() => {
     const runId = `local-puzzle-run-${item.profileId}`;
     const firstLevel = item.levels?.[0] ?? null;
     return {
-      ...buildMockPuzzleRun(item.profileId, firstLevel?.levelName ?? item.levelName),
+      ...buildMockPuzzleRun(
+        item.profileId,
+        firstLevel?.levelName ?? item.levelName,
+      ),
       runId,
       entryProfileId: item.profileId,
       currentLevel: {
-        ...buildMockPuzzleRun(item.profileId, firstLevel?.levelName ?? item.levelName)
-          .currentLevel!,
+        ...buildMockPuzzleRun(
+          item.profileId,
+          firstLevel?.levelName ?? item.levelName,
+        ).currentLevel!,
         runId,
         levelId: levelId ?? firstLevel?.levelId ?? null,
         coverImageSrc: firstLevel?.coverImageSrc ?? item.coverImageSrc,
@@ -3404,30 +3426,16 @@ test('create tab shows template tabs and embeds puzzle form by default', async (
   expect(screen.getByRole('tablist', { name: '玩法模�分类' })).toBeTruthy();
   expect(
     screen.getByRole('tablist', { name: '玩法模�分类' }).className,
-  ).toContain(
-    'scroll-px-3',
-  );
+  ).toContain('scroll-px-3');
   expect(
     screen.getByRole('tab', { name: '最近创作' }).getAttribute('aria-selected'),
   ).toBe('true');
-  expect(
-    await findCreationTypeButton('拼图'),
-  ).toBeTruthy();
-  expect(
-    await findCreationTypeButton('文字冒险'),
-  ).toBeTruthy();
-  expect(
-    await findCreationTypeButton('抓大鹅'),
-  ).toBeTruthy();
-  expect(
-    await findCreationTypeButton('汪汪声浪'),
-  ).toBeTruthy();
-  expect(
-    await findCreationTypeButton('��识物'),
-  ).toBeTruthy();
-  expect(
-    queryCreationTypeButton('智能创作'),
-  ).toBeNull();
+  expect(await findCreationTypeButton('拼图')).toBeTruthy();
+  expect(await findCreationTypeButton('文字冒险')).toBeTruthy();
+  expect(await findCreationTypeButton('抓大鹅')).toBeTruthy();
+  expect(await findCreationTypeButton('汪汪声浪')).toBeTruthy();
+  expect(await findCreationTypeButton('��识物')).toBeTruthy();
+  expect(queryCreationTypeButton('智能创作')).toBeNull();
   expect(
     screen
       .getByRole('tab', { name: '最近创作' })
@@ -3566,8 +3574,6 @@ test('direct bark battle runtime public code opens published runtime', async ()
   expect(screen.queryByText('分享给朋�')).toBeNull();
 });
 
-
-
 test('bark battle form checks mud points before creating image assets', async () => {
   const user = userEvent.setup();
   vi.mocked(getProfileDashboard).mockResolvedValue({
@@ -3673,7 +3679,9 @@ test('published bark battle stays visible when refresh temporarily returns only
   await user.click(within(panel).getByRole('button', { name: /已�布/u }));
 
   expect(await within(panel).findByText('汪汪测试�')).toBeTruthy();
-  expect(within(panel).getByRole('button', { name: /查看详情《汪汪测试�》/u })).toBeTruthy();
+  expect(
+    within(panel).getByRole('button', { name: /查看详情《汪汪测试�》/u }),
+  ).toBeTruthy();
 });
 
 test('running match3d form generation can return to draft tab and reopen progress', async () => {
@@ -3786,9 +3794,9 @@ test('running match3d persisted draft reopens progress instead of unfinished res
     await screen.findByRole('button', { name: '生�抓大鹅�稿' }),
   );
   expect(await screen.findByText('抓大鹅�稿生�进度')).toBeTruthy();
-  expect(
-    await screen.findAllByText('素�生��在��处�'),
-  ).not.toHaveLength(0);
+  expect(await screen.findAllByText('素�生��在��处�')).not.toHaveLength(
+    0,
+  );
   vi.mocked(match3dCreationClient.getSession).mockClear();
 
   await user.click(screen.getByRole('button', { name: '返回创作中心' }));
@@ -4437,8 +4445,7 @@ test('match3d result trial passes generated 2D image views into first runtime mo
       imageViews: [1, 2, 3, 4, 5].map((viewIndex) => ({
         viewId: `view-${String(viewIndex).padStart(2, '0')}`,
         viewIndex,
-        imageSrc:
-          `/generated-match3d-assets/session/profile/items/match3d-item-1-item/views/view-${String(viewIndex).padStart(2, '0')}.png`,
+        imageSrc: `/generated-match3d-assets/session/profile/items/match3d-item-1-item/views/view-${String(viewIndex).padStart(2, '0')}.png`,
         imageObjectKey: null,
       })),
       modelSrc: null,
@@ -4953,9 +4960,9 @@ test('completed baby object match draft viewed immediately does not keep unread
   await user.click(screen.getByRole('tab', { name: '��识物' }));
   await waitFor(() => {
     expect(
-      screen.getByRole('tab', { name: '��识物' }).getAttribute(
-        'aria-selected',
-      ),
+      screen
+        .getByRole('tab', { name: '��识物' })
+        .getAttribute('aria-selected'),
     ).toBe('true');
   });
   await user.type(await screen.findByLabelText('物� A'), '苹果');
@@ -5106,7 +5113,8 @@ test('puzzle draft generation auto starts trial and runtime back opens draft res
   render(<TestWrapper withAuth />);
 
   await openCreateTemplateHub(user);
-  await user.click(screen.getByRole('button', { name: '生��稿' }));
+  await user.click(await findCreationTypeButton('拼图'));
+  await user.click(await screen.findByRole('button', { name: '生��稿' }));
 
   await waitFor(() => {
     expect(updatePuzzleWork).toHaveBeenCalledWith(
@@ -5144,10 +5152,14 @@ test('puzzle draft generation auto starts trial and runtime back opens draft res
     '/generated-puzzle-assets/puzzle-session-auto-1/ui/background.png',
   );
   expect(screen.queryByText('拼图结果页')).toBeNull();
+  await waitFor(() => {
+    expect(window.location.pathname).toBe('/runtime/puzzle');
+    expect(window.location.search).toBe(
+      '?runtimeProfileId=puzzle-profile-auto-1&runtimeSessionId=puzzle-session-auto-1&mode=draft',
+    );
+  });
 
-  await user.click(
-    await screen.findByRole('button', { name: '返回上一页' }),
-  );
+  await user.click(await screen.findByRole('button', { name: '返回上一页' }));
 
   expect(await screen.findByText('拼图结果页')).toBeTruthy();
   expect(screen.getByDisplayValue('雨夜猫街')).toBeTruthy();
@@ -6277,10 +6289,9 @@ test('home recommendation Match3D runtime keeps image, music and UI assets witho
   expect(
     screen.getByTestId('match3d-runtime-background-music-count'),
   ).toHaveProperty('textContent', '1');
-  expect(screen.getByTestId('match3d-runtime-container-ui-count')).toHaveProperty(
-    'textContent',
-    '1',
-  );
+  expect(
+    screen.getByTestId('match3d-runtime-container-ui-count'),
+  ).toHaveProperty('textContent', '1');
   expect(
     screen.getByTestId('match3d-runtime-top-level-background-count'),
   ).toHaveProperty('textContent', '1');
@@ -6931,6 +6942,68 @@ test('persisted generating puzzle draft opens generation progress after refresh'
   expect(screen.queryByText('拼图结果页')).toBeNull();
 });
 
+test('persisted generating puzzle draft keeps session polling on the same session', async () => {
+  const user = userEvent.setup();
+
+  vi.mocked(listPuzzleWorks).mockResolvedValue({
+    items: [
+      {
+        workId: 'puzzle-work-session-generating',
+        profileId: 'puzzle-profile-session-generating',
+        ownerUserId: 'user-1',
+        sourceSessionId: 'puzzle-session-generating',
+        authorDisplayName: '测试玩家',
+        workTitle: '生�中拼图',
+        workDescription: '刷新��应回到生���。',
+        levelName: '生�中拼图',
+        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: 'generating',
+      },
+    ],
+  });
+  const persistedGeneratingPuzzleSession = buildMockPuzzleAgentSession({
+    sessionId: 'puzzle-session-generating',
+    stage: 'collecting_anchors',
+    progressPercent: 88,
+    lastAssistantReply: '正在生�拼图�稿。',
+    updatedAt: '2026-05-18T12:00:00.000Z',
+  });
+  vi.mocked(getPuzzleAgentSession).mockResolvedValue({
+    session: persistedGeneratingPuzzleSession,
+  });
+
+  render(<TestWrapper withAuth />);
+
+  await openDraftHub(user);
+  await user.click(await screen.findByRole('button', { name: /继续创作/u }));
+
+  await waitFor(() => {
+    expect(getPuzzleAgentSession).toHaveBeenCalledTimes(2);
+  });
+
+  expect(
+    await screen.findByRole('progressbar', {
+      name: '拼图�稿生�进度',
+    }),
+  ).toBeTruthy();
+
+  await act(async () => {
+    await new Promise((resolve) => window.setTimeout(resolve, 120));
+  });
+
+  expect(getPuzzleAgentSession).toHaveBeenCalledTimes(2);
+});
+
 test('published puzzle work card restores its source session for editing', async () => {
   const user = userEvent.setup();
 
@@ -7631,11 +7704,7 @@ test('missing puzzle public detail returns to platform home', async () => {
 test('direct missing public work detail alert returns to platform home', async () => {
   const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => {});
 
-  window.history.replaceState(
-    null,
-    '',
-    '/works/detail?work=PZ-7A7B18D9',
-  );
+  window.history.replaceState(null, '', '/works/detail?work=PZ-7A7B18D9');
   vi.mocked(listPuzzleGallery).mockResolvedValue({
     items: [],
   });
@@ -8521,7 +8590,9 @@ test('agent draft result test button enters the opened draft profile instead of
       name: /继续完善《星砂废都》/u,
     }),
   );
-  expect(await screen.findByText('世界档案', {}, { timeout: 5000 })).toBeTruthy();
+  expect(
+    await screen.findByText('世界档案', {}, { timeout: 5000 }),
+  ).toBeTruthy();
   expect(screen.getByText('星砂废都')).toBeTruthy();
 
   await user.click(
@@ -8656,7 +8727,9 @@ test('agent draft result start button enters the opened published draft profile
       name: /继续完善《星砂废都》/u,
     }),
   );
-  expect(await screen.findByText('世界档案', {}, { timeout: 5000 })).toBeTruthy();
+  expect(
+    await screen.findByText('世界档案', {}, { timeout: 5000 }),
+  ).toBeTruthy();
   expect(screen.getByText('星砂废都')).toBeTruthy();
 
   await user.click(
@@ -8976,9 +9049,7 @@ test('agent draft result back button returns to creation hub without syncing res
   await user.click(screen.getByRole('button', { name: /返回创作/u }));
 
   await waitFor(() => {
-    expect(
-      screen.getByRole('tablist', { name: '玩法模�分类' }),
-    ).toBeTruthy();
+    expect(screen.getByRole('tablist', { name: '玩法模�分类' })).toBeTruthy();
   });
 
   expect(
@@ -9416,8 +9487,12 @@ test('profile page exposes save archive picker as a direct entry', async () => {
   render(<TestWrapper withAuth onContinueGame={handleContinueGame} />);
 
   await clickFirstButtonByName(user, '我的');
-  const shortcutRegion = await screen.findByRole('region', { name: '常用功能' });
-  await user.click(within(shortcutRegion).getByRole('button', { name: /存档/u }));
+  const shortcutRegion = await screen.findByRole('region', {
+    name: '常用功能',
+  });
+  await user.click(
+    within(shortcutRegion).getByRole('button', { name: /存档/u }),
+  );
 
   const closeButton = await screen.findByLabelText('关闭存档');
   const modal = closeButton.closest('.fixed') as HTMLElement;
@@ -9977,7 +10052,9 @@ test('creation hub published work edit keeps loaded detail profile assets instea
   });
   await user.click(await screen.findByRole('button', { name: '作�编辑' }));
 
-  expect(await screen.findByText('世界档案', {}, { timeout: 5000 })).toBeTruthy();
+  expect(
+    await screen.findByText('世界档案', {}, { timeout: 5000 }),
+  ).toBeTruthy();
   expect(
     document.querySelector('video[src="/assets/custom-world/opening.mp4"]'),
   ).toBeTruthy();
diff --git a/src/routing/appPageRoutes.test.ts b/src/routing/appPageRoutes.test.ts
index 39d38ae9..f80c8028 100644
--- a/src/routing/appPageRoutes.test.ts
+++ b/src/routing/appPageRoutes.test.ts
@@ -1,6 +1,9 @@
+/* @vitest-environment jsdom */
+
 import { describe, expect, it } from 'vitest';
 
 import {
+  pushAppHistoryPath,
   resolvePathForSelectionStage,
   resolveSelectionStageFromPath,
 } from './appPageRoutes';
@@ -117,4 +120,43 @@ describe('appPageRoutes', () => {
       '/creation/baby-object-match',
     );
   });
+
+  it('preserves creation restore query params within the same creation flow', () => {
+    window.history.replaceState(
+      null,
+      '',
+      '/creation/rpg?sessionId=session-1&profileId=profile-1&draftId=draft-1&workId=work-1&clientRuntime=wechat_mini_program',
+    );
+
+    pushAppHistoryPath('/creation/rpg/result');
+
+    expect(window.location.pathname).toBe('/creation/rpg/result');
+    expect(window.location.search).toBe(
+      '?sessionId=session-1&profileId=profile-1&draftId=draft-1&workId=work-1',
+    );
+  });
+
+  it('clears creation restore query params when leaving the flow or switching flows', () => {
+    window.history.replaceState(
+      null,
+      '',
+      '/creation/rpg?sessionId=session-1&profileId=profile-1',
+    );
+
+    pushAppHistoryPath('/creation/puzzle');
+
+    expect(window.location.pathname).toBe('/creation/puzzle');
+    expect(window.location.search).toBe('');
+
+    window.history.replaceState(
+      null,
+      '',
+      '/creation/rpg?sessionId=session-2&profileId=profile-2',
+    );
+
+    pushAppHistoryPath('/');
+
+    expect(window.location.pathname).toBe('/');
+    expect(window.location.search).toBe('');
+  });
 });
diff --git a/src/routing/appPageRoutes.ts b/src/routing/appPageRoutes.ts
index 48f1da96..19750566 100644
--- a/src/routing/appPageRoutes.ts
+++ b/src/routing/appPageRoutes.ts
@@ -1,4 +1,9 @@
 import type { SelectionStage } from '../components/platform-entry';
+import {
+  buildCreationUrlSearchFromParams,
+  isCreationRestorePath,
+  isSameCreationFlowPath,
+} from '../services/creationUrlState';
 
 export type RuntimePageRoute = 'rpg-character-select' | 'rpg-adventure';
 
@@ -130,7 +135,14 @@ export function isKnownMainAppPagePath(pathname: string) {
 export function pushAppHistoryPath(path: string) {
   const nextUrl = new URL(path, window.location.origin);
   const normalizedPath = normalizeAppPath(nextUrl.pathname);
-  const nextRelativeUrl = `${normalizedPath}${nextUrl.search}`;
+  const nextSearch =
+    nextUrl.search ||
+    buildPreservedAppSearch(
+      window.location.pathname,
+      normalizedPath,
+      window.location.search,
+    );
+  const nextRelativeUrl = `${normalizedPath}${nextSearch}`;
   const currentRelativeUrl = `${normalizeAppPath(window.location.pathname)}${window.location.search}`;
   if (currentRelativeUrl === nextRelativeUrl) {
     return;
@@ -139,3 +151,18 @@ export function pushAppHistoryPath(path: string) {
   // 页�阶段�化是用户�感知导航，写入 history 以支��进�退。
   window.history.pushState(null, '', nextRelativeUrl);
 }
+
+function buildPreservedAppSearch(
+  currentPathname: string,
+  normalizedPath: string,
+  search: string,
+) {
+  if (
+    !isCreationRestorePath(normalizedPath) ||
+    !isSameCreationFlowPath(currentPathname, normalizedPath)
+  ) {
+    return '';
+  }
+
+  return buildCreationUrlSearchFromParams(search);
+}
diff --git a/src/services/creationUrlState.test.ts b/src/services/creationUrlState.test.ts
new file mode 100644
index 00000000..ab905599
--- /dev/null
+++ b/src/services/creationUrlState.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  clearCreationUrlState,
+  readCreationUrlState,
+  writeCreationUrlState,
+} from './creationUrlState';
+
+describe('creationUrlState', () => {
+  it('writes and reads restore state on creation restore paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/creation/puzzle/result',
+        search: '?clientRuntime=wechat_mini_program',
+      },
+      history: { replaceState },
+    };
+
+    writeCreationUrlState(
+      {
+        sessionId: ' session-1 ',
+        profileId: 'profile-1',
+        draftId: 'draft-1',
+        workId: 'work-1',
+      },
+      env,
+    );
+
+    expect(replaceState).toHaveBeenCalledWith(
+      null,
+      '',
+      '/creation/puzzle/result?clientRuntime=wechat_mini_program&sessionId=session-1&profileId=profile-1&draftId=draft-1&workId=work-1',
+    );
+    expect(
+      readCreationUrlState({
+        location: {
+          pathname: '/creation/puzzle/result',
+          search:
+            '?sessionId=session-1&profileId=profile-1&draftId=draft-1&workId=work-1',
+        },
+      }),
+    ).toEqual({
+      sessionId: 'session-1',
+      profileId: 'profile-1',
+      draftId: 'draft-1',
+      workId: 'work-1',
+    });
+  });
+
+  it('ignores writes and clears outside creation restore paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/works/detail',
+        search: '?work=PZ-123&sessionId=session-1',
+      },
+      history: { replaceState },
+    };
+
+    writeCreationUrlState({ sessionId: 'session-2' }, env);
+    clearCreationUrlState(env);
+
+    expect(replaceState).not.toHaveBeenCalled();
+  });
+
+  it('clears only private restore params on creation restore paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/creation/bark-battle/result',
+        search: '?draftId=draft-1&workId=work-1&clientRuntime=wechat',
+      },
+      history: { replaceState },
+    };
+
+    clearCreationUrlState(env);
+
+    expect(replaceState).toHaveBeenCalledWith(
+      null,
+      '',
+      '/creation/bark-battle/result?clientRuntime=wechat',
+    );
+  });
+});
diff --git a/src/services/creationUrlState.ts b/src/services/creationUrlState.ts
new file mode 100644
index 00000000..6bc42735
--- /dev/null
+++ b/src/services/creationUrlState.ts
@@ -0,0 +1,220 @@
+import {
+  CUSTOM_WORLD_AGENT_OPERATION_QUERY_KEY,
+  CUSTOM_WORLD_AGENT_SESSION_QUERY_KEY,
+  CUSTOM_WORLD_GENERATION_SOURCE_QUERY_KEY,
+} from './customWorldAgentUiState';
+
+export const CREATION_URL_SESSION_QUERY_KEY = 'sessionId';
+export const CREATION_URL_PROFILE_QUERY_KEY = 'profileId';
+export const CREATION_URL_DRAFT_QUERY_KEY = 'draftId';
+export const CREATION_URL_WORK_QUERY_KEY = 'workId';
+
+export const CREATION_URL_RESTORE_QUERY_KEYS = [
+  CUSTOM_WORLD_AGENT_SESSION_QUERY_KEY,
+  CUSTOM_WORLD_AGENT_OPERATION_QUERY_KEY,
+  CUSTOM_WORLD_GENERATION_SOURCE_QUERY_KEY,
+  CREATION_URL_SESSION_QUERY_KEY,
+  CREATION_URL_PROFILE_QUERY_KEY,
+  CREATION_URL_DRAFT_QUERY_KEY,
+  CREATION_URL_WORK_QUERY_KEY,
+] as const;
+
+export type CreationUrlState = {
+  sessionId?: string | null;
+  profileId?: string | null;
+  draftId?: string | null;
+  workId?: string | null;
+};
+
+type CreationUrlEnvironment = {
+  location?: {
+    pathname: string;
+    search: string;
+  } | null;
+  history?: {
+    replaceState: (
+      data: unknown,
+      unused: string,
+      url?: string | URL | null,
+    ) => void;
+  } | null;
+};
+
+const CREATION_PATH_PREFIXES = [
+  '/creation/rpg',
+  '/creation/big-fish',
+  '/creation/match3d',
+  '/creation/square-hole',
+  '/creation/jump-hop',
+  '/creation/wooden-fish',
+  '/creation/bark-battle',
+  '/creation/visual-novel',
+  '/creation/baby-object-match',
+  '/creation/puzzle',
+] as const;
+
+function resolveEnvironment(
+  env?: CreationUrlEnvironment,
+): Required<CreationUrlEnvironment> {
+  if (env) {
+    return {
+      location: env.location ?? null,
+      history: env.history ?? null,
+    };
+  }
+
+  if (typeof window === 'undefined') {
+    return {
+      location: null,
+      history: null,
+    };
+  }
+
+  return {
+    location: window.location,
+    history: window.history,
+  };
+}
+
+function normalizeValue(value: unknown) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizePathname(value: string | undefined) {
+  const pathname = value?.trim().toLowerCase() ?? '';
+  if (!pathname || pathname === '/') {
+    return '/';
+  }
+
+  return pathname.replace(/\/+$/u, '');
+}
+
+export function isCreationRestorePath(pathname: string | undefined) {
+  const normalizedPathname = normalizePathname(pathname);
+  return CREATION_PATH_PREFIXES.some(
+    (pathPrefix) =>
+      normalizedPathname === pathPrefix ||
+      normalizedPathname.startsWith(`${pathPrefix}/`),
+  );
+}
+
+export function isSameCreationFlowPath(
+  currentPathname: string | undefined,
+  nextPathname: string | undefined,
+) {
+  const normalizedCurrentPath = normalizePathname(currentPathname);
+  const normalizedNextPath = normalizePathname(nextPathname);
+  if (
+    !normalizedCurrentPath ||
+    !normalizedNextPath ||
+    normalizedCurrentPath === '/' ||
+    normalizedNextPath === '/'
+  ) {
+    return false;
+  }
+
+  const currentCreationPrefix = CREATION_PATH_PREFIXES.find((pathPrefix) =>
+    normalizedCurrentPath === pathPrefix ||
+    normalizedCurrentPath.startsWith(`${pathPrefix}/`),
+  );
+  const nextCreationPrefix = CREATION_PATH_PREFIXES.find((pathPrefix) =>
+    normalizedNextPath === pathPrefix ||
+    normalizedNextPath.startsWith(`${pathPrefix}/`),
+  );
+  return Boolean(
+    currentCreationPrefix &&
+      nextCreationPrefix &&
+      currentCreationPrefix === nextCreationPrefix,
+  );
+}
+
+export function buildCreationUrlSearchFromParams(search: string) {
+  const params = new URLSearchParams(search);
+  const preservedParams = new URLSearchParams();
+
+  CREATION_URL_RESTORE_QUERY_KEYS.forEach((key) => {
+    const value = normalizeValue(params.get(key));
+    if (value) {
+      preservedParams.set(key, value);
+    }
+  });
+
+  const queryString = preservedParams.toString();
+  return queryString ? `?${queryString}` : '';
+}
+
+export function readCreationUrlState(
+  env?: CreationUrlEnvironment,
+): CreationUrlState {
+  const resolved = resolveEnvironment(env);
+  const params = new URLSearchParams(resolved.location?.search ?? '');
+
+  return {
+    sessionId: normalizeValue(params.get(CREATION_URL_SESSION_QUERY_KEY)),
+    profileId: normalizeValue(params.get(CREATION_URL_PROFILE_QUERY_KEY)),
+    draftId: normalizeValue(params.get(CREATION_URL_DRAFT_QUERY_KEY)),
+    workId: normalizeValue(params.get(CREATION_URL_WORK_QUERY_KEY)),
+  };
+}
+
+export function writeCreationUrlState(
+  state: CreationUrlState,
+  env?: CreationUrlEnvironment,
+) {
+  const resolved = resolveEnvironment(env);
+  if (
+    !resolved.location ||
+    !resolved.history?.replaceState ||
+    !isCreationRestorePath(resolved.location.pathname)
+  ) {
+    return;
+  }
+
+  const params = new URLSearchParams(resolved.location.search);
+  const entries = [
+    [CREATION_URL_SESSION_QUERY_KEY, state.sessionId],
+    [CREATION_URL_PROFILE_QUERY_KEY, state.profileId],
+    [CREATION_URL_DRAFT_QUERY_KEY, state.draftId],
+    [CREATION_URL_WORK_QUERY_KEY, state.workId],
+  ] as const;
+
+  entries.forEach(([key, rawValue]) => {
+    const value = normalizeValue(rawValue);
+    if (value) {
+      params.set(key, value);
+    } else {
+      params.delete(key);
+    }
+  });
+
+  const search = params.toString();
+  const nextUrl = search
+    ? `${resolved.location.pathname}?${search}`
+    : resolved.location.pathname;
+  resolved.history.replaceState(null, '', nextUrl);
+}
+
+export function clearCreationUrlState(env?: CreationUrlEnvironment) {
+  const resolved = resolveEnvironment(env);
+  if (
+    !resolved.location ||
+    !resolved.history?.replaceState ||
+    !isCreationRestorePath(resolved.location.pathname)
+  ) {
+    return;
+  }
+
+  const params = new URLSearchParams(resolved.location.search);
+  [
+    CREATION_URL_SESSION_QUERY_KEY,
+    CREATION_URL_PROFILE_QUERY_KEY,
+    CREATION_URL_DRAFT_QUERY_KEY,
+    CREATION_URL_WORK_QUERY_KEY,
+  ].forEach((key) => params.delete(key));
+
+  const search = params.toString();
+  const nextUrl = search
+    ? `${resolved.location.pathname}?${search}`
+    : resolved.location.pathname;
+  resolved.history.replaceState(null, '', nextUrl);
+}
diff --git a/src/services/puzzleRuntimeUrlState.test.ts b/src/services/puzzleRuntimeUrlState.test.ts
new file mode 100644
index 00000000..2cb7aa70
--- /dev/null
+++ b/src/services/puzzleRuntimeUrlState.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  clearPuzzleRuntimeUrlState,
+  readPuzzleRuntimeUrlState,
+  writePuzzleRuntimeUrlState,
+} from './puzzleRuntimeUrlState';
+
+describe('puzzleRuntimeUrlState', () => {
+  it('writes puzzle runtime identity on runtime paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/runtime/puzzle',
+        search: '?clientRuntime=wechat_mini_program',
+      },
+      history: { replaceState },
+    };
+
+    writePuzzleRuntimeUrlState(
+      {
+        runtimeSessionId: 'puzzle-session-1',
+        runtimeProfileId: 'puzzle-profile-1',
+        runtimeLevelId: 'puzzle-level-2',
+        publicWorkCode: 'PZ-12345678',
+        mode: 'draft',
+      },
+      env,
+    );
+
+    expect(replaceState).toHaveBeenCalledWith(
+      null,
+      '',
+      '/runtime/puzzle?clientRuntime=wechat_mini_program&runtimeProfileId=puzzle-profile-1&runtimeSessionId=puzzle-session-1&runtimeLevelId=puzzle-level-2&work=PZ-12345678&mode=draft',
+    );
+    expect(
+      readPuzzleRuntimeUrlState({
+        location: {
+          pathname: '/runtime/puzzle',
+          search:
+            '?runtimeProfileId=puzzle-profile-1&runtimeSessionId=puzzle-session-1&runtimeLevelId=puzzle-level-2&work=PZ-12345678&mode=draft',
+        },
+      }),
+    ).toEqual({
+      runtimeProfileId: 'puzzle-profile-1',
+      runtimeSessionId: 'puzzle-session-1',
+      runtimeLevelId: 'puzzle-level-2',
+      publicWorkCode: 'PZ-12345678',
+      mode: 'draft',
+    });
+  });
+
+  it('ignores writes outside puzzle runtime paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/creation/puzzle/result',
+        search: '?sessionId=puzzle-session-1',
+      },
+      history: { replaceState },
+    };
+
+    writePuzzleRuntimeUrlState({ runtimeSessionId: 'puzzle-session-2' }, env);
+
+    expect(replaceState).not.toHaveBeenCalled();
+  });
+
+  it('can write runtime state to an explicit puzzle runtime pathname', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/creation/puzzle/result',
+        search: '?clientRuntime=wechat_mini_program',
+      },
+      history: { replaceState },
+    };
+
+    writePuzzleRuntimeUrlState(
+      {
+        runtimeProfileId: 'puzzle-profile-1',
+        mode: 'published',
+        publicWorkCode: 'PZ-12345678',
+      },
+      env,
+      { pathname: '/runtime/puzzle' },
+    );
+
+    expect(replaceState).toHaveBeenCalledWith(
+      null,
+      '',
+      '/runtime/puzzle?clientRuntime=wechat_mini_program&runtimeProfileId=puzzle-profile-1&work=PZ-12345678&mode=published',
+    );
+  });
+
+  it('clears only puzzle runtime restore params on runtime paths', () => {
+    const replaceState = vi.fn();
+    const env = {
+      location: {
+        pathname: '/runtime/puzzle',
+        search:
+          '?runtimeSessionId=puzzle-session-1&runtimeProfileId=puzzle-profile-1&runtimeLevelId=puzzle-level-1&work=PZ-12345678&mode=draft&clientRuntime=wechat',
+      },
+      history: { replaceState },
+    };
+
+    clearPuzzleRuntimeUrlState(env);
+
+    expect(replaceState).toHaveBeenCalledWith(
+      null,
+      '',
+      '/runtime/puzzle?clientRuntime=wechat',
+    );
+  });
+});
diff --git a/src/services/puzzleRuntimeUrlState.ts b/src/services/puzzleRuntimeUrlState.ts
new file mode 100644
index 00000000..d61c9e86
--- /dev/null
+++ b/src/services/puzzleRuntimeUrlState.ts
@@ -0,0 +1,155 @@
+export const PUZZLE_RUNTIME_WORK_QUERY_KEY = 'work';
+export const PUZZLE_RUNTIME_PROFILE_QUERY_KEY = 'runtimeProfileId';
+export const PUZZLE_RUNTIME_SESSION_QUERY_KEY = 'runtimeSessionId';
+export const PUZZLE_RUNTIME_LEVEL_QUERY_KEY = 'runtimeLevelId';
+export const PUZZLE_RUNTIME_MODE_QUERY_KEY = 'mode';
+
+export type PuzzleRuntimeUrlMode = 'draft' | 'published';
+
+export type PuzzleRuntimeUrlState = {
+  runtimeProfileId?: string | null;
+  runtimeSessionId?: string | null;
+  runtimeLevelId?: string | null;
+  publicWorkCode?: string | null;
+  mode?: PuzzleRuntimeUrlMode | null;
+};
+
+type PuzzleRuntimeUrlEnvironment = {
+  location?: {
+    pathname: string;
+    search: string;
+  } | null;
+  history?: {
+    replaceState: (
+      data: unknown,
+      unused: string,
+      url?: string | URL | null,
+    ) => void;
+  } | null;
+};
+
+type WritePuzzleRuntimeUrlOptions = {
+  pathname?: string;
+};
+
+function resolveEnvironment(
+  env?: PuzzleRuntimeUrlEnvironment,
+): Required<PuzzleRuntimeUrlEnvironment> {
+  if (env) {
+    return {
+      location: env.location ?? null,
+      history: env.history ?? null,
+    };
+  }
+
+  if (typeof window === 'undefined') {
+    return {
+      location: null,
+      history: null,
+    };
+  }
+
+  return {
+    location: window.location,
+    history: window.history,
+  };
+}
+
+function normalizeValue(value: unknown) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizeRuntimeMode(value: unknown): PuzzleRuntimeUrlMode | null {
+  const normalized = normalizeValue(value);
+  return normalized === 'draft' || normalized === 'published'
+    ? normalized
+    : null;
+}
+
+function isPuzzleRuntimePath(pathname: string | undefined) {
+  return pathname?.trim().toLowerCase().replace(/\/+$/u, '') === '/runtime/puzzle';
+}
+
+export function readPuzzleRuntimeUrlState(
+  env?: PuzzleRuntimeUrlEnvironment,
+): PuzzleRuntimeUrlState {
+  const resolved = resolveEnvironment(env);
+  const params = new URLSearchParams(resolved.location?.search ?? '');
+
+  return {
+    runtimeProfileId: normalizeValue(
+      params.get(PUZZLE_RUNTIME_PROFILE_QUERY_KEY),
+    ),
+    runtimeSessionId: normalizeValue(
+      params.get(PUZZLE_RUNTIME_SESSION_QUERY_KEY),
+    ),
+    runtimeLevelId: normalizeValue(params.get(PUZZLE_RUNTIME_LEVEL_QUERY_KEY)),
+    publicWorkCode: normalizeValue(params.get(PUZZLE_RUNTIME_WORK_QUERY_KEY)),
+    mode: normalizeRuntimeMode(params.get(PUZZLE_RUNTIME_MODE_QUERY_KEY)),
+  };
+}
+
+export function writePuzzleRuntimeUrlState(
+  state: PuzzleRuntimeUrlState,
+  env?: PuzzleRuntimeUrlEnvironment,
+  options: WritePuzzleRuntimeUrlOptions = {},
+) {
+  const resolved = resolveEnvironment(env);
+  const pathname = options.pathname ?? resolved.location?.pathname;
+  if (
+    !resolved.location ||
+    !resolved.history?.replaceState ||
+    !isPuzzleRuntimePath(pathname)
+  ) {
+    return;
+  }
+
+  const params = new URLSearchParams(resolved.location.search);
+  const entries = [
+    [PUZZLE_RUNTIME_PROFILE_QUERY_KEY, state.runtimeProfileId],
+    [PUZZLE_RUNTIME_SESSION_QUERY_KEY, state.runtimeSessionId],
+    [PUZZLE_RUNTIME_LEVEL_QUERY_KEY, state.runtimeLevelId],
+    [PUZZLE_RUNTIME_WORK_QUERY_KEY, state.publicWorkCode],
+    [PUZZLE_RUNTIME_MODE_QUERY_KEY, state.mode],
+  ] as const;
+
+  entries.forEach(([key, rawValue]) => {
+    const value = normalizeValue(rawValue);
+    if (value) {
+      params.set(key, value);
+    } else {
+      params.delete(key);
+    }
+  });
+
+  const search = params.toString();
+  const nextPathname = pathname ?? resolved.location.pathname;
+  const nextUrl = search ? `${nextPathname}?${search}` : nextPathname;
+  resolved.history.replaceState(null, '', nextUrl);
+}
+
+export function clearPuzzleRuntimeUrlState(env?: PuzzleRuntimeUrlEnvironment) {
+  const resolved = resolveEnvironment(env);
+  if (
+    !resolved.location ||
+    !resolved.history?.replaceState ||
+    !isPuzzleRuntimePath(resolved.location.pathname)
+  ) {
+    return;
+  }
+
+  const params = new URLSearchParams(resolved.location.search);
+  [
+    PUZZLE_RUNTIME_PROFILE_QUERY_KEY,
+    PUZZLE_RUNTIME_SESSION_QUERY_KEY,
+    PUZZLE_RUNTIME_LEVEL_QUERY_KEY,
+    PUZZLE_RUNTIME_WORK_QUERY_KEY,
+    PUZZLE_RUNTIME_MODE_QUERY_KEY,
+  ].forEach((key) => params.delete(key));
+
+  const search = params.toString();
+  const nextUrl = search
+    ? `${resolved.location.pathname}?${search}`
+    : resolved.location.pathname;
+  resolved.history.replaceState(null, '', nextUrl);
+}