diff --git a/apps/admin-web/src/api/adminApiClient.ts b/apps/admin-web/src/api/adminApiClient.ts
index f03280a2b..b3e502b37 100644
--- a/apps/admin-web/src/api/adminApiClient.ts
+++ b/apps/admin-web/src/api/adminApiClient.ts
@@ -34,11 +34,13 @@ import type {
   AdminFeatureGateConfigResponse,
   AdminGameDistributionGameListResponse,
   AdminGameDistributionGameStatus,
+  AdminGameDistributionPreviewSessionResponse,
   AdminGameDistributionRestoreRequest,
   AdminGameDistributionRestoreResponse,
   AdminGameDistributionReviewListResponse,
   AdminGameDistributionReviewRequest,
   AdminGameDistributionReviewResponse,
+  AdminGameDistributionVersionDetailResponse,
   AdminGameReviewDetailResponse,
   AdminGameReviewGamesQuery,
   AdminGameReviewGamesResponse,
@@ -1251,6 +1253,32 @@ export function listAdminGameDistributionReviews(token: string, limit = 48) {
   );
 }
 
+export function getAdminGameDistributionVersion(
+  token: string,
+  versionId: string,
+) {
+  return request<AdminGameDistributionVersionDetailResponse>(
+    `/admin/api/game-distribution/versions/${encodeURIComponent(versionId)}`,
+    { token },
+  );
+}
+
+export function createAdminGameDistributionPreviewSession(
+  token: string,
+  versionId: string,
+) {
+  return request<AdminGameDistributionPreviewSessionResponse>(
+    `/admin/api/game-distribution/versions/${encodeURIComponent(versionId)}/preview-session`,
+    { token, method: 'POST' },
+  ).then((response) => ({
+    ...response,
+    previewUrl: new URL(
+      response.previewUrl,
+      ADMIN_API_BASE_URL || window.location.origin,
+    ).toString(),
+  }));
+}
+
 /**
  * 后台作品管理列表。
  *
diff --git a/apps/admin-web/src/api/adminApiTypes.ts b/apps/admin-web/src/api/adminApiTypes.ts
index 32dcefd63..d3718adf8 100644
--- a/apps/admin-web/src/api/adminApiTypes.ts
+++ b/apps/admin-web/src/api/adminApiTypes.ts
@@ -1110,6 +1110,52 @@ export interface AdminGameDistributionReviewEntry {
   updatedAt: string;
 }
 
+export interface AdminGameDistributionGameDetail {
+  id: string;
+  title: string;
+  summary: string;
+  description: string;
+  category: string;
+  tags: string[];
+  coverObjectKey: string | null;
+  screenshots: string[];
+  author: {
+    id: string;
+    name: string;
+    avatarUrl: string | null;
+  };
+  deviceSupport: {
+    desktop: boolean;
+    mobile: boolean;
+    touch: boolean;
+  };
+  inputModes: string[];
+  orientation: string;
+  status: string;
+  publicationRevision: number;
+  playCount: number;
+  createdAt: string;
+}
+
+export interface AdminGameDistributionVersionDetail
+  extends AdminGameDistributionReviewEntry {
+  packageFileCount: number;
+  entryUrl: string | null;
+  recoveryAction: string;
+  frozenMetadata: Record<string, unknown> | null;
+}
+
+export interface AdminGameDistributionVersionDetailResponse {
+  game: AdminGameDistributionGameDetail;
+  version: AdminGameDistributionVersionDetail;
+}
+
+export interface AdminGameDistributionPreviewSessionResponse {
+  previewUrl: string;
+  expiresAt: string;
+  versionId: string;
+}
+
 export interface AdminGameDistributionReviewListResponse {
   entries: AdminGameDistributionReviewEntry[];
   nextCursor: string | null;
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
index 8291e815e..013603ed9 100644
--- a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
@@ -10,11 +10,16 @@ import {
 import { beforeEach, expect, test, vi } from 'vitest';
 
 import {
+  createAdminGameDistributionPreviewSession,
+  getAdminGameDistributionVersion,
   listAdminGameDistributionReviews,
   reviewAdminGameDistributionVersion,
   suspendAdminGameDistributionGame,
 } from '../api/adminApiClient';
-import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
+import type {
+  AdminGameDistributionReviewEntry,
+  AdminGameDistributionVersionDetailResponse,
+} from '../api/adminApiTypes';
 import { AdminGameDistributionReviewPage } from './AdminGameDistributionReviewPage';
 
 vi.mock('../api/adminApiClient', () => ({
@@ -28,11 +33,13 @@ vi.mock('../api/adminApiClient', () => ({
   formatAdminApiError: vi.fn((error: unknown) =>
     error instanceof Error ? error.message : '请求失败',
   ),
+  createAdminGameDistributionPreviewSession: vi.fn(),
+  getAdminGameDistributionVersion: vi.fn(),
   listAdminGameDistributionReviews: vi.fn(),
   reviewAdminGameDistributionVersion: vi.fn(),
   suspendAdminGameDistributionGame: vi.fn(),
-}));
 
+}));
 const entry: AdminGameDistributionReviewEntry = {
   versionId: 'version-1',
   gameId: 'game_1',
@@ -46,10 +53,40 @@ const entry: AdminGameDistributionReviewEntry = {
   updatedAt: '2026-09-20T08:00:00Z',
 };
 
+const detailResponse: AdminGameDistributionVersionDetailResponse = {
+  game: {
+    id: 'game_1',
+    title: '测试游戏',
+    summary: '测试简介',
+    description: '测试详细介绍',
+    category: '益智',
+    tags: ['测试'],
+    coverObjectKey: null,
+    screenshots: [],
+    author: { id: 'user-1', name: '测试作者', avatarUrl: null },
+    deviceSupport: { desktop: true, mobile: false, touch: true },
+    inputModes: ['keyboard'],
+    orientation: 'landscape',
+    status: 'unpublished',
+    publicationRevision: 4,
+    playCount: 0,
+    createdAt: '2026-09-20T08:00:00Z',
+  },
+  version: {
+    ...entry,
+    packageFileCount: 3,
+    entryUrl: null,
+    recoveryAction: 'wait',
+    frozenMetadata: { title: '测试游戏' },
+  },
+};
+
 beforeEach(() => {
   vi.mocked(listAdminGameDistributionReviews).mockReset();
   vi.mocked(reviewAdminGameDistributionVersion).mockReset();
   vi.mocked(suspendAdminGameDistributionGame).mockReset();
+  vi.mocked(getAdminGameDistributionVersion).mockReset();
+  vi.mocked(createAdminGameDistributionPreviewSession).mockReset();
   vi.mocked(listAdminGameDistributionReviews).mockResolvedValue({
     entries: [entry],
     nextCursor: null,
@@ -230,3 +267,30 @@ test('取消安全下架确认时不下架', async () => {
   await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
   expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
 });
+
+test('详情展示发布者和冻结资料，并试玩当前待审版本', async () => {
+  vi.mocked(getAdminGameDistributionVersion).mockResolvedValue(detailResponse);
+  vi.mocked(createAdminGameDistributionPreviewSession).mockResolvedValue({
+    previewUrl: 'http://127.0.0.1:8082/api/game-distribution/admin-previews/preview-1/',
+    expiresAt: '2026-10-02T12:10:00Z',
+    versionId: 'version-1',
+  });
+
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText('game_1');
+
+  fireEvent.click(screen.getByRole('button', { name: '详情' }));
+  expect((await screen.findAllByText(/测试作者/u)).length).toBeGreaterThan(0);
+  expect(screen.getByText('测试详细介绍')).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: '试玩当前待审版本' }));
+  const frame = await screen.findByTitle('测试游戏 待审版本试玩');
+  expect(frame.getAttribute('src')).toBe(
+    'http://127.0.0.1:8082/api/game-distribution/admin-previews/preview-1/',
+  );
+  expect(frame.getAttribute('sandbox')).toBe('allow-scripts');
+});
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
index 5325772f8..42911fe55 100644
--- a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
@@ -5,6 +5,7 @@ import {
   AdminListPanel,
   AdminPage,
   AdminPageHeading,
+  GameDetailDisplay,
   formatAdminDateTime,
   Modal,
   TextField,
@@ -13,11 +14,18 @@ import { RefreshCcw } from 'lucide-react';
 import { useCallback, useEffect, useState } from 'react';
 
 import {
+  createAdminGameDistributionPreviewSession,
+  getAdminAssetReadUrl,
+  getAdminGameDistributionVersion,
   listAdminGameDistributionReviews,
   reviewAdminGameDistributionVersion,
   suspendAdminGameDistributionGame,
 } from '../api/adminApiClient';
-import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
+import type {
+  AdminGameDistributionGameDetail,
+  AdminGameDistributionReviewEntry,
+  AdminGameDistributionVersionDetailResponse,
+} from '../api/adminApiTypes';
 import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
 import { handlePageError } from './pageUtils';
 
@@ -31,6 +39,48 @@ interface ReviewReasonPrompt {
   entry: AdminGameDistributionReviewEntry;
 }
 
+function applyFrozenGameMetadata(
+  game: AdminGameDistributionGameDetail,
+  metadata: Record<string, unknown> | null,
+): AdminGameDistributionGameDetail {
+  if (!metadata) return game;
+  const screenshots = Array.isArray(metadata.screenshots)
+    ? metadata.screenshots
+        .map((item) =>
+          item && typeof item === 'object' && 'objectKey' in item
+            ? item.objectKey
+            : null,
+        )
+        .filter((value): value is string => typeof value === 'string' && Boolean(value.trim()))
+    : game.screenshots;
+  const deviceSupport =
+    metadata.deviceSupport && typeof metadata.deviceSupport === 'object'
+      ? { ...game.deviceSupport, ...metadata.deviceSupport }
+      : game.deviceSupport;
+  return {
+    ...game,
+    title: typeof metadata.title === 'string' ? metadata.title : game.title,
+    summary: typeof metadata.summary === 'string' ? metadata.summary : game.summary,
+    description:
+      typeof metadata.description === 'string' ? metadata.description : game.description,
+    category: typeof metadata.category === 'string' ? metadata.category : game.category,
+    tags: Array.isArray(metadata.tags)
+      ? metadata.tags.filter((value): value is string => typeof value === 'string')
+      : game.tags,
+    coverObjectKey:
+      typeof metadata.coverObjectKey === 'string'
+        ? metadata.coverObjectKey
+        : game.coverObjectKey,
+    screenshots,
+    deviceSupport,
+    inputModes: Array.isArray(metadata.inputModes)
+      ? metadata.inputModes.filter((value): value is string => typeof value === 'string')
+      : game.inputModes,
+    orientation:
+      typeof metadata.orientation === 'string' ? metadata.orientation : game.orientation,
+  };
+}
+
 function formatBytes(value: number) {
   if (value >= 1024 * 1024) {
     return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
@@ -75,6 +125,16 @@ export function AdminGameDistributionReviewPage({
   const [reasonError, setReasonError] = useState('');
   const [busyGameId, setBusyGameId] = useState('');
   const writeConfirm = useAdminWriteConfirm();
+  const [selectedEntry, setSelectedEntry] =
+    useState<AdminGameDistributionReviewEntry | null>(null);
+  const [detail, setDetail] =
+    useState<AdminGameDistributionVersionDetailResponse | null>(null);
+  const [isDetailLoading, setIsDetailLoading] = useState(false);
+  const [detailError, setDetailError] = useState('');
+  const [previewUrl, setPreviewUrl] = useState('');
+  const [previewError, setPreviewError] = useState('');
+  const [isPreviewLoading, setIsPreviewLoading] = useState(false);
+  const [assetUrls, setAssetUrls] = useState<Record<string, string>>({});
 
   const loadReviews = useCallback(async () => {
     setIsLoading(true);
@@ -93,6 +153,77 @@ export function AdminGameDistributionReviewPage({
     void loadReviews();
   }, [loadReviews]);
 
+  async function openDetails(entry: AdminGameDistributionReviewEntry) {
+    setSelectedEntry(entry);
+    setDetail(null);
+    setDetailError('');
+    setPreviewUrl('');
+    setPreviewError('');
+    setAssetUrls({});
+    setIsDetailLoading(true);
+    try {
+      const response = await getAdminGameDistributionVersion(
+        token,
+        entry.versionId,
+      );
+      const reviewGame = applyFrozenGameMetadata(
+        response.game,
+        response.version.frozenMetadata,
+      );
+      const reviewDetail = { ...response, game: reviewGame };
+      setDetail(reviewDetail);
+      const objectKeys = [reviewGame.coverObjectKey, ...reviewGame.screenshots].filter(
+        (value): value is string => Boolean(value?.trim()),
+      );
+      const resolvedUrls = await Promise.all(
+        objectKeys.map(async (objectKey) => {
+          try {
+            const asset = await getAdminAssetReadUrl(token, {
+              objectKey,
+              expireSeconds: 300,
+            });
+            return [
+              objectKey,
+              asset.read?.signedUrl ?? asset.signedUrl ?? '',
+            ] as const;
+          } catch {
+            return [objectKey, ''] as const;
+          }
+        }),
+      );
+      setAssetUrls(Object.fromEntries(resolvedUrls));
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setDetailError);
+    } finally {
+      setIsDetailLoading(false);
+    }
+  }
+
+  function closeDetails() {
+    setSelectedEntry(null);
+    setDetail(null);
+    setPreviewUrl('');
+    setPreviewError('');
+    setAssetUrls({});
+  }
+
+  async function startPreview() {
+    if (!selectedEntry) return;
+    setIsPreviewLoading(true);
+    setPreviewError('');
+    try {
+      const response = await createAdminGameDistributionPreviewSession(
+        token,
+        selectedEntry.versionId,
+      );
+      setPreviewUrl(response.previewUrl);
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setPreviewError);
+    } finally {
+      setIsPreviewLoading(false);
+    }
+  }
+
   async function submitReview(
     entry: AdminGameDistributionReviewEntry,
     decision: 'approve' | 'reject',
@@ -204,6 +335,30 @@ export function AdminGameDistributionReviewPage({
     void suspendGame(entry, reason);
   }
 
+  if (selectedEntry) {
+    return (
+      <AdminGameDistributionReviewDetailView
+        detail={detail}
+        detailError={detailError}
+        isDetailLoading={isDetailLoading}
+        isPreviewLoading={isPreviewLoading}
+        previewError={previewError}
+        previewUrl={previewUrl}
+        assetUrls={assetUrls}
+        onBack={closeDetails}
+        onPreview={() => void startPreview()}
+        onReject={() => {
+          closeDetails();
+          openReasonPrompt(selectedEntry, 'reject');
+        }}
+        onApprove={() => {
+          closeDetails();
+          void submitReview(selectedEntry, 'approve');
+        }}
+      />
+    );
+  }
+
   return (
     <AdminPage wide>
       <AdminPageHeading
@@ -269,7 +424,15 @@ export function AdminGameDistributionReviewPage({
               </td>
               <td>{formatAdminDateTime(entry.createdAt)}</td>
               <td>
-                <AdminActionRow>
+                <AdminActionRow className="admin-review-actions">
+                  <AdminButton
+                    variant="secondary"
+                    type="button"
+                    disabled={busy}
+                    onClick={() => void openDetails(entry)}
+                  >
+                    详情
+                  </AdminButton>
                   <AdminButton
                     variant="primary"
                     type="button"
@@ -311,7 +474,7 @@ export function AdminGameDistributionReviewPage({
           className="genarrative-ui"
           footer={
             <div
-              className="admin-confirm-actions"
+              className="admin-confirm-actions admin-review-actions"
               style={{
                 width: '100%',
               }}
@@ -353,3 +516,118 @@ export function AdminGameDistributionReviewPage({
     </AdminPage>
   );
 }
+
+function AdminGameDistributionReviewDetailView({
+  detail,
+  detailError,
+  isDetailLoading,
+  isPreviewLoading,
+  previewError,
+  previewUrl,
+  assetUrls,
+  onBack,
+  onPreview,
+  onReject,
+  onApprove,
+}: {
+  detail: AdminGameDistributionVersionDetailResponse | null;
+  detailError: string;
+  isDetailLoading: boolean;
+  isPreviewLoading: boolean;
+  previewError: string;
+  previewUrl: string;
+  assetUrls: Record<string, string>;
+  onBack: () => void;
+  onPreview: () => void;
+  onReject: () => void;
+  onApprove: () => void;
+}) {
+  if (!detail) {
+    return (
+      <AdminPage wide>
+        <AdminPageHeading title="审核详情" />
+        {isDetailLoading ? <AdminAlert>正在加载审核详情…</AdminAlert> : null}
+        {detailError ? <AdminAlert tone="warning">{detailError}</AdminAlert> : null}
+        <AdminButton variant="secondary" type="button" onClick={onBack}>
+          返回审核列表
+        </AdminButton>
+      </AdminPage>
+    );
+  }
+
+  return (
+    <AdminPage wide>
+      <AdminPageHeading
+        title={`${detail.game.title} · v${detail.version.versionNumber}`}
+        actions={
+          <AdminButton variant="secondary" type="button" onClick={onBack}>
+            返回审核列表
+          </AdminButton>
+        }
+      />
+      {detailError ? <AdminAlert tone="warning">{detailError}</AdminAlert> : null}
+      <GameDetailDisplay
+        className="platform-theme platform-theme--light admin-game-review-detail"
+        game={detail.game}
+        coverObjectKey={detail.game.coverObjectKey}
+        screenshotObjectKeys={detail.game.screenshots}
+        assetUrls={assetUrls}
+        controlsLabel={detail.game.inputModes.join('、') || '未声明'}
+        versionLabel={`v${detail.version.versionNumber}`}
+        infoCards={[
+          { label: '状态', value: detail.version.status },
+          { label: '提交时间', value: formatAdminDateTime(detail.version.createdAt) },
+          { label: '包大小', value: formatBytes(detail.version.packageBytes) },
+          { label: '文件数', value: detail.version.packageFileCount },
+          { label: 'SHA-256', value: <code>{detail.version.packageSha256}</code> },
+        ]}
+        actions={
+          <AdminActionRow className="admin-review-actions">
+            <AdminButton
+              variant="primary"
+              type="button"
+              disabled={isPreviewLoading}
+              onClick={onPreview}
+            >
+              {isPreviewLoading ? '准备试玩…' : '试玩当前待审版本'}
+            </AdminButton>
+            <AdminButton variant="ghost" type="button" onClick={onReject}>
+              拒绝
+            </AdminButton>
+            <AdminButton variant="primary" type="button" onClick={onApprove}>
+              通过
+            </AdminButton>
+          </AdminActionRow>
+        }
+      >
+        <section>
+          <h2>版本审核</h2>
+          <p>
+            发布者：{detail.game.author.name} · <code>{detail.game.author.id}</code>
+          </p>
+          {detail.version.reviewReason ? (
+            <AdminAlert tone="warning">审核理由：{detail.version.reviewReason}</AdminAlert>
+          ) : null}
+          {detail.version.frozenMetadata ? (
+            <details>
+              <summary>查看版本冻结资料</summary>
+              <pre className="admin-json-preview">
+                {JSON.stringify(detail.version.frozenMetadata, null, 2)}
+              </pre>
+            </details>
+          ) : null}
+          {previewError ? <AdminAlert tone="warning">{previewError}</AdminAlert> : null}
+          {previewUrl ? (
+            <iframe
+              title={`${detail.game.title} 待审版本试玩`}
+              src={previewUrl}
+              sandbox="allow-scripts"
+              referrerPolicy="no-referrer"
+              className="admin-game-review-preview"
+            />
+          ) : null}
+        </section>
+      </GameDetailDisplay>
+    </AdminPage>
+  );
+}
diff --git a/apps/admin-web/src/styles/admin.css b/apps/admin-web/src/styles/admin.css
index 8a861808c..888ea282f 100644
--- a/apps/admin-web/src/styles/admin.css
+++ b/apps/admin-web/src/styles/admin.css
@@ -3507,3 +3507,22 @@ button:disabled {
     grid-template-columns: 1fr;
   }
 }
+
+.admin-game-review-detail {
+  max-width: 70rem;
+  margin: 0 auto;
+  padding: clamp(1rem, 2.4vw, 2.75rem);
+  border-radius: 1.75rem;
+  background: var(--platform-body-fill);
+  color: var(--platform-text-strong);
+}
+
+.admin-game-review-preview {
+  display: block;
+  width: 100%;
+  min-height: 42rem;
+  margin-top: 1rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1rem;
+  background: #fff;
+}
diff --git a/apps/admin-web/vite.config.ts b/apps/admin-web/vite.config.ts
index a8fa7e8bc..cc843d5d8 100644
--- a/apps/admin-web/vite.config.ts
+++ b/apps/admin-web/vite.config.ts
@@ -46,6 +46,11 @@ export default defineConfig(({ command, mode }) => {
           changeOrigin: true,
           secure: false,
         },
+        '/api/game-distribution/admin-previews': {
+          target: apiTarget,
+          changeOrigin: true,
+          secure: false,
+        },
         '/healthz': {
           target: apiTarget,
           changeOrigin: true,
diff --git a/apps/ai-game-creator-shell/scripts/check-config.mjs b/apps/ai-game-creator-shell/scripts/check-config.mjs
index 787be765f..b47e8cbe3 100644
--- a/apps/ai-game-creator-shell/scripts/check-config.mjs
+++ b/apps/ai-game-creator-shell/scripts/check-config.mjs
@@ -134,6 +134,7 @@ const allowedUncalledTauriCommands = [
   'prepare_local_project_game_package',
   'read_game_cover_generation_price',
   'suggest_game_distribution_publish_metadata',
+  'read_game_distribution_publication',
   'upload_local_project_game_package',
   // 账户与钱包由 Rust typed command 持有 origin/Bearer/envelope；命令名在 `accountHost.ts`
   // 里以字面量出现，静态扫描仍按共享注册表核验。
diff --git a/apps/ai-game-creator-shell/src-tauri/src/desktop.rs b/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
index bfb3d6a8f..1eec25092 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
@@ -610,6 +610,7 @@ pub(super) fn run() {
             suggest_game_distribution_publish_metadata,
             read_game_cover_generation_price,
             generate_game_distribution_cover,
+            read_game_distribution_publication,
             publish_local_project_game,
             read_game_creator_app_config,
             clear_game_creator_acl_elevation_denials,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs b/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
index da397f1fa..767586b58 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
@@ -18,9 +18,14 @@ use reqwest::header::{HeaderName, HeaderValue, CONTENT_TYPE};
 use reqwest::{Method, StatusCode};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
 use shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER;
+use shared_contracts::game_creation_app::{
+    GameCreationAppManifest, GameCreationAppPublicationBinding,
+};
 use shared_contracts::game_distribution::{
     GameDistributionCreateGameRequest, GameDistributionCreateVersionRequest,
+    GameDistributionDeviceSupport, GameDistributionInputMode, GameDistributionOrientation,
     GameDistributionPublishMetadataSuggestion, GameDistributionPublishMetadataSuggestionRequest,
 };
 use std::path::Path;
@@ -39,6 +44,9 @@ const COVER_PREVIEW_MAX_BYTES: usize = 8 * 1024 * 1024;
 
 const PACKAGE_UPLOAD_PROGRESS_EVENT: &str = "game-package-upload-progress";
 
+/// JS `Number.MAX_SAFE_INTEGER`：版本号经 JSON number 传递，超过它就会丢精度。
+const MAX_SAFE_VERSION_NUMBER: u64 = 9_007_199_254_740_991;
+
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct GameDistributionPublishResult {
@@ -49,6 +57,71 @@ pub(crate) struct GameDistributionPublishResult {
     pub(crate) package_sha256: String,
     pub(crate) package_size_bytes: u64,
     pub(crate) file_count: u32,
+    /// 发布成功并把绑定写回本地清单后的整份 manifest；渲染层据此同步两处挂载点。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) manifest: Option<GameCreationAppManifest>,
+    /// 本次写回的发布绑定，便于调用方不解析 manifest 也能就地更新。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) publication: Option<GameCreationAppPublicationBinding>,
+}
+
+/// 回读版本冻结资料时带回的封面/截图草稿条目。
+///
+/// `asset_id` 只在版本冻结资料里存在；历史版本没有冻结资料时为 `None`，此时只能给出预览，
+/// 更新发布必须让作者重新选择素材。`preview_url` 是服务端换签后的地址，换签失败留空。
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct GameDistributionPublicationImageDraft {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) asset_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) preview_url: Option<String>,
+}
+
+/// 更新发布时默认回填的发行资料与封面/截图。
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct GameDistributionPublicationDraft {
+    pub(crate) title: String,
+    pub(crate) summary: String,
+    pub(crate) description: String,
+    pub(crate) category: String,
+    #[serde(default)]
+    pub(crate) tags: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) cover: Option<GameDistributionPublicationImageDraft>,
+    #[serde(default)]
+    pub(crate) screenshots: Vec<GameDistributionPublicationImageDraft>,
+    /// 随版本冻结的设备/输入/方向声明：面板不出售这些字段，但更新发布必须原样沿用，
+    /// 否则会被创建版本请求的默认值静默改写成「桌面 + 触屏 + responsive」。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) device_support: Option<GameDistributionDeviceSupport>,
+    #[serde(default)]
+    pub(crate) input_modes: Vec<GameDistributionInputMode>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) orientation: Option<GameDistributionOrientation>,
+}
+
+/// 发布面板打开时的发布状态回读。
+///
+/// `state` 三态刻意分开：`unavailable` 表示恢复被网络/401/5xx 挡住，**不能**当成首次发布；
+/// `first-publish` 只在服务端给出确定答案（无绑定且作者名下没有匹配作品）时返回。
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct GameDistributionPublicationReadResult {
+    /// `first-publish` | `update` | `unavailable`
+    pub(crate) state: String,
+    /// 始终下发（无绑定时为 null），让渲染层的三态联合类型与线上一一对应。
+    #[serde(default)]
+    pub(crate) binding: Option<GameCreationAppPublicationBinding>,
+    /// 线上状态是否成功刷新；本地绑定仍在但读不到线上时为 false。
+    pub(crate) refreshed: bool,
+    #[serde(default)]
+    pub(crate) draft: Option<GameDistributionPublicationDraft>,
+    #[serde(default)]
+    pub(crate) visibility: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) message: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
@@ -122,6 +195,55 @@ struct CreatedVersion {
     version_number: u64,
     #[serde(default)]
     status: String,
+    #[serde(default)]
+    publication_revision: Option<u64>,
+}
+
+/// 作者名下作品条目（`GET /my-games` 列表项与 `GET /my-games/{gameId}` 的 `game`）。
+///
+/// 只声明恢复绑定需要的字段：游戏身份、`localProjectId`、最近版本与公开修订号。
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct OwnerGameEntry {
+    id: String,
+    #[serde(default)]
+    local_project_id: Option<String>,
+    #[serde(default)]
+    title: String,
+    #[serde(default)]
+    summary: String,
+    #[serde(default)]
+    description: String,
+    #[serde(default)]
+    category: String,
+    #[serde(default)]
+    tags: Vec<String>,
+    #[serde(default)]
+    cover_object_key: Option<String>,
+    #[serde(default)]
+    screenshots: Vec<String>,
+    #[serde(default)]
+    status: String,
+    #[serde(default)]
+    publication_revision: u64,
+    #[serde(default)]
+    latest_version: Option<OwnerGameVersion>,
+    #[serde(default)]
+    device_support: Option<GameDistributionDeviceSupport>,
+    #[serde(default)]
+    input_modes: Vec<String>,
+    #[serde(default)]
+    orientation: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct OwnerGameVersion {
+    version_id: String,
+    #[serde(default)]
+    version_number: u64,
+    #[serde(default)]
+    status: String,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -217,6 +339,27 @@ fn map_http_error(status: StatusCode, body: &str, fallback: &str) -> String {
             message.unwrap_or_else(|| "当前账号无权执行此操作".to_string())
         );
     }
+    // 目标版本号冲突必须是可读且可区分的提示：这是更新发布会遇到的主要正常失败，
+    // 不能让作者看到笼统的「HTTP 409」。
+    if status == StatusCode::CONFLICT
+        && (code.as_deref() == Some("VERSION_NUMBER_CONFLICT")
+            || message
+                .as_deref()
+                .is_some_and(|value| value.trim_start().starts_with("VERSION_NUMBER_CONFLICT")))
+    {
+        let detail = message
+            .as_deref()
+            .map(|value| {
+                value
+                    .trim()
+                    .trim_start_matches("VERSION_NUMBER_CONFLICT")
+                    .trim_start_matches([':', '：'])
+                    .trim()
+            })
+            .filter(|value| !value.is_empty())
+            .unwrap_or("目标版本号必须大于当前最大版本号");
+        return format!("版本号冲突：{detail}");
+    }
     let detail = message
         .or(code)
         .filter(|value| !value.trim().is_empty())
@@ -279,6 +422,496 @@ fn build_client() -> Result<reqwest::Client, String> {
         .map_err(|error| format!("创建陶泥儿网络客户端失败：{error}"))
 }
 
+fn normalized_origin(value: &str) -> String {
+    value.trim().trim_end_matches('/').to_string()
+}
+
+fn metadata_digest(metadata: &GameDistributionCreateGameRequest) -> Result<String, String> {
+    let bytes = serde_json::to_vec(metadata)
+        .map_err(|error| format!("计算发布资料摘要失败：{error}"))?;
+    let mut hasher = Sha256::new();
+    hasher.update(&bytes);
+    Ok(format!("{:x}", hasher.finalize()))
+}
+
+/// 版本身份恢复请求的失败分类：只有确定「不存在」才允许回落首次发布。
+enum GameDistributionReadError {
+    /// 服务端明确回答该资源不可见/不存在（404）。
+    NotFound,
+    /// 网络、超时、401 或 5xx：结果未知，绝不能当成首次发布。
+    Unavailable(String),
+    /// 其它 4xx（403/422 等）：服务端拒绝，按不可用处理并向作者展示原因。
+    Rejected(String),
+}
+
+async fn request_json_for_read(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    method: Method,
+    segments: &[&str],
+    fallback: &str,
+) -> Result<Value, GameDistributionReadError> {
+    let current = current_scoped_session(snapshot)
+        .map_err(GameDistributionReadError::Unavailable)?;
+    let url = endpoint(snapshot, segments).map_err(GameDistributionReadError::Rejected)?;
+    let request = client
+        .request(method, &url)
+        .bearer_auth(&current.access_token)
+        .header(
+            HeaderName::from_static(AGC_CLIENT_MARKER_HEADER),
+            HeaderValue::from_static(AGC_CLIENT_MARKER_VALUE),
+        )
+        .header(
+            HeaderName::from_static(API_RESPONSE_ENVELOPE_HEADER),
+            HeaderValue::from_static(API_RESPONSE_ENVELOPE_VERSION),
+        )
+        .timeout(HTTP_TIMEOUT);
+    let response = request.send().await.map_err(|error| {
+        GameDistributionReadError::Unavailable(if error.is_timeout() {
+            format!("{fallback}：请求超时，请稍后重试")
+        } else {
+            format!("{fallback}：无法连接登录服务，请确认配套后端或 API 代理已启动后重试")
+        })
+    })?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|error| GameDistributionReadError::Unavailable(format!("{fallback}：读取响应失败：{error}")))?;
+    if let Err(message) = validate_session(snapshot) {
+        return Err(GameDistributionReadError::Unavailable(message));
+    }
+    if status == StatusCode::NOT_FOUND {
+        return Err(GameDistributionReadError::NotFound);
+    }
+    if status == StatusCode::UNAUTHORIZED || status.is_server_error() {
+        return Err(GameDistributionReadError::Unavailable(map_http_error(
+            status, &text, fallback,
+        )));
+    }
+    if !status.is_success() {
+        return Err(GameDistributionReadError::Rejected(map_http_error(
+            status, &text, fallback,
+        )));
+    }
+    response_data(&text)
+        .map_err(|error| GameDistributionReadError::Rejected(format!("{fallback}：{error}")))
+}
+
+fn parse_owner_game_entry(value: Value) -> Result<OwnerGameEntry, String> {
+    serde_json::from_value(value).map_err(|error| format!("作者作品响应无效：{error}"))
+}
+
+fn first_publish_state(message: Option<String>) -> GameDistributionPublicationReadResult {
+    GameDistributionPublicationReadResult {
+        state: "first-publish".to_string(),
+        binding: None,
+        refreshed: true,
+        draft: None,
+        visibility: None,
+        message,
+    }
+}
+
+fn unavailable_state(message: Option<String>) -> GameDistributionPublicationReadResult {
+    GameDistributionPublicationReadResult {
+        state: "unavailable".to_string(),
+        binding: None,
+        refreshed: false,
+        draft: None,
+        visibility: None,
+        message,
+    }
+}
+
+fn write_publication_binding(
+    root: &Path,
+    binding: GameCreationAppPublicationBinding,
+) -> Result<(), String> {
+    crate::project::mutate_manifest_at(root, |manifest| {
+        manifest.publication = Some(binding.clone());
+        Ok(())
+    })
+}
+
+fn clear_publication_binding(root: &Path) {
+    let _ = crate::project::mutate_manifest_at(root, |manifest| {
+        manifest.publication = None;
+        Ok(())
+    });
+}
+
+fn asset_read_url(api_base_url: &str, object_key: &str) -> Result<String, String> {
+    let mut url = Url::parse(&format!(
+        "{}/api/assets/read-url",
+        api_base_url.trim_end_matches('/')
+    ))
+    .map_err(|_| "陶泥儿服务地址无效".to_string())?;
+    url.query_pairs_mut().append_pair("objectKey", object_key);
+    Ok(url.to_string())
+}
+
+/// 把冻结资料里的对象键换成可展示的换签地址；失败只留空预览，不影响发布资料回填。
+async fn resolve_preview_url(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    object_key: Option<&str>,
+) -> Option<String> {
+    let object_key = object_key?.trim();
+    if object_key.is_empty() {
+        return None;
+    }
+    let read_url = asset_read_url(&snapshot.api_base_url, object_key).ok()?;
+    match crate::assets::resolve_external_asset_signed_url(
+        client,
+        snapshot.access_token.as_str(),
+        read_url,
+    )
+    .await
+    {
+        Ok(url) => Some(url),
+        Err(error) => {
+            app_log!("读取发行素材预览失败：{error}");
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct FrozenPublicationMetadata {
+    #[serde(default)]
+    title: String,
+    #[serde(default)]
+    summary: String,
+    #[serde(default)]
+    description: String,
+    #[serde(default)]
+    category: String,
+    #[serde(default)]
+    tags: Vec<String>,
+    #[serde(default)]
+    cover_asset_id: Option<String>,
+    #[serde(default)]
+    cover_object_key: Option<String>,
+    #[serde(default)]
+    screenshots: Vec<FrozenPublicationScreenshot>,
+    #[serde(default)]
+    device_support: Option<GameDistributionDeviceSupport>,
+    #[serde(default)]
+    input_modes: Vec<String>,
+    #[serde(default)]
+    orientation: Option<String>,
+}
+
+/// 声明字段按字符串宽容解析：未来新增取值或历史脏值时收口成缺省，不让整份恢复失败。
+fn parse_input_modes(values: Vec<String>) -> Vec<GameDistributionInputMode> {
+    values
+        .into_iter()
+        .filter_map(|value| match value.trim() {
+            "keyboard" => Some(GameDistributionInputMode::Keyboard),
+            "mouse" => Some(GameDistributionInputMode::Mouse),
+            "touch" => Some(GameDistributionInputMode::Touch),
+            _ => None,
+        })
+        .collect()
+}
+
+fn parse_orientation(value: Option<String>) -> Option<GameDistributionOrientation> {
+    match value.as_deref().map(str::trim) {
+        Some("landscape") => Some(GameDistributionOrientation::Landscape),
+        Some("portrait") => Some(GameDistributionOrientation::Portrait),
+        Some("responsive") => Some(GameDistributionOrientation::Responsive),
+        _ => None,
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct FrozenPublicationScreenshot {
+    #[serde(default)]
+    asset_id: Option<String>,
+    #[serde(default)]
+    object_key: Option<String>,
+}
+
+async fn fetch_frozen_metadata(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    version_id: &str,
+) -> Option<FrozenPublicationMetadata> {
+    let value = match request_json_for_read(
+        client,
+        snapshot,
+        Method::GET,
+        &["api", "game-distribution", "versions", version_id],
+        "读取发行版本资料失败",
+    )
+    .await
+    {
+        Ok(value) => value,
+        Err(GameDistributionReadError::NotFound) => return None,
+        Err(GameDistributionReadError::Unavailable(message))
+        | Err(GameDistributionReadError::Rejected(message)) => {
+            app_log!("回读发行版本资料失败：{message}");
+            return None;
+        }
+    };
+    let frozen = value
+        .get("version")
+        .and_then(|version| version.get("frozenMetadata"))?;
+    if frozen.is_null() {
+        return None;
+    }
+    match serde_json::from_value::<FrozenPublicationMetadata>(frozen.clone()) {
+        Ok(frozen) => Some(frozen),
+        Err(error) => {
+            app_log!("发行版本冻结资料格式无效：{error}");
+            None
+        }
+    }
+}
+
+fn pick_non_empty(primary: String, fallback: &str) -> String {
+    let primary = primary.trim();
+    if primary.is_empty() {
+        fallback.to_string()
+    } else {
+        primary.to_string()
+    }
+}
+
+async fn build_publication_draft(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    entry: &OwnerGameEntry,
+    frozen: Option<FrozenPublicationMetadata>,
+) -> GameDistributionPublicationDraft {
+    let (
+        title,
+        summary,
+        description,
+        category,
+        tags,
+        cover_asset_id,
+        cover_object_key,
+        screenshots,
+        device_support,
+        input_modes,
+        orientation,
+    ) = match frozen {
+        Some(frozen) => (
+            pick_non_empty(frozen.title, &entry.title),
+            pick_non_empty(frozen.summary, &entry.summary),
+            pick_non_empty(frozen.description, &entry.description),
+            pick_non_empty(frozen.category, &entry.category),
+            if frozen.tags.is_empty() {
+                entry.tags.clone()
+            } else {
+                frozen.tags
+            },
+            frozen.cover_asset_id,
+            frozen.cover_object_key,
+            frozen
+                .screenshots
+                .into_iter()
+                .map(|screenshot| (screenshot.asset_id, screenshot.object_key))
+                .collect::<Vec<_>>(),
+            frozen.device_support.or_else(|| entry.device_support.clone()),
+            if frozen.input_modes.is_empty() {
+                entry.input_modes.clone()
+            } else {
+                frozen.input_modes
+            },
+            frozen.orientation.or_else(|| entry.orientation.clone()),
+        ),
+        None => (
+            entry.title.clone(),
+            entry.summary.clone(),
+            entry.description.clone(),
+            entry.category.clone(),
+            entry.tags.clone(),
+            None,
+            entry.cover_object_key.clone(),
+            entry
+                .screenshots
+                .iter()
+                .map(|object_key| (None, Some(object_key.clone())))
+                .collect::<Vec<_>>(),
+            entry.device_support.clone(),
+            entry.input_modes.clone(),
+            entry.orientation.clone(),
+        ),
+    };
+    let normalize_asset_id =
+        |value: Option<String>| value.map(|value| value.trim().to_string()).filter(|value| !value.is_empty());
+    let cover = if cover_asset_id.is_some() || cover_object_key.is_some() {
+        Some(GameDistributionPublicationImageDraft {
+            asset_id: normalize_asset_id(cover_asset_id),
+            preview_url: resolve_preview_url(client, snapshot, cover_object_key.as_deref()).await,
+        })
+    } else {
+        None
+    };
+    let mut screenshot_drafts = Vec::with_capacity(screenshots.len());
+    for (asset_id, object_key) in screenshots {
+        screenshot_drafts.push(GameDistributionPublicationImageDraft {
+            asset_id: normalize_asset_id(asset_id),
+            preview_url: resolve_preview_url(client, snapshot, object_key.as_deref()).await,
+        });
+    }
+    GameDistributionPublicationDraft {
+        title,
+        summary,
+        description,
+        category,
+        tags,
+        cover,
+        screenshots: screenshot_drafts,
+        device_support,
+        input_modes: parse_input_modes(input_modes),
+        orientation: parse_orientation(orientation),
+    }
+}
+
+async fn bound_publication_result(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    root: &Path,
+    entry: OwnerGameEntry,
+) -> Result<GameDistributionPublicationReadResult, String> {
+    if entry.id.trim().is_empty() {
+        return Err("作者作品响应缺少游戏标识".to_string());
+    }
+    let latest = entry.latest_version.clone();
+    let binding = GameCreationAppPublicationBinding {
+        account_id: snapshot.user_id.clone(),
+        api_base_url: normalized_origin(&snapshot.api_base_url),
+        game_id: entry.id.trim().to_string(),
+        revision: entry.publication_revision,
+        latest_version_id: latest.as_ref().map(|version| version.version_id.clone()),
+        latest_version_number: latest.as_ref().map(|version| version.version_number),
+        status: latest.as_ref().map(|version| version.status.clone()),
+    };
+    let frozen = match latest.as_ref() {
+        Some(version) if !version.version_id.trim().is_empty() => {
+            fetch_frozen_metadata(client, snapshot, version.version_id.as_str()).await
+        }
+        _ => None,
+    };
+    let draft = build_publication_draft(client, snapshot, &entry, frozen).await;
+    // 恢复得到的绑定立即回写本地清单：即使作者这次不发布，重开项目也能直接进入更新模式。
+    if let Err(error) = write_publication_binding(root, binding.clone()) {
+        app_log!("回写发布绑定失败：{error}");
+    }
+    Ok(GameDistributionPublicationReadResult {
+        state: "update".to_string(),
+        binding: Some(binding),
+        refreshed: true,
+        draft: Some(draft),
+        visibility: Some(entry.status.clone()).filter(|status| !status.is_empty()),
+        message: None,
+    })
+}
+
+/// 发布面板打开时的绑定恢复。
+///
+/// 只有「本地绑定（且属于当前账号/origin）+ 线上作品」或「无本地绑定时按作者 + localProjectId
+/// 精确匹配」两种情况才进入更新模式；网络/401/5xx 一律返回 `unavailable`，绝不静默按首次发布。
+#[tauri::command]
+pub(crate) async fn read_game_distribution_publication(
+    project_path: String,
+) -> Result<GameDistributionPublicationReadResult, String> {
+    let snapshot = require_platform_session()?;
+    let root = Path::new(project_path.trim());
+    if root.as_os_str().is_empty() {
+        return Err("发布需要绑定本地项目".to_string());
+    }
+    let manifest = crate::project::read_manifest_for_project(root)?;
+    let origin = normalized_origin(&snapshot.api_base_url);
+    let existing = manifest.publication.clone().filter(|binding| {
+        binding.account_id == snapshot.user_id
+            && normalized_origin(&binding.api_base_url) == origin
+            && !binding.game_id.trim().is_empty()
+    });
+    let client = build_client()?;
+    match existing {
+        Some(binding) => {
+            let game_id = binding.game_id.trim().to_string();
+            let segments = ["api", "game-distribution", "my-games", game_id.as_str()];
+            match request_json_for_read(&client, &snapshot, Method::GET, &segments, "读取线上作品失败")
+                .await
+            {
+                Ok(value) => {
+                    let entry =
+                        parse_owner_game_entry(value.get("game").cloned().unwrap_or(value))?;
+                    bound_publication_result(&client, &snapshot, root, entry).await
+                }
+                Err(GameDistributionReadError::NotFound) => {
+                    // 线上作品已不存在：这是确定答案，清掉过期绑定并明确回到首次发布。
+                    clear_publication_binding(root);
+                    Ok(first_publish_state(Some(
+                        "本地记录的线上作品已不存在，将按首次发布处理".to_string(),
+                    )))
+                }
+                Err(GameDistributionReadError::Unavailable(message)) => {
+                    // 结果未知：保留本地绑定，按更新模式返回但标注未刷新，由发布时的 CAS 兜底。
+                    Ok(GameDistributionPublicationReadResult {
+                        state: "update".to_string(),
+                        binding: Some(binding),
+                        refreshed: false,
+                        draft: None,
+                        visibility: None,
+                        message: Some(format!("无法刷新线上状态：{message}")),
+                    })
+                }
+                Err(GameDistributionReadError::Rejected(message)) => Ok(unavailable_state(Some(message))),
+            }
+        }
+        None => {
+            let local_project_id = manifest.project_id.trim().to_string();
+            if local_project_id.is_empty() {
+                return Ok(first_publish_state(None));
+            }
+            match request_json_for_read(
+                &client,
+                &snapshot,
+                Method::GET,
+                &["api", "game-distribution", "my-games"],
+                "读取作者作品失败",
+            )
+            .await
+            {
+                Ok(value) => {
+                    let games = value
+                        .get("games")
+                        .and_then(Value::as_array)
+                        .cloned()
+                        .unwrap_or_default();
+                    let matched = games.into_iter().find(|game| {
+                        game.get("localProjectId")
+                            .and_then(Value::as_str)
+                            .map(str::trim)
+                            == Some(local_project_id.as_str())
+                    });
+                    match matched {
+                        Some(entry) => {
+                            let entry = parse_owner_game_entry(entry)?;
+                            bound_publication_result(&client, &snapshot, root, entry).await
+                        }
+                        None => Ok(first_publish_state(None)),
+                    }
+                }
+                Err(GameDistributionReadError::NotFound) => Ok(first_publish_state(None)),
+                Err(GameDistributionReadError::Unavailable(message))
+                | Err(GameDistributionReadError::Rejected(message)) => {
+                    Ok(unavailable_state(Some(message)))
+                }
+            }
+        }
+    }
+}
+
 fn read_cover_asset_id(payload: &CoverGenerationPayload) -> Option<String> {
     payload
         .asset_object_id
@@ -581,6 +1214,9 @@ pub(crate) async fn publish_local_project_game(
     project_path: String,
     package_relative_path: String,
     metadata: GameDistributionCreateGameRequest,
+    game_id: Option<String>,
+    version_number: Option<u64>,
+    expected_publication_revision: Option<u64>,
     idempotency_key: Option<String>,
 ) -> Result<GameDistributionPublishResult, String> {
     let snapshot = require_platform_session()?;
@@ -608,8 +1244,30 @@ pub(crate) async fn publish_local_project_game(
     if metadata.screenshots.len() > 6 {
         return Err("游戏截图最多 6 张".to_string());
     }
-    // 根幂等键由账本按「账号 + origin + 本地项目 + 包摘要」解析：同一份包重发、响应丢失后
-    // 重试、进程重启后的分片续传都落在同一次服务端尝试上；包内容变了才换键。
+    let target_game_id = game_id
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string);
+    // 版本号按 JSON number 传输：超出安全整数就已经丢精度，必须在发请求前失败关闭。
+    if let Some(number) = version_number {
+        if number == 0 {
+            return Err("目标版本号必须是大于 0 的整数".to_string());
+        }
+        if number > MAX_SAFE_VERSION_NUMBER {
+            return Err("目标版本号超出安全整数范围".to_string());
+        }
+    }
+    if target_game_id.is_some() && version_number.is_none() {
+        return Err("更新游戏必须填写目标版本号".to_string());
+    }
+    if target_game_id.is_some() && expected_publication_revision.is_none() {
+        return Err("缺少公开修订号，请重新打开发布面板后再试".to_string());
+    }
+    let digest = metadata_digest(&metadata)?;
+    // 根幂等键由账本按「账号 + origin + 本地项目 + 包摘要 + 目标游戏/版本 + 资料摘要」解析：
+    // 同一份包重发、响应丢失后重试、进程重启后的分片续传都落在同一次服务端尝试上；
+    // 包内容、目标版本或资料任一变化都换键，用户改的版本号不会被幂等收据吞掉。
     let root_key = match idempotency_key
         .as_deref()
         .map(str::trim)
@@ -619,49 +1277,70 @@ pub(crate) async fn publish_local_project_game(
         None => {
             crate::game_publish_attempt::resolve_game_publish_root_key(
                 &app_data_dir,
-                &snapshot.user_id,
-                &snapshot.api_base_url,
-                &local_project_id,
-                &staged.package_sha256,
+                crate::game_publish_attempt::GamePublishAttemptIntent {
+                    account_id: &snapshot.user_id,
+                    origin: &snapshot.api_base_url,
+                    local_project_id: &local_project_id,
+                    package_sha256: &staged.package_sha256,
+                    target_game_id: target_game_id.as_deref(),
+                    target_version_number: version_number,
+                    metadata_digest: &digest,
+                },
             )?
             .0
         }
     };
     let client = build_client()?;
-    // 准备阶段还没有版本标识，事件只用根键关联。
+    let root = Path::new(project_path.trim());
+    // 准备阶段还没有版本标识，事件只用根键关联。更新发布不会新建游戏。
     emit_publish_progress(
         &app,
         &root_key,
         "",
         "prepare",
-        "正在创建平台游戏与发行版本…",
+        if target_game_id.is_some() {
+            "正在创建新发行版本…"
+        } else {
+            "正在创建平台游戏与发行版本…"
+        },
         0,
         0,
     );
-    let game_value = request_json(
-        &client,
-        &snapshot,
-        Method::POST,
-        &["api", "game-distribution", "games"],
-        Some(
-            serde_json::to_value(&metadata)
-                .map_err(|error| format!("创建平台游戏请求无效：{error}"))?,
-        ),
-        Some(&format!("{root_key}:game")),
-        "创建平台游戏失败",
-    )
-    .await?;
-    let game: CreatedGame = serde_json::from_value(game_value)
-        .map_err(|error| format!("创建平台游戏响应无效：{error}"))?;
-    if game.id.trim().is_empty() {
-        return Err("创建平台游戏未返回游戏 ID".to_string());
-    }
+    let (game_id, mut publication_revision) = match target_game_id.as_deref() {
+        Some(game_id) => {
+            let revision = expected_publication_revision
+                .ok_or_else(|| "缺少公开修订号，请重新打开发布面板后再试".to_string())?;
+            (game_id.to_string(), revision)
+        }
+        None => {
+            let game_value = request_json(
+                &client,
+                &snapshot,
+                Method::POST,
+                &["api", "game-distribution", "games"],
+                Some(
+                    serde_json::to_value(&metadata)
+                        .map_err(|error| format!("创建平台游戏请求无效：{error}"))?,
+                ),
+                Some(&format!("{root_key}:game")),
+                "创建平台游戏失败",
+            )
+            .await?;
+            let game: CreatedGame = serde_json::from_value(game_value)
+                .map_err(|error| format!("创建平台游戏响应无效：{error}"))?;
+            if game.id.trim().is_empty() {
+                return Err("创建平台游戏未返回游戏 ID".to_string());
+            }
+            (game.id, game.publication_revision)
+        }
+    };
     let version_request = GameDistributionCreateVersionRequest {
         local_project_id: Some(local_project_id.clone()),
         package_sha256: staged.package_sha256.clone(),
         package_bytes: staged.package_size_bytes,
         package_file_count: staged.package_file_count,
         package_entry_path: "index.html".to_string(),
+        version_number,
         game_metadata: metadata,
     };
     let version_value = request_json(
@@ -672,7 +1351,7 @@ pub(crate) async fn publish_local_project_game(
             "api",
             "game-distribution",
             "games",
-            game.id.as_str(),
+            game_id.as_str(),
             "versions",
         ],
         Some(
@@ -688,6 +1367,9 @@ pub(crate) async fn publish_local_project_game(
     if version.version_id.trim().is_empty() {
         return Err("创建发行版本未返回版本 ID".to_string());
     }
+    if let Some(revision) = version.publication_revision {
+        publication_revision = revision;
+    }
     validate_session(&snapshot)?;
     let progress_version_id = version.version_id.clone();
     let verify_version_id = version.version_id.clone();
@@ -761,7 +1443,7 @@ pub(crate) async fn publish_local_project_game(
             "submit",
         ],
         Some(json!({
-            "expectedPublicationRevision": game.publication_revision,
+            "expectedPublicationRevision": publication_revision,
         })),
         Some(&format!("{root_key}:submit")),
         "提交审核失败",
@@ -769,6 +1451,32 @@ pub(crate) async fn publish_local_project_game(
     .await?;
     let submitted: SubmittedVersion =
         serde_json::from_value(submit_value).unwrap_or(SubmittedVersion { version: None });
+    let status = submitted
+        .version
+        .and_then(|version| version.status)
+        .filter(|status| !status.trim().is_empty())
+        .unwrap_or_else(|| {
+            if uploaded.status.trim().is_empty() {
+                version.status.clone()
+            } else {
+                uploaded.status.clone()
+            }
+        });
+    // 发布成功：把平台作品绑定和最近版本状态写回本地清单。写回失败不回滚已经成功的发布，
+    // 但会把错误交给作者——否则下次打开项目会退回首次发布，甚至可能重复建作品。
+    let binding = GameCreationAppPublicationBinding {
+        account_id: snapshot.user_id.clone(),
+        api_base_url: normalized_origin(&snapshot.api_base_url),
+        game_id: game_id.clone(),
+        revision: publication_revision,
+        latest_version_id: Some(version.version_id.clone()),
+        latest_version_number: Some(version.version_number),
+        status: Some(status.clone()),
+    };
+    let manifest = crate::project::mutate_manifest_at(root, |manifest| {
+        manifest.publication = Some(binding.clone());
+        Ok(manifest.clone())
+    })?;
     // 服务端已经完成收口（送审成功）：清掉本次尝试记录，下一次同内容的发布就是一个新版本。
     // 清理失败不影响这次已经成功的发布——重试只会命中服务端幂等收据，不会多建游戏或版本。
     let _ = crate::game_publish_attempt::clear_game_publish_attempt(
@@ -778,23 +1486,15 @@ pub(crate) async fn publish_local_project_game(
         &local_project_id,
     );
     Ok(GameDistributionPublishResult {
-        game_id: game.id,
+        game_id,
         version_id: version.version_id,
         version_number: version.version_number,
-        status: submitted
-            .version
-            .and_then(|version| version.status)
-            .filter(|status| !status.trim().is_empty())
-            .unwrap_or_else(|| {
-                if uploaded.status.trim().is_empty() {
-                    version.status
-                } else {
-                    uploaded.status
-                }
-            }),
+        status,
         package_sha256: staged.package_sha256,
         package_size_bytes: staged.package_size_bytes,
         file_count: staged.package_file_count,
+        manifest: Some(manifest),
+        publication: Some(binding),
     })
 }
 
@@ -854,6 +1554,92 @@ mod tests {
         );
     }
 
+    #[test]
+    fn version_number_conflict_is_a_readable_distinct_message() {
+        // 更新发布会遇到的主要正常失败：必须让作者看到「版本号冲突」而不是笼统 HTTP 409。
+        assert_eq!(
+            map_http_error(
+                StatusCode::CONFLICT,
+                r#"{"error":{"code":"VERSION_NUMBER_CONFLICT","message":"VERSION_NUMBER_CONFLICT: 版本号 3 必须严格大于当前最大版本号 5"}}"#,
+                "创建游戏发行版本失败"
+            ),
+            "版本号冲突：版本号 3 必须严格大于当前最大版本号 5"
+        );
+        // 没有 message 时给出兜底提示，不泄漏原始英文代码。
+        assert_eq!(
+            map_http_error(
+                StatusCode::CONFLICT,
+                r#"{"error":{"code":"VERSION_NUMBER_CONFLICT"}}"#,
+                "创建游戏发行版本失败"
+            ),
+            "版本号冲突：目标版本号必须大于当前最大版本号"
+        );
+    }
+
+    #[test]
+    fn metadata_digest_changes_with_frozen_metadata() {
+        let mut metadata = GameDistributionCreateGameRequest {
+            local_project_id: Some("proj-1".to_string()),
+            title: "游戏".to_string(),
+            summary: "简介".to_string(),
+            description: None,
+            category: "益智".to_string(),
+            tags: vec![],
+            cover_asset_id: Some("asset-cover".to_string()),
+            screenshots: vec![],
+            device_support: shared_contracts::game_distribution::GameDistributionDeviceSupport {
+                desktop: true,
+                mobile: false,
+                touch: false,
+            },
+            input_modes: vec![],
+            orientation:
+                shared_contracts::game_distribution::GameDistributionOrientation::Responsive,
+        };
+        let first = metadata_digest(&metadata).expect("digest");
+        assert_eq!(first.len(), 64);
+        assert_eq!(metadata_digest(&metadata).expect("stable"), first);
+        metadata.title = "新标题".to_string();
+        assert_ne!(metadata_digest(&metadata).expect("changed"), first);
+    }
+
+    #[test]
+    fn owner_game_entry_parses_author_payload_with_local_project_id() {
+        let entry = parse_owner_game_entry(json!({
+            "id": "game-1",
+            "localProjectId": "proj-1",
+            "title": "星轨防线",
+            "summary": "守住轨道城",
+            "status": "published",
+            "publicationRevision": 4,
+            "latestVersion": {
+                "versionId": "gamever-2",
+                "versionNumber": 2,
+                "status": "pending_review"
+            }
+        }))
+        .expect("owner entry");
+        assert_eq!(entry.id, "game-1");
+        assert_eq!(entry.local_project_id.as_deref(), Some("proj-1"));
+        assert_eq!(entry.publication_revision, 4);
+        let latest = entry.latest_version.expect("latest version");
+        assert_eq!(latest.version_id, "gamever-2");
+        assert_eq!(latest.version_number, 2);
+        assert_eq!(latest.status, "pending_review");
+    }
+
+    #[test]
+    fn normalize_origin_ignores_trailing_slashes_for_binding_isolation() {
+        assert_eq!(
+            normalized_origin("https://dev.genarrative.world/"),
+            "https://dev.genarrative.world"
+        );
+        assert_eq!(
+            normalized_origin(" https://dev.genarrative.world "),
+            "https://dev.genarrative.world"
+        );
+    }
+
     #[test]
     fn cover_payload_prefers_registered_asset_id() {
         let payload: CoverGenerationPayload = serde_json::from_value(json!({
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs b/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
index c869e76ce..8ba251276 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
@@ -33,11 +33,35 @@ struct GamePublishAttemptRecord {
     local_project_id: String,
     /// 归一化发行包摘要；换包即换尝试。
     package_sha256: String,
+    /// 目标游戏身份：更新已有作品时非空；首次发布为空。
+    #[serde(default)]
+    target_game_id: Option<String>,
+    /// 用户选择的目标版本号：更新发布必须记录，换了目标版本就是一次新尝试。
+    #[serde(default)]
+    target_version_number: Option<u64>,
+    /// 随版本冻结的资料摘要：同一份包换了资料修订也必须换根键，不能只按 ZIP 摘要吞掉新发布。
+    #[serde(default)]
+    metadata_digest: String,
     /// 本次尝试的发布根幂等键。
     root_key: String,
     updated_at: u64,
 }
 
+/// 一次发布的意图：账本按「账号 + origin + 本地项目 + 包摘要 + 目标游戏/版本 + 资料摘要」复用。
+///
+/// 只要其中任何一项变化，就必须换根幂等键：否则「同一份 ZIP、但用户把目标版本从 3 改成 4」
+/// 会命中上一次尝试的幂等收据，用户改的版本号静默失效。
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct GamePublishAttemptIntent<'a> {
+    pub(crate) account_id: &'a str,
+    pub(crate) origin: &'a str,
+    pub(crate) local_project_id: &'a str,
+    pub(crate) package_sha256: &'a str,
+    pub(crate) target_game_id: Option<&'a str>,
+    pub(crate) target_version_number: Option<u64>,
+    pub(crate) metadata_digest: &'a str,
+}
+
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GamePublishAttemptFile {
@@ -88,11 +112,28 @@ fn normalize_record(record: GamePublishAttemptRecord) -> Option<GamePublishAttem
     {
         return None;
     }
+    let target_game_id = record
+        .target_game_id
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty());
+    if let Some(game_id) = target_game_id.as_deref() {
+        if !is_valid_attempt_identity(game_id) {
+            return None;
+        }
+    }
+    let metadata_digest = record.metadata_digest.trim().to_ascii_lowercase();
+    // 空摘要只属于升级前的旧记录；新记录必须带合法摘要，否则重发意图无法与历史尝试区分。
+    if !metadata_digest.is_empty() && !is_valid_package_sha256(&metadata_digest) {
+        return None;
+    }
     Some(GamePublishAttemptRecord {
         account_id: record.account_id.trim().to_string(),
         origin: record.origin.trim().to_string(),
         local_project_id: record.local_project_id.trim().to_string(),
         package_sha256: record.package_sha256.trim().to_ascii_lowercase(),
+        target_game_id,
+        target_version_number: record.target_version_number,
+        metadata_digest,
         root_key: record.root_key.trim().to_string(),
         updated_at: record.updated_at,
     })
@@ -184,20 +225,21 @@ fn attempts_capped(mut attempts: Vec<GamePublishAttemptRecord>) -> Vec<GamePubli
 
 /// 解析本次发布要用的根幂等键。
 ///
-/// 命中「同账号 + 同 origin + 同本地项目 + 同包摘要」时复用既有键（响应丢失、进程重启、
-/// 分片续传都落在同一次服务端尝试上）；否则铸一个新键并落盘。返回的第二个值表示是否复用。
+/// 命中「同账号 + 同 origin + 同本地项目 + 同包摘要 + 同目标游戏/版本 + 同资料摘要」时复用
+/// 既有键（响应丢失、进程重启、分片续传都落在同一次服务端尝试上）；否则铸一个新键并落盘，
+/// 并用新尝试替换同一项目下未收口的旧记录。返回的第二个值表示是否复用。
 pub(crate) fn resolve_game_publish_root_key(
     app_data_dir: &Path,
-    account_id: &str,
-    origin: &str,
-    local_project_id: &str,
-    package_sha256: &str,
+    intent: GamePublishAttemptIntent<'_>,
 ) -> Result<(String, bool), String> {
     let candidate = normalize_record(GamePublishAttemptRecord {
-        account_id: account_id.to_string(),
-        origin: origin.to_string(),
-        local_project_id: local_project_id.to_string(),
-        package_sha256: package_sha256.to_string(),
+        account_id: intent.account_id.to_string(),
+        origin: intent.origin.to_string(),
+        local_project_id: intent.local_project_id.to_string(),
+        package_sha256: intent.package_sha256.to_string(),
+        target_game_id: intent.target_game_id.map(str::to_string),
+        target_version_number: intent.target_version_number,
+        metadata_digest: intent.metadata_digest.to_string(),
         root_key: new_game_publish_root_key(),
         updated_at: unix_timestamp(),
     })
@@ -207,15 +249,14 @@ pub(crate) fn resolve_game_publish_root_key(
         .lock()
         .map_err(|_| "发布尝试账本锁不可用".to_string())?;
     let mut attempts = read_attempts_at(&path);
-    if let Some(existing) = attempts.iter().find(|record| {
-        record.account_id == candidate.account_id
-            && record.origin == candidate.origin
-            && record.local_project_id == candidate.local_project_id
-            && record.package_sha256 == candidate.package_sha256
-    }) {
+    if let Some(existing) = attempts
+        .iter()
+        .find(|record| record_matches_intent(record, &candidate))
+    {
         return Ok((existing.root_key.clone(), true));
     }
     let root_key = candidate.root_key.clone();
+    // 同一项目只保留一个未收口尝试：用户改了目标版本或资料后，旧意图的半成品不再续用。
     attempts.retain(|record| {
         !(record.account_id == candidate.account_id
             && record.origin == candidate.origin
@@ -226,6 +267,19 @@ pub(crate) fn resolve_game_publish_root_key(
     Ok((root_key, false))
 }
 
+fn record_matches_intent(
+    record: &GamePublishAttemptRecord,
+    candidate: &GamePublishAttemptRecord,
+) -> bool {
+    record.account_id == candidate.account_id
+        && record.origin == candidate.origin
+        && record.local_project_id == candidate.local_project_id
+        && record.package_sha256 == candidate.package_sha256
+        && record.target_game_id == candidate.target_game_id
+        && record.target_version_number == candidate.target_version_number
+        && record.metadata_digest == candidate.metadata_digest
+}
+
 /// 一次发布在服务端收口后清掉记录：下一次同样内容的发布就是一个新版本。
 ///
 /// 清理失败不影响已经成功的发布——重试只会命中服务端幂等收据而不会多建版本，
@@ -267,44 +321,101 @@ mod tests {
         dir
     }
 
+    fn intent<'a>(
+        account_id: &'a str,
+        origin: &'a str,
+        local_project_id: &'a str,
+        package_sha256: &'a str,
+    ) -> GamePublishAttemptIntent<'a> {
+        GamePublishAttemptIntent {
+            account_id,
+            origin,
+            local_project_id,
+            package_sha256,
+            target_game_id: None,
+            target_version_number: None,
+            metadata_digest: "",
+        }
+    }
+
     #[test]
     fn same_package_reuses_root_key_and_new_package_rotates_it() {
         let dir = fixture_dir("reuse");
         let sha = "a".repeat(64);
         let (first, reused) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("first key");
         assert!(!reused);
         assert!(first.starts_with("agc-publish-"));
 
         let (again, reused) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("reused key");
         assert!(reused, "同一份包重发必须复用同一个根幂等键");
         assert_eq!(again, first);
 
         // 重启不改变结论：换一个进程视角重新读盘仍然是同一个键。
         let (after_restart, reused) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("restarted key");
         assert!(reused);
         assert_eq!(after_restart, first);
 
         let other_sha = "b".repeat(64);
-        let (rotated, reused) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &other_sha)
-                .expect("rotated key");
+        let (rotated, reused) = resolve_game_publish_root_key(
+            &dir,
+            intent("user-1", "https://dev.test", "proj-1", &other_sha),
+        )
+        .expect("rotated key");
         assert!(!reused, "换了包就不是同一次尝试");
         assert_ne!(rotated, first);
         let _ = fs::remove_dir_all(&dir);
     }
 
+    #[test]
+    fn target_version_and_metadata_digest_are_part_of_the_attempt_identity() {
+        let dir = fixture_dir("intent");
+        let sha = "f".repeat(64);
+        let digest_a = "1".repeat(64);
+        let digest_b = "2".repeat(64);
+        let mut base = intent("user-1", "https://dev.test", "proj-1", &sha);
+        base.metadata_digest = &digest_a;
+        base.target_game_id = Some("game-1");
+        base.target_version_number = Some(3);
+        let (first, _) = resolve_game_publish_root_key(&dir, base).expect("first key");
+
+        // 同一份 ZIP、同一资料，只是用户把目标版本从 3 改成 4：必须换根键，
+        // 否则服务端幂等收据会把用户填的版本号静默吞掉。
+        let mut bumped_version = base;
+        bumped_version.target_version_number = Some(4);
+        let (bumped, reused) =
+            resolve_game_publish_root_key(&dir, bumped_version).expect("bumped version key");
+        assert!(!reused, "改目标版本号就是一次新尝试");
+        assert_ne!(bumped, first);
+
+        // 资料摘要变化同样换键：不能只按 ZIP 摘要合并不同发布意图。
+        let mut bumped_metadata = intent("user-1", "https://dev.test", "proj-1", &sha);
+        bumped_metadata.metadata_digest = &digest_b;
+        bumped_metadata.target_game_id = Some("game-1");
+        bumped_metadata.target_version_number = Some(4);
+        let (metadata_rotated, reused) = resolve_game_publish_root_key(&dir, bumped_metadata)
+            .expect("metadata rotated key");
+        assert!(!reused, "资料修订变化也必须换键");
+        assert_ne!(metadata_rotated, bumped);
+
+        let (reused_again, reused) =
+            resolve_game_publish_root_key(&dir, bumped_metadata).expect("reuse identical intent");
+        assert!(reused);
+        assert_eq!(reused_again, metadata_rotated);
+        let _ = fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn attempts_are_scoped_per_account_origin_and_project() {
         let dir = fixture_dir("scope");
         let sha = "c".repeat(64);
         let (base, _) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("base key");
         for (account, origin, project) in [
             ("user-2", "https://dev.test", "proj-1"),
@@ -312,7 +423,7 @@ mod tests {
             ("user-1", "https://dev.test", "proj-2"),
         ] {
             let (scoped, reused) =
-                resolve_game_publish_root_key(&dir, account, origin, project, &sha)
+                resolve_game_publish_root_key(&dir, intent(account, origin, project, &sha))
                     .expect("scoped key");
             assert!(!reused, "不同账号/origin/项目不得复用别人的发布尝试");
             assert_ne!(scoped, base);
@@ -325,12 +436,12 @@ mod tests {
         let dir = fixture_dir("clear");
         let sha = "d".repeat(64);
         let (first, _) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("first key");
         clear_game_publish_attempt(&dir, "user-1", "https://dev.test", "proj-1")
             .expect("clear attempt");
         let (second, reused) =
-            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            resolve_game_publish_root_key(&dir, intent("user-1", "https://dev.test", "proj-1", &sha))
                 .expect("second key");
         assert!(!reused, "收口过的尝试不再复用，下一次发布是新版本");
         assert_ne!(second, first);
@@ -344,8 +455,12 @@ mod tests {
     fn ledger_only_holds_identifiers_and_summaries() {
         let dir = fixture_dir("shape");
         let sha = "e".repeat(64);
-        resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
-            .expect("key");
+        let digest = "a".repeat(64);
+        let mut shape = intent("user-1", "https://dev.test", "proj-1", &sha);
+        shape.metadata_digest = &digest;
+        shape.target_game_id = Some("game-1");
+        shape.target_version_number = Some(2);
+        resolve_game_publish_root_key(&dir, shape).expect("key");
         let content =
             fs::read_to_string(game_publish_attempt_path(&dir)).expect("read ledger file");
         let parsed: serde_json::Value = serde_json::from_str(&content).expect("ledger json");
@@ -364,6 +479,16 @@ mod tests {
                 .and_then(|value| value.as_str()),
             Some("proj-1")
         );
+        assert_eq!(
+            record.get("targetGameId").and_then(|value| value.as_str()),
+            Some("game-1")
+        );
+        assert_eq!(
+            record
+                .get("targetVersionNumber")
+                .and_then(serde_json::Value::as_u64),
+            Some(2)
+        );
         // 账本不写 token、刷新凭据，也不写本地绝对路径。
         for forbidden in [
             "token",
diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index b5144f404..89f01ccf0 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -1808,6 +1808,11 @@ export function App({
           manifest={manifest}
           packageResult={publishPackageResult}
           onClose={() => setPublishPanelOpen(false)}
+          onPublished={(published) => {
+            // 发布成功会把平台作品绑定写回本地清单；用原生返回的整份 manifest 覆盖
+            // 工作台状态，两处面板挂载点（普通项目 / DirectProject）共享同一份状态。
+            if (published.manifest) setManifest(published.manifest);
+          }}
         />
         <GamePublishProgressDialog
           progress={publishProgress}
@@ -1939,6 +1944,9 @@ export function App({
         manifest={manifest}
         packageResult={publishPackageResult}
         onClose={() => setPublishPanelOpen(false)}
+        onPublished={(published) => {
+          if (published.manifest) setManifest(published.manifest);
+        }}
       />
       <GamePublishProgressDialog
         progress={publishProgress}
diff --git a/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx b/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
index 114366e48..5a02cb470 100644
--- a/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
@@ -8,12 +8,15 @@ import { resolveTauriInvoke } from '../../app/tauri';
 import type { LocalProjectExportPackageResult } from '../../app/types';
 import { uploadPlatformMediaAsset } from '../../services/assetDirectUpload';
 import {
+  type GameDistributionPublicationImageDraft,
+  type GameDistributionPublicationReadResult,
   type GameDistributionPublishMetadata,
   type GameDistributionPublishResult,
   generateGameDistributionCover,
   MAX_AGC_GAME_SCREENSHOTS,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../../services/gameDistributionPublish';
 import {
@@ -46,9 +49,17 @@ type PanelScreenshotEntry = {
   assetObjectId: string | null;
   status: 'uploading' | 'ready' | 'failed';
   error: string | null;
-  file: File;
+  /** 已恢复的历史截图没有本地文件；新建条目总是带文件。 */
+  file: File | null;
 };
 
+/**
+ * 发布面板的绑定状态：检查中 / 首次发布 / 更新 / 不可用。
+ *
+ * `unavailable` 时禁止提交：恢复失败（网络、401、5xx）不能退化成首次发布，否则会多建作品。
+ */
+type PanelPublicationState = 'checking' | 'first-publish' | 'update' | 'unavailable';
+
 function resolvePanelImageLabel(kind: PanelImageKind) {
   return kind === 'cover' ? '游戏封面' : '游戏截图';
 }
@@ -91,6 +102,65 @@ function createPanelScreenshotId() {
   return `screenshot-${randomUuid}`;
 }
 
+/** 版本状态到中文标签的静态映射；未知状态原样展示，不臆造。 */
+const PUBLICATION_VERSION_STATUS_LABELS: Record<string, string> = {
+  awaiting_upload: '待上传',
+  uploaded: '已上传',
+  validating: '校验中',
+  pending_review: '审核中',
+  published: '已公开',
+  upload_failed: '上传失败',
+  validation_failed: '校验失败',
+  rejected: '已驳回',
+  cancelled: '已撤回',
+  revoked: '已撤销',
+};
+
+function publicationVersionStatusLabel(status: string | null | undefined) {
+  const normalized = status?.trim() ?? '';
+  if (!normalized) return '未知状态';
+  return PUBLICATION_VERSION_STATUS_LABELS[normalized] ?? normalized;
+}
+
+/** 目标版本号只接受正整数安全整数；非法输入返回 null，由调用方给出可读错误。 */
+function parseTargetVersion(value: string): number | null {
+  const trimmed = value.trim();
+  if (!/^\d+$/u.test(trimmed)) return null;
+  const parsed = Number(trimmed);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+
+/** 已发布作品的封面恢复：预览用换签地址，提交仍复用冻结素材 ID。 */
+function buildRestoredCover(
+  cover: GameDistributionPublicationImageDraft,
+): PanelImageAsset {
+  const assetId = cover.assetId?.trim() ?? '';
+  return {
+    signature: `existing:${assetId || cover.previewUrl?.trim() || 'cover'}`,
+    name: '当前发布封面',
+    assetObjectId: assetId,
+    previewUrl: cover.previewUrl?.trim() ?? '',
+  };
+}
+
+/** 已发布作品的截图恢复；历史版本缺少冻结素材 ID 时标记为失败，要求作者重新选择。 */
+function buildRestoredScreenshot(
+  screenshot: GameDistributionPublicationImageDraft,
+  index: number,
+): PanelScreenshotEntry {
+  const assetId = screenshot.assetId?.trim() ?? '';
+  return {
+    id: `restored-screenshot-${index}-${assetId || 'missing'}`,
+    name: `当前截图 ${index + 1}`,
+    previewUrl: screenshot.previewUrl?.trim() ?? '',
+    assetObjectId: assetId || null,
+    status: assetId ? 'ready' : 'failed',
+    error: assetId ? null : '该截图缺少平台素材，请删除后重新选择',
+    file: null,
+  };
+}
+
 const COVER_GENERATION_MODEL = IMAGE_MODEL_GPT_IMAGE_2;
 const COVER_GENERATION_ASPECT_RATIO = '16:9';
 const COVER_GENERATION_IMAGE_SIZE = '2K';
@@ -194,7 +264,26 @@ export function GameDistributionPublishPanel({
     message: string;
     percent: number | null;
   } | null>(null);
+  /** 发布绑定状态：检查中 / 首次发布 / 更新 / 不可用。 */
+  const [publicationState, setPublicationState] =
+    useState<PanelPublicationState>('checking');
+  const [publicationBinding, setPublicationBinding] = useState<
+    GameDistributionPublicationReadResult['binding'] | null
+  >(null);
+  const [publicationRefreshed, setPublicationRefreshed] = useState(false);
+  const [publicationMessage, setPublicationMessage] = useState('');
+  const [targetVersion, setTargetVersion] = useState('1');
+  /** 已知最大版本号；首次发布为 0。 */
+  const [latestVersionNumber, setLatestVersionNumber] = useState(0);
   const metadataSuggestionRequestRef = useRef(0);
+  const publicationRequestRef = useRef(0);
+  const publicationDraftAppliedRef = useRef(false);
+  /** 回读冻结资料里的设备/输入/方向声明：面板不编辑，但更新发布必须原样沿用。 */
+  const restoredDeclarationsRef = useRef<{
+    deviceSupport?: GameDistributionPublishMetadata['deviceSupport'];
+    inputModes?: GameDistributionPublishMetadata['inputModes'];
+    orientation?: GameDistributionPublishMetadata['orientation'];
+  } | null>(null);
   const summaryTouchedRef = useRef(false);
   const categoryTouchedRef = useRef(false);
   const coverInputRef = useRef<HTMLInputElement>(null);
@@ -211,6 +300,8 @@ export function GameDistributionPublishPanel({
     setTitle(manifest.name.trim());
     setSummary(fallbackSummary);
     setCategory('其他');
+    setCover(null);
+    setScreenshots([]);
     setBusy(false);
     setError('');
     setResult(null);
@@ -222,10 +313,19 @@ export function GameDistributionPublishPanel({
     setCoverGenerationDetail('');
     setPreviewScreenshot(null);
     setPublishPhase(null);
+    setPublicationState('checking');
+    setPublicationBinding(null);
+    setPublicationRefreshed(false);
+    setPublicationMessage('');
+    setTargetVersion('1');
+    setLatestVersionNumber(0);
     summaryTouchedRef.current = false;
     categoryTouchedRef.current = false;
+    publicationDraftAppliedRef.current = false;
+    restoredDeclarationsRef.current = null;
+    uploadedAssetCacheRef.current.clear();
 
-    const requestId = ++metadataSuggestionRequestRef.current;
+    const suggestionRequestId = ++metadataSuggestionRequestRef.current;
     setMetadataSuggestionPending(true);
     void suggestGameDistributionPublishMetadata({
       name: manifest.name,
@@ -233,11 +333,20 @@ export function GameDistributionPublishPanel({
       context: buildPublishProjectContext(manifest),
     })
       .then((suggestion) => {
-        if (requestId !== metadataSuggestionRequestRef.current) return;
-        if (!summaryTouchedRef.current && suggestion.summary.trim()) {
+        if (suggestionRequestId !== metadataSuggestionRequestRef.current) return;
+        // 更新发布以线上冻结资料为准：已有草稿回填时不再用 AI 建议覆盖。
+        if (
+          !publicationDraftAppliedRef.current &&
+          !summaryTouchedRef.current &&
+          suggestion.summary.trim()
+        ) {
           setSummary(suggestion.summary.trim().slice(0, 120));
         }
-        if (!categoryTouchedRef.current && suggestion.category) {
+        if (
+          !publicationDraftAppliedRef.current &&
+          !categoryTouchedRef.current &&
+          suggestion.category
+        ) {
           setCategory(suggestion.category);
         }
         setMetadataSuggestionReady(true);
@@ -246,11 +355,91 @@ export function GameDistributionPublishPanel({
         // 免费增强能力失败时保留本地兜底，不阻断发布。
       })
       .finally(() => {
-        if (requestId === metadataSuggestionRequestRef.current) {
+        if (suggestionRequestId === metadataSuggestionRequestRef.current) {
           setMetadataSuggestionPending(false);
         }
       });
-  }, [manifest, open, packageResult?.packageRelativePath]);
+
+    // 绑定恢复：原生按当前会话（账号 + origin）隔离；网络/401/5xx 返回 unavailable，
+    // 面板据此禁用提交而不是退化成首次发布。
+    const invoke = resolveTauriInvoke();
+    if (!invoke) {
+      // 非 Tauri 宿主：没有可恢复的原生状态，交给提交时的失败提示兜底。
+      setPublicationState('first-publish');
+      return;
+    }
+    const publicationRequestId = ++publicationRequestRef.current;
+    void readGameDistributionPublication({ projectPath })
+      .then((recovery) => {
+        if (publicationRequestId !== publicationRequestRef.current) return;
+        if (recovery.state === 'unavailable') {
+          setPublicationState('unavailable');
+          setPublicationMessage(
+            recovery.message?.trim() ||
+              '无法确认该项目的线上发布状态，请稍后重试',
+          );
+          return;
+        }
+        if (recovery.state === 'update') {
+          const latest = recovery.binding.latestVersionNumber ?? null;
+          const max = latest ?? 0;
+          setPublicationState('update');
+          setPublicationBinding(recovery.binding);
+          setPublicationRefreshed(recovery.refreshed);
+          setPublicationMessage(recovery.message?.trim() ?? '');
+          setLatestVersionNumber(max);
+          setTargetVersion(String(max + 1));
+          if (recovery.draft) {
+            applyPublicationDraft(recovery.draft);
+          }
+          return;
+        }
+        setPublicationState('first-publish');
+        setPublicationMessage(recovery.message?.trim() ?? '');
+      })
+      .catch((recoveryError) => {
+        if (publicationRequestId !== publicationRequestRef.current) return;
+        setPublicationState('unavailable');
+        setPublicationMessage(
+          recoveryError instanceof Error
+            ? recoveryError.message
+            : '无法确认该项目的线上发布状态，请稍后重试',
+        );
+      });
+
+    function applyPublicationDraft(
+      draft: NonNullable<
+        Extract<
+          GameDistributionPublicationReadResult,
+          { state: 'update' }
+        >['draft']
+      >,
+    ) {
+      publicationDraftAppliedRef.current = true;
+      restoredDeclarationsRef.current = {
+        deviceSupport: draft.deviceSupport ?? undefined,
+        inputModes: draft.inputModes?.length ? draft.inputModes : undefined,
+        orientation: draft.orientation ?? undefined,
+      };
+      if (draft.title.trim()) setTitle(draft.title.trim().slice(0, 40));
+      if (!summaryTouchedRef.current && draft.summary.trim()) {
+        setSummary(draft.summary.trim().slice(0, 120));
+      }
+      if (!categoryTouchedRef.current && draft.category) {
+        setCategory(draft.category);
+      }
+      if (draft.cover && (draft.cover.assetId || draft.cover.previewUrl)) {
+        setCover(buildRestoredCover(draft.cover));
+      }
+      if (draft.screenshots.length > 0) {
+        setScreenshots(
+          draft.screenshots.map((screenshot, index) =>
+            buildRestoredScreenshot(screenshot, index),
+          ),
+        );
+      }
+    }
+  }, [manifest, open, packageResult?.packageRelativePath, projectPath]);
 
   useEffect(() => {
     if (!open) return;
@@ -428,7 +617,7 @@ export function GameDistributionPublishPanel({
     // 每张截图独立上传、独立失败；某一张失败只标记该张，不打断同批其它截图。
     await Promise.all(
       entries.map(async (entry) => {
-        if (entry.status === 'failed') return;
+        if (entry.status === 'failed' || !entry.file) return;
         try {
           const assetObjectId = await resolveAssetObjectId(
             entry.file,
@@ -478,10 +667,35 @@ export function GameDistributionPublishPanel({
       setError('需要在 Tauri App 内发布');
       return;
     }
+    if (publicationState === 'checking') {
+      setError('正在确认项目发布状态，请稍候再试');
+      return;
+    }
+    if (publicationState === 'unavailable') {
+      setError(
+        publicationMessage || '无法确认该项目的线上发布状态，请稍后重试',
+      );
+      return;
+    }
+    const parsedTargetVersion = parseTargetVersion(targetVersion);
+    if (parsedTargetVersion === null) {
+      setError('目标版本号必须是大于 0 的整数');
+      return;
+    }
+    if (parsedTargetVersion <= latestVersionNumber) {
+      setError(
+        `目标版本号必须大于当前最大版本号 ${latestVersionNumber}，不能覆盖已有版本`,
+      );
+      return;
+    }
     if (!cover) {
       setError('请先选择游戏封面（JPG/PNG/WebP）');
       return;
     }
+    if (!cover.assetObjectId.trim()) {
+      setError('当前发布封面缺少平台素材，请重新选择封面后再发布');
+      return;
+    }
     if (
       uploadingLabel ||
       screenshots.some((item) => item.status === 'uploading')
@@ -537,7 +751,14 @@ export function GameDistributionPublishPanel({
               } => item.status === 'ready' && Boolean(item.assetObjectId),
             )
             .map((item) => item.assetObjectId),
+          // 更新发布沿用线上冻结的设备/输入/方向声明；首次发布没有这些值，服务端默认。
+          ...(restoredDeclarationsRef.current ?? {}),
         },
+        gameId:
+          publicationState === 'update' ? publicationBinding?.gameId ?? null : null,
+        versionNumber: parsedTargetVersion,
+        expectedPublicationRevision:
+          publicationState === 'update' ? publicationBinding?.revision ?? null : null,
       });
       setResult(next);
       onPublished?.(next);
@@ -607,6 +828,42 @@ export function GameDistributionPublishPanel({
           </div>
         ) : (
           <>
+            <div
+              className={`game-distribution-publish-panel__publication is-${publicationState}`}
+              role="status"
+            >
+              <strong>
+                {publicationState === 'update'
+                  ? '更新游戏'
+                  : publicationState === 'unavailable'
+                    ? '无法确认发布状态'
+                    : publicationState === 'checking'
+                      ? '正在检查发布绑定…'
+                      : '首次发布'}
+              </strong>
+              {publicationState === 'update' && publicationBinding ? (
+                <span>
+                  当前版本{' '}
+                  {latestVersionNumber > 0 ? latestVersionNumber : '—'} ·{' '}
+                  {publicationVersionStatusLabel(publicationBinding.status)}
+                  {publicationRefreshed
+                    ? ''
+                    : '（未能刷新线上状态，发布以服务端校验为准）'}
+                </span>
+              ) : publicationState === 'first-publish' ? (
+                <span>这个项目还没有发布到游戏广场。</span>
+              ) : publicationState === 'checking' ? (
+                <span>正在读取本地绑定与线上作品状态。</span>
+              ) : (
+                <span>
+                  {publicationMessage ||
+                    '无法确认该项目的线上发布状态，请稍后重试。'}
+                </span>
+              )}
+              {publicationState === 'update' && publicationMessage ? (
+                <span>{publicationMessage}</span>
+              ) : null}
+            </div>
             <div className="game-distribution-publish-panel__fields">
               <label>
                 游戏名称
@@ -647,6 +904,28 @@ export function GameDistributionPublishPanel({
                   ))}
                 </select>
               </label>
+              <label>
+                目标版本号
+                <input
+                  type="number"
+                  min={1}
+                  step={1}
+                  inputMode="numeric"
+                  value={targetVersion}
+                  disabled={
+                    busy ||
+                    generatingCover ||
+                    publicationState === 'checking' ||
+                    publicationState === 'unavailable'
+                  }
+                  onChange={(event) => setTargetVersion(event.target.value)}
+                />
+              </label>
+              <span className="game-distribution-publish-panel__hint">
+                {latestVersionNumber > 0
+                  ? `当前最大版本号 ${latestVersionNumber}，建议 ${latestVersionNumber + 1}；允许跳号，但不能小于等于当前版本号。`
+                  : '首次发布建议使用版本号 1；版本号必须是大于 0 的整数。'}
+              </span>
               <span
                 className="game-distribution-publish-panel__metadata-hint"
                 role="status"
@@ -872,6 +1151,8 @@ export function GameDistributionPublishPanel({
                   generatingCover ||
                   screenshotsUploading ||
                   Boolean(uploadingLabel) ||
+                  publicationState === 'checking' ||
+                  publicationState === 'unavailable' ||
                   !title.trim() ||
                   !summary.trim() ||
                   !packageResult
@@ -885,7 +1166,13 @@ export function GameDistributionPublishPanel({
                       ? '截图上传中…'
                       : uploadingLabel
                         ? '素材上传中…'
-                        : '发布游戏'}
+                        : publicationState === 'update'
+                          ? '更新游戏'
+                          : publicationState === 'checking'
+                            ? '正在检查发布状态…'
+                            : publicationState === 'unavailable'
+                              ? '无法确认发布状态'
+                              : '发布游戏'}
               </button>
             </div>
           </>
diff --git a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
index 5a81a1700..1db81edf0 100644
--- a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
+++ b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
@@ -1,7 +1,11 @@
-import type { GameCreationAppManifest } from '../../../../packages/shared/src/contracts/gameCreationApp';
+import type {
+  GameCreationAppManifest,
+  GameCreationAppPublicationBinding,
+} from '../../../../packages/shared/src/contracts/gameCreationApp';
 import type {
   GameDistributionCategory,
   GameDistributionCreateGameRequest,
+  GameDistributionDeviceSupport,
   GameDistributionInputMode,
   GameDistributionOrientation,
 } from '../../../../packages/shared/src/contracts/gameDistribution';
@@ -46,8 +50,91 @@ export type GameDistributionPublishResult = {
   packageSha256: string;
   packageSizeBytes: number;
   fileCount: number;
+  /** 发布成功并回写绑定后的整份 manifest；渲染层据此同步工作台状态。 */
+  manifest?: GameCreationAppManifest | null;
+  publication?: GameCreationAppPublicationBinding | null;
 };
 
+/** 更新发布时默认回填的封面/截图；`assetId` 缺失表示历史版本没有冻结素材，需重新选择。 */
+export type GameDistributionPublicationImageDraft = {
+  assetId: string | null;
+  previewUrl: string | null;
+};
+
+export type GameDistributionPublicationDraft = {
+  title: string;
+  summary: string;
+  description: string;
+  category: GameDistributionCategory;
+  tags: string[];
+  cover: GameDistributionPublicationImageDraft | null;
+  screenshots: GameDistributionPublicationImageDraft[];
+  /** 随版本冻结的设备/输入/方向声明；更新发布必须原样沿用，避免被默认值改写。 */
+  deviceSupport?: GameDistributionDeviceSupport | null;
+  inputModes?: GameDistributionInputMode[];
+  orientation?: GameDistributionOrientation | null;
+};
+
+/**
+ * 发布面板打开时的发布状态回读。
+ *
+ * `state` 三态必须分开处理：`unavailable` 表示恢复被网络/401/5xx 挡住，绝不能当成首次发布；
+ * `first-publish` 只在服务端给出确定答案（无绑定且作者名下没有匹配作品）时出现。
+ */
+export type GameDistributionPublicationReadResult =
+  | {
+      state: 'first-publish';
+      binding: null;
+      refreshed: boolean;
+      draft: null;
+      visibility: null;
+      message?: string | null;
+    }
+  | {
+      state: 'update';
+      binding: GameCreationAppPublicationBinding;
+      refreshed: boolean;
+      draft: GameDistributionPublicationDraft | null;
+      visibility?: string | null;
+      message?: string | null;
+    }
+  | {
+      state: 'unavailable';
+      binding: null;
+      refreshed: false;
+      draft: null;
+      visibility: null;
+      message?: string | null;
+    };
+
+/**
+ * 发布面板打开时由原生恢复本地绑定与线上作品状态。
+ *
+ * 原生按当前会话（账号 + origin）隔离绑定：切换账号/环境后不会接管他人作品；无本地绑定时
+ * 按作者作品的 `localProjectId` 精确匹配做一次性恢复。网络/401/5xx 返回 `unavailable`，
+ * 调用方不得据此按首次发布继续。
+ */
+export async function readGameDistributionPublication(
+  args: { projectPath: string },
+  invoke?: TauriInvoke,
+): Promise<GameDistributionPublicationReadResult> {
+  const projectPath = args.projectPath.trim();
+  if (!projectPath) {
+    throw new Error('发布需要绑定本地项目');
+  }
+  const payload = await requireNativeInvoke(invoke)<
+    GameDistributionPublicationReadResult | null | undefined
+  >('read_game_distribution_publication', { projectPath });
+  const state = payload?.state;
+  if (
+    !payload ||
+    (state !== 'first-publish' && state !== 'update' && state !== 'unavailable')
+  ) {
+    throw new Error('发布状态回读结果无效');
+  }
+  return payload;
+}
+
 export type GameDistributionPublishMetadataSuggestion = {
   summary: string;
   category: GameDistributionCategory;
@@ -205,11 +292,21 @@ export async function publishLocalProjectGame(args: {
   packageRelativePath: string;
   manifest: GameCreationAppManifest;
   metadata?: Partial<GameDistributionPublishMetadata>;
+  /**
+   * 更新已有作品时的目标游戏身份（来自发布绑定）。提供时必须同时给出
+   * `versionNumber` 与 `expectedPublicationRevision`：原生会跳过 create game，
+   * 直接在原 gameId 上创建新版本。
+   */
+  gameId?: string | null;
+  /** 用户选择的目标正整数版本号；首次发布默认 1。不传则退回服务端自动递增。 */
+  versionNumber?: number | null;
+  /** 更新送审所需的公开修订号 CAS；来自发布绑定。 */
+  expectedPublicationRevision?: number | null;
   /**
    * 发布根幂等键。渲染层默认**不**生成也不持久化它：原生发布链路按
-   * 「账号身份 + 本地项目 + 发行包摘要」在应用数据里维护发布尝试账本，同一份包
-   * 重发、响应丢失、进程重启与分片续传都落在同一次服务端尝试上。只有显式传入
-   * （测试或调用方已持有键）时才覆盖账本。
+   * 「账号身份 + 本地项目 + 发行包摘要 + 目标游戏/版本 + 资料摘要」在应用数据里维护发布
+   * 尝试账本，同一份包重发、响应丢失、进程重启与分片续传都落在同一次服务端尝试上。
+   * 只有显式传入（测试或调用方已持有键）时才覆盖账本。
    */
   idempotencyKey?: string;
 }): Promise<GameDistributionPublishResult> {
@@ -223,16 +320,42 @@ export async function publishLocalProjectGame(args: {
   if (!localProjectId) {
     throw new Error('发布需要本地项目标识，请重新打开项目后再试');
   }
+  const gameId = args.gameId?.trim() ?? '';
+  const versionNumber = args.versionNumber ?? null;
+  if (versionNumber !== null) {
+    if (
+      !Number.isSafeInteger(versionNumber) ||
+      versionNumber <= 0
+    ) {
+      throw new Error('目标版本号必须是大于 0 的安全整数');
+    }
+  }
+  if (gameId) {
+    if (versionNumber === null) {
+      throw new Error('更新游戏必须填写目标版本号');
+    }
+    if (
+      args.expectedPublicationRevision === null ||
+      args.expectedPublicationRevision === undefined
+    ) {
+      throw new Error('缺少公开修订号，请重新打开发布面板后再试');
+    }
+  }
   const gameMetadata = toCreateGameRequest(metadata, localProjectId);
   const rootKey = args.idempotencyKey?.trim() ?? '';
   // 发布编排、认证、origin、分片续传与送审都在 Rust 完成；渲染进程只传递
-  // 已归一化的资料和本地项目相对包路径，不接触 token、base URL 或整包字节。
+  // 已归一化的资料、目标游戏/版本和本地项目相对包路径，不接触 token、base URL 或整包字节。
   return args.invoke<GameDistributionPublishResult>(
     'publish_local_project_game',
     {
       projectPath,
       packageRelativePath,
       metadata: gameMetadata,
+      ...(gameId ? { gameId } : {}),
+      ...(versionNumber !== null ? { versionNumber } : {}),
+      ...(gameId
+        ? { expectedPublicationRevision: args.expectedPublicationRevision }
+        : {}),
       ...(rootKey ? { idempotencyKey: rootKey } : {}),
     },
   );
diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index 60afebf6e..23721cf63 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -3558,6 +3558,36 @@ textarea {
   line-height: 1.5;
 }
 
+.game-distribution-publish-panel__publication {
+  display: grid;
+  gap: 4px;
+  margin-top: 16px;
+  padding: 10px 12px;
+  border: 1px solid rgb(104 77 57 / 16%);
+  border-radius: 10px;
+  background: rgb(255 246 238 / 72%);
+  color: var(--platform-text-muted);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 1.5;
+}
+
+.game-distribution-publish-panel__publication strong {
+  color: var(--platform-text-strong);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.game-distribution-publish-panel__publication.is-unavailable {
+  border-color: rgb(180 35 24 / 28%);
+  background: rgb(255 240 238 / 78%);
+  color: #b42318;
+}
+
+.game-distribution-publish-panel__publication.is-unavailable strong {
+  color: #b42318;
+}
+
 .game-distribution-publish-panel__fields label {
   display: grid;
   gap: 6px;
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
index d6c4e518e..67be97d81 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
@@ -7,6 +7,7 @@ import {
   generateGameDistributionCover,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../src/services/gameDistributionPublish';
 const MANIFEST = {
@@ -248,4 +249,109 @@ describe('Rust 发布 facade', () => {
       },
     ]);
   });
+
+  test('发布状态恢复通过单个 native command 传递项目路径与三态结果', async () => {
+    const updateResult = {
+      state: 'update',
+      binding: {
+        accountId: 'user-1',
+        apiBaseUrl: 'https://dev.test',
+        gameId: 'game_9',
+        revision: 7,
+        latestVersionId: 'gamever_2',
+        latestVersionNumber: 2,
+        status: 'pending_review',
+      },
+      refreshed: true,
+      draft: null,
+      visibility: 'published',
+    };
+    const { invoke, calls } = installNativeInvoke((command) => {
+      if (command === 'read_game_distribution_publication') {
+        return updateResult;
+      }
+      throw new Error(`未预期的命令：${command}`);
+    });
+
+    await expect(
+      readGameDistributionPublication({ projectPath: '/tmp/project' }, invoke),
+    ).resolves.toEqual(updateResult);
+    expect(calls).toEqual([
+      {
+        command: 'read_game_distribution_publication',
+        args: { projectPath: '/tmp/project' },
+      },
+    ]);
+  });
+
+  test('恢复结果缺少已知三态时失败关闭，不把未知结果当成首次发布', async () => {
+    const { invoke } = installNativeInvoke(() => undefined);
+    await expect(
+      readGameDistributionPublication({ projectPath: '/tmp/project' }, invoke),
+    ).rejects.toThrow('发布状态回读结果无效');
+  });
+
+  test('更新发布会带上原 gameId、目标版本号与公开修订号', async () => {
+    const { invoke, calls } = installNativeInvoke(() => PUBLISH_RESULT);
+
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      manifest: MANIFEST,
+      metadata: { coverAssetId: 'asset_cover' },
+      gameId: 'game_9',
+      versionNumber: 3,
+      expectedPublicationRevision: 7,
+    });
+
+    expect(calls[0]?.args).toMatchObject({
+      gameId: 'game_9',
+      versionNumber: 3,
+      expectedPublicationRevision: 7,
+    });
+  });
+
+  test('更新发布缺少目标版本号或公开修订号时在 native command 前失败关闭', async () => {
+    const invoke = vi.fn() as unknown as TauriInvoke;
+    await expect(
+      publishLocalProjectGame({
+        invoke,
+        projectPath: '/tmp/project',
+        packageRelativePath: 'exports/playtest-package-1.zip',
+        manifest: MANIFEST,
+        metadata: { coverAssetId: 'asset_cover' },
+        gameId: 'game_9',
+      }),
+    ).rejects.toThrow('更新游戏必须填写目标版本号');
+    await expect(
+      publishLocalProjectGame({
+        invoke,
+        projectPath: '/tmp/project',
+        packageRelativePath: 'exports/playtest-package-1.zip',
+        manifest: MANIFEST,
+        metadata: { coverAssetId: 'asset_cover' },
+        gameId: 'game_9',
+        versionNumber: 3,
+      }),
+    ).rejects.toThrow('缺少公开修订号');
+    expect(invoke).not.toHaveBeenCalled();
+  });
+
+  test('目标版本号不是安全整数时在 native command 前失败关闭', async () => {
+    const invoke = vi.fn() as unknown as TauriInvoke;
+    for (const versionNumber of [0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1]) {
+      await expect(
+        publishLocalProjectGame({
+          invoke,
+          projectPath: '/tmp/project',
+          packageRelativePath: 'exports/playtest-package-1.zip',
+          manifest: MANIFEST,
+          metadata: { coverAssetId: 'asset_cover' },
+          versionNumber,
+        }),
+      ).rejects.toThrow('目标版本号必须是大于 0 的安全整数');
+    }
+    expect(invoke).not.toHaveBeenCalled();
+  });
 });
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
index ac81e4baa..8fa36e44c 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
@@ -502,20 +502,31 @@ liveTest(
             String(metadata.localProjectId),
             staged.packageSha256,
           );
-        const game = await unwrap<{
-          id: string;
-          publicationRevision?: number;
-        }>(
-          await realFetch(apiUrl('/api/game-distribution/games'), {
-            method: 'POST',
-            headers: {
-              ...packageAuthHeaders(token),
-              'Content-Type': 'application/json',
-              'Idempotency-Key': `${rootKey}:game`,
-            },
-            body: JSON.stringify(metadata),
-          }),
-        );
+        // 更新模式：带原 gameId 时跳过 create game，直接在原游戏上创建新版本。
+        const requestedGameId = String(args?.gameId ?? '').trim();
+        const requestedVersionNumber =
+          typeof args?.versionNumber === 'number' ? args.versionNumber : undefined;
+        const game = requestedGameId
+          ? {
+              id: requestedGameId,
+              publicationRevision: Number(
+                args?.expectedPublicationRevision ?? 0,
+              ),
+            }
+          : await unwrap<{
+              id: string;
+              publicationRevision?: number;
+            }>(
+              await realFetch(apiUrl('/api/game-distribution/games'), {
+                method: 'POST',
+                headers: {
+                  ...packageAuthHeaders(token),
+                  'Content-Type': 'application/json',
+                  'Idempotency-Key': `${rootKey}:game`,
+                },
+                body: JSON.stringify(metadata),
+              }),
+            );
         const version = await unwrap<{
           versionId: string;
           versionNumber: number;
@@ -536,6 +547,9 @@ liveTest(
                 packageBytes: staged.packageSizeBytes,
                 packageFileCount: staged.packageFileCount,
                 packageEntryPath: 'index.html',
+                ...(requestedVersionNumber === undefined
+                  ? {}
+                  : { versionNumber: requestedVersionNumber }),
                 gameMetadata: metadata,
               }),
             },
@@ -660,6 +674,29 @@ liveTest(
     expect(second.gameId).toBe(first.gameId);
     expect(second.versionNumber).toBe(first.versionNumber + 1);
 
+    // 更新发布：AGC 带原 gameId + 用户目标版本号，跳过 create game，只新增版本。
+    const ownerDetail = await unwrap<{
+      game: { publicationRevision: number };
+    }>(
+      await realFetch(
+        apiUrl(`/api/game-distribution/my-games/${second.gameId}`),
+        { headers: { Authorization: `Bearer ${token}`, ...ENVELOPE_HEADERS } },
+      ),
+    );
+    const targetVersionNumber = 7;
+    const updated = await publishLocalProjectGame({
+      invoke,
+      projectPath: '/data/dsk/Genarrative/tmp-agc-live-project',
+      packageRelativePath: 'dist/game.zip',
+      manifest,
+      metadata: { ...metadata, inputModes: [...metadata.inputModes] },
+      gameId: second.gameId,
+      versionNumber: targetVersionNumber,
+      expectedPublicationRevision: ownerDetail.game.publicationRevision,
+    });
+    expect(updated.gameId).toBe(second.gameId);
+    expect(updated.versionNumber).toBe(targetVersionNumber);
+
     const myGames = await unwrap<{
       games: Array<{
         id: string;
@@ -671,8 +708,14 @@ liveTest(
       }),
     );
     const published = myGames.games.find((game) => game.id === first.gameId);
-    expect(published?.latestVersion?.versionId).toBe(second.versionId);
+    expect(published?.latestVersion?.versionId).toBe(updated.versionId);
     expect(published?.latestVersion?.status).toBe('pending_review');
+    // 更新只增加版本，不重复创建作品：该 localProjectId 在作者名下仍然只有一款游戏。
+    expect(
+      myGames.games.filter(
+        (game) => game.id === first.gameId || game.id === updated.gameId,
+      ),
+    ).toHaveLength(1);
   },
   120_000,
 );
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
index d23c916bf..19f0f046b 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
@@ -24,6 +24,7 @@ import {
   generateGameDistributionCover,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../src/services/gameDistributionPublish';
 import { GAME_PACKAGE_UPLOAD_PROGRESS_EVENT } from '../src/services/gamePackageUploadProgress';
@@ -41,6 +42,7 @@ vi.mock('../src/services/gameDistributionPublish', async (importOriginal) => {
     generateGameDistributionCover: vi.fn(),
     publishLocalProjectGame: vi.fn(),
     readGameCoverGenerationPrice: vi.fn(),
+    readGameDistributionPublication: vi.fn(),
     suggestGameDistributionPublishMetadata: vi.fn(),
   };
 });
@@ -125,6 +127,14 @@ beforeEach(() => {
   vi.mocked(suggestGameDistributionPublishMetadata).mockImplementation(
     () => new Promise(() => undefined),
   );
+  // 默认按「首次发布」恢复，保持既有用例的提交路径不变；更新模式用例单独覆盖。
+  vi.mocked(readGameDistributionPublication).mockResolvedValue({
+    state: 'first-publish',
+    binding: null,
+    refreshed: true,
+    draft: null,
+    visibility: null,
+  });
 });
 
 afterEach(() => {
@@ -134,6 +144,7 @@ afterEach(() => {
   vi.mocked(generateGameDistributionCover).mockReset();
   vi.mocked(publishLocalProjectGame).mockReset();
   vi.mocked(readGameCoverGenerationPrice).mockReset();
+  vi.mocked(readGameDistributionPublication).mockReset();
   vi.mocked(suggestGameDistributionPublishMetadata).mockReset();
   vi.mocked(uploadPlatformMediaAsset).mockReset();
   delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
@@ -488,7 +499,10 @@ describe('GameDistributionPublishPanel', () => {
     installTauriInvoke(async () => undefined);
     renderPanel();
 
-    fireEvent.click(screen.getByRole('button', { name: '发布游戏' }));
+    // 绑定恢复完成前提交按钮显示「正在检查发布状态…」，等待回到首次发布后再点击。
+    fireEvent.click(
+      await screen.findByRole('button', { name: '发布游戏' }),
+    );
 
     expect(
       await screen.findByText('请先选择游戏封面（JPG/PNG/WebP）'),
@@ -662,10 +676,147 @@ describe('GameDistributionPublishPanel', () => {
     cleanup();
     installTauriInvoke(async () => undefined);
     renderPanel({ packageResult: null });
-    expect(screen.getByRole('button', { name: '发布游戏' })).toHaveProperty(
-      'disabled',
-      true,
-    );
+    expect(
+      await screen.findByRole('button', { name: '发布游戏' }),
+    ).toHaveProperty('disabled', true);
     expect(screen.queryByLabelText('发行包摘要')).toBeNull();
   });
+
+  test('已有绑定时进入更新模式，回填线上资料并提交原 gameId 与更高版本号', async () => {
+    installTauriInvoke(async () => undefined);
+    vi.mocked(readGameDistributionPublication).mockResolvedValue({
+      state: 'update',
+      binding: {
+        accountId: 'user-1',
+        apiBaseUrl: 'https://dev.test',
+        gameId: 'game_9',
+        revision: 7,
+        latestVersionId: 'gamever_2',
+        latestVersionNumber: 2,
+        status: 'pending_review',
+      },
+      refreshed: true,
+      draft: {
+        title: '星轨防线（线上）',
+        summary: '线上简介',
+        description: '线上详介',
+        category: '策略',
+        tags: ['塔防'],
+        cover: {
+          assetId: 'asset_cover_old',
+          previewUrl: 'https://assets.test/cover.png',
+        },
+        screenshots: [
+          {
+            assetId: 'asset_shot_old',
+            previewUrl: 'https://assets.test/shot.png',
+          },
+        ],
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+        inputModes: ['keyboard', 'mouse'],
+        orientation: 'landscape',
+      },
+      visibility: 'published',
+    });
+    vi.mocked(publishLocalProjectGame).mockResolvedValue({
+      gameId: 'game_9',
+      versionId: 'gamever_3',
+      versionNumber: 3,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    const { onPublished } = renderPanel();
+
+    // 回填线上冻结资料，目标版本默认「最大版本号 + 1」。
+    await screen.findByRole('button', { name: '更新游戏' });
+    expect(screen.getByLabelText('游戏名称')).toHaveProperty(
+      'value',
+      '星轨防线（线上）',
+    );
+    expect(screen.getByLabelText('一句话简介')).toHaveProperty(
+      'value',
+      '线上简介',
+    );
+    expect(screen.getByLabelText('目标版本号')).toHaveProperty('value', '3');
+    expect(
+      screen.getByText(/当前最大版本号 2，建议 3/u),
+    ).not.toBeNull();
+
+    fireEvent.click(screen.getByRole('button', { name: '更新游戏' }));
+    await waitFor(() =>
+      expect(publishLocalProjectGame).toHaveBeenCalledTimes(1),
+    );
+    const args = vi.mocked(publishLocalProjectGame).mock.calls[0]?.[0];
+    expect(args?.gameId).toBe('game_9');
+    expect(args?.versionNumber).toBe(3);
+    expect(args?.expectedPublicationRevision).toBe(7);
+    // 冻结素材 ID 直接复用，不要求作者重新上传封面/截图。
+    expect(args?.metadata?.coverAssetId).toBe('asset_cover_old');
+    expect(args?.metadata?.screenshots).toEqual(['asset_shot_old']);
+    // 设备/输入/方向声明沿用线上冻结值，不被创建请求默认值改写。
+    expect(args?.metadata?.deviceSupport).toEqual({
+      desktop: true,
+      mobile: false,
+      touch: false,
+    });
+    expect(args?.metadata?.inputModes).toEqual(['keyboard', 'mouse']);
+    expect(args?.metadata?.orientation).toBe('landscape');
+    expect(await screen.findByText('已提交审核')).not.toBeNull();
+    expect(onPublished).toHaveBeenCalledTimes(1);
+  });
+
+  test('目标版本号不大于当前最大版本号时本地拦截且不发起发布', async () => {
+    installTauriInvoke(async () => undefined);
+    vi.mocked(readGameDistributionPublication).mockResolvedValue({
+      state: 'update',
+      binding: {
+        accountId: 'user-1',
+        apiBaseUrl: 'https://dev.test',
+        gameId: 'game_9',
+        revision: 7,
+        latestVersionId: 'gamever_5',
+        latestVersionNumber: 5,
+        status: 'published',
+      },
+      refreshed: true,
+      draft: null,
+      visibility: 'published',
+    });
+    renderPanel();
+    await screen.findByRole('button', { name: '更新游戏' });
+
+    fireEvent.change(screen.getByLabelText('目标版本号'), {
+      target: { value: '5' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '更新游戏' }));
+
+    expect(
+      await screen.findByText(/目标版本号必须大于当前最大版本号 5/u),
+    ).not.toBeNull();
+    expect(publishLocalProjectGame).not.toHaveBeenCalled();
+  });
+
+  test('恢复失败（网络/5xx）时禁用提交，不按首次发布继续', async () => {
+    installTauriInvoke(async () => undefined);
+    vi.mocked(readGameDistributionPublication).mockResolvedValue({
+      state: 'unavailable',
+      binding: null,
+      refreshed: false,
+      draft: null,
+      visibility: null,
+      message: '无法刷新线上状态：无法连接登录服务',
+    });
+    renderPanel();
+
+    const submit = await screen.findByRole('button', {
+      name: '无法确认发布状态',
+    });
+    expect(submit).toHaveProperty('disabled', true);
+    expect(
+      screen.getByText('无法刷新线上状态：无法连接登录服务'),
+    ).not.toBeNull();
+    expect(publishLocalProjectGame).not.toHaveBeenCalled();
+  });
 });
diff --git a/docs/project-memory/plans/【实施计划】AGC已发布游戏版本更新-2026-10-02.md b/docs/project-memory/plans/【实施计划】AGC已发布游戏版本更新-2026-10-02.md
new file mode 100644
index 000000000..aeddd0ff9
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】AGC已发布游戏版本更新-2026-10-02.md
@@ -0,0 +1,40 @@
+# 【实施计划】AGC 已发布游戏版本更新
+
+| 字段 | 值 |
+| --- | --- |
+| Milestone | `docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md` |
+| Status | proposed |
+| Owner | Genarrative Agent |
+
+## 修改边界
+
+- `packages/shared/src/contracts/gameCreationApp.ts`：本地 `publication` 绑定，不混入本地编辑迭代 `versions[]`。
+- `packages/shared/src/contracts/gameDistribution.ts` 与 Rust shared-contracts：创建版本请求增加可选 `versionNumber`。
+- `apps/ai-game-creator-shell`：绑定回读、首次发布/更新 UI、目标版本输入、原 gameId 新版本发布、结果回写。
+- `api-server`、`spacetime-client`、`spacetime-module`：把可选目标版本号传入现有创建版本 procedure，事务内比较最大版本号并拒绝冲突。
+- 现有创建版本 procedure 输入/生成绑定需要同步，但不修改持久表字段。
+
+## 实现顺序
+
+1. 契约先补 `versionNumber?: number` 和本地 `publication`，明确版本号校验与兼容。
+2. 创建版本事务在未传时自动递增；传入时必须大于现有最大版本号，并在同事务内校验。
+3. AGC 发布绑定保存 `gameId`、最新版本、状态和 revision；按账号和 API origin 隔离绑定。
+4. AGC 打开项目回读已有作品；旧项目通过 `localProjectId` 恢复关联。
+5. 发布面板区分首次发布/更新，给出当前版本和可编辑目标版本输入。
+6. Rust 发布 facade 在更新模式跳过创建 game，使用原 gameId 创建新 version；幂等账本把目标版本号纳入发布意图，不能仅以 ZIP 摘要合并不同发布。
+7. 验证重复提交、响应丢失、切换账号、版本冲突、旧作品恢复，以及旧公开版本在新版本审核中继续可玩。
+
+## 数据库影响
+
+- 不新增表。
+- 不修改 `version_number` 字段类型或重排字段。
+- 修改创建版本 procedure 输入 DTO 与生成绑定；按当前 SpacetimeDB 门禁验证。
+- 老客户端不传版本号仍自动递增，已有版本和历史数据不需要回填。
+
+## 验证
+
+- 领域/数据库创建版本测试：默认递增、指定更高版本、重复/较小/零/负数/非整数/越界输入、并发相同目标号。
+- AGC 发布面板测试：首发、更新、默认目标版本、用户改号和恢复失败。
+- AGC Rust 发布测试：跳过 create game、原 gameId、新 version、结果持久化、幂等意图区分。
+- `npm run typecheck`、定向 Rust/Vitest、schema/生成绑定检查、编码与 diff。
+- 真机发布：首次发布 → 重开项目 → 修改游戏 → 指定更高版本 → 更新送审 → 审核后原公开链接运行新包。
diff --git a/docs/project-memory/plans/【实施计划】后台游戏审核详情与待审版本试玩-2026-10-02.md b/docs/project-memory/plans/【实施计划】后台游戏审核详情与待审版本试玩-2026-10-02.md
new file mode 100644
index 000000000..845fce1e3
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】后台游戏审核详情与待审版本试玩-2026-10-02.md
@@ -0,0 +1,52 @@
+# 【实施计划】后台游戏审核详情与待审版本试玩
+
+| 字段 | 值 |
+| --- | --- |
+| Milestone | `docs/project-memory/plans/【里程碑】后台游戏审核详情与待审版本试玩-2026-10-02.md` |
+| Status | in-progress |
+| Owner | Genarrative Agent |
+
+## 修改边界
+
+### 允许修改
+
+- `server-rs/crates/api-server`：管理员版本详情/预览会话/待审版本资源读取，以及现有发行资源公共逻辑的安全复用。
+- `server-rs/crates/shared-contracts`、`apps/admin-web/src/api`：审核详情、预览会话和资料字段 DTO。
+- `apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx` 及其测试：详情工作台、试玩入口、审核动作刷新。
+- 现有 admin 权限映射、发行 sandbox/CSP/storage 兼容逻辑的必要扩展。
+- 当前玩法主规范、里程碑证据和实施计划。
+
+### 明确不修改
+
+- `spacetime-module` 持久表结构、`migration.rs`、SpacetimeDB schema 和现有生成绑定，除非调研发现当前字段不足并重新获得迁移确认。
+- `/api/external/v1`、作者发布页面、公开游戏详情和用户评价数据模型。
+- 审核员分派、批量审核、精选推荐和后台游戏资料编辑。
+
+## 实现顺序
+
+1. 固化现有详情响应的字段映射与权限边界，先补 admin DTO 和契约测试。
+2. 定义版本绑定的短期预览会话与错误语义，复用发行 ZIP 路径白名单、大小限制、HTML 注入、CSP 和响应头。
+3. 实现管理员待审版本预览资源读取，确认公开发行路径不能读取未公开版本。
+4. 将审核列表升级为详情工作台：资料分组、发布者、版本摘要、封面/截图、试玩状态和审核动作。
+5. 补齐正常、拒绝、过期、越权、Cookie、缺文件、资源 404、CAS 冲突和幂等重放测试。
+6. 运行真实本地审核 smoke，确认打开的是待审 `versionId`，不是当前公开版本；完成后回写主规范并删除临时计划。
+
+## 验证命令
+
+1. `npm run typecheck`
+2. `npm exec -- vitest run apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx apps/admin-web/src/api/adminApiClient.test.ts --root .`
+3. `cargo test -p api-server game_distribution --manifest-path server-rs/Cargo.toml`
+4. `cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check`
+5. `npm run check:encoding`
+6. `npm run check:doc-index`
+7. `git diff --check`
+8. 本地 `npm run dev` + 管理员登录 + 待审版本详情/试玩 smoke。
+
+## 风险与回滚点
+
+- **预览越权**：Token 必须绑定 `versionId` 和过期时间；错误实现会把私有待审包变成可枚举资源。回滚点是关闭预览会话路由，不影响公开发行网关。
+- **版本串播**：预览 URL 不能复用 `game.currentVersion.entryUrl`；详情和资源读取都必须携带并校验待审版本。回滚点是隐藏试玩按钮，保留资料审核。
+- **sandbox 放宽**：不得添加 `allow-same-origin`；如 storage 兼容层回归，回滚新增注入逻辑而不放宽 sandbox。
+- **资料漂移**：详情必须展示版本冻结快照；若快照缺失，只显示明确缺失状态，不静默用作者当前资料替代。
+- **审核并发**：继续使用 `publicationRevision` 和幂等键；CAS 冲突只刷新，不自动重放决定。
+- **API 兼容**：新字段可选，旧后台响应不能因缺少冻结资料而崩溃；预览接口失败不能影响公开游戏游玩。
diff --git a/docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md b/docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md
new file mode 100644
index 000000000..140feea39
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md
@@ -0,0 +1,38 @@
+# 【里程碑】AGC 已发布游戏版本更新
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 1.0 |
+| Status | proposed |
+| Date | 2026-10-02 |
+| Parent Spec | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md#AGC 游戏分发与在线游玩合同` |
+
+## 目标
+
+让 AGC 区分首次发布与已有作品更新：已有作品继续使用原 `gameId`，创建不可覆盖的新版本；发布时用户可以决定目标正整数版本号。
+
+## 范围
+
+- 本地项目清单保存平台作品绑定和最近版本状态。
+- 打开项目时回读绑定作品；旧清单按 `localProjectId` 做一次性恢复。
+- 发布面板显示首次发布/更新模式、当前版本和建议目标版本。
+- 用户在发布时填写目标版本号，默认最大版本号加一。
+- 服务端可选接收 `versionNumber`；旧客户端不传时继续自动递增。
+- 同一 `gameId` 的新版本上传、校验、送审和结果回写。
+
+## 不在范围内
+
+- AGC 完整版本历史页、版本回滚、版本删除、版本对比。
+- 覆盖已有版本号或原地替换发行包。
+- 新增 SpacetimeDB 持久表或修改 `game_distribution_version.version_number` 类型。
+- 改变公开 URL、审核状态机、发行网关或后台审核权限。
+
+## 验收标准
+
+- [ ] 首次发布完成后项目清单保存 `gameId`、`versionId`、版本号、状态和 `publicationRevision`。
+- [ ] 重新打开同一项目显示“更新游戏”，不再显示“创建平台游戏”。
+- [ ] 默认目标版本为最大版本号加一，用户可改为更大的正整数。
+- [ ] 目标版本不大于已有最大版本号时服务端拒绝，不能覆盖旧版本。
+- [ ] 更新使用同一 `gameId`，只增加一个新 `versionId`，公开地址保持不变。
+- [ ] 旧项目没有发布绑定时能按作者和 `localProjectId` 恢复；恢复失败时明确回到首次发布。
+- [ ] 上传响应丢失、重复提交、版本号冲突和切换账号不会创建重复游戏或错误接管作品。
diff --git a/docs/project-memory/plans/【里程碑】后台游戏审核详情与待审版本试玩-2026-10-02.md b/docs/project-memory/plans/【里程碑】后台游戏审核详情与待审版本试玩-2026-10-02.md
new file mode 100644
index 000000000..361c3aab7
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】后台游戏审核详情与待审版本试玩-2026-10-02.md
@@ -0,0 +1,51 @@
+# 【里程碑】后台游戏审核详情与待审版本试玩
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 1.0 |
+| Status | in-progress |
+| Date | 2026-10-02 |
+| Parent Spec | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md#后台游戏审核详情与待审版本试玩合同` |
+
+## 目标
+
+把后台游戏版本审核从“列表操作”补成可复核的审核详情工作台：审核员能确认发布者和冻结游戏资料，能试玩当前待审版本，并能在同一详情上下达审核决定。
+
+## 范围
+
+- 待审版本详情回读。
+- 发布者、游戏资料、版本包摘要和冻结资料展示。
+- 单个待审版本的短期隔离试玩会话。
+- 试玩资源、Cookie、sandbox、CSP 和版本绑定边界。
+- 通过、拒绝、安全下架动作与现有 CAS/幂等规则对齐。
+- admin-web、api-server、shared-contracts 和相关测试的契约同步。
+
+## 不在范围内
+
+- 新增游戏审核、发布者、试玩会话或游戏资料持久化表。
+- 审核员分派、SLA、批量审核和精选推荐。
+- 后台修改游戏资料、重新构建或重新上传发行包。
+- 公开发行接口、作者发布链路和 `/api/external/v1`。
+
+## 依赖与前置条件
+
+- 现有管理员版本详情接口继续返回游戏投影和版本冻结资料。
+- 现有 SpacetimeDB `game_distribution_game` 与 `game_distribution_version` 字段满足详情展示。
+- 现有发行 ZIP 校验、静态资源白名单和 HTML storage 兼容层可以抽取复用。
+- 现有游戏审核权限映射作为第一版预览权限，不新增权限角色。
+
+## 验收标准
+
+- [ ] 审核详情显示发布者、完整游戏资料、版本摘要和审核状态。
+- [ ] 详情使用待审版本冻结资料，不被后续 game 行资料修改污染。
+- [ ] 审核员可以打开当前 `versionId` 试玩，且 JS/CSS/图片/音频等同包资源可加载。
+- [ ] 预览 Token 绑定版本、短期有效、过期和越权读取均失败。
+- [ ] 预览不读取平台 Cookie，不授予 `allow-same-origin`，保留发行 sandbox/CSP/storage 约束。
+- [ ] 通过、拒绝、安全下架继续执行理由、CAS、幂等和刷新规则。
+- [ ] 无 SpacetimeDB schema、migration、公开契约破坏性变化。
+
+## 证据要求
+
+- 自动化：admin-web 详情/动作测试、api-server 预览会话和权限测试、DTO/类型检查、编码和 diff 检查。
+- 运行时：本地管理员打开待审版本，确认资料、封面/截图和待审包试玩；确认旧公开版本不会被误播。
+- 边界：过期 Token、错误 versionId、Cookie、越权管理员、缺入口、资源 404、CAS 冲突和幂等重放。
diff --git a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
index 5751955d7..7b266b6f4 100644
--- a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
+++ b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
@@ -94,14 +94,14 @@
 
 ### 身份、状态、审核与更新
 
-- `gameId` 是服务端分配的稳定游戏身份；`ownerUserId` 只从当前认证主体派生。AGC 的本地 `projectId` 只能作为作者名下的关联提示，不能证明云端游戏所有权。网页上传和 AGC 发布使用相同游戏、版本与上传记录，不建立两套发行系统。
-- 同一作者用相同 `localProjectId` 再次发布时复用既有 `gameId` 并只新增版本；游戏身份、版本号和服务端校验都不依赖客户端传来的路径或 ID 可信度。缺少 `localProjectId` 的旧客户端仍可发布，但会被视为新建游戏。
-- 每次发行分配唯一 `versionId` 与游戏内递增 `versionNumber`。版本的游戏归属、包摘要、已确认字节和送审资料冻结后不可变；改包或改送审资料必须创建新版本。版本状态可以流转，内容不能原地覆盖。
+- `gameId` 是服务端分配的稳定游戏身份；`ownerUserId` 只从当前认证主体派生。AGC 本地 `projectId` 只用于关联提示，不能证明云端游戏所有权。AGC 发布成功后必须把 `gameId`、最近 `versionId`、`versionNumber`、`publicationRevision` 和状态写入项目清单；网页上传和 AGC 发布使用相同游戏、版本与上传记录，不建立两套发行系统。
+- 同一作者用相同 `localProjectId` 再次发布时复用既有 `gameId` 并只新增版本；AGC 如果清单缺少发布记录，首次更新前按作者作品回读和 `localProjectId` 做一次性恢复。缺少 `localProjectId` 的旧客户端仍可发布，但会被视为新建游戏。
+- 每次发行分配唯一 `versionId`，`version_number` 已存在于版本表。服务端保留“未传版本号时自动取最大值加一”的旧客户端兼容行为；AGC 更新发布必须让用户填写正整数版本号，默认建议为当前最大版本号加一。版本号必须严格大于该游戏已有最大版本号，不能覆盖、重用或静默改写旧版本；允许跳号但发布前明确展示当前版本与目标版本。
 - 游戏单独保存 `publicationRevision`、`activeVersionId` 和可见性 `unpublished | published | suspended`；正式可见性由服务端持久化事实决定。未通过审核时 `activeVersionId` 为空；`suspended` 是管理员安全下架，作者不能自行解除。
 - 版本状态为 `awaiting_upload → uploaded → validating → pending_review → published`。上传确定失败进入 `upload_failed`，验证失败进入 `validation_failed`，人工拒绝进入 `rejected`；尚未公开版本可以撤回为 `cancelled`，已公开版本可撤销为 `revoked`。已成功上传的相同字节可重新校验；内容改变或审核拒绝后的修改必须新建版本。
 - 首版建议人工审核。审核员检查游戏资料、真实桌面运行、声明移动适配、内容与外部请求被阻断的行为；自动包校验通过只进入 `pending_review`，不自动公开。审核记录保存审核者、目标版本、结论、理由和时间。后台只授权现有管理员身份，不让普通作者调用审核动作。
 - 更新送审时旧 `activeVersionId` 继续服务目录、详情与游玩。审核通过并完成对象可读验证后，一次事务切换当前公开版本和公开资料；新版本上传、校验、审核或对象安装失败均不改变旧版本。
-- 发布页先自动填入可用标题和封面，首次需要确认必需资料，此后复用上次资料；用户一次“提交发布”动作串联校验、上传和送审，并显示真实阶段。等待审核不能显示“已发布”；成功后提供查看详情和复制公开链接。
+- AGC 发布面板在无绑定时显示“首次发布”，存在绑定时显示“更新游戏”，回填当前版本号、状态和建议目标版本号。首版不做完整版本历史/回滚管理，只提供目标版本号选择、当前状态和新版本发布。
 
 ### 幂等、并发与恢复
 
@@ -464,3 +464,75 @@
 2026-10-01 按用户后续实现授权完成公开快照、共享契约、后端响应和共享评分文本接入。绑定以仓库固定 SpacetimeDB 2.8.3 生成，持久化表未变；只为列表最终返回游戏聚合评价。隔离库没有既有评分 fixture，本次复用既有 helper 临时创建两个账号、两款游戏和两条评价，未新增仓库 E2E 脚本或完整管理矩阵。
 
 本地验证通过，尚待用户验收和生产部署。未跑完整仓库测试、完整评价/后台管理 E2E、真实手机、长标题/极大人数浏览器矩阵、浏览器登录改分和实际发行包游玩；返回刷新使用真实 API 改分验证，登录用户公开列表已在 API smoke 对照。
+
+## 后台游戏审核详情与待审版本试玩合同
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 1.0 |
+| Status | in-progress |
+| Date | 2026-10-02 |
+| 适用范围 | admin-web 游戏版本审核、作者/游戏资料回读、待审版本隔离试玩 |
+| 数据事实源 | `game_distribution_game`、`game_distribution_version` 及现有版本冻结资料 |
+
+### 目标
+
+- 审核员在一个详情工作台内看到发布者、游戏资料、待审版本包信息、审核状态和审核历史。
+- 审核员可以实际试玩当前待审 `versionId`，不能误播旧的公开版本或另一个待审版本。
+- 试玩保持发行网关的 opaque sandbox、Cookie 隔离、CSP、路径白名单和运行期 storage 兼容边界。
+- 通过、拒绝、安全下架继续使用现有 `publicationRevision`、认证管理员和幂等语义。
+
+### 非目标
+
+- 不新增平行游戏审核表、游戏资料表、发布者表或公开发行通道。
+- 不把待审包提前写入公开发行网关路径，不改变未审核版本的可见性。
+- 不在审核页提供游戏资料编辑、重新打包、重新上传或替作者发布。
+- 不把管理员 Access Token 放进 iframe URL，也不授予 `allow-same-origin`。
+
+### 详情数据与权限
+
+- 审核列表使用现有版本审核列表；点击版本后回读现有管理员版本详情。
+- 详情必须展示：发布者 ID/名称/头像、游戏标题、简介、详细介绍、分类、标签、操作方式、支持设备、输入方式、方向、封面、截图、版本号、包大小、文件数、SHA-256、提交时间、审核时间、审核理由和 `publicationRevision`。
+- 展示的游戏资料优先使用该版本冻结的 `metadata_json`；不能用审核期间作者后来修改的 game 行资料替代待审快照。
+- 发布者和游戏资料仅通过管理员受保护接口读取；公开目录不得因此增加作者私有字段或待审版本字段。
+- 封面与截图通过现有后台素材换签接口读取 Object Key，不把私有 Object Key 当作浏览器直链。
+
+### 待审版本试玩
+
+- 管理员先创建绑定单个 `versionId` 的短期预览会话，再得到 `previewUrl` 与过期时间。
+- 预览会话不持久化到 SpacetimeDB；Token 仅能读取绑定版本包，过期后不可继续读取。
+- 预览资源读取必须拒绝平台 Cookie，继续返回 `nosniff`、跨来源静态资源头、最小权限 CSP，并复用发行 ZIP 路径和大小白名单。
+- HTML 入口必须保留 `sandbox="allow-scripts"`，继续注入隔离的运行期 `localStorage/sessionStorage` 兼容层；不得添加 `allow-same-origin`。
+- 试玩入口、JS、CSS、图片、音频和其它包内资源都必须来自同一个绑定的待审版本；读取失败显示明确资源/入口错误，不降级到公开版本。
+
+### 审核动作
+
+- 详情页保留通过、拒绝、安全下架；列表页保留快捷动作。
+- 拒绝和下架继续要求理由；所有写操作携带 `publicationRevision` 和 `Idempotency-Key`。
+- 并发修订返回冲突时只提示刷新并重新读取，不覆盖其他审核员的决定。
+- 审核操作成功后刷新详情和待审列表，不能只修改前端本地状态。
+
+### 契约与数据库边界
+
+- 第一版不新增 SpacetimeDB 表、字段、migration 或生成绑定。
+- 复用现有 `game_distribution_game`、`game_distribution_version`、`metadata_json`、审核人/时间/理由和 `publicationRevision` 字段。
+- 预览会话属于 api-server 短期运行态；如果未来需要审核任务分派或完整试玩审计，另开规范评估是否增加持久化表。
+- 管理员预览接口属于后台契约，必须同步 admin DTO、权限映射、API 测试和前端类型；不改变 `/api/external/v1`。
+
+### 验收标准
+
+| 条款 | 验收方式 | 证据 |
+| --- | --- | --- |
+| 发布者和资料 | 详情回读 + admin-web 页面检查 | admin-web 详情测试通过，显示作者、资料、版本摘要和冻结 JSON |
+| 待审快照 | 修改 game 行资料后仍显示待审版本冻结资料 | 详情响应和页面已接入 `frozenMetadata`；真实数据验证待补 |
+| 版本隔离试玩 | 用两个版本验证预览 URL 不能串读，待审包资源全部可加载 | 预览会话路由和版本绑定已实现；真实审核试玩待补 |
+| 安全边界 | Cookie、过期 Token、越权 versionId、公开路径访问拒绝 | sandbox、Cookie 拒绝和短期 Token 已实现；HTTP 边界测试待补 |
+| 审核动作 | 通过/拒绝/下架、理由、CAS 冲突、幂等重放 | 既有审核动作保留，详情页已接入；回归测试沿用现有 6 项审核页面测试 |
+| 工程门禁 | admin-web 测试、api-server 定向测试、类型、编码、diff | admin-web typecheck、详情测试、api-server cargo check、Rust fmt、编码和 diff 通过 |
+
+2026-10-02 已完成第一版审核详情工作台与待审版本预览接线：后台详情回读复用现有 game/version 投影，预览 Token 只绑定待审 versionId，预览 iframe 保持 `sandbox="allow-scripts"`。尚未完成真实管理员登录、待审包资源全量加载和 Token 越权 HTTP smoke。
+
+### 未决问题
+
+- 管理员权限继续复用现有游戏审核权限映射，还是单独增加 `game-review-preview` 动作权限；第一里程碑默认复用现有审核权限，不扩大权限模型。
+- 预览 Token 的单次 HTML 读取与同包静态资源多次读取需要统一 TTL 和失效规则；第一里程碑使用短 TTL 的版本绑定会话。
diff --git a/packages/shared/src/components/GameDetailDisplay/index.css b/packages/shared/src/components/GameDetailDisplay/index.css
new file mode 100644
index 000000000..c7acb5c1f
--- /dev/null
+++ b/packages/shared/src/components/GameDetailDisplay/index.css
@@ -0,0 +1,349 @@
+/*
+ * 游戏详情展示层样式：公开游戏详情与后台审核详情共用同一套 hero、封面/截图、正文与资料侧栏。
+ *
+ * 这里只放表现。游戏数据加载、游玩入口、评价与审核动作都留在各自宿主里，
+ * 组件本身不取数、不鉴权。类名统一用 `game-detail-` 前缀，避免与宿主自己的
+ * 游戏卡片（`.game-cover` / `.game-eyebrow` / `.game-avatar` 等）互相影响。
+ */
+
+.game-detail-display {
+  min-width: 0;
+  color: var(--platform-text-strong);
+  font-family: var(--platform-font-family, system-ui, sans-serif);
+  font-weight: 400;
+}
+
+.game-detail-eyebrow {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.38rem;
+  color: var(--platform-accent-strong);
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.game-detail-eyebrow svg {
+  width: 0.9rem;
+  height: 0.9rem;
+}
+
+/* 封面：素材未就绪时用渐变 + 图标占位，换签成功后图片覆盖在占位之上。 */
+.game-detail-cover {
+  position: relative;
+  display: flex;
+  min-height: 12rem;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  isolation: isolate;
+}
+
+.game-detail-cover__grid {
+  position: absolute;
+  inset: 0;
+  opacity: 0.22;
+  background-image: linear-gradient(
+      rgba(255, 255, 255, 0.2) 1px,
+      transparent 1px
+    ),
+    linear-gradient(90deg, rgba(255, 255, 255, 0.2) 1px, transparent 1px);
+  background-size: 2rem 2rem;
+  transform: perspective(12rem) rotateX(58deg) scale(1.7) translateY(25%);
+}
+
+.game-detail-cover__glow {
+  position: absolute;
+  width: 70%;
+  aspect-ratio: 1;
+  border-radius: 50%;
+  background: radial-gradient(
+    circle,
+    rgba(255, 236, 204, 0.5),
+    transparent 66%
+  );
+  filter: blur(0.6rem);
+}
+
+.game-detail-cover__icon {
+  position: relative;
+  z-index: 1;
+  display: grid;
+  width: 5.4rem;
+  aspect-ratio: 1;
+  place-items: center;
+  border: 1px solid rgba(255, 255, 255, 0.4);
+  border-radius: 1.5rem;
+  background: rgba(255, 255, 255, 0.13);
+  box-shadow: 0 1rem 2rem rgba(0, 0, 0, 0.2);
+  color: #fff5dc;
+  font-size: 3rem;
+  backdrop-filter: blur(8px);
+}
+
+.game-detail-cover > img {
+  position: absolute;
+  inset: 0;
+  z-index: 2;
+  display: block;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+.game-detail-showcase {
+  display: grid;
+  gap: 0.7rem;
+  min-width: 0;
+}
+
+.game-detail-thumbs {
+  display: flex;
+  gap: 0.5rem;
+  overflow-x: auto;
+  padding-bottom: 0.15rem;
+  scroll-snap-type: x proximity;
+  scrollbar-width: thin;
+}
+
+.game-detail-thumb {
+  position: relative;
+  flex: 0 0 auto;
+  width: 5.4rem;
+  aspect-ratio: 16 / 9;
+  overflow: hidden;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.7rem;
+  padding: 0;
+  background: linear-gradient(
+    135deg,
+    rgba(241, 159, 95, 0.24),
+    rgba(91, 49, 42, 0.16)
+  );
+  cursor: pointer;
+  scroll-snap-align: start;
+  transition: 160ms ease;
+}
+
+.game-detail-thumb:hover {
+  border-color: rgba(199, 101, 61, 0.45);
+}
+
+.game-detail-thumb[aria-pressed='true'] {
+  border-color: rgba(199, 101, 61, 0.62);
+  box-shadow: 0 0 0 2px rgba(199, 101, 61, 0.22);
+}
+
+.game-detail-thumb img {
+  position: absolute;
+  inset: 0;
+  display: block;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+.game-detail-thumb__placeholder {
+  position: absolute;
+  inset: 0;
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+
+.game-detail-hero {
+  display: grid;
+  grid-template-columns: minmax(13rem, 21rem) minmax(0, 1fr);
+  align-items: center;
+  gap: clamp(1.4rem, 4vw, 3.5rem);
+  margin-top: 1.5rem;
+}
+
+.game-detail-hero .game-detail-cover {
+  border-radius: 1.7rem;
+  box-shadow: 0 1.25rem 2.5rem rgba(70, 42, 34, 0.18);
+}
+
+.game-detail-hero h1 {
+  margin: 0.65rem 0 0;
+  font-size: clamp(2rem, 4.8vw, 3.7rem);
+  font-weight: 400;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+  letter-spacing: -0.055em;
+}
+
+.game-detail-hero__summary {
+  max-width: 32rem;
+  margin: 0.8rem 0 0;
+  color: var(--platform-text-base);
+  font-size: 1rem;
+  line-height: 1.75;
+}
+
+.game-detail-hero__author {
+  display: flex;
+  align-items: center;
+  gap: 0.55rem;
+  margin-top: 1.15rem;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  font-weight: 700;
+}
+
+.game-detail-avatar {
+  display: grid;
+  width: 1.8rem;
+  height: 1.8rem;
+  place-items: center;
+  border-radius: 50%;
+  background: rgba(199, 101, 61, 0.18);
+  color: var(--platform-accent-strong);
+  font-weight: 900;
+}
+
+.game-detail-hero__actions {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin-top: 1.4rem;
+}
+
+.game-detail-hero__play-count {
+  color: var(--platform-text-soft);
+  font-size: 0.75rem;
+}
+
+.game-detail-body {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 17rem;
+  gap: 3rem;
+  margin-top: 3rem;
+  border-top: 1px solid var(--platform-surface-border);
+  padding-top: 2rem;
+}
+
+.game-detail-main h2 {
+  margin: 0;
+  font-size: 1.25rem;
+}
+
+.game-detail-main p {
+  max-width: 45rem;
+  margin: 0.75rem 0 0;
+  color: var(--platform-text-base);
+  line-height: 1.9;
+}
+
+.game-detail-tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.45rem;
+  margin-top: 1.3rem;
+}
+
+.game-detail-tag-list span {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.35rem 0.65rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+
+.game-detail-side {
+  display: grid;
+  gap: 0.7rem;
+  align-content: start;
+}
+
+.game-detail-info-card {
+  display: grid;
+  gap: 0.3rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1rem;
+  padding: 0.8rem 0.9rem;
+  background: var(--platform-panel-fill);
+}
+
+.game-detail-info-card strong {
+  font-size: 0.72rem;
+}
+
+.game-detail-info-card span {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.28rem;
+  color: var(--platform-text-soft);
+  min-width: 0;
+  overflow-wrap: anywhere;
+  font-size: 0.72rem;
+  line-height: 1.45;
+}
+
+.game-detail-info-card svg {
+  width: 0.85rem;
+}
+
+.game-detail-footnote {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  margin-top: 2.2rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+
+.game-detail-footnote svg {
+  width: 0.9rem;
+}
+
+@media (max-width: 820px) {
+  .game-detail-hero {
+    grid-template-columns: 9rem minmax(0, 1fr);
+    gap: 1.15rem;
+  }
+
+  .game-detail-hero .game-detail-cover {
+    min-height: 9rem;
+  }
+
+  .game-detail-cover__icon {
+    width: 3.7rem;
+    border-radius: 1rem;
+    font-size: 2rem;
+  }
+
+  .game-detail-body {
+    grid-template-columns: 1fr;
+    gap: 1.5rem;
+  }
+
+  .game-detail-side {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 560px) {
+  .game-detail-thumb {
+    width: 4.6rem;
+  }
+
+  .game-detail-hero {
+    display: block;
+  }
+
+  .game-detail-hero .game-detail-cover {
+    min-height: 13rem;
+    margin-top: 1.2rem;
+  }
+
+  .game-detail-hero h1 {
+    margin-top: 1.4rem;
+  }
+
+  .game-detail-side {
+    grid-template-columns: 1fr;
+  }
+}
diff --git a/packages/shared/src/components/GameDetailDisplay/index.test.tsx b/packages/shared/src/components/GameDetailDisplay/index.test.tsx
new file mode 100644
index 000000000..190b8055f
--- /dev/null
+++ b/packages/shared/src/components/GameDetailDisplay/index.test.tsx
@@ -0,0 +1,64 @@
+/* @vitest-environment jsdom */
+
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+
+import { GameDetailDisplay } from './index';
+
+describe('GameDetailDisplay', () => {
+  test('renders host-provided data and switches the hero through asset urls', async () => {
+    render(
+      <GameDetailDisplay
+        game={{
+          title: '星轨防线',
+          summary: '守住最后一条航线。',
+          description: '一款测试游戏。',
+          category: '动作',
+          tags: ['测试'],
+          author: { name: '陶泥儿' },
+          deviceSupport: { desktop: true, mobile: false, touch: false },
+          playCount: 1200,
+        }}
+        coverObjectKey="cover/alpha.png"
+        screenshotObjectKeys={['screenshot/one.png']}
+        assetUrls={{
+          'cover/alpha.png': 'https://assets.example.test/cover/alpha.png',
+          'screenshot/one.png': 'https://assets.example.test/screenshot/one.png',
+        }}
+        controlsLabel="键盘"
+        versionLabel="v2"
+        rating={<span>评分 9.1</span>}
+        actions={<button type="button">试玩当前待审版本</button>}
+        infoCards={[{ label: '发行包', value: '2.0 MiB' }]}
+        footnoteText="游戏运行在独立的安全容器中。"
+      />,
+    );
+
+    expect(screen.getByRole('heading', { name: '星轨防线' })).toBeTruthy();
+    expect(screen.getByText('由 陶泥儿 制作')).toBeTruthy();
+    expect(screen.getByText(/次游玩$/u)).toBeTruthy();
+    expect(screen.getByText('评分 9.1')).toBeTruthy();
+    expect(
+      screen.getByRole('button', { name: '试玩当前待审版本' }),
+    ).toBeTruthy();
+    expect(screen.getByText('键盘')).toBeTruthy();
+    expect(screen.getByText('v2')).toBeTruthy();
+    expect(screen.getByText('发行包').parentElement?.textContent).toBe(
+      '发行包2.0 MiB',
+    );
+    expect(screen.getByText('游戏运行在独立的安全容器中。')).toBeTruthy();
+
+    const heroImage = () =>
+      document.querySelector('.game-detail-cover img')?.getAttribute('src');
+    expect(heroImage()).toBe('https://assets.example.test/cover/alpha.png');
+
+    const thumbs = screen.getAllByRole('button', { name: /（查看大图）/u });
+    expect(thumbs).toHaveLength(2);
+    fireEvent.click(thumbs[1]!);
+    await waitFor(() =>
+      expect(heroImage()).toBe(
+        'https://assets.example.test/screenshot/one.png',
+      ),
+    );
+  });
+});
diff --git a/packages/shared/src/components/GameDetailDisplay/index.tsx b/packages/shared/src/components/GameDetailDisplay/index.tsx
new file mode 100644
index 000000000..00a44a9cc
--- /dev/null
+++ b/packages/shared/src/components/GameDetailDisplay/index.tsx
@@ -0,0 +1,295 @@
+import './index.css';
+
+import { Maximize2, Smartphone, Sparkles } from 'lucide-react';
+import { useState, type ReactElement, type ReactNode } from 'react';
+
+/** 详情展示里素材出现的位置：hero 大图与缩略图条。 */
+export type GameDetailAssetRole = 'cover' | 'thumb';
+
+export interface GameDetailAssetRenderInput {
+  /** 素材 objectKey，宿主据此换签。 */
+  objectKey: string;
+  role: GameDetailAssetRole;
+  /** 该素材当前是否为 hero 大图 / 已选中的缩略图。 */
+  active: boolean;
+  /** 素材名（封面、截图 1…），用于缩略图无障碍标签。 */
+  label: string;
+}
+
+export interface GameDetailShowcaseProps {
+  /** 封面 objectKey；为空时只展示彩色占位。 */
+  coverObjectKey?: string | null;
+  /** 截图 objectKey（不含封面），最多展示 6 张。 */
+  screenshotObjectKeys?: string[];
+  /** 占位渐变的起始色，缺省用平台默认橙色。 */
+  coverColor?: string;
+  /** 占位图标，缺省 ✦。 */
+  icon?: string;
+  /** objectKey → 已换签的展示地址；缺项按占位处理。 */
+  assetUrls?: Readonly<Record<string, string | null | undefined>>;
+  /**
+   * 覆盖默认的图片渲染：宿主可以用自己的取址钩子逐项渲染 `<img>`（后台则是已取到的地址）。
+   * 返回空节点即保留占位视觉；返回的图片无需类名，样式由展示层提供。
+   */
+  renderAsset?: (input: GameDetailAssetRenderInput) => ReactElement | null;
+}
+
+export interface GameDetailDisplayInfoCard {
+  /** 资料卡标题，如「发行包」。 */
+  label: string;
+  value: ReactNode;
+}
+
+export interface GameDetailDisplayProps extends GameDetailShowcaseProps {
+  game: {
+    title: string;
+    summary: string;
+    description: string;
+    category: string;
+    tags: string[];
+    author: { name: string };
+    deviceSupport: {
+      desktop: boolean;
+      mobile: boolean;
+      touch: boolean;
+    };
+    /** 缺省时不显示游玩次数。 */
+    playCount?: number;
+  };
+  /** 「游玩方式」文案；缺省「未标注操作方式」。 */
+  controlsLabel?: string;
+  /** 「当前版本」文案；缺省 —。 */
+  versionLabel?: string;
+  /** 追加到资料侧栏的卡片（宿主自定义信息）。 */
+  infoCards?: GameDetailDisplayInfoCard[];
+  /** hero 里的评分摘要（公开详情传评分，后台可省略）。 */
+  rating?: ReactNode;
+  /** hero 里的主行动作区（公开详情是「立即玩」，后台是「试玩待审版本」）。 */
+  actions?: ReactNode;
+  /** hero 与正文之间的内容（作者作品状态、后台版本与审核信息等）。 */
+  children?: ReactNode;
+  /** 正文之后的脚注文案，带全屏提示图标；缺省不渲染。 */
+  footnoteText?: string;
+  className?: string;
+}
+
+const DEFAULT_COVER_COLOR = '#d77a51';
+const DEFAULT_COVER_ICON = '✦';
+const MAX_SCREENSHOTS = 6;
+
+/**
+ * 素材渲染：宿主给了 `renderAsset` 就交给宿主（公开详情按 objectKey 逐个换签），
+ * 否则用宿主传入的 `assetUrls` 直接渲染 `<img>`；没有地址时返回空节点，由展示层占位兜底。
+ */
+function GameDetailAsset({
+  objectKey,
+  role,
+  active,
+  label,
+  assetUrls,
+  renderAsset,
+}: GameDetailAssetRenderInput & {
+  assetUrls?: GameDetailShowcaseProps['assetUrls'];
+  renderAsset?: GameDetailShowcaseProps['renderAsset'];
+}): ReactElement | null {
+  if (renderAsset) return renderAsset({ objectKey, role, active, label });
+  const url = (assetUrls?.[objectKey] ?? '').trim();
+  if (!url) return null;
+  return (
+    <img
+      src={url}
+      alt=""
+      loading={role === 'cover' ? 'eager' : 'lazy'}
+      decoding="async"
+    />
+  );
+}
+
+/**
+ * 封面区：默认展示封面，存在截图时在下方给出可点击的缩略图条。
+ *
+ * 缩略图第一项固定是封面本身，方便从截图切回封面；只有封面时整条不渲染。
+ * 素材地址由宿主提供（`assetUrls` 或 `renderAsset`），组件自身不取数。
+ */
+export function GameDetailShowcase({
+  coverObjectKey,
+  screenshotObjectKeys,
+  coverColor,
+  icon,
+  assetUrls,
+  renderAsset,
+}: GameDetailShowcaseProps) {
+  const coverKey = (coverObjectKey ?? '').trim();
+  const screenshotKeys = (screenshotObjectKeys ?? [])
+    .map((key) => key.trim())
+    .filter(Boolean)
+    .slice(0, MAX_SCREENSHOTS);
+  const items = [
+    ...(coverKey ? [{ key: coverKey, label: '封面' }] : []),
+    ...screenshotKeys.map((key, index) => ({
+      key,
+      label: `截图 ${index + 1}`,
+    })),
+  ];
+  const [activeIndex, setActiveIndex] = useState(0);
+  const activeKey = items[activeIndex]?.key ?? coverKey;
+
+  return (
+    <div className="game-detail-showcase">
+      <div
+        className="game-detail-cover"
+        style={{
+          background: `linear-gradient(145deg, ${coverColor ?? DEFAULT_COVER_COLOR}, #16151c)`,
+        }}
+        aria-hidden="true"
+      >
+        <span className="game-detail-cover__glow" />
+        <span className="game-detail-cover__icon">
+          {icon ?? DEFAULT_COVER_ICON}
+        </span>
+        <span className="game-detail-cover__grid" />
+        <GameDetailAsset
+          objectKey={activeKey}
+          role="cover"
+          active
+          label="封面"
+          assetUrls={assetUrls}
+          renderAsset={renderAsset}
+        />
+      </div>
+      {items.length > 1 ? (
+        <div className="game-detail-thumbs" role="group" aria-label="游戏截图">
+          {items.map((item, index) => (
+            <button
+              key={item.key}
+              type="button"
+              className="game-detail-thumb"
+              aria-pressed={index === activeIndex}
+              aria-label={`${item.label}（查看大图）`}
+              onClick={() => setActiveIndex(index)}
+            >
+              <span className="game-detail-thumb__placeholder" />
+              <GameDetailAsset
+                objectKey={item.key}
+                role="thumb"
+                active={index === activeIndex}
+                label={item.label}
+                assetUrls={assetUrls}
+                renderAsset={renderAsset}
+              />
+            </button>
+          ))}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+/**
+ * 游戏详情展示：hero、封面区、正文与资料侧栏。
+ *
+ * 纯受控展示组件——游戏数据、素材地址、评分、主行动作与附加区块全部由宿主传入，
+ * 组件不加载数据、不鉴权、不接管游玩或评价逻辑，公开详情与后台审核详情共用同一套视觉。
+ */
+export function GameDetailDisplay({
+  game,
+  coverObjectKey,
+  screenshotObjectKeys,
+  coverColor,
+  icon,
+  assetUrls,
+  renderAsset,
+  controlsLabel,
+  versionLabel,
+  infoCards,
+  rating,
+  actions,
+  children,
+  footnoteText,
+  className,
+}: GameDetailDisplayProps) {
+  const controls = (controlsLabel ?? '').trim();
+  const version = (versionLabel ?? '').trim();
+  return (
+    <div
+      className={['game-detail-display', className].filter(Boolean).join(' ')}
+    >
+      <section className="game-detail-hero">
+        <GameDetailShowcase
+          coverObjectKey={coverObjectKey}
+          screenshotObjectKeys={screenshotObjectKeys}
+          coverColor={coverColor}
+          icon={icon}
+          assetUrls={assetUrls}
+          renderAsset={renderAsset}
+        />
+        <div className="game-detail-hero__copy">
+          <span className="game-detail-eyebrow">
+            <Sparkles aria-hidden="true" /> {game.category}
+          </span>
+          <h1>{game.title}</h1>
+          <p className="game-detail-hero__summary">{game.summary}</p>
+          {rating ? (
+            <div className="game-detail-hero__rating">{rating}</div>
+          ) : null}
+          <div className="game-detail-hero__author">
+            <span className="game-detail-avatar">
+              {game.author.name.slice(0, 1)}
+            </span>
+            <span>由 {game.author.name} 制作</span>
+          </div>
+          <div className="game-detail-hero__actions">
+            {actions}
+            {typeof game.playCount === 'number' ? (
+              <span className="game-detail-hero__play-count">
+                {game.playCount.toLocaleString()} 次游玩
+              </span>
+            ) : null}
+          </div>
+        </div>
+      </section>
+      {children}
+      <section className="game-detail-body">
+        <div className="game-detail-main">
+          <h2>关于这款游戏</h2>
+          <p>{game.description}</p>
+          <div className="game-detail-tag-list">
+            {game.tags.map((tag) => (
+              <span key={tag}>{tag}</span>
+            ))}
+          </div>
+        </div>
+        <aside className="game-detail-side">
+          <div className="game-detail-info-card">
+            <strong>游玩方式</strong>
+            <span>{controls || '未标注操作方式'}</span>
+          </div>
+          <div className="game-detail-info-card">
+            <strong>设备支持</strong>
+            <span>
+              <Smartphone aria-hidden="true" />{' '}
+              {game.deviceSupport.mobile ? '移动端' : ''}
+              {game.deviceSupport.desktop ? ' · 桌面端' : ''}
+              {game.deviceSupport.touch ? ' · 支持触屏' : ''}
+            </span>
+          </div>
+          <div className="game-detail-info-card">
+            <strong>当前版本</strong>
+            <span>{version || '—'}</span>
+          </div>
+          {(infoCards ?? []).map((card) => (
+            <div className="game-detail-info-card" key={card.label}>
+              <strong>{card.label}</strong>
+              <span>{card.value}</span>
+            </div>
+          ))}
+        </aside>
+      </section>
+      {footnoteText ? (
+        <p className="game-detail-footnote">
+          <Maximize2 aria-hidden="true" /> {footnoteText}
+        </p>
+      ) : null}
+    </div>
+  );
+}
diff --git a/packages/shared/src/components/admin/admin.css b/packages/shared/src/components/admin/admin.css
index 3c91b9cfa..0aabe04fd 100644
--- a/packages/shared/src/components/admin/admin.css
+++ b/packages/shared/src/components/admin/admin.css
@@ -191,6 +191,40 @@
   font-weight: 700;
 }
 
+/*
+ * 审核动作行约定：审核页里「详情 / 通过 / 拒绝 / 安全下架」等并列动作统一排布，
+ * 并统一按钮高度、圆角、字号与图文间距，保证同一行按钮视觉齐平。
+ * 规则限定在本类内部，其它后台按钮（含作为图标按钮使用的 ghost）不受影响。
+ */
+.admin-review-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+.admin-review-actions .admin-primary-button,
+.admin-review-actions .admin-secondary-button,
+.admin-review-actions .admin-danger-button,
+.admin-review-actions .admin-ghost-button {
+  gap: 8px;
+  width: auto;
+  min-height: 40px;
+  height: 40px;
+  padding: 0 16px;
+  border-radius: 8px;
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 1;
+}
+
+/* 审核动作里的 ghost 承载「拒绝」等次要动作：保留浅暖底，只还原成常规按钮尺寸。 */
+.admin-review-actions .admin-ghost-button {
+  color: #755a49;
+  background: #f8efe7;
+}
+
 .admin-alert {
   border: 1px solid #e2b9a4;
   border-radius: 8px;
diff --git a/packages/shared/src/components/index.ts b/packages/shared/src/components/index.ts
index 811853f6e..c60cc131a 100644
--- a/packages/shared/src/components/index.ts
+++ b/packages/shared/src/components/index.ts
@@ -1,3 +1,11 @@
+export type {
+  GameDetailAssetRenderInput,
+  GameDetailAssetRole,
+  GameDetailDisplayInfoCard,
+  GameDetailDisplayProps,
+  GameDetailShowcaseProps,
+} from './GameDetailDisplay';
+export { GameDetailDisplay, GameDetailShowcase } from './GameDetailDisplay';
 export { GameRatingSummaryText } from './GameRatingSummaryText';
 export type {
   PlatformActionButtonAlign,
diff --git a/packages/shared/src/contracts/gameCreationApp.ts b/packages/shared/src/contracts/gameCreationApp.ts
index 17103aa6f..a4525bad6 100644
--- a/packages/shared/src/contracts/gameCreationApp.ts
+++ b/packages/shared/src/contracts/gameCreationApp.ts
@@ -959,6 +959,23 @@ export interface GameIterationVersion {
   editPrompt?: string | null;
 }
 
+/**
+ * AGC 本地发布绑定：记录该本地项目对应哪个平台账号 / 服务 origin 的哪个游戏与最近版本。
+ *
+ * `accountId` + `apiBaseUrl` 是隔离键：切换账号或服务环境后，同一份本地清单不得被当成
+ * 另一个账号的作品来更新；缺失或与当前会话不匹配时按未发布处理。`revision` 是游戏公开
+ * 修订号，更新送审时用作 `expectedPublicationRevision` CAS。
+ */
+export interface GameCreationAppPublicationBinding {
+  accountId: string;
+  apiBaseUrl: string;
+  gameId: string;
+  revision: number;
+  latestVersionId?: string | null;
+  latestVersionNumber?: number | null;
+  status?: string | null;
+}
+
 export interface GameCreationAppManifest {
   schemaVersion: string;
   projectId: string;
@@ -971,6 +988,8 @@ export interface GameCreationAppManifest {
   versions?: GameIterationVersion[];
   godotProjectRoot?: string | null;
   cocosProjectRoot?: string | null;
+  /** 平台发布绑定；缺失即该项目尚未发布过。 */
+  publication?: GameCreationAppPublicationBinding | null;
 }
 
 export interface GameCreationAgentToolCallTrace {
diff --git a/packages/shared/src/contracts/gameDistribution.ts b/packages/shared/src/contracts/gameDistribution.ts
index 31484fe54..d30259902 100644
--- a/packages/shared/src/contracts/gameDistribution.ts
+++ b/packages/shared/src/contracts/gameDistribution.ts
@@ -168,6 +168,11 @@ export type GameDistributionCreateGameRequest = {
 
 export type GameDistributionCreateVersionRequest = {
   localProjectId?: string | null;
+  /**
+   * 显式目标版本号；缺省时服务端按该游戏已有最大版本号自动 +1。
+   * 必须严格大于当前最大版本号（允许跳号），否则返回 409。
+   */
+  versionNumber?: number | null;
   packageSha256: string;
   packageBytes: number;
   packageFileCount: number;
diff --git a/server-rs/crates/api-server/src/modules/game_distribution.rs b/server-rs/crates/api-server/src/modules/game_distribution.rs
index 443e2aeb7..fccbac5df 100644
--- a/server-rs/crates/api-server/src/modules/game_distribution.rs
+++ b/server-rs/crates/api-server/src/modules/game_distribution.rs
@@ -36,7 +36,8 @@ use shared_contracts::admin::{
     AdminGameReviewsResponse,
 };
 use shared_contracts::game_distribution::{
-    GAME_DISTRIBUTION_CATEGORIES, GameDistributionAuthor, GameDistributionCreateGameRequest,
+    GAME_DISTRIBUTION_CATEGORIES, GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT,
+    GameDistributionAuthor, GameDistributionCreateGameRequest,
     GameDistributionCreateVersionRequest, GameDistributionInputMode,
     GameDistributionMyReviewResponse, GameDistributionOrientation,
     GameDistributionPublishMetadataSuggestion, GameDistributionPublishMetadataSuggestionRequest,
@@ -362,6 +363,10 @@ pub fn router(state: AppState) -> Router<AppState> {
             "/admin/api/game-distribution/versions/{version_id}",
             get(admin_get_version),
         )
+        .route(
+            "/admin/api/game-distribution/versions/{version_id}/preview-session",
+            post(admin_create_version_preview_session),
+        )
         .route("/admin/api/game-distribution/games", get(admin_list_games))
         .route(
             "/admin/api/game-distribution/games/{game_id}/suspend",
@@ -396,6 +401,18 @@ pub fn router(state: AppState) -> Router<AppState> {
             "/api/game-distribution/releases/{game_id}/",
             get(serve_release_entry),
         )
+        .route(
+            "/api/game-distribution/admin-previews/{preview_token}/{*asset_path}",
+            get(serve_admin_version_preview_asset),
+        )
+        .route(
+            "/api/game-distribution/admin-previews/{preview_token}",
+            get(serve_admin_version_preview_entry),
+        )
+        .route(
+            "/api/game-distribution/admin-previews/{preview_token}/",
+            get(serve_admin_version_preview_entry),
+        )
         .merge(public_games)
         .merge(protected)
         .merge(user_reviews)
@@ -840,7 +857,20 @@ async fn serve_release_asset(
         return Err(AppError::from_status(StatusCode::NOT_FOUND));
     }
     let package = release_package_bytes(&state, &game_id, &version.version_id).await?;
-    let content = match extract_release_asset(&package, &asset_path) {
+    release_package_asset_response(
+        &package,
+        &asset_path,
+        content_type,
+        "public, max-age=60, must-revalidate",
+    )
+}
+fn release_package_asset_response(
+    package: &[u8],
+    asset_path: &str,
+    content_type: &'static str,
+    cache_control: &'static str,
+) -> Result<Response, AppError> {
+    let content = match extract_release_asset(package, asset_path) {
         Ok(content) => content,
         Err(ReleaseAssetError::FileTooLarge) => {
             return Err(AppError::from_status(StatusCode::PAYLOAD_TOO_LARGE)
@@ -849,7 +879,7 @@ async fn serve_release_asset(
         Err(_) => return Err(AppError::from_status(StatusCode::NOT_FOUND)),
     };
     let content = inject_release_storage_bootstrap(content, content_type);
-    Ok(release_asset_response(content, content_type))
+    Ok(release_asset_response_with_cache(content, content_type, cache_control))
 }
 
 fn inject_release_storage_bootstrap(content: Vec<u8>, content_type: &str) -> Vec<u8> {
@@ -899,7 +929,12 @@ async fn release_package_bytes(
     Ok(bytes)
 }
 
-fn release_asset_response(content: Vec<u8>, content_type: &'static str) -> Response {
+
+fn release_asset_response_with_cache(
+    content: Vec<u8>,
+    content_type: &'static str,
+    cache_control: &'static str,
+) -> Response {
     let mut response = Response::new(Body::from(content));
     let headers = response.headers_mut();
     headers.insert(header::CONTENT_TYPE, HeaderValue::from_static(content_type));
@@ -913,7 +948,7 @@ fn release_asset_response(content: Vec<u8>, content_type: &'static str) -> Respo
     );
     headers.insert(
         header::CACHE_CONTROL,
-        HeaderValue::from_static("public, max-age=60, must-revalidate"),
+        HeaderValue::from_static(cache_control),
     );
     // 发行文档运行在 allow-scripts 的 opaque origin 沙箱里，其同包资源请求不再与
     // 网关同源；CORP 必须允许跨来源，ES modules 还需要不带 credentials 的 CORS，
@@ -1331,6 +1366,7 @@ async fn create_version(
                 game_id,
                 owner_user_id: auth.claims().user_id().to_string(),
                 version_id,
+                version_number: payload.version_number,
                 metadata_json,
                 package_sha256: payload.package_sha256,
                 package_bytes: payload.package_bytes,
@@ -2320,6 +2356,97 @@ async fn admin_get_version(
     ))
 }
 
+const ADMIN_GAME_PREVIEW_TTL_SECONDS: i64 = 10 * 60;
+
+async fn admin_create_version_preview_session(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Path(version_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let version = state
+        .spacetime_client()
+        .get_game_distribution_version(version_id.clone())
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    if !matches!(version.status.as_str(), "pending_review" | "rejected") {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_message("当前版本没有可供审核的发行包"));
+    }
+    let expires_at =
+        time::OffsetDateTime::now_utc() + time::Duration::seconds(ADMIN_GAME_PREVIEW_TTL_SECONDS);
+    let preview_token = state
+        .create_game_distribution_preview_session(version_id.clone(), expires_at)
+        .await;
+    let expires_at = shared_kernel::format_rfc3339(expires_at)
+        .map_err(|_| AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR))?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "admin_game_preview_session_created",
+        version_id = %version_id,
+        expires_at = %expires_at,
+        "管理员创建待审版本试玩会话"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({
+            "previewUrl": format!(
+                "/api/game-distribution/admin-previews/{preview_token}/"
+            ),
+            "expiresAt": expires_at,
+            "versionId": version_id,
+        }),
+    ))
+}
+
+async fn serve_admin_version_preview_entry(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Path(preview_token): Path<String>,
+) -> Result<Response, AppError> {
+    serve_admin_version_preview_asset_inner(state, headers, preview_token, "index.html".to_string())
+        .await
+}
+
+async fn serve_admin_version_preview_asset(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Path((preview_token, asset_path)): Path<(String, String)>,
+) -> Result<Response, AppError> {
+    serve_admin_version_preview_asset_inner(state, headers, preview_token, asset_path).await
+}
+
+async fn serve_admin_version_preview_asset_inner(
+    state: AppState,
+    headers: HeaderMap,
+    preview_token: String,
+    asset_path: String,
+) -> Result<Response, AppError> {
+    if headers.contains_key(header::COOKIE) {
+        return Err(AppError::from_status(StatusCode::FORBIDDEN)
+            .with_message("审核试玩资源不能携带平台 Cookie"));
+    }
+    let session = state
+        .get_game_distribution_preview_session(&preview_token)
+        .await
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let asset_path = asset_path.trim_start_matches('/').to_string();
+    let content_type = release_asset_content_type(&asset_path)
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let version = state
+        .spacetime_client()
+        .get_game_distribution_version(session.version_id.clone())
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    if !matches!(version.status.as_str(), "pending_review" | "rejected") {
+        return Err(AppError::from_status(StatusCode::NOT_FOUND));
+    }
+    let package = release_package_bytes(&state, &version.game_id, &version.version_id).await?;
+    release_package_asset_response(&package, &asset_path, content_type, "no-store")
+}
+
 /// 审核通过时派生的发行入口：平台同源路径 `/games/{gameId}/`。
 ///
 /// 存相对路径而不是绝对 URL，部署侧就不需要提供发行域名；dev / release / 预览环境
@@ -2728,6 +2855,15 @@ fn owner_game_entry_payload(entry: GameDistributionOwnerGameRecord) -> Value {
     let Some(object) = payload.as_object_mut() else {
         return payload;
     };
+    object.insert(
+        "localProjectId".to_string(),
+        entry
+            .game
+            .local_project_id
+            .clone()
+            .map(Value::String)
+            .unwrap_or(Value::Null),
+    );
     object.insert(
         "latestVersion".to_string(),
         versions.first().cloned().unwrap_or(Value::Null),
@@ -3006,6 +3142,13 @@ fn map_package_error(error: ReleasePackageError) -> AppError {
 
 fn map_spacetime_error(error: SpacetimeClientError) -> AppError {
     match error {
+        SpacetimeClientError::Procedure(message)
+            if message.starts_with(GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT) =>
+        {
+            AppError::from_status(StatusCode::CONFLICT)
+                .with_code("VERSION_NUMBER_CONFLICT")
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
         SpacetimeClientError::Procedure(message) if message.contains("owner 不匹配") => {
             AppError::from_status(StatusCode::FORBIDDEN)
                 .with_details(json!({ "provider": "game-distribution", "message": message }))
@@ -4394,7 +4537,11 @@ mod tests {
     fn release_response_allows_opaque_sandbox_asset_loads() {
         // 发行文档在 allow-scripts 沙箱里是 opaque origin；CORP same-origin 会让游戏
         // 自己的脚本被浏览器拦下。
-        let response = release_asset_response(b"x".to_vec(), "text/javascript; charset=utf-8");
+        let response = release_asset_response_with_cache(
+            b"x".to_vec(),
+            "text/javascript; charset=utf-8",
+            "public, max-age=60, must-revalidate",
+        );
         assert_eq!(
             response
                 .headers()
@@ -4437,14 +4584,22 @@ mod tests {
 
     #[test]
     fn release_response_sets_nosniff_and_scopes_csp_to_html() {
-        let html = release_asset_response(b"<html></html>".to_vec(), "text/html; charset=utf-8");
+        let html = release_asset_response_with_cache(
+            b"<html></html>".to_vec(),
+            "text/html; charset=utf-8",
+            "public, max-age=60, must-revalidate",
+        );
         assert_eq!(
             html.headers().get(header::X_CONTENT_TYPE_OPTIONS).unwrap(),
             "nosniff"
         );
         assert!(html.headers().contains_key(header::CONTENT_SECURITY_POLICY));
 
-        let image = release_asset_response(vec![1, 2, 3], "image/png");
+        let image = release_asset_response_with_cache(
+            vec![1, 2, 3],
+            "image/png",
+            "public, max-age=60, must-revalidate",
+        );
         assert_eq!(
             image.headers().get(header::CONTENT_TYPE).unwrap(),
             "image/png"
diff --git a/server-rs/crates/api-server/src/state.rs b/server-rs/crates/api-server/src/state.rs
index a7b970bfc..e15e360e6 100644
--- a/server-rs/crates/api-server/src/state.rs
+++ b/server-rs/crates/api-server/src/state.rs
@@ -3,7 +3,7 @@ use std::sync::Mutex;
 #[cfg(test)]
 use std::sync::atomic::AtomicUsize;
 use std::{
-    collections::BTreeMap,
+    collections::{BTreeMap, HashMap},
     error::Error,
     fmt,
     sync::{
@@ -136,6 +136,12 @@ impl BackpressureState {
     }
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct GameDistributionPreviewSession {
+    pub(crate) version_id: String,
+    pub(crate) expires_at: OffsetDateTime,
+}
+
 #[derive(Clone)]
 pub struct AppState(Arc<AppStateInner>);
 
@@ -306,6 +312,8 @@ pub struct AppStateInner {
     ai_task_service: AiTaskService,
     spacetime_client: SpacetimeClient,
     external_api_auth_state: ExternalApiAuthState,
+    game_distribution_preview_sessions:
+        Arc<AsyncMutex<HashMap<String, GameDistributionPreviewSession>>>,
     editor_project_state: EditorProjectState,
     #[cfg(any())]
     puzzle_gallery_cache: PuzzleGalleryCache,
@@ -688,6 +696,7 @@ impl AppState {
             test_fail_editor_generation_enqueue: AtomicBool::new(false),
             #[cfg(test)]
             test_external_background_removal_enqueue: Arc::new(Mutex::new(None)),
+            game_distribution_preview_sessions: Arc::new(AsyncMutex::new(HashMap::new())),
             oss_client,
             project_snapshot_oss_client,
             template_library_store,
@@ -748,6 +757,35 @@ impl AppState {
         &self.refresh_cookie_config
     }
 
+    pub(crate) async fn create_game_distribution_preview_session(
+        &self,
+        version_id: String,
+        expires_at: OffsetDateTime,
+    ) -> String {
+        let token = uuid::Uuid::new_v4().to_string();
+        let now = OffsetDateTime::now_utc();
+        let mut sessions = self.game_distribution_preview_sessions.lock().await;
+        sessions.retain(|_, session| session.expires_at > now);
+        sessions.insert(
+            token.clone(),
+            GameDistributionPreviewSession {
+                version_id,
+                expires_at,
+            },
+        );
+        token
+    }
+
+    pub(crate) async fn get_game_distribution_preview_session(
+        &self,
+        token: &str,
+    ) -> Option<GameDistributionPreviewSession> {
+        let now = OffsetDateTime::now_utc();
+        let mut sessions = self.game_distribution_preview_sessions.lock().await;
+        sessions.retain(|_, session| session.expires_at > now);
+        sessions.get(token).cloned()
+    }
+
     pub fn http_request_permit_pools(&self) -> HttpRequestPermitPools {
         self.http_request_permit_pools.clone()
     }
diff --git a/server-rs/crates/shared-contracts/src/game_creation_app.rs b/server-rs/crates/shared-contracts/src/game_creation_app.rs
index d5ed46dd4..d11c615ac 100644
--- a/server-rs/crates/shared-contracts/src/game_creation_app.rs
+++ b/server-rs/crates/shared-contracts/src/game_creation_app.rs
@@ -1070,6 +1070,23 @@ pub fn validate_game_iteration_versions(versions: &[GameIterationVersion]) -> Re
 /// 代价与配套：未知顶层字段本身就是「这个文件比本客户端新」的信号。客户端读到直接报错并拒绝改写，
 /// 由调用方提示升级；同一读路径上还有 `schemaVersion` 的失败关闭门，两者互补——`schemaVersion` 管
 /// 「文件明说自己是新版本」，本属性管「版本号没升但字段已经变了」。
+/// AGC 本地发布绑定：记录该本地项目对应哪个平台账号/origin 的哪个游戏与最近版本。
+/// 缺失即未发布；accountId/apiBaseUrl 用于按实际会话隔离，避免切换账号后接管他人作品。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameCreationAppPublicationBinding {
+    pub account_id: String,
+    pub api_base_url: String,
+    pub game_id: String,
+    pub revision: u64,
+    #[serde(default)]
+    pub latest_version_id: Option<String>,
+    #[serde(default)]
+    pub latest_version_number: Option<u64>,
+    #[serde(default)]
+    pub status: Option<String>,
+}
+
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct GameCreationAppManifest {
@@ -1091,6 +1108,8 @@ pub struct GameCreationAppManifest {
     pub godot_project_root: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cocos_project_root: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publication: Option<GameCreationAppPublicationBinding>,
 }
 
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
@@ -1224,6 +1243,7 @@ pub fn new_game_creation_app_manifest(
         command_runs: Vec::new(),
         versions: Vec::new(),
         godot_project_root: None,
+        publication: None,
         cocos_project_root: None,
     }
 }
diff --git a/server-rs/crates/shared-contracts/src/game_distribution.rs b/server-rs/crates/shared-contracts/src/game_distribution.rs
index 8f346e2fb..289bf8ab9 100644
--- a/server-rs/crates/shared-contracts/src/game_distribution.rs
+++ b/server-rs/crates/shared-contracts/src/game_distribution.rs
@@ -14,6 +14,12 @@ pub const GAME_DISTRIBUTION_CATEGORIES: [&str; 7] =
 /// 客户端要么放行服务端必拒的包（白等一次上传），要么拦掉服务端能收的包。
 pub const GAME_DISTRIBUTION_MAX_PACKAGE_BYTES: u64 = 200 * 1024 * 1024;
 
+/// 显式版本号与既有版本冲突时的统一错误前缀。
+///
+/// SpacetimeDB 创建版本事务在 max 校验失败、或自动递增溢出时返回带此前缀的错误；
+/// api-server 据此映射成 HTTP 409，让客户端区分"版本号必须严格更大"与参数格式错误。
+pub const GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT: &str = "VERSION_NUMBER_CONFLICT";
+
 /// 发布页免费生成简介与分类的输入。
 ///
 /// 只传经过裁剪的项目摘要，不传本地绝对路径、聊天记录、凭据或完整 manifest。
@@ -224,6 +230,13 @@ pub struct GameDistributionCreateGameRequest {
 pub struct GameDistributionCreateVersionRequest {
     #[serde(default)]
     pub local_project_id: Option<String>,
+    /// 显式目标版本号；缺省时服务端按该游戏已有最大版本号自动 +1。
+    ///
+    /// 传入值必须严格大于该游戏已有最大版本号，允许跳号但不允许覆盖、重用或回退；
+    /// 冲突时服务端返回 409（`GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT`）。
+    /// 缺省时序列化省略该字段，保证旧客户端请求的幂等摘要与升级前一致。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version_number: Option<u64>,
     pub package_sha256: String,
     pub package_bytes: u64,
     pub package_file_count: u32,
@@ -363,6 +376,48 @@ mod tests {
         assert_eq!(payload.local_project_id.as_deref(), Some("proj-1"));
     }
 
+    #[test]
+    fn create_version_request_version_number_is_optional() {
+        let legacy: GameDistributionCreateVersionRequest =
+            serde_json::from_value(serde_json::json!({
+                "packageSha256": "a".repeat(64),
+                "packageBytes": 10,
+                "packageFileCount": 1,
+                "packageEntryPath": "index.html",
+                "gameMetadata": {
+                    "title": "游戏",
+                    "summary": "简介",
+                    "category": "益智",
+                    "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                    "inputModes": ["keyboard"],
+                    "orientation": "responsive",
+                },
+            }))
+            .expect("旧客户端不传版本号应继续可解析");
+        assert_eq!(legacy.version_number, None);
+
+        let explicit: GameDistributionCreateVersionRequest =
+            serde_json::from_value(serde_json::json!({
+                "versionNumber": 5,
+                "packageSha256": "a".repeat(64),
+                "packageBytes": 10,
+                "packageFileCount": 1,
+                "packageEntryPath": "index.html",
+                "gameMetadata": {
+                    "title": "游戏",
+                    "summary": "简介",
+                    "category": "益智",
+                    "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                    "inputModes": ["keyboard"],
+                    "orientation": "responsive",
+                },
+            }))
+            .expect("显式版本号应可解析");
+        assert_eq!(explicit.version_number, Some(5));
+        let serialized = serde_json::to_value(&explicit).expect("显式版本号应可序列化");
+        assert_eq!(serialized["versionNumber"], 5);
+    }
+
     #[test]
     fn update_game_metadata_request_round_trips_publication_revision() {
         let payload: GameDistributionUpdateGameMetadataRequest =
diff --git a/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs b/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
index e0790691b..de0076dec 100644
--- a/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
@@ -179,6 +179,7 @@ pub struct GameDistributionGameRecord {
     pub created_at: String,
     pub updated_at: String,
     pub cover_object_key: Option<String>,
+    pub local_project_id: Option<String>,
     pub screenshots_json: Option<String>,
 }
 
@@ -274,6 +275,7 @@ fn map_game(
         play_count: value.play_count,
         created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
         updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
+        local_project_id: value.local_project_id,
         cover_object_key: value.cover_object_key,
         screenshots_json: value.screenshots_json,
     }
diff --git a/server-rs/crates/spacetime-client/src/game_distribution.rs b/server-rs/crates/spacetime-client/src/game_distribution.rs
index 903cf497f..2a46f27fb 100644
--- a/server-rs/crates/spacetime-client/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/game_distribution.rs
@@ -88,6 +88,8 @@ pub struct GameDistributionCreateVersionRecordInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    /// 显式目标版本号；`None` 时由服务端按已有最大版本号自动 +1。
+    pub version_number: Option<u64>,
     /// api-server 校验并解析素材后生成的资料快照 JSON。
     pub metadata_json: String,
     pub package_sha256: String,
@@ -657,6 +659,7 @@ impl SpacetimeClient {
             game_id: input.game_id,
             owner_user_id: input.owner_user_id,
             version_id: input.version_id,
+            version_number: input.version_number,
             metadata_json: input.metadata_json,
             package_sha_256: input.package_sha256,
             package_bytes: input.package_bytes,
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs
index 86e199c18..e2529a295 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs
@@ -10,6 +10,7 @@ pub struct GameDistributionCreateVersionInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    pub version_number: Option<u64>,
     pub metadata_json: String,
     pub package_sha_256: String,
     pub package_bytes: u64,
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs
index 555f390bf..c9146e464 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs
@@ -28,6 +28,7 @@ pub struct GameDistributionGameSnapshot {
     pub play_count: u64,
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
+    pub local_project_id: Option<String>,
     pub cover_object_key: Option<String>,
     pub screenshots_json: Option<String>,
 }
diff --git a/server-rs/crates/spacetime-module/src/game_distribution.rs b/server-rs/crates/spacetime-module/src/game_distribution.rs
index e53883afb..502582030 100644
--- a/server-rs/crates/spacetime-module/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-module/src/game_distribution.rs
@@ -933,6 +933,8 @@ pub struct GameDistributionCreateVersionInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    /// 显式目标版本号；`None` 时由事务按该游戏最大版本号自动 +1（旧客户端兼容）。
+    pub version_number: Option<u64>,
     /// 由 api-server 校验并解析素材后生成的资料快照 JSON。
     pub metadata_json: String,
     pub package_sha256: String,
@@ -1150,6 +1152,7 @@ pub struct GameDistributionGameSnapshot {
     pub play_count: u64,
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
+    pub local_project_id: Option<String>,
     pub cover_object_key: Option<String>,
     pub screenshots_json: Option<String>,
 }
@@ -1887,6 +1890,33 @@ fn create_game_distribution_game_tx(
     Ok((game_distribution_game_snapshot(&game), false))
 }
 
+/// 解析本次创建的版本号。
+///
+/// - `None`：旧客户端兼容路径，取该游戏已有最大版本号 +1；溢出时失败关闭。
+/// - `Some(requested)`：必须严格大于已有最大版本号，允许跳号，但不允许覆盖或重用
+///   （`requested == 0` 在 `max_existing >= 0` 时必然落进拒绝分支）。
+///
+/// 事务串行化保证并发创建看到的是前一个事务提交后的 `max_existing`：两个并发请求传入
+/// 同一个显式版本号时，后执行的事务会读到已被占用的最大值并被这里拒绝。
+fn resolve_game_distribution_version_number(
+    max_existing: u64,
+    requested: Option<u64>,
+) -> Result<u64, String> {
+    match requested {
+        Some(requested) if requested > max_existing => Ok(requested),
+        Some(requested) => Err(format!(
+            "{}: 版本号 {requested} 必须严格大于当前最大版本号 {max_existing}",
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT
+        )),
+        None => max_existing.checked_add(1).ok_or_else(|| {
+            format!(
+                "{}: 版本号已达上限 {max_existing}，无法自动递增",
+                shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT
+            )
+        }),
+    }
+}
+
 fn create_game_distribution_version_tx(
     ctx: &ReducerContext,
     input: GameDistributionCreateVersionInput,
@@ -1950,16 +1980,16 @@ fn create_game_distribution_version_tx(
         return Err("版本 ID 已存在".to_string());
     }
 
-    let version_number = ctx
+    let max_existing_version = ctx
         .db
         .game_distribution_version()
         .iter()
         .filter(|version| version.game_id == game_id)
         .map(|version| version.version_number)
         .max()
-        .unwrap_or(0)
-        .checked_add(1)
-        .ok_or_else(|| "版本号溢出".to_string())?;
+        .unwrap_or(0);
+    let version_number =
+        resolve_game_distribution_version_number(max_existing_version, input.version_number)?;
     let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
     ctx.db
         .game_distribution_version()
@@ -3589,6 +3619,7 @@ fn game_distribution_game_snapshot(game: &GameDistributionGame) -> GameDistribut
         play_count: game.play_count,
         created_at_micros: game.created_at.to_micros_since_unix_epoch(),
         updated_at_micros: game.updated_at.to_micros_since_unix_epoch(),
+        local_project_id: game.local_project_id.clone(),
         cover_object_key: game.cover_object_key.clone(),
         screenshots_json: game.screenshots_json.clone(),
     }
@@ -3747,3 +3778,89 @@ fn public_game_distribution_snapshot(
         rating_count,
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn conflict(error: &str) -> bool {
+        error.starts_with(
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT,
+        )
+    }
+
+    #[test]
+    fn legacy_request_without_version_number_auto_increments_from_max() {
+        assert_eq!(
+            resolve_game_distribution_version_number(0, None).expect("首版应自动分配 1"),
+            1
+        );
+        assert_eq!(
+            resolve_game_distribution_version_number(7, None).expect("应分配最大版本号 +1"),
+            8
+        );
+    }
+
+    #[test]
+    fn explicit_version_number_must_exceed_current_max() {
+        assert_eq!(
+            resolve_game_distribution_version_number(2, Some(3)).expect("严格更大应接受"),
+            3
+        );
+        // 允许跳号：显式值可以从 0 直接跳到 5。
+        assert_eq!(
+            resolve_game_distribution_version_number(0, Some(5)).expect("跳号应接受"),
+            5
+        );
+        // 先发布 3、再发布 5：第二个显式值仍严格大于新的最大值。
+        assert_eq!(
+            resolve_game_distribution_version_number(3, Some(5)).expect("递增跳号应接受"),
+            5
+        );
+        assert_eq!(
+            resolve_game_distribution_version_number(u64::MAX - 1, Some(u64::MAX))
+                .expect("u64 上限作为显式值应接受"),
+            u64::MAX
+        );
+    }
+
+    #[test]
+    fn explicit_version_number_at_or_below_max_is_rejected_as_conflict() {
+        // 0 严格不大于任何已有最大值（含空集时的 0），必须拒绝，不能落成版本号 0。
+        let zero =
+            resolve_game_distribution_version_number(0, Some(0)).expect_err("版本号 0 应被拒绝");
+        assert!(conflict(&zero), "应带冲突前缀：{zero}");
+
+        let equal =
+            resolve_game_distribution_version_number(4, Some(4)).expect_err("相同版本号应被拒绝");
+        assert!(conflict(&equal), "应带冲突前缀：{equal}");
+
+        let lower =
+            resolve_game_distribution_version_number(4, Some(2)).expect_err("更小版本号应被拒绝");
+        assert!(conflict(&lower), "应带冲突前缀：{lower}");
+
+        let max_taken = resolve_game_distribution_version_number(u64::MAX, Some(u64::MAX))
+            .expect_err("已被占用的最大值应被拒绝");
+        assert!(conflict(&max_taken), "应带冲突前缀：{max_taken}");
+    }
+
+    #[test]
+    fn concurrent_same_explicit_version_number_is_rejected_for_the_later_transaction() {
+        // 两个并发事务都传 5、当前最大值为 4：先提交的事务写入 5，后执行的事务重新读到
+        // max=5 后必须拒绝，而不是覆盖已存在的版本。
+        let first = resolve_game_distribution_version_number(4, Some(5)).expect("首个请求应成功");
+        assert_eq!(first, 5);
+        let second = resolve_game_distribution_version_number(first, Some(5))
+            .expect_err("第二个同名版本号应被拒绝");
+        assert!(conflict(&second), "应带冲突前缀：{second}");
+    }
+
+    #[test]
+    fn auto_increment_overflow_is_reported_as_conflict() {
+        let overflow = resolve_game_distribution_version_number(u64::MAX, None)
+            .expect_err("最大版本号下自动递增应失败关闭");
+        assert!(conflict(&overflow), "应带冲突前缀：{overflow}");
+        // 溢出不能回绕成 0 或静默改写已有版本。
+        assert!(!overflow.contains("版本号 0"));
+    }
+}
diff --git a/src/components/game-distribution/GameDetailPage.tsx b/src/components/game-distribution/GameDetailPage.tsx
index 9d578f902..51eb05e69 100644
--- a/src/components/game-distribution/GameDetailPage.tsx
+++ b/src/components/game-distribution/GameDetailPage.tsx
@@ -1,13 +1,10 @@
 import './gameDistribution.css';
-import './gameDistributionShowcase.css';
 
 import {
-  ArrowLeft,
-  Gamepad2,
-  Maximize2,
-  Smartphone,
-  Sparkles,
-} from 'lucide-react';
+  GameDetailDisplay,
+  type GameDetailAssetRenderInput,
+} from '@genarrative/shared/components';
+import { ArrowLeft, Gamepad2, Maximize2 } from 'lucide-react';
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 import type {
@@ -32,7 +29,6 @@ import {
   normalizeGameId,
   useIsMobileViewport,
 } from './gameDistributionGuards';
-import { GameCover } from './GameGalleryPage';
 import { GAME_METADATA_INPUT_MODE_LABELS } from './gameMetadataOptions';
 import { GameRatingSummary, GameReviews } from './GameReviews';
 import { GameVersionHistory } from './GameVersionHistory';
@@ -83,74 +79,23 @@ function resolveControlsLabel(
   return fallback || '未标注操作方式';
 }
 
-/** 缩略图自己换签，失败时退回空占位，不阻塞 hero 与主行动作。 */
-function GameShowcaseThumb({
-  objectKey,
-  label,
-  isActive,
-  onSelect,
-}: {
-  objectKey: string;
-  label: string;
-  isActive: boolean;
-  onSelect: () => void;
-}) {
-  const { resolvedUrl } = useResolvedAssetReadUrl(null, { objectKey });
-  return (
-    <button
-      type="button"
-      className="game-detail-thumb"
-      aria-pressed={isActive}
-      aria-label={label}
-      onClick={onSelect}
-    >
-      {resolvedUrl ? (
-        <img src={resolvedUrl} alt="" loading="lazy" decoding="async" />
-      ) : (
-        <span className="game-detail-thumb__placeholder" />
-      )}
-    </button>
-  );
-}
-
 /**
- * 详情页封面区：默认展示封面，存在截图时在下方给出可点击的缩略图条。
- *
- * 缩略图第一项固定是封面本身，方便作者/玩家从截图切回封面；只有封面时整条不渲染。
+ * 展示层需要的素材换签桥接：公开详情仍按 objectKey 逐个换签，
+ * 只是把结果交给共享展示组件渲染，换签失败时保持占位。
  */
-function GameShowcase({ game }: { game: GameDistributionGame }) {
-  const coverKey = (game.coverObjectKey ?? '').trim();
-  const screenshotKeys = (game.screenshots ?? [])
-    .map((key) => key.trim())
-    .filter(Boolean)
-    .slice(0, 6);
-  const items = [
-    ...(coverKey ? [{ key: coverKey, label: '封面' }] : []),
-    ...screenshotKeys.map((key, index) => ({
-      key,
-      label: `截图 ${index + 1}`,
-    })),
-  ];
-  const [activeIndex, setActiveIndex] = useState(0);
-  const activeKey = items[activeIndex]?.key ?? coverKey;
-
+function GameDetailResolvedAsset({
+  objectKey,
+  role,
+}: GameDetailAssetRenderInput) {
+  const { resolvedUrl } = useResolvedAssetReadUrl(null, { objectKey });
+  if (!resolvedUrl) return null;
   return (
-    <div className="game-detail-showcase">
-      <GameCover game={game} priority objectKey={activeKey} />
-      {items.length > 1 ? (
-        <div className="game-detail-thumbs" role="group" aria-label="游戏截图">
-          {items.map((item, index) => (
-            <GameShowcaseThumb
-              key={item.key}
-              objectKey={item.key}
-              label={`${item.label}（查看大图）`}
-              isActive={index === activeIndex}
-              onSelect={() => setActiveIndex(index)}
-            />
-          ))}
-        </div>
-      ) : null}
-    </div>
+    <img
+      src={resolvedUrl}
+      alt=""
+      loading={role === 'cover' ? 'eager' : 'lazy'}
+      decoding="async"
+    />
   );
 }
 
@@ -359,22 +304,18 @@ function GameDetailContent({
       <button type="button" className="game-back-button" onClick={onBack}>
         <ArrowLeft /> 返回
       </button>
-      <section className="game-detail-hero">
-        <GameShowcase game={game} />
-        <div className="game-detail-hero__copy">
-          <span className="game-eyebrow">
-            <Sparkles aria-hidden="true" /> {game.category}
-          </span>
-          <h1>{game.title}</h1>
-          <p className="game-detail-hero__summary">{game.summary}</p>
-          <div className="game-detail-hero__rating">
-            <GameRatingSummary state={reviews} />
-          </div>
-          <div className="game-detail-hero__author">
-            <span className="game-avatar">{game.author.name.slice(0, 1)}</span>
-            <span>由 {game.author.name} 制作</span>
-          </div>
-          <div className="game-detail-hero__actions">
+      <GameDetailDisplay
+        game={game}
+        coverObjectKey={game.coverObjectKey}
+        screenshotObjectKeys={game.screenshots}
+        coverColor={game.coverColor}
+        icon={game.icon}
+        renderAsset={(asset) => <GameDetailResolvedAsset {...asset} />}
+        controlsLabel={resolveControlsLabel(version, game.inputModes)}
+        versionLabel={versionLabel}
+        rating={<GameRatingSummary state={reviews} />}
+        actions={
+          <>
             <PlatformActionButton
               size="lg"
               shape="pill"
@@ -402,76 +343,44 @@ function GameDetailContent({
                 作品尚未公开，暂时没有在线可玩版本
               </span>
             ) : null}
-            <span className="game-detail-hero__play-count">
-              {game.playCount.toLocaleString()} 次游玩
-            </span>
-          </div>
-        </div>
-      </section>
-      {ownerView && ownerGame ? (
-        <section className="game-owner-panel" aria-label="作品状态">
-          <div className="game-owner-panel__heading">
-            <h2>作品状态</h2>
-            <span
-              className={`my-game-status my-game-status--${ownerGame.status}`}
-            >
-              {GAME_STATUS_LABEL[ownerGame.status] ?? ownerGame.status}
-            </span>
-          </div>
-          <div className="game-owner-panel__meta">
-            {latestVersion ? (
-              <span>
-                最新版本 v{latestVersion.versionNumber} ·{' '}
-                {VERSION_STATUS_LABEL[latestVersion.status] ??
-                  latestVersion.status}
+          </>
+        }
+      >
+        {ownerView && ownerGame ? (
+          <section className="game-owner-panel" aria-label="作品状态">
+            <div className="game-owner-panel__heading">
+              <h2>作品状态</h2>
+              <span
+                className={`my-game-status my-game-status--${ownerGame.status}`}
+              >
+                {GAME_STATUS_LABEL[ownerGame.status] ?? ownerGame.status}
               </span>
-            ) : (
-              <span>还没有提交过版本</span>
-            )}
-          </div>
-          {latestReviewReason ? (
-            <p className="game-owner-panel__reason">
-              驳回理由：{latestReviewReason}
-            </p>
-          ) : null}
-          {ownerGame.versions.length > 0 ? (
-            <GameVersionHistory
-              versions={ownerGame.versions}
-              recoveryActions={recoveryActions}
-            />
-          ) : null}
-        </section>
-      ) : null}
-      <section className="game-detail-body">
-        <div className="game-detail-main">
-          <h2>关于这款游戏</h2>
-          <p>{game.description}</p>
-          <div className="game-tag-list">
-            {game.tags.map((tag) => (
-              <span key={tag}>{tag}</span>
-            ))}
-          </div>
-        </div>
-        <aside className="game-detail-side">
-          <div className="game-info-card">
-            <strong>游玩方式</strong>
-            <span>{resolveControlsLabel(version, game.inputModes)}</span>
-          </div>
-          <div className="game-info-card">
-            <strong>设备支持</strong>
-            <span>
-              <Smartphone aria-hidden="true" />{' '}
-              {game.deviceSupport.mobile ? '移动端' : ''}
-              {game.deviceSupport.desktop ? ' · 桌面端' : ''}
-              {game.deviceSupport.touch ? ' · 支持触屏' : ''}
-            </span>
-          </div>
-          <div className="game-info-card">
-            <strong>当前版本</strong>
-            <span>{versionLabel || '—'}</span>
-          </div>
-        </aside>
-      </section>
+            </div>
+            <div className="game-owner-panel__meta">
+              {latestVersion ? (
+                <span>
+                  最新版本 v{latestVersion.versionNumber} ·{' '}
+                  {VERSION_STATUS_LABEL[latestVersion.status] ??
+                    latestVersion.status}
+                </span>
+              ) : (
+                <span>还没有提交过版本</span>
+              )}
+            </div>
+            {latestReviewReason ? (
+              <p className="game-owner-panel__reason">
+                驳回理由：{latestReviewReason}
+              </p>
+            ) : null}
+            {ownerGame.versions.length > 0 ? (
+              <GameVersionHistory
+                versions={ownerGame.versions}
+                recoveryActions={recoveryActions}
+              />
+            ) : null}
+          </section>
+        ) : null}
+      </GameDetailDisplay>
       <GameReviews state={reviews} canReview={canReview} onLogin={onLogin} />
       <p className="game-detail-footnote">
         <Maximize2 aria-hidden="true" />{' '}
diff --git a/src/components/game-distribution/GameDistributionPages.test.tsx b/src/components/game-distribution/GameDistributionPages.test.tsx
index 862cc8aa5..45be877b9 100644
--- a/src/components/game-distribution/GameDistributionPages.test.tsx
+++ b/src/components/game-distribution/GameDistributionPages.test.tsx
@@ -679,7 +679,7 @@ describe('游戏封面与截图展示', () => {
     await screen.findByRole('heading', { name: '星轨防线' });
     const heroImage = () =>
       document
-        .querySelector('.game-detail-showcase img.game-cover__image')
+        .querySelector('.game-detail-cover img')
         ?.getAttribute('src');
     expect(heroImage()).toBe(
       'https://assets.example.test/game-distribution/cover/alpha.png',
@@ -724,7 +724,9 @@ describe('游戏封面与截图展示', () => {
     );
 
     await screen.findByRole('heading', { name: '星轨防线' });
-    expect(document.querySelectorAll('img.game-cover__image')).toHaveLength(0);
-    expect(document.querySelectorAll('.game-cover__icon')).toHaveLength(1);
+    expect(document.querySelectorAll('.game-detail-cover img')).toHaveLength(0);
+    expect(
+      document.querySelectorAll('.game-detail-cover__icon'),
+    ).toHaveLength(1);
   });
 });
diff --git a/src/components/game-distribution/gameDistribution.css b/src/components/game-distribution/gameDistribution.css
index d9b432406..2ec1a61ac 100644
--- a/src/components/game-distribution/gameDistribution.css
+++ b/src/components/game-distribution/gameDistribution.css
@@ -351,38 +351,6 @@
 .game-back-button svg {
   width: 1rem;
 }
-.game-detail-hero {
-  display: grid;
-  grid-template-columns: minmax(13rem, 21rem) minmax(0, 1fr);
-  align-items: center;
-  gap: clamp(1.4rem, 4vw, 3.5rem);
-  margin-top: 1.5rem;
-}
-.game-detail-hero .game-cover {
-  border-radius: 1.7rem;
-  box-shadow: 0 1.25rem 2.5rem rgba(70, 42, 34, 0.18);
-}
-.game-detail-hero h1 {
-  margin: 0.65rem 0 0;
-  font-size: clamp(2rem, 4.8vw, 3.7rem);
-  letter-spacing: -0.055em;
-}
-.game-detail-hero__summary {
-  max-width: 32rem;
-  margin: 0.8rem 0 0;
-  color: var(--platform-text-base);
-  font-size: 1rem;
-  line-height: 1.75;
-}
-.game-detail-hero__author {
-  display: flex;
-  align-items: center;
-  gap: 0.55rem;
-  margin-top: 1.15rem;
-  color: var(--platform-text-soft);
-  font-size: 0.78rem;
-  font-weight: 700;
-}
 .game-avatar {
   display: grid;
   width: 1.8rem;
@@ -393,91 +361,11 @@
   color: var(--platform-accent-strong);
   font-weight: 900;
 }
-.game-detail-hero__actions {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  margin-top: 1.4rem;
-}
-.game-detail-hero__play-count {
-  color: var(--platform-text-soft);
-  font-size: 0.75rem;
-}
 .game-device-warning {
   color: var(--platform-accent-strong);
   font-size: 0.75rem;
   font-weight: 800;
 }
-.game-detail-body {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) 17rem;
-  gap: 3rem;
-  margin-top: 3rem;
-  border-top: 1px solid var(--platform-surface-border);
-  padding-top: 2rem;
-}
-.game-detail-main h2 {
-  margin: 0;
-  font-size: 1.25rem;
-}
-.game-detail-main p {
-  max-width: 45rem;
-  margin: 0.75rem 0 0;
-  color: var(--platform-text-base);
-  line-height: 1.9;
-}
-.game-tag-list {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.45rem;
-  margin-top: 1.3rem;
-}
-.game-tag-list span {
-  border: 1px solid var(--platform-surface-border);
-  border-radius: 999px;
-  padding: 0.35rem 0.65rem;
-  color: var(--platform-text-soft);
-  font-size: 0.7rem;
-  font-weight: 700;
-}
-.game-detail-side {
-  display: grid;
-  gap: 0.7rem;
-  align-content: start;
-}
-.game-info-card {
-  display: grid;
-  gap: 0.3rem;
-  border: 1px solid var(--platform-surface-border);
-  border-radius: 1rem;
-  padding: 0.8rem 0.9rem;
-  background: var(--platform-panel-fill);
-}
-.game-info-card strong {
-  font-size: 0.72rem;
-}
-.game-info-card span {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.28rem;
-  color: var(--platform-text-soft);
-  font-size: 0.72rem;
-  line-height: 1.45;
-}
-.game-info-card svg {
-  width: 0.85rem;
-}
-.game-detail-footnote {
-  display: flex;
-  align-items: center;
-  gap: 0.4rem;
-  margin-top: 2.2rem;
-  color: var(--platform-text-soft);
-  font-size: 0.7rem;
-}
-.game-detail-footnote svg {
-  width: 0.9rem;
-}
 .game-loading-panel {
   display: grid;
   min-height: 18rem;
@@ -646,25 +534,11 @@
   .game-grid {
     grid-template-columns: repeat(2, minmax(0, 1fr));
   }
-  .game-detail-hero {
-    grid-template-columns: 9rem minmax(0, 1fr);
-    gap: 1.15rem;
-  }
-  .game-detail-hero .game-cover {
-    min-height: 9rem;
-  }
   .game-cover__icon {
     width: 3.7rem;
     border-radius: 1rem;
     font-size: 2rem;
   }
-  .game-detail-body {
-    grid-template-columns: 1fr;
-    gap: 1.5rem;
-  }
-  .game-detail-side {
-    grid-template-columns: repeat(3, minmax(0, 1fr));
-  }
 }
 
 @media (max-width: 560px) {
@@ -704,19 +578,6 @@
   .game-cover {
     min-height: 10.5rem;
   }
-  .game-detail-hero {
-    display: block;
-  }
-  .game-detail-hero .game-cover {
-    min-height: 13rem;
-    margin-top: 1.2rem;
-  }
-  .game-detail-hero h1 {
-    margin-top: 1.4rem;
-  }
-  .game-detail-side {
-    grid-template-columns: 1fr;
-  }
   .game-play-page {
     padding: 0.7rem;
   }
diff --git a/src/components/game-distribution/gameDistributionShowcase.css b/src/components/game-distribution/gameDistributionShowcase.css
index 5cd687181..2d879c129 100644
--- a/src/components/game-distribution/gameDistributionShowcase.css
+++ b/src/components/game-distribution/gameDistributionShowcase.css
@@ -1,8 +1,10 @@
 /*
- * 游戏分发封面与截图的展示层补充样式。
+ * `.game-cover` 的「图片已就绪」态样式。
  *
- * 真实封面/截图换签成功后覆盖原有渐变占位；未上传、换签失败或仍在解析时保持
- * gameDistribution.css 里的占位视觉，因此这里的规则只负责“图片已就绪”这一态。
+ * 列表卡片、播放页与作者中心卡片共用：真实封面/截图换签成功后覆盖
+ * gameDistribution.css 里的渐变占位；未上传、换签失败或仍在解析时保持占位视觉，
+ * 所以这里只负责这一态。详情展示层有自己的 `.game-detail-cover`，见
+ * packages/shared/src/components/GameDetailDisplay/index.css。
  */
 .game-cover__image {
   position: absolute;
@@ -12,64 +14,3 @@
   height: 100%;
   object-fit: cover;
 }
-
-.game-detail-showcase {
-  display: grid;
-  gap: 0.7rem;
-  min-width: 0;
-}
-
-.game-detail-thumbs {
-  display: flex;
-  gap: 0.5rem;
-  overflow-x: auto;
-  padding-bottom: 0.15rem;
-  scroll-snap-type: x proximity;
-  scrollbar-width: thin;
-}
-
-.game-detail-thumb {
-  flex: 0 0 auto;
-  width: 5.4rem;
-  aspect-ratio: 16 / 9;
-  overflow: hidden;
-  border: 1px solid var(--platform-surface-border);
-  border-radius: 0.7rem;
-  padding: 0;
-  background: linear-gradient(
-    135deg,
-    rgba(241, 159, 95, 0.24),
-    rgba(91, 49, 42, 0.16)
-  );
-  cursor: pointer;
-  scroll-snap-align: start;
-  transition: 160ms ease;
-}
-
-.game-detail-thumb:hover {
-  border-color: rgba(199, 101, 61, 0.45);
-}
-
-.game-detail-thumb[aria-pressed='true'] {
-  border-color: rgba(199, 101, 61, 0.62);
-  box-shadow: 0 0 0 2px rgba(199, 101, 61, 0.22);
-}
-
-.game-detail-thumb img {
-  display: block;
-  width: 100%;
-  height: 100%;
-  object-fit: cover;
-}
-
-.game-detail-thumb__placeholder {
-  display: block;
-  width: 100%;
-  height: 100%;
-}
-
-@media (max-width: 560px) {
-  .game-detail-thumb {
-    width: 4.6rem;
-  }
-}