diff --git a/.gitea/workflows/project-ci.yml b/.gitea/workflows/project-ci.yml
index 5bde92df5..d56eba0f4 100644
--- a/.gitea/workflows/project-ci.yml
+++ b/.gitea/workflows/project-ci.yml
@@ -20,6 +20,9 @@ env:
   CARGO_HTTP_MULTIPLEXING: 'false'
   CARGO_NET_RETRY: '10'
   CARGO_TERM_COLOR: always
+  # 等价于给每条 `cargo test` 加 `-q`：通过的用例只打点号，失败的才按名字列出。
+  # 对 npm 脚本、shard runner 里嵌套的 cargo 同样生效，避免逐条 `test ... ok` 刷屏。
+  CARGO_TERM_QUIET: 'true'
   NPM_CONFIG_AUDIT: 'false'
   NPM_CONFIG_FETCH_RETRIES: '10'
   NPM_CONFIG_FETCH_RETRY_FACTOR: '2'
diff --git a/apps/admin-web/src/api/adminApiClient.test.ts b/apps/admin-web/src/api/adminApiClient.test.ts
index 8c6d85581..ec4781c68 100644
--- a/apps/admin-web/src/api/adminApiClient.test.ts
+++ b/apps/admin-web/src/api/adminApiClient.test.ts
@@ -618,7 +618,7 @@ test('游戏管理列表与恢复动作使用约定的 URL、方法和幂等键'
   );
 
   expect(fetchMock.mock.calls[0]?.[0]).toBe(
-    '/admin/api/game-distribution/games?limit=50',
+    '/admin/api/game-distribution/games?limit=80',
   );
   expect(fetchMock.mock.calls[0]?.[1]).toEqual(
     expect.objectContaining({
@@ -656,6 +656,32 @@ test('游戏管理列表与恢复动作使用约定的 URL、方法和幂等键'
   expect(fetchMock).toHaveBeenCalledTimes(2);
 });
 
+test('游戏管理列表把筛选与游标编码进查询串', async () => {
+  const fetchMock = vi
+    .fn()
+    .mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({ ok: true, data: { games: [], nextCursor: null } }),
+          { status: 200 },
+        ),
+      ),
+    );
+  vi.stubGlobal('fetch', fetchMock);
+
+  await listAdminGameDistributionGames('admin-token', {
+    limit: 20,
+    keyword: ' 拼图 ',
+    owner: 'user_9',
+    status: 'suspended',
+    cursor: '1710000000000:game_1',
+  });
+
+  expect(fetchMock.mock.calls[0]?.[0]).toBe(
+    '/admin/api/game-distribution/games?limit=20&keyword=%E6%8B%BC%E5%9B%BE&owner=user_9&status=suspended&cursor=1710000000000%3Agame_1',
+  );
+});
+
 test('安全下架请求携带公开修订号、原因与幂等键', async () => {
   const fetchMock = vi.fn().mockImplementation(() =>
     Promise.resolve(
diff --git a/apps/admin-web/src/api/adminApiClient.ts b/apps/admin-web/src/api/adminApiClient.ts
index e068b3adb..9c3470426 100644
--- a/apps/admin-web/src/api/adminApiClient.ts
+++ b/apps/admin-web/src/api/adminApiClient.ts
@@ -33,11 +33,14 @@ import type {
   AdminExternalApiKeyListResponse,
   AdminFeatureGateConfigResponse,
   AdminGameDistributionGameListResponse,
+  AdminGameDistributionGameStatus,
+  AdminGameDistributionPreviewSessionResponse,
   AdminGameDistributionRestoreRequest,
   AdminGameDistributionRestoreResponse,
   AdminGameDistributionReviewListResponse,
   AdminGameDistributionReviewRequest,
   AdminGameDistributionReviewResponse,
+  AdminGameDistributionVersionDetailResponse,
   AdminGameReviewDetailResponse,
   AdminGameReviewGamesQuery,
   AdminGameReviewGamesResponse,
@@ -1257,6 +1260,39 @@ 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(),
+  }));
+}
+
+/**
+ * 后台作品管理列表。
+ *
+ * 关键词、作者与状态过滤以及游标分页都由服务端执行：前端只透传查询参数，
+ * 不本地过滤，否则分页边界会与 `nextCursor` 的语义打架。
+ */
+
 function gameReviewQuery(
   query: AdminGameReviewGamesQuery | AdminGameReviewsQuery,
 ) {
@@ -1311,18 +1347,30 @@ export function moderateAdminGameReview(
     },
   );
 }
-
 export function listAdminGameDistributionGames(
   token: string,
-  options: { limit?: number } = {},
+  options: {
+    limit?: number;
+    keyword?: string;
+    owner?: string;
+    status?: AdminGameDistributionGameStatus | '';
+    cursor?: string | null;
+  } = {},
   signal?: AbortSignal,
 ) {
   const requestedLimit = options.limit ?? 50;
   const normalizedLimit = Number.isFinite(requestedLimit)
-    ? Math.min(Math.max(Math.trunc(requestedLimit), 1), 50)
+    ? Math.min(Math.max(Math.trunc(requestedLimit), 1), 200)
     : 50;
+  const params = new URLSearchParams({ limit: String(normalizedLimit) });
+  const keyword = options.keyword?.trim();
+  if (keyword) params.set('keyword', keyword);
+  const owner = options.owner?.trim();
+  if (owner) params.set('owner', owner);
+  if (options.status) params.set('status', options.status);
+  if (options.cursor) params.set('cursor', options.cursor);
   return request<AdminGameDistributionGameListResponse>(
-    `/admin/api/game-distribution/games?limit=${normalizedLimit}`,
+    `/admin/api/game-distribution/games?${params.toString()}`,
     { token, signal },
   );
 }
diff --git a/apps/admin-web/src/api/adminApiTypes.ts b/apps/admin-web/src/api/adminApiTypes.ts
index 1e540beae..8fecfe485 100644
--- a/apps/admin-web/src/api/adminApiTypes.ts
+++ b/apps/admin-web/src/api/adminApiTypes.ts
@@ -1143,6 +1143,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;
@@ -1197,18 +1243,29 @@ export interface AdminGameDistributionGameEntry {
     name: string;
     avatarUrl: string | null;
   };
-  status: string;
+  status: AdminGameDistributionGameStatus;
   versionCount: number;
   playCount: number;
   activeVersionId: string | null;
   publicationRevision: number;
   createdAt: string;
   updatedAt: string;
+  /** 作者软删除时间；为空表示未删除。 */
+  deletedAt: string | null;
   versions: AdminGameDistributionGameVersionEntry[];
 }
 
+/** 后台作品列表的状态：游戏可见性 + 作者软删除。 */
+export type AdminGameDistributionGameStatus =
+  | 'published'
+  | 'unpublished'
+  | 'suspended'
+  | 'deleted';
+
 export interface AdminGameDistributionGameListResponse {
   games: AdminGameDistributionGameEntry[];
+  /** 还有下一页时为下一页游标；旧响应没有该字段，按空值处理。 */
+  nextCursor?: string | null;
 }
 
 export interface AdminGameDistributionRestoreRequest {
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
index 8291e815e..3ca7ab6be 100644
--- a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
@@ -10,11 +10,17 @@ import {
 import { beforeEach, expect, test, vi } from 'vitest';
 
 import {
+  createAdminGameDistributionPreviewSession,
+  getAdminGameDistributionVersion,
+  listAdminGameDistributionGames,
   listAdminGameDistributionReviews,
   reviewAdminGameDistributionVersion,
-  suspendAdminGameDistributionGame,
 } from '../api/adminApiClient';
-import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
+import type {
+  AdminGameDistributionGameListResponse,
+  AdminGameDistributionReviewEntry,
+  AdminGameDistributionVersionDetailResponse,
+} from '../api/adminApiTypes';
 import { AdminGameDistributionReviewPage } from './AdminGameDistributionReviewPage';
 
 vi.mock('../api/adminApiClient', () => ({
@@ -28,11 +34,12 @@ vi.mock('../api/adminApiClient', () => ({
   formatAdminApiError: vi.fn((error: unknown) =>
     error instanceof Error ? error.message : '请求失败',
   ),
+  createAdminGameDistributionPreviewSession: vi.fn(),
+  getAdminGameDistributionVersion: vi.fn(),
+  listAdminGameDistributionGames: vi.fn(),
   listAdminGameDistributionReviews: vi.fn(),
   reviewAdminGameDistributionVersion: vi.fn(),
-  suspendAdminGameDistributionGame: vi.fn(),
 }));
-
 const entry: AdminGameDistributionReviewEntry = {
   versionId: 'version-1',
   gameId: 'game_1',
@@ -42,18 +49,72 @@ const entry: AdminGameDistributionReviewEntry = {
   status: 'pending_review',
   publicationRevision: 4,
   reviewReason: null,
-  createdAt: '2026-09-20T08:00:00Z',
-  updatedAt: '2026-09-20T08:00:00Z',
+  // 真实后台下发的是 `seconds.microsZ`（非 ISO 8601），见 shared-kernel `format_timestamp_micros`。
+  createdAt: '1791008678.817257Z',
+  updatedAt: '1791008678.817257Z',
+};
+
+/** 游戏名与作者由既有后台作品列表接口按 gameId 反查（待审列表本身不含这两个字段）。 */
+const gameTitle = '测试游戏名';
+const gameListResponse: AdminGameDistributionGameListResponse = {
+  games: [
+    {
+      gameId: 'game_1',
+      title: gameTitle,
+      author: { id: 'user-9f1', name: '136****8867', avatarUrl: null },
+      status: 'unpublished',
+      versionCount: 1,
+      playCount: 0,
+      activeVersionId: null,
+      publicationRevision: 4,
+      createdAt: '2026-09-20T08:00:00Z',
+      updatedAt: '2026-09-20T08:00:00Z',
+      deletedAt: null,
+      versions: [],
+    },
+  ],
+  nextCursor: null,
+};
+
+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: 7,
+    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(listAdminGameDistributionGames).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,
   });
+  vi.mocked(listAdminGameDistributionGames).mockResolvedValue(gameListResponse);
 });
 
 test('通过审核只提交当前 publicationRevision 并刷新列表', async () => {
@@ -68,7 +129,7 @@ test('通过审核只提交当前 publicationRevision 并刷新列表', async ()
       onUnauthorized={vi.fn()}
     />,
   );
-  await screen.findByText('game_1');
+  await screen.findByText(gameTitle);
 
   expect(screen.queryByLabelText('发行入口')).toBeNull();
   expect(screen.queryByText('通过后由系统分配发行地址')).toBeNull();
@@ -107,7 +168,7 @@ test('点击拒绝后填写理由再提交审核接口', async () => {
       onUnauthorized={vi.fn()}
     />,
   );
-  await screen.findByText('game_1');
+  await screen.findByText(gameTitle);
 
   fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
   const dialog = await screen.findByRole('dialog');
@@ -135,54 +196,44 @@ test('点击拒绝后填写理由再提交审核接口', async () => {
   });
 });
 
-test('安全下架需要先填写原因，再二次确认并携带公开修订号', async () => {
-  vi.mocked(suspendAdminGameDistributionGame).mockResolvedValue({
-    game: {
-      id: 'game_1',
-      title: '测试游戏',
-      status: 'suspended',
-      publicationRevision: 5,
-    },
-    replayed: false,
-  });
-
+test('待审版本行内只保留版本级审核动作，不提供游戏级安全下架', async () => {
   render(
     <AdminGameDistributionReviewPage
       token="admin-token"
       onUnauthorized={vi.fn()}
     />,
   );
-  await screen.findByText('game_1');
+  await screen.findByText(gameTitle);
 
-  fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
-  const reasonDialog = await screen.findByRole('dialog');
-  fireEvent.change(
-    within(reasonDialog).getByRole('textbox', { name: '下架原因' }),
-    {
-      target: { value: '盗用素材' },
-    },
-  );
-  fireEvent.click(
-    within(reasonDialog).getByRole('button', { name: '继续下架' }),
-  );
+  // 「安全下架」是游戏级动作（强制下线线上版本），入口在「游戏管理」页；
+  // 审核一个新版本时不该出现该动作。
+  expect(screen.queryByRole('button', { name: '安全下架' })).toBeNull();
+  expect(screen.queryByText('继续下架')).toBeNull();
+  expect(screen.queryByLabelText('下架原因')).toBeNull();
 
-  await screen.findByText('确认操作');
-  const confirmDialog = screen.getByRole('dialog');
-  fireEvent.click(within(confirmDialog).getByRole('button', { name: '确认' }));
+  fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
+  const dialog = await screen.findByRole('dialog');
+  expect(within(dialog).queryByRole('button', { name: '继续下架' })).toBeNull();
+  expect(within(dialog).getByLabelText('拒绝理由')).toBeTruthy();
+});
 
-  await waitFor(() =>
-    expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
+test('提交时间列把后端的 seconds.microsZ 渲染成可读本地时间', async () => {
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText(gameTitle);
+
+  const row = screen.getByText(gameTitle).closest('tr');
+  expect(row).not.toBeNull();
+  const submittedCell = within(row as HTMLElement).getAllByRole('cell')[3];
+  // 解析不出来时会回落到 `-`，这正是本次修复前的线上表现。
+  expect(submittedCell?.textContent).not.toBe('-');
+  expect(submittedCell?.textContent).toMatch(
+    /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2}$/u,
   );
-  const [token, gameId, idempotencyKey, payload] =
-    vi.mocked(suspendAdminGameDistributionGame).mock.calls[0] ?? [];
-  expect(token).toBe('admin-token');
-  expect(gameId).toBe('game_1');
-  expect(String(idempotencyKey)).toContain('game_1');
-  expect(payload).toEqual({
-    expectedPublicationRevision: 4,
-    reason: '盗用素材',
-  });
-  expect(await screen.findByText(/已安全下架/u)).toBeTruthy();
 });
 
 test('取消理由输入时不做审核操作', async () => {
@@ -192,7 +243,7 @@ test('取消理由输入时不做审核操作', async () => {
       onUnauthorized={vi.fn()}
     />,
   );
-  await screen.findByText('game_1');
+  await screen.findByText(gameTitle);
 
   fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
   const dialog = await screen.findByRole('dialog');
@@ -202,31 +253,67 @@ test('取消理由输入时不做审核操作', async () => {
   expect(reviewAdminGameDistributionVersion).not.toHaveBeenCalled();
 });
 
-test('取消安全下架确认时不下架', async () => {
+test('游戏列显示游戏名与作者，不再把 gameId 当主展示', async () => {
   render(
     <AdminGameDistributionReviewPage
       token="admin-token"
       onUnauthorized={vi.fn()}
     />,
   );
-  await screen.findByText('game_1');
+  await screen.findByText(gameTitle);
 
-  fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
-  const reasonDialog = await screen.findByRole('dialog');
-  fireEvent.change(
-    within(reasonDialog).getByRole('textbox', { name: '下架原因' }),
-    {
-      target: { value: '盗用素材' },
-    },
-  );
-  fireEvent.click(
-    within(reasonDialog).getByRole('button', { name: '继续下架' }),
+  // 按 gameId 反查一次，第二次刷新走缓存（本次只加载一次列表）。
+  expect(listAdminGameDistributionGames).toHaveBeenCalledWith(
+    'admin-token',
+    expect.objectContaining({ keyword: 'game_1' }),
   );
 
-  await screen.findByText('确认操作');
-  const confirmDialog = screen.getByRole('dialog');
-  fireEvent.click(within(confirmDialog).getByRole('button', { name: '取消' }));
-
-  await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
-  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+  const row = screen.getByText(gameTitle).closest('tr');
+  expect(row).not.toBeNull();
+  const gameCell = within(row as HTMLElement).getAllByRole('cell')[0];
+  // 主展示是游戏名 + 打码作者名；gameId 只留在悬浮标题里。
+  expect(gameCell?.textContent).toContain('136****8867');
+  expect(gameCell?.textContent).not.toContain('game_1');
+  expect(screen.getByTitle('user-9f1').textContent).toBe('user-9f1');
+  expect(gameCell?.querySelector('[title="game_1"]')).not.toBeNull();
+});
+
+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(gameTitle);
+
+  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');
+  fireEvent.click(screen.getByRole('button', { name: '通过' }));
+  await waitFor(() =>
+    expect(reviewAdminGameDistributionVersion).toHaveBeenCalledWith(
+      'admin-token',
+      'version-1',
+      expect.any(String),
+      expect.objectContaining({
+        decision: 'approve',
+        expectedPublicationRevision: 7,
+      }),
+    ),
+  );
 });
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
index 5325772f8..f63a9c79e 100644
--- a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
@@ -1,3 +1,5 @@
+import './adminGameDistributionReview.css';
+
 import {
   AdminActionRow,
   AdminAlert,
@@ -6,19 +8,26 @@ import {
   AdminPage,
   AdminPageHeading,
   formatAdminDateTime,
+  GameDetailDisplay,
   Modal,
   TextField,
 } from '@genarrative/shared/components';
 import { RefreshCcw } from 'lucide-react';
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 import {
+  createAdminGameDistributionPreviewSession,
+  getAdminAssetReadUrl,
+  getAdminGameDistributionVersion,
+  listAdminGameDistributionGames,
   listAdminGameDistributionReviews,
   reviewAdminGameDistributionVersion,
-  suspendAdminGameDistributionGame,
 } from '../api/adminApiClient';
-import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
-import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
+import type {
+  AdminGameDistributionGameDetail,
+  AdminGameDistributionReviewEntry,
+  AdminGameDistributionVersionDetailResponse,
+} from '../api/adminApiTypes';
 import { handlePageError } from './pageUtils';
 
 interface AdminGameDistributionReviewPageProps {
@@ -27,10 +36,71 @@ interface AdminGameDistributionReviewPageProps {
 }
 
 interface ReviewReasonPrompt {
-  decision: 'reject' | 'suspend';
   entry: AdminGameDistributionReviewEntry;
 }
 
+/** 待审列表要展示的游戏名与作者：由既有后台作品列表接口按 gameId 反查得到。 */
+interface ReviewGameMeta {
+  title: string;
+  authorName: string;
+  authorId: string;
+}
+
+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`;
@@ -41,14 +111,6 @@ function formatBytes(value: number) {
   return `${value} B`;
 }
 
-function createSuspendIdempotencyKey(gameId: string) {
-  const random =
-    typeof crypto !== 'undefined' && 'randomUUID' in crypto
-      ? crypto.randomUUID()
-      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  return `game-suspend-${gameId}-${random}`.slice(0, 128);
-}
-
 function createReviewIdempotencyKey(versionId: string) {
   const random =
     typeof crypto !== 'undefined' && 'randomUUID' in crypto
@@ -73,8 +135,66 @@ export function AdminGameDistributionReviewPage({
   );
   const [reasonDraft, setReasonDraft] = useState('');
   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 [gameMetaByGameId, setGameMetaByGameId] = useState<
+    Record<string, ReviewGameMeta>
+  >({});
+  // 同一 gameId 的标题/作者在会话内不变，缓存避免每次刷新重复反查。
+  const gameMetaCacheRef = useRef<Record<string, ReviewGameMeta>>({});
+
+  /**
+   * 待审列表只回版本字段（无游戏名/作者），这里用既有后台作品列表接口按 gameId 反查，
+   * 逐游戏一次请求并去重；单个游戏取不到只回落显示 gameId，不阻断审核列表。
+   */
+  const resolveGameMeta = useCallback(
+    async (gameIds: string[]) => {
+      const resolved = await Promise.all(
+        gameIds.map(async (gameId) => {
+          const cached = gameMetaCacheRef.current[gameId];
+          if (cached) {
+            return [gameId, cached] as const;
+          }
+          try {
+            const response = await listAdminGameDistributionGames(token, {
+              limit: 5,
+              keyword: gameId,
+            });
+            const matched = response.games.find(
+              (game) => game.gameId === gameId,
+            );
+            if (!matched) return null;
+            const meta: ReviewGameMeta = {
+              title: matched.title?.trim() || matched.gameId,
+              authorName: matched.author?.name?.trim() || '',
+              authorId: matched.author?.id?.trim() || '',
+            };
+            gameMetaCacheRef.current[gameId] = meta;
+            return [gameId, meta] as const;
+          } catch {
+            return null;
+          }
+        }),
+      );
+      const merged = Object.fromEntries(
+        resolved.filter(
+          (item): item is readonly [string, ReviewGameMeta] => item !== null,
+        ),
+      );
+      if (Object.keys(merged).length > 0) {
+        setGameMetaByGameId((current) => ({ ...current, ...merged }));
+      }
+    },
+    [token],
+  );
 
   const loadReviews = useCallback(async () => {
     setIsLoading(true);
@@ -82,17 +202,92 @@ export function AdminGameDistributionReviewPage({
     try {
       const response = await listAdminGameDistributionReviews(token);
       setEntries(response.entries);
+      await resolveGameMeta([
+        ...new Set(response.entries.map((entry) => entry.gameId)),
+      ]);
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
       setIsLoading(false);
     }
-  }, [token, onUnauthorized]);
+  }, [token, onUnauthorized, resolveGameMeta]);
 
   useEffect(() => {
     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',
@@ -136,48 +331,13 @@ export function AdminGameDistributionReviewPage({
   }
 
   /**
-   * 管理员安全下架：先二次确认，再带当前公开修订号调用后端；并发审核导致修订号变化时
-   * 由服务端返回冲突，前端只提示刷新，不静默重试。
+   * 待审版本行内只做版本级动作（详情 / 通过 / 拒绝）。管理员「安全下架」是游戏级
+   * 动作（强制下线线上版本），入口在后台「游戏管理」页，不在审核新版本的语境里。
    */
-  async function suspendGame(
-    entry: AdminGameDistributionReviewEntry,
-    reason: string,
-  ) {
-    const trimmedReason = reason.trim();
-    const confirmed = await writeConfirm.confirmWrite({
-      action: '安全下架游戏',
-      target: `${entry.gameId}（版本 v${entry.versionNumber}）`,
-    });
-    if (!confirmed) return;
-    setBusyGameId(entry.gameId);
-    setErrorMessage('');
-    setStatusMessage('');
-    try {
-      await suspendAdminGameDistributionGame(
-        token,
-        entry.gameId,
-        createSuspendIdempotencyKey(entry.gameId),
-        {
-          expectedPublicationRevision: entry.publicationRevision,
-          ...(trimmedReason ? { reason: trimmedReason } : {}),
-        },
-      );
-      setStatusMessage(`游戏 ${entry.gameId} 已安全下架，发行入口已关闭`);
-      await loadReviews();
-    } catch (error) {
-      handlePageError(error, onUnauthorized, setErrorMessage);
-    } finally {
-      setBusyGameId('');
-    }
-  }
-
-  function openReasonPrompt(
-    entry: AdminGameDistributionReviewEntry,
-    decision: ReviewReasonPrompt['decision'],
-  ) {
+  function openReasonPrompt(entry: AdminGameDistributionReviewEntry) {
     setReasonDraft('');
     setReasonError('');
-    setReasonPrompt({ decision, entry });
+    setReasonPrompt({ entry });
   }
 
   function closeReasonPrompt() {
@@ -190,18 +350,50 @@ export function AdminGameDistributionReviewPage({
     if (!reasonPrompt) return;
 
     const reason = reasonDraft.trim();
-    if (reasonPrompt.decision === 'reject' && !reason) {
+    if (!reason) {
       setReasonError('拒绝审核必须填写理由');
       return;
     }
 
-    const { decision, entry } = reasonPrompt;
+    const { entry } = reasonPrompt;
     closeReasonPrompt();
-    if (decision === 'reject') {
-      void submitReview(entry, 'reject', reason);
-      return;
-    }
-    void suspendGame(entry, reason);
+    void submitReview(entry, 'reject', 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={() => {
+          const expectedEntry = detail
+            ? {
+                ...selectedEntry,
+                publicationRevision: detail.game.publicationRevision,
+              }
+            : selectedEntry;
+          closeDetails();
+          openReasonPrompt(expectedEntry);
+        }}
+        onApprove={() => {
+          const expectedEntry = detail
+            ? {
+                ...selectedEntry,
+                publicationRevision: detail.game.publicationRevision,
+              }
+            : selectedEntry;
+          closeDetails();
+          void submitReview(expectedEntry, 'approve');
+        }}
+      />
+    );
   }
 
   return (
@@ -240,6 +432,7 @@ export function AdminGameDistributionReviewPage({
         extra={<span className="admin-muted-text">共 {entries.length} 条</span>}
         rows={entries}
         size="wide"
+        tableClassName="admin-game-review-table"
         columns={[
           { key: 'gameId', label: '游戏' },
           { key: 'versionNumber', label: '版本' },
@@ -249,10 +442,32 @@ export function AdminGameDistributionReviewPage({
         ]}
         renderRow={(entry) => {
           const busy = busyVersionId === entry.versionId;
+          const gameMeta = gameMetaByGameId[entry.gameId];
           return (
             <tr key={entry.versionId}>
               <td>
-                <code>{entry.gameId}</code>
+                {/* gameId 不再作为主展示，只留在悬浮标题里做兜底标识。 */}
+                <div className="admin-game-review-game" title={entry.gameId}>
+                  <span className="admin-table-cell-ellipsis">
+                    {gameMeta?.title ?? entry.gameId}
+                  </span>
+                  <small className="admin-game-review-game-author admin-muted-text">
+                    <span
+                      className="admin-game-review-game-author-name"
+                      title={gameMeta?.authorName || undefined}
+                    >
+                      {gameMeta?.authorName || '—'}
+                    </span>
+                    {gameMeta?.authorId ? (
+                      <span
+                        className="admin-game-review-game-author-id"
+                        title={gameMeta.authorId}
+                      >
+                        {gameMeta.authorId}
+                      </span>
+                    ) : null}
+                  </small>
+                </div>
               </td>
               <td>
                 v{entry.versionNumber}
@@ -268,8 +483,16 @@ export function AdminGameDistributionReviewPage({
                 </div>
               </td>
               <td>{formatAdminDateTime(entry.createdAt)}</td>
-              <td>
-                <AdminActionRow>
+              <td className="admin-game-review-cell--actions">
+                <AdminActionRow className="admin-review-actions">
+                  <AdminButton
+                    variant="secondary"
+                    type="button"
+                    disabled={busy}
+                    onClick={() => void openDetails(entry)}
+                  >
+                    详情
+                  </AdminButton>
                   <AdminButton
                     variant="primary"
                     type="button"
@@ -282,18 +505,10 @@ export function AdminGameDistributionReviewPage({
                     variant="ghost"
                     type="button"
                     disabled={busy}
-                    onClick={() => openReasonPrompt(entry, 'reject')}
+                    onClick={() => openReasonPrompt(entry)}
                   >
                     拒绝
                   </AdminButton>
-                  <AdminButton
-                    variant="danger"
-                    type="button"
-                    disabled={busy || busyGameId === entry.gameId}
-                    onClick={() => openReasonPrompt(entry, 'suspend')}
-                  >
-                    {busyGameId === entry.gameId ? '正在下架…' : '安全下架'}
-                  </AdminButton>
                 </AdminActionRow>
               </td>
             </tr>
@@ -303,7 +518,7 @@ export function AdminGameDistributionReviewPage({
       {reasonPrompt ? (
         <Modal
           open
-          title={reasonPrompt.decision === 'reject' ? '拒绝审核' : '安全下架'}
+          title="拒绝审核"
           description={`${reasonPrompt.entry.gameId} · 版本 v${reasonPrompt.entry.versionNumber}`}
           closeLabel="关闭理由输入"
           onClose={closeReasonPrompt}
@@ -311,7 +526,7 @@ export function AdminGameDistributionReviewPage({
           className="genarrative-ui"
           footer={
             <div
-              className="admin-confirm-actions"
+              className="admin-confirm-actions admin-review-actions"
               style={{
                 width: '100%',
               }}
@@ -325,12 +540,10 @@ export function AdminGameDistributionReviewPage({
               </AdminButton>
               <AdminButton
                 type="button"
-                variant={
-                  reasonPrompt.decision === 'reject' ? 'ghost' : 'danger'
-                }
+                variant="ghost"
                 onClick={confirmReasonPrompt}
               >
-                {reasonPrompt.decision === 'reject' ? '确认拒绝' : '继续下架'}
+                确认拒绝
               </AdminButton>
             </div>
           }
@@ -338,7 +551,7 @@ export function AdminGameDistributionReviewPage({
           <TextField
             autoFocus
             multiline
-            label={reasonPrompt.decision === 'reject' ? '拒绝理由' : '下架原因'}
+            label="拒绝理由"
             value={reasonDraft}
             error={reasonError}
             rows={4}
@@ -349,7 +562,136 @@ export function AdminGameDistributionReviewPage({
           />
         </Modal>
       ) : null}
-      {writeConfirm.confirmDialog}
+    </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/pages/AdminGameManagementPage.test.tsx b/apps/admin-web/src/pages/AdminGameManagementPage.test.tsx
index a105c679a..41a1e64a2 100644
--- a/apps/admin-web/src/pages/AdminGameManagementPage.test.tsx
+++ b/apps/admin-web/src/pages/AdminGameManagementPage.test.tsx
@@ -68,6 +68,7 @@ const publishedGame: AdminGameDistributionGameEntry = {
   publicationRevision: 4,
   createdAt: '2026-09-18T08:00:00Z',
   updatedAt: '2026-09-20T10:00:00Z',
+  deletedAt: null,
   versions: [version],
 };
 
@@ -86,6 +87,26 @@ const suspendedGame: AdminGameDistributionGameEntry = {
   publicationRevision: 7,
   createdAt: '2026-09-19T08:00:00Z',
   updatedAt: '2026-09-21T08:00:00Z',
+  deletedAt: null,
+  versions: [],
+};
+
+const deletedGame: AdminGameDistributionGameEntry = {
+  gameId: 'game_3',
+  title: '已删除作品',
+  author: {
+    id: 'user_3',
+    name: '作者丙',
+    avatarUrl: null,
+  },
+  status: 'deleted',
+  versionCount: 1,
+  playCount: 3,
+  activeVersionId: null,
+  publicationRevision: 2,
+  createdAt: '2026-09-17T08:00:00Z',
+  updatedAt: '2026-09-22T08:00:00Z',
+  deletedAt: '2026-09-22T08:00:00Z',
   versions: [],
 };
 
@@ -197,20 +218,62 @@ test('恢复按钮只在下架态出现，成功后携带幂等键并刷新列
   expect(await screen.findByText('游戏《下架游戏》已恢复')).toBeTruthy();
 });
 
-test('下架需要原因和二次确认，提交原因与当前公开修订号', async () => {
+test('下架原因在独立面板内填写：空原因不提交并给出提示', async () => {
   render(
     <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
   );
 
   await screen.findByText('测试游戏');
-  fireEvent.change(screen.getByLabelText('下架原因'), {
-    target: { value: '违规内容' },
-  });
+  // 操作列不再内嵌输入框，点按钮才打开面板。
+  expect(screen.queryByLabelText('下架原因')).toBeNull();
   fireEvent.click(screen.getByRole('button', { name: '下架' }));
 
+  const dialog = await screen.findByRole('dialog', { name: '下架游戏' });
+  const reasonInput = within(dialog).getByLabelText('下架原因');
+  expect((reasonInput as HTMLTextAreaElement).value).toBe('');
+
+  fireEvent.click(within(dialog).getByRole('button', { name: '确认下架' }));
+
+  expect(await within(dialog).findByText('请填写下架原因')).toBeTruthy();
+  expect(reasonInput.getAttribute('aria-invalid')).toBe('true');
   expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
-  await screen.findByRole('dialog');
-  fireEvent.click(screen.getByRole('button', { name: '确认' }));
+  expect(screen.queryByRole('dialog', { name: '确认操作' })).toBeNull();
+});
+
+test('下架面板取消不触发请求', async () => {
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  fireEvent.click(screen.getByRole('button', { name: '下架' }));
+  const dialog = await screen.findByRole('dialog', { name: '下架游戏' });
+  fireEvent.change(within(dialog).getByLabelText('下架原因'), {
+    target: { value: '违规内容' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '取消' }));
+
+  await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+});
+
+test('下架面板确认后仍需二次确认，提交原因与当前公开修订号', async () => {
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  fireEvent.click(screen.getByRole('button', { name: '下架' }));
+  const dialog = await screen.findByRole('dialog', { name: '下架游戏' });
+  fireEvent.change(within(dialog).getByLabelText('下架原因'), {
+    target: { value: '违规内容' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '确认下架' }));
+
+  // 面板确认只进入原有的写入二次确认，此时还不能发请求。
+  const confirmDialog = await screen.findByRole('dialog', { name: '确认操作' });
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+  fireEvent.click(within(confirmDialog).getByRole('button', { name: '确认' }));
 
   await waitFor(() =>
     expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
@@ -277,3 +340,92 @@ test('401 交给 onUnauthorized 处理', async () => {
   );
   expect(screen.queryByRole('alert')).toBeNull();
 });
+
+test('筛选条件按服务端口径透传，重置回到无条件第一页', async () => {
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  fireEvent.change(screen.getByPlaceholderText('标题、gameId 或作者 ID'), {
+    target: { value: '  拼图 ' },
+  });
+  fireEvent.change(screen.getByPlaceholderText('作者 user ID'), {
+    target: { value: 'user_9' },
+  });
+  fireEvent.change(screen.getByRole('combobox', { name: '状态' }), {
+    target: { value: 'suspended' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '查询' }));
+
+  await waitFor(() =>
+    expect(listAdminGameDistributionGames).toHaveBeenCalledTimes(2),
+  );
+  const [, applied] = vi.mocked(listAdminGameDistributionGames).mock.calls[1]!;
+  expect(applied).toEqual({
+    limit: 50,
+    cursor: null,
+    keyword: '拼图',
+    owner: 'user_9',
+    status: 'suspended',
+  });
+
+  fireEvent.click(screen.getByRole('button', { name: '重置' }));
+  await waitFor(() =>
+    expect(listAdminGameDistributionGames).toHaveBeenCalledTimes(3),
+  );
+  const [, reset] = vi.mocked(listAdminGameDistributionGames).mock.calls[2]!;
+  expect(reset).toEqual({
+    limit: 50,
+    cursor: null,
+    keyword: '',
+    owner: '',
+    status: '',
+  });
+  expect(
+    (screen.getByPlaceholderText('标题、gameId 或作者 ID') as HTMLInputElement)
+      .value,
+  ).toBe('');
+});
+
+test('游标分页把上一页返回的 nextCursor 传给下一页', async () => {
+  vi.mocked(listAdminGameDistributionGames)
+    .mockResolvedValueOnce({ games: [publishedGame], nextCursor: 'cursor-1' })
+    .mockResolvedValueOnce({ games: [suspendedGame], nextCursor: null });
+
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  const nextButton = screen.getByRole('button', { name: '下一页' });
+  expect((nextButton as HTMLButtonElement).disabled).toBe(false);
+  fireEvent.click(nextButton);
+
+  await screen.findByText('下架游戏');
+  expect(screen.queryByText('测试游戏')).toBeNull();
+  const [, secondPage] = vi.mocked(listAdminGameDistributionGames).mock
+    .calls[1]!;
+  expect(secondPage?.cursor).toBe('cursor-1');
+  expect(
+    (screen.getByRole('button', { name: '下一页' }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+});
+
+test('已删除作品显示删除时间且不再提供下架与恢复', async () => {
+  vi.mocked(listAdminGameDistributionGames).mockResolvedValue({
+    games: [deletedGame],
+  });
+
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  const row = (await screen.findByText('已删除作品')).closest('tr')!;
+  expect(within(row).getByText('已删除')).toBeTruthy();
+  expect(within(row).getByText(/删除于/)).toBeTruthy();
+  expect(within(row).queryByRole('button', { name: '下架' })).toBeNull();
+  expect(within(row).queryByRole('button', { name: '恢复' })).toBeNull();
+  expect(within(row).getByRole('button', { name: '版本历史' })).toBeTruthy();
+});
diff --git a/apps/admin-web/src/pages/AdminGameManagementPage.tsx b/apps/admin-web/src/pages/AdminGameManagementPage.tsx
index 75a8f8a29..745a96b49 100644
--- a/apps/admin-web/src/pages/AdminGameManagementPage.tsx
+++ b/apps/admin-web/src/pages/AdminGameManagementPage.tsx
@@ -4,15 +4,16 @@ import {
   AdminAlert,
   AdminButton,
   AdminDialog,
-  AdminFieldGroup,
+  AdminField,
   AdminListPanel,
   AdminPage,
   AdminPageHeading,
+  AdminPagination,
   AdminStatusPill,
   formatAdminDateTime,
 } from '@genarrative/shared/components';
-import { RefreshCcw } from 'lucide-react';
-import { useCallback, useEffect, useState } from 'react';
+import { RefreshCcw, Search, X } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 import {
   listAdminGameDistributionGames,
@@ -21,6 +22,7 @@ import {
 } from '../api/adminApiClient';
 import type {
   AdminGameDistributionGameEntry,
+  AdminGameDistributionGameStatus,
   AdminGameDistributionGameVersionEntry,
 } from '../api/adminApiTypes';
 import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
@@ -39,8 +41,35 @@ const GAME_STATUS_META: Record<
   published: { label: '已公开', tone: 'ok' },
   suspended: { label: '已下架', tone: 'error' },
   unpublished: { label: '未公开', tone: 'pending' },
+  // 作者软删除：保留在后台可见（默认视图之外），但不再公开可玩。
+  deleted: { label: '已删除', tone: 'error' },
 };
 
+const STATUS_FILTER_OPTIONS: {
+  value: AdminGameDistributionGameStatus | '';
+  label: string;
+}[] = [
+  { value: '', label: '全部状态' },
+  { value: 'published', label: '已公开' },
+  { value: 'unpublished', label: '未公开' },
+  { value: 'suspended', label: '已下架' },
+  { value: 'deleted', label: '已删除' },
+];
+
+const DEFAULT_PAGE_SIZE = 50;
+const PAGE_SIZE_OPTIONS = [20, 50, 100];
+
+/** 下架原因必填；面板校验与提交前兜底共用同一句提示。 */
+const SUSPEND_REASON_REQUIRED_MESSAGE = '请填写下架原因';
+
+interface GameFilters {
+  keyword: string;
+  owner: string;
+  status: AdminGameDistributionGameStatus | '';
+}
+
+const EMPTY_FILTERS: GameFilters = { keyword: '', owner: '', status: '' };
+
 function gameStatusMeta(status: string) {
   return (
     GAME_STATUS_META[status] ?? {
@@ -91,40 +120,161 @@ export function AdminGameManagementPage({
   onUnauthorized,
 }: AdminGameManagementPageProps) {
   const [games, setGames] = useState<AdminGameDistributionGameEntry[]>([]);
+  const [nextCursor, setNextCursor] = useState<string | null>(null);
+  const [pageIndex, setPageIndex] = useState(1);
+  const [pageSize, setPageSize] = useState(DEFAULT_PAGE_SIZE);
+  const [draftFilters, setDraftFilters] = useState<GameFilters>(EMPTY_FILTERS);
+  const [filters, setFilters] = useState<GameFilters>(EMPTY_FILTERS);
   const [isLoading, setIsLoading] = useState(false);
+  const [hasLoaded, setHasLoaded] = useState(false);
   const [busyGameId, setBusyGameId] = useState('');
   const [errorMessage, setErrorMessage] = useState('');
   const [statusMessage, setStatusMessage] = useState('');
-  const [suspendReasonByGame, setSuspendReasonByGame] = useState<
-    Record<string, string>
-  >({});
+  // 下架原因在下架面板内填写；面板打开状态、草稿与校验错误都由页面持有。
+  const [suspendTarget, setSuspendTarget] =
+    useState<AdminGameDistributionGameEntry | null>(null);
+  const [suspendReasonDraft, setSuspendReasonDraft] = useState('');
+  const [suspendReasonError, setSuspendReasonError] = useState('');
   const [versionGame, setVersionGame] =
     useState<AdminGameDistributionGameEntry | null>(null);
   const writeConfirm = useAdminWriteConfirm();
+  const listController = useRef<AbortController | null>(null);
+  // 远端按游标分页且不给总数：第 N 页的起始游标只能由前 N-1 页依次返回，
+  // 因此按页记录已取得的游标，翻页只在这些游标之间移动。
+  const pageCursors = useRef<(string | null)[]>([null]);
 
-  const loadGames = useCallback(async () => {
-    setIsLoading(true);
-    setErrorMessage('');
-    try {
-      const response = await listAdminGameDistributionGames(token, {
-        limit: 50,
-      });
-      setGames(response.games);
-    } catch (error) {
-      handlePageError(error, onUnauthorized, setErrorMessage);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [token, onUnauthorized]);
+  const loadGames = useCallback(
+    async (cursor: string | null, page: number) => {
+      listController.current?.abort();
+      const controller = new AbortController();
+      listController.current = controller;
+      setIsLoading(true);
+      setErrorMessage('');
+      try {
+        const response = await listAdminGameDistributionGames(
+          token,
+          {
+            limit: pageSize,
+            cursor,
+            keyword: filters.keyword,
+            owner: filters.owner,
+            status: filters.status,
+          },
+          controller.signal,
+        );
+        if (controller.signal.aborted) return;
+        setGames(response.games);
+        setNextCursor(response.nextCursor ?? null);
+        setPageIndex(page);
+        setHasLoaded(true);
+      } catch (error: unknown) {
+        // 翻页或刷新失败时保留当前页，不把已看到的列表换成空表。
+        if (!controller.signal.aborted)
+          handlePageError(error, onUnauthorized, setErrorMessage);
+      } finally {
+        if (listController.current === controller) {
+          listController.current = null;
+          setIsLoading(false);
+        }
+      }
+    },
+    [
+      token,
+      onUnauthorized,
+      pageSize,
+      filters.keyword,
+      filters.owner,
+      filters.status,
+    ],
+  );
 
+  // 条件或每页条数变化时回到第一页；这里是唯一的"重置游标"入口。
   useEffect(() => {
-    void loadGames();
+    pageCursors.current = [null];
+    setPageIndex(1);
+    void loadGames(null, 1);
   }, [loadGames]);
 
-  async function suspendGame(entry: AdminGameDistributionGameEntry) {
-    const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
+  useEffect(
+    () => () => {
+      listController.current?.abort();
+    },
+    [],
+  );
+
+  function applyFilters() {
+    setFilters({
+      keyword: draftFilters.keyword.trim(),
+      owner: draftFilters.owner.trim(),
+      status: draftFilters.status,
+    });
+  }
+
+  function resetFilters() {
+    setDraftFilters(EMPTY_FILTERS);
+    setFilters(EMPTY_FILTERS);
+  }
+
+  function refreshCurrentPage() {
+    void loadGames(pageCursors.current[pageIndex - 1] ?? null, pageIndex);
+  }
+
+  function goToNextPage() {
+    if (!nextCursor) return;
+    const nextPage = pageIndex + 1;
+    pageCursors.current[nextPage - 1] = nextCursor;
+    void loadGames(nextCursor, nextPage);
+  }
+
+  function goToPreviousPage() {
+    if (pageIndex <= 1) return;
+    const previousPage = pageIndex - 1;
+    void loadGames(pageCursors.current[previousPage - 1] ?? null, previousPage);
+  }
+
+  function changePageSize(size: number) {
+    pageCursors.current = [null];
+    setPageSize(size);
+  }
+
+  const filtersActive = Boolean(
+    filters.keyword || filters.owner || filters.status,
+  );
+
+  function openSuspendPrompt(entry: AdminGameDistributionGameEntry) {
+    setSuspendReasonDraft('');
+    setSuspendReasonError('');
+    setSuspendTarget(entry);
+  }
+
+  function closeSuspendPrompt() {
+    setSuspendTarget(null);
+    setSuspendReasonDraft('');
+    setSuspendReasonError('');
+  }
+
+  /** 面板确认：先做必填校验，再走原有的二次确认与下架请求。 */
+  function confirmSuspendPrompt() {
+    if (!suspendTarget) return;
+
+    const reason = suspendReasonDraft.trim();
     if (!reason) {
-      setErrorMessage('下架原因不能为空');
+      setSuspendReasonError(SUSPEND_REASON_REQUIRED_MESSAGE);
+      return;
+    }
+
+    const entry = suspendTarget;
+    closeSuspendPrompt();
+    void suspendGame(entry, reason);
+  }
+
+  async function suspendGame(
+    entry: AdminGameDistributionGameEntry,
+    reason: string,
+  ) {
+    const trimmedReason = reason.trim();
+    if (!trimmedReason) {
+      setErrorMessage(SUSPEND_REASON_REQUIRED_MESSAGE);
       setStatusMessage('');
       return;
     }
@@ -145,15 +295,11 @@ export function AdminGameManagementPage({
         createGameActionIdempotencyKey('suspend', entry.gameId),
         {
           expectedPublicationRevision: entry.publicationRevision,
-          reason,
+          reason: trimmedReason,
         },
       );
       setStatusMessage(`游戏《${entry.title || entry.gameId}》已下架`);
-      setSuspendReasonByGame((current) => ({
-        ...current,
-        [entry.gameId]: '',
-      }));
-      await loadGames();
+      refreshCurrentPage();
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
@@ -179,7 +325,7 @@ export function AdminGameManagementPage({
         { expectedPublicationRevision: entry.publicationRevision },
       );
       setStatusMessage(`游戏《${entry.title || entry.gameId}》已恢复`);
-      await loadGames();
+      refreshCurrentPage();
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
@@ -195,7 +341,7 @@ export function AdminGameManagementPage({
           <AdminButton
             variant="secondary"
             type="button"
-            onClick={() => void loadGames()}
+            onClick={refreshCurrentPage}
             disabled={isLoading}
           >
             <RefreshCcw aria-hidden="true" />
@@ -213,16 +359,96 @@ export function AdminGameManagementPage({
         <AdminAlert tone="success">{statusMessage}</AdminAlert>
       ) : null}
 
+      <form
+        className="admin-stack"
+        onSubmit={(event) => {
+          event.preventDefault();
+          applyFilters();
+        }}
+      >
+        <AdminActionRow>
+          <AdminField label="关键词" compact>
+            <input
+              aria-label="关键词"
+              placeholder="标题、gameId 或作者 ID"
+              value={draftFilters.keyword}
+              onChange={(event) =>
+                setDraftFilters((current) => ({
+                  ...current,
+                  keyword: event.target.value,
+                }))
+              }
+              disabled={isLoading}
+            />
+          </AdminField>
+          <AdminField label="作者" compact>
+            <input
+              aria-label="作者"
+              placeholder="作者 user ID"
+              value={draftFilters.owner}
+              onChange={(event) =>
+                setDraftFilters((current) => ({
+                  ...current,
+                  owner: event.target.value,
+                }))
+              }
+              disabled={isLoading}
+            />
+          </AdminField>
+          <AdminField label="状态" compact>
+            <select
+              aria-label="状态"
+              value={draftFilters.status}
+              onChange={(event) =>
+                setDraftFilters((current) => ({
+                  ...current,
+                  status: event.target.value as
+                    | AdminGameDistributionGameStatus
+                    | '',
+                }))
+              }
+              disabled={isLoading}
+            >
+              {STATUS_FILTER_OPTIONS.map((option) => (
+                <option key={option.value || 'all'} value={option.value}>
+                  {option.label}
+                </option>
+              ))}
+            </select>
+          </AdminField>
+          <AdminButton variant="primary" type="submit" disabled={isLoading}>
+            <Search aria-hidden="true" />
+            查询
+          </AdminButton>
+          <AdminButton
+            variant="secondary"
+            type="button"
+            onClick={resetFilters}
+            disabled={isLoading && !filtersActive}
+          >
+            <X aria-hidden="true" />
+            重置
+          </AdminButton>
+        </AdminActionRow>
+      </form>
+
       <AdminListPanel
+        ariaLabel="游戏列表"
         busy={isLoading}
         busyText="正在加载游戏列表…"
         busyVariant="line"
-        emptyText="暂无游戏。"
+        emptyText={filtersActive ? '没有匹配的作品。' : '暂无游戏。'}
         emptyVariant="text"
+        showEmpty={hasLoaded && games.length === 0 && !errorMessage}
         title="游戏列表"
-        extra={<span className="admin-muted-text">共 {games.length} 条</span>}
+        extra={
+          <span className="admin-muted-text">
+            第 {pageIndex} 页{games.length ? `，本页 ${games.length} 条` : ''}
+          </span>
+        }
         rows={games}
         size="wide"
+        tableClassName="admin-game-management-table"
         columns={[
           { key: 'title', label: '标题' },
           { key: 'author', label: '作者' },
@@ -232,8 +458,31 @@ export function AdminGameManagementPage({
           { key: 'playCount', label: '游玩数' },
           { key: 'actions', label: '操作' },
         ]}
+        pagination={
+          hasLoaded ? (
+            <AdminPagination
+              ariaLabel="游戏列表分页"
+              info={
+                <>
+                  第 {pageIndex} 页
+                  {games.length ? `，本页 ${games.length} 条` : ''}
+                </>
+              }
+              pageSize={{
+                value: pageSize,
+                options: PAGE_SIZE_OPTIONS,
+                ariaLabel: '每页条数',
+                onChange: changePageSize,
+              }}
+              busy={isLoading}
+              previous={{ disabled: pageIndex <= 1, onClick: goToPreviousPage }}
+              next={{ disabled: !nextCursor, onClick: goToNextPage }}
+            />
+          ) : null
+        }
         renderRow={(entry) => {
           const status = gameStatusMeta(entry.status);
+          const isDeleted = entry.status === 'deleted';
           const isSuspended = entry.status === 'suspended';
           const busy = busyGameId === entry.gameId;
           return (
@@ -241,7 +490,7 @@ export function AdminGameManagementPage({
               <td>
                 <strong>{entry.title?.trim() || '—'}</strong>
               </td>
-              <td>
+              <td className="admin-game-author-cell">
                 <div
                   className="admin-database-user-cell"
                   style={{
@@ -266,52 +515,39 @@ export function AdminGameManagementPage({
                       authorInitial(entry)
                     )}
                   </div>
-                  <div>
-                    <span>{authorName(entry)}</span>
-                    <small>{entry.author?.id?.trim() || '—'}</small>
+                  <div className="admin-inline-identity">
+                    <div>
+                      <span>{authorName(entry)}</span>
+                      <small title={entry.author?.id?.trim() || undefined}>
+                        {entry.author?.id?.trim() || '—'}
+                      </small>
+                    </div>
                   </div>
                 </div>
               </td>
               <td>
-                <code>{entry.gameId}</code>
+                <code
+                  className="admin-table-cell-ellipsis"
+                  title={entry.gameId}
+                >
+                  {entry.gameId}
+                </code>
               </td>
               <td>
                 <AdminStatusPill tone={status.tone}>
                   {status.label}
                 </AdminStatusPill>
+                {entry.deletedAt ? (
+                  <small className="admin-muted-text">
+                    删除于 {formatOptionalTime(entry.deletedAt)}
+                  </small>
+                ) : null}
               </td>
               <td>{entry.versionCount}</td>
               <td>{entry.playCount}</td>
-              <td>
+              <td className="admin-game-actions-cell">
                 <AdminActionRow>
-                  {!isSuspended ? (
-                    <>
-                      <AdminFieldGroup
-                        label="下架原因"
-                        htmlFor={`game-suspend-reason-${entry.gameId}`}
-                      >
-                        <input
-                          id={`game-suspend-reason-${entry.gameId}`}
-                          value={suspendReasonByGame[entry.gameId] ?? ''}
-                          onChange={(event) =>
-                            setSuspendReasonByGame((current) => ({
-                              ...current,
-                              [entry.gameId]: event.target.value,
-                            }))
-                          }
-                          disabled={busy}
-                        />
-                      </AdminFieldGroup>
-                      <AdminButton
-                        variant="danger"
-                        type="button"
-                        disabled={busy}
-                        onClick={() => void suspendGame(entry)}
-                      >
-                        {busy ? '处理中…' : '下架'}
-                      </AdminButton>
-                    </>
-                  ) : (
+                  {isDeleted ? null : isSuspended ? (
                     <AdminButton
                       variant="primary"
                       type="button"
@@ -320,6 +556,15 @@ export function AdminGameManagementPage({
                     >
                       {busy ? '处理中…' : '恢复'}
                     </AdminButton>
+                  ) : (
+                    <AdminButton
+                      variant="danger"
+                      type="button"
+                      disabled={busy}
+                      onClick={() => openSuspendPrompt(entry)}
+                    >
+                      {busy ? '处理中…' : '下架'}
+                    </AdminButton>
                   )}
                   <AdminButton
                     variant="secondary"
@@ -347,6 +592,58 @@ export function AdminGameManagementPage({
         }}
       />
 
+      {suspendTarget ? (
+        <AdminDialog
+          as="form"
+          closeLabel="关闭下架面板"
+          description={
+            <>
+              {suspendTarget.title?.trim() || '—'}（{suspendTarget.gameId}）
+            </>
+          }
+          panelClassName="admin-confirm-panel"
+          title="下架游戏"
+          titleProps={{ id: 'admin-game-suspend-title' }}
+          onClose={closeSuspendPrompt}
+          onSubmit={(event) => {
+            event.preventDefault();
+            confirmSuspendPrompt();
+          }}
+        >
+          <AdminField label="下架原因（必填）">
+            <textarea
+              autoFocus
+              aria-label="下架原因"
+              aria-invalid={suspendReasonError ? true : undefined}
+              placeholder="填写下架原因，提交后记录在游戏状态变更里"
+              rows={3}
+              value={suspendReasonDraft}
+              onChange={(event) => {
+                setSuspendReasonDraft(event.target.value);
+                if (suspendReasonError) setSuspendReasonError('');
+              }}
+            />
+          </AdminField>
+          {suspendReasonError ? (
+            <AdminAlert role="alert" tone="warning">
+              {suspendReasonError}
+            </AdminAlert>
+          ) : null}
+          <div className="admin-confirm-actions">
+            <AdminButton
+              variant="secondary"
+              type="button"
+              onClick={closeSuspendPrompt}
+            >
+              取消
+            </AdminButton>
+            <AdminButton variant="danger" type="submit">
+              确认下架
+            </AdminButton>
+          </div>
+        </AdminDialog>
+      ) : null}
+
       {versionGame ? (
         <AdminDialog
           closeLabel="关闭版本历史"
diff --git a/apps/admin-web/src/pages/AdminGrayReleaseConfigPage.tsx b/apps/admin-web/src/pages/AdminGrayReleaseConfigPage.tsx
index 6fa1b786a..7b0b78ab3 100644
--- a/apps/admin-web/src/pages/AdminGrayReleaseConfigPage.tsx
+++ b/apps/admin-web/src/pages/AdminGrayReleaseConfigPage.tsx
@@ -64,7 +64,7 @@ const FIXED_GATE_TARGETS: GateTargetOption[] = [
     key: 'game-distribution:publish',
     label: '游戏发布',
     description:
-      '游戏发布入口灰度：未配置或关闭时对已登录作者默认开放，开启后只放行白名单 / 灰度命中',
+      '游戏发布入口灰度：未配置或关闭时不开放，启用后按白名单 / 用户标签 / 灰度比例放行',
   },
 ];
 
diff --git a/apps/admin-web/src/pages/adminGameDistributionReview.css b/apps/admin-web/src/pages/adminGameDistributionReview.css
new file mode 100644
index 000000000..2eed66619
--- /dev/null
+++ b/apps/admin-web/src/pages/adminGameDistributionReview.css
@@ -0,0 +1,106 @@
+/*
+ * 「游戏审核」待审版本表的页面专属样式。
+ *
+ * 目标：1280 / 1440 / 1920 三档视口下，「详情 / 通过 / 拒绝」三个版本级动作
+ * 都在面板可视带内、单行不换行，不依赖面板内横向滚动。
+ *
+ * 做法：只在本页表格上加自己的类，覆盖 `.admin-table-wide` 的 min-width 并固定列宽，
+ * 把动作列按内容取宽；gameId 最长（37 字符）用省略号截断并保留 title 作为完整值出口。
+ * 不改共享 `.admin-table-wide` 的全局语义，也不影响其它后台页面。
+ */
+
+/* `.admin-table-wide` 是共享类，用元素+类提升优先级覆盖它，只作用于本页表格。 */
+table.admin-game-review-table {
+  width: 100%;
+  min-width: 0;
+  table-layout: fixed;
+}
+
+table.admin-game-review-table th:nth-child(2),
+table.admin-game-review-table td:nth-child(2) {
+  /* `pending_review` 是最长状态值（约 120px + 单元格内边距），必须给足，否则会压到「发行包」列。 */
+  width: 148px;
+}
+
+table.admin-game-review-table th:nth-child(3),
+table.admin-game-review-table td:nth-child(3) {
+  width: 124px;
+}
+
+table.admin-game-review-table th:nth-child(4),
+table.admin-game-review-table td:nth-child(4) {
+  width: 172px;
+  white-space: nowrap;
+}
+
+table.admin-game-review-table th:nth-child(5),
+table.admin-game-review-table td:nth-child(5) {
+  width: 240px;
+}
+
+/* 固定列宽下，任何溢出都应该在本列内被裁掉，而不是压到相邻列上。 */
+table.admin-game-review-table td {
+  overflow: hidden;
+}
+
+table.admin-game-review-table td .admin-muted-text {
+  overflow-wrap: anywhere;
+}
+
+.admin-game-review-cell--actions {
+  white-space: nowrap;
+}
+
+.admin-game-review-cell--actions .admin-review-actions {
+  flex-wrap: nowrap;
+  justify-content: flex-end;
+}
+
+/* 游戏列：主行游戏名、副行作者（打码名 + user_id 截断，完整值放 title）。 */
+.admin-game-review-game {
+  display: grid;
+  min-width: 0;
+  gap: 2px;
+}
+
+.admin-game-review-game-author {
+  display: flex;
+  min-width: 0;
+  align-items: baseline;
+  gap: 6px;
+}
+
+.admin-game-review-game-author-name {
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.admin-game-review-game-author-id {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  opacity: 0.75;
+}
+
+/* 移动端/窄屏：动作列保持不换行，仍靠省略号吸收 gameId 的宽度。 */
+@media (max-width: 980px) {
+  table.admin-game-review-table {
+    table-layout: auto;
+  }
+
+  table.admin-game-review-table th:nth-child(2),
+  table.admin-game-review-table td:nth-child(2),
+  table.admin-game-review-table th:nth-child(3),
+  table.admin-game-review-table td:nth-child(3),
+  table.admin-game-review-table th:nth-child(4),
+  table.admin-game-review-table td:nth-child(4),
+  table.admin-game-review-table th:nth-child(5),
+  table.admin-game-review-table td:nth-child(5) {
+    width: auto;
+  }
+}
diff --git a/apps/admin-web/src/styles/admin.css b/apps/admin-web/src/styles/admin.css
index 1f8880d60..cca933070 100644
--- a/apps/admin-web/src/styles/admin.css
+++ b/apps/admin-web/src/styles/admin.css
@@ -3580,3 +3580,55 @@ 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;
+}
+
+/*
+ * 游戏管理列表（AdminGameManagementPage）专属排布，选择器全部框在本页表格内，
+ * 不影响其它后台页面：
+ * - 操作列按内容取宽且按钮组不换行，避免「查看评价」被挤到第二行；
+ * - 单元格垂直居中，行高不再随最长单元格跳动；
+ * - 标题列给最小宽度，避免被长 gameId 挤压成一行一个字。
+ * 这里用 `.admin-table.admin-game-management-table` 复合选择器：共享样式表在 dev 下
+ * 由组件模块后注入，单类选择器会被 `.admin-table th, .admin-table td` 反超。
+ */
+.admin-table.admin-game-management-table th,
+.admin-table.admin-game-management-table td {
+  vertical-align: middle;
+}
+
+.admin-game-management-table td:first-child {
+  min-width: 200px;
+}
+
+.admin-game-management-table th:last-child,
+.admin-game-management-table td.admin-game-actions-cell {
+  width: 1%;
+  white-space: nowrap;
+}
+
+.admin-game-actions-cell .admin-action-row {
+  flex-wrap: nowrap;
+  justify-content: flex-end;
+}
+
+.admin-game-author-cell {
+  min-width: 190px;
+}
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/package.json b/apps/ai-game-creator-shell/package.json
index 0d3ec33c6..54a85623d 100644
--- a/apps/ai-game-creator-shell/package.json
+++ b/apps/ai-game-creator-shell/package.json
@@ -16,7 +16,7 @@
     "bundled-resources:check": "node scripts/check-package-layout.mjs",
     "bundled-resources:sync": "node scripts/check-package-layout.mjs --write",
     "bundled-resources:prepare": "node scripts/prepare-bundled-resources.mjs",
-    "bundled-resources:test": "node --test scripts/prepare-bundled-resources.test.mjs",
+    "bundled-resources:test": "node --test --test-reporter=dot scripts/prepare-bundled-resources.test.mjs",
     "llm-status": "node scripts/run-cli-with-config.mjs --llm-status",
     "config": "node scripts/game-creator-config-wizard.mjs",
     "check:tests:types": "tsc -p tsconfig.tests.json --noEmit",
diff --git a/apps/ai-game-creator-shell/scripts/check-config.mjs b/apps/ai-game-creator-shell/scripts/check-config.mjs
index 5754f5098..27edb95c7 100644
--- a/apps/ai-game-creator-shell/scripts/check-config.mjs
+++ b/apps/ai-game-creator-shell/scripts/check-config.mjs
@@ -135,8 +135,8 @@ const allowedUncalledTauriCommands = [
   'generate_game_distribution_cover',
   'prepare_local_project_game_package',
   'read_game_cover_generation_price',
-  'read_game_publish_availability',
   '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/agent/direct_runtime/mod.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime/mod.rs
index 48fdc3b0b..909d9e2e3 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime/mod.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime/mod.rs
@@ -4179,10 +4179,18 @@ fn sync_direct_codex_project_file_projection_at(
         return Err("Codex 返回后没有可登记的游戏文件".to_string());
     }
     update_manifest_task_status_at(root, "code-prototype", GameCreationAppTaskStatus::Completed)?;
+    let mut version_registered = false;
     if outputs_changed || manifest_requires_sync {
         let _lock = acquire_project_write_lock_with_wait(root, "direct-codex.version")?;
         let version_revision = advance_agent_runtime_project_revision_locked(root)?;
-        append_agent_game_iteration_version_at(root, version_revision)?;
+        version_registered = append_agent_game_iteration_version_at(root, version_revision)?;
+    }
+    if version_registered {
+        // 新增的内部版本只落在清单里：这条写入不经过任何工具桥，也就没有任何事件。
+        // 必须显式宣告清单失效，否则渲染层的资源投影（「项目版本」卡、发布面板的版本标签）
+        // 在本回合结束后不会重读清单 —— 版本已经在盘上，用户却看不到新的版本卡。
+        // 与工具桥的素材写入同一口径（见 direct_tool_bridge.rs 的 asset-import）。
+        emit_game_creator_manifest_invalidated(root, "direct-codex.version");
     }
     Ok(())
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/commands/desktop.rs b/apps/ai-game-creator-shell/src-tauri/src/commands/desktop.rs
index 8b7da7ad0..ff2565b84 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/commands/desktop.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/commands/desktop.rs
@@ -1200,6 +1200,10 @@ pub(crate) async fn upload_local_project_game_package(
     }
     let emit_handle = app.clone();
     let progress_version_id = version_id.clone();
+    let progress_publish_id = idempotency_key.trim().to_string();
+    let verify_handle = app.clone();
+    let verify_version_id = version_id.clone();
+    let verify_publish_id = progress_publish_id.clone();
     crate::game_package_upload::upload_staged_game_package(
         &client,
         crate::game_package_upload::GamePackageUploadRequest {
@@ -1215,11 +1219,27 @@ pub(crate) async fn upload_local_project_game_package(
                 crate::game_package_upload::GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
                 crate::game_package_upload::progress_event_payload(
                     &progress_version_id,
+                    &progress_publish_id,
+                    "upload",
+                    "正在上传发行包…",
                     received_bytes,
                     total_bytes,
                 ),
             );
         },
+        move || {
+            let _ = verify_handle.emit(
+                crate::game_package_upload::GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
+                crate::game_package_upload::progress_event_payload(
+                    &verify_version_id,
+                    &verify_publish_id,
+                    "verify",
+                    "正在校验发行包…",
+                    0,
+                    0,
+                ),
+            );
+        },
     )
     .await
 }
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 8b5c3078d..1eec25092 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
@@ -607,10 +607,10 @@ pub(super) fn run() {
             login_client_with_password,
             login_client_with_phone_code,
             logout_client_session,
-            read_game_publish_availability,
             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 ca41e3fd8..b3ee96410 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
@@ -13,13 +13,20 @@ use crate::http_client::agc_main_site_client_builder;
 use crate::platform_session::{
     current_platform_session, validate_platform_session_identity, PlatformSessionSnapshot,
 };
+use base64::Engine;
+
 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;
@@ -34,8 +41,13 @@ const HTTP_TIMEOUT: Duration = Duration::from_secs(60);
 const COVER_QUEUE_POLL_INTERVAL: Duration = Duration::from_millis(1_600);
 const COVER_QUEUE_TIMEOUT: Duration = Duration::from_secs(20 * 60);
 const COVER_QUEUE_MAX_POLLS: usize = 800;
+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 {
@@ -46,6 +58,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)]
@@ -63,6 +140,8 @@ struct CoverGenerationPayload {
     #[serde(default)]
     image_src: Option<String>,
     #[serde(default)]
+    object_key: Option<String>,
+    #[serde(default)]
     asset_object_id: Option<String>,
     #[serde(default)]
     asset: Option<CoverAssetPayload>,
@@ -117,6 +196,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)]
@@ -214,6 +342,27 @@ fn map_http_error(status: StatusCode, body: &str, fallback: &str) -> String {
             server_error_detail(code, message, || "当前账号无权执行此操作".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 = server_error_detail(code, message, || format!("HTTP {}", status.as_u16()));
     format!("{fallback}：{detail}")
 }
@@ -273,6 +422,514 @@ 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,
+    }
+}
+
+/// 回写发布绑定；本地遗留的 `projectVersion` 一并清空。
+///
+/// 绑定本身已按当前会话（账号 + origin）与 gameId 隔离。项目版本标签不再从绑定推导（它由
+/// AGC 工程内部版本 `versions[]` 派生、只读），所以这里只落绑定，并把存量清单里可能残留的
+/// 遗留标签置空——`skip_serializing_if` 会让该键随下一次落盘消失。
+fn write_publication_binding(
+    root: &Path,
+    binding: GameCreationAppPublicationBinding,
+) -> Result<(), String> {
+    crate::project::mutate_manifest_at(root, |manifest| {
+        manifest.project_version = None;
+        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
@@ -287,6 +944,48 @@ fn read_cover_asset_id(payload: &CoverGenerationPayload) -> Option<String> {
         .filter(|value| !value.is_empty())
 }
 
+fn cover_preview_data_url(media_type: &str, bytes: &[u8]) -> Result<String, String> {
+    let media_type = media_type
+        .split(';')
+        .next()
+        .unwrap_or(media_type)
+        .trim()
+        .to_ascii_lowercase();
+    if !media_type.starts_with("image/") {
+        return Err("游戏封面预览不是受支持的图片类型".to_string());
+    }
+    if bytes.is_empty() || bytes.len() > COVER_PREVIEW_MAX_BYTES {
+        return Err("游戏封面预览超过安全大小限制".to_string());
+    }
+    let encoded = base64::engine::general_purpose::STANDARD.encode(bytes);
+    Ok(format!("data:{media_type};base64,{encoded}"))
+}
+
+async fn resolve_cover_preview_data_url(
+    snapshot: &PlatformSessionSnapshot,
+    payload: &CoverGenerationPayload,
+) -> Result<String, String> {
+    current_scoped_session(snapshot)?;
+    let client = build_client()?;
+    let source = json!({
+        "objectKey": payload.object_key.as_deref(),
+        "imageSrc": payload.image_src.as_deref(),
+    });
+    let download = crate::assets::resolve_canvas_resource_download_with_limit_route_and_fence(
+        &client,
+        snapshot.api_base_url.as_str(),
+        snapshot.access_token.as_str(),
+        &source,
+        COVER_PREVIEW_MAX_BYTES,
+        "/api/assets/read-url",
+        || Ok(()),
+    )
+    .await?
+    .ok_or_else(|| "游戏封面预览内容为空".to_string())?;
+    current_scoped_session(snapshot)?;
+    cover_preview_data_url(&download.media_type, &download.bytes)
+}
+
 async fn resolve_cover_queue(
     client: &reqwest::Client,
     snapshot: &PlatformSessionSnapshot,
@@ -350,6 +1049,7 @@ async fn resolve_cover_queue(
                 .map_err(|error| format!("封面生成结果格式无效：{error}"))?;
             return Ok(CoverGenerationPayload {
                 image_src: completed.image_src.or(initial.image_src),
+                object_key: completed.object_key.or(initial.object_key),
                 asset_object_id: completed.asset_object_id.or(initial.asset_object_id),
                 asset: completed.asset.or(initial.asset),
                 task_id: completed.task_id.or(initial.task_id),
@@ -361,26 +1061,6 @@ async fn resolve_cover_queue(
     Err("生成游戏封面超时，请稍后重试".to_string())
 }
 
-#[tauri::command]
-pub(crate) async fn read_game_publish_availability() -> Result<bool, String> {
-    let snapshot = require_platform_session()?;
-    let client = build_client()?;
-    let value = request_json(
-        &client,
-        &snapshot,
-        Method::GET,
-        &["api", "runtime", "frontend-config"],
-        None,
-        None,
-        "读取发布灰度配置失败",
-    )
-    .await?;
-    Ok(value
-        .get("gameDistributionPublishEnabled")
-        .and_then(Value::as_bool)
-        .unwrap_or(false))
-}
-
 #[tauri::command]
 pub(crate) async fn suggest_game_distribution_publish_metadata(
     name: String,
@@ -483,9 +1163,16 @@ pub(crate) async fn generate_game_distribution_cover(
     let payload = resolve_cover_queue(&client, &snapshot, initial).await?;
     let asset_object_id =
         read_cover_asset_id(&payload).ok_or_else(|| "生成游戏封面未返回平台素材 ID".to_string())?;
+    let preview_url = match resolve_cover_preview_data_url(&snapshot, &payload).await {
+        Ok(value) => value,
+        Err(error) => {
+            app_log!("游戏封面生成成功但预览下载失败：{error}");
+            String::new()
+        }
+    };
     Ok(GameDistributionCoverGenerationResult {
         asset_object_id,
-        preview_url: payload.image_src.unwrap_or_default().trim().to_string(),
+        preview_url,
         task_id: payload.task_id.unwrap_or_default().trim().to_string(),
         model: payload
             .model
@@ -496,19 +1183,18 @@ pub(crate) async fn generate_game_distribution_cover(
 }
 
 fn stage_publish_package(
-    app: &AppHandle,
+    app_data_dir: &Path,
     project_path: &str,
     package_relative_path: &str,
 ) -> Result<StagedGamePackage, String> {
     let root = Path::new(project_path.trim());
     crate::project::enforce_project_permission_policy(root, "project.export_package")?;
+    // 发布前先按平台合同校验工程栈：非 Phaser 4 / 非 Vite 的 npm 工程在这里就给出
+    // 可操作错误，不进入后续任何服务端请求。
+    crate::project::ensure_publish_project_stack(root)?;
     let payload =
         crate::project::read_local_project_export_package_at(root, package_relative_path.trim())?;
-    let app_data_dir = app
-        .path()
-        .app_data_dir()
-        .map_err(|error| format!("无法读取 AGC 应用数据目录：{error}"))?;
-    let staging_dir = game_package_upload_staging_dir(&app_data_dir);
+    let staging_dir = game_package_upload_staging_dir(app_data_dir);
     let mut staged = stage_game_package_bytes(
         &staging_dir,
         &payload.package_sha256,
@@ -518,16 +1204,46 @@ fn stage_publish_package(
     Ok(staged)
 }
 
+/// 发布进度事件：阶段 + 文案 + （仅上传阶段有意义的）已收字节/总字节。
+fn emit_publish_progress(
+    app: &AppHandle,
+    publish_id: &str,
+    version_id: &str,
+    phase: &str,
+    message: &str,
+    received_bytes: u64,
+    total_bytes: u64,
+) {
+    let _ = app.emit(
+        PACKAGE_UPLOAD_PROGRESS_EVENT,
+        crate::game_package_upload::progress_event_payload(
+            version_id,
+            publish_id,
+            phase,
+            message,
+            received_bytes,
+            total_bytes,
+        ),
+    );
+}
+
 #[tauri::command]
 pub(crate) async fn publish_local_project_game(
     app: AppHandle,
     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()?;
-    let staged = stage_publish_package(&app, &project_path, &package_relative_path)?;
+    let app_data_dir = app
+        .path()
+        .app_data_dir()
+        .map_err(|error| format!("无法读取 AGC 应用数据目录：{error}"))?;
+    let staged = stage_publish_package(&app_data_dir, &project_path, &package_relative_path)?;
     let local_project_id = metadata
         .local_project_id
         .as_deref()
@@ -547,37 +1263,103 @@ pub(crate) async fn publish_local_project_game(
     if metadata.screenshots.len() > 6 {
         return Err("游戏截图最多 6 张".to_string());
     }
-    let root_key = idempotency_key
+    let target_game_id = game_id
         .as_deref()
         .map(str::trim)
         .filter(|value| !value.is_empty())
-        .map(str::to_string)
-        .unwrap_or_else(|| format!("agc-publish-{}", uuid::Uuid::new_v4()));
-    let client = build_client()?;
-    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());
+        .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)
+        .filter(|value| !value.is_empty())
+    {
+        Some(explicit) => explicit.to_string(),
+        None => {
+            crate::game_publish_attempt::resolve_game_publish_root_key(
+                &app_data_dir,
+                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_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),
+        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(
@@ -588,7 +1370,7 @@ pub(crate) async fn publish_local_project_game(
             "api",
             "game-distribution",
             "games",
-            game.id.as_str(),
+            game_id.as_str(),
             "versions",
         ],
         Some(
@@ -604,10 +1386,26 @@ 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();
     let emit_handle = app.clone();
+    let verify_handle = app.clone();
     let session_identity = snapshot.identity();
+    emit_publish_progress(
+        &app,
+        &root_key,
+        &version.version_id,
+        "upload",
+        "正在上传发行包…",
+        0,
+        staged.package_size_bytes,
+    );
+    let upload_publish_id = root_key.clone();
+    let verify_publish_id = root_key.clone();
     let uploaded: GamePackageUploadOutcome = upload_staged_game_package(
         &client,
         GamePackageUploadRequest {
@@ -619,18 +1417,39 @@ pub(crate) async fn publish_local_project_game(
             session_identity: Some(&session_identity),
         },
         move |received_bytes, total_bytes| {
-            let _ = emit_handle.emit(
-                PACKAGE_UPLOAD_PROGRESS_EVENT,
-                crate::game_package_upload::progress_event_payload(
-                    &progress_version_id,
-                    received_bytes,
-                    total_bytes,
-                ),
+            emit_publish_progress(
+                &emit_handle,
+                &upload_publish_id,
+                &progress_version_id,
+                "upload",
+                "正在上传发行包…",
+                received_bytes,
+                total_bytes,
+            );
+        },
+        move || {
+            emit_publish_progress(
+                &verify_handle,
+                &verify_publish_id,
+                &verify_version_id,
+                "verify",
+                "正在校验发行包…",
+                0,
+                0,
             );
         },
     )
     .await?;
     validate_session(&snapshot)?;
+    emit_publish_progress(
+        &app,
+        &root_key,
+        &version.version_id,
+        "submit",
+        "正在提交审核…",
+        0,
+        0,
+    );
     let submit_value = request_json(
         &client,
         &snapshot,
@@ -643,7 +1462,7 @@ pub(crate) async fn publish_local_project_game(
             "submit",
         ],
         Some(json!({
-            "expectedPublicationRevision": game.publication_revision,
+            "expectedPublicationRevision": publication_revision,
         })),
         Some(&format!("{root_key}:submit")),
         "提交审核失败",
@@ -651,24 +1470,54 @@ 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()
+            }
+        });
+    // 发布成功：把平台作品绑定和最近版本状态写回本地清单。项目版本标签不在这里对齐——它由
+    // 工程内部版本派生，这次提交的平台版本号不回写本地（遗留 `projectVersion` 一并清空）。
+    // 写回失败不回滚已经成功的发布，但会把错误交给作者——否则下次打开项目会退回首次发布，
+    // 甚至可能重复建作品。
+    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.project_version = None;
+        manifest.publication = Some(binding.clone());
+        Ok(manifest.clone())
+    })?;
+    // 服务端已经完成收口（送审成功）：清掉本次尝试记录，下一次同内容的发布就是一个新版本。
+    // 清理失败不影响这次已经成功的发布——重试只会命中服务端幂等收据，不会多建游戏或版本。
+    let _ = crate::game_publish_attempt::clear_game_publish_attempt(
+        &app_data_dir,
+        &snapshot.user_id,
+        &snapshot.api_base_url,
+        &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),
     })
 }
 
@@ -728,6 +1577,104 @@ 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: 版本号已达上限 18446744073709551615，无法自动递增"}}"#,
+                "创建游戏发行版本失败"
+            ),
+            "版本号冲突：版本号已达上限 18446744073709551615，无法自动递增"
+        );
+        // 没有 message 时给出兜底提示，不泄漏原始英文代码。
+        assert_eq!(
+            map_http_error(
+                StatusCode::CONFLICT,
+                r#"{"error":{"code":"VERSION_NUMBER_CONFLICT"}}"#,
+                "创建游戏发行版本失败"
+            ),
+            "版本号冲突：服务端无法为这次发布分配版本号"
+        );
+    }
+
+    #[test]
+    fn repeated_or_lower_project_version_is_not_a_client_side_conflict() {
+        // 重复提交同一版本、回退到更小版本都由服务端接受，客户端不得在本地把它当成冲突。
+        let repeated = map_http_error(
+            StatusCode::BAD_REQUEST,
+            r#"{"error":{"code":"BAD_REQUEST","message":"版本号必须是大于 0 的整数"}}"#,
+            "创建游戏发行版本失败",
+        );
+        assert_eq!(repeated, "创建游戏发行版本失败：版本号必须是大于 0 的整数");
+    }
+
+    #[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!({
@@ -741,4 +1688,14 @@ mod tests {
             Some("asset-from-top-level")
         );
     }
+    #[test]
+    fn cover_preview_data_url_accepts_images_and_rejects_invalid_payloads() {
+        assert_eq!(
+            cover_preview_data_url("image/png; charset=binary", &[0, 1, 2])
+                .expect("image data URL"),
+            "data:image/png;base64,AAEC"
+        );
+        assert!(cover_preview_data_url("text/plain", &[0, 1, 2]).is_err());
+        assert!(cover_preview_data_url("image/png", &[]).is_err());
+    }
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
index 7fdc8c17b..ccaf75a95 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
@@ -329,6 +329,7 @@ pub(crate) async fn upload_staged_game_package(
     client: &reqwest::Client,
     request: GamePackageUploadRequest<'_>,
     mut on_progress: impl FnMut(u64, u64),
+    mut on_verify: impl FnMut(),
 ) -> Result<GamePackageUploadOutcome, String> {
     let total_bytes = fs::metadata(request.staging_path)
         .map_err(|error| format!("读取发行包暂存文件失败：{error}"))?
@@ -406,6 +407,7 @@ pub(crate) async fn upload_staged_game_package(
         on_progress(received, total_bytes);
     }
     let access_token = request.current_access_token()?;
+    on_verify();
     let mut outcome = complete_upload(
         client,
         request.api_base_url,
@@ -418,14 +420,20 @@ pub(crate) async fn upload_staged_game_package(
     Ok(outcome)
 }
 
-/// 进度事件的载荷形状（渲染进程按它显示进度）。
+/// 发布进度载荷；上传阶段带字节进度，其他阶段按阶段文案展示。
 pub(crate) fn progress_event_payload(
     version_id: &str,
+    publish_id: &str,
+    phase: &str,
+    message: &str,
     received_bytes: u64,
     total_bytes: u64,
 ) -> Value {
     json!({
         "versionId": version_id,
+        "publishId": publish_id,
+        "phase": phase,
+        "message": message,
         "receivedBytes": received_bytes,
         "totalBytes": total_bytes,
     })
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
new file mode 100644
index 000000000..bd7d94085
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
@@ -0,0 +1,528 @@
+//! AGC 发布尝试账本：把「同一份发行包的发布尝试」固定到同一个根幂等键上。
+//!
+//! 发布根幂等键派生 `:game` / `:version` / `:upload` / `:submit` 四个子键。只有当
+//! **同一账号、同一本地项目、同一发行包字节**重发时复用同一个根键，服务端才会把
+//! 重发识别成同一次尝试：响应丢失后重试不会多出一个版本，进程重启后分片续传仍接在
+//! 原来那个版本的已收字节上。包内容变了（重新导出或改了工程）就是新尝试，必须换键，
+//! 否则服务端会拿旧版本声明的体积拒绝这份新包。
+//!
+//! 账本落在应用数据目录（`app_data_dir`），不写进项目、也不参与项目快照同步；内容只
+//! 有账号标识、本地项目标识、包摘要和根键，**不含 token、不含任何本地绝对路径**。
+//! 一次发布在服务端完整收口（送审成功）后账本记录即被清掉，下一次发布自然是一个新版本。
+
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::{LazyLock, Mutex};
+
+use serde::{Deserialize, Serialize};
+
+const GAME_PUBLISH_ATTEMPT_SCHEMA_VERSION: &str = "agc-game-publish-attempts.v1";
+const GAME_PUBLISH_ATTEMPT_FILE_NAME: &str = "game-publish-attempts.json";
+/// 账本上限：只服务「同一作者在多个项目里各有一次未收口发布」这一种场景，超出按更新时间丢弃最旧记录。
+const MAX_GAME_PUBLISH_ATTEMPTS: usize = 64;
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct GamePublishAttemptRecord {
+    /// 平台账号标识（`user_account.user_id`），只从当前会话主体派生。
+    account_id: String,
+    /// 平台 origin：同一账号在不同环境（dev / release）的尝试必须互不复用。
+    origin: String,
+    /// AGC 本地项目标识（`manifest.projectId`），不是本地路径。
+    local_project_id: String,
+    /// 归一化发行包摘要；换包即换尝试。
+    package_sha256: String,
+    /// 目标游戏身份：更新已有作品时非空；首次发布为空。
+    #[serde(default)]
+    target_game_id: Option<String>,
+    /// 这次发布提交的项目版本标签（由清单 `versions[]` 的条数派生，不由 `projectVersion`
+    /// 这种遗留兼容位提供）：换了标签就是一次新尝试。
+    #[serde(default)]
+    target_version_number: Option<u64>,
+    /// 随版本冻结的资料摘要：同一份包换了资料修订也必须换根键，不能只按 ZIP 摘要吞掉新发布。
+    #[serde(default)]
+    metadata_digest: String,
+    /// 本次尝试的发布根幂等键。
+    root_key: String,
+    updated_at: u64,
+}
+
+/// 一次发布的意图：账本按「账号 + origin + 本地项目 + 包摘要 + 目标游戏/版本 + 资料摘要」复用。
+///
+/// 只要其中任何一项变化，就必须换根幂等键：否则「同一份 ZIP、但目标版本标签变了（工程内部版本
+/// 推进后重发）的这次提交」会命中上一次尝试的幂等收据，新标签静默失效。
+#[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 {
+    #[serde(default = "game_publish_attempt_schema_version")]
+    schema_version: String,
+    #[serde(default)]
+    attempts: Vec<GamePublishAttemptRecord>,
+}
+
+fn game_publish_attempt_schema_version() -> String {
+    GAME_PUBLISH_ATTEMPT_SCHEMA_VERSION.to_string()
+}
+
+/// 账本读改写串行化：同一进程里的并发发布不会互相覆盖记录。
+static GAME_PUBLISH_ATTEMPT_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
+
+pub(crate) fn game_publish_attempt_path(app_data_dir: &Path) -> PathBuf {
+    app_data_dir.join(GAME_PUBLISH_ATTEMPT_FILE_NAME)
+}
+
+/// 新的发布根幂等键：形状与渲染层历史键一致（`agc-publish-<uuid>`），便于服务端日志关联。
+pub(crate) fn new_game_publish_root_key() -> String {
+    format!("agc-publish-{}", uuid::Uuid::new_v4())
+}
+
+fn unix_timestamp() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or_default()
+}
+
+fn is_valid_package_sha256(value: &str) -> bool {
+    value.len() == 64 && value.chars().all(|character| character.is_ascii_hexdigit())
+}
+
+fn is_valid_attempt_identity(value: &str) -> bool {
+    let trimmed = value.trim();
+    !trimmed.is_empty() && trimmed.len() <= 256 && !trimmed.contains(['\n', '\r'])
+}
+
+fn normalize_record(record: GamePublishAttemptRecord) -> Option<GamePublishAttemptRecord> {
+    if !is_valid_attempt_identity(&record.account_id)
+        || !is_valid_attempt_identity(&record.origin)
+        || !is_valid_attempt_identity(&record.local_project_id)
+        || !is_valid_package_sha256(&record.package_sha256)
+        || !is_valid_attempt_identity(&record.root_key)
+    {
+        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,
+    })
+}
+
+/// 读取账本；文件缺失、损坏或含无效记录时按「没有可复用尝试」处理，发布本身不因此失败。
+fn read_attempts_at(path: &Path) -> Vec<GamePublishAttemptRecord> {
+    let Ok(metadata) = fs::symlink_metadata(path) else {
+        return Vec::new();
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return Vec::new();
+    }
+    let Ok(content) = fs::read_to_string(path) else {
+        return Vec::new();
+    };
+    let Ok(file) = serde_json::from_str::<GamePublishAttemptFile>(&content) else {
+        return Vec::new();
+    };
+    file.attempts
+        .into_iter()
+        .filter_map(normalize_record)
+        .collect()
+}
+
+/// 原子写入账本：临时文件 + `sync_all` + 改名，模式与工作区偏好存储一致。
+fn write_attempts_at(path: &Path, attempts: Vec<GamePublishAttemptRecord>) -> Result<(), String> {
+    let parent = path
+        .parent()
+        .ok_or_else(|| "发布尝试账本缺少父目录".to_string())?;
+    fs::create_dir_all(parent).map_err(|error| format!("创建发布尝试账本目录失败：{error}"))?;
+    if let Ok(metadata) = fs::symlink_metadata(path) {
+        if metadata.file_type().is_symlink() || !metadata.is_file() {
+            return Err("发布尝试账本必须是普通文件".to_string());
+        }
+    }
+    let file = GamePublishAttemptFile {
+        schema_version: game_publish_attempt_schema_version(),
+        attempts,
+    };
+    let content = serde_json::to_string_pretty(&file)
+        .map_err(|error| format!("序列化发布尝试账本失败：{error}"))?;
+    let temp_path = path.with_file_name(format!(
+        ".{}.tmp.{}.{}",
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or(GAME_PUBLISH_ATTEMPT_FILE_NAME),
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos()
+    ));
+    let mut handle = OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .open(&temp_path)
+        .map_err(|error| format!("创建发布尝试账本临时文件失败：{error}"))?;
+    let write_result = handle
+        .write_all(format!("{content}\n").as_bytes())
+        .and_then(|_| handle.sync_all());
+    drop(handle);
+    if let Err(error) = write_result {
+        let _ = fs::remove_file(&temp_path);
+        return Err(format!("写入发布尝试账本失败：{error}"));
+    }
+    #[cfg(windows)]
+    if path.exists() {
+        fs::remove_file(path).map_err(|error| {
+            let _ = fs::remove_file(&temp_path);
+            format!("替换发布尝试账本失败：{error}")
+        })?;
+    }
+    if let Err(error) = fs::rename(&temp_path, path) {
+        let _ = fs::remove_file(&temp_path);
+        return Err(format!("提交发布尝试账本失败：{error}"));
+    }
+    Ok(())
+}
+
+fn attempts_capped(mut attempts: Vec<GamePublishAttemptRecord>) -> Vec<GamePublishAttemptRecord> {
+    if attempts.len() <= MAX_GAME_PUBLISH_ATTEMPTS {
+        return attempts;
+    }
+    attempts.sort_by(|left, right| right.updated_at.cmp(&left.updated_at));
+    attempts.truncate(MAX_GAME_PUBLISH_ATTEMPTS);
+    attempts
+}
+
+/// 解析本次发布要用的根幂等键。
+///
+/// 命中「同账号 + 同 origin + 同本地项目 + 同包摘要 + 同目标游戏/版本 + 同资料摘要」时复用
+/// 既有键（响应丢失、进程重启、分片续传都落在同一次服务端尝试上）；否则铸一个新键并落盘，
+/// 并用新尝试替换同一项目下未收口的旧记录。返回的第二个值表示是否复用。
+pub(crate) fn resolve_game_publish_root_key(
+    app_data_dir: &Path,
+    intent: GamePublishAttemptIntent<'_>,
+) -> Result<(String, bool), String> {
+    let candidate = normalize_record(GamePublishAttemptRecord {
+        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(),
+    })
+    .ok_or_else(|| "发布尝试账本身份无效，请重新登录或重新打开项目后再试".to_string())?;
+    let path = game_publish_attempt_path(app_data_dir);
+    let _guard = GAME_PUBLISH_ATTEMPT_LOCK
+        .lock()
+        .map_err(|_| "发布尝试账本锁不可用".to_string())?;
+    let mut attempts = read_attempts_at(&path);
+    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
+            && record.local_project_id == candidate.local_project_id)
+    });
+    attempts.push(candidate);
+    write_attempts_at(&path, attempts_capped(attempts))?;
+    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
+}
+
+/// 一次发布在服务端收口后清掉记录：下一次同样内容的发布就是一个新版本。
+///
+/// 清理失败不影响已经成功的发布——重试只会命中服务端幂等收据而不会多建版本，
+/// 代价是作者可能看不到新版本，因此这里只在账本可写时才是「干净」的。
+pub(crate) fn clear_game_publish_attempt(
+    app_data_dir: &Path,
+    account_id: &str,
+    origin: &str,
+    local_project_id: &str,
+) -> Result<(), String> {
+    let path = game_publish_attempt_path(app_data_dir);
+    let _guard = GAME_PUBLISH_ATTEMPT_LOCK
+        .lock()
+        .map_err(|_| "发布尝试账本锁不可用".to_string())?;
+    let mut attempts = read_attempts_at(&path);
+    let before = attempts.len();
+    attempts.retain(|record| {
+        !(record.account_id == account_id
+            && record.origin == origin
+            && record.local_project_id == local_project_id)
+    });
+    if attempts.len() == before {
+        return Ok(());
+    }
+    write_attempts_at(&path, attempts)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture_dir(name: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!(
+            "agc-game-publish-attempt-{name}-{}",
+            std::process::id()
+        ));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).expect("fixture dir");
+        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,
+            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,
+            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,
+            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,
+            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,
+            intent("user-1", "https://dev.test", "proj-1", &sha),
+        )
+        .expect("base key");
+        for (account, origin, project) in [
+            ("user-2", "https://dev.test", "proj-1"),
+            ("user-1", "https://release.test", "proj-1"),
+            ("user-1", "https://dev.test", "proj-2"),
+        ] {
+            let (scoped, reused) =
+                resolve_game_publish_root_key(&dir, intent(account, origin, project, &sha))
+                    .expect("scoped key");
+            assert!(!reused, "不同账号/origin/项目不得复用别人的发布尝试");
+            assert_ne!(scoped, base);
+        }
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn clearing_attempt_rotates_the_next_publish_of_the_same_package() {
+        let dir = fixture_dir("clear");
+        let sha = "d".repeat(64);
+        let (first, _) = 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,
+            intent("user-1", "https://dev.test", "proj-1", &sha),
+        )
+        .expect("second key");
+        assert!(!reused, "收口过的尝试不再复用，下一次发布是新版本");
+        assert_ne!(second, first);
+        // 清掉不存在的记录是幂等的空操作。
+        clear_game_publish_attempt(&dir, "user-1", "https://dev.test", "proj-1")
+            .expect("clear again");
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn ledger_only_holds_identifiers_and_summaries() {
+        let dir = fixture_dir("shape");
+        let sha = "e".repeat(64);
+        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");
+        assert_eq!(
+            parsed.get("schemaVersion").and_then(|value| value.as_str()),
+            Some(GAME_PUBLISH_ATTEMPT_SCHEMA_VERSION)
+        );
+        let record = parsed
+            .get("attempts")
+            .and_then(|value| value.as_array())
+            .and_then(|records| records.first())
+            .expect("attempt record");
+        assert_eq!(
+            record
+                .get("localProjectId")
+                .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",
+            "access",
+            "refresh",
+            "Authorization",
+            ":\\",
+            "/home/",
+        ] {
+            assert!(
+                !content.contains(forbidden),
+                "账本出现了不该持久化的字段：{forbidden}"
+            );
+        }
+        // 原子写入不残留临时文件。
+        let leftovers = fs::read_dir(&dir)
+            .expect("dir")
+            .filter_map(Result::ok)
+            .filter(|entry| entry.file_name().to_string_lossy().starts_with('.'))
+            .count();
+        assert_eq!(leftovers, 0, "临时文件必须被改名或清理");
+        let _ = fs::remove_dir_all(&dir);
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/main.rs b/apps/ai-game-creator-shell/src-tauri/src/main.rs
index 8db190f8d..d35778005 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/main.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/main.rs
@@ -104,6 +104,7 @@ mod environment_check;
 pub mod error_report;
 mod game_distribution_publish;
 mod game_package_upload;
+mod game_publish_attempt;
 mod git_inspect;
 mod http_client;
 mod image_inspect;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/export.rs b/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
index 3f27a23ef..4896eaa65 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
@@ -260,6 +260,7 @@ pub(crate) async fn export_local_project_package_for_publish_at(
     root: &Path,
 ) -> Result<LocalProjectExportPackageResult, String> {
     if validate_project_game_entry(root).is_ok() {
+        ensure_publish_project_stack(root)?;
         return export_local_project_package_at(root);
     }
     let manifest = read_manifest_for_project(root)?;
@@ -269,6 +270,9 @@ pub(crate) async fn export_local_project_package_for_publish_at(
         );
     }
     let plan = resolve_publish_build_plan(root)?;
+    // 首版发行包合同只覆盖 Phaser 4 + Vite 的 npm 工程：在跑安装/构建之前先说清楚，
+    // 避免作者等完一次 npm install 才拿到一句泛化错误。
+    ensure_publish_project_stack_at(root, plan.cwd_relative)?;
     // `game/` 子工程构建前必须先有依赖：缺 node_modules 时由发布流程自己补一次安装，
     // 否则作者要点两次（先 bootstrap 再发布）。
     if plan.needs_dependency_install {
@@ -301,6 +305,170 @@ pub(crate) async fn export_local_project_package_for_publish_at(
     export_local_project_package_at(root)
 }
 
+/// 解析依赖声明里的版本号主版本：跳过 `^`、`~`、`>=` 等前缀，取第一段连续数字。
+///
+/// `*`、`latest`、`workspace:*` 这类没有数字的声明返回 `None`，由调用方决定是否回退到
+/// `package-lock.json` 的解析结果。
+fn declared_version_major(spec: &str) -> Option<u64> {
+    let digits = spec
+        .trim()
+        .chars()
+        .skip_while(|character| !character.is_ascii_digit())
+        .take_while(char::is_ascii_digit)
+        .collect::<String>();
+    digits.parse::<u64>().ok()
+}
+
+/// 读取依赖声明原文；兼容 `"phaser": "4.2.1"` 与 `"phaser": { "version": "4.2.1" }` 两种写法。
+fn declared_dependency_spec(package: &serde_json::Value, name: &str) -> Option<String> {
+    const SECTIONS: [&str; 3] = ["dependencies", "devDependencies", "peerDependencies"];
+    for section in SECTIONS {
+        let Some(entry) = package.get(section).and_then(|deps| deps.get(name)) else {
+            continue;
+        };
+        let spec = match entry {
+            serde_json::Value::String(spec) => spec.trim().to_string(),
+            serde_json::Value::Object(object) => object
+                .get("version")
+                .and_then(serde_json::Value::as_str)
+                .map(str::trim)
+                .unwrap_or_default()
+                .to_string(),
+            _ => String::new(),
+        };
+        if !spec.is_empty() {
+            return Some(spec);
+        }
+    }
+    None
+}
+
+/// `package-lock.json` 的已解析版本：v2/v3 看 `packages["node_modules/<name>"]`，v1 看 `dependencies`。
+fn locked_dependency_version(package_root: &Path, name: &str) -> Option<String> {
+    let lock_path = package_root.join("package-lock.json");
+    let content = fs::read_to_string(&lock_path).ok()?;
+    let lock: serde_json::Value = serde_json::from_str(&content).ok()?;
+    let from_packages = lock
+        .get("packages")
+        .and_then(|packages| packages.get(format!("node_modules/{name}")))
+        .and_then(|entry| entry.get("version"))
+        .and_then(serde_json::Value::as_str);
+    from_packages
+        .or_else(|| {
+            lock.get("dependencies")
+                .and_then(|dependencies| dependencies.get(name))
+                .and_then(|entry| entry.get("version"))
+                .and_then(serde_json::Value::as_str)
+        })
+        .map(|version| version.trim().to_string())
+        .filter(|version| !version.is_empty())
+}
+
+/// 读取某个 npm 工作区的 `package.json`；不存在或不是普通文件时返回 `None`。
+fn read_publish_workspace_package(
+    root: &Path,
+    cwd_relative: &str,
+) -> Result<Option<(PathBuf, serde_json::Value)>, String> {
+    let package_root = if cwd_relative == "." {
+        root.to_path_buf()
+    } else {
+        resolve_local_project_path(root, cwd_relative)?
+    };
+    let package_path = package_root.join("package.json");
+    let metadata = match fs::symlink_metadata(&package_path) {
+        Ok(metadata) => metadata,
+        Err(_) => return Ok(None),
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return Err(format!("{cwd_relative}/package.json 必须是普通文件"));
+    }
+    let content = fs::read_to_string(&package_path)
+        .map_err(|error| format!("读取 {cwd_relative}/package.json 失败：{error}"))?;
+    let package: serde_json::Value = serde_json::from_str(&content)
+        .map_err(|error| format!("解析 {cwd_relative}/package.json 失败：{error}"))?;
+    Ok(Some((package_root, package)))
+}
+
+fn workspace_has_vite_config(package_root: &Path) -> bool {
+    [
+        "vite.config.js",
+        "vite.config.mjs",
+        "vite.config.cjs",
+        "vite.config.ts",
+        "vite.config.mts",
+        "vite.config.cts",
+    ]
+    .iter()
+    .any(|name| package_root.join(name).is_file())
+}
+
+/// 发布到游戏广场首版只接受 Phaser 4 + Vite 的 npm 工程。
+///
+/// 客户端发布必须命中 npm 构建工作区；无 `package.json` 的单文件 HTML 项目不属于首版 Phaser 4 发布合同。
+/// 判定顺序以**将被构建的那个工作区**为准，它没声明 phaser 时再看项目里的另一个工作区
+/// （根工程 / `game` 子工程），避免多工作区项目被误判；校验失败必须给出可操作错误——
+/// 缺什么依赖、当前声明是什么版本、要怎么做。错误文案只带项目内相对路径。
+
+fn ensure_publish_project_stack_at(
+    root: &Path,
+    build_cwd_relative: &'static str,
+) -> Result<(), String> {
+    let candidates: [&'static str; 2] = if build_cwd_relative == "." {
+        [".", "game"]
+    } else {
+        [build_cwd_relative, "."]
+    };
+    let mut phaser: Option<(String, String, PathBuf)> = None;
+    let mut vite_ready = false;
+    for cwd_relative in candidates {
+        let Some((package_root, package)) = read_publish_workspace_package(root, cwd_relative)?
+        else {
+            continue;
+        };
+        if phaser.is_none() {
+            if let Some(spec) = declared_dependency_spec(&package, "phaser") {
+                phaser = Some((spec, cwd_relative.to_string(), package_root.clone()));
+            }
+        }
+        if declared_dependency_spec(&package, "vite").is_some()
+            || workspace_has_vite_config(&package_root)
+        {
+            vite_ready = true;
+        }
+    }
+    let Some((spec, cwd_relative, package_root)) = phaser else {
+        return Err(format!(
+            "发布到游戏广场目前只支持 Phaser 4（npm + Vite）工程：{build_cwd_relative}/package.json 未声明 phaser 依赖。请先安装 Phaser 4（例如 npm install phaser@4.2.1）后重新发布。"
+        ));
+    };
+    let major = declared_version_major(&spec).or_else(|| {
+        locked_dependency_version(&package_root, "phaser")
+            .as_deref()
+            .and_then(declared_version_major)
+    });
+    if major.is_some_and(|major| major != 4) {
+        return Err(format!(
+            "发布到游戏广场目前只支持 Phaser 4（npm + Vite）工程：{cwd_relative}/package.json 声明的 phaser 版本是 {spec}。请升级到 Phaser 4（例如 npm install phaser@4.2.1）后重新发布。"
+        ));
+    }
+    if !vite_ready {
+        return Err(format!(
+            "发布到游戏广场目前只支持 Phaser 4（npm + Vite）工程：{cwd_relative}/package.json 未声明 vite 依赖，也没有 vite.config.*。请改用 Vite 构建（例如 npm create vite）后重新发布。"
+        ));
+    }
+    Ok(())
+}
+
+/// 发布前校验工程栈：客户端发布必须使用 Phaser 4 + Vite npm 工程。
+pub(crate) fn ensure_publish_project_stack(root: &Path) -> Result<(), String> {
+    let Some(cwd_relative) = resolve_publish_build_cwd(root)? else {
+        return Err(
+            "发布到游戏广场目前只支持 Phaser 4（npm + Vite）工程：项目没有可识别的 npm build 工作区。请先使用 Phaser 4 + Vite 工程并提供 npm run build 后重新发布。".to_string(),
+        );
+    };
+    ensure_publish_project_stack_at(root, cwd_relative)
+}
+
 /// 发布前的客户端预检：包体不得超过平台上限。
 ///
 /// 服务端仍会独立校验；这里先判一次是为了给作者可操作错误（含实际体积与上限），
@@ -376,6 +544,7 @@ pub(crate) fn read_local_project_export_package_at(
         if content.len() as u64 != expected_size {
             return Err(format!("发行包条目长度不一致：{path}"));
         }
+        let content = normalize_release_asset_references(&path, content);
         entries.push((path, content));
     }
     entries.sort_by(|left, right| left.0.cmp(&right.0));
@@ -422,6 +591,50 @@ pub(crate) fn read_local_project_export_package_at(
     })
 }
 
+fn normalize_release_asset_references(path: &str, content: Vec<u8>) -> Vec<u8> {
+    let is_text = matches!(
+        path.rsplit('.')
+            .next()
+            .unwrap_or_default()
+            .to_ascii_lowercase()
+            .as_str(),
+        "css" | "html" | "htm" | "js" | "json" | "mjs"
+    );
+    if !is_text {
+        return content;
+    }
+    let mut source = match String::from_utf8(content) {
+        Ok(source) => source,
+        Err(error) => return error.into_bytes(),
+    };
+    for root in ["assets", "game", "ui"] {
+        source = source.replace(&format!("\"/{root}/"), &format!("\"{root}/"));
+        source = source.replace(&format!("'/{root}/"), &format!("'{root}/"));
+        source = source.replace(&format!("`/{root}/"), &format!("`{root}/"));
+        source = source.replace(&format!("url(/{root}/"), &format!("url({root}/"));
+    }
+    source.into_bytes()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::normalize_release_asset_references;
+
+    #[test]
+    fn normalize_release_asset_references_removes_root_prefix_only_in_text() {
+        let source = br#"<img src="/assets/hero.png"><script>fetch('/ui/config.json')</script><style>url(/game/icon.svg)</style>"#;
+        let normalized = normalize_release_asset_references("index.html", source.to_vec());
+        let normalized = String::from_utf8(normalized).expect("normalized text");
+        assert!(normalized.contains("src=\"assets/hero.png\""));
+        assert!(normalized.contains("fetch('ui/config.json')"));
+        assert!(normalized.contains("url(game/icon.svg)"));
+        assert_eq!(
+            normalize_release_asset_references("image.png", b"/assets/image.png".to_vec()),
+            b"/assets/image.png"
+        );
+    }
+}
+
 pub(crate) fn next_project_export_package_relative_path(root: &Path) -> Result<String, String> {
     let seed = unix_millis();
     for suffix in 0..1000 {
@@ -570,6 +783,20 @@ pub(crate) fn collect_project_export_package_files(
                     .ok_or("构建产物路径非法")?
             );
         }
+        // AGC 上传的素材登记在项目根 `assets/`，部分 Phaser 工程直接以
+        // `assets/uploads/...` 作为运行 URL，没有通过 Vite public 目录复制到 dist。
+        // 构建产物优先；只有 dist 没有同路径时才补入根目录素材，避免重复 ZIP 条目。
+        let assets_root = resolve_local_project_path(root, "assets")?;
+        if assets_root.exists() {
+            let mut root_assets = Vec::new();
+            collect_project_export_package_dir_files(root, "assets", &mut root_assets)?;
+            for entry in root_assets {
+                let dist_path = format!("game/{}", entry.0);
+                if !files.iter().any(|(path, _, _)| path == &dist_path) {
+                    files.push(entry);
+                }
+            }
+        }
     } else {
         collect_project_export_package_dir_files(root, "game", &mut files)?;
     }
@@ -660,6 +887,35 @@ pub(crate) fn normalize_export_package_entry_path(relative_path: &str) -> Result
 mod npm_export_tests {
     use super::*;
 
+    #[test]
+    fn declared_version_major_reads_semver_prefixes_and_ranges() {
+        assert_eq!(declared_version_major("4.2.1"), Some(4));
+        assert_eq!(declared_version_major("^4.2.1"), Some(4));
+        assert_eq!(declared_version_major("~4.2.1"), Some(4));
+        assert_eq!(declared_version_major(">=4 <5"), Some(4));
+        assert_eq!(declared_version_major("3.90.0"), Some(3));
+        assert_eq!(declared_version_major("latest"), None);
+        assert_eq!(declared_version_major("*"), None);
+        assert_eq!(declared_version_major("workspace:*"), None);
+    }
+
+    #[test]
+    fn declared_dependency_spec_accepts_string_and_object_forms() {
+        let package = serde_json::json!({
+            "dependencies": { "phaser": "^4.2.1" },
+            "devDependencies": { "vite": { "version": "^6.2.0" } }
+        });
+        assert_eq!(
+            declared_dependency_spec(&package, "phaser").as_deref(),
+            Some("^4.2.1")
+        );
+        assert_eq!(
+            declared_dependency_spec(&package, "vite").as_deref(),
+            Some("^6.2.0")
+        );
+        assert_eq!(declared_dependency_spec(&package, "three"), None);
+    }
+
     #[test]
     fn publish_precheck_rejects_packages_over_the_platform_limit() {
         let limit = shared_contracts::game_distribution::GAME_DISTRIBUTION_MAX_PACKAGE_BYTES;
@@ -677,18 +933,26 @@ mod npm_export_tests {
     }
 
     #[test]
-    fn npm_package_contains_only_dist_and_publish_readme() {
-        let base = PathBuf::from(std::env::var("HOME").unwrap()).join("data/tmp");
-        fs::create_dir_all(&base).unwrap();
-        let root = tempfile::tempdir_in(base).unwrap();
-        for directory in ["dist/assets", "assets", "exports", "node_modules", "game"] {
+    fn npm_package_contains_dist_project_root_assets_and_publish_readme() {
+        // 仓库约定的跨平台临时根（基于 std::env::temp_dir()）：不依赖 HOME，
+        // Windows 上只有 USERPROFILE 时同样可跑。
+        let root = crate::tests::canonical_test_tempdir("agc-npm-export-");
+        for directory in [
+            "dist/assets/uploads",
+            "assets/uploads",
+            "exports",
+            "node_modules",
+            "game",
+        ] {
             fs::create_dir_all(root.path().join(directory)).unwrap();
         }
         for file in [
             "package.json",
             "dist/index.html",
             "dist/assets/main.js",
+            "dist/assets/uploads/shared.png",
             "assets/hero.png",
+            "assets/uploads/shared.png",
             "exports/README.md",
             "node_modules/private.js",
             "game/source.js",
@@ -700,13 +964,716 @@ mod npm_export_tests {
             .iter()
             .map(|(name, _, _)| name.as_str())
             .collect::<Vec<_>>();
+        // 构建工程（dist 存在）的试玩包 = dist 构建产物（带 `game/` 前缀，归一化成
+        // 发行包时剥离）+ 项目根 `assets/**` 中 dist 未包含的素材（AGC 上传素材以
+        // `assets/uploads/...` 作为运行 URL，未必经 Vite public 复制进 dist）
+        // + 发布说明。`node_modules` 与 `game/` 源码不进包。
         assert_eq!(
             names,
             vec![
+                "assets/hero.png",
                 "exports/README.md",
                 "game/assets/main.js",
-                "game/index.html"
+                "game/assets/uploads/shared.png",
+                "game/index.html",
             ]
         );
+        // 同名素材以 dist 构建产物为准：根 `assets/uploads/shared.png` 会被丢弃，
+        // 否则归一化剥离 `game/` 前缀后会与 dist 条目重名。
+        let shared = files
+            .iter()
+            .find(|(name, _, _)| name == "game/assets/uploads/shared.png")
+            .expect("dist asset entry");
+        assert_eq!(
+            shared.1,
+            root.path().join("dist/assets/uploads/shared.png"),
+            "同路径素材必须保留 dist 构建产物"
+        );
+    }
+
+    #[test]
+    fn built_project_publish_payload_includes_uploaded_assets_and_prefers_dist_assets() {
+        // 与同批另 5 条 publish_export_tests 同口径：用仓库的跨平台临时根，不依赖 HOME。
+        let root = crate::tests::canonical_test_tempdir("agc-publish-payload-");
+        for directory in [
+            "dist/assets/uploads",
+            "assets/uploads",
+            "exports",
+            "node_modules",
+            "game/src",
+        ] {
+            fs::create_dir_all(root.path().join(directory)).unwrap();
+        }
+        // 构建入口用根绝对引用 `/assets/main.js`：发行包必须把它改写成发行目录内可用的
+        // 相对引用，否则包根 index.html 取不到同一包内的资源。
+        let built_entry = "<!doctype html><html><body><canvas></canvas><script src=\"/assets/main.js\"></script></body></html>";
+        for (file, content) in [
+            ("package.json", "{\"scripts\":{\"build\":\"vite build\"}}"),
+            ("dist/index.html", built_entry),
+            ("dist/assets/main.js", "dist-main"),
+            ("dist/assets/uploads/shared.png", "dist-shared"),
+            ("assets/uploads/food.png", "root-food"),
+            ("assets/uploads/shared.png", "root-shared"),
+            ("exports/README.md", "publish notes"),
+            ("node_modules/private.js", "private"),
+            ("game/src/app.js", "game source"),
+        ] {
+            fs::write(root.path().join(file), content).unwrap();
+        }
+
+        let exported = export_local_project_package_at(root.path()).expect("export built project");
+        let payload =
+            read_local_project_export_package_at(root.path(), &exported.package_relative_path)
+                .expect("normalize publish package");
+
+        // 归一化后的发行包条目：`game/` 前缀已剥掉、dist 产物落在包根、项目根 `assets/**`
+        // 与 dist 独有路径并存、发布说明在包内；`node_modules` 与 `game/` 源码不入包。
+        let names = payload
+            .files
+            .iter()
+            .map(|file| file.path.clone())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            names,
+            vec![
+                "assets/main.js",
+                "assets/uploads/food.png",
+                "assets/uploads/shared.png",
+                "exports/README.md",
+                "index.html",
+            ]
+        );
+        assert!(
+            names.iter().all(|name| !name.starts_with("game/")),
+            "发行包不得保留试玩包的 game/ 前缀：{names:?}"
+        );
+
+        let mut archive = zip::ZipArchive::new(Cursor::new(payload.package_bytes))
+            .expect("read normalized package");
+        let read_entry = |archive: &mut zip::ZipArchive<Cursor<Vec<u8>>>, name: &str| {
+            let mut bytes = Vec::new();
+            archive
+                .by_name(name)
+                .unwrap_or_else(|error| panic!("{name}: {error}"))
+                .read_to_end(&mut bytes)
+                .expect("read entry");
+            bytes
+        };
+        // dist 未包含的 AGC 上传素材（运行 URL `assets/uploads/...`）必须补入发行包。
+        assert_eq!(
+            read_entry(&mut archive, "assets/uploads/food.png"),
+            b"root-food"
+        );
+        // 同路径素材以 dist 构建产物为准，根版本被丢弃（否则归一化后会重名）。
+        assert_eq!(
+            read_entry(&mut archive, "assets/uploads/shared.png"),
+            b"dist-shared"
+        );
+        assert_eq!(read_entry(&mut archive, "assets/main.js"), b"dist-main");
+        assert_eq!(
+            read_entry(&mut archive, "exports/README.md"),
+            b"publish notes"
+        );
+        let entry_html =
+            String::from_utf8(read_entry(&mut archive, "index.html")).expect("utf8 entry");
+        assert!(
+            entry_html.contains("src=\"assets/main.js\""),
+            "{entry_html}"
+        );
+        assert!(!entry_html.contains("\"/assets/"), "{entry_html}");
+        // `node_modules` 与 `game/` 源码不得随包发布。
+        for forbidden in ["node_modules/private.js", "src/app.js", "game/src/app.js"] {
+            assert!(
+                archive.by_name(forbidden).is_err(),
+                "{forbidden} 不应进入发行包"
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod publish_export_tests {
+    use super::*;
+
+    /// 发布前工程栈校验与「已有可玩入口时跳过构建」的回归覆盖。
+    ///
+    /// 这些用例原在 `src/tests/project.rs`，随 master `839051f53` 删除该文件、merge
+    /// `783ca014e` 采纳 master 侧而丢失，这里按原断言意图重建在现役测试布局内。
+    fn publish_project_tempdir(prefix: &str) -> tempfile::TempDir {
+        crate::tests::canonical_test_tempdir(prefix)
+    }
+
+    fn write_game_package_json(root: &Path, package: serde_json::Value) {
+        fs::write(
+            root.join("game/package.json"),
+            serde_json::to_string_pretty(&package).expect("serialize package json"),
+        )
+        .expect("write package json");
+    }
+
+    #[test]
+    fn publish_stack_validation_accepts_scaffolded_phaser4_vite_project() {
+        let temporary = publish_project_tempdir("agc-publish-stack-ok-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-stack-ok", "栈校验通过项目")
+            .expect("project init");
+
+        ensure_publish_project_stack(root).expect("Phaser 4 + Vite 脚手架应通过发布前工程栈校验");
+    }
+
+    #[test]
+    fn publish_stack_validation_reports_actionable_error_for_phaser3() {
+        let temporary = publish_project_tempdir("agc-publish-stack-phaser3-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-stack-phaser3", "Phaser 3 项目")
+            .expect("project init");
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "stack-phaser3",
+                "private": true,
+                "scripts": { "build": "vite build" },
+                "dependencies": { "phaser": "^3.90.0" },
+                "devDependencies": { "vite": "^6.2.0" }
+            }),
+        );
+
+        let error = ensure_publish_project_stack(root).expect_err("Phaser 3 必须被拦下");
+
+        assert!(error.contains("只支持 Phaser 4"), "{error}");
+        assert!(error.contains("3.90.0"), "错误要带上当前声明版本：{error}");
+        assert!(
+            error.contains("npm install phaser@4.2.1"),
+            "错误要给出可操作修复：{error}"
+        );
+        // 错误文案只带项目内相对路径，不带本地绝对路径。
+        assert!(
+            !error.contains(&root.to_string_lossy().to_string()),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn publish_stack_validation_requires_phaser_dependency_and_vite() {
+        let temporary = publish_project_tempdir("agc-publish-stack-missing-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-stack-missing", "缺依赖项目")
+            .expect("project init");
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "stack-no-phaser",
+                "private": true,
+                "scripts": { "build": "vite build" },
+                "devDependencies": { "vite": "^6.2.0" }
+            }),
+        );
+        let error = ensure_publish_project_stack(root).expect_err("缺 phaser 必须被拦下");
+        assert!(error.contains("未声明 phaser 依赖"), "{error}");
+
+        // Phaser 4 但没有 Vite（依赖与配置都不存在）：错误必须指向 Vite。
+        fs::remove_file(root.join("game/vite.config.js")).expect("remove scaffold vite config");
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "stack-webpack",
+                "private": true,
+                "scripts": { "build": "webpack" },
+                "dependencies": { "phaser": "4.2.1" }
+            }),
+        );
+        let error = ensure_publish_project_stack(root).expect_err("非 Vite 工程必须被拦下");
+        assert!(error.contains("vite"), "{error}");
+        assert!(error.contains("Vite 构建"), "{error}");
+    }
+
+    #[test]
+    fn publish_stack_validation_reads_semver_ranges_and_lockfile_versions() {
+        let temporary = publish_project_tempdir("agc-publish-stack-semver-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-stack-semver", "版本区间项目")
+            .expect("project init");
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "stack-semver",
+                "private": true,
+                "scripts": { "build": "vite build" },
+                "dependencies": { "phaser": ">=4 <5" },
+                "devDependencies": { "vite": "^6.2.0" }
+            }),
+        );
+        ensure_publish_project_stack(root).expect(">=4 <5 属于 Phaser 4");
+
+        // 声明成 `*` 时以 package-lock.json 的解析版本为准。
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "stack-star",
+                "private": true,
+                "scripts": { "build": "vite build" },
+                "dependencies": { "phaser": "*" },
+                "devDependencies": { "vite": "^6.2.0" }
+            }),
+        );
+        fs::write(
+            root.join("game/package-lock.json"),
+            serde_json::to_string_pretty(&serde_json::json!({
+                "name": "stack-star",
+                "lockfileVersion": 3,
+                "packages": { "": {}, "node_modules/phaser": { "version": "3.90.0" } }
+            }))
+            .expect("serialize lockfile"),
+        )
+        .expect("write lockfile");
+        let error = ensure_publish_project_stack(root).expect_err("锁文件里的 Phaser 3 也要拦下");
+        assert!(error.contains("只支持 Phaser 4"), "{error}");
+    }
+
+    #[test]
+    fn publish_stack_validation_rejects_projects_without_npm_build_workspace() {
+        let temporary = publish_project_tempdir("agc-publish-stack-legacy-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-stack-legacy", "无 npm 构建项目")
+            .expect("project init");
+        // 去掉 npm 工作区（没有 package.json 也就没有 build 脚本），单文件项目不属于客户端首版合同。
+        fs::remove_file(root.join("game/package.json")).expect("remove game package json");
+
+        let error = ensure_publish_project_stack(root).expect_err("单文件项目必须失败关闭");
+        assert!(error.contains("只支持 Phaser 4"), "{error}");
+    }
+
+    #[tokio::test]
+    async fn publish_export_skips_build_when_phaser_vite_entry_exists() {
+        let temporary = publish_project_tempdir("agc-publish-skip-build-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-publish-skip", "已构建发布项目")
+            .expect("project init");
+        // 已有可玩构建产物：发布会直接打包，不再触发 npm run build。
+        fs::create_dir_all(root.join("game/dist")).expect("create dist directory");
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "publish-skip-fixture",
+                "private": true,
+                "scripts": { "build": "vite build" },
+                "dependencies": { "phaser": "4.2.1" },
+                "devDependencies": { "vite": "^6.2.0" }
+            }),
+        );
+        fs::write(root.join("game/vite.config.js"), "export default {};\n")
+            .expect("write vite config");
+        fs::write(
+            root.join("game/dist/index.html"),
+            "<!doctype html><html><body><canvas></canvas><script>window.started = true;</script></body></html>",
+        )
+        .expect("write playable html");
+
+        let result = export_local_project_package_for_publish_at(root)
+            .await
+            .expect("已有可玩入口且缺少 README 时应自动生成并直接导出");
+
+        assert!(result.package_relative_path.ends_with(".zip"));
+        let readme =
+            fs::read_to_string(root.join("exports/README.md")).expect("read generated readme");
+        assert!(readme.contains("# 已构建发布项目 试玩说明"), "{readme}");
+        let payload = read_local_project_export_package_at(root, &result.package_relative_path)
+            .expect("read publishable package");
+        assert!(payload.files.iter().any(|file| file.path == "index.html"));
+        assert!(payload
+            .files
+            .iter()
+            .any(|file| file.path == "exports/README.md"));
+        let log = fs::read_to_string(root.join(".agent/logs/command.log")).unwrap_or_default();
+        assert!(
+            !log.contains("project.verify build"),
+            "已有可玩入口时不应触发构建：{log}"
+        );
+    }
+
+    /// 单文件可玩 HTML：原 `tests/mod.rs::fake_llm_game_draft().game_html` 的最小内联副本，
+    /// 满足 `validate_game_html_smoke`（画布、主循环、输入、目标/胜负/重开文案、自包含）。
+    const PLAYABLE_GAME_HTML: &str = r#"<!doctype html>
+<html lang="zh-CN">
+  <head><meta charset="UTF-8"><title>月光弹幕厨房</title></head>
+  <body>
+    <canvas id="game" width="320" height="180"></canvas>
+    <script>
+      const canvas = document.getElementById('game');
+      const ctx = canvas.getContext('2d');
+      const player = { x: 40, y: 90, hp: 4 };
+      let litPots = 0;
+      let state = 'playing';
+      const marker = 'MOCK_UNIQUE_MECHANIC:moon-kitchen-reflect';
+      function resetGame() {
+        player.hp = 4;
+        litPots = 0;
+        state = 'playing';
+      }
+      function frame() {
+        ctx.fillStyle = '#101827';
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.fillStyle = '#facc15';
+        ctx.fillText(marker, 16, 32);
+        ctx.fillText('目标：反弹月光弹幕，点亮三口锅', 16, 58);
+        ctx.fillText('状态：继续 / 胜利 / 失败，R 重开', 16, 82);
+        if (litPots >= 3) state = '胜利';
+        if (player.hp <= 0) state = '失败';
+        requestAnimationFrame(frame);
+      }
+      window.addEventListener('keydown', (event) => {
+        if (event.key.toLowerCase() === 'r') resetGame();
+      });
+      requestAnimationFrame(frame);
+    </script>
+  </body>
+</html>"#;
+
+    /// 单文件 HTML 项目（非构建布局）：脚手架提供 manifest 与目录，再去掉 npm 工作区脚手架，
+    /// 换成可玩入口。等价于已删除的 `tests/mod.rs::init_existing_html_project_at`。
+    fn init_existing_html_project(root: &Path, project_id: &str, name: &str) {
+        init_local_game_project_at(root, project_id, name).expect("project init");
+        for relative in [
+            "game/package.json",
+            "game/package-lock.json",
+            "game/vite.config.js",
+            "game/style.css",
+            "game/game.js",
+        ] {
+            let _ = fs::remove_file(root.join(relative));
+        }
+        fs::write(root.join("game/index.html"), PLAYABLE_GAME_HTML).expect("write playable html");
+    }
+
+    #[test]
+    fn publish_build_plan_prefers_game_subproject_and_requires_dependencies() {
+        let temporary = publish_project_tempdir("agc-publish-plan-game-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-plan-game", "Phaser 工程").expect("project init");
+
+        // 脚手架是 game/ + vite build（Phaser 4 工程）：缺依赖时必须先 install。
+        let plan = resolve_publish_build_plan(root).expect("解析构建计划");
+        assert_eq!(plan.cwd_relative, "game");
+        assert_eq!(plan.command, "vite build");
+        assert!(
+            plan.needs_dependency_install,
+            "缺少 game/node_modules 时应先装依赖"
+        );
+
+        fs::create_dir_all(root.join("game/node_modules")).expect("create node_modules");
+        let installed = resolve_publish_build_plan(root).expect("解析构建计划");
+        assert!(
+            !installed.needs_dependency_install,
+            "已有依赖时不应重复 install"
+        );
+    }
+
+    #[test]
+    fn publish_build_plan_falls_back_to_root_npm_build() {
+        let temporary = publish_project_tempdir("agc-publish-plan-root-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-plan-root", "根工程构建").expect("project init");
+        // 去掉 game 子工程的 build，改用项目根 npm 工程构建。
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "plan-root-game",
+                "private": true,
+                "scripts": { "check": "node -e \"process.exit(0)\"" }
+            }),
+        );
+        fs::write(
+            root.join("package.json"),
+            serde_json::to_string_pretty(&serde_json::json!({
+                "name": "plan-root-fixture",
+                "private": true,
+                "scripts": { "build": "node build-root.mjs" }
+            }))
+            .expect("serialize root package json"),
+        )
+        .expect("write root package json");
+
+        let plan = resolve_publish_build_plan(root).expect("解析构建计划");
+        assert_eq!(plan.cwd_relative, ".");
+        assert_eq!(plan.command, "node build-root.mjs");
+        assert!(!plan.needs_dependency_install);
+    }
+
+    #[tokio::test]
+    async fn publish_export_runs_project_build_before_packaging() {
+        let temporary = publish_project_tempdir("agc-publish-auto-build-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-auto-build", "自动构建发布项目")
+            .expect("project init");
+        // 只有源码：package.json 声明 build，构建脚本产出 dist/ 可玩产物。
+        fs::write(
+            root.join("package.json"),
+            serde_json::to_string_pretty(&serde_json::json!({
+                "name": "publish-auto-build-fixture",
+                "private": true,
+                "scripts": { "build": "node build-publish.mjs" }
+            }))
+            .expect("serialize package json"),
+        )
+        .expect("write package json");
+        fs::write(
+            root.join("build-publish.mjs"),
+            r#"import { mkdirSync, writeFileSync } from 'node:fs';
+mkdirSync('dist/assets', { recursive: true });
+writeFileSync('dist/index.html', '<!doctype html><html><head><meta charset="utf-8"><title>Auto Build</title><script src="assets/app.js"></script></head><body><h1>AUTO-BUILD</h1></body></html>');
+writeFileSync('dist/assets/app.js', 'document.documentElement.dataset.autoBuild = "1";');
+"#,
+        )
+        .expect("write build script");
+        update_manifest_task_status_at(
+            root,
+            "code-prototype",
+            GameCreationAppTaskStatus::Completed,
+        )
+        .expect("mark prototype completed");
+        write_local_project_file_at(root, "exports/README.md", "publish notes")
+            .expect("write readme");
+
+        let result = export_local_project_package_for_publish_at(root)
+            .await
+            .expect("发布前构建并导出");
+
+        assert!(root.join("dist/index.html").is_file());
+        assert!(root.join("dist/assets/app.js").is_file());
+        assert!(result
+            .package_relative_path
+            .starts_with("exports/playtest-package-"));
+        let log = fs::read_to_string(root.join(".agent/logs/command.log")).unwrap_or_default();
+        assert!(
+            log.contains("project.verify build"),
+            "发布前应记录一次 project.verify build：{log}"
+        );
+    }
+
+    #[tokio::test]
+    async fn publish_export_blocks_build_until_runnable_prototype_is_completed() {
+        let temporary = publish_project_tempdir("agc-publish-prototype-pending-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-prototype-pending", "原型未完成项目")
+            .expect("project init");
+        fs::write(
+            root.join("package.json"),
+            serde_json::to_string_pretty(&serde_json::json!({
+                "name": "publish-prototype-pending-fixture",
+                "private": true,
+                "scripts": { "build": "node build-should-not-run.mjs" }
+            }))
+            .expect("serialize package json"),
+        )
+        .expect("write package json");
+        fs::write(
+            root.join("build-should-not-run.mjs"),
+            "import { writeFileSync } from 'node:fs'; writeFileSync('build-ran.txt', 'yes');",
+        )
+        .expect("write build marker script");
+
+        let error = export_local_project_package_for_publish_at(root)
+            .await
+            .expect_err("原型未完成时禁止触发用户项目构建");
+
+        assert!(
+            error.contains("首个可运行原型尚未完成"),
+            "错误应说明原型未完成：{error}"
+        );
+        assert!(!root.join("build-ran.txt").exists());
+        let log = fs::read_to_string(root.join(".agent/logs/command.log")).unwrap_or_default();
+        assert!(
+            !log.contains("project.verify build"),
+            "原型未完成时不应执行项目构建：{log}"
+        );
+    }
+
+    #[tokio::test]
+    async fn publish_export_reports_actionable_error_without_entry_or_build_script() {
+        let temporary = publish_project_tempdir("agc-publish-no-entry-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-no-entry", "缺少可玩入口项目")
+            .expect("project init");
+        update_manifest_task_status_at(
+            root,
+            "code-prototype",
+            GameCreationAppTaskStatus::Completed,
+        )
+        .expect("mark prototype completed");
+        // 脚手架默认带 build 脚本；这里改成只有 check 脚本，模拟“没有可玩产物且没有构建脚本”。
+        write_game_package_json(
+            root,
+            serde_json::json!({
+                "name": "publish-no-entry-fixture",
+                "private": true,
+                "scripts": { "check": "node -e \"process.exit(0)\"" }
+            }),
+        );
+
+        let error = export_local_project_package_for_publish_at(root)
+            .await
+            .expect_err("缺少入口且没有 build 脚本时必须失败关闭");
+
+        assert!(
+            error.contains("还没有可玩入口"),
+            "错误应说明缺少可玩入口：{error}"
+        );
+        assert!(
+            error.contains("build 脚本"),
+            "错误应指向 build 脚本：{error}"
+        );
+    }
+
+    #[test]
+    fn local_project_export_package_publish_payload_contains_bytes_and_file_digests() {
+        let temporary = publish_project_tempdir("agc-publish-payload-");
+        let root = temporary.path();
+        init_existing_html_project(root, "project-publish", "在线试玩项目");
+        write_local_project_file_at(root, "exports/README.md", "publish notes")
+            .expect("write readme");
+
+        let exported = export_local_project_package_at(root).expect("export package");
+        assert_eq!(
+            fs::read_to_string(root.join("exports/README.md")).unwrap(),
+            "publish notes"
+        );
+        let payload = read_local_project_export_package_at(root, &exported.package_relative_path)
+            .expect("read publish payload");
+
+        assert_eq!(
+            payload.package_relative_path,
+            exported.package_relative_path
+        );
+        assert_eq!(
+            payload.package_size_bytes,
+            payload.package_bytes.len() as u64
+        );
+        assert_eq!(payload.files.len(), 2);
+        assert!(payload.files.iter().any(|file| file.path == "index.html"));
+        assert!(payload
+            .files
+            .iter()
+            .any(|file| file.path == "exports/README.md"));
+        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(&payload.package_bytes))
+            .expect("read normalized package");
+        let names = (0..archive.len())
+            .map(|index| {
+                archive
+                    .by_index(index)
+                    .expect("normalized entry")
+                    .name()
+                    .to_string()
+            })
+            .collect::<Vec<_>>();
+        assert!(names.iter().any(|name| name == "index.html"));
+        assert!(!names.iter().any(|name| name.starts_with("game/")));
+        assert_eq!(payload.package_sha256.len(), 64);
+        assert!(payload
+            .package_sha256
+            .chars()
+            .all(|value| value.is_ascii_hexdigit()));
+    }
+
+    #[test]
+    fn local_project_export_package_list_only_returns_recent_playtest_zips() {
+        let temporary = publish_project_tempdir("agc-export-list-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-1", "像素动作原型").expect("project init");
+        fs::write(root.join("exports/playtest-package-001.zip"), "old").expect("write old zip");
+        fs::write(root.join("exports/not-playtest.zip"), "ignore").expect("write ignored zip");
+        fs::write(root.join("exports/playtest-package-002.zip"), "newer").expect("write newer zip");
+        fs::write(root.join("game/playtest-package-003.zip"), "wrong dir")
+            .expect("write wrong dir zip");
+
+        let result = list_local_project_export_packages_at(root).expect("list packages");
+
+        assert_eq!(result.project_path, root.to_string_lossy().into_owned());
+        let paths = result
+            .packages
+            .iter()
+            .map(|package| package.package_relative_path.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            paths,
+            vec![
+                "exports/playtest-package-002.zip",
+                "exports/playtest-package-001.zip"
+            ]
+        );
+        assert_eq!(result.packages[0].total_bytes, 5);
+        assert!(result.packages[0].modified_at > 0);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn local_project_export_package_list_skips_symlink_packages() {
+        let temporary = publish_project_tempdir("agc-export-list-link-");
+        let root = temporary.path();
+        init_local_game_project_at(root, "project-1", "像素动作原型").expect("project init");
+        fs::write(root.join("exports/playtest-package-real.zip"), "real").expect("write zip");
+        std::os::unix::fs::symlink(
+            root.join("memory/project.md"),
+            root.join("exports/playtest-package-link.zip"),
+        )
+        .expect("create package symlink");
+
+        let result = list_local_project_export_packages_at(root).expect("list packages");
+
+        assert_eq!(result.packages.len(), 1);
+        assert_eq!(
+            result.packages[0].package_relative_path,
+            "exports/playtest-package-real.zip"
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn local_project_export_package_rejects_symlink_assets() {
+        let temporary = publish_project_tempdir("agc-export-link-assets-");
+        let root = temporary.path();
+        init_existing_html_project(root, "project-1", "像素动作原型");
+        write_local_project_file_at(root, "exports/README.md", "playtest notes")
+            .expect("write readme");
+        std::os::unix::fs::symlink(
+            root.join("memory/project.md"),
+            root.join("assets/private.md"),
+        )
+        .expect("create symlink asset");
+
+        let error = export_local_project_package_at(root).expect_err("symlink should be rejected");
+
+        assert!(error.contains("试玩包不能包含符号链接"));
+        assert!(!root.join("exports").join("playtest-package-").exists());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn local_project_export_package_rejects_symlink_runtime_dirs_and_readme() {
+        let temporary = publish_project_tempdir("agc-export-link-runtime-");
+        let root = temporary.path();
+        init_existing_html_project(root, "project-1", "像素动作原型");
+        write_local_project_file_at(root, "memory/project.md", "private memory")
+            .expect("write memory");
+        std::os::unix::fs::symlink(
+            root.join("memory/project.md"),
+            root.join("exports/README.md"),
+        )
+        .expect("create readme symlink");
+
+        let error = export_local_project_package_at(root).expect_err("readme symlink rejected");
+
+        assert!(error.contains("符号链接"), "{error}");
+        fs::remove_file(root.join("exports/README.md")).expect("remove readme symlink");
+        write_local_project_file_at(root, "exports/README.md", "playtest notes")
+            .expect("write readme");
+        fs::remove_dir_all(root.join("assets")).expect("remove assets dir");
+        fs::create_dir_all(root.join("memory/assets")).expect("create memory assets");
+        fs::write(root.join("memory/assets/hero.txt"), "private asset").expect("write asset");
+        std::os::unix::fs::symlink(root.join("memory/assets"), root.join("assets"))
+            .expect("create assets symlink");
+
+        let error = export_local_project_package_at(root).expect_err("assets symlink rejected");
+
+        assert!(error.contains("符号链接"), "{error}");
     }
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
index a09c68f68..94242824d 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
@@ -205,6 +205,18 @@ fn validate_manifest_cocos_project_root(value: Option<&str>) -> Result<(), Strin
     Ok(())
 }
 
+/// 遗留字段 `projectVersion` 的取值范围：缺省合法（旧清单），写了就必须是正整数。
+///
+/// 它**不参与**发布版本标签的推导（标签由 `versions[]` 的条数派生），只是为了让存量清单继续
+/// 可读。`0` 不是"未设置"的别名——未设置就是字段缺失；一旦落盘 0 会被当成非法值，所以在读
+/// 写两侧都失败关闭，避免坏值被静默传播。
+fn validate_manifest_project_version(value: Option<u64>) -> Result<(), String> {
+    if value == Some(0) {
+        return Err("manifest projectVersion 必须是大于 0 的整数".to_string());
+    }
+    Ok(())
+}
+
 /// Unity 工程身份来自根目录普通文件和目录；禁止借助链接跳到其它工程。
 pub(crate) fn discover_local_unity_project_root(root: &Path) -> Result<Option<String>, String> {
     if root.as_os_str().is_empty() || !root.is_absolute() || project_path_has_control_chars(root) {
@@ -2273,6 +2285,8 @@ pub(crate) fn read_manifest(path: &Path) -> Result<GameCreationAppManifest, Stri
         .map_err(|error| format!("校验 {label} Godot 项目根失败：{error}"))?;
     validate_manifest_cocos_project_root(manifest.cocos_project_root.as_deref())
         .map_err(|error| format!("校验 {label} Cocos 项目根失败：{error}"))?;
+    validate_manifest_project_version(manifest.project_version)
+        .map_err(|error| format!("校验 {label} 项目版本标签失败：{error}"))?;
     validate_game_iteration_versions(&manifest.versions)
         .map_err(|error| format!("校验 {label} 项目版本失败：{error}"))?;
     Ok(manifest)
@@ -2466,6 +2480,8 @@ where
         .map_err(|error| format!("校验 manifest Godot 项目根失败：{error}"))?;
     validate_manifest_cocos_project_root(manifest.cocos_project_root.as_deref())
         .map_err(|error| format!("校验 manifest Cocos 项目根失败：{error}"))?;
+    validate_manifest_project_version(manifest.project_version)
+        .map_err(|error| format!("校验 manifest 项目版本标签失败：{error}"))?;
     if let Some(parent) = path.parent() {
         ensure_game_creator_private_directory_tree(parent, "manifest 目录")?;
         prepare_game_creator_private_path_for_read(parent, true, "manifest 目录")?;
diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index 4aee35d18..145a3fb0a 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -88,7 +88,6 @@ import {
   type ResourceReferenceInsertManyEventDetail,
 } from './features/project-workspace/resourceReferences';
 import { RuntimeConfigDialog } from './features/runtime-config/RuntimeConfigDialog';
-import { readGamePublishAvailability } from './services/gameDistributionPublish';
 import {
   setAgcPluginProjectPath,
   startAvailableAgcEditorPlugins,
@@ -334,8 +333,6 @@ export function App({
   const [publishBlockedMessage, setPublishBlockedMessage] = useState<
     string | null
   >(null);
-  // 发布灰度：只有命中的账号才把「发布到游戏广场」入口交给聊天头；读取失败按不开放处理。
-  const [gamePublishAllowed, setGamePublishAllowed] = useState(false);
   const [projectChatError, setProjectChatError] = useState('');
   const designReplyAnimation = useDesignReplyAnimation();
   const [designAgentStatus, setDesignAgentStatus] = useState('');
@@ -866,20 +863,6 @@ export function App({
     }
   }
 
-  useEffect(() => {
-    let cancelled = false;
-    void readGamePublishAvailability()
-      .then((allowed) => {
-        if (!cancelled) setGamePublishAllowed(allowed);
-      })
-      .catch(() => {
-        if (!cancelled) setGamePublishAllowed(false);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [localProject?.projectPath]);
-
   /**
    * 导出试玩包并打开发布面板。
    *
@@ -914,6 +897,7 @@ export function App({
     setPublishProgress({
       phase: 'running',
       message: '正在构建并打包试玩包，请稍候…',
+      step: 'build',
     });
     try {
       const result = await invoke<LocalProjectExportPackageResult>(
@@ -1847,9 +1831,7 @@ export function App({
           ensureConversationReadAllowed={ensureDirectHistoryReadAllowed}
           ensureConversationWriteAllowed={ensureDirectTurnWriteAllowed}
           initialTurn={initialDirectTurn}
-          onRequestGamePublish={
-            gamePublishAllowed ? requestGamePublish : undefined
-          }
+          onRequestGamePublish={requestGamePublish}
           onCancelConfirmation={cancelUiCommandConfirmation}
           onConfirmConfirmation={confirmUiCommand}
           pendingConfirmation={pendingUiConfirmation}
@@ -1862,6 +1844,11 @@ export function App({
           manifest={manifest}
           packageResult={publishPackageResult}
           onClose={() => setPublishPanelOpen(false)}
+          onPublished={(published) => {
+            // 发布成功会把平台作品绑定写回本地清单；用原生返回的整份 manifest 覆盖
+            // 工作台状态，两处面板挂载点（普通项目 / DirectProject）共享同一份状态。
+            if (published.manifest) setManifest(published.manifest);
+          }}
         />
         <GamePublishProgressDialog
           progress={publishProgress}
@@ -1993,6 +1980,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 23524532f..51dc44f27 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
@@ -1,23 +1,35 @@
 import { Eye, Trash2 } from 'lucide-react';
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 
-import type { GameCreationAppManifest } from '../../../../../packages/shared/src/contracts/gameCreationApp';
+import {
+  type GameCreationAppManifest,
+  resolveGameCreationAppProjectVersion,
+} from '../../../../../packages/shared/src/contracts/gameCreationApp';
 import { GAME_DISTRIBUTION_CATEGORIES } from '../../../../../packages/shared/src/contracts/gameDistribution';
 import { IMAGE_MODEL_GPT_IMAGE_2 } from '../../../../../src/components/image-editor/ImageCanvasGenerationModel';
 import { resolveTauriInvoke } from '../../app/tauri';
 import type { LocalProjectExportPackageResult } from '../../app/types';
 import { uploadPlatformMediaAsset } from '../../services/assetDirectUpload';
 import {
-  createGameDistributionPublishKey,
+  type GameDistributionPublicationImageDraft,
+  type GameDistributionPublicationReadResult,
   type GameDistributionPublishMetadata,
   type GameDistributionPublishResult,
   generateGameDistributionCover,
   MAX_AGC_GAME_SCREENSHOTS,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../../services/gameDistributionPublish';
+import {
+  computeGamePackageUploadPercent,
+  type GamePublishRuntimePhase,
+  subscribeGamePackageUploadProgress,
+} from '../../services/gamePackageUploadProgress';
+import type { TauriEventUnsubscribe } from '../../services/tauriEventSubscription';
 import { ThemedModal } from '../modal/ThemedModal';
+import { GamePublishPhaseSteps } from './GamePublishPhaseSteps';
 
 /** 封面与截图都是公开展示素材，限制单张体积，避免手机原图直传拖垮发布流程。 */
 const PANEL_IMAGE_MAX_BYTES = 6 * 1024 * 1024;
@@ -40,9 +52,21 @@ 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' ? '游戏封面' : '游戏截图';
 }
@@ -85,6 +109,56 @@ 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;
+}
+
+/** 已发布作品的封面恢复：预览用换签地址，提交仍复用冻结素材 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';
@@ -173,17 +247,47 @@ export function GameDistributionPublishPanel({
   const [previewScreenshot, setPreviewScreenshot] =
     useState<PanelScreenshotEntry | null>(null);
   const [uploadingLabel, setUploadingLabel] = useState('');
-  const [metadataSuggestionPending, setMetadataSuggestionPending] =
-    useState(false);
-  const [metadataSuggestionReady, setMetadataSuggestionReady] = useState(false);
   const [coverConfirmOpen, setCoverConfirmOpen] = useState(false);
   const [generatingCover, setGeneratingCover] = useState(false);
   const [coverGenerationPrice, setCoverGenerationPrice] = useState<
     number | null
   >(null);
   const [coverGenerationDetail, setCoverGenerationDetail] = useState('');
-  const publishIdempotencyKeyRef = useRef('');
+  /** 发布进行中的阶段与百分比；来自 `game-package-upload-progress`。 */
+  const [publishPhase, setPublishPhase] = useState<{
+    phase: GamePublishRuntimePhase;
+    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('');
+  /** 线上最近提交的版本号；首次发布为 0（没有线上版本）。 */
+  const [latestVersionNumber, setLatestVersionNumber] = useState(0);
+  /**
+   * 面板展示并提交的「项目版本」：AGC 工程内部版本序数，唯一来源是清单的 `versions[]`。
+   *
+   * 只读派生值，不是可编辑 state：用户不能改，平台版本号也改不了它。每次智能体修订追加一条
+   * 内部版本，这个值随之推进。
+   */
+  const projectVersion = useMemo(
+    () => resolveGameCreationAppProjectVersion(manifest),
+    [manifest],
+  );
   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);
@@ -200,51 +304,136 @@ export function GameDistributionPublishPanel({
     setTitle(manifest.name.trim());
     setSummary(fallbackSummary);
     setCategory('其他');
+    setCover(null);
+    setScreenshots([]);
     setBusy(false);
     setError('');
     setResult(null);
-    setMetadataSuggestionPending(false);
-    setMetadataSuggestionReady(false);
     setCoverConfirmOpen(false);
     setGeneratingCover(false);
     setCoverGenerationPrice(null);
     setCoverGenerationDetail('');
     setPreviewScreenshot(null);
+    setPublishPhase(null);
+    setPublicationState('checking');
+    setPublicationBinding(null);
+    setPublicationRefreshed(false);
+    setPublicationMessage('');
+    setLatestVersionNumber(0);
     summaryTouchedRef.current = false;
     categoryTouchedRef.current = false;
+    publicationDraftAppliedRef.current = false;
+    restoredDeclarationsRef.current = null;
+    uploadedAssetCacheRef.current.clear();
 
-    const requestId = ++metadataSuggestionRequestRef.current;
-    setMetadataSuggestionPending(true);
+    const suggestionRequestId = ++metadataSuggestionRequestRef.current;
     void suggestGameDistributionPublishMetadata({
       name: manifest.name,
       goal: manifest.goal,
       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);
       })
       .catch(() => {
         // 免费增强能力失败时保留本地兜底，不阻断发布。
-      })
-      .finally(() => {
-        if (requestId === metadataSuggestionRequestRef.current) {
-          setMetadataSuggestionPending(false);
-        }
       });
-  }, [manifest, open, packageResult?.packageRelativePath]);
 
-  useEffect(() => {
-    if (open) {
-      publishIdempotencyKeyRef.current = createGameDistributionPublishKey();
+    // 绑定恢复：原生按当前会话（账号 + origin）隔离；网络/401/5xx 返回 unavailable，
+    // 面板据此禁用提交而不是退化成首次发布。
+    const invoke = resolveTauriInvoke();
+    if (!invoke) {
+      // 非 Tauri 宿主：没有可恢复的原生状态，交给提交时的失败提示兜底。
+      setPublicationState('first-publish');
+      return;
     }
-  }, [open, packageResult?.packageRelativePath]);
+    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 latestVersionNumber = recovery.binding.latestVersionNumber ?? 0;
+          setPublicationState('update');
+          setPublicationBinding(recovery.binding);
+          setPublicationRefreshed(recovery.refreshed);
+          setPublicationMessage(recovery.message?.trim() ?? '');
+          setLatestVersionNumber(latestVersionNumber);
+          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;
@@ -422,7 +611,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,
@@ -472,10 +661,24 @@ export function GameDistributionPublishPanel({
       setError('需要在 Tauri App 内发布');
       return;
     }
+    if (publicationState === 'checking') {
+      setError('正在确认项目发布状态，请稍候再试');
+      return;
+    }
+    if (publicationState === 'unavailable') {
+      setError(
+        publicationMessage || '无法确认该项目的线上发布状态，请稍后重试',
+      );
+      return;
+    }
     if (!cover) {
       setError('请先选择游戏封面（JPG/PNG/WebP）');
       return;
     }
+    if (!cover.assetObjectId.trim()) {
+      setError('当前发布封面缺少平台素材，请重新选择封面后再发布');
+      return;
+    }
     if (
       uploadingLabel ||
       screenshots.some((item) => item.status === 'uploading')
@@ -485,6 +688,32 @@ export function GameDistributionPublishPanel({
     }
     setBusy(true);
     setError('');
+    setPublishPhase({
+      phase: 'prepare',
+      message: '正在准备发布…',
+      percent: null,
+    });
+    // 先订阅再发起发布：Rust 的「准备 / 上传 / 校验 / 送审」事件都在命令执行期间回传，
+    // 订阅是异步的，晚订阅会丢掉开头几个阶段。事件的 versionId 在命令返回前对渲染层
+    // 不可知，所以只按「本次订阅窗口」收敛——同一窗口同一时刻只有一次发布在跑。
+    let unsubscribe: TauriEventUnsubscribe = () => undefined;
+    try {
+      unsubscribe = await subscribeGamePackageUploadProgress((progress) => {
+        setPublishPhase({
+          phase: progress.phase,
+          message: progress.message || '正在发布…',
+          percent:
+            progress.phase === 'upload'
+              ? computeGamePackageUploadPercent(
+                  progress.receivedBytes,
+                  progress.totalBytes,
+                )
+              : null,
+        });
+      });
+    } catch {
+      // 订阅失败只影响阶段条：发布本身照常进行，按钮上仍显示「正在发布…」。
+    }
     try {
       const next = await publishLocalProjectGame({
         invoke,
@@ -505,8 +734,18 @@ export function GameDistributionPublishPanel({
               } => item.status === 'ready' && Boolean(item.assetObjectId),
             )
             .map((item) => item.assetObjectId),
+          // 更新发布沿用线上冻结的设备/输入/方向声明；首次发布没有这些值，服务端默认。
+          ...(restoredDeclarationsRef.current ?? {}),
         },
-        idempotencyKey: publishIdempotencyKeyRef.current,
+        gameId:
+          publicationState === 'update'
+            ? (publicationBinding?.gameId ?? null)
+            : null,
+        versionNumber: projectVersion,
+        expectedPublicationRevision:
+          publicationState === 'update'
+            ? (publicationBinding?.revision ?? null)
+            : null,
       });
       setResult(next);
       onPublished?.(next);
@@ -515,7 +754,9 @@ export function GameDistributionPublishPanel({
         nextError instanceof Error ? nextError.message : String(nextError),
       );
     } finally {
+      unsubscribe();
       setBusy(false);
+      setPublishPhase(null);
     }
   }
 
@@ -562,7 +803,7 @@ export function GameDistributionPublishPanel({
             <strong>已提交审核</strong>
             <p>版本已进入审核队列，审核通过后才会在游戏广场公开展示。</p>
             <p className="game-distribution-publish-panel__mono">
-              版本 {result.versionNumber} ·{' '}
+              项目版本 v{result.versionNumber} ·{' '}
               {result.packageSizeBytes.toLocaleString()} B ·{' '}
               {result.packageSha256.slice(0, 16)}…
             </p>
@@ -574,6 +815,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 ? `v${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>
                 游戏名称
@@ -614,16 +891,24 @@ export function GameDistributionPublishPanel({
                   ))}
                 </select>
               </label>
-              <span
-                className="game-distribution-publish-panel__metadata-hint"
-                role="status"
-              >
-                {metadataSuggestionPending
-                  ? '正在根据创作内容生成简介和分类…'
-                  : metadataSuggestionReady
-                    ? 'AI 已根据创作内容生成简介和分类，免费；你可以直接修改。'
-                    : '已根据创作内容预填简介和分类，免费；你可以直接修改。'}
-              </span>
+              <label>
+                <span className="game-distribution-publish-panel__version-label">
+                  项目版本
+                  <span className="game-distribution-publish-panel__version-tag">
+                    {`v${projectVersion}`}
+                  </span>
+                </span>
+                <input
+                  type="number"
+                  min={1}
+                  step={1}
+                  inputMode="numeric"
+                  aria-label="项目版本"
+                  readOnly
+                  aria-readonly="true"
+                  value={projectVersion}
+                />
+              </label>
             </div>
             <div
               className="game-distribution-publish-panel__media"
@@ -681,11 +966,11 @@ export function GameDistributionPublishPanel({
                       </button>
                     ) : null}
                   </div>
-                  <span className="game-distribution-publish-panel__hint">
-                    {cover
-                      ? `已选择「${cover.name}」；重新选择即可替换封面。`
-                      : '封面会作为游戏广场卡片与详情页首图，建议 16:9 的 JPG/PNG/WebP，最大 6MB。'}
-                  </span>
+                  {cover ? null : (
+                    <span className="game-distribution-publish-panel__hint">
+                      {'封面会作为游戏广场卡片与详情页首图，建议 16:9 的 JPG/PNG/WebP，最大 6MB。'}
+                    </span>
+                  )}
                   {coverGenerationDetail ? (
                     <span
                       className="game-distribution-publish-panel__hint"
@@ -723,9 +1008,6 @@ export function GameDistributionPublishPanel({
                         : '添加截图'}
                   </span>
                 </span>
-                <span className="game-distribution-publish-panel__hint">
-                  每张截图独立上传，单张失败不会影响其它截图或发布；鼠标移到成功截图上可删除或预览。
-                </span>
               </label>
               {screenshots.length > 0 ? (
                 <ul className="game-distribution-publish-panel__shots">
@@ -811,6 +1093,18 @@ export function GameDistributionPublishPanel({
                 {error}
               </p>
             ) : null}
+            {busy && publishPhase ? (
+              <div
+                className="game-distribution-publish-panel__progress"
+                role="status"
+              >
+                <GamePublishPhaseSteps
+                  activeStep={publishPhase.phase}
+                  percent={publishPhase.percent}
+                  message={publishPhase.message}
+                />
+              </div>
+            ) : null}
             <div className="game-distribution-publish-panel__actions">
               <button
                 type="button"
@@ -827,20 +1121,28 @@ export function GameDistributionPublishPanel({
                   generatingCover ||
                   screenshotsUploading ||
                   Boolean(uploadingLabel) ||
+                  publicationState === 'checking' ||
+                  publicationState === 'unavailable' ||
                   !title.trim() ||
                   !summary.trim() ||
                   !packageResult
                 }
               >
                 {busy
-                  ? '上传中…'
+                  ? '正在发布…'
                   : generatingCover
                     ? '封面生成中…'
                     : screenshotsUploading
                       ? '截图上传中…'
                       : uploadingLabel
                         ? '素材上传中…'
-                        : '发布游戏'}
+                        : publicationState === 'update'
+                          ? '更新游戏'
+                          : publicationState === 'checking'
+                            ? '正在检查发布状态…'
+                            : publicationState === 'unavailable'
+                              ? '无法确认发布状态'
+                              : '发布游戏'}
               </button>
             </div>
           </>
diff --git a/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishPhaseSteps.tsx b/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishPhaseSteps.tsx
new file mode 100644
index 000000000..e9382567c
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishPhaseSteps.tsx
@@ -0,0 +1,70 @@
+import {
+  GAME_PUBLISH_STEPS,
+  type GamePublishStepId,
+} from '../../services/gamePackageUploadProgress';
+
+/**
+ * 发布阶段步骤条：构建 → 准备 → 上传 → 校验 → 送审。
+ *
+ * 只做展示：当前阶段之前的一律标成已完成，当前阶段带百分比（只有上传阶段有可换算的总量），
+ * 之后的仍为待执行。组件不订阅事件，进度由调用方（发布面板 / 全屏进度弹窗）注入。
+ */
+export function GamePublishPhaseSteps({
+  activeStep,
+  percent = null,
+  message = '',
+}: {
+  activeStep: GamePublishStepId;
+  percent?: number | null;
+  message?: string;
+}) {
+  const activeIndex = Math.max(
+    0,
+    GAME_PUBLISH_STEPS.findIndex((step) => step.id === activeStep),
+  );
+  const activeLabel = GAME_PUBLISH_STEPS[activeIndex]?.label ?? '';
+  return (
+    <div className="game-publish-phase">
+      <ol className="game-publish-phase__steps" aria-label="发布阶段">
+        {GAME_PUBLISH_STEPS.map((step, index) => {
+          const state =
+            index === activeIndex
+              ? 'active'
+              : index < activeIndex
+                ? 'done'
+                : 'pending';
+          return (
+            <li
+              key={step.id}
+              className={`game-publish-phase__step is-${state}`}
+              aria-current={state === 'active' ? 'step' : undefined}
+            >
+              <span className="game-publish-phase__marker" aria-hidden="true">
+                {state === 'done' ? '✓' : index + 1}
+              </span>
+              <span className="game-publish-phase__label">{step.label}</span>
+              {state === 'active' && percent !== null ? (
+                <span className="game-publish-phase__percent">{percent}%</span>
+              ) : null}
+            </li>
+          );
+        })}
+      </ol>
+      {percent === null ? null : (
+        <div
+          className="game-publish-phase__bar"
+          role="progressbar"
+          aria-label={`${activeLabel}进度`}
+          aria-valuemin={0}
+          aria-valuemax={100}
+          aria-valuenow={percent}
+        >
+          <span style={{ width: `${percent}%` }} />
+        </div>
+      )}
+      {message ? (
+        <p className="game-publish-phase__message">{message}</p>
+      ) : null}
+    </div>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishProgressDialog.tsx b/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishProgressDialog.tsx
index b784c2b9d..9b5e94b83 100644
--- a/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishProgressDialog.tsx
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/GamePublishProgressDialog.tsx
@@ -1,11 +1,17 @@
 import { CircleAlert, LoaderCircle } from 'lucide-react';
 
+import type { GamePublishStepId } from '../../services/gamePackageUploadProgress';
 import { ThemedModal } from '../modal/ThemedModal';
+import { GamePublishPhaseSteps } from './GamePublishPhaseSteps';
 
 export type GamePublishProgressState =
   | {
       phase: 'running';
       message: string;
+      /** 当前步骤；缺省按「构建」处理——导出打包是发布链路的第一步。 */
+      step?: GamePublishStepId;
+      /** 只有上传阶段有可换算的百分比；其它阶段为 `null`（不确定进度）。 */
+      percent?: number | null;
     }
   | {
       phase: 'failed';
@@ -21,6 +27,7 @@ export function GamePublishProgressDialog({
   onClose: () => void;
 }) {
   const failed = progress?.phase === 'failed';
+  const running = progress?.phase === 'running' ? progress : null;
   return (
     <ThemedModal
       open={progress !== null}
@@ -46,6 +53,12 @@ export function GamePublishProgressDialog({
       <p role={failed ? 'alert' : 'status'}>
         {failed ? progress.detail : progress?.message}
       </p>
+      {running ? (
+        <GamePublishPhaseSteps
+          activeStep={running.step ?? 'build'}
+          percent={running.percent ?? null}
+        />
+      ) : null}
       {failed ? (
         <button type="button" onClick={onClose}>
           关闭
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/LocalGamePreviewFrame.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/LocalGamePreviewFrame.tsx
index 880adb5c3..f47951e8f 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/LocalGamePreviewFrame.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/LocalGamePreviewFrame.tsx
@@ -272,6 +272,7 @@ export function LocalGamePreviewFrame({
   title,
   className,
   inspectMode = false,
+  reloadNonce = 0,
   onInspectSelection,
   onInspectExit,
 }: {
@@ -279,6 +280,14 @@ export function LocalGamePreviewFrame({
   title: string;
   className?: string;
   inspectMode?: boolean;
+  /**
+   * 换一个值就把 iframe 重新挂载一次＝重新载入运行页面（使用方的「刷新运行画面」）。
+   *
+   * 游戏预览不是 vite dev 的实时刷新：改完代码要看到新一版只有重载页面这一条路。`src` 不变，
+   * 靠 React 的 `key` 换元素身份——跨域 iframe 里 `contentWindow.location.reload()` 会被
+   * 浏览器挡掉（运行页面在另一个端口上）。
+   */
+  reloadNonce?: number;
   onInspectSelection?: (selection: LocalGamePreviewInspectSelection) => void;
   onInspectExit?: () => void;
 }) {
@@ -425,6 +434,7 @@ export function LocalGamePreviewFrame({
     <div ref={containerRef} className="local-game-preview-frame">
       <iframe
         ref={iframeRef}
+        key={reloadNonce}
         className={className}
         title={title}
         src={embeddedUrl}
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/GameRunVersionPicker.tsx b/apps/ai-game-creator-shell/src/features/resource-canvas/GameRunVersionPicker.tsx
index bc5d79f0f..68e882d57 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/GameRunVersionPicker.tsx
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/GameRunVersionPicker.tsx
@@ -3,7 +3,11 @@ import { createPortal } from 'react-dom';
 
 import type { GameIterationVersion } from '../../../../../packages/shared/src/contracts/gameCreationApp';
 import { useImageCanvasFloatingOptionDismiss } from '../../../../../src/components/image-editor/useImageCanvasFloatingOptionDismiss';
-import { formatIterationVersionLabel } from './resourceCanvasVersionBindingModel';
+import {
+  formatIterationVersionDetail,
+  formatIterationVersionLabel,
+  formatIterationVersionTitle,
+} from './resourceCanvasVersionBindingModel';
 
 type GameRunVersionPickerProps = {
   versions: readonly GameIterationVersion[];
@@ -64,6 +68,12 @@ export function GameRunVersionPicker({
   if (!currentVersion) {
     return null;
   }
+  const currentVersionIndex = Math.max(
+    0,
+    versions.findIndex(
+      (version) => version.versionId === currentVersion.versionId,
+    ),
+  );
 
   return (
     <div ref={rootRef} className="game-run-version-picker">
@@ -72,16 +82,25 @@ export function GameRunVersionPicker({
         className="game-run-version-trigger"
         aria-haspopup="listbox"
         aria-expanded={open}
-        aria-label={`当前版本：${formatIterationVersionLabel(currentVersion)}`}
+        aria-label={`当前版本：${formatIterationVersionLabel(
+          currentVersion,
+          currentVersionIndex,
+        )}`}
         onClick={() => setOpen((current) => !current)}
       >
         {/*
-          版本名可能很长（`初始版本 · 2026/9/19 02:10:03`）。按钮是 flex 容器，直接放文本节点
-          时 `text-overflow: ellipsis` 不生效（匿名 flex item 不参与父级省略），所以套一层
-          span 由它省略（见样式里的 `.game-run-version-trigger-label`）。
+          按钮是 flex 容器，直接放文本节点时 `text-overflow: ellipsis` 不生效（匿名 flex item
+          不参与父级省略），所以序号与括号里那一截各套一层 span（见样式里的
+          `.game-run-version-trigger-label`）。分两层还让「空间不够只留 `版本 1`」成为一次
+          `display: none`——顶栏窄到放不下完整标识时收掉的是括号那一层，不是整枚入口。
         */}
         <span className="game-run-version-trigger-label">
-          {formatIterationVersionLabel(currentVersion)}
+          <span className="game-run-version-trigger-title">
+            {formatIterationVersionTitle(currentVersionIndex)}
+          </span>
+          <span className="game-run-version-trigger-detail">
+            （{formatIterationVersionDetail(currentVersion)}）
+          </span>
         </span>
       </button>
       {open
@@ -106,7 +125,7 @@ export function GameRunVersionPicker({
                   : '0',
               }}
             >
-              {versions.map((version) => {
+              {versions.map((version, index) => {
                 const selected = version.versionId === currentVersion.versionId;
                 return (
                   <button
@@ -114,7 +133,7 @@ export function GameRunVersionPicker({
                     type="button"
                     role="option"
                     aria-selected={selected}
-                    aria-label={`切换到${formatIterationVersionLabel(version)}`}
+                    aria-label={`切换到${formatIterationVersionLabel(version, index)}`}
                     className={selected ? 'is-selected' : undefined}
                     onClick={() => {
                       setOpen(false);
@@ -122,7 +141,7 @@ export function GameRunVersionPicker({
                       onSelectVersion(version.versionId);
                     }}
                   >
-                    <span>{formatIterationVersionLabel(version)}</span>
+                    <span>{formatIterationVersionLabel(version, index)}</span>
                     <small>{version.versionId}</small>
                   </button>
                 );
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasVersionBindingModel.ts b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasVersionBindingModel.ts
index e6dabc448..f59a2af60 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasVersionBindingModel.ts
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasVersionBindingModel.ts
@@ -20,7 +20,20 @@ export const ITERATION_VERSION_REASON_LABELS: Record<
 };
 
 /**
- * 版本在 UI 里的可读标识：创建原因 + 创建时间。
+ * 版本序号：`manifest.versions[]` 的下标 + 1。
+ *
+ * 与资源画布「项目版本」卡片的 `版本 N`（`resourceProjectionModel` 里同一份下标口径）是同一个
+ * 编号——两处都按 manifest 里版本的落盘顺序数，不要在别处另起一套编号。
+ */
+export function formatIterationVersionTitle(ordinalIndex: number) {
+  return `版本 ${ordinalIndex + 1}`;
+}
+
+/**
+ * 版本标识里「括号里那一截」：创建原因 + 创建时间。
+ *
+ * 顶栏宽度不够时整截收起、只留 `版本 N`（见 `workbenchToolbarModel` 的档位），所以它是独立
+ * 一段文本，而不是拼在序号里的后缀。
  *
  * `GameIterationVersion.createdAt` 的单位是 **Unix 秒**（写入侧为
  * `project/manifest.rs` 的 `created_at: unix_timestamp()`，而 `unix_timestamp()` 取
@@ -28,7 +41,7 @@ export const ITERATION_VERSION_REASON_LABELS: Record<
  * 渲染成 1970 年（例如 1788075047 会显示成 1970/1/22）。
  * 同一约定在 `ResourceAssetDeleteDialog` 与待确认资源编辑的创建时间标签里一致使用。
  */
-export function formatIterationVersionLabel(
+export function formatIterationVersionDetail(
   version: Pick<GameIterationVersion, 'createdReason' | 'createdAt'>,
 ) {
   const reason =
@@ -41,6 +54,21 @@ export function formatIterationVersionLabel(
   return `${reason} · ${time}`;
 }
 
+/**
+ * 版本在 UI 里的完整标识：`版本 1（智能体修订 · 2026/10/3 14:21:05）`。
+ *
+ * 视觉上空间不够时可以只显示 `formatIterationVersionTitle`，但可访问名、菜单项与排障文案一律
+ * 用这一条完整的——收起来的是排版，不是信息。
+ */
+export function formatIterationVersionLabel(
+  version: Pick<GameIterationVersion, 'createdReason' | 'createdAt'>,
+  ordinalIndex: number,
+) {
+  return `${formatIterationVersionTitle(ordinalIndex)}（${formatIterationVersionDetail(
+    version,
+  )}）`;
+}
+
 /**
  * C5 / C7 卡片边框：一个资源是否正在被「当前版本」使用。
  *
diff --git a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
index fc67e37cd..aa5fb0b9e 100644
--- a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
+++ b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
@@ -1,7 +1,12 @@
-import type { GameCreationAppManifest } from '../../../../packages/shared/src/contracts/gameCreationApp';
+import {
+  type GameCreationAppManifest,
+  type GameCreationAppPublicationBinding,
+  resolveGameCreationAppProjectVersion,
+} from '../../../../packages/shared/src/contracts/gameCreationApp';
 import type {
   GameDistributionCategory,
   GameDistributionCreateGameRequest,
+  GameDistributionDeviceSupport,
   GameDistributionInputMode,
   GameDistributionOrientation,
 } from '../../../../packages/shared/src/contracts/gameDistribution';
@@ -38,19 +43,6 @@ function requireNativeInvoke(invoke?: TauriInvoke) {
   return resolved;
 }
 
-/**
- * 读取当前账号的游戏发布灰度。
- *
- * 与网页端共用 `/api/runtime/frontend-config`：后端未配置 `game-distribution:publish`
- * 时对已登录作者默认开放，运营收紧后只有白名单/灰度命中的作者返回 `true`。读取失败按
- * “不开放入口”处理——写入口本身还会再拦一次，AGC 面板不作为唯一把关点。
- */
-export async function readGamePublishAvailability(
-  invoke?: TauriInvoke,
-): Promise<boolean> {
-  return requireNativeInvoke(invoke)('read_game_publish_availability');
-}
-
 export type GameDistributionPublishResult = {
   gameId: string;
   versionId: string;
@@ -59,14 +51,89 @@ export type GameDistributionPublishResult = {
   packageSha256: string;
   packageSizeBytes: number;
   fileCount: number;
+  /** 发布成功并回写绑定后的整份 manifest；渲染层据此同步工作台状态。 */
+  manifest?: GameCreationAppManifest | null;
+  publication?: GameCreationAppPublicationBinding | null;
 };
 
-export function createGameDistributionPublishKey() {
-  const randomUuid =
-    typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
-      ? crypto.randomUUID()
-      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  return `agc-publish-${randomUuid}`;
+/** 更新发布时默认回填的封面/截图；`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 = {
@@ -226,6 +293,27 @@ export async function publishLocalProjectGame(args: {
   packageRelativePath: string;
   manifest: GameCreationAppManifest;
   metadata?: Partial<GameDistributionPublishMetadata>;
+  /**
+   * 更新已有作品时的目标游戏身份（来自发布绑定）。提供时必须同时给出
+   * `expectedPublicationRevision`：原生会跳过 create game，直接在原 gameId 上创建新版本。
+   */
+  gameId?: string | null;
+  /**
+   * 这次提交使用的项目版本标签。
+   *
+   * 缺省时按 AGC 工程内部版本 `versions[]` 派生（见 `resolveGameCreationAppProjectVersion`）：
+   * 标签等于当前存活的内部版本条数，发布面板展示的只读值就是它，不存在第二份版本来源，也不
+   * 读取平台绑定里的版本号。同一个版本标签可以反复提交，每次提交生成新的 `versionId`。
+   */
+  versionNumber?: number | null;
+  /** 更新送审所需的公开修订号 CAS；来自发布绑定。 */
+  expectedPublicationRevision?: number | null;
+  /**
+   * 发布根幂等键。渲染层默认**不**生成也不持久化它：原生发布链路按
+   * 「账号身份 + 本地项目 + 发行包摘要 + 目标游戏/版本 + 资料摘要」在应用数据里维护发布
+   * 尝试账本，同一份包重发、响应丢失、进程重启与分片续传都落在同一次服务端尝试上。
+   * 只有显式传入（测试或调用方已持有键）时才覆盖账本。
+   */
   idempotencyKey?: string;
 }): Promise<GameDistributionPublishResult> {
   const projectPath = args.projectPath.trim();
@@ -238,18 +326,37 @@ export async function publishLocalProjectGame(args: {
   if (!localProjectId) {
     throw new Error('发布需要本地项目标识，请重新打开项目后再试');
   }
+  const gameId = args.gameId?.trim() ?? '';
+  // 版本标签只有一个来源：调用方显式传入的值优先（发布面板展示的派生值），否则回落到按 AGC
+  // 工程内部版本派生的同一个值。服务端的自动递增路径只服务不传版本号的老客户端。
+  const versionNumber =
+    args.versionNumber ?? resolveGameCreationAppProjectVersion(args.manifest);
+  if (!Number.isSafeInteger(versionNumber) || versionNumber <= 0) {
+    throw new Error('项目版本必须是大于 0 的安全整数');
+  }
+  if (
+    gameId &&
+    (args.expectedPublicationRevision === null ||
+      args.expectedPublicationRevision === undefined)
+  ) {
+    throw new Error('缺少公开修订号，请重新打开发布面板后再试');
+  }
   const gameMetadata = toCreateGameRequest(metadata, localProjectId);
-  const rootKey =
-    args.idempotencyKey?.trim() || createGameDistributionPublishKey();
+  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,
-      idempotencyKey: rootKey,
+      ...(gameId ? { gameId } : {}),
+      versionNumber,
+      ...(gameId
+        ? { expectedPublicationRevision: args.expectedPublicationRevision }
+        : {}),
+      ...(rootKey ? { idempotencyKey: rootKey } : {}),
     },
   );
 }
diff --git a/apps/ai-game-creator-shell/src/services/gamePackageUploadProgress.ts b/apps/ai-game-creator-shell/src/services/gamePackageUploadProgress.ts
new file mode 100644
index 000000000..6fba29b38
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/services/gamePackageUploadProgress.ts
@@ -0,0 +1,116 @@
+import {
+  subscribeTauriEvent,
+  type TauriEventSubscribeOptions,
+  type TauriEventUnsubscribe,
+} from './tauriEventSubscription';
+
+/**
+ * AGC 发布进度事件：Rust 在发布编排的每个阶段回传，渲染层只做展示。
+ *
+ * 事件名与 Rust `game_package_upload::GAME_PACKAGE_UPLOAD_PROGRESS_EVENT` 绑定：
+ * 分片上传的字节进度和「准备 / 上传 / 校验 / 送审」阶段切换走同一条事件，避免两条
+ * 事件流在 UI 上互相覆盖。载荷只含标识、阶段、文案与字节数，不含 token、本地路径
+ * 或整包字节。
+ */
+export const GAME_PACKAGE_UPLOAD_PROGRESS_EVENT =
+  'game-package-upload-progress';
+
+/** Rust 发布编排回传的阶段：准备（建游戏/版本）→ 上传 → 校验 → 送审。 */
+export type GamePublishRuntimePhase =
+  | 'prepare'
+  | 'upload'
+  | 'verify'
+  | 'submit';
+
+export type GamePackageUploadProgressEvent = {
+  versionId: string;
+  /** 本次发布尝试的根幂等键；准备阶段还没有版本标识时只有它可用。 */
+  publishId: string;
+  phase: GamePublishRuntimePhase;
+  message: string;
+  receivedBytes: number;
+  totalBytes: number;
+};
+
+/**
+ * 发布 UI 的完整步骤条：`build` 由渲染层在导出打包阶段点亮（Rust 不 emit 它），
+ * 其余四步来自 `game-package-upload-progress`。
+ */
+export type GamePublishStepId = 'build' | GamePublishRuntimePhase;
+
+export type GamePublishStep = {
+  id: GamePublishStepId;
+  label: string;
+};
+
+export const GAME_PUBLISH_STEPS: readonly GamePublishStep[] = [
+  { id: 'build', label: '构建' },
+  { id: 'prepare', label: '准备' },
+  { id: 'upload', label: '上传' },
+  { id: 'verify', label: '校验' },
+  { id: 'submit', label: '送审' },
+];
+
+const RUNTIME_PHASES: readonly GamePublishRuntimePhase[] = [
+  'prepare',
+  'upload',
+  'verify',
+  'submit',
+];
+
+function readText(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+/** 把事件载荷收敛成渲染层认识的形状；不认识的阶段返回 `null` 由调用方忽略。 */
+export function readGamePackageUploadProgressEvent(
+  payload: unknown,
+): GamePackageUploadProgressEvent | null {
+  if (!payload || typeof payload !== 'object') return null;
+  const record = payload as Record<string, unknown>;
+  const phase = readText(record.phase);
+  if (!RUNTIME_PHASES.includes(phase as GamePublishRuntimePhase)) return null;
+  const readBytes = (value: unknown) =>
+    typeof value === 'number' && Number.isFinite(value) && value > 0
+      ? Math.floor(value)
+      : 0;
+  return {
+    versionId: readText(record.versionId),
+    publishId: readText(record.publishId),
+    phase: phase as GamePublishRuntimePhase,
+    message: readText(record.message),
+    receivedBytes: readBytes(record.receivedBytes),
+    totalBytes: readBytes(record.totalBytes),
+  };
+}
+
+/** 上传百分比（0–100，整数）；没有可换算的总量（非上传阶段）时返回 `null`。 */
+export function computeGamePackageUploadPercent(
+  receivedBytes: number,
+  totalBytes: number,
+): number | null {
+  if (!Number.isFinite(totalBytes) || totalBytes <= 0) return null;
+  if (!Number.isFinite(receivedBytes) || receivedBytes <= 0) return 0;
+  const ratio = Math.min(1, receivedBytes / totalBytes);
+  return Math.round(ratio * 100);
+}
+
+/**
+ * 订阅发布进度事件；载荷无效（阶段不认识）的事件被吞掉，不让 UI 退回错误阶段。
+ *
+ * 与其它 Tauri 事件入口一样，这里在真实 WebView 内走自建登记以避开 tauri 2.11 的
+ * 注销竞态；浏览器预览与 jsdom 里沿用注入的事件桥接或返回空操作。
+ */
+export function subscribeGamePackageUploadProgress(
+  handler: (event: GamePackageUploadProgressEvent) => void,
+  options: TauriEventSubscribeOptions = {},
+): Promise<TauriEventUnsubscribe> {
+  return subscribeTauriEvent<unknown>(
+    GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
+    (event) => {
+      const progress = readGamePackageUploadProgressEvent(event.payload);
+      if (progress) handler(progress);
+    },
+    options,
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index 74d8e5e41..9c2749317 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -3506,12 +3506,27 @@ textarea {
   width: min(520px, 100%);
   max-height: min(760px, calc(100vh - 48px));
   overflow-y: auto;
+  /*
+   * 抽屉自身就是唯一滚动区：滚动条一律不画（用户口径：这条抽屉里的滚动条太丑）。
+   * 滚轮 / 键盘 / 触控板滚动照旧，内容仍可滚到底。
+   *
+   * 不写 `scrollbar-gutter: stable`：实测（CDP，Chromium/WebView2）在
+   * `scrollbar-width: none` 下引擎不会为滚动条预留槽位（预留 0px），所以内容宽度恒定等于
+   * `520 - 2×1px 边框`；也因此不会出现「有滚动条 503px / 无滚动条 518px」这种宽度跳变。
+   */
+  scrollbar-width: none;
   padding: 24px;
   border: 1px solid rgb(104 77 57 / 16%);
   border-radius: 20px;
   box-shadow: 0 24px 80px rgb(74 48 33 / 20%);
 }
 
+/* `scrollbar-width` 只覆盖标准属性；WebView2 里仍要显式关掉 webkit 滚动条（口径同
+   `.image-canvas-editor__floating-toolbar` 与共享 `.scrollbar-hide`）。 */
+.game-distribution-publish-panel::-webkit-scrollbar {
+  display: none;
+}
+
 .game-distribution-publish-panel__header {
   display: flex;
   align-items: flex-start;
@@ -3551,13 +3566,36 @@ textarea {
   margin-top: 18px;
 }
 
-.game-distribution-publish-panel__metadata-hint {
+.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;
@@ -3707,6 +3745,23 @@ textarea {
   line-height: 1.5;
 }
 
+/* 项目版本标签：值就是 AGC 工程内部版本序数（资源总览「项目版本」栏目里最新那张卡的「版本 N」）。 */
+.game-distribution-publish-panel__version-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.game-distribution-publish-panel__version-tag {
+  padding: 1px 8px;
+  border-radius: 999px;
+  background: rgb(168 102 61 / 12%);
+  color: #a8663d;
+  font-size: 11px;
+  font-weight: 800;
+  font-variant-numeric: tabular-nums;
+}
+
 .game-distribution-publish-panel__cover-editor {
   display: grid;
   align-content: start;
@@ -3940,6 +3995,14 @@ textarea {
   line-height: 1.5;
 }
 
+.game-distribution-publish-panel__progress {
+  margin-top: 14px;
+  padding: 12px 14px;
+  border: 1px solid rgb(104 77 57 / 14%);
+  border-radius: 12px;
+  background: rgb(168 102 61 / 6%);
+}
+
 .game-distribution-publish-panel__success {
   margin-top: 18px;
   padding: 16px;
@@ -6212,14 +6275,19 @@ iframe.preview-frame {
   min-height: 48px;
   padding: 8px 12px;
   background: transparent;
+  /* 一行到底：空间不够不再换行，而是按 `data-layout` 降级（顺序与判据见
+   * `view/project-development/workbenchToolbarModel.ts`）。`overflow: hidden` 有两个用处：
+   * 溢出的那一截不会画到对话列上；`scrollWidth` 仍然把溢出的内容算进内容宽度，档位判定靠它。 */
+  flex-wrap: nowrap;
+  overflow: hidden;
 }
 
-/* 左侧控件组：「资源管理 / 运行」分段 + 紧贴其后的「播放」。
+/* 左侧控件组：只剩「资源管理 / 运行」分段（播放并进「运行」页签，见 index.tsx）。
  * 整组在工具条里左对齐，取代播放按钮原先的居中悬浮（absolute + translateX(-50%)）。 */
 .game-workbench-view-tabs {
+  flex: 0 0 auto;
   display: flex;
   align-items: center;
-  flex-wrap: wrap;
   gap: 7px;
 }
 
@@ -6227,10 +6295,16 @@ iframe.preview-frame {
 .game-workbench-view-actions {
   display: flex;
   align-items: center;
-  flex-wrap: wrap;
   gap: 7px;
 }
 
+/* 动作区：宽度够时按内容排布并贴右，不够时由 `min-width: 0` 让出宽度给降级判定
+ * （不设它的话 flex 子项不会缩到内容宽度以下，溢出永远检测不到）。 */
+.game-workbench-view-actions {
+  flex: 0 1 auto;
+  min-width: 0;
+}
+
 .game-workbench-tabs {
   padding: 3px;
   border: 1px solid var(--platform-subpanel-border);
@@ -6239,16 +6313,20 @@ iframe.preview-frame {
 }
 
 .game-resource-sort-tabs {
+  /* 与版本入口同一课：`overflow: hidden` 的 flex 子项可以缩到 0，把溢出「吃掉」，
+   * 顶栏的档位判定就永远量不到真实溢出（实测窄宽度下「依赖 / 类型」被压成 0 宽）。
+   * 这一组不参与收缩。 */
+  flex: 0 0 auto;
   flex-wrap: nowrap;
   gap: 0;
   padding: 0;
   overflow: hidden;
 }
 
-/* 「依赖 / 类型」内部用 0 间距（共享边界的连通分段），但与同一行其他按钮之间必须跟行的间距
- * 一致：这一行是 `gap: 7px` 的 flex 容器，分段控件曾在它里面自带 `padding: 3px`，靠那 3px
- * 把自己和前一枚按钮顶开，于是「整理画布 → 生成任务 → 依赖」的视觉间距只有 10px，
- * 而其余按钮之间是 24px——一行里两套间距。这里把它补到 24px，整行只剩一套间距。 */
+/* 「依赖 / 类型」内部用 0 间距（共享边界的连通分段），但它与同一行其他按钮之间必须跟行的间距
+ * 一致：这一行是 `gap: 7px` 的 flex 容器，分段控件自带 `padding: 3px`，靠那 3px 把自己和前
+ * 一枚按钮顶开，于是相邻间距只有 10px，而其余按钮之间是 24px——一行里两套间距。这里把它补到
+ * 24px，整行只剩一套间距（它与左邻是谁无关：现在左邻是版本入口，此前是「整理画布 / 恢复草稿」）。 */
 .game-workbench-tabs.game-resource-sort-tabs {
   margin-left: 17px;
 }
@@ -6267,7 +6345,8 @@ iframe.preview-frame {
   border-color: transparent;
 }
 
-/* 左侧控件组里的按钮（目前只有「播放」）与分段控件、右侧动作区共用同一套基础外观。 */
+/* 模式分段（含并进来的「运行 ▶」）、动作区按钮（含「更多」里的条目共用同一套基础外观的入口
+ * 那一枚）共用同一套基础外观。 */
 .game-workbench-tabs button,
 .game-workbench-view-tabs button,
 .game-workbench-view-actions button {
@@ -6320,21 +6399,84 @@ iframe.preview-frame {
   color: var(--platform-button-secondary-text);
 }
 
-/* 「播放」与「资源管理 / 运行」同组，外观仍按主按钮走；禁用时退回次级按钮。 */
-.game-workbench-view-tabs .game-workbench-play-button {
-  position: static;
-  border-color: var(--platform-button-primary-border);
-  background: var(--platform-button-primary-fill);
-  color: var(--platform-button-primary-text);
-  transform: none;
+/*
+ * 顶栏降级档位：`data-layout` 由 `useWorkbenchToolbarLayout` 按实测内容宽度写在工具条上，
+ * 取 `full` / `compact-version` / `collapsed-actions`，顺序与判据在 `workbenchToolbarModel`。
+ * 这里只声明每一档「藏什么」——藏起来的是排版，不是信息：可访问名与菜单项都保留完整口径。
+ */
+.game-workbench-toolbar[data-layout='compact-version']
+  .game-run-version-trigger-detail {
+  display: none;
 }
 
-.game-workbench-view-tabs .game-workbench-play-button:disabled {
-  border-color: var(--platform-surface-border);
-  background: var(--platform-button-secondary-fill);
-  color: var(--platform-text-muted);
+/* 「更多」那一档同样只留 `版本 N`：它比 `compact-version` 更窄，没有理由把括号段放回来。 */
+.game-workbench-toolbar[data-layout='collapsed-actions']
+  .game-run-version-trigger-detail {
+  display: none;
+}
+
+/* `打开项目目录 / 资源面板 / 整理画布`：收进「更多」的那一档才藏，且与菜单互为开关——
+ * 默认（未量到宽度、'full'）保持行内形态，与脚本关闭的环境一致。 */
+.game-workbench-toolbar[data-layout='collapsed-actions']
+  .game-workbench-foldable-action {
+  display: none;
+}
+
+/* 「更多」下拉：只在动作收进菜单的那一档出现。 */
+.game-workbench-more-actions {
+  display: none;
+}
+
+.game-workbench-toolbar[data-layout='collapsed-actions']
+  .game-workbench-more-actions {
+  display: inline-flex;
+  align-items: center;
+}
+
+/* 最后一档仍放不下（视口远小于 1280 合同宽度）时改成右对齐：溢出的那一截甩到左边被裁掉，
+ * 而不是把钉在最右的版本入口一起裁没。放得下时这条与 `margin-left: auto` 结果相同。 */
+.game-workbench-toolbar[data-layout='collapsed-actions']
+  .game-workbench-view-actions {
+  justify-content: flex-end;
+}
+
+.game-workbench-more-menu {
+  display: grid;
+  gap: 4px;
+  min-width: 11rem;
+  padding: 6px;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 10px;
+  background: var(--platform-subpanel-fill);
+  box-shadow: 0 16px 34px rgb(75 47 32 / 18%);
+  z-index: 80;
+}
+
+.game-workbench-more-menu button {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  min-height: 34px;
+  gap: 8px;
+  padding: 0 9px;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: var(--platform-text-strong);
+  font-size: 12px;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+.game-workbench-more-menu button:hover,
+.game-workbench-more-menu button:focus-visible {
+  background: var(--platform-nav-item-hover-fill);
+  outline: 0;
+}
+
+.game-workbench-more-menu button:disabled {
   cursor: not-allowed;
-  opacity: 0.6;
+  opacity: 0.45;
 }
 
 .game-workbench-view-actions .game-workbench-inspect-button.is-active {
@@ -8098,6 +8240,23 @@ iframe.preview-frame {
   -webkit-line-clamp: 3;
 }
 
+/*
+ * 最新内部版本卡的中性角标。只出现在 `versions[]` 最后一条上：不写「发布标签」，
+ * 因为发布固定取最新内部版本、不需要用户在卡上挑；选中态另有一套「当前版本素材」口径。
+ * 形制沿用卡面既有的中性 pill（与 `.game-resource-card-engine-label` 同族）。
+ */
+.game-resource-card-version-latest-tag {
+  padding: 1px 7px;
+  border: 1px solid rgb(139 91 69 / 28%);
+  border-radius: 999px;
+  background: rgb(255 255 255 / 72%);
+  color: #8b5b45;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  white-space: nowrap;
+}
+
 .game-resource-card-version-relations {
   color: #8e6f62;
   font-size: 9px;
@@ -8679,18 +8838,46 @@ iframe.preview-frame {
   flex: 0 0 auto;
   display: inline-flex;
   align-items: center;
+  /* 固定在最右：它是动作区的最后一枚，且行内空间富余时贴右缘（`margin-left: auto` 吃掉
+   * 左侧所有剩余空间）。空间不够时它自己先收成 `版本 N`（`data-layout` 档位），
+   * 而不是被换行甩到第二行。 */
+  margin-left: auto;
 }
 
 .game-run-version-trigger {
   max-width: min(18rem, 60vw);
+  /* 默认**不参与收缩**（`max-content`）：收缩 + 省略号会把溢出「吃掉」，让顶栏的档位判定
+   * （`workbenchToolbarModel`）永远量不到真实溢出——窄到该降档时它却原地把版本名截断。
+   * 只有降到最后一档、动作已经全收进「更多」时才允许它省略兜底（见下面那条选择器）。 */
+  min-width: max-content;
+}
+
+.game-workbench-toolbar[data-layout='collapsed-actions']
+  .game-run-version-trigger {
   min-width: 0;
 }
 
 /*
  * 版本名单独一层才省得掉：按钮是 flex 容器，文本直接挂在按钮上时 `text-overflow`
  * 落在匿名 flex item 上、不生效（见 `GameRunVersionPicker` 里的注释）。
+ * 层里再分「序号」与「括号那一截」两层：窄宽度收掉的是后者（`display: none`），
+ * 序号永远留着。
  */
 .game-run-version-trigger-label {
+  display: inline-flex;
+  align-items: baseline;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.game-run-version-trigger-title {
+  flex: 0 0 auto;
+}
+
+.game-run-version-trigger-detail {
+  flex: 0 1 auto;
   min-width: 0;
   overflow: hidden;
   text-overflow: ellipsis;
@@ -8757,13 +8944,13 @@ iframe.preview-frame {
 }
 
 /*
- * 画面右下角的「全屏预览」。压在游戏画面上，所以用深色半透明底 + 白图标：任何游戏配色下都
- * 看得清，也不在画面中间抢位置。全屏那一格还是它自己（`:fullscreen` 铺满屏幕），所以这枚按钮
- * 在全屏里照旧可用，用户点它就能退出来。
+ * 画面右下角两枚浮起控件：「刷新运行画面」（左）与「全屏预览」（右）。压在游戏画面上，所以用
+ * 深色半透明底 + 白图标：任何游戏配色下都看得清，也不在画面中间抢位置。全屏那一格还是它自己
+ * （`:fullscreen` 铺满屏幕），所以两枚按钮在全屏里照旧可用——刷新照旧刷画面，点全屏那枚就退出。
  */
-.game-run-preview-fullscreen {
+.game-run-preview-fullscreen,
+.game-run-preview-refresh {
   position: absolute;
-  right: 10px;
   bottom: 10px;
   z-index: 2;
   display: inline-flex;
@@ -8779,8 +8966,18 @@ iframe.preview-frame {
   backdrop-filter: blur(6px);
 }
 
+.game-run-preview-refresh {
+  right: 50px;
+}
+
+.game-run-preview-fullscreen {
+  right: 10px;
+}
+
 .game-run-preview-fullscreen:hover,
-.game-run-preview-fullscreen:focus-visible {
+.game-run-preview-fullscreen:focus-visible,
+.game-run-preview-refresh:hover,
+.game-run-preview-refresh:focus-visible {
   background: rgb(12 14 20 / 84%);
   outline: 0;
 }
@@ -9921,6 +10118,94 @@ iframe.preview-frame {
   box-shadow: 0 0 0 3px rgb(199 101 61 / 28%);
 }
 
+/* 发布阶段步骤条：构建 → 准备 → 上传 → 校验 → 送审。 */
+.game-publish-phase {
+  display: grid;
+  gap: 10px;
+  width: 100%;
+}
+
+.game-publish-phase__steps {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 6px 8px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.game-publish-phase__step {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 10px;
+  border: 1px solid rgb(104 77 57 / 16%);
+  border-radius: 999px;
+  color: var(--platform-text-muted);
+  font-size: 11px;
+  font-weight: 600;
+  list-style: none;
+}
+
+.game-publish-phase__step.is-done {
+  border-color: rgb(51 125 87 / 26%);
+  color: #337d57;
+}
+
+.game-publish-phase__step.is-active {
+  border-color: #a8663d;
+  background: rgb(168 102 61 / 10%);
+  color: #a8663d;
+}
+
+.game-publish-phase__marker {
+  display: grid;
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  background: rgb(104 77 57 / 10%);
+  font-size: 10px;
+  place-items: center;
+}
+
+.game-publish-phase__step.is-done .game-publish-phase__marker {
+  background: rgb(51 125 87 / 14%);
+}
+
+.game-publish-phase__step.is-active .game-publish-phase__marker {
+  background: #a8663d;
+  color: #fff;
+}
+
+.game-publish-phase__percent {
+  font-variant-numeric: tabular-nums;
+  font-weight: 800;
+}
+
+.game-publish-phase__bar {
+  overflow: hidden;
+  width: 100%;
+  height: 6px;
+  border-radius: 999px;
+  background: rgb(104 77 57 / 12%);
+}
+
+.game-publish-phase__bar > span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: #c7653d;
+  transition: width 0.2s ease;
+}
+
+.game-publish-phase__message {
+  margin: 0;
+  color: #8f7367;
+  font-size: 12px;
+  line-height: 1.5;
+}
+
 .game-approval-backdrop {
   position: fixed;
   top: var(--window-chrome-height);
@@ -10209,15 +10494,6 @@ iframe.preview-frame {
   .game-workbench-layout {
     grid-template-columns: minmax(0, 1fr) minmax(280px, 0.42fr);
   }
-
-  .game-workbench-toolbar {
-    align-items: stretch;
-    flex-direction: column;
-  }
-
-  .game-workbench-view-actions {
-    justify-content: flex-end;
-  }
 }
 
 @media (max-width: 760px) {
@@ -10242,17 +10518,6 @@ iframe.preview-frame {
     border-left: 0;
   }
 
-  .game-workbench-toolbar,
-  .game-workbench-view-actions {
-    align-items: stretch;
-    flex-direction: column;
-  }
-
-  .game-workbench-tabs {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
   .game-resource-section {
     min-width: 460px;
   }
@@ -12415,17 +12680,15 @@ button.design-workspace-tree__entry:hover,
   white-space: nowrap;
 }
 
+/* 组头 chevron 只保留外层定位与过渡；**换向唯一来源**是共享 `AgentProcessSummary` 的
+   `[aria-expanded='true'] > .agent-process-summary .agent-process-summary-chevron`。
+   这里若再写一条 `rotate(180deg)`，会与 wrapper 的旋转叠加成 360°，展开态看起来仍是朝下。 */
 .agent-tool-call-group-chevron {
   flex: 0 0 auto;
   color: inherit;
   transition: transform 120ms ease;
 }
 
-.agent-tool-call-group-head[aria-expanded='true']
-  .agent-tool-call-group-chevron {
-  transform: rotate(180deg);
-}
-
 /* `hidden` 必须压过下面的 `display: grid`，否则折叠态只是内容不可见却仍占位。 */
 .agent-tool-call-group-body[hidden],
 .agent-tool-call-row-detail[hidden] {
diff --git a/apps/ai-game-creator-shell/src/view/project-development/WorkbenchMoreActionsMenu.tsx b/apps/ai-game-creator-shell/src/view/project-development/WorkbenchMoreActionsMenu.tsx
new file mode 100644
index 000000000..13a8a93a7
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/project-development/WorkbenchMoreActionsMenu.tsx
@@ -0,0 +1,111 @@
+import { MoreHorizontal } from 'lucide-react';
+import { type ReactNode, useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+
+import { useImageCanvasFloatingOptionDismiss } from '../../../../../src/components/image-editor/useImageCanvasFloatingOptionDismiss';
+
+export type WorkbenchMoreAction = {
+  key: string;
+  label: string;
+  /** 与内联形态同一枚图标：菜单里逐条重画，不新造一套语义。 */
+  icon: ReactNode;
+  disabled?: boolean;
+  onSelect: () => void;
+};
+
+/**
+ * 顶栏动作的「更多」下拉：窄宽度下 `打开项目目录 / 资源面板 / 整理画布` 的收容处。
+ *
+ * 只在顶栏落到 `collapsed-actions` 档时由 CSS 显示（见 `styles.css` 里的 `[data-layout]`
+ * 选择器），档位判据在 `workbenchToolbarModel`。菜单 portal 到 `document.body` 并每次渲染
+ * 按触发钮的实时 rect 定位：顶栏会随对话列收放横移，菜单挂在按钮旁边而不是挂在某个坐标上。
+ */
+export function WorkbenchMoreActionsMenu({
+  actions,
+}: {
+  readonly actions: readonly WorkbenchMoreAction[];
+}) {
+  const [open, setOpen] = useState(false);
+  const rootRef = useRef<HTMLDivElement>(null);
+  const menuRef = useRef<HTMLDivElement>(null);
+  // 定位每次渲染都按触发钮实时 rect 重算；滚动 / 缩放后必须重算，否则 fixed 定位的菜单会漂在
+  // 旧位置上。用一个 tick 驱动重算，「打开当帧就有菜单」的时序不变。
+  const [, setMenuAnchorTick] = useState(0);
+  useEffect(() => {
+    if (!open) return undefined;
+    const refreshMenuAnchor = () => setMenuAnchorTick((tick) => tick + 1);
+    window.addEventListener('scroll', refreshMenuAnchor, true);
+    window.addEventListener('resize', refreshMenuAnchor);
+    return () => {
+      window.removeEventListener('scroll', refreshMenuAnchor, true);
+      window.removeEventListener('resize', refreshMenuAnchor);
+    };
+  }, [open]);
+
+  // 菜单在 `rootRef` 子树外的 portal 里，必须一起登记成「点这里不算外部」，否则落在菜单项上的
+  // 那一下会被当成点外部，菜单在选项收到 click 之前就被收掉。
+  useImageCanvasFloatingOptionDismiss({
+    isOpen: open,
+    boundaryRefs: [rootRef, menuRef],
+    onDismiss: () => setOpen(false),
+  });
+
+  if (actions.length === 0) {
+    return null;
+  }
+
+  return (
+    <div ref={rootRef} className="game-workbench-more-actions">
+      <button
+        type="button"
+        className="game-workbench-more-trigger"
+        aria-haspopup="menu"
+        aria-expanded={open}
+        aria-label="更多项目操作"
+        onClick={() => setOpen((current) => !current)}
+      >
+        <MoreHorizontal size={15} aria-hidden="true" />
+        更多
+      </button>
+      {open
+        ? createPortal(
+            <div
+              ref={menuRef}
+              className="game-workbench-more-menu"
+              role="menu"
+              aria-label="更多项目操作"
+              style={{
+                position: 'fixed',
+                top: rootRef.current
+                  ? `${rootRef.current.getBoundingClientRect().bottom + 6}px`
+                  : '0',
+                left: rootRef.current
+                  ? `${Math.max(
+                      8,
+                      rootRef.current.getBoundingClientRect().left,
+                    )}px`
+                  : '0',
+              }}
+            >
+              {actions.map((action) => (
+                <button
+                  key={action.key}
+                  type="button"
+                  role="menuitem"
+                  disabled={action.disabled}
+                  onClick={() => {
+                    setOpen(false);
+                    action.onSelect();
+                  }}
+                >
+                  {action.icon}
+                  {action.label}
+                </button>
+              ))}
+            </div>,
+            document.body,
+          )
+        : null}
+    </div>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/view/project-development/index.tsx b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
index 50e0c00dc..7ed5989c5 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/index.tsx
+++ b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
@@ -46,6 +46,7 @@ import {
   Redo2,
   Replace,
   RotateCcw,
+  RotateCw,
   Search,
   Shapes,
   SlidersHorizontal,
@@ -443,6 +444,11 @@ import {
 import { useProjectResourceCardPreviews } from './useProjectResourceCardPreviews';
 import { useProjectResourceSectionHeights } from './useProjectResourceSectionHeights';
 import { useResourceAssetDeleteFlow } from './useResourceAssetDeleteFlow';
+import { useWorkbenchToolbarLayout } from './useWorkbenchToolbarLayout';
+import {
+  type WorkbenchMoreAction,
+  WorkbenchMoreActionsMenu,
+} from './WorkbenchMoreActionsMenu';
 
 export type {
   ProjectAgentResultSummary,
@@ -1291,9 +1297,15 @@ const ResourceCard = memo(function ResourceCard({
       );
     }
     if (kind === 'version') {
+      // 角标只写「最新」：发布固定取最新内部版本，卡面不写「发布标签」；
+      // 否则用户会以为"挑中哪张卡就发哪张"，而选中态只影响「当前版本素材」与运行用哪版播放。
+      const isLatestVersion = resource.version?.publicationTag !== undefined;
       return (
         <span className="game-resource-card-version-visual">
           <Gamepad2 size={34} aria-hidden="true" />
+          {isLatestVersion ? (
+            <span className="game-resource-card-version-latest-tag">最新</span>
+          ) : null}
           <span className="game-resource-card-version-relations">
             {resource.version?.childVersionIds.length
               ? `${resource.version.childVersionIds.length} 个直接子版本`
@@ -1831,6 +1843,12 @@ export default function ProjectDevelopmentView({
   // 运行画面的「全屏预览」：全屏的是画面那一格（`.game-run-preview`），不是整块工作台，
   // 所以按钮与 ref 都归运行表现层自己持有。
   const runPreviewFullscreen = useElementFullscreen<HTMLDivElement>();
+  // 「刷新运行画面」的载入次数：递增一次＝换 iframe 的元素身份＝重新载入运行页面。
+  const [runPreviewReloadNonce, setRunPreviewReloadNonce] = useState(0);
+  // 顶栏按实测宽度自己在三档之间退（见 `workbenchToolbarModel`）：档位只写在 DOM 属性上，
+  // 不参与 React 状态。
+  const workbenchToolbarRef = useRef<HTMLDivElement>(null);
+  useWorkbenchToolbarLayout(workbenchToolbarRef);
   const [resourceBookState, dispatchResourceBook] = useReducer(
     resourceBookReducer,
     initialResourceBookState,
@@ -2783,6 +2801,17 @@ export default function ProjectDevelopmentView({
       });
     }
   }, [embeddedPreviewUrl, onNotice]);
+  /**
+   * 「刷新运行画面」：先把预览确认成活的（`onPlay` 命中活体预览只切视图、不重启服务），再换一次
+   * iframe 的元素身份把页面重新载入。
+   *
+   * 游戏预览不是 vite dev 的实时刷新，改完代码只有重载页面才看得到新一版；以前只能靠切到资源
+   * 管理再切回来，这一枚把同一个动作放回运行画面本身。
+   */
+  const refreshRunPreview = useCallback(() => {
+    onPlay?.();
+    setRunPreviewReloadNonce((current) => current + 1);
+  }, [onPlay]);
   const runAvailable =
     embeddedPreviewUrl !== null ||
     manifest.tasks.some(
@@ -2793,6 +2822,29 @@ export default function ProjectDevelopmentView({
       setRuntimeInspectMode(false);
     }
   }, [embeddedPreviewUrl, mode]);
+
+  /**
+   * 站在运行视图上却没有画面可看时，自动按一次「运行」。
+   *
+   * 「运行」页签就是播放入口，但**进入项目**这条路上用户可能一进来就站在运行页：从别的项目
+   * 切过来时工作台不重挂（`mode` 是工作台自己的 state），上一条项目的运行视图会原样留下，
+   * 画面却已经没了；此时页面上只有一句「点击顶部「运行」页签」，看起来就是坏的。这里把缺的那
+   * 一下自动补上——只在**没有画面**时发，画面还在就不重复启动。
+   *
+   * 记账用 ref 而不是 state：`showRunView`（用户点页签）会先记上再自己发一次播放，这里就不会
+   * 跟着重复发；同一个项目只自动发一次，失败后不打转，手动重跑仍走页签或画面上的刷新按钮。
+   */
+  const autoRunPreviewProjectRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (mode !== 'run' || embeddedPreviewUrl || !runAvailable || !onPlay) {
+      return;
+    }
+    if (autoRunPreviewProjectRef.current === projectPath) {
+      return;
+    }
+    autoRunPreviewProjectRef.current = projectPath;
+    onPlay();
+  }, [embeddedPreviewUrl, mode, onPlay, projectPath, runAvailable]);
   const handleRuntimeInspectSelection = useCallback(
     (selection: LocalGamePreviewInspectSelection) => {
       const sourceName = selection.sourcePath?.split('/').pop()?.toLowerCase();
@@ -7341,6 +7393,17 @@ export default function ProjectDevelopmentView({
     uiEditorRoute,
   ]);
 
+  /**
+   * 切到运行视图**并载入游戏**：原来的「播放」按钮合并进「运行」页签，两者本来就是同一件事
+   * （切视图 + 启动本地预览）。页签因此在不可运行时不置灰、只给提示（见 `run-unavailable-hint`），
+   * 点了不切视图也不发播放请求。
+   *
+   * 这里记一次账（`autoRunPreviewProjectRef`）再发播放：下一条 effect 会在「运行视图 + 没有
+   * 画面」时自动补发，不记账就会跟着重复发一次。
+   *
+   * 自动切运行那两条路径（会话内已确认的预览、播放请求）不走这里，它们只是**呈现**运行结果，
+   * 不该再发起一次播放。
+   */
   function showRunView() {
     if (!runAvailable || uiEditorRoute) {
       return;
@@ -7354,6 +7417,8 @@ export default function ProjectDevelopmentView({
     captureResourceSectionScrollPositions();
     stopActiveCardMedia();
     setMode('run');
+    autoRunPreviewProjectRef.current = projectPath;
+    onPlay?.();
   }
 
   const showRunUnavailableHint = !runAvailable && !uiEditorRoute;
@@ -9582,6 +9647,54 @@ export default function ProjectDevelopmentView({
     ],
   );
 
+  /**
+   * 「整理画布」的可用判据：布局还没读出来，或当前范围里一个素材都没有时不放行。行内按钮与
+   * 「更多」里的同一条动作共用这一份，别在两处各写一遍。
+   */
+  const resourceCanvasOrganizeDisabled =
+    !resourceLayoutReady ||
+    (resourceOrganizeSections !== null &&
+      resourceOrganizeSections.length === 0);
+
+  /**
+   * 顶栏动作区里可被「更多」下拉收容的三枚动作，与行内形态是**同一批动作**：出现条件与禁用
+   * 口径必须一起改（行内按钮见 `game-workbench-foldable-action`）。
+   */
+  const workbenchMoreActionCandidates: Array<WorkbenchMoreAction | null> = [
+    onRevealProjectDirectory
+      ? {
+          key: 'reveal-project-directory',
+          label: '打开项目目录',
+          icon: <FolderOpen size={15} aria-hidden="true" />,
+          onSelect: () => void onRevealProjectDirectory(),
+        }
+      : null,
+    mode === 'resources' && !uiEditorRoute
+      ? {
+          key: 'resource-panel',
+          label: '资源面板',
+          icon: <FolderTree size={15} aria-hidden="true" />,
+          disabled: canvasResources.length === 0,
+          onSelect: () => {
+            setResourcePanelNotice('');
+            setResourcePanelOpen((current) => !current);
+          },
+        }
+      : null,
+    mode === 'resources' && !uiEditorRoute
+      ? {
+          key: 'organize-canvas',
+          label: '整理画布',
+          icon: <LayoutGrid size={15} aria-hidden="true" />,
+          disabled: resourceCanvasOrganizeDisabled,
+          onSelect: organizeResourceCanvasLayout,
+        }
+      : null,
+  ];
+  const workbenchMoreActions = workbenchMoreActionCandidates.filter(
+    (action): action is WorkbenchMoreAction => action !== null,
+  );
+
   if (planningStartMode) {
     return (
       <section
@@ -9638,11 +9751,11 @@ export default function ProjectDevelopmentView({
               : undefined
           }
         >
-          <div className="game-workbench-toolbar">
+          <div className="game-workbench-toolbar" ref={workbenchToolbarRef}>
             {/*
-              「资源管理 / 运行」与「播放」是同一组左侧控件：播放紧贴模式切换之后、整组左对齐，
-              不再居中悬浮。**两个页签下都常驻**——运行视图空态与预览失败态都要靠它重跑
-              （空态文案就是「点击顶部播放按钮后将在这里直接运行游戏」）。
+              左侧只剩模式切换：「资源管理 / 运行」。**运行页签本身就是播放入口**（前面带 ▶）：
+              切过去即按「播放」载入游戏资源，不再单开一枚「播放」按钮——两枚入口说的是同一件事，
+              并排只会把右侧动作区挤到第二行。运行视图空态与预览失败态都靠再点一次这枚页签重跑。
             */}
             <div className="game-workbench-view-tabs">
               <div className="game-workbench-tabs" role="tablist">
@@ -9670,30 +9783,22 @@ export default function ProjectDevelopmentView({
                   disabled={uiEditorRoute !== null}
                   onClick={showRunView}
                 >
+                  <Play size={14} aria-hidden="true" />
                   运行
                 </button>
               </div>
-              <button
-                type="button"
-                className="game-workbench-play-button"
-                disabled={!runAvailable || !onPlay || uiEditorRoute !== null}
-                onClick={() => {
-                  showRunView();
-                  onPlay?.();
-                }}
-                title={
-                  runAvailable ? '运行当前游戏' : '首个可运行原型完成后才能播放'
-                }
-              >
-                <Play size={15} aria-hidden="true" />
-                播放
-              </button>
             </div>
             <div className="game-workbench-view-actions">
+              {/*
+                窄宽度收容：`打开项目目录 / 资源面板 / 整理画布` 在顶栏掉到 `collapsed-actions`
+                档时改从这里进（宽的时候仍是行内按钮）。档位顺序与判据在
+                `workbenchToolbarModel`；两处渲染的是同一批动作，出现条件与禁用口径要一起改。
+              */}
+              <WorkbenchMoreActionsMenu actions={workbenchMoreActions} />
               {onRevealProjectDirectory ? (
                 <button
                   type="button"
-                  className="game-workbench-resource-panel-button"
+                  className="game-workbench-resource-panel-button game-workbench-foldable-action"
                   aria-label="打开项目目录"
                   onClick={() => void onRevealProjectDirectory()}
                 >
@@ -9739,7 +9844,7 @@ export default function ProjectDevelopmentView({
                 <>
                   <button
                     type="button"
-                    className="game-workbench-resource-panel-button"
+                    className="game-workbench-resource-panel-button game-workbench-foldable-action"
                     aria-expanded={resourcePanelOpen}
                     disabled={canvasResources.length === 0}
                     onClick={() => {
@@ -9764,12 +9869,9 @@ export default function ProjectDevelopmentView({
                   */}
                   <button
                     type="button"
+                    className="game-workbench-foldable-action"
                     aria-label="整理画布"
-                    disabled={
-                      !resourceLayoutReady ||
-                      (resourceOrganizeSections !== null &&
-                        resourceOrganizeSections.length === 0)
-                    }
+                    disabled={resourceCanvasOrganizeDisabled}
                     aria-busy={resourceLayoutSaving}
                     onClick={organizeResourceCanvasLayout}
                   >
@@ -9798,32 +9900,6 @@ export default function ProjectDevelopmentView({
                       })}
                     </button>
                   ) : null}
-                  <div
-                    className="game-workbench-tabs game-resource-sort-tabs"
-                    role="group"
-                    aria-label="资源排列方式"
-                  >
-                    <button
-                      type="button"
-                      className={sortMode === 'dependency' ? 'is-active' : ''}
-                      aria-label="按依赖"
-                      aria-pressed={sortMode === 'dependency'}
-                      onClick={() => showResourceSortMode('dependency')}
-                    >
-                      <FolderTree size={15} aria-hidden="true" />
-                      依赖
-                    </button>
-                    <button
-                      type="button"
-                      className={sortMode === 'type' ? 'is-active' : ''}
-                      aria-label="按类型"
-                      aria-pressed={sortMode === 'type'}
-                      onClick={() => showResourceSortMode('type')}
-                    >
-                      <ListFilter size={15} aria-hidden="true" />
-                      类型
-                    </button>
-                  </div>
                 </>
               ) : null}
               {/*
@@ -9841,6 +9917,39 @@ export default function ProjectDevelopmentView({
                   onSelectVersion={selectActiveVersion}
                 />
               )}
+              {/*
+                排序分段（依赖 / 类型）收在**行尾**：它与左侧「资源管理 / 运行」是顶栏里两枚体量
+                最大的分组控件，分居这一行的两端；版本入口紧邻它左侧（用户口径：「版本应该在
+                依赖 / 类型左边」），所以版本入口不放在最右。
+              */}
+              {mode === 'resources' && !uiEditorRoute ? (
+                <div
+                  className="game-workbench-tabs game-resource-sort-tabs"
+                  role="group"
+                  aria-label="资源排列方式"
+                >
+                  <button
+                    type="button"
+                    className={sortMode === 'dependency' ? 'is-active' : ''}
+                    aria-label="按依赖"
+                    aria-pressed={sortMode === 'dependency'}
+                    onClick={() => showResourceSortMode('dependency')}
+                  >
+                    <FolderTree size={15} aria-hidden="true" />
+                    依赖
+                  </button>
+                  <button
+                    type="button"
+                    className={sortMode === 'type' ? 'is-active' : ''}
+                    aria-label="按类型"
+                    aria-pressed={sortMode === 'type'}
+                    onClick={() => showResourceSortMode('type')}
+                  >
+                    <ListFilter size={15} aria-hidden="true" />
+                    类型
+                  </button>
+                </div>
+              ) : null}
             </div>
             {/*
               布局状态提示**不进动作行**：它是一段随保存过程变长的文案（空 →「保存中」→
@@ -11023,6 +11132,7 @@ export default function ProjectDevelopmentView({
                     title={`${projectName} 游戏运行画面`}
                     preview={preview}
                     inspectMode={runtimeInspectMode}
+                    reloadNonce={runPreviewReloadNonce}
                     onInspectSelection={handleRuntimeInspectSelection}
                     onInspectExit={() => setRuntimeInspectMode(false)}
                   />
@@ -11030,9 +11140,25 @@ export default function ProjectDevelopmentView({
                   <div className="game-run-preview-empty">
                     <Sparkles size={28} aria-hidden="true" />
                     <strong>客户端运行画面尚未载入</strong>
-                    <span>点击顶部播放按钮后将在这里直接运行游戏</span>
+                    <span>点击顶部「运行」页签后将在这里直接运行游戏</span>
                   </div>
                 )}
+                {/*
+                  刷新运行画面：贴在画面右下角、全屏那一枚的左边。游戏预览不是 vite dev 的实时
+                  刷新，改完代码要看到新一版只有重载页面这一条路（以前得切到资源管理再切回来）。
+                  没有活预览时不渲染——那时该走的是顶栏「运行」页签。
+                */}
+                {embeddedPreviewUrl ? (
+                  <button
+                    type="button"
+                    className="game-run-preview-refresh"
+                    aria-label="刷新运行画面"
+                    title="重新载入运行画面（游戏不是实时刷新，改完代码用这一枚重载）"
+                    onClick={refreshRunPreview}
+                  >
+                    <RotateCw size={16} aria-hidden="true" />
+                  </button>
+                ) : null}
                 {/*
                   全屏预览：贴在画面右下角。**只有画面这一格进全屏**——顶部页签、右侧对话与
                   底部信息栏都不跟着放大，符合「预览画面」而不是「全屏应用」。没有活预览时不渲染，
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
index 97ba9a92b..3c2b47a49 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
@@ -114,6 +114,11 @@ export type ResourceCanvasItem = {
   label: string;
   mediaType: string;
   dependencyDepth: number;
+  /**
+   * 栏目内显式次序键（可选）。同层落位先按它升序，缺省时退回 opaque `id`：
+   * 资源 id 只是标识，只有自带线性序的资源（如「项目版本」的 `版本 N`）才给这个键。
+   */
+  orderIndex?: number;
   cardSize?: ResourceCanvasCardSize;
 };
 
@@ -408,6 +413,24 @@ function compareStableIdentifier(left: string, right: string) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+/**
+ * 同层内的落位次序：先按资源自带的显式次序键 `orderIndex`，缺省视为同一序，再退回 opaque id。
+ *
+ * 资源 id 只是标识（`version:{versionId}` 里的 versionId 是 `initial-*` / `agent-*`），
+ * 拿它当次序会让「项目版本」栏目排成 `agent-*` 在前、`initial-*` 在后 —— 与卡面
+ * `版本 N`（内部版本序数）不一致，也看不出哪张是最新版本。只有声明了显式次序的资源
+ * （当前就是项目版本）受影响，其余资源一律保持原有的 id 序，落位逐值不变。
+ */
+function compareResourceOrder(
+  resourceById: ReadonlyMap<string, ResourceCanvasItem>,
+  leftId: string,
+  rightId: string,
+) {
+  const leftOrder = resourceById.get(leftId)?.orderIndex ?? 0;
+  const rightOrder = resourceById.get(rightId)?.orderIndex ?? 0;
+  return leftOrder - rightOrder || compareStableIdentifier(leftId, rightId);
+}
+
 function compareResources(
   mode: ProjectResourceCanvasLayoutMode,
   left: ResourceCanvasItem,
@@ -423,6 +446,9 @@ function compareResources(
   return (
     compareStableIdentifier(left.subtype, right.subtype) ||
     compareStableIdentifier(left.mediaType, right.mediaType) ||
+    // 自带显式次序的资源（项目版本）先按序数：卡面 `版本 N` 按字符串比会在 10 版之后错位
+    // （`版本 10` 排在 `版本 2` 前）。没有序键的资源一律退回原有的标签序。
+    (left.orderIndex ?? 0) - (right.orderIndex ?? 0) ||
     left.label.localeCompare(right.label, 'zh-CN') ||
     compareStableIdentifier(left.id, right.id)
   );
@@ -817,7 +843,11 @@ function sortDependencyBucket(
     }
     return (
       left.previousRank - right.previousRank ||
-      compareStableIdentifier(left.minimumResourceId, right.minimumResourceId)
+      compareResourceOrder(
+        resourceById,
+        left.minimumResourceId,
+        right.minimumResourceId,
+      )
     );
   });
   resourceIds.splice(
@@ -828,7 +858,7 @@ function sortDependencyBucket(
         (left, right) =>
           (rankByResourceId.get(left) ?? 0) -
             (rankByResourceId.get(right) ?? 0) ||
-          compareStableIdentifier(left, right),
+          compareResourceOrder(resourceById, left, right),
       ),
     ),
   );
@@ -977,7 +1007,7 @@ function dependencyAutomaticPositions(
     .filter((component) => !component.related)
     .flatMap((component) => component.resourceIds)
     .filter((resourceId) => automaticIds.has(resourceId))
-    .sort(compareStableIdentifier);
+    .sort((left, right) => compareResourceOrder(resourceById, left, right));
 
   const clusters: DependencyCluster[] = [];
   for (const component of relatedComponents) {
@@ -1058,7 +1088,9 @@ function dependencyAutomaticPositions(
       idsByDepth.set(resource.dependencyDepth, ids);
     }
     for (const [depth, resourceIds] of idsByDepth) {
-      resourceIds.sort(compareStableIdentifier);
+      resourceIds.sort((left, right) =>
+        compareResourceOrder(resourceById, left, right),
+      );
       const grid = dependencyLayerGrid(resourceIds, cardSizeByResourceId);
       gridByBucket.set(resourceIds, grid);
       // 层内 rank 用"网格行号"，同一行的相邻卡共享纵向位置，跨层中位数对齐仍然成立。
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
index b30c063d6..9182d0225 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
@@ -32,6 +32,15 @@ export type ProjectAgentResultSummary = {
 export type ProjectVersionResourceSummary = GameIterationVersion & {
   label: string;
   childVersionIds: string[];
+  /**
+   * 只有**最新内部版本**（`manifest.versions` 最后一条）带它，值是内部版本序数
+   * （= `versions.length`，也就是发布时会提交的那个标签，与发布面板的
+   * `resolveGameCreationAppProjectVersion` 同源）。
+   *
+   * 卡面据此只渲染**中性**的「最新」角标：发布固定取最新内部版本，卡面不把它写成
+   * 「发布标签」，免得诱导用户以为要挑一张卡才能发。
+   */
+  publicationTag?: number;
 };
 
 export type ProjectResource = {
@@ -49,6 +58,15 @@ export type ProjectResource = {
   referenceResourceIds: string[];
   dependencies: string[];
   dependencyDepth: number;
+  /**
+   * 栏目内显式次序键：同类同层资源按它升序落位，缺省时退回 opaque 资源 id。
+   *
+   * 「项目版本」卡必须带它：卡面 `版本 N` 就是 AGC 内部版本序数（= `manifest.versions`
+   * 的下标 + 1，也是发布面板取的标签），而版本资源 id 是 `version:{versionId}`，
+   * versionId 又是 `initial-*` / `agent-*` 这类 opaque 标识。按 id 排会把初始版本
+   * （`initial-*` 字符串序大于 `agent-*`）排到最后，与卡面序号和「最新版本」都对不上。
+   */
+  orderIndex?: number;
   content?: string;
   version?: ProjectVersionResourceSummary;
   /**
@@ -497,8 +515,9 @@ export function projectResourcesFromReadModels(
     });
   }
 
+  const manifestVersions = manifest.versions ?? [];
   const childVersionIdsByParent = new Map<string, string[]>();
-  for (const version of manifest.versions ?? []) {
+  for (const version of manifestVersions) {
     if (!version.parentVersionId) {
       continue;
     }
@@ -506,12 +525,17 @@ export function projectResourcesFromReadModels(
     children.push(version.versionId);
     childVersionIdsByParent.set(version.parentVersionId, children);
   }
-  for (const [index, manifestVersion] of (manifest.versions ?? []).entries()) {
+  for (const [index, manifestVersion] of manifestVersions.entries()) {
     const version: ProjectVersionResourceSummary = {
       ...manifestVersion,
       label: `版本 ${index + 1}`,
       childVersionIds:
         childVersionIdsByParent.get(manifestVersion.versionId) ?? [],
+      // 最新内部版本 = 数组最后一条 = 发布时会提交的标签（`versions.length`）。
+      // 只有它带 `publicationTag`：卡面据此只渲染中性的「最新」角标。
+      ...(index === manifestVersions.length - 1
+        ? { publicationTag: index + 1 }
+        : {}),
     };
     resources.push({
       id: `version:${version.versionId}`,
@@ -530,6 +554,8 @@ export function projectResourcesFromReadModels(
       referenceResourceIds: [],
       dependencies: [],
       dependencyDepth: 0,
+      // 显示次序 = `manifest.versions` 下标 = 卡面 `版本 N` 的序号 = 发布面板取的标签。
+      orderIndex: index,
       version,
     });
   }
diff --git a/apps/ai-game-creator-shell/src/view/project-development/useWorkbenchToolbarLayout.ts b/apps/ai-game-creator-shell/src/view/project-development/useWorkbenchToolbarLayout.ts
new file mode 100644
index 000000000..64a6f1f7c
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/project-development/useWorkbenchToolbarLayout.ts
@@ -0,0 +1,87 @@
+import { type RefObject, useLayoutEffect } from 'react';
+
+import {
+  resolveWorkbenchToolbarLayout,
+  type WorkbenchToolbarLayout,
+} from './workbenchToolbarModel';
+
+/**
+ * 顶栏当前档位挂在 DOM 属性上（`data-layout`），并**只由这个 hook 写**。
+ *
+ * 不让 React 渲染这个属性：档位是量出来的，不是 state 推出来的。这条链路上每次量宽都要先把
+ * 候选档位真的写到 DOM（否则量到的还是当前档位的宽度），React 受控属性会被这类「量一次写一次」
+ * 的中间值污染，且每次窗口拖动都要触发一轮工作台整树重渲染——顶栏只有这一处样式差异，不值得。
+ * React 不声明它就不会覆盖它，见 `styles.css` 里的 `[data-layout=...]` 选择器。
+ */
+export const WORKBENCH_TOOLBAR_LAYOUT_ATTRIBUTE = 'data-layout';
+
+/**
+ * 把候选档位写到 DOM 上量一次内容宽度。
+ *
+ * 顶栏是 `flex-wrap: nowrap` + `overflow: hidden`：放不下时溢出的那部分仍计入 `scrollWidth`，
+ * 所以「量得的内容宽度 > clientWidth」就是这一档放不下。
+ */
+function measureToolbarContentWidth(
+  element: HTMLElement,
+  candidate: WorkbenchToolbarLayout,
+): number {
+  element.dataset.layout = candidate;
+  return element.scrollWidth;
+}
+
+/** 重新爬一次档位阶梯并落定；返回落定后的档位（测试与排障用）。 */
+export function applyWorkbenchToolbarLayout(
+  element: HTMLElement,
+): WorkbenchToolbarLayout {
+  const layout = resolveWorkbenchToolbarLayout(
+    element.clientWidth,
+    (candidate) => measureToolbarContentWidth(element, candidate),
+  );
+  element.dataset.layout = layout;
+  return layout;
+}
+
+/**
+ * 让顶栏按实际可用宽度自己选档位（`workbenchToolbarModel` 给了顺序与判据）。
+ *
+ * 两个信号都要：
+ * - `ResizeObserver`：可用宽度变了（窗口拖动、对话列收放）；
+ * - `MutationObserver`：宽度不变但**内容**变了（切运行页、出现「恢复草稿」、面板开合）。
+ *   这种变化不改顶栏宽度，只看尺寸会停在旧档位上——动作变少了却还收在「更多」里。
+ *
+ * 观测本身不引起递归：写的是被观测节点自己的属性，而属性不在观测范围内（`childList` /
+ * `characterData` / `subtree` 都不含根节点自身属性），且档位变化不改顶栏尺寸。
+ * 没有 `ResizeObserver` 的环境（jsdom）只按内容变化重算，量到 0 宽就停在默认的 `full`——
+ * 与关闭脚本前的默认形态一致。
+ */
+export function useWorkbenchToolbarLayout(
+  toolbarRef: RefObject<HTMLElement | null>,
+): void {
+  useLayoutEffect(() => {
+    const element = toolbarRef.current;
+    if (!element) {
+      return undefined;
+    }
+    applyWorkbenchToolbarLayout(element);
+
+    const resizeObserver =
+      typeof ResizeObserver === 'function'
+        ? new ResizeObserver(() => applyWorkbenchToolbarLayout(element))
+        : null;
+    resizeObserver?.observe(element);
+    const mutationObserver =
+      typeof MutationObserver === 'function'
+        ? new MutationObserver(() => applyWorkbenchToolbarLayout(element))
+        : null;
+    mutationObserver?.observe(element, {
+      childList: true,
+      characterData: true,
+      subtree: true,
+    });
+
+    return () => {
+      resizeObserver?.disconnect();
+      mutationObserver?.disconnect();
+    };
+  }, [toolbarRef]);
+}
diff --git a/apps/ai-game-creator-shell/src/view/project-development/workbenchToolbarModel.ts b/apps/ai-game-creator-shell/src/view/project-development/workbenchToolbarModel.ts
new file mode 100644
index 000000000..0f9ae2d32
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/project-development/workbenchToolbarModel.ts
@@ -0,0 +1,49 @@
+/**
+ * 工作台顶栏在横向空间不足时的降级档位。
+ *
+ * 顶栏是**一行到底**的 flex 行：左侧「资源管理 / 运行」，右侧动作区 + 版本入口。以前两侧都可以
+ * `flex-wrap: wrap`，窄一点就把「播放」和版本入口甩到第二行——同一行控件分裂成两行，用户明确
+ * 否掉了这种换行。现在不换行，空间不够按固定顺序退：
+ *
+ * 1. `full`：动作全部内联，版本入口显示 `版本 1（智能体修订 · 时间）`；
+ * 2. `compact-version`：版本入口只留 `版本 1`（括号里那截原因与时间整体收起）；
+ * 3. `collapsed-actions`：`打开项目目录 / 资源面板 / 整理画布` 收进「更多」下拉；
+ * 4. 再不够就停在 `collapsed-actions`：版本名由省略号兜底，动作区不再继续牺牲。
+ *
+ * 档位只决定「隐藏什么」，具体隐藏由 `styles.css` 里 `[data-layout=...]` 的选择器完成；
+ * 每一档到底占多宽由真实 DOM 量（`useWorkbenchToolbarLayout`），这里只留纯判据，便于单测。
+ */
+export const WORKBENCH_TOOLBAR_LAYOUTS = [
+  'full',
+  'compact-version',
+  'collapsed-actions',
+] as const;
+
+export type WorkbenchToolbarLayout = (typeof WORKBENCH_TOOLBAR_LAYOUTS)[number];
+
+/**
+ * 「这一档放不下」的余量。
+ *
+ * 判定用 `scrollWidth > clientWidth`，两者都取整到整数像素，且 125% 缩放下同一份内容在不同
+ * 设备像素比下会差 1px 上下；不给余量就会在临界宽度上反复在相邻两档之间抖。
+ */
+const OVERFLOW_TOLERANCE = 1;
+
+/**
+ * 按档位顺序取第一个放得下的档位。
+ *
+ * `measureContentWidth(candidate)` 由调用方提供：它把候选档位真的写到 DOM 上再量一次内容宽度
+ * （见 `useWorkbenchToolbarLayout`），所以这里不缓存任何宽度、也不做增量推算——每一档的宽度
+ * 都随模式（资源页 / 运行页）、动作出现与否（恢复草稿、点选素材）变化。
+ */
+export function resolveWorkbenchToolbarLayout(
+  availableWidth: number,
+  measureContentWidth: (candidate: WorkbenchToolbarLayout) => number,
+): WorkbenchToolbarLayout {
+  for (const candidate of WORKBENCH_TOOLBAR_LAYOUTS) {
+    if (measureContentWidth(candidate) - availableWidth <= OVERFLOW_TOLERANCE) {
+      return candidate;
+    }
+  }
+  return 'collapsed-actions';
+}
diff --git a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
index 866de0c7c..c83bafff6 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
@@ -461,6 +461,9 @@ export function registerProjectWorkbenchFoundationTests() {
       ],
     });
 
+    // 「运行」页签就是播放入口（原「播放」按钮并进来）：这枚 spy 用来证明不可运行时
+    // 点了它既不切视图、也不向宿主发播放请求。
+    const onPlay = vi.fn();
     render(
       React.createElement(ProjectDevelopmentView, {
         projectName: '陶泥儿工作台测试',
@@ -483,6 +486,7 @@ export function registerProjectWorkbenchFoundationTests() {
         ),
         onHomeOpen: vi.fn(),
         onProjectsOpen: vi.fn(),
+        onPlay,
       }),
     );
 
@@ -500,14 +504,13 @@ export function registerProjectWorkbenchFoundationTests() {
     const runTab = screen.getByRole('tab', {
       name: '运行',
     }) as HTMLButtonElement;
+    // 「运行」页签就是播放入口（原「播放」按钮并进来）：不可运行时不置灰、只给提示，
+    // 点了既不切视图、也不向宿主发播放请求。
     expect(runTab.disabled).toBe(false);
     expect(runTab.getAttribute('data-unavailable')).toBe('true');
-    const playButton = screen.getByRole('button', {
-      name: '播放',
-    }) as HTMLButtonElement;
-    expect(playButton.disabled).toBe(true);
     fireEvent.click(runTab);
     expect(runTab.getAttribute('aria-selected')).toBe('false');
+    expect(onPlay).not.toHaveBeenCalled();
     expect(
       screen.getByText('首个可运行原型尚未完成，运行视图暂不可用'),
     ).not.toBeNull();
@@ -5895,15 +5898,25 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(styles).toMatch(
       /\.game-workbench-view-tabs\s*\{[^}]*display:\s*flex[^}]*align-items:\s*center/s,
     );
-    // 播放按钮跟着「资源管理 / 运行」左对齐，不再居中悬浮。
+    // 播放并进「运行」页签：顶栏左侧只剩模式分段，「播放」按钮与它的整套外观规则一起退役。
+    expect(styles).not.toMatch(/game-workbench-play-button/);
+    // 顶栏一行到底：空间不够走 `data-layout` 降级，不再换行（换行会把版本入口甩到第二行）。
     expect(styles).toMatch(
-      /\.game-workbench-view-tabs \.game-workbench-play-button\s*\{[^}]*position:\s*static[^}]*transform:\s*none/s,
+      /\.game-workbench-toolbar\s*\{[^}]*flex-wrap:\s*nowrap[^}]*overflow:\s*hidden/s,
     );
-    expect(styles).not.toMatch(
-      /\.game-workbench-play-button\s*\{[^}]*position:\s*absolute/s,
+    // 两档降级：先收版本名的括号段，再收「打开项目目录 / 资源面板 / 整理画布」进「更多」，
+    // 且版本入口钉在动作区最右。
+    expect(styles).toMatch(
+      /\.game-workbench-toolbar\[data-layout='compact-version'\]\s*\.game-run-version-trigger-detail\s*\{[^}]*display:\s*none/s,
     );
-    // 新位置必须并进按钮基础外观与焦点环的规则列表：不然播放按钮会掉成零圆角、零内边距、
-    // 无边框、默认字号的裸按钮，而颜色规则看起来仍然生效。
+    expect(styles).toMatch(
+      /\.game-workbench-toolbar\[data-layout='collapsed-actions'\]\s*\.game-workbench-foldable-action\s*\{[^}]*display:\s*none/s,
+    );
+    expect(styles).toMatch(
+      /\.game-run-version-picker\s*\{[^}]*margin-left:\s*auto/s,
+    );
+    // 模式分段与动作区按钮必须共用同一条基础外观规则与焦点环：不然新进来的「运行 ▶」页签会掉成
+    // 零圆角、零内边距、无边框、默认字号的裸按钮，而颜色规则看起来仍然生效。
     expect(styles).toMatch(
       /\.game-workbench-tabs button,\s*\.game-workbench-view-tabs button,\s*\.game-workbench-view-actions button\s*\{[^}]*border-radius:\s*999px/s,
     );
@@ -6513,7 +6526,8 @@ export function registerProjectWorkbenchFoundationTests() {
       }),
     );
 
-    fireEvent.click(screen.getByRole('button', { name: '播放' }));
+    // 「运行」页签就是播放入口：切过去即向宿主发一次播放请求，并落到运行表现层。
+    fireEvent.click(screen.getByRole('tab', { name: '运行' }));
     expect(onPlay).toHaveBeenCalledTimes(1);
     expect(screen.getByLabelText('运行表现层')).not.toBeNull();
 
@@ -6521,7 +6535,9 @@ export function registerProjectWorkbenchFoundationTests() {
       name: '运行',
     }) as HTMLButtonElement;
     expect(runTab.disabled).toBe(false);
+    // 再点一次同一枚页签＝重跑：空态与预览失败态都靠它。
     fireEvent.click(runTab);
+    expect(onPlay).toHaveBeenCalledTimes(2);
     expect(screen.getByLabelText('运行表现层')).not.toBeNull();
     const previewFrame = screen.getByTitle(
       '可运行工作台 游戏运行画面',
@@ -6747,7 +6763,7 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(screen.queryByTitle('远程预览拒绝测试 游戏运行画面')).toBeNull();
     expect(screen.getByText('客户端运行画面尚未载入')).not.toBeNull();
     expect(
-      screen.getByText('点击顶部播放按钮后将在这里直接运行游戏'),
+      screen.getByText('点击顶部「运行」页签后将在这里直接运行游戏'),
     ).not.toBeNull();
     expect(screen.queryByText(/\/run|\/preview/)).toBeNull();
   });
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
index e1213d6a4..33ee4da1f 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
@@ -7,10 +7,9 @@ import {
   generateGameDistributionCover,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
-  readGamePublishAvailability,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../src/services/gameDistributionPublish';
-
 const MANIFEST = {
   projectId: 'local-proj-1',
   name: '星轨防线',
@@ -91,6 +90,31 @@ describe('Rust 发布 facade', () => {
     expect(calls[0]?.args).not.toHaveProperty('packageBytes');
   });
 
+  test('未显式给出根幂等键时不生成键，交由原生账本解析', async () => {
+    const { invoke, calls } = installNativeInvoke((command) => {
+      if (command === 'publish_local_project_game') return PUBLISH_RESULT;
+      throw new Error(`未预期的命令：${command}`);
+    });
+
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      manifest: MANIFEST,
+      metadata: { coverAssetId: 'asset_cover' },
+    });
+
+    expect(calls).toHaveLength(1);
+    // 渲染层不铸键也不落盘：Rust 按「账号 + 本地项目 + 包摘要」的账本解析根幂等键，
+    // 这样响应丢失、重启与分片续传才会落在同一次服务端尝试上。
+    expect(calls[0]?.args).not.toHaveProperty('idempotencyKey');
+    expect(calls[0]?.args).toMatchObject({
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      metadata: { localProjectId: 'local-proj-1' },
+    });
+  });
+
   test('缺少本地项目标识时在发起 native command 前失败关闭', async () => {
     const invoke = vi.fn() as unknown as TauriInvoke;
     await expect(
@@ -139,9 +163,8 @@ describe('Rust 发布 facade', () => {
     expect(invoke).not.toHaveBeenCalled();
   });
 
-  test('发布灰度、资料建议和价格均通过 native command', async () => {
+  test('资料建议和价格均通过 native command', async () => {
     const { invoke, calls } = installNativeInvoke((command) => {
-      if (command === 'read_game_publish_availability') return true;
       if (command === 'suggest_game_distribution_publish_metadata') {
         return { summary: '驾驶炮台守住轨道城', category: '策略' };
       }
@@ -149,7 +172,6 @@ describe('Rust 发布 facade', () => {
       throw new Error(`未预期的命令：${command}`);
     });
 
-    await expect(readGamePublishAvailability(invoke)).resolves.toBe(true);
     await expect(
       suggestGameDistributionPublishMetadata(
         {
@@ -169,7 +191,6 @@ describe('Rust 发布 facade', () => {
     ).resolves.toBe(5);
 
     expect(calls).toEqual([
-      { command: 'read_game_publish_availability', args: undefined },
       {
         command: 'suggest_game_distribution_publish_metadata',
         args: {
@@ -229,9 +250,151 @@ describe('Rust 发布 facade', () => {
     ]);
   });
 
-  test('缺少 native 宿主时发布网络 facade 失败关闭', async () => {
-    await expect(readGamePublishAvailability()).rejects.toThrow(
-      '需要在 Tauri App 内执行发布操作',
-    );
+  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('未显式给出项目版本时按工程内部版本条数派生', async () => {
+    const { invoke, calls } = installNativeInvoke(() => PUBLISH_RESULT);
+
+    // 没有任何内部版本记录：首版回落 1，不把「没写」变成服务端自动递增。
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      manifest: MANIFEST,
+      metadata: { coverAssetId: 'asset_cover' },
+    });
+    expect(calls[0]?.args).toMatchObject({ versionNumber: 1 });
+
+    // 4 条内部版本 → 标签就是最新那张卡的序数 4；平台绑定里的版本号不参与派生。
+    const withVersions = {
+      ...MANIFEST,
+      versions: [
+        { versionId: 'initial-13', parentVersionId: null, projectRevision: 13 },
+        {
+          versionId: 'agent-22',
+          parentVersionId: 'initial-13',
+          projectRevision: 22,
+        },
+        {
+          versionId: 'agent-42',
+          parentVersionId: 'agent-22',
+          projectRevision: 42,
+        },
+        {
+          versionId: 'agent-46',
+          parentVersionId: 'agent-42',
+          projectRevision: 46,
+        },
+      ],
+      projectVersion: 6,
+      publication: { latestVersionNumber: 6 },
+    } as unknown as GameCreationAppManifest;
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      manifest: withVersions,
+      metadata: { coverAssetId: 'asset_cover' },
+      gameId: 'game_9',
+      expectedPublicationRevision: 7,
+    });
+    expect(calls[1]?.args).toMatchObject({
+      gameId: 'game_9',
+      versionNumber: 4,
+      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',
+        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 5ae63e1af..ceafb61fd 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
@@ -14,7 +14,7 @@
  * 分片协议（upload-state → chunk → complete）代跑，等同于原生上传器的行为；
  * 原生实现自身的分片规划、权威偏移续传与错误分类在 Rust 单测里覆盖。
  */
-import { createHash, randomBytes } from 'node:crypto';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
 
 import JSZip from 'jszip';
 import { expect, test, vi } from 'vitest';
@@ -298,6 +298,32 @@ async function buildStagedPackage(): Promise<{
   };
 }
 
+/**
+ * 原生发布尝试账本的替身：与 Rust `game_publish_attempt` 同口径。
+ *
+ * 同一账号 + 同一本地项目 + **同一份发行包摘要**复用同一个根幂等键（响应丢失后重发、
+ * 进程重启、分片续传都落在同一次服务端尝试上）；包内容变了或上一次已经收口（送审成功）
+ * 就换新键，下一次发布会新增版本而不是复用旧版本。
+ */
+function createPublishAttemptLedger() {
+  const attempts = new Map<string, string>();
+  return {
+    resolve(localProjectId: string, packageSha256: string): string {
+      const key = `${localProjectId}:${packageSha256}`;
+      const existing = attempts.get(key);
+      if (existing) return existing;
+      const rootKey = `agc-publish-live-${randomUUID()}`;
+      attempts.set(key, rootKey);
+      return rootKey;
+    },
+    clear(localProjectId: string): void {
+      for (const key of [...attempts.keys()]) {
+        if (key.startsWith(`${localProjectId}:`)) attempts.delete(key);
+      }
+    },
+  };
+}
+
 type PackageUploadState = {
   receivedBytes: number;
   chunkBytes: number;
@@ -461,28 +487,48 @@ liveTest(
     } as unknown as GameCreationAppManifest;
     // 记录本次发布实际发送过的分片偏移，用来证明「中断后不重传已收字节」。
     const sentOffsets: number[] = [];
-    // 该 mock 只按命令返回固定结构，无法满足 TauriInvoke 的泛型逐命令建模，故整体断言为 TauriInvoke。
+    const attempts = createPublishAttemptLedger();
     const invoke = vi.fn(
       async (command: string, args?: Record<string, unknown>) => {
         if (command !== 'publish_local_project_game') {
           throw new Error(`未预期的命令：${command}`);
         }
         const metadata = args?.metadata as Record<string, unknown>;
-        const rootKey = String(args?.idempotencyKey ?? '');
-        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),
-          }),
-        );
+        // 渲染层不再铸键；显式传入时覆盖账本，与 Rust 发布命令同口径。
+        const explicitKey = String(args?.idempotencyKey ?? '').trim();
+        const rootKey =
+          explicitKey ||
+          attempts.resolve(
+            String(metadata.localProjectId),
+            staged.packageSha256,
+          );
+        // 更新模式：带原 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;
@@ -503,6 +549,9 @@ liveTest(
                 packageBytes: staged.packageSizeBytes,
                 packageFileCount: staged.packageFileCount,
                 packageEntryPath: 'index.html',
+                ...(requestedVersionNumber === undefined
+                  ? {}
+                  : { versionNumber: requestedVersionNumber }),
                 gameMetadata: metadata,
               }),
             },
@@ -535,6 +584,8 @@ liveTest(
             },
           ),
         );
+        // 送审成功即服务端收口：原生账本同样在这里清除本次尝试。
+        attempts.clear(String(metadata.localProjectId));
         return {
           gameId: game.id,
           versionId: version.versionId,
@@ -545,6 +596,7 @@ liveTest(
           fileCount: staged.packageFileCount,
         };
       },
+      // 该 mock 只按命令返回固定结构，无法满足 TauriInvoke 的泛型逐命令建模，故整体断言为 TauriInvoke。
     ) as unknown as TauriInvoke;
     // 服务端要求发布必须带封面。真实 Tauri 里 `upload_platform_media_asset` 由 Rust
     // 完成「凭证 → 对象存储直传 → confirm」；jsdom 没有原生宿主，这里用同一个
@@ -616,7 +668,8 @@ liveTest(
     expect(readResult.version.recoveryAction).toBe('wait');
     expect(readResult.game.id).toBe(first.gameId);
 
-    // 第二次发布不带旧幂等键：同 localProjectId 必须复用同一 gameId 并新增版本。
+    // 第二次发布：上一次已在送审成功时收口，账本清除，因此这里换新键——同
+    // localProjectId 必须复用同一 gameId 并新增版本。
     const second = await publishLocalProjectGame({
       invoke,
       projectPath: '/data/dsk/Genarrative/tmp-agc-live-project',
@@ -627,6 +680,79 @@ 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);
+
+    // 同一个项目版本重复提交：服务端必须生成新的 versionId，而不是覆盖上一个提交实例。
+    const afterUpdate = await unwrap<{
+      game: { publicationRevision: number };
+    }>(
+      await realFetch(
+        apiUrl(`/api/game-distribution/my-games/${second.gameId}`),
+        {
+          headers: { Authorization: `Bearer ${token}`, ...ENVELOPE_HEADERS },
+        },
+      ),
+    );
+    const repeated = 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: afterUpdate.game.publicationRevision,
+    });
+    expect(repeated.gameId).toBe(second.gameId);
+    expect(repeated.versionNumber).toBe(targetVersionNumber);
+    expect(repeated.versionId).not.toBe(updated.versionId);
+
+    // 回退：项目版本可以低于线上最大版本号，服务端只校验它是正整数。
+    const afterRepeat = await unwrap<{
+      game: { publicationRevision: number };
+    }>(
+      await realFetch(
+        apiUrl(`/api/game-distribution/my-games/${second.gameId}`),
+        {
+          headers: { Authorization: `Bearer ${token}`, ...ENVELOPE_HEADERS },
+        },
+      ),
+    );
+    const reverted = 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: 2,
+      expectedPublicationRevision: afterRepeat.game.publicationRevision,
+    });
+    expect(reverted.gameId).toBe(second.gameId);
+    expect(reverted.versionNumber).toBe(2);
+    expect(reverted.versionId).not.toBe(repeated.versionId);
+
     const myGames = await unwrap<{
       games: Array<{
         id: string;
@@ -638,8 +764,17 @@ liveTest(
       }),
     );
     const published = myGames.games.find((game) => game.id === first.gameId);
-    expect(published?.latestVersion?.versionId).toBe(second.versionId);
+    // 「最新提交」按版本号降序取第一条：v7 有两条提交实例，回退的 v2 不会顶掉它们。
+    expect([updated.versionId, repeated.versionId]).toContain(
+      published?.latestVersion?.versionId,
+    );
     expect(published?.latestVersion?.status).toBe('pending_review');
+    // 重复提交同一版本、回退到更小版本都只增加版本，不重复创建作品。
+    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 98de312bf..f0f071c79 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
@@ -6,6 +6,7 @@
  * 真实的 HTTP 链路由 `gameDistributionPublishLive.test.ts` 覆盖。
  */
 import {
+  act,
   cleanup,
   fireEvent,
   render,
@@ -23,8 +24,13 @@ import {
   generateGameDistributionCover,
   publishLocalProjectGame,
   readGameCoverGenerationPrice,
+  readGameDistributionPublication,
   suggestGameDistributionPublishMetadata,
 } from '../src/services/gameDistributionPublish';
+import { GAME_PACKAGE_UPLOAD_PROGRESS_EVENT } from '../src/services/gamePackageUploadProgress';
+import { createTauriEventFake, type TauriEventFake } from './tauriEventFake';
+
+let eventFake: TauriEventFake | null = null;
 
 vi.mock('../src/services/gameDistributionPublish', async (importOriginal) => {
   const actual =
@@ -36,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(),
   };
 });
@@ -91,7 +98,7 @@ async function selectCover(
   fireEvent.change(screen.getByLabelText(/游戏封面/u), {
     target: { files: [file] },
   });
-  await screen.findByText(new RegExp(`已选择「${file.name}」`, 'u'));
+  await screen.findByText('更换封面图片');
 }
 
 function renderPanel(
@@ -121,13 +128,24 @@ beforeEach(() => {
   vi.mocked(suggestGameDistributionPublishMetadata).mockImplementation(
     () => new Promise<never>(() => undefined),
   );
+  // 默认按「首次发布」恢复，保持既有用例的提交路径不变；更新模式用例单独覆盖。
+  vi.mocked(readGameDistributionPublication).mockResolvedValue({
+    state: 'first-publish',
+    binding: null,
+    refreshed: true,
+    draft: null,
+    visibility: null,
+  });
 });
 
 afterEach(() => {
   cleanup();
+  eventFake?.restore();
+  eventFake = null;
   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__;
@@ -154,7 +172,6 @@ describe('GameDistributionPublishPanel', () => {
       screen.queryByText(/exports\/playtest-package-unit\.zip/u),
     ).toBeNull();
     expect(screen.queryByText(/只上传已导出的 ZIP/u)).toBeNull();
-    await screen.findByText(/简介和分类/u);
   });
 
   test('打开时根据创作上下文补全简介和分类', async () => {
@@ -172,11 +189,6 @@ describe('GameDistributionPublishPanel', () => {
       );
     });
     expect(screen.getByLabelText('分类')).toHaveProperty('value', '策略');
-    expect(
-      screen.getByText(
-        'AI 已根据创作内容生成简介和分类，免费；你可以直接修改。',
-      ),
-    ).not.toBeNull();
   });
 
   test('发布资料建议只带脱敏且有界的项目上下文', async () => {
@@ -315,11 +327,13 @@ describe('GameDistributionPublishPanel', () => {
       coverAssetId: 'asset_cover',
       screenshots: ['asset_shot_1'],
     });
-    expect(String(args?.idempotencyKey)).toMatch(/^agc-publish-/u);
+    // 根幂等键由原生发布链路按「账号 + 本地项目 + 包摘要」的账本解析并持久化，
+    // 渲染层不再自己铸键，因此这里不带 idempotencyKey。
+    expect(args?.idempotencyKey).toBeUndefined();
     expect(invoke).toBeDefined();
 
     expect(await screen.findByText('已提交审核')).not.toBeNull();
-    expect(screen.getByText(/版本 1/u)).not.toBeNull();
+    expect(screen.getByText(/项目版本/u)).not.toBeNull();
     expect(onPublished).toHaveBeenCalledTimes(1);
   });
 
@@ -339,7 +353,7 @@ describe('GameDistributionPublishPanel', () => {
     fireEvent.click(submit);
     fireEvent.click(submit);
 
-    expect(await screen.findByText('上传中…')).not.toBeNull();
+    expect(await screen.findByText('正在发布…')).not.toBeNull();
     expect(publishLocalProjectGame).toHaveBeenCalledTimes(1);
 
     resolvePublish({
@@ -354,6 +368,118 @@ describe('GameDistributionPublishPanel', () => {
     expect(await screen.findByText('已提交审核')).not.toBeNull();
   });
 
+  test('发布进行中按原生事件显示阶段与上传百分比', async () => {
+    let resolvePublish: (value: unknown) => void = () => undefined;
+    vi.mocked(publishLocalProjectGame).mockImplementation(() => {
+      // `Promise.withResolvers` 需要 lib ES2024，本仓 AGC 走 ES2022；这里手写等价 deferred：
+      // resolve 由外部持有、promise 交回测试，语义与 withResolvers 一致（reject 原本未使用）。
+      let settlePending: (value: unknown) => void = () => undefined;
+      const pending = new Promise<unknown>((resolve) => {
+        settlePending = resolve;
+      });
+      resolvePublish = settlePending;
+      return pending as never;
+    });
+    eventFake = createTauriEventFake();
+    eventFake.install();
+    renderPanel();
+    await selectCover();
+
+    fireEvent.click(screen.getByRole('button', { name: '发布游戏' }));
+    await waitFor(() =>
+      expect(eventFake?.pendingRegistrationEvals()).toBeGreaterThan(0),
+    );
+    // 订阅发生在发起 native 命令之前，事件不会丢；这里让注册 eval 落地后才能投递。
+    eventFake.flushRegistrationEvals();
+
+    // 导出打包已经完成，因此构建步骤是「已完成」，当前停在准备步骤。
+    const steps = await screen.findByRole('list', { name: '发布阶段' });
+    expect(within(steps).getByText('构建').closest('li')?.className).toContain(
+      'is-done',
+    );
+    expect(
+      within(steps)
+        .getByText('准备')
+        .closest('li')
+        ?.getAttribute('aria-current'),
+    ).toBe('step');
+
+    // 上传阶段：百分比只由「已收字节 / 总字节」换算。
+    act(() => {
+      eventFake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+        versionId: 'gamever_1',
+        publishId: 'agc-publish-unit',
+        phase: 'upload',
+        message: '正在上传发行包…',
+        receivedBytes: 5 * 1024 * 1024,
+        totalBytes: 10 * 1024 * 1024,
+      });
+    });
+    expect(await screen.findByText('正在上传发行包…')).not.toBeNull();
+    expect(
+      (
+        await screen.findByRole('progressbar', { name: '上传进度' })
+      ).getAttribute('aria-valuenow'),
+    ).toBe('50');
+
+    // 校验与送审阶段没有可换算的总量：进度条隐去，阶段照常前进。
+    act(() => {
+      eventFake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+        versionId: 'gamever_1',
+        publishId: 'agc-publish-unit',
+        phase: 'verify',
+        message: '正在校验发行包…',
+        receivedBytes: 0,
+        totalBytes: 0,
+      });
+    });
+    expect(await screen.findByText('正在校验发行包…')).not.toBeNull();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+
+    act(() => {
+      eventFake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+        versionId: 'gamever_1',
+        publishId: 'agc-publish-unit',
+        phase: 'submit',
+        message: '正在提交审核…',
+        receivedBytes: 0,
+        totalBytes: 0,
+      });
+    });
+    expect(await screen.findByText('正在提交审核…')).not.toBeNull();
+    expect(
+      within(screen.getByRole('list', { name: '发布阶段' }))
+        .getByText('送审')
+        .closest('li')
+        ?.getAttribute('aria-current'),
+    ).toBe('step');
+
+    // 不认识的阶段不允许把进度打回错误位置，也不显示它的文案。
+    act(() => {
+      eventFake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+        versionId: 'gamever_1',
+        publishId: 'agc-publish-unit',
+        phase: 'unexpected-phase',
+        message: '不该出现的阶段',
+        receivedBytes: 0,
+        totalBytes: 0,
+      });
+    });
+    expect(screen.queryByText('不该出现的阶段')).toBeNull();
+    expect(screen.getByText('正在提交审核…')).not.toBeNull();
+
+    resolvePublish({
+      gameId: 'game_1',
+      versionId: 'gamever_1',
+      versionNumber: 1,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    expect(await screen.findByText('已提交审核')).not.toBeNull();
+  });
+
   test('服务端失败时保留面板并展示可读错误', async () => {
     installTauriInvoke(async () => undefined);
     vi.mocked(publishLocalProjectGame).mockRejectedValue(
@@ -376,7 +502,8 @@ 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）'),
@@ -407,7 +534,7 @@ describe('GameDistributionPublishPanel', () => {
     fireEvent.change(screen.getByLabelText(/游戏封面/u), {
       target: { files: [coverFile] },
     });
-    await screen.findByText(/已选择「cover.png」/u);
+    await screen.findByText('更换封面图片');
     expect(uploadPlatformMediaAsset).toHaveBeenCalledTimes(1);
   });
 
@@ -550,10 +677,192 @@ 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: 2,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    const { onPublished } = renderPanel();
+
+    // 回填线上冻结资料；项目版本按工程内部版本派生（本 fixture 没有 versions → 首版 1），
+    // 平台绑定的线上版本号只用于展示，不参与派生。
+    await screen.findByRole('button', { name: '更新游戏' });
+    expect(screen.getByLabelText('游戏名称')).toHaveProperty(
+      'value',
+      '星轨防线（线上）',
+    );
+    expect(screen.getByLabelText('一句话简介')).toHaveProperty(
+      'value',
+      '线上简介',
+    );
+    const versionInput = screen.getByLabelText('项目版本');
+    expect(versionInput).toHaveProperty('value', '1');
+    expect(versionInput).toHaveProperty('readOnly', true);
+    expect(screen.getByText('v1')).not.toBeNull();
+    expect(screen.getByText(/线上最近提交 v2 · 审核中/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');
+    // 提交的就是派生出来的内部版本序数，与线上最近提交的 v2 无关。
+    expect(args?.versionNumber).toBe(1);
+    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',
+    });
+    vi.mocked(publishLocalProjectGame).mockResolvedValue({
+      gameId: 'game_9',
+      versionId: 'gamever_6',
+      versionNumber: 4,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    renderPanel({
+      manifest: {
+        ...MANIFEST,
+        // 4 条内部版本 → 标签 4；遗留 projectVersion 6 与线上 v5 都不得影响它。
+        versions: [
+          {
+            versionId: 'initial-13',
+            parentVersionId: null,
+            projectRevision: 13,
+          },
+          {
+            versionId: 'agent-22',
+            parentVersionId: 'initial-13',
+            projectRevision: 22,
+          },
+          {
+            versionId: 'agent-42',
+            parentVersionId: 'agent-22',
+            projectRevision: 42,
+          },
+          {
+            versionId: 'agent-46',
+            parentVersionId: 'agent-42',
+            projectRevision: 46,
+          },
+        ],
+        projectVersion: 6,
+      } as unknown as GameCreationAppManifest,
+    });
+    await screen.findByRole('button', { name: '更新游戏' });
+
+    const input = screen.getByLabelText('项目版本');
+    expect(input).toHaveProperty('value', '4');
+    expect(input).toHaveProperty('readOnly', true);
+    expect(screen.getByText('v4')).not.toBeNull();
+    expect(screen.getByText(/线上最近提交 v5 · 已公开/u)).not.toBeNull();
+    await selectCover();
+    fireEvent.click(screen.getByRole('button', { name: '更新游戏' }));
+
+    await waitFor(() =>
+      expect(publishLocalProjectGame).toHaveBeenCalledTimes(1),
+    );
+    expect(
+      vi.mocked(publishLocalProjectGame).mock.calls[0]?.[0].versionNumber,
+    ).toBe(4);
+  });
+
+  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/apps/ai-game-creator-shell/tests/gamePackageUploadProgress.test.ts b/apps/ai-game-creator-shell/tests/gamePackageUploadProgress.test.ts
new file mode 100644
index 000000000..77852e125
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/gamePackageUploadProgress.test.ts
@@ -0,0 +1,136 @@
+// @vitest-environment jsdom
+/**
+ * 发布进度事件的前端收敛层：Rust 的 `game-package-upload-progress` 载荷在这里被
+ * 规范化（未知阶段丢弃）、换算百分比，并通过统一的事件订阅入口投递给 UI。
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  computeGamePackageUploadPercent,
+  GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
+  readGamePackageUploadProgressEvent,
+  subscribeGamePackageUploadProgress,
+} from '../src/services/gamePackageUploadProgress';
+import { createTauriEventFake, type TauriEventFake } from './tauriEventFake';
+
+let fake: TauriEventFake | null = null;
+
+beforeEach(() => {
+  fake = createTauriEventFake();
+  fake.install();
+});
+
+afterEach(() => {
+  fake?.restore();
+  fake = null;
+});
+
+describe('发布进度事件收敛', () => {
+  it('规范化原生载荷：阶段、文案与字节计数都对上', () => {
+    expect(
+      readGamePackageUploadProgressEvent({
+        versionId: ' gamever_1 ',
+        publishId: ' agc-publish-1 ',
+        phase: 'upload',
+        message: ' 正在上传发行包… ',
+        receivedBytes: 5_242_880.9,
+        totalBytes: 10_000_000,
+      }),
+    ).toEqual({
+      versionId: 'gamever_1',
+      publishId: 'agc-publish-1',
+      phase: 'upload',
+      message: '正在上传发行包…',
+      receivedBytes: 5_242_880,
+      totalBytes: 10_000_000,
+    });
+  });
+
+  it('不认识的阶段与非法载荷一律丢弃，不让 UI 退回错误阶段', () => {
+    expect(readGamePackageUploadProgressEvent(null)).toBeNull();
+    expect(readGamePackageUploadProgressEvent('upload')).toBeNull();
+    expect(
+      readGamePackageUploadProgressEvent({
+        phase: 'staging',
+        receivedBytes: 1,
+        totalBytes: 2,
+      }),
+    ).toBeNull();
+    expect(
+      readGamePackageUploadProgressEvent({
+        phase: 'verify',
+        receivedBytes: -3,
+        totalBytes: Number.NaN,
+      }),
+    ).toEqual({
+      versionId: '',
+      publishId: '',
+      phase: 'verify',
+      message: '',
+      receivedBytes: 0,
+      totalBytes: 0,
+    });
+  });
+
+  it('只有拿到总字节才换算百分比，其余阶段返回 null', () => {
+    expect(computeGamePackageUploadPercent(0, 0)).toBeNull();
+    expect(computeGamePackageUploadPercent(5, 0)).toBeNull();
+    expect(computeGamePackageUploadPercent(0, 10)).toBe(0);
+    expect(computeGamePackageUploadPercent(5, 10)).toBe(50);
+    expect(computeGamePackageUploadPercent(1, 3)).toBe(33);
+    expect(computeGamePackageUploadPercent(12, 10)).toBe(100);
+  });
+
+  it('订阅只投递规范化后的事件，注销后不再投递', async () => {
+    const handler = vi.fn();
+    const unsubscribe = await subscribeGamePackageUploadProgress(handler);
+    fake?.flushRegistrationEvals();
+
+    fake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+      versionId: 'gamever_1',
+      publishId: 'agc-publish-1',
+      phase: 'upload',
+      message: '正在上传发行包…',
+      receivedBytes: 10,
+      totalBytes: 40,
+    });
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith({
+      versionId: 'gamever_1',
+      publishId: 'agc-publish-1',
+      phase: 'upload',
+      message: '正在上传发行包…',
+      receivedBytes: 10,
+      totalBytes: 40,
+    });
+
+    // 未知阶段不投递：UI 不会因为一条不认识的事件退回错误步骤。
+    fake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+      phase: 'unknown',
+      message: '不该出现',
+      receivedBytes: 0,
+      totalBytes: 0,
+    });
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    unsubscribe();
+    fake?.emit(GAME_PACKAGE_UPLOAD_PROGRESS_EVENT, {
+      phase: 'submit',
+      message: '正在提交审核…',
+      receivedBytes: 0,
+      totalBytes: 0,
+    });
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(fake?.jsCallbackCount()).toBe(0);
+  });
+
+  it('没有原生宿主时订阅是空操作而不是报错', async () => {
+    fake?.restore();
+    fake = null;
+    const handler = vi.fn();
+    const unsubscribe = await subscribeGamePackageUploadProgress(handler);
+    expect(typeof unsubscribe).toBe('function');
+    unsubscribe();
+    expect(handler).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/gamePublishFeedback.test.tsx b/apps/ai-game-creator-shell/tests/gamePublishFeedback.test.tsx
index 8bae3c725..12316d6ac 100644
--- a/apps/ai-game-creator-shell/tests/gamePublishFeedback.test.tsx
+++ b/apps/ai-game-creator-shell/tests/gamePublishFeedback.test.tsx
@@ -31,21 +31,6 @@ import {
 } from './styleCascade';
 import { installTauriRuntime } from './tauriRuntimeFake';
 
-const readGamePublishAvailabilityMock = vi.hoisted(() =>
-  vi.fn(async () => true),
-);
-
-vi.mock('../src/services/gameDistributionPublish', async (importOriginal) => {
-  const actual =
-    await importOriginal<
-      typeof import('../src/services/gameDistributionPublish')
-    >();
-  return {
-    ...actual,
-    readGamePublishAvailability: readGamePublishAvailabilityMock,
-  };
-});
-
 const PROJECT_PATH = '/tmp/game-publish-feedback-project';
 const PROJECT_ID = 'game-publish-feedback-project';
 
@@ -133,8 +118,6 @@ async function clickPublish() {
 
 beforeEach(() => {
   window.history.pushState({}, '', '/');
-  readGamePublishAvailabilityMock.mockReset();
-  readGamePublishAvailabilityMock.mockResolvedValue(true);
 });
 
 function createExportPackageResult() {
diff --git a/apps/ai-game-creator-shell/tests/gameRunToolbarActionsStyle.test.ts b/apps/ai-game-creator-shell/tests/gameRunToolbarActionsStyle.test.ts
index 85cdf0265..5888d3924 100644
--- a/apps/ai-game-creator-shell/tests/gameRunToolbarActionsStyle.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameRunToolbarActionsStyle.test.ts
@@ -56,12 +56,25 @@ describe('运行页顶栏动作区样式', () => {
     expect(trigger.has('border')).toBe(false);
     expect(trigger.has('background')).toBe(false);
     expect(trigger.has('color')).toBe(false);
-    expect(declaration(trigger, 'min-width')).toBe('0');
+    // 入口默认不参与收缩（`max-content`）：收缩 + 省略号会把溢出「吃掉」，顶栏的档位判定
+    // 就永远量不到真实溢出。只有降到最后一档（动作已全收进「更多」）才允许它省略兜底。
+    expect(declaration(trigger, 'min-width')).toBe('max-content');
+    expect(
+      declaration(
+        resolved([
+          ".game-workbench-toolbar[data-layout='collapsed-actions'] .game-run-version-trigger",
+        ]),
+        'min-width',
+      ),
+    ).toBe('0');
     // 省略号要真的生效：按钮是 flex 容器，文本必须挂在自带 overflow 的 span 上。
     const label = resolved(['.game-run-version-trigger-label']);
     expect(declaration(label, 'overflow')).toBe('hidden');
     expect(declaration(label, 'text-overflow')).toBe('ellipsis');
     expect(declaration(label, 'white-space')).toBe('nowrap');
+    // 括号里那一截（原因 + 时间）单独一层，窄档位收掉的就是它，序号永远留着。
+    expect(hasRule('.game-run-version-trigger-detail')).toBe(true);
+    expect(hasRule('.game-run-version-trigger-title')).toBe(true);
     expect(hasRule('.game-run-version-trigger:hover')).toBe(false);
     expect(hasRule('.game-run-version-trigger:focus-visible')).toBe(false);
 
diff --git a/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts b/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
index 4a38324a9..35d7f8b48 100644
--- a/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
@@ -293,6 +293,10 @@ describe('项目资源投影', () => {
     ]);
     expect(versions[0]?.version?.childVersionIds).toEqual(['version-child']);
     expect(versions[1]?.version?.parentVersionId).toBe('version-root');
+    // 只有最新内部版本（数组最后一条）带发布标签：它等于 `versions.length`，
+    // 也就是发布面板「项目版本」取的同一个数；角标只长在这一张卡上。
+    expect(versions[0]?.version?.publicationTag).toBeUndefined();
+    expect(versions[1]?.version?.publicationTag).toBe(2);
   });
 
   it('按稳定优先级推导资源卡类型标识并为未知类型兜底', () => {
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
index c7f2f107e..e7f10c994 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
@@ -147,8 +147,12 @@ describe('「生成任务」侧栏的开合与入口位置', () => {
       (button) => button.getAttribute('aria-label') === '按依赖',
     );
     expect(sortIndex).toBeGreaterThanOrEqual(0);
-    // 依赖 / 类型仍然收在行尾。
+    // 「依赖 / 类型」占行尾两枚（连通分段，内部 0 间距），也是动作行最后一个子元素：
+    // 顶栏里「资源管理 / 运行」与它分居这一行两端（版本入口的先后见资源版本切换用例）。
     expect(sortIndex).toBe(buttons.length - 2);
+    const sortGroup = actionsRow!.querySelector('.game-resource-sort-tabs');
+    expect(sortGroup).not.toBeNull();
+    expect(actionsRow!.lastElementChild).toBe(sortGroup);
 
     // 锚点挂在主视窗（stage）的**画布那一格**里：右上角坐标是相对画布工作面算的，
     // 不是相对整个窗口，也不会压在工具条那一行上。
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
index 1310098b7..e445ec2e9 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
@@ -372,6 +372,82 @@ describe('resource canvas layout model', () => {
     ]);
   });
 
+  it('项目版本卡按内部版本序数落位，而不是按 opaque 资源 id', () => {
+    // 版本资源 id 里的 versionId 是 opaque 标识：`initial-13` 的字符串序大于 `agent-22`。
+    // 没有显式次序键时，依赖视图会把初始版本排到最后 —— 卡面 `版本 1` 落在最右，
+    // 与「最新内部版本 = 版本 N」以及发布面板取的标签（`versions.length`）都对不上。
+    const rows = [
+      ['initial-13', 0],
+      ['agent-22', 1],
+      ['agent-42', 2],
+      ['agent-46', 3],
+      ['agent-69', 4],
+    ] as const;
+
+    const withOrderIndex = reconcileResourceCanvasLayout(
+      createEmptyResourceCanvasLayout('project-version-order', 'dependency'),
+      rows.map(([versionId, orderIndex]) => ({
+        ...resource(`version:${versionId}`, 'version'),
+        subtype: 'project-version',
+        mediaType: '正式项目版本',
+        label: `版本 ${orderIndex + 1}`,
+        orderIndex,
+      })),
+    ).layout;
+
+    // 阅读次序 = 先上后下、先左后右；它必须与 `版本 N` 的序号一致。
+    expect(
+      [...withOrderIndex.positions]
+        .sort((left, right) => left.y - right.y || left.x - right.x)
+        .map((position) => position.resourceId),
+    ).toEqual(rows.map(([versionId]) => `version:${versionId}`));
+
+    // 对照组：不带显式次序键时落位退回 opaque id，`initial-*` 排到最后 —— 这就是要修的观感。
+    const withoutOrderIndex = reconcileResourceCanvasLayout(
+      createEmptyResourceCanvasLayout('project-version-order', 'dependency'),
+      rows.map(([versionId, orderIndex]) => ({
+        ...resource(`version:${versionId}`, 'version'),
+        subtype: 'project-version',
+        mediaType: '正式项目版本',
+        label: `版本 ${orderIndex + 1}`,
+      })),
+    ).layout;
+
+    expect(
+      [...withoutOrderIndex.positions]
+        .sort((left, right) => left.y - right.y || left.x - right.x)
+        .map((position) => position.resourceId),
+    ).toEqual([
+      'version:agent-22',
+      'version:agent-42',
+      'version:agent-46',
+      'version:agent-69',
+      'version:initial-13',
+    ]);
+  });
+
+  it('类型视图的项目版本也按序数排，不按 `版本 N` 的字符串序', () => {
+    // 10 版之后 `版本 10` 的字符串序小于 `版本 2`，按 label 比会错位；显式序键不会。
+    const indexes = Array.from({ length: 10 }, (_unused, index) => index);
+
+    const typeLayout = reconcileResourceCanvasLayout(
+      createEmptyResourceCanvasLayout('project-version-type-order', 'type'),
+      indexes.map((index) => ({
+        ...resource(`version:agent-${index + 1}`, 'version'),
+        subtype: 'project-version',
+        mediaType: '正式项目版本',
+        label: `版本 ${index + 1}`,
+        orderIndex: index,
+      })),
+    ).layout;
+
+    expect(
+      [...typeLayout.positions]
+        .sort((left, right) => left.y - right.y || left.x - right.x)
+        .map((position) => position.resourceId),
+    ).toEqual(indexes.map((index) => `version:agent-${index + 1}`));
+  });
+
   it('keeps connected art cards close while placing separate components before isolates', () => {
     const layout = reconcileResourceCanvasLayout(
       createEmptyResourceCanvasLayout('project-clusters', 'dependency'),
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasVersionBindingModel.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasVersionBindingModel.test.ts
index 8468fe223..edb3b532f 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasVersionBindingModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasVersionBindingModel.test.ts
@@ -2,7 +2,9 @@ import { describe, expect, test } from 'vitest';
 
 import {
   currentVersionResourceBindingIds,
+  formatIterationVersionDetail,
   formatIterationVersionLabel,
+  formatIterationVersionTitle,
   isResourceUsedByCurrentVersion,
 } from '../src/features/resource-canvas/resourceCanvasVersionBindingModel';
 
@@ -86,10 +88,18 @@ describe('运行模块版本绑定判定', () => {
   });
 
   test('labels a version with its Chinese created reason and creation time', () => {
-    expect(formatIterationVersionLabel(versions[0]!)).toBe(
-      `初始版本 · ${new Date(1_788_075_047 * 1000).toLocaleString('zh-CN')}`,
+    // 完整标识＝`版本 N（原因 · 时间）`；`N` 取 manifest 里的落盘顺序（与资源画布
+    // 「项目卡片」上的 `版本 N` 同一编号）。
+    expect(formatIterationVersionLabel(versions[0]!, 0)).toBe(
+      `版本 1（初始版本 · ${new Date(1_788_075_047 * 1000).toLocaleString('zh-CN')}）`,
     );
-    expect(formatIterationVersionLabel(versions[1]!)).toBe(
+    expect(formatIterationVersionLabel(versions[1]!, 1)).toBe(
+      `版本 2（智能体修订 · ${new Date(1_788_075_104 * 1000).toLocaleString('zh-CN')}）`,
+    );
+    // 顶栏窄到只放得下序号时显示的就是 `formatIterationVersionTitle`，括号里那一截整段收起
+    // （样式按 `data-layout` 隐藏 `.game-run-version-trigger-detail`）。两半各自是独立口径。
+    expect(formatIterationVersionTitle(1)).toBe('版本 2');
+    expect(formatIterationVersionDetail(versions[1]!)).toBe(
       `智能体修订 · ${new Date(1_788_075_104 * 1000).toLocaleString('zh-CN')}`,
     );
   });
@@ -100,8 +110,8 @@ describe('运行模块版本绑定判定', () => {
     const createdAtLocal = new Date(1_788_075_047 * 1000).toLocaleString(
       'zh-CN',
     );
-    const label = formatIterationVersionLabel(versions[0]!);
-    expect(label).toBe(`初始版本 · ${createdAtLocal}`);
+    const label = formatIterationVersionLabel(versions[0]!, 0);
+    expect(label).toBe(`版本 1（初始版本 · ${createdAtLocal}）`);
 
     // 年 / 月 / 日必须来自真实时刻，而不是 1970。这里用显式数值选项断言，
     // 不依赖 `toLocaleString` 的具体排版（不同 ICU 版本会给出不同分隔符）。
diff --git a/apps/ai-game-creator-shell/tests/resourceVersionSwitch.test.tsx b/apps/ai-game-creator-shell/tests/resourceVersionSwitch.test.tsx
index ba5b4bf63..d5ad4462f 100644
--- a/apps/ai-game-creator-shell/tests/resourceVersionSwitch.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceVersionSwitch.test.tsx
@@ -194,6 +194,25 @@ describe('C7 运行模块版本切换', () => {
     expect(trigger.getAttribute('aria-label')).toContain('智能体修订');
   });
 
+  test('顶栏里版本入口排在「依赖 / 类型」左边，排序分段收在行尾', async () => {
+    installResourceCardIntersectionObserver();
+    renderWorkbench(createVersionedManifest());
+    await screen.findByLabelText(/^当前版本：/);
+
+    const actionsRow = document.querySelector('.game-workbench-view-actions');
+    const versionPicker = actionsRow?.querySelector('.game-run-version-picker');
+    const sortGroup = actionsRow?.querySelector('.game-resource-sort-tabs');
+    expect(actionsRow).not.toBeNull();
+    expect(versionPicker).not.toBeNull();
+    expect(sortGroup).not.toBeNull();
+    // 顶栏这一行两端是「资源管理 / 运行」与「依赖 / 类型」两枚大分组；版本入口紧邻排序分段
+    // 左侧——用户口径是「版本应该在依赖 / 类型左边」，别把版本放回最右。
+    expect(versionPicker!.compareDocumentPosition(sortGroup!)).toBe(
+      Node.DOCUMENT_POSITION_FOLLOWING,
+    );
+    expect(actionsRow!.lastElementChild).toBe(sortGroup);
+  });
+
   test('switches the current version through the entry and reports it to the host', async () => {
     installResourceCardIntersectionObserver();
     const manifest = createVersionedManifest();
diff --git a/apps/ai-game-creator-shell/tests/runAutoLoadOnEnter.test.tsx b/apps/ai-game-creator-shell/tests/runAutoLoadOnEnter.test.tsx
new file mode 100644
index 000000000..fb2e37060
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/runAutoLoadOnEnter.test.tsx
@@ -0,0 +1,182 @@
+/** @vitest-environment jsdom */
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createGameCreationAppManifest,
+  type GameCreationAppPreviewState,
+} from '../../../packages/shared/src/contracts/gameCreationApp';
+import ProjectDevelopmentView from '../src/view/project-development';
+import { installTauriRuntime } from './tauriRuntimeFake';
+
+/**
+ * 「进入项目时已经站在运行页，却没有画面」要自动载入一次。
+ *
+ * 现场：从另一个项目切过来时工作台不重挂（`mode` 是工作台自己的 state），上一条项目留下的运行
+ * 视图会原样保留，画面却已经没了；用户看到的就是「客户端运行画面尚未载入 + 点击顶部「运行」
+ * 页签」，像坏了一样。
+ */
+const OFFLINE_PREVIEW: GameCreationAppPreviewState = {
+  status: 'running',
+  url: 'https://example.com/game',
+  port: 443,
+};
+
+/** 有完成的代码原型才算「可运行」——运行页签才会真的发播放请求。 */
+function buildManifest(id: string, name: string) {
+  const manifest = createGameCreationAppManifest(id, name);
+  manifest.tasks = manifest.tasks.map((task) =>
+    task.id === 'code-prototype' ? { ...task, status: 'completed' } : task,
+  );
+  return manifest;
+}
+
+function installInvoke() {
+  installTauriRuntime({
+    core: {
+      invoke: vi.fn(async (command: string, args?: Record<string, unknown>) => {
+        if (command === 'read_local_project_resource_graph') {
+          return {
+            resourceIds: [],
+            referenceEdges: [],
+            taskFlows: [],
+            categories: [],
+            diagnostics: [],
+          };
+        }
+        if (command === 'read_local_project_resource_canvas_layout') {
+          return {
+            schemaVersion: 'game-creator-resource-layout.v1',
+            projectId: args?.expectedProjectId,
+            mode: args?.mode,
+            revision: 0,
+            positions: [],
+            updatedAt: 0,
+          };
+        }
+        throw new Error(`unexpected invoke ${command}`);
+      }),
+    },
+  });
+}
+
+function renderWorkbench({
+  projectPath,
+  name,
+  preview = OFFLINE_PREVIEW,
+  onPlay,
+}: {
+  projectPath: string;
+  name: string;
+  preview?: GameCreationAppPreviewState;
+  onPlay: () => void;
+}) {
+  installInvoke();
+  return render(
+    <ProjectDevelopmentView
+      projectName={name}
+      projectPath={projectPath}
+      manifest={buildManifest('run-auto-load', name)}
+      attachments={[]}
+      recentRunStatus="completed"
+      recentRunStopReason={null}
+      preview={preview}
+      chat={null}
+      onHomeOpen={vi.fn()}
+      onProjectsOpen={vi.fn()}
+      onNotice={vi.fn()}
+      onPlay={onPlay}
+    />,
+  );
+}
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+  vi.restoreAllMocks();
+});
+
+describe('运行视图没有画面时的自动载入', () => {
+  it('切到另一个项目时自动补一次播放，同一个项目不重复发', async () => {
+    const onPlay = vi.fn();
+    const view = renderWorkbench({
+      projectPath: '/tmp/project-a',
+      name: '项目 A',
+      onPlay,
+    });
+
+    // 先在「项目 A」上把视图切到运行（没有可嵌入的预览：切过去只有空态）。
+    fireEvent.click(screen.getByRole('tab', { name: '运行' }));
+    await screen.findByText('客户端运行画面尚未载入');
+    expect(onPlay).toHaveBeenCalledTimes(1);
+
+    // 工作台不重挂，只换项目：运行视图原样留下，画面是空的 → 自动补一次。
+    view.rerender(
+      <ProjectDevelopmentView
+        projectName="项目 B"
+        projectPath="/tmp/project-b"
+        manifest={buildManifest('run-auto-load-b', '项目 B')}
+        attachments={[]}
+        recentRunStatus={null}
+        recentRunStopReason={null}
+        preview={OFFLINE_PREVIEW}
+        chat={null}
+        onHomeOpen={vi.fn()}
+        onProjectsOpen={vi.fn()}
+        onNotice={vi.fn()}
+        onPlay={onPlay}
+      />,
+    );
+    expect(onPlay).toHaveBeenCalledTimes(2);
+
+    // 同一个项目再渲染一次（manifest 刷新、对话更新之类）不该反复发播放请求。
+    view.rerender(
+      <ProjectDevelopmentView
+        projectName="项目 B"
+        projectPath="/tmp/project-b"
+        manifest={buildManifest('run-auto-load-b', '项目 B 更新')}
+        attachments={[]}
+        recentRunStatus={null}
+        recentRunStopReason={null}
+        preview={OFFLINE_PREVIEW}
+        chat={null}
+        onHomeOpen={vi.fn()}
+        onProjectsOpen={vi.fn()}
+        onNotice={vi.fn()}
+        onPlay={onPlay}
+      />,
+    );
+    expect(onPlay).toHaveBeenCalledTimes(2);
+  });
+
+  it('点「运行」页签本身只发一次播放，不被自动载入重复触发', async () => {
+    const onPlay = vi.fn();
+    renderWorkbench({
+      projectPath: '/tmp/project-a',
+      name: '项目 A',
+      onPlay,
+    });
+
+    fireEvent.click(screen.getByRole('tab', { name: '运行' }));
+
+    expect(onPlay).toHaveBeenCalledTimes(1);
+  });
+
+  it('有活体预览时不补发：画面已经在，没必要再启动一次', async () => {
+    const onPlay = vi.fn();
+    renderWorkbench({
+      projectPath: '/tmp/project-a',
+      name: '项目 A',
+      preview: {
+        status: 'running',
+        url: 'http://127.0.0.1:4173/',
+        port: 4173,
+      },
+      onPlay,
+    });
+
+    // 会话内确认过的预览会自动切到运行视图；此时画面在，谁都不该发播放请求。
+    await screen.findByTitle('项目 A 游戏运行画面');
+    expect(onPlay).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/runPreviewRefresh.test.tsx b/apps/ai-game-creator-shell/tests/runPreviewRefresh.test.tsx
new file mode 100644
index 000000000..c0fa9213e
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/runPreviewRefresh.test.tsx
@@ -0,0 +1,115 @@
+/** @vitest-environment jsdom */
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createGameCreationAppManifest,
+  type GameCreationAppPreviewState,
+} from '../../../packages/shared/src/contracts/gameCreationApp';
+import ProjectDevelopmentView from '../src/view/project-development';
+import { installTauriRuntime } from './tauriRuntimeFake';
+
+const PREVIEW_URL = 'http://127.0.0.1:4173/';
+
+function installInvoke() {
+  installTauriRuntime({
+    core: {
+      invoke: vi.fn(async (command: string, args?: Record<string, unknown>) => {
+        if (command === 'read_local_project_resource_graph') {
+          return {
+            resourceIds: [],
+            referenceEdges: [],
+            taskFlows: [],
+            categories: [],
+            diagnostics: [],
+          };
+        }
+        if (command === 'read_local_project_resource_canvas_layout') {
+          return {
+            schemaVersion: 'game-creator-resource-layout.v1',
+            projectId: args?.expectedProjectId,
+            mode: args?.mode,
+            revision: 0,
+            positions: [],
+            updatedAt: 0,
+          };
+        }
+        throw new Error(`unexpected invoke ${command}`);
+      }),
+    },
+  });
+}
+
+function renderRunView(
+  preview: GameCreationAppPreviewState = {
+    status: 'running',
+    url: PREVIEW_URL,
+    port: 4173,
+  },
+) {
+  installInvoke();
+  const onPlay = vi.fn();
+  const manifest = createGameCreationAppManifest(
+    'run-preview-refresh',
+    '运行页刷新画面',
+  );
+  manifest.tasks = manifest.tasks.map((task) =>
+    task.id === 'code-prototype' ? { ...task, status: 'completed' } : task,
+  );
+  render(
+    <ProjectDevelopmentView
+      projectName={manifest.name}
+      projectPath="/tmp/run-preview-refresh"
+      manifest={manifest}
+      attachments={[]}
+      recentRunStatus="completed"
+      recentRunStopReason={null}
+      preview={preview}
+      chat={null}
+      onHomeOpen={vi.fn()}
+      onProjectsOpen={vi.fn()}
+      onNotice={vi.fn()}
+      onPlay={onPlay}
+    />,
+  );
+  return { onPlay };
+}
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+  vi.restoreAllMocks();
+});
+
+describe('运行页「刷新运行画面」', () => {
+  it('点一下就重新载入画面：iframe 换新节点、地址不变，并顺带把预览确认成活体', async () => {
+    const { onPlay } = renderRunView();
+    await screen.findByTitle('运行页刷新画面 游戏运行画面');
+
+    const before = document.querySelector('iframe');
+    expect(before).not.toBeNull();
+    expect(before?.getAttribute('src')).toBe(PREVIEW_URL);
+
+    fireEvent.click(screen.getByRole('button', { name: '刷新运行画面' }));
+
+    const after = document.querySelector('iframe');
+    // 换元素身份＝浏览器重新载入这一页：游戏预览不是 vite dev 的实时刷新，只有这一条路。
+    expect(after).not.toBe(before);
+    expect(after?.getAttribute('src')).toBe(PREVIEW_URL);
+    expect(onPlay).toHaveBeenCalledTimes(1);
+  });
+
+  it('没有活预览时不渲染刷新，而不是留一个点了没反应的入口', async () => {
+    // 非 loopback 地址会被 `resolveEmbeddedPreviewUrl` 拒掉。此时切到运行页只有空态，
+    // 该走的是顶栏「运行」页签——刷新入口不该在没画面可刷的时候出现。
+    renderRunView({
+      status: 'running',
+      url: 'https://example.com/game',
+      port: 443,
+    });
+
+    fireEvent.click(screen.getByRole('tab', { name: '运行' }));
+    await screen.findByText('客户端运行画面尚未载入');
+    expect(screen.queryByRole('button', { name: '刷新运行画面' })).toBeNull();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/workbenchToolbarLayout.test.ts b/apps/ai-game-creator-shell/tests/workbenchToolbarLayout.test.ts
new file mode 100644
index 000000000..1adeafedb
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/workbenchToolbarLayout.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  resolveWorkbenchToolbarLayout,
+  type WorkbenchToolbarLayout,
+} from '../src/view/project-development/workbenchToolbarModel';
+
+/**
+ * 工作台顶栏降级阶梯的判据：顺序、余量与「都放不下」的兜底。
+ *
+ * 每一档的真实宽度由 DOM 量（`useWorkbenchToolbarLayout` 把候选档位写上去再读 `scrollWidth`），
+ * 所以这里只喂一个假的量宽函数；真机几何由浏览器实测确认，这一条钉的是**顺序**。
+ */
+function ladder(
+  availableWidth: number,
+  widths: Record<WorkbenchToolbarLayout, number>,
+) {
+  const measured: WorkbenchToolbarLayout[] = [];
+  const layout = resolveWorkbenchToolbarLayout(availableWidth, (candidate) => {
+    measured.push(candidate);
+    return widths[candidate];
+  });
+  return { layout, measured };
+}
+
+describe('工作台顶栏降级阶梯', () => {
+  test('放得下就停在 full，不去量后面的档位', () => {
+    const { layout, measured } = ladder(1000, {
+      full: 900,
+      'compact-version': 800,
+      'collapsed-actions': 400,
+    });
+    expect(layout).toBe('full');
+    expect(measured).toEqual(['full']);
+  });
+
+  test('full 放不下先收版本名的括号段，动作一枚都不动', () => {
+    const { layout, measured } = ladder(1000, {
+      full: 1100,
+      'compact-version': 900,
+      'collapsed-actions': 500,
+    });
+    expect(layout).toBe('compact-version');
+    expect(measured).toEqual(['full', 'compact-version']);
+  });
+
+  test('收掉括号段还不够，才把「打开项目目录 / 资源面板 / 整理画布」收进「更多」', () => {
+    const { layout, measured } = ladder(1000, {
+      full: 1400,
+      'compact-version': 1100,
+      'collapsed-actions': 700,
+    });
+    expect(layout).toBe('collapsed-actions');
+    expect(measured).toEqual(['full', 'compact-version', 'collapsed-actions']);
+  });
+
+  test('三档都放不下时停在最后一档，不回到前面已经试过的档位', () => {
+    const { layout, measured } = ladder(500, {
+      full: 1400,
+      'compact-version': 1100,
+      'collapsed-actions': 700,
+    });
+    expect(layout).toBe('collapsed-actions');
+    expect(measured).toEqual(['full', 'compact-version', 'collapsed-actions']);
+  });
+
+  test('临界宽度留 1px 余量：正好贴边算放得下，多出 2px 才降档', () => {
+    expect(
+      ladder(1000, {
+        full: 1001,
+        'compact-version': 900,
+        'collapsed-actions': 500,
+      }).layout,
+    ).toBe('full');
+    expect(
+      ladder(1000, {
+        full: 1002,
+        'compact-version': 900,
+        'collapsed-actions': 500,
+      }).layout,
+    ).toBe('compact-version');
+  });
+});
diff --git a/docs/README.md b/docs/README.md
index c27e5d9a5..65d144aa8 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -78,6 +78,7 @@
 - [GameAgent 资源自由画板与快速编辑](./technical/【技术方案】GameAgent资源自由画板与快速编辑-2026-08-20.md)
 - [AGC 栏目画布底部工具栏入口矩阵](./technical/【AGC】栏目画布底部工具栏入口矩阵-2026-09-13.md)：栏目画布底部工具栏的入口矩阵、可用条件与验收口径。
 - [AGC 资源工作台三处交互收口改动前对照图](./technical/assets/agc-resource-workbench-ui-before-20260914/README.md)：任务侧栏两个关闭入口、左侧贴边折叠把手、顶部播放按钮居中悬浮三张改动前截图与问题说明。
+- [AGC 顶栏布局收口改动后对照图](./technical/assets/agc-toolbar-layout-after-20261004/README.md)：顶栏一行到底、版本入口钉右并三档降级、「播放」并入「运行」页签、运行画面刷新入口四张改动后截图与口径。
 - [AGC 资源派生与非破坏性编辑合同](./technical/【技术方案】AGC资源派生与非破坏性编辑合同-2026-09-09.md)：AGC 全类型现有资源非破坏性编辑的权威合同，约束资源派生、替换与写回边界。
 - [AGC 聊天素材引用](./【功能说明】AGC聊天素材引用-2026-09-08.md)：聊天输入框 @ 引用项目素材的入口、引用模型与「当前版本素材」口径。
 - [AGC 聊天 AI 润色与发送前提醒](./【功能说明】AGC聊天AI润色与发送前提醒-2026-09-10.md)：提示词润色与发送前提醒的交互、失败与取消口径。
diff --git a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
index 9e38ea713..da7403bed 100644
--- a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
+++ b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
@@ -131,7 +131,7 @@
 - 资源总览的“资源依赖 / 资源类型”视图切换使用连通的分段按钮组，相邻选项共享边界并保持唯一选中语义。每个分段都必须有清晰的键盘焦点指示，焦点环不得被分段容器的圆角或 `overflow` 裁切。
 - 右侧 Supervisor 对话中，用户消息使用右对齐、最大宽度受限的主题暖色气泡，assistant 消息保持左对齐；消息换行不得产生水平溢出，执行过程卡继续占满消息区可用宽度。消息列表必须约束在右侧对话列内并独立滚动，不得覆盖中央资源或运行视图；提交按钮必须保留随状态变化的可访问名称。气泡正文在 light / dark 平台主题下均须满足 WCAG AA 普通文本 `4.5:1` 对比度。
 - 客户端正式产品仍只按最小 `1280×720` 横屏合同交付，并保留 `1280×800` 默认窗口与既有基线验收；更窄浏览器样式只负责不崩溃和开发兼容，不改成移动端创作工作台。
-- 工作台顶部播放按钮紧贴「资源管理 / 运行」模式切换之后、整组左对齐；不再在桌面视窗中水平居中悬浮；两个页签下都常驻（运行视图空态与预览失败态要靠它重跑）。资源管理视窗触发播放时直接切换到运行视窗并启动本地预览，不再弹出 `game.run_local` 二次确认。
+- 工作台顶部工具条固定**一行到底**，**两枚体量最大的分组控件分居这一行两端**：左端「资源管理 / 运行」模式分段，右端「依赖 / 类型」排序分段；中间依次是动作按钮与版本入口，**版本入口紧邻排序分段左侧**（不放在最右）、固定显示 `版本 N`，空间够时补上括号里的「创建原因 + 时间」。「运行」页签本身就是播放入口（页签前带 ▶ 图标；切过去即启动本地预览，不再单开一枚「播放」按钮，也不再弹出 `game.run_local` 二次确认；运行视图空态与预览失败态靠再点一次该页签重跑，不可运行时页签不置灰、点了不切视图并出提示）。**站在运行视图上却没有画面时自动补发一次载入**（典型场景：从别的项目切过来，工作台不重挂，运行视图原样留下而画面已经没了），同一个项目只自动补一次，画面已在就不重复启动。空间不足按固定顺序降级：先只留 `版本 N`，再把「打开项目目录 / 资源面板 / 整理画布」收进「更多」下拉——任何宽度都不把控件甩到第二行，右端始终由「依赖 / 类型」收住。运行画面右下角提供「刷新运行画面」：游戏预览不是实时刷新，改完代码需要重载页面。
 - 创建模式素材画布的“素材名称”是用户可编辑的正式输出名称；“资源用途”是 manifest subtype，不向普通用户开放自由文本。新增资源默认“普通游戏美术”，可从普通游戏美术、统一视觉规范、游戏界面原型、核心美术图集四项中选择。图片精修继承源名称和用途，不显示创建模式保存设置；候选图片只从选中图片的“设为最终图”提交。精修顶栏只保留返回、导入、定位当前最终图、撤销和重做，删除进入图片上下文工具栏，通用 AI 生成只保留给创建模式。图片输出统一使用 PNG；创建模式工具动作与保存设置分层展示，“保存到项目”在 `1280×800` 和窄容器中都必须完整可见。
 - 首页创作输入区与“最近项目”之间不展示共享项目状态文本，“最近项目”标题下也不追加解释性副标题；默认、成功、进行中或失败状态均不得在该位置形成文字行，项目管理页继续保留自己的状态反馈。
 
diff --git a/docs/project-memory/plans/【实施计划】AGC发布版本以工程内部版本为准-2026-10-03.md b/docs/project-memory/plans/【实施计划】AGC发布版本以工程内部版本为准-2026-10-03.md
new file mode 100644
index 000000000..493160ff5
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】AGC发布版本以工程内部版本为准-2026-10-03.md
@@ -0,0 +1,87 @@
+# 【实施计划】AGC 发布版本以工程内部版本为准
+
+| 字段 | 值 |
+| --- | --- |
+| Milestone | `docs/project-memory/plans/【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md` |
+| Status | proposed |
+| Owner | Genarrative Agent |
+| 关联 | PR #565（`feat/game-works-management`）；取代 `【里程碑/实施计划】AGC已发布游戏版本更新-2026-10-02` 中「用户可编辑发行版本标签」的口径 |
+
+## 修改边界（不动的东西）
+
+- 不改 `server-rs/crates/{spacetime-module,module-game-distribution,api-server,spacetime-client}`：服务端 `versionNumber` 语义与 `publicationRevision` CAS 保持不变。
+- 不改 `apps/admin-web/**`、不改 `src-tauri/src/project/export.rs`（两者正被其它 worker 修改）。
+- 不删除本地字段 `projectVersion`（Rust DTO 带 `deny_unknown_fields`：`server-rs/crates/shared-contracts/src/game_creation_app.rs:1121`）。
+
+## 修改顺序
+
+1. 文档：主规范改写 → 本里程碑 → 本实现计划 → `decision-log` 条目 → 两份 2026-10-02 计划文档的取代标注。
+2. 契约：TS 解析器改为内部版本派生。
+3. Rust：拆掉两条 `project_version` 写链路 + 删除手改命令。
+4. 渲染层：面板改只读派生、删失焦写回与 `onManifestUpdated`。
+5. service：删保存函数、改默认值与注释。
+6. 测试改写 + 门禁全跑。
+
+## 逐条改动（文件 → 位置 → 改什么 → 验收）
+
+| # | 文件 | 位置 | 改什么 | 验收 |
+| --- | --- | --- | --- | --- |
+| 1 | `packages/shared/src/contracts/gameCreationApp.ts` | `:1001-1013` | `resolveGameCreationAppProjectVersion` 去掉 `binding` 形参，返回 `versions.length > 0 ? versions.length : GAME_CREATION_APP_FIRST_PROJECT_VERSION`；注释改为「唯一来源 = 工程内部版本」 | `npm run agc:typecheck`；面板/服务用例 |
+| 2 | 同上 | `:1034-1037` | `projectVersion?: number \| null` 保留，注释改「遗留位：旧清单兼容读，不再读写」 | 静态检查 |
+| 3 | `server-rs/crates/shared-contracts/src/game_creation_app.rs` | `:1107-1118`、`:1090-1096` | 删 `resolve_game_creation_app_project_version` 与 `GAME_CREATION_APP_FIRST_PROJECT_VERSION` / `is_game_creation_app_project_version`；对应单测改为「字段被忽略」 | `cargo test -p shared-contracts` |
+| 4 | 同上 | `:1146-1150` | `project_version` 字段保留，注释改「遗留：仅为旧清单可解析，不再读写」 | 同上 |
+| 5 | `apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs` | `:24-27` | 去掉解析器 import | `cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml game_distribution_publish` |
+| 6 | 同上 | `:536-541`（`write_publication_binding`） | 删除 `manifest.project_version = Some(resolve(...))`，改为置 `None`；保留 `manifest.publication = Some(binding.clone())` | 同上 + `jq` 自检 |
+| 7 | 同上 | `:1531-1535`（发布成功回写） | 删除 `manifest.project_version = Some(version.version_number)`，改为置 `None`；保留 publication 回写 | 同上 |
+| 8 | 同上 | `:944-965` | 删除 `update_game_distribution_project_version` 命令 | 编译 + `rg` 零命中 |
+| 9 | `apps/ai-game-creator-shell/src-tauri/src/desktop.rs` | `:614` | 从 invoke handler 清单删除该命令 | 编译 |
+| 10 | `apps/ai-game-creator-shell/scripts/check-config.mjs` | `:138` | 从命令注册表删除 `'update_game_distribution_project_version'` | `npm run agc:typecheck` |
+| 11 | `apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts` | `:148-167` | 删除 `saveGameDistributionProjectVersion` | typecheck + 用例 |
+| 12 | 同上 | `:329-337`、`:362-363` | 注释改为「唯一来源 = 工程内部版本」；默认值 `args.versionNumber ?? resolveGameCreationAppProjectVersion(args.manifest)` | 同上 |
+| 13 | `apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx` | `:129-136`、`:283-288`、`:331-332`、`:397-403`、`:683-708`、`:731-734`、`:804` | 删 `parseProjectVersion`、`projectVersion`/`savedProjectVersion` state、`projectVersionSaveRequestRef`、`handleProjectVersionCommit` 与三处 setState；新增派生值 `useMemo(() => resolveGameCreationAppProjectVersion(manifest), [manifest.versions])`；提交改为 `versionNumber: projectVersion` | 面板用例 |
+| 14 | 同上 | `:947-1000` | 「项目版本」输入框改 `readOnly`（保留 `aria-label="项目版本"`），删 `onChange`/`onBlur`/`disabled`；提示语改为「来自 AGC 内部版本（版本 N）…」 | 面板用例 |
+| 15 | 同上 | `:242-243`、`:700` | 删除 `onManifestUpdated` prop 与唯一调用点 | typecheck |
+| 16 | `apps/ai-game-creator-shell/src/App.tsx` | `:1816`、`:1951` | 删除两处 `onManifestUpdated={setManifest}` | typecheck |
+| 17 | `apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx` | `:735-761`、`:778-823`、`:825-868` | 前两条改为「标签 = 内部版本数」；后两条（失焦写回 / 非法回退）整块删除；fixture `MANIFEST` 补非空 `versions` | vitest |
+| 18 | `apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts` | `:319-420` | 删 `saveGameDistributionProjectVersion` 用例块；默认值断言改为「无 `versions` → 1；N 条 → N」 | vitest |
+| 19 | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md` | `:97`、`:99`、`:106` + 新增两条 | 见主规范新条款 | `npm run check:doc-index` |
+| 20 | `docs/project-memory/plans/【实施计划】AGC已发布游戏版本更新-2026-10-02.md` | `:11`、`:23` | 行内追加「被 2026-10-03 里程碑取代」标注 | 阅读 |
+| 21 | `docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md` | `:27-30` | 同上，逐条标注被取代/收窄 | 阅读 |
+| 22 | `docs/project-memory/shared-memory/decision-log.md` | 最新条目区 | 追加本决策条目 | `npm run check:doc-index` |
+
+## 验证命令
+
+```bash
+npx vitest run apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts \
+  apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx \
+  apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
+npm run agc:typecheck
+cd server-rs && cargo test -p shared-contracts
+cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml game_distribution_publish
+npm run check:doc-index
+npm run check:encoding
+git diff --check
+# 静态断言：命令与字段来源都已拆干净
+rg -n "update_game_distribution_project_version" .            # 期望 0 命中
+rg -n "projectVersion" apps/ai-game-creator-shell/src packages/shared/src  # 期望仅剩遗留声明/注释
+```
+
+## 数据迁移
+
+- 无迁移脚本。读路径立即忽略 `projectVersion`；改动点 6/7 会在下一次「平台回读绑定 / 发布成功」时把它置空，`skip_serializing_if` 使该键随下次落盘消失。
+- 平台侧历史版本行不做任何改写（不可变留痕）。
+
+## 风险与回滚点
+
+- 回滚点：只动 AGC 客户端 + 本地契约 + 文档；回滚 = 还原提交，服务端数据无副作用。
+- 旧客户端降级：清单里 `projectVersion` 被置空后，旧版 AGC 会回落到绑定 `latestVersionNumber`（旧行为重现），仅影响本机，需写 release note。
+- 派生标签会因「截尾删除版本」而回退（删素材连带删版本），平台接受该回退，但会产生「同一标签先后指向不同包」——这属平台现行契约允许的形态（用户手动重复提交同版本同样会产生）。
+
+## 不做（本里程碑之外）
+
+1. 「线上最近提交 vN」加「（平台）」字样（纯文案）。
+2. 平台历史版本号对齐（**明确不做**：不可变历史行无改写入口，会破坏审核留痕）。
+3. 后台/作者侧的「同标签多实例」可辨识列（落在 `apps/admin-web/**`，正被其它 worker 修改）。
+4. 「截尾删除致标签回退」的产品兜底（引入单调计数器 = 新字段 = SpacetimeDB schema 变更，须单独评审）。
+5. `edit-<operationId>` 形状的资源编辑版本是否计入内部版本序数（当前计入，与资源卡口径一致）。
+6. 旧客户端降级提示写 release note。
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..b1785378a
--- /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`：本地唯一 `projectVersion` 和 `publication` 绑定，不混入内部编辑迭代 `versions[]`。**（2026-10-03 取代：发布标签改为由工程内部 `versions[]` 派生、只读；`projectVersion` 降级为不再读写的遗留兼容位，见 `【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md`。）**
+- `packages/shared/src/contracts/gameDistribution.ts` 与 Rust shared-contracts：创建版本请求支持正整数 `versionNumber`，允许重复标签提交。
+- `apps/ai-game-creator-shell`：绑定回读、首次发布/更新 UI、项目版本输入、原 gameId 新提交、结果回写。
+- `api-server`、`spacetime-client`、`spacetime-module`：创建版本事务只校验正整数；同 gameId/同 versionNumber 生成新 versionId，publicationRevision 继续 CAS。
+- 现有创建版本 procedure 输入/生成绑定需要同步，但不修改持久表字段。
+
+## 实现顺序
+
+1. 契约先补唯一 `projectVersion` 和本地 publication，明确 versionId/版本标签/内部 projectRevision 的边界。
+2. 创建版本事务不再要求大于 max；未传时保留旧客户端自动递增，传入时校验正整数，并按同版本最新有效提交处理 pending 替代。
+3. AGC 发布绑定保存 gameId、最新 versionId、状态和 revision；按账号和 API origin 隔离绑定。
+4. AGC 打开项目回读已有作品；旧项目通过 localProjectId 恢复关联。
+5. 发布面板编辑 projectVersion，区分首次发布/更新，允许重复提交和回退，不再存在独立 targetVersion。**（2026-10-03 取代：面板不再编辑版本标签，标签由工程内部 `versions[]` 派生且只读；仍区分首次发布/更新。）**
+6. Rust 发布 facade 在更新模式跳过 create game，使用原 gameId 创建新 version；幂等账本把目标 projectVersion、资料和提交意图纳入发布意图。
+7. 验证重复提交同版本、回退版本、响应丢失、切换账号、publicationRevision 冲突和旧公开版本继续可玩。
+
+## 数据库影响
+
+- 不新增表。
+- 不修改 `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/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md b/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md
new file mode 100644
index 000000000..5239fcc45
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md
@@ -0,0 +1,81 @@
+# 【实施计划】游戏作品管理与客户端发布收口-2026-09-30
+
+关联 Issue：`#470`「做一下创作者作品管理，从工具到平台的一键导出和发布」。
+分支：`feat/game-works-management`。
+
+## 目标
+
+在 10.7「陶泥儿游戏平台」上线前，把「创作者作品管理（用户侧 / 后台）+ 客户端打包上传（只保证 Phaser 4）」这条链路补齐到可用：作品能进来、能看得见状态、能管住。
+
+- 发布管道（AGC 构建打包 → 8 MiB 分片上传 → 送审 → 后台审核 → 公开可玩 → 发行网关）已实现，并有真实栈证据（见[实施计划【游戏分发阶段A领域合同】](【实施计划】游戏分发阶段A领域合同-2026-09-19.md)）。
+- 本轮已补齐：客户端 Phaser 4 + Vite 工程栈门禁、发布阶段/上传百分比、发布根幂等账本；Web 作者私有详情、状态/版本筛选、版本历史、资料编辑、软删除和作者操作；后台作品搜索、作者/状态筛选、游标分页与删除状态展示。
+- 生产发布开关仍默认关闭；真实客户端 GUI 发布、生产首个作品和发布包清理策略仍需运行时取证。
+
+## 已落地（本分支）
+
+| 项 | 落点 | 证据 |
+| --- | --- | --- |
+| 作者读自己名下单个游戏详情 `GET /api/game-distribution/my-games/{gameId}` | `api-server/src/modules/game_distribution.rs`（`get_owner_game`、`load_owner_game_versions`、`owner_game_entry_payload`） | `cargo test -p api-server game_distribution::tests` → 26 passed；`owner_game_entry_payload_carries_private_versions_that_public_payload_omits` 断言作者条目带版本私有状态、公开投影不带 |
+| 版本私有状态补 `entryUrl` / `packageFileCount` | 同上 `private_version_payload` | 同上测试断言 |
+| 主规范路由表登记新路由并修正 `/my/games` 错名 | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md` 路由表 | — |
+
+设计要点：不新增 SpacetimeDB 表与 procedure。详情路由的 game 走 `get_game_distribution_game`（owner 作用域，精确命中），版本沿用作者自有列表 procedure 的聚合结果。
+
+## 计划与落地状态
+
+### 波 1：闭环可用
+
+- [ ] AGC 真机把「构建 → 打包 → 分片上传 → 送审」跑通一次。
+- [x] 发布进度接线：前端监听既有 `game-package-upload-progress`，渲染真实阶段与百分比。
+- [x] 幂等键落盘：按账号、origin、本地项目和包摘要持久化根键，重试复用同一 key。
+- [ ] 运营开闸 + 生产发布第一个作品，走完审核 → 公开 → 游客可玩。
+
+### 波 2：管理完整
+
+- [x] 作品资料编辑：展示资料在 `game` 级可编辑、立即生效并留审计；包仍随版本冻结。
+- [x] 作品软删除：`game_distribution_game` 末尾追加 `deleted_at`，公开投影与列表过滤软删行。
+- [x] 网页侧对齐：`/games/mine` 补删除、资料编辑、版本历史、作者查看未公开作品。
+- [x] 后台作品列表：游标分页 + 搜索 + 按作者/状态筛选。
+
+### 波 3：运营治理
+
+11. 审核历史展示（复用版本已有的 `reviewed_by_user_id` / `submitted_at` / `reviewed_at` / `published_at`，不新增表）。
+12. 批量审核操作。
+13. 精选 / 推荐位（与游玩线的推荐排序定边界）。
+14. 举报处理（先确认能否复用现役反馈管道）。
+
+## 尚未完成
+
+- AGC 真机 GUI 端到端发布取证。
+- 生产环境发布第一个作品并开闸。
+- 非 Phaser（Godot / Cocos / Unity）发布的主动拦截：这些工程没有 npm 构建工作区，仍只给泛化错误文案（单 HTML 项目同理）。
+- 发布包清理策略的上线验收。
+
+## 不变式
+
+- 新增字段一律追加到 Rust 表结构体末尾并带明确默认值；不改名、不重排、不改类型。改 schema 后同步 `migration.rs`、表目录与生成绑定，并跑 `npm run check:spacetime-schema`。
+- 公开投影不得携带作者私有字段（包摘要、驳回理由、文档本地路径）。作者视角走 owner 作用域路由。
+- 复用现役管道与组件，不新造上传、审核、发行通道。
+
+## 波 1 · AGC 客户端发布切片（2026-10-01 落地；自动门禁已通过，真实 GUI/生产待验收）
+
+| 项 | 落点 | 行为 |
+| --- | --- | --- |
+| 发布进度接线 | `src-tauri/src/game_package_upload.rs`、`game_distribution_publish.rs`、`commands.rs`、`src/services/gamePackageUploadProgress.ts`、`src/components/game-distribution/GamePublishProgressDialog.tsx`、`GamePublishPhaseSteps.tsx`、`GameDistributionPublishPanel.tsx`、`App.tsx` | 既有 `game-package-upload-progress` 事件扩展出 `phase`（`prepare` / `upload` / `verify` / `submit`）与 `message`，上传阶段仍带 `receivedBytes` / `totalBytes`；`/complete`（重算摘要 + 展开清单）之前由上传器回调切到「校验」。渲染层在全屏进度弹窗显示「构建」步骤，在发布面板显示「构建 → 准备 → 上传 → 校验 → 送审」步骤条与上传百分比。 |
+| 根幂等键落盘 | 新增 `src-tauri/src/game_publish_attempt.rs`（应用数据目录 `game-publish-attempts.json`，原子写 + 进程内锁） | 键按「账号 + origin + 本地项目 + 归一化包摘要」解析：同一份包重发、响应丢失、进程重启与分片续传复用同一根键（服务端因此只认一次尝试）；送审成功后清除记录，下一次发布会新增版本。渲染层不再铸键，`publishLocalProjectGame` 只在显式传入时才带 `idempotencyKey`。账本只存账号标识、origin、本地项目标识、包摘要与根键，不含 token 与本地绝对路径。 |
+| 发布前工程栈校验 | `src-tauri/src/project/export.rs`（`ensure_publish_project_stack`，导出与发布两条入口都调用） | 存在 npm 构建工作区时要求 Phaser 4 + Vite：缺 `phaser` 依赖、声明的主版本不是 4（含 `package-lock.json` 回退判定）、以及既没有 `vite` 依赖也没有 `vite.config.*` 都给出可操作中文错误（指明缺什么、当前声明、怎么修）。没有 npm 工作区的老单文件项目保持原有发布能力。 |
+
+## 已知限制
+
+- 作者自有游戏列表与新增的作者详情共享同一个单次条数上限（48）：单作者作品数超过上限时，详情页拿不到版本记录。放量前需要补一条按 `gameId` 精确列版本的 procedure。
+- 客户端不暴露 `localProjectId`：本地项目与线上作品的对应关系由客户端本地账本维护，服务端只在发布时用它复用 `gameId`。
+- 发布尝试账本按「本地项目 + 包摘要」判同一尝试：改了工程或重新导出了不同内容的包就是新尝试（新建版本），旧版本的半成品包仍需走网页作者侧的恢复/重置入口。
+- 发布阶段条按「本次订阅窗口」收敛（事件的 `versionId` 在命令返回前对渲染层不可知）；同一窗口同一时刻只有一次发布在跑。
+- 工程栈校验按首版「只支持 Phaser 4」执行：npm 工程（含 Three.js 等三维工程）未声明 `phaser` 会被拦下并提示安装 Phaser 4。若产品决定放行其它 npm 技术栈，需要在这里改成「phaser 声明存在时必须是 4，其余技术栈按白名单放行」。
+
+## 尚未完成
+
+- AGC 真机 GUI 端到端发布取证。
+- 生产环境发布第一个作品并开闸。
+- 非 Phaser（Godot / Cocos / Unity）发布的主动拦截：这些工程没有 npm 构建工作区，仍只给泛化错误文案（单 HTML 项目同理）。
+- 发布包清理策略的上线验收。
diff --git a/docs/project-memory/plans/【实施计划】游戏分发阶段C-AGC发布资料AI生成-2026-09-23.md b/docs/project-memory/plans/【实施计划】游戏分发阶段C-AGC发布资料AI生成-2026-09-23.md
index 646340772..f012f3802 100644
--- a/docs/project-memory/plans/【实施计划】游戏分发阶段C-AGC发布资料AI生成-2026-09-23.md
+++ b/docs/project-memory/plans/【实施计划】游戏分发阶段C-AGC发布资料AI生成-2026-09-23.md
@@ -49,6 +49,8 @@ AGC 发布面板完成三项收敛：
 ## 6. 本次缺陷修复记录
 
 - 2026-09-23：AGC 生成游戏封面请求补充 `generationInputs.source = "ai-game-creator-client"`。队列 worker 依据该来源选择 `GameCreatorResourceEditor` 结果契约；未标记来源时会按 `Standard` 紧凑化并省略 `result`，导致生成完成后无法回传 `assetObjectId`。对应前端定向测试已锁定请求字段与平台素材 ID 回填链路。
+- 2026-10-02：生成结果中的 `imageSrc/objectKey` 是私有素材引用，不再直接交给 WebView `<img>`；AGC Rust 发布 facade 经鉴权 `read-url` 有界下载为 `data:` 图片预览，预览失败不阻断已登记素材发布。
+
 ## 7. 本轮核对（2026-09-28）
 
 六项交付结果都在合并后的工作树里，并有本轮实测：
diff --git a/docs/project-memory/plans/【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md b/docs/project-memory/plans/【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md
new file mode 100644
index 000000000..50fd9d40d
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md
@@ -0,0 +1,33 @@
+# 【里程碑】AGC 发布版本以工程内部版本为准
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 1.0 |
+| Status | proposed |
+| Date | 2026-10-03 |
+| Parent Spec | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md`（「身份、状态、审核与更新」章） |
+
+## 目标
+
+让 AGC 发布面板的「项目版本」只有一个权威来源：AGC 工程内部版本记录 `manifest.versions[]`（即资源总览「项目版本」栏目里的版本卡）。标签等于当前存活的内部版本条数（最新卡的「版本 N」），只读、不可手填、不被平台 `version_number` 回填或覆盖，与 `publicationRevision` 无关。
+
+## 边界
+
+- 不改服务端能力：`publicationRevision` 继续严格 CAS；平台 `versionNumber` 继续接受正整数、重复与回退（网页端与历史客户端依赖该兼容口径）。
+- 不新增或修改 SpacetimeDB 表、字段与 procedure；`game_distribution_version.version_number` 不动。
+- 不重写平台历史版本行；不改公开地址、审核状态机与发行网关。
+- 不做版本历史页、版本对比、一键回滚 UI。
+- 不删除本地清单字段 `projectVersion`（Rust DTO 带 `deny_unknown_fields`，删除会让存量清单解析失败），它降级为不再读写的兼容位。
+
+## 验收标准
+
+- [ ] 发布面板显示的「项目版本」等于当前 `manifest.versions` 的条数（`versions` 为空时为 1），与平台 `version_number`、`publicationRevision` 均无关。
+- [ ] 面板不提供任何修改该值的入口；提交时 `versionNumber` 逐字等于该派生值。
+- [ ] 打开已有线上作品（线上最近提交 v6、内部版本 4 条）时，面板显示 v4，且仍并列显示「线上最近提交 v6 · 审核中」。
+- [ ] AGC 任何路径都不再写入 `projectVersion`（含发布成功回写、绑定回读回填、面板失焦写回）。
+- [ ] 存量清单里已有的 `projectVersion` 值不影响展示与提交。
+- [ ] 内部版本被截尾删除（长度 4 → 3）后，面板显示 v3 且能正常提交，不需要任何本地冲突处理。
+
+## 依赖
+
+- 无外部依赖；与「AGC 已发布游戏版本更新（2026-10-02）」是**取代**关系（见该文档内的取代标注）。
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..c2545dc96
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md
@@ -0,0 +1,33 @@
+# 【里程碑】AGC 已发布游戏版本更新
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 1.0 |
+| Status | proposed |
+| Date | 2026-10-02 |
+| Parent Spec | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md#AGC 游戏分发与在线游玩合同` |
+
+## 目标
+
+让 AGC 区分首次发布与已有作品更新：已有作品继续使用原 `gameId`；用户维护唯一项目发行版本标签，同一标签可以重复提交或回退，具体提交由不可变 `versionId` 标识。
+- 同一 `gameId` 的新版本上传、校验、送审和结果回写。
+
+## 不在范围内
+
+- AGC 完整版本历史页、版本对比和一键回滚 UI；回退版本标签的发布路径属于本里程碑。
+- 原地替换已发布 `versionId`；已发布提交保持不可变。
+- 新增 SpacetimeDB 持久表或修改 `game_distribution_version.version_number` 类型。
+- 改变公开 URL、审核状态机、发行网关或后台审核权限。
+
+## 验收标准
+
+- [ ] 首次发布完成后项目清单保存 `gameId`、`versionId`、版本号、状态和 `publicationRevision`。
+- [ ] 重新打开同一项目显示“更新游戏”，不再显示“创建平台游戏”。
+- [ ] 项目清单只有一个用户发行版本字段，发布面板编辑它，不存在独立 targetVersion。**（2026-10-03 取代：发布标签改由 AGC 工程内部 `versions[]` 派生且只读，面板不再编辑；见 `【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md`。）**
+- [ ] 同一 `gameId`、同一 `versionNumber` 可以重复提交，生成新的 `versionId`，不覆盖旧公开实例。
+- [ ] 项目版本可以低于线上最新版本，服务端允许回退标签，但仍校验为正整数。**（2026-10-03 收窄：平台侧继续成立；AGC 侧不再由用户手填回退，派生标签只在内部版本被截尾删除时变小。）**
+- [ ] 同版本旧 pending 提交被取消或被最新提交替代，审核队列不产生重复有效任务。
+- [ ] `publicationRevision` 仍用于并发 CAS，与用户版本号规则独立。
+- [ ] 更新使用同一 `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..ffceb220c
--- /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/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 40c41e769..7b9537951 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -1,5 +1,18 @@
 # 决策记录
 
+## 2026-10-03 AGC 发布版本标签改为由工程内部版本派生，取代「用户可编辑标签」口径
+
+- 背景：用户实机验收指出发布面板「项目版本」显示 v6，而 AGC 工程内部只有 4 条正式版本记录（资源总览「项目版本」栏目 4 张卡，顶栏「智能体修订」下拉同样只有这 4 条）。核实：面板值来自本地清单 `manifest.projectVersion` 这个可编辑标量，它被三条链路反复钉到**平台** `game_distribution_version.version_number` 上——发布成功回写（`apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs:1531-1535`）、打开面板回读绑定回填（`:536-541`）、用户手改（`:944-965`）；而 `manifest.versions` 从头到尾不参与该值。`publicationRevision` 只做 CAS，与任何版本号都无推导关系（`module-game-distribution/src/domain.rs:27-40` 的版本号解析只比 `max_existing` 与 `requested`）。
+- 决策：AGC 发布面板的「项目版本」改为**由 AGC 工程内部版本记录 `versions[]` 派生**（标签 = 当前存活内部版本条数，即最新版本卡的「版本 N」，空数组取 1），**只读**，且不得被平台 `version_number` 回填或覆盖、不得读取 `publicationRevision`。平台侧 `versionNumber` 语义不变（正整数、允许重复与回退；`None` 仍自动 `max+1` 以兼容网页端与历史客户端）。本地字段 `projectVersion` 降级为遗留兼容位：保留可解析、不再读写（Rust DTO 带 `deny_unknown_fields`，删字段会让存量清单解析失败）。
+- 取代（逐条）：
+  1. `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md:97,99`（原「项目清单保存唯一用户发行版本 `projectVersion`」「AGC 发布面板直接编辑项目清单的 `projectVersion`」）→ 已就地改写为「派生只读 + 遗留兼容位」。
+  2. 同文件原 `:105`（「允许用户修改项目版本标签、重复提交同版本和回退到旧版本标签」）→ 已就地改写为「用户不再编辑版本标签；回退与重复仍由平台侧接受」。
+  3. `docs/project-memory/plans/【实施计划】AGC已发布游戏版本更新-2026-10-02.md:11,23`（「本地唯一 `projectVersion`…不混入内部编辑迭代 `versions[]`」「发布面板编辑 `projectVersion`」）→ 行内追加取代标注。
+  4. `docs/project-memory/plans/【里程碑】AGC已发布游戏版本更新-2026-10-02.md:27-30` 的验收项「项目清单只有一个用户发行版本字段，发布面板编辑它」被取代；「项目版本可以低于线上最新版本」在平台侧继续成立，AGC 侧口径改为「派生标签可能因截尾删除而变小」。
+- 边界：不改 SpacetimeDB 表/字段/procedure，不改 `publicationRevision` CAS，不改公开地址与审核状态机，不重写平台历史版本行，不做版本历史/回滚 UI。AGC 工程内部版本 `versions` 只能追加或按显式放行删除一个后缀（删素材连带删版本），因此派生标签不保证单调；平台必须继续接受回退标签。
+- 影响范围：`packages/shared/src/contracts/gameCreationApp.ts`、`server-rs/crates/shared-contracts/src/game_creation_app.rs`、`apps/ai-game-creator-shell/src-tauri/src/{game_distribution_publish.rs,desktop.rs}`、`apps/ai-game-creator-shell/src/{services/gameDistributionPublish.ts,components/game-distribution/GameDistributionPublishPanel.tsx,App.tsx}`、`apps/ai-game-creator-shell/scripts/check-config.mjs`、`apps/ai-game-creator-shell/tests/**`、`docs/【玩法创作】平台入口与玩法链路-2026-05-15.md`、`docs/project-memory/plans/`。
+- 验证方式：`npx vitest run …gameDistributionPublish*.test.*`、`npm run agc:typecheck`（含 `scripts/check-config.mjs`）、`cargo test -p shared-contracts`、`cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml game_distribution_publish`、`npm run check:doc-index`、`npm run check:encoding`、`git diff --check`；真机：内部版本 4 条、线上最近提交 v6 的项目打开面板显示 v4 且只读，提交 `versionNumber: 4`。
+- 关联文档：[平台入口与玩法链路](../../【玩法创作】平台入口与玩法链路-2026-05-15.md)、[里程碑](【里程碑】AGC发布版本以工程内部版本为准-2026-10-03.md)。
 ## 2026-10-04 游戏游玩次数修订：关停不强制 flush、flush 失败丢弃剩余分片、客户端 IP 只信 X-Real-IP
 
 - 变更：ADR `docs/adr/【ADR】游戏游玩次数计数-2026-10-03.md` 修订——原「正常 SIGTERM/滚动重启必须在 `finalize_shutdown` 内 force flush」作废；崩溃、被杀、正常关停都允许丢最后一个未落库窗口，`api-server` 不再注册关停 flush。
@@ -19,6 +32,18 @@
 - 权威文档：`docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md` 的 `game_distribution_game` 节，以及 `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md` 的「游玩计数（已实现）」节。
 - 验证：`cargo check -p api-server` 与 `cargo test -p api-server game_play_counter`（9 passed）通过；前端定向 vitest（点击上报断言 + clientId 稳定性）与 `eslint --max-warnings 0` 通过；`npm run check:server-rs-ddd`、`npm run check:generated-bindings`、`npm run check:encoding`、`npm run check:doc-index`、`git diff --check` 通过。
 
+## 2026-10-04 AGC 工作台顶栏一行到底：三档降级 + 播放并入运行页签 + 运行画面刷新
+
+- 背景：用户现场截图指出四个问题（改动前的形态与口径见 `docs/technical/assets/agc-toolbar-layout-after-20261004/README.md`）：① 顶栏放不下时两侧容器各自 `flex-wrap: wrap`，第二行只剩「播放」与版本入口，两行控件分裂；② 版本入口不贴右缘，被前面按钮的文本宽度顶开；③「播放」与「运行」两个入口说的是同一件事；④ 运行画面里的游戏不是 vite dev 的实时刷新，改完代码只能切到资源管理再切回来才能重载页面（飞书讨论里提的「单独的刷新」）。
+- 决策（顶栏排版）：工具条改**一行到底**（`flex-wrap: nowrap` + `overflow: hidden`），空间不足不再换行，而是按固定顺序降级、档位写在工具条的 `data-layout` 上：`full` → `compact-version`（版本入口只留 `版本 N`）→ `collapsed-actions`（`打开项目目录 / 资源面板 / 整理画布` 收进「更多」下拉）。顺序与 1px 判定余量是纯函数（`workbenchToolbarModel.ts`，单独用例钉顺序）；档位由 `useWorkbenchToolbarLayout` 实测写入——`ResizeObserver` 管可用宽度、`MutationObserver` 管**内容**变化（切运行页、出现「恢复草稿」都不改顶栏宽度，只看尺寸会停在旧档位上），每次量宽都把候选档位真的写到 DOM 再读 `scrollWidth`。档位不参与 React 状态：写的是工具条自己的属性，React 不声明就不会覆盖；也没用容器查询（阈值随模式与按钮出现与否变化，写死必然抖）。
+- 决策（两个「吞掉溢出」的坑，都是实测踩出来的）：`overflow: hidden` 的 flex 子项能缩到 0 或靠省略号吸收溢出，档位判定就永远量不到真实溢出——所以版本入口默认 `min-width: max-content`（只在 `collapsed-actions` 档放开为 `0`，那一档已退无可退，省略号才是兜底）、「依赖 / 类型」分段补 `flex: 0 0 auto`（此前窄宽度下被压成 0 宽）。`max-width: 1000px` / `max-width: 760px` 两处把工具条改成 `flex-direction: column` 的媒体查询删除（那是「第二行」的另一个来源，降级已由档位负责），`≤1000px` 里给动作区的 `justify-content: flex-end` 一并删除（溢出会甩到左边，`scrollWidth` 看不见）。最后一档确实放不下时（视口远小于 1280 合同宽度）才改右对齐：宁可裁左边，也不把钉在最右的版本入口裁没。
+- 决策（版本入口与两端分组）：工具条这一行**两端留给体量最大的两枚分组控件**——左端「资源管理 / 运行」、右端「依赖 / 类型」（用户口径：「最大的这两个放两边」），中间依次是动作按钮与版本入口；版本入口 `margin-left: auto` 推到动作区右侧，且紧邻排序分段左侧（用户口径：「版本应该在依赖 / 类型左边」），不再是最右那一枚。显示 `版本 N（原因 · 时间）`，其中 `版本 N` 复用资源画布版本卡的编号口径（`manifest.versions` 落盘顺序 + 1，`formatIterationVersionTitle`），括号里那截是独立一层（`formatIterationVersionDetail`）——窄档位收掉的是这一层而不是整枚入口；可访问名、菜单项与排障文案一律保留完整标识。DOM 顺序由 `tests/resourceVersionSwitch.test.tsx`（版本入口在排序分段之前）与 `tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx`（排序分段是动作行最后一个子元素）双向钉住。
+- 决策（播放并入运行 + 刷新入口）：删掉独立的「播放」按钮，「运行」页签前加 ▶ 图标，点页签＝`showRunView()` + `onPlay?.()`（与旧播放按钮逐字等价，含「再点一次＝重跑」）；不可运行时页签不置灰、点了既不切视图也不发播放请求，只出既有提示。运行画面右下角新增「刷新运行画面」（全屏那一枚左侧）：`onPlay` 命中活体预览只切视图、不重启服务，真正重载页面靠换 `iframe` 的元素身份（`LocalGamePreviewFrame` 新增 `reloadNonce`）——运行页在另一个端口上，跨域 iframe 里 `contentWindow.location.reload()` 会被浏览器挡掉。
+- 决策（进入项目自动载入）：站在运行视图上却没有画面可看时自动补发一次 `onPlay`——典型现场是从别的项目切过来（工作台不重挂，`mode` 是工作台自己的 state，上一条项目的运行视图原样留下而画面已经没了），用户只会看到「客户端运行画面尚未载入」，像坏了一样。只在**没有画面且可运行**时发；`showRunView` 先记账再自己发播放（`autoRunPreviewProjectRef`）所以点页签不会被重复触发；同一个项目只自动补一次，失败不打转，手动重跑仍走页签或画面上的刷新按钮。
+- 边界：不改后端、契约与 SpacetimeDB；`runAvailable` / `showRunView` 的门槛语义不变，自动切运行的两条路径（会话内已确认的预览、播放请求）不走 `showRunView`，不会多发播放请求。窄于合同宽度只保证不崩，不做移动端布局。
+- 影响范围：`apps/ai-game-creator-shell/src/{styles.css,view/project-development/{index.tsx,workbenchToolbarModel.ts,useWorkbenchToolbarLayout.ts,WorkbenchMoreActionsMenu.tsx},features/resource-canvas/{GameRunVersionPicker.tsx,resourceCanvasVersionBindingModel.ts},features/project-workspace/LocalGamePreviewFrame.tsx}`；用例 `tests/{workbenchToolbarLayout,runPreviewRefresh,runAutoLoadOnEnter}.test.ts(x)`（新增）、`tests/appSurface/project-development.suite.ts`、`tests/{gameRunToolbarActionsStyle,resourceCanvasVersionBindingModel}.test.ts`；文档 `docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md`、`docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md`（S17 改写 + 新增 S17a）、`docs/README.md`、新目录 `docs/technical/assets/agc-toolbar-layout-after-20261004/`。
+- 验证：`npx vitest run apps/ai-game-creator-shell/tests`（200 passed / 1 skipped 文件，1929 passed / 17 skipped 用例，末次全量）；定向 8 个文件 253 passed；`npm run typecheck`（在 `apps/ai-game-creator-shell`，含 `check:tests:types`——只跑 `tsc -p tsconfig.json` 覆盖不到 `tests/`）、eslint `--max-warnings 0`、`prettier --check`、`npm run check:encoding`、`npm run check:doc-index`、`git diff --check` 全绿。真机几何用一次性 Vite 夹具在真实 Chromium 里逐档实测（视口 1412 / 1240 / 1100 / 1024 / 960 / 860 / 800 / 760 / 700 / 640 / 560 / 480 / 400）：始终单行、排序分段贴右缘（`工具栏右缘 - padding - 排序分段右缘 = 0`）、版本入口始终在排序分段左侧、1240/1100 走 `compact-version`、1024/800/700/640/560/480 走 `collapsed-actions`，「更多」下拉三条动作可点且点「资源面板」真的开面板、点「刷新运行画面」`iframe` 换新节点而 `src` 不变；截图见 `docs/technical/assets/agc-toolbar-layout-after-20261004/`。
+
 ## 2026-10-03 AGC 画布引用统一走「活跃聊天输入区」注册表（Issue 602）
 
 - 背景：画布的「引用」按钮与「拖拽批量引用」只派发 window 事件，消费者只有 `App.tsx` 一处，而它插的是绑在 `PlanningChatView` 上的 `chatComposerRef`；2026-09-22 DirectProject 拆分后普通项目走 `directProjectMode` 提前 return，渲染不到策划面 → ref 恒为 `null`，可选链静默吞掉点击（画布上是死按钮）。同一批合并冲突还丢了 `RESOURCE_REFERENCE_INSERT_MANY_EVENT` 的监听，批量引用连消费者都没有。
diff --git a/docs/project-memory/shared-memory/pitfalls.md b/docs/project-memory/shared-memory/pitfalls.md
index 20a8f87ba..444162046 100644
--- a/docs/project-memory/shared-memory/pitfalls.md
+++ b/docs/project-memory/shared-memory/pitfalls.md
@@ -2,6 +2,42 @@
 
 这里只记录对当前开发仍有用的症状、根因、排查方法和风险边界。同一事实保留一个当前口径；退役对象的专属过程与单轮测试结果由 Git 历史追溯。遇到旧路径或版本时，以现行代码和专题文档为准。
 
+## 2026-10-03 AGC 随包 plugins 的 feature 档位必须与消费方一致，且门禁会因 build.rs 未重跑而假通过
+
+- **现象**：Windows 本机 `npm run check:generated-bindings`（`npm run lint` 链内，`scripts/check-repository-ci.sh` 的 Repository checks 也走它）在 `build.rs:167:29` panic：`插件随包资源校验失败：随包插件存在未声明文件：.../src-tauri/resources/plugins/agc-godot-editor/native/gdextension/bin/win-x64/agc_godot_editor.dll（目标 x86_64-pc-windows-msvc 与当前 feature 组合不允许；请先执行随包资源准备步骤）`；树上换成 `agc-unity-editor/dotnet/publish/win-x64/Agc.Unity.Attach.exe` 时报同一类错。反向还有更隐蔽的形态：门禁 2 秒就 exit 0 说「通过」，但 tree 上其实带着编辑器产物。
+- **原因**：`apps/ai-game-creator-shell/src-tauri/resources/plugins/` 是 gitignored 但被 dev / 发布 / 门禁多流程共用的目录，它的**档位**（staging 里放了哪些编辑器产物）必须与本次 cargo 调用实际生效的 feature 组合一致。`apps/ai-game-creator-shell/src-tauri/Cargo.toml` 的 `[features] default =` 是空的，而 `scripts/check-generated-bindings.mjs` 对 AGC 用的是裸 `cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml export_bindings`（**不带任何 feature**）；`build.rs` 按「当前 TARGET + 已启用 `CARGO_FEATURE_*`」构造 plugins 允许集合，于是为 windows 编辑器 feature 准备的 `origin: prepared` / `libraryStaging` 产物全成了「未声明文件」。
+- **关键坑（假通过）**：`resources/**` **不是**构建脚本声明的输入（设计如此，避免每次资源变化都重编），所以缓存命中的 `cargo test` **根本不会重跑 `build.rs`**，校验被整个跳过。实测：树上带着未声明的 unity 产物时，门禁仍以 2.33 秒 exit 0「通过」；`touch apps/ai-game-creator-shell/src-tauri/build.rs` 强制重跑后才暴露。
+- **处理（现行口径）**：校验 / 无 feature 的消费方先复位到 featureless：`npm run agc:bundled-resources:prepare -- --features=`。要带编辑器能力的本地 AGC：`npm run agc:bundled-resources:prepare -- --target x86_64-pc-windows-msvc --features=cocos-editor-execute,unity-editor-execute,godot-editor-execute`（`cocos-editor-bridge.dll` 的 native payload 另需 `cocos-editor-injection`）。要求门禁**真校验**过，先 `touch apps/ai-game-creator-shell/src-tauri/build.rs` 再跑门禁。
+- **判据/取证**：复位后强制重跑那次输出 `生成绑定校验通过：shared-contracts（1 个文件）` / `生成绑定校验通过：ai-game-creator-shell（104 个文件）` / `生成绑定校验通过：合计 105 个文件与 Rust 声明一致`（exit 0）。featureless 判据：`resources/plugins` 只有各插件 `plugin.json` + `src/`（cocos 另有 `panels/`），不存在 `Agc.Unity.Attach.exe` / `agc_godot_editor.dll` / `cocos-editor-bridge.dll`。
+- **边界**：这是同一工作树里多人共享的档位——featureless 是无 feature 构建与并发 cargo 运行的前提，带编辑器产物会让它们失败，反之亦然。`prepare-bundled-resources.mjs` 的原子替换要 rename `resources/plugins`，撞上外部目录句柄会 `EPERM` 并把 staging 留在 `resources/plugins-staging-<pid>-<hex>`（`.gitignore:61` 已声明该模式），确认无并发进程后重试即可。
+- **关联**：`apps/ai-game-creator-shell/src-tauri/build.rs`（`validate_staged_plugins` / `validate_prepared_payloads`）、`src-tauri/build_support/package-layout.json`、`apps/ai-game-creator-shell/scripts/{prepare-bundled-resources.mjs,cargo-features.mjs}`、`scripts/check-generated-bindings.mjs`；另见本文件「随包资源的写入方按产物来源分界」「AGC 随包资源的布局只能改声明文件」「构建期 staging 撞上不装 npm 依赖的 Linux 门禁」三条。
+
+## 2026-10-03 工作树位于 `.worktrees/` 下时前端 Vite 被自己的忽略规则整棵排除：改代码不热更
+
+- **现象**：在 `.worktrees/<name>/` 里的工作树改主站或后台前端源码，浏览器看不到任何更新；重启 Vite 也不生效（本轮有人重启 3 次才发现不是缓存问题）。
+- **原因**：根 `vite.config.ts`（`ignoredWatchGlobs`，约 461-468 行）与 `apps/admin-web/vite.config.ts`（约 19-24 行）的忽略列表都含 `'**/.worktrees/**'`。工作树本身就在 `.worktrees/` 目录下，该 glob 会匹配工作树内的**每一个文件**，等于把整个项目排除出 watch——不报错、不提示，只是永远不触发 HMR / 重建。
+- **影响面**：主站 web 与 admin-web 都中招（两者共用这条规则）；`npm run dev:web` 走 `scripts/vite-cli.mjs`，它只是转发到 Vite 自带 bin、用的是同一份根配置，所以经 CLI 入口启动也一样。`apps/ai-game-creator-shell/vite.config.ts` 只忽略 `'**/src-tauri/target/**'`，**不受影响**。
+- **处理方向（本轮未改配置）**：忽略规则必须只排除**其它** worktree 而放行当前 root——例如按真实仓库根计算，形如只忽略 `<repoRoot>/.worktrees/*/` 且显式排除当前 root；或当项目 root 自身已落在 `.worktrees/` 内时不注入该条。不要保留无条件的 `'**/.worktrees/**'`。
+- **验证方向**：修改 `src/**` 一句话后，主站与 admin-web 各自应打印 HMR 更新（修改后立即生效），而不是只在重启后才生效；必要时打印生效的 watch 忽略集合确认不再覆盖当前 root。
+- **关联**：`vite.config.ts`、`apps/admin-web/vite.config.ts`、`apps/ai-game-creator-shell/vite.config.ts`、`scripts/vite-cli.mjs`。
+
+## 2026-10-03 同一工作树并发拉起多份 dev 栈：`.app/dev-stack.json` 互相覆盖，启动兜底清扫会反杀健康栈
+
+- **现象**：在同一工作树里再开一个 `npm run dev` 之后，AGC 侧报「后端归属校验失败」，或前端代理连到别的端口（「后端端口记错」）；更严重的是新会话启动后，`8082` / `8083` 上原本健康的后端被清掉，旧会话随即报连接失败。
+- **原因**：`.app/dev-stack.json` 是**全工作树单文件**（`scripts/dev.mjs` 的 `resolveDevStackStatePath()` → `<repoRoot>/.app/dev-stack.json`，`scripts/dev-all.mjs` 与若干 e2e 脚本也读它），每个 `DevRunner` 都整份覆写快照，端口、SpacetimeDB data-dir 与 instance id 只保留最后写入者，于是两份并发栈互相覆盖实例信息。同时 `dev.mjs` 在启动/退出时会按身份兜底清扫 `stopWindowsWorktreeBackendProcesses`（`api-server.exe` 绝对路径 + SpacetimeDB `--data-dir`），这是**按工作树**而不是按会话匹配的：其它会话留下的半死栈一旦重启，就会把当前健康栈一并收走。
+- **处理（现行口径）**：同一工作树保持**单栈**；确需并发时用显式端口参数（`--api-port` / `--web-port` / `--admin-web-port` / `--spacetime-port` 等）错开，并接受状态文件只有一个「最后写入者」。清理残留必须按**端口 → PID → 命令行**确认归属，再杀该 PID 的整棵进程树；不要 `taskkill /IM node.exe`（会误伤其它会话与 IDE 的 Node 进程）。
+- **排查顺序**：先比对 `.app/dev-stack.json` 的 status / 端口与实际监听（`Get-NetTCPConnection -State Listen -LocalPort ...`）是否一致，再用 `Get-CimInstance Win32_Process` 按本工作树 `server-rs\target\debug\api-server.exe` 路径与 SpacetimeDB `--data-dir` 核对归属；不要因为 `/healthz` 返回 200 就认定后端属于当前会话。
+- **关联**：`scripts/dev.mjs`（`resolveDevStackStatePath` / `stopWindowsWorktreeBackendProcesses`）、`scripts/dev-windows-process.mjs`、`scripts/dev-all.mjs`、`scripts/check-game-distribution-ratings-e2e.mjs`；另见本文件「`npm run agc` 的 Ctrl+C 不能只依赖 shell 包装层与端口健康检查」与 `docs/【开发运维】本地开发验证与生产运维-2026-05-15.md`。
+
+## 2026-10-03 Windows 上会弹阻塞模态的启动失败用例挂死本机分片 runner
+
+- **现象**：Windows 本机 `npm run ai-game-creator-shell:check:rust:shell -- --shard-index=3/4` 长时间无进展（可到 2400s 超时）；单独跑那条用例同样超时——进程还在、CPU 不再增长、也没有子进程，形态很像「测试死锁」或「分片器坏了」。
+- **原因**：`apps/ai-game-creator-shell/src-tauri/src/main.rs:2042` 的 `startup_log_slot_fail_without_path_still_reports_instead_of_going_silent` 调 `StartupLogSlot::fail()`（约 1854 行），而 `fail()` 会走 `show_startup_error_dialog()`；Windows 实现（约 1740 行）用的是 `MessageBoxW(..., MB_OK | MB_ICONERROR | MB_SETFOREGROUND)`，是**阻塞模态**，没有人点「确定」就永不返回。`STARTUP_ERROR_DIALOG_SHOWN`（约 1534 行）只在同一个进程内保证「只弹一次」，对测试用例没有任何豁免。分片 runner 用 `--exact <名单> --test-threads=1` 串行执行，一条挂死就整片挂死。
+- **影响面**：Linux CI 走非 Windows 分支（约 1778 行）只写 stderr，**不受影响**；这是本机专属现象，不要据此判定 Rust 代码或分片规则有问题。
+- **处理（本机绕过）**：改用等价分块跑，而不是整片上阵——同一个测试二进制、同一 `--exact <名单>` 与 `--test-threads=1` argv、同一 TMPDIR 隔离，把这条阻塞用例排除或单独限定。
+- **判据/取证**：单独执行 `cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml --bin genarrative-ai-game-creator-shell -- --exact startup_log_slot_fail_without_path_still_reports_instead_of_going_silent --test-threads=1` 本机同样挂住；对照非 Windows 分支只产生 stderr 文案。
+- **关联**：`apps/ai-game-creator-shell/src-tauri/src/main.rs`、`apps/ai-game-creator-shell/scripts/run-rust-shell-test-shards.mjs`；另见本文件「AGC 壳 Rust 套件按「一片一 job」拆分，且分片必须自校验覆盖」条中此前记为「本机跑到约 20 分钟后长时间无进展」的同一现象。
+
 ## 2026-10-03 AGC 画布「引用」死按钮：window 事件的消费者挂在一个只在另一条链路赋值的 ref 上
 
 - **现象**（Issue 602）：AGC 资源画布选中一张已登记素材，选中工具条点「引用」（图标 `@`、可见文案与 `title` 都是「引用」）没有任何反应——聊天输入框里不出现 `@素材名` 芯片，也没有任何提示。普通项目（`directProjectMode`）必现，立项策划项目（`planningStartMode`）复现不出来；把素材卡拖到对话栏的批量引用同样没反应。
diff --git a/docs/technical/assets/agc-toolbar-layout-after-20261004/01-toolbar-resources-full-1412.jpg b/docs/technical/assets/agc-toolbar-layout-after-20261004/01-toolbar-resources-full-1412.jpg
new file mode 100644
index 000000000..54534090d
Binary files /dev/null and b/docs/technical/assets/agc-toolbar-layout-after-20261004/01-toolbar-resources-full-1412.jpg differ
diff --git a/docs/technical/assets/agc-toolbar-layout-after-20261004/02-toolbar-resources-compact-1240.jpg b/docs/technical/assets/agc-toolbar-layout-after-20261004/02-toolbar-resources-compact-1240.jpg
new file mode 100644
index 000000000..9da0c4c47
Binary files /dev/null and b/docs/technical/assets/agc-toolbar-layout-after-20261004/02-toolbar-resources-compact-1240.jpg differ
diff --git a/docs/technical/assets/agc-toolbar-layout-after-20261004/03-toolbar-more-menu-800.jpg b/docs/technical/assets/agc-toolbar-layout-after-20261004/03-toolbar-more-menu-800.jpg
new file mode 100644
index 000000000..18f73ba1b
Binary files /dev/null and b/docs/technical/assets/agc-toolbar-layout-after-20261004/03-toolbar-more-menu-800.jpg differ
diff --git a/docs/technical/assets/agc-toolbar-layout-after-20261004/04-toolbar-run-tab-and-preview-refresh-1412.jpg b/docs/technical/assets/agc-toolbar-layout-after-20261004/04-toolbar-run-tab-and-preview-refresh-1412.jpg
new file mode 100644
index 000000000..f0bdcd6d1
Binary files /dev/null and b/docs/technical/assets/agc-toolbar-layout-after-20261004/04-toolbar-run-tab-and-preview-refresh-1412.jpg differ
diff --git a/docs/technical/assets/agc-toolbar-layout-after-20261004/README.md b/docs/technical/assets/agc-toolbar-layout-after-20261004/README.md
new file mode 100644
index 000000000..595498dbb
--- /dev/null
+++ b/docs/technical/assets/agc-toolbar-layout-after-20261004/README.md
@@ -0,0 +1,24 @@
+# AGC 顶栏布局收口：改动后对照图（2026-10-04）
+
+本目录是「优化 AGC 标题栏布局」（`fix/agc-toolbar-layout`）的改动后截图，供 PR 与后续回归对照使用。四张图都取自一次性冒烟夹具（`.codex/skills/agc-workbench-browser-smoke`：真实 Chromium 挂 `ProjectDevelopmentView`，不是 Tauri 客户端），因此没有客户端窗口边框与左侧启动器侧栏。
+
+| 文件                                              | 画面                    | 改动后的形态                                                                                                                                                                                       |
+| ------------------------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `01-toolbar-resources-full-1412.jpg`              | 资源管理页（窗口 1412） | 顶栏一行到底：**两端是两枚大分组**——左端「资源管理 / 运行」，右端「依赖 / 类型」；中间依次是动作按钮与版本入口，版本入口紧邻排序分段左侧并显示完整标识 `版本 1（智能体修订 · 2026/10/3 14:21:05）` |
+| `02-toolbar-resources-compact-1240.jpg`           | 资源管理页（窗口 1240） | 空间不足第一档：版本入口收成 `版本 1`，其余一枚不动、不换行，行尾仍由「依赖 / 类型」收住                                                                                                           |
+| `03-toolbar-more-menu-800.jpg`                    | 资源管理页（窗口 800）  | 空间不足第二档：`打开项目目录 / 资源面板 / 整理画布` 收进「更多」下拉，展开即同一批动作；行尾仍由「依赖 / 类型」收住                                                                               |
+| `04-toolbar-run-tab-and-preview-refresh-1412.jpg` | 运行页（窗口 1412）     | 「播放」并入「运行」页签（页签前带 ▶）；运行画面右下角多一枚「刷新运行画面」，与「全屏预览」并列                                                                                                  |
+
+改动前的问题（用户现场截图）：
+
+1. 顶栏放不下时两侧各自 `flex-wrap: wrap`：第二行只剩「播放」与版本入口，两行控件分裂；
+2. 版本入口不贴右缘，被前面按钮的文本宽度顶开；
+3. 「播放」与「运行」是两个入口说同一件事；
+4. 运行画面里的游戏不是实时刷新，改完代码只能切到资源管理再切回来重载；
+5. 两枚体量最大的分组控件（「资源管理 / 运行」「依赖 / 类型」）挤在同一侧，版本入口又压在「依赖 / 类型」右边——现在两枚大分组分居一行两端，版本入口在排序分段左侧。
+
+相关文档口径已同步到：
+
+- [`docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md`](../../../prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md)（顶部工具条那一行）
+- [`docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md`](../【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md)（S17 播放、S17a 刷新）
+- [`docs/project-memory/shared-memory/decision-log.md`](../../../project-memory/shared-memory/decision-log.md)（顶栏降级档位与两端分组决策）
diff --git a/docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md b/docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md
index 07b6c5b88..acf6a3c38 100644
--- a/docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md
+++ b/docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md
@@ -63,8 +63,9 @@
 
 | 步骤                   | 操作                                         | 期望结果                                                                                                 | 对应 PRD 条款                   | 怎么判"过了"                                                                                                                                                                                              | 已知例外 / 未做项                                                                                                                                                                                |
 | ---------------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **S16** 版本切换       | 运行模块**右上角**版本选择器 → 切到另一版本  | 触发钮显示当前版本；切换后资源卡「当前使用」高亮与 **@ 面板「当前版本素材」同步更新**，并重载当前预览    | L165、L190、L324、L530；#309 C7 | `aria-label="当前版本：<label>"`、菜单 `role="listbox" aria-label="切换游戏版本"`、选项 `role="option" aria-selected`；`[data-used-by-current-version="true"]` 集合随切换变化                             | **C7 只做记录层 + UI 层**；"历史版本独有资源集合被运行时按版本加载"需新增版本化资源解析机制，**本轮未实现**；版本卡卡面**不渲染**「项目修订 / 父版本」文字                                       |
-| **S17** 播放           | 顶部「播放」                                 | 直接切运行视图并启动本地预览；**不再弹 `game.run_local` 二次确认**；预览占满中央可用区、无 iframe 滚动条 | L16、L71–72、L122、L493         | `data-resource-view-state` 变为 `undefined`；`await window.__TAURI__.core.invoke('get_local_game_preview_status',{projectPath})` → `status==='running'` 且有 `url`（形如 `http://127.0.0.1:<随机端口>/`） | 播放按钮 `disabled={!runAvailable \|\| !onPlay \|\| uiEditorRoute!==null}`，**不可用时点不动**；不可用提示实现文案为「首个可运行原型尚未完成，运行视图暂不可用」，与 PRD L165 表述不同（见 7.4） |
+| **S16** 版本切换       | 顶栏动作区的版本入口（「依赖 / 类型」左侧，运行页与资源页都在）→ 切到另一版本 | 触发钮显示当前版本；切换后资源卡「当前使用」高亮与 **@ 面板「当前版本素材」同步更新**，并重载当前预览    | L165、L190、L324、L530；#309 C7 | `aria-label="当前版本：<label>"`、菜单 `role="listbox" aria-label="切换游戏版本"`、选项 `role="option" aria-selected`；`[data-used-by-current-version="true"]` 集合随切换变化                             | **C7 只做记录层 + UI 层**；"历史版本独有资源集合被运行时按版本加载"需新增版本化资源解析机制，**本轮未实现**；版本卡卡面**不渲染**「项目修订 / 父版本」文字                                       |
+| **S17** 播放           | 顶部「运行」页签（页签前带 ▶ 图标）          | 切到运行视图并启动本地预览；**不再弹 `game.run_local` 二次确认**；预览占满中央可用区、无 iframe 滚动条；**站在运行视图却没有画面时（例如从别的项目切过来）自动补发一次载入**，同一个项目不重复补发 | L16、L71–72、L122、L493         | `data-resource-view-state` 变为 `undefined`；`await window.__TAURI__.core.invoke('get_local_game_preview_status',{projectPath})` → `status==='running'` 且有 `url`（形如 `http://127.0.0.1:<随机端口>/`） | 播放并进「运行」页签，**没有独立的「播放」按钮**：不可运行时（`runAvailable === false`）页签不置灰，点了既不切视图也不发播放请求，只出提示「首个可运行原型尚未完成，运行视图暂不可用」（与 PRD L165 表述不同，见 7.4） |
+| **S17a** 刷新运行画面  | 运行画面右下角「刷新运行画面」（全屏那一枚左边） | 重新载入游戏页面：游戏预览不是 vite dev 的实时刷新，改完代码要看到新一版只有重载页面这一条路（此前只能切到资源管理再切回来） | L134                            | `iframe` 换成新 DOM 节点且 `src` 不变（跨域 iframe 里 `contentWindow.location.reload()` 会被浏览器挡掉，实现走 React `key` 换元素身份）；点击同时向宿主确认一次预览还活着（`onPlay` 命中活体预览不重启服务）。没有活预览时**不渲染**这枚按钮 | 全屏里照旧可用（两枚按钮都在画面那一格内）；只重载页面，不重跑构建                                                                                                                                |
 | **S18** 停止与退出收尾 | 聊天侧工程操作组点「停止预览」；或关闭客户端 | 预览停止、manifest `preview` 对齐 `stopped`（清 url/port）；退出时也统一收尾                             | L165                            | 停止后 `get_local_game_preview_status` 非 running；`.agent/logs/preview.log` 追加 `stopped`；退出后重开同一项目应落回 `resource-overview`                                                                 | 停止按钮**不在**运行视图工具栏，在工作台右侧工程操作组；退出失败会打 `preview.gui_exit.stop_failed`                                                                                              |
 
 ### E 阶段 · 对话侧
@@ -170,6 +171,7 @@ window.__TAURI__.core.invoke = (cmd, args) => {
 | S15  | 弹窗是否出现 `被 N 个游戏版本使用`；不勾选时版本记录仍在（可读但悬空）                                                                                                               |
 | S16  | `aria-label="当前版本：…"` 是否随切换更新；`[data-used-by-current-version="true"]` 集合是否变化                                                                                      |
 | S17  | `get_local_game_preview_status` 返回的 `status/url/port`；`.agent/logs/preview.log` 的 `running` 行                                                                                  |
+| S17a | `iframe` 是否是**新的** DOM 节点（`document.querySelector('iframe')` 前后比较）而 `src` 不变；没有活预览时 `button[aria-label="刷新运行画面"]` 是否为 `null`                          |
 | S18  | 退出后重开项目是否落回资源总览；Rust 日志中的 `preview.gui_exit.stop_failed`                                                                                                         |
 | S19  | chip 的 `data-resource-reference-id`；两页签 `role="tab"` 的 `aria-selected`；空态文案（`当前版本还没有绑定素材` / `当前项目还没有已登记素材` / `没有匹配的素材`）                   |
 | S20  | 弹窗标题「发送前提醒」；`localStorage['agc.chat.prompt-polish-reminder.disabled']` 的值；`润色中…` 或 `AI 润色失败，可重试` 状态行                                                   |
@@ -204,6 +206,7 @@ api-server 是否本次重启：□ 是  □ 否
 | S15 删除三分支                                                  | ☐ 无引用 ☐ 引用未勾选 ☐ 勾选连带 |                                       |
 | S16 版本切换 + 当前使用高亮 + @ 同步                            | ☐ 过 ☐ 不过                      |                                       |
 | S17 播放 → 运行视图 + 本地预览                                  | ☐ 过 ☐ 不过                      | url：******\_\_******                 |
+| S17a 刷新运行画面（iframe 换节点、src 不变）                      | ☐ 过 ☐ 不过                      |                                       |
 | S18 停止预览 / 退出收尾对齐 stopped                             | ☐ 过 ☐ 不过                      |                                       |
 | S19 @ 引用两页签 + 独立筛选 + chip 原子性                       | ☐ 过 ☐ 不过                      |                                       |
 | S19a @ 面板标签筛选（多标签 AND，叠加关键字与功能分类）         | ☐ 过 ☐ 不过                      |                                       |
@@ -264,7 +267,7 @@ api-server 是否本次重启：□ 是  □ 否
 | 偏差                   | 文档表述                                                           | 代码实际                                                                                                                                                        | 建议                                                                                                                         |
 | ---------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
 | 资源卡「打开详情」     | PRD L61–62 要求"打开详情"与"播放 / 暂停"是可分别键盘聚焦的同级按钮 | 不存在该按钮（测试显式断言为 `null`）；真正入口是 `选中资源：<栏目> <名>`，播放按钮是 `播放/暂停 <名>`；**只读信息浮层已回归**（2026-09-11 工具条「信息」动作） | 按 #309 C3（取消资源详情面板与全屏编辑路由）判，**C3 取消的仍只是可编辑详情面板与全屏编辑路由**；PRD L61–62 建议同步修订     |
-| 运行入口不可用文案     | PRD L165 显示"当前无可运行版本"，但仍允许点击                      | 源码中无此字符串；实现为「首个可运行原型尚未完成，运行视图暂不可用」；且播放按钮 `disabled`，只有"运行"tab 不 disabled、用 `data-unavailable` 表达              | 建议按"tab 可点 + 播放按钮置灰"判，并把 PRD L165 文案对齐实现                                                                |
+| 运行入口不可用文案     | PRD L165 显示"当前无可运行版本"，但仍允许点击                      | 源码中无此字符串；实现为「首个可运行原型尚未完成，运行视图暂不可用」；「运行」页签不置灰、用 `data-unavailable` 表达，点了不切视图也不发播放请求              | 按"页签可点 + 不可用时什么都不做并出提示"判，并把 PRD L165 文案对齐实现                                                                |
 | 画布生成入口           | #309「画布生成入口未接」                                           | 已接两条：浮层入口只做视频；音频与图片类在栏目画布底部工具栏（见 S11a / PRD §3.10）                                                                             | 按代码与当前产品口径判，并更新 #309 进度段                                                                                   |
 | 分类手设入口           | 旧版 PRD「用户可在分类与标签面板手动设置 category」                | 已移除；面板只编辑 tags（已随 `6bdc8bbd9` 入库）                                                                                                                | 按新口径判                                                                                                                   |
 | 真机 manifest 分类分布 | —                                                                  | 落盘 `unclassified 57 / ui-interaction 3 / scene 1`                                                                                                             | **读时自愈**会把 kind 可明确分类的资产显示到正确栏目，判定必须看 UI 栏目计数，不能看 manifest 文件，否则必然误报"分类不生效" |
diff --git a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
index 9ace24f5a..670dd508d 100644
--- a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
+++ b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
@@ -483,8 +483,10 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 - 源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`
 - 用途：游戏分发稳定身份与公开版本指针。保存 owner、标题/简介/分类资料、设备与输入声明、`publication_revision`、当前 `active_version_id`、可见性和游玩计数；标签与输入模式按版本化 JSON 保存，展示资料由 `api-server` 通过 `spacetime-client` 归一后返回。
 - 公开素材：游戏行末尾追加可空 `cover_object_key` 与 `screenshots_json`（截图 `{assetId, objectKey}` 数组）；创建游戏时 `api-server` 就复核封面/截图素材存在且属于当前作者（不存在 400、他人素材 403），创建版本时按同一口径再次复核并派生对象键。 发布写入受灰度配置键 `game-distribution:publish` 约束：**灰度默认关闭**，未配置或 `enabled=false` 时写入口（创建游戏/版本、确认包、送审、审核通过激活）返回 503 `GAME_DISTRIBUTION_PUBLISH_DISABLED`，`enabled=true` 且白名单/比例/标签命中才放行，读取与安全下架保持可用；同一判据在 `GET /api/runtime/frontend-config` 以 `gameDistributionPublishEnabled` 下发给前端入口，匿名恒为 `false`。只有可见性为 `published` 且存在有效 `active_version_id` 的游戏，其封面/截图素材才在 `/api/assets/read-url` 上获得匿名读授权。
-- 复用规则：末尾可空列 `local_project_id` 保存发布方本地项目标识（AGC 的 `manifest.projectId`）。同一 `owner_user_id` 再次以相同 `local_project_id` 创建游戏时复用既有 `game_id` 并只新增版本，避免“更新”被实现成新建游戏；该字段只是复用提示，不构成所有权或路径凭证，也不能用于跨账号匹配。
-- 索引：`by_game_distribution_game_owner_user_id` 用于作者私有游戏列表；`game_id` 为主键。公开目录只返回 `visibility = published` 且存在有效 `active_version_id` 的投影。
+- 复用规则：末尾可空列 `local_project_id` 保存发布方本地项目标识（AGC 的 `manifest.projectId`）。同一 `owner_user_id` 再次以相同 `local_project_id` 创建游戏时复用既有 `game_id` 并只新增版本，避免“更新”被实现成新建游戏；该字段只是复用提示，不构成所有权或路径凭证，也不能用于跨账号匹配。已软删除的游戏不参与复用：删除后重新发布同一本地项目应得到新的游戏身份。
+- 软删除：游戏行末尾追加可空 `deleted_at`（2026-10-01）。非空表示作者已删除该作品：`delete_game_distribution_game_and_return` 只写该时间戳并把公开投影下线（可见性回到 `unpublished`、撤销当前公开版本、递增 `publication_revision`），版本行、发行包与其冻结资料一律不改写。软删行不进入作者列表（`list_owner_game_distribution_games_and_return`）、公开目录（`list_public_game_distribution_games_and_return`）、公开详情（`get_public_game_distribution_game_and_return`）、发行网关素材授权（`game_distribution_asset_has_public_read_grant`）与审核队列；后台默认视图同样排除，只有显式 `status=deleted` 才会读到。作者侧版本回读对软删作品返回空（404），因此上传、确认与送审入口一并关闭。
+- 资料编辑：`update_game_distribution_game_metadata_and_return` 覆盖游戏行上的展示字段（标题/简介/详介/分类/标签/封面/截图/设备/输入模式/方向）并立即生效，要求 `expected_publication_revision` CAS；版本行与冻结资料不变，下一次审核通过仍会用新版本的冻结资料覆盖游戏行。
+- 索引：`by_game_distribution_game_owner_user_id` 用于作者私有游戏列表；`game_id` 为主键。公开目录只返回 `visibility = published`、`deleted_at` 为空且存在有效 `active_version_id` 的投影。
 - 游玩计数写入：`play_count` 只由批量 procedure `increment_game_distribution_game_play_counts_and_return`（输入 `GameDistributionPlayCountIncrementInput { increments: Vec<{ gameId, delta }> }`）累加。`api-server` 在内存里按 `identity + gameId` 做 30 分钟去重、按 `IP + gameId` 做固定窗口限流后，按 `GENARRATIVE_GAME_PLAY_COUNTER_FLUSH_INTERVAL_MS`（默认 5 秒）批量落库；事务内只对 `published` 且存在有效 `active_version_id` 的游戏 `saturating_add`，非公开静默跳过，且**不更新** `updated_at`。公开 HTTP 入口为 `POST /api/game-distribution/games/{gameId}/plays`，完整行为见玩法链路的「游玩计数（已实现）」。
 
 ### `game_distribution_review`
@@ -525,11 +527,12 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 
 ### 后台游戏管理读模型与恢复动作（2026-09-23）
 
-- 页面目标：后台新增「游戏管理」页，展示全量游戏（标题 / 作者名 + 头像 / gameId / 状态 / 版本数 / 游玩数），行内提供安全下架、恢复与版本历史；它是运营面的全量视图，不替代 `#game-distribution` 待审队列。
-- 数据来源：新增只读 procedure `list_admin_game_distribution_games_and_return`（输入 `GameDistributionAdminGameListInput { limit }`）。它在同一事务里读 `game_distribution_game`，按 `by_game_distribution_version_game_id` 统计每个游戏的版本数并取最近 20 个版本；作者名与头像按 `user_account.user_id` 读时联 `display_name` / `avatar_url`（行内快照为空时以联表结果为准）。不新增表、不改 schema、不改公开投影。
-- 恢复动作：新增 procedure `restore_game_distribution_game_and_return`（输入 `GameDistributionRestoreInput`）。它只允许管理员解除 `suspended`：重新激活该游戏最近一个由管理员暂停撤回（`status = revoked`、`published_at` 非空且 `reviewed_by_user_id` 非空）的版本，恢复 `visibility = published` 并递增 `publication_revision`；作者自行下架的版本不写审核者，因此不会被恢复动作重新公开。没有可恢复版本、`expected_publication_revision` CAS 不符或游戏不在暂停态时失败关闭。幂等收据复用 `game_distribution_idempotency_receipt`（action = `restore`），恢复动作不受发布灰度开关限制，与安全下架同口径。
-- 后台 HTTP：`GET /admin/api/game-distribution/games?limit=` 返回 `{ games: [{ gameId, title, author{ id, name, avatarUrl }, status, versionCount, playCount, activeVersionId, publicationRevision, createdAt, updatedAt, versions: [...] }] }`；`POST /admin/api/game-distribution/games/{gameId}/restore` 要求 `Idempotency-Key` 与 `expectedPublicationRevision`，返回 `{ game, replayed }`。两者都走 `require_admin_auth`，Tab 权限为 `game-management` 或 `editor-showcase`，不新增公开契约。
-- 前端：`apps/admin-web` 新增 `#game-management` 路由与 `AdminGameManagementPage`，复用现有 `admin-table` 表格与 `useAdminWriteConfirm` 二次确认；版本历史在弹层内展示，长列表保持横向滚动。
+- 页面目标：后台新增「游戏管理」页，展示游戏（标题 / 作者名 + 头像 / gameId / 状态 / 版本数 / 游玩数），支持关键词、作者与状态筛选与游标分页，行内提供安全下架、恢复与版本历史；它是运营面的全量视图，不替代 `#game-distribution` 待审队列。
+- 数据来源：只读 procedure `list_admin_game_distribution_games_and_return`（输入 `GameDistributionAdminGameListInput { limit, keyword, ownerUserId, status, cursor }`）。它在同一事务里读 `game_distribution_game`，按 `by_game_distribution_version_game_id` 统计每个游戏的版本数并取最近 20 个版本；作者名与头像按 `user_account.user_id` 读时联 `display_name` / `avatar_url`（行内快照为空时以联表结果为准）。不新增表、不改公开投影。
+- 筛选与分页（2026-10-01）：`keyword` 大小写不敏感匹配标题、gameId 或作者 user ID；`ownerUserId` 精确匹配作者；`status` 取 `published` / `unpublished` / `suspended` / `deleted`，为空时排除已软删除作品（`deleted` 只返回软删行）。排序仍是创建时间倒序、gameId 升序，游标是 `<created_at_micros>:<gameId>`，结果类型新追加 `next_cursor`；多取一条判断是否还有下一页，因此**不会**像旧版那样静默截断到 200 条。
+- 恢复动作：procedure `restore_game_distribution_game_and_return`（输入 `GameDistributionRestoreInput`）只允许管理员解除 `suspended`：重新激活该游戏最近一个由管理员暂停撤回（`status = revoked`、`published_at` 非空且 `reviewed_by_user_id` 非空）的版本，恢复 `visibility = published` 并递增 `publication_revision`；作者自行下架的版本不写审核者，因此不会被恢复动作重新公开。没有可恢复版本、`expected_publication_revision` CAS 不符、游戏不在暂停态或已软删除时失败关闭。幂等收据复用 `game_distribution_idempotency_receipt`（action = `restore`），恢复动作不受发布灰度开关限制，与安全下架同口径。
+- 后台 HTTP：`GET /admin/api/game-distribution/games?limit=&keyword=&owner=&status=&cursor=` 返回 `{ games: [{ gameId, title, author{ id, name, avatarUrl }, status, versionCount, playCount, activeVersionId, publicationRevision, createdAt, updatedAt, deletedAt, versions: [...] }], nextCursor }`（旧字段保持原样，`deletedAt` 与 `nextCursor` 是新增项）；`status` 不在白名单时返回 400。`POST /admin/api/game-distribution/games/{gameId}/restore` 要求 `Idempotency-Key` 与 `expectedPublicationRevision`，返回 `{ game, replayed }`。两者都走 `require_admin_auth`，Tab 权限为 `game-management` 或 `editor-showcase`，不新增公开契约。
+- 前端：`apps/admin-web` 的 `#game-management` 路由与 `AdminGameManagementPage` 提供关键词/作者/状态筛选、`AdminPagination` 游标翻页与版本历史弹层；`status=deleted` 行展示删除时间，下架/恢复沿用 `useAdminWriteConfirm` 二次确认。后台 fake API（`scripts/admin-web-fake-api.mjs`）按同一查询参数过滤并返回 `nextCursor`。
 - 验收：`cargo test -p api-server game_distribution`、`cargo test -p spacetime-module game_distribution`、`npm run spacetime:generate` 后 `npm run check:spacetime-schema`、admin-web 定向 Vitest + typecheck、`npm run check:encoding`、`git diff --check`。
 
 ### `game_distribution_idempotency_receipt`
diff --git a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
index c241dd71c..bac2dd9bc 100644
--- a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
+++ b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
@@ -56,9 +56,9 @@
 | 字段 | 值 |
 | --- | --- |
 | Version | 0.2 |
-| Status | proposed（待评审，未上线） |
+| Status | current（实现已落地；真实客户端 GUI 与生产发布仍待验收） |
 | Date | 2026-09-18 |
-| 适用边界 | 本节是新增业务提案；评审与实现验收前，不改变上文现役入口和移动端合同 |
+| 适用边界 | 当前 game-distribution 作品管理、Phaser 4 客户端发布和静态 Web 发行合同；生产发布开关默认关闭 |
 
 ### 交付目标与范围
 
@@ -83,25 +83,29 @@
 ### 真实发行包与资料合同
 
 1. AGC 发布取当前 npm 工程已成功构建的 `dist/` 内容，重新检查入口和实际字节；ZIP 内部必须把 `dist/index.html` 归一化为根 `index.html`，其余路径相对发行根保持不变。不得上传整个项目、源码快照或仅发送本地路径。网页 ZIP 同样要求根 `index.html`，不猜测并自动剥离多层目录。
-2. 所有运行依赖都必须在发行包内。资源 URL 使用与发行版本目录兼容的相对地址；前导 `/assets`、本地文件 URL、外部脚本/样式/媒体/字体地址均不属于可接受发行合同。客户端给出可操作错误，服务器仍独立校验；静态校验不能代替运行时 CSP 阻断。
+2. 所有运行依赖都必须在发行包内。资源 URL 使用与发行版本目录兼容的相对地址；前导 `/assets`、本地文件 URL、外部脚本/样式/媒体/字体地址均不属于可接受发行合同。AGC 发布归一化阶段只把包内已知根路径 `/assets/`、`/game/`、`/ui/` 转成相对引用，不修改项目源码；其它外部绝对地址仍由客户端/服务器拒绝，静态校验不能代替运行时 CSP 阻断。
 3. 建议首版限额：压缩包 100 MiB、展开总量 250 MiB、单文件 64 MiB、最多 10,000 个文件、展开/压缩比不超过 100。服务端拒绝加密 ZIP、重复或大小写冲突路径、绝对路径、`..`、符号链接/重解析点、设备文件和嵌套压缩包；拒绝 `.agent`、版本控制目录、`node_modules`、凭据文件与源码映射文件。超限返回明确错误，不截断后继续发布。
 4. 提交声明 ZIP 的 SHA-256 与字节数，服务端对收到的真实 ZIP 重新计算，再对展开文件建立相对路径、字节数和 SHA-256 清单。摘要不一致、缺文件或入口损坏时停止；只有 metadata 而没有已确认完整对象的提交必须失败。
-5. 游戏资料随发行版本冻结：标题 2–40 字、短简介不超过 120 字、详细介绍不超过 2,000 字、一个分类、最多 5 个标签（每个不超过 20 字）、必需封面、最多 6 张截图、操作方式不超过 240 字。分类首版为休闲、益智、动作、冒险、模拟、策略、其他；封面/截图复用平台图片上传与归属校验，不接受任意外链作为审核图片。作者不需要自己构建或打 ZIP：AGC 发布时对 `game/` 子工程按需执行 `npm install`（复用 `project.bootstrap`）与 `npm run build`（复用 `project.verify` 的受控 npm 运行器，脚本白名单含 `build`、禁止项目级 `.npmrc` 改写语义），再把 `game/dist` 归一化成根 `index.html` 的发行包上传；已有可玩入口（`game/index.html` 或 `dist/index.html`）时跳过构建。Phaser 4 + Vite 已按此口径端到端验证（构建产物、发行网关与网页沙箱播放）。发布入口按灰度下发：后端灰度配置键固定为 `game-distribution:publish`（后台「灰度发布配置」可改，支持 `enabled` / `rolloutPercent` / `allowUserIds` / `allowUserTags`）。灰度默认关闭：未配置该键、或 `enabled=false` 时，未登录与已登录作者都拿到不开放（发布入口不渲染、写入口 503）；运营在后台创建该键并 `enabled=true` 后，只有白名单 / 灰度比例 / 用户标签命中的作者拿到开放状态。发布入口的开放状态随 `/api/runtime/frontend-config` 的 `gameDistributionPublishEnabled` 下发，网页广场/我的游戏入口与 AGC 聊天头「发布到游戏广场」按钮据此显示或隐藏；写入口仍独立校验，收紧期间提交返回 503 与可读文案，读接口、目录、详情、发行网关与安全下架不受影响。作者续发时按版本冻结快照回填封面与截图并复用同一批素材；公开投影只暴露对象键，素材 ID 只在作者与管理员回读时返回，快照里缺素材 ID 的旧版本必须要求作者重新选择封面。AGC 发布面板不展示 ZIP 路径、文件数或体积等技术摘要；一句话简介与分类可根据有界、脱敏的创作上下文免费生成（不扣用户泥点，仍可编辑），分类必须收敛到上述白名单；游戏封面支持基于项目上下文生成，生成走现役图片生成与泥点扣费链路，产物必须登记为当前账号平台素材后才能作为 `coverAssetId` 提交。
+5. 游戏资料随发行版本冻结：标题 2–40 字、短简介不超过 120 字、详细介绍不超过 2,000 字、一个分类、最多 5 个标签（每个不超过 20 字）、必需封面、最多 6 张截图、操作方式不超过 240 字。分类首版为休闲、益智、动作、冒险、模拟、策略、其他；封面/截图复用平台图片上传与归属校验，不接受任意外链作为审核图片。作者不需要自己构建或打 ZIP：AGC 发布时对 `game/` 子工程按需执行 `npm install` 和 `npm run build`，将 `dist` 归一化为根 `index.html` ZIP；为兼容 AGC 上传素材的运行 URL，会补入项目根 `assets/**` 中 dist 未包含的文件，同路径以 dist 构建产物为准，不修改项目源码。
 6. `supportedDevices` 至少包含 `desktop` 或 `mobile`；`inputModes` 来自 `keyboard`、`mouse`、`touch`；声明移动端必须包含 `touch`。`orientation` 为 `landscape`、`portrait` 或 `responsive`。这些是待人工复核的作者声明，目录只显示已经随版本审核通过的值。
 7. 原始 ZIP、未审核展开目录、审核资料均为私有对象；公开版本不暴露源码镜像键、本地路径、访问凭据或私有账号元数据。运行文件只能由发行网关按游戏、版本和文件白名单读取，不能绕过网关访问公开 OSS bucket。
-8. 现役发行网关由 `api-server` 提供：`GET /api/game-distribution/releases/{gameId}`（含尾斜杠）等价于该游戏的 `index.html`，`GET /api/game-distribution/releases/{gameId}/{assetPath}` 只服务当前已公开版本包内的文件，私有 ZIP 与未公开版本不因知道 ID 而可读。响应按扩展名白名单设定内容类型，未知扩展名返回 404；全部响应带 `X-Content-Type-Options: nosniff`、`Cross-Origin-Resource-Policy: cross-origin` 与不带 credentials 的 `Access-Control-Allow-Origin: *`（发行文档运行在 `allow-scripts` 的 opaque origin 沙箱里，`same-origin` 会让游戏自己的脚本被浏览器拦下），HTML 追加最小权限 CSP。带平台 `Cookie` 的请求一律 `403`；边缘在转发到发行网关前清空 `Cookie`，游戏文档又运行在 `sandbox="allow-scripts"` 的不透明来源里，读不到主站 Cookie 与 storage。发行包按对象键在进程内做有界缓存，单个超预算包不进入缓存。
+8. 现役发行网关由 `api-server` 提供：`GET /api/game-distribution/releases/{gameId}`（含尾斜杠）等价于该游戏的 `index.html`，`GET /api/game-distribution/releases/{gameId}/{assetPath}` 只服务当前已公开版本包内的文件，私有 ZIP 与未公开版本不因知道 ID 而可读。响应按扩展名白名单设定内容类型，未知扩展名返回 404；全部响应带 `X-Content-Type-Options: nosniff`、`Cross-Origin-Resource-Policy: cross-origin` 与不带 credentials 的 `Access-Control-Allow-Origin: *`（发行文档运行在 `allow-scripts` 的 opaque origin 沙箱里，`same-origin` 会让游戏自己的脚本被浏览器拦下），HTML 追加最小权限 CSP，并在游戏脚本前注入隔离的运行期 `localStorage` / `sessionStorage` 兼容层，避免游戏直接读取 opaque origin 原生 storage 时抛 `SecurityError`。兼容层只在当前运行实例内存中有效，不读取平台 Cookie、主站 DOM 或账号数据。公开发行与审核预览只拒绝真实平台 refresh Cookie；审核预览 Token 绑定单个版本且短期有效。发行包按对象键在进程内做有界缓存，单个超预算包不进入缓存。
 9. 发行入口既不由管理员填写，也不需要部署侧配置：审核通过时 `api-server` 按 gameId 派生**平台同源路径** `/games/{gameId}/` 写入公开投影，dev / release / 预览环境口径完全一致，不再需要发行域名、通配 DNS 或通配证书。gameId 必须是服务端生成的稳定标识（只允许 `[A-Za-z0-9_-]`），派生失败时审核通过直接失败，不回落主站其它路径、内网地址或任意外部地址。客户端读取该字段时按当前 origin 解析成绝对地址再交给 iframe；历史数据里的绝对 URL（非当前源的 https）继续兼容，新写入只用相对路径。路径到发行网关的映射由边缘 nginx 的同源发行入口 location 完成。
 
 ### 身份、状态、审核与更新
 
-- `gameId` 是服务端分配的稳定游戏身份；`ownerUserId` 只从当前认证主体派生。AGC 的本地 `projectId` 只能作为作者名下的关联提示，不能证明云端游戏所有权。网页上传和 AGC 发布使用相同游戏、版本与上传记录，不建立两套发行系统。
-- 同一作者用相同 `localProjectId` 再次发布时复用既有 `gameId` 并只新增版本；游戏身份、版本号和服务端校验都不依赖客户端传来的路径或 ID 可信度。缺少 `localProjectId` 的旧客户端仍可发布，但会被视为新建游戏。
-- 每次发行分配唯一 `versionId` 与游戏内递增 `versionNumber`。版本的游戏归属、包摘要、已确认字节和送审资料冻结后不可变；改包或改送审资料必须创建新版本。版本状态可以流转，内容不能原地覆盖。
+- `gameId` 是服务端分配的稳定游戏身份；`ownerUserId` 只从当前认证主体派生。AGC 本地 `projectId` 只用于关联提示，不能证明云端游戏所有权。AGC 项目清单保存平台绑定（`gameId`、最近 `versionId`、`publicationRevision`、状态）与 AGC 工程内部版本记录 `versions[]`；AGC 发布面板展示的「项目版本」不是清单里可编辑的标量，而是由 `versions[]` 派生的只读标签（见下条）。网页上传和 AGC 发布使用相同游戏、版本与上传记录，不建立两套发行系统。
+- 同一作者用相同 `localProjectId` 再次发布时复用既有 `gameId`。一次具体上传/资料/审核快照由不可变 `versionId` 标识；同一个用户版本标签可以有多个提交实例，旧公开实例不原地修改。AGC 如果清单缺少发布记录，首次更新前按作者作品回读和 `localProjectId` 做一次性恢复。
+- AGC 发布面板的「项目版本」是 AGC 工程内部版本序数，唯一来源是 AGC 项目清单的 `versions[]`（AGC 工程内部版本记录，即资源总览「项目版本」栏目里的版本卡）：标签等于当前存活的内部版本条数（即最新内部版本卡的「版本 N」），`versions` 为空时取 1。该标签**只读**，用户不能编辑，且**不由平台侧任何字段推导**——不得读取、回填或覆盖平台 `version_number`，也不得读取 `publicationRevision`。每次智能体修订追加一条内部版本，标签随之推进。
+- 平台侧 `versionNumber` 是用户可见的正整数版本标签，**不要求严格递增，允许回退和重复提交**；服务端不传时保留旧客户端自动取最大值加一的兼容行为，传入时只校验 `versionNumber >= 1`。该兼容口径只为网页端与历史客户端保留，AGC 不再用它维护"用户发行版本"字段。AGC 项目清单里的历史字段 `projectVersion` 属遗留位：仅为兼容旧清单可解析而保留，任何读写路径都不得再把它当作发行版本来源，AGC 也不再提供修改它的入口。
+- 同一 `gameId` 与同一 `versionNumber` 的再次提交创建新的 `versionId`；旧的 `published`/`activeVersionId` 继续服务，新的提交审核通过后才切换 `activeVersionId`。旧的 pending 提交可被新提交标记为 `cancelled`，审核队列只展示最新有效提交。`publicationRevision` 仍然严格 CAS 递增，但不限制用户版本号。
 - 游戏单独保存 `publicationRevision`、`activeVersionId` 和可见性 `unpublished | published | suspended`；正式可见性由服务端持久化事实决定。未通过审核时 `activeVersionId` 为空；`suspended` 是管理员安全下架，作者不能自行解除。
-- 版本状态为 `awaiting_upload → uploaded → validating → pending_review → published`。上传确定失败进入 `upload_failed`，验证失败进入 `validation_failed`，人工拒绝进入 `rejected`；尚未公开版本可以撤回为 `cancelled`，已公开版本可撤销为 `revoked`。已成功上传的相同字节可重新校验；内容改变或审核拒绝后的修改必须新建版本。
-- 首版建议人工审核。审核员检查游戏资料、真实桌面运行、声明移动适配、内容与外部请求被阻断的行为；自动包校验通过只进入 `pending_review`，不自动公开。审核记录保存审核者、目标版本、结论、理由和时间。后台只授权现有管理员身份，不让普通作者调用审核动作。
-- 更新送审时旧 `activeVersionId` 继续服务目录、详情与游玩。审核通过并完成对象可读验证后，一次事务切换当前公开版本和公开资料；新版本上传、校验、审核或对象安装失败均不改变旧版本。
-- 发布页先自动填入可用标题和封面，首次需要确认必需资料，此后复用上次资料；用户一次“提交发布”动作串联校验、上传和送审，并显示真实阶段。等待审核不能显示“已发布”；成功后提供查看详情和复制公开链接。
+- 版本状态为 `awaiting_upload → uploaded → validating → pending_review → published`。上传确定失败进入 `upload_failed`，验证失败进入 `validation_failed`，人工拒绝进入 `rejected`；尚未公开提交可以撤回为 `cancelled`，已公开实例可撤销为 `revoked`。同一用户版本标签的新内容必须创建新提交实例。
+- 首版建议人工审核。审核员检查游戏资料、真实桌面运行、声明移动适配、内容与外部请求被阻断的行为；自动包校验通过只进入 `pending_review`，不自动公开。审核记录保存审核者、目标 `versionId`、结论、理由和时间。后台只授权现有管理员身份，不让普通作者调用审核动作。
+- 更新送审时旧 `activeVersionId` 继续服务目录、详情与游玩。审核通过并完成对象可读验证后，一次事务切换当前公开版本和公开资料；新提交上传、校验、审核或对象安装失败均不改变旧版本。
+- AGC 发布面板在无绑定时显示“首次发布”，存在绑定时显示“更新游戏”，回填**派生的项目版本标签、线上版本状态和建议值**；不再回填 `projectVersion`。面板同时逐字展示平台侧事实「线上最近提交 vN · 状态」（`N` 取该作品最近更新的版本行，与派生标签可以不同），两者并列展示、互不推导。首版不做完整版本历史/回滚管理；用户不再直接编辑版本标签，回退与重复提交仍由平台侧接受（例如 AGC 工程内部版本被截尾删除后派生标签会变小）。
+- 兼容与迁移：AGC 项目清单的 `versions` 只能追加，或按显式放行删除一个**后缀**（删除素材时连带删除引用该素材的版本）；因此内部版本序数（派生标签）不保证单调递增，历史发布标签可能高于后续发布标签。平台必须继续接受回退标签，AGC 不得把回退在本地判成冲突。本地遗留字段 `projectVersion` 只做兼容解析，不参与任何派生。
+- 非目标：不新增服务端内部版本号字段、不新增或修改 SpacetimeDB 表/字段/procedure、不改 `publicationRevision` 的 CAS 语义、不做版本历史/对比/一键回滚 UI、不重写平台历史版本行的 `version_number`。
 
 ### 幂等、并发与恢复
 
@@ -121,7 +125,10 @@
 | `GET /games/{gameId}` | 游客 | **已实现**：当前公开资料与 `currentVersion.entryUrl`；不可见时 404 |
 | `POST /games/{gameId}/plays` | 游客/登录 | **已实现**：上报一次「开始游戏」；可选 Bearer，非公开 404、超限 429，成功返回 `{recorded}`；只进 api-server 内存缓冲，失败不影响游玩 |
 | `GET /game-distribution/releases/{gameId}[/{assetPath}]` | 游客 | **已实现**：根路径等价于 `index.html`；发行网关只服务当前已公开版本包内文件，按扩展名白名单设内容类型，未知扩展名 404，带 Cookie 的请求 403；游玩页的入口来自详情投影的 `currentVersion.entryUrl` |
-| `GET /my/games` | 登录作者 | **已实现**：当前账号游戏、最近版本状态与驳回理由；owner 只从认证主体派生 |
+| `GET /my-games` | 登录作者 | **已实现**：当前账号游戏、最近版本状态与驳回理由；owner 只从认证主体派生，单次最多 48 项 |
+| `GET /my-games/{gameId}` | 登录作者 | **已实现**：作者读自己名下单个游戏的详情，条目与 `GET /my-games` 同形（含全部版本私有状态、驳回理由与已公开版本的 `entryUrl`）。作者要能打开「审核中 / 被驳回 / 已下架 / 已撤回」的作品，公开详情只服务已公开投影，所以作者视角必须走这条 owner 作用域路由；游戏不存在或不属于当前主体都返回 404 |
+| `PATCH /my-games/{gameId}` | 登录作者 | **已实现**：作者编辑自己名下游戏的展示资料（标题/简介/详介/分类/标签/封面/截图/设备/输入模式/方向），立即生效并落 `tracking_event` 审计；要求 `Idempotency-Key` 与 `expectedPublicationRevision` CAS，随版本冻结的包摘要与资料快照不受影响，缺封面/截图归属不符仍按创建口径拒绝 |
+| `DELETE /my-games/{gameId}?expectedPublicationRevision=` | 登录作者 | **已实现**：作者软删除自己的作品。只写 `deleted_at` 并把公开投影下线（可见性回到 `unpublished`、撤销当前公开版本、递增 `publication_revision`），版本行、发行包与其冻结资料保留；作者列表/公开目录/公开详情/发行网关/审核队列与后台默认视图都不再返回，后台可用 `status=deleted` 查看。要求 `Idempotency-Key`（同 key 同请求返回原结果），不受发布灰度开关约束 |
 | `POST /games` | 登录作者 | **已实现**：幂等创建游戏身份，尚不公开；带 `localProjectId` 时同一作者复用既有 `gameId` |
 | `POST /games/{gameId}/versions` | owner | **已实现**：创建不可变待上传版本，冻结包摘要/字节数/文件数与资料 |
 | `PUT /versions/{versionId}/package` | owner | **已实现**：接收真实 ZIP、重算摘要与文件清单并写入私有对象；不执行游戏代码 |
@@ -131,7 +138,8 @@
 | `POST /games/{gameId}/unpublish` | owner | **已实现**：CAS 关闭公开游戏及其版本入口，不删除审核记录 |
 | `GET /admin/api/game-distribution/reviews` | 管理员 | **已实现**：分页获取待审版本；此行是完整后台路径 |
 | `POST /admin/api/game-distribution/versions/{versionId}/review` | 管理员 | **已实现**：批准由服务端按 gameId 派生平台同源发行路径 `/games/{gameId}/` 并执行公开版本 CAS；拒绝需理由；此行是完整后台路径 |
-| `POST /admin/api/game-distribution/games/{gameId}/suspend` | 管理员 | **已实现**：安全下架整个游戏并撤销发行访问，要求 `expectedPublicationRevision` CAS 与幂等键；后台游戏审核页提供带原因输入与二次确认的入口；此行是完整后台路径 |
+| `POST /admin/api/game-distribution/games/{gameId}/suspend` | 管理员 | **已实现**：安全下架整个游戏并撤销发行访问，要求 `expectedPublicationRevision` CAS 与幂等键；入口在后台「游戏管理」页，带原因输入与二次确认（审核页只做版本级通过/拒绝，不承载游戏级下架）；此行是完整后台路径 |
+| `GET /admin/api/game-distribution/games` | 管理员 | **已实现**：后台作品管理列表，支持 `limit` / `keyword` / `owner` / `status`（`published`、`unpublished`、`suspended`、`deleted`，为空时排除软删行）/ `cursor` 过滤与游标分页，返回 `{ games, nextCursor }`；`status` 不在白名单时 400；此行是完整后台路径 |
 
 除显式 `/admin/api/...` 外，表内路径均相对 `/api/game-distribution`。错误采用现有平台 envelope，覆盖 400 格式错误、401 未登录、403 owner/审核权限错误、404 不可见、409 幂等/状态/并发冲突、413 大小上限、422 包或资料校验失败、429 限流和明确的可重试 5xx；服务端响应不包含存储凭据和本地绝对路径。
 
@@ -470,3 +478,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 冲突、幂等重放；游戏级安全下架在「游戏管理」页 | 审核页只保留版本级动作（含取消不写请求）；游戏管理页保留「下架（原因必填）+ 二次确认」入口 |
+| 工程门禁 | 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/package.json b/package.json
index ca24fab4d..1a9caaae3 100644
--- a/package.json
+++ b/package.json
@@ -189,7 +189,7 @@
     "agc:bundled-resources:sync": "npm --prefix apps/ai-game-creator-shell run bundled-resources:sync",
     "agc:bundled-resources:prepare": "npm --prefix apps/ai-game-creator-shell run bundled-resources:prepare --",
     "agc:bundled-resources:test": "npm --prefix apps/ai-game-creator-shell run bundled-resources:test --",
-    "agc:plugins:test": "node --test plugins/agc-cocos-editor/src/entry.test.mjs plugins/agc-unity-editor/src/entry.test.mjs plugins/agc-godot-editor/src/entry.test.mjs",
+    "agc:plugins:test": "node --test --test-reporter=dot plugins/agc-cocos-editor/src/entry.test.mjs plugins/agc-unity-editor/src/entry.test.mjs plugins/agc-godot-editor/src/entry.test.mjs",
     "agc:plugins:native-test": "cargo test --manifest-path plugins/agc-cocos-editor/native/cocos-editor-bridge/Cargo.toml && cargo test --locked --manifest-path plugins/agc-unity-editor/native/unity-editor-bridge/Cargo.toml && cargo test --locked --manifest-path plugins/agc-godot-editor/native/godot-editor-bridge/Cargo.toml",
     "agc:plugins:check": "npm run agc:plugins:test && npm run agc:plugins:native-test",
     "agc:check": "npm run ai-game-creator-shell:check",
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..1cd432067
--- /dev/null
+++ b/packages/shared/src/components/GameDetailDisplay/index.tsx
@@ -0,0 +1,299 @@
+import './index.css';
+
+import { Maximize2, Smartphone, Sparkles } from 'lucide-react';
+import { type ReactElement, type ReactNode, useState } 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();
+  /** 作者名由宿主解析（公开详情会按作者 ID 补查真实昵称）；空名不渲染，避免出现「由 — 制作」。 */
+  const authorName = (game.author.name ?? '').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}
+          {authorName ? (
+            <div className="game-detail-hero__author">
+              <span className="game-detail-avatar" aria-hidden="true">
+                {Array.from(authorName)[0]}
+              </span>
+              <span title={authorName}>由 {authorName} 制作</span>
+            </div>
+          ) : null}
+          <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/AdminFormat.test.ts b/packages/shared/src/components/admin/AdminFormat.test.ts
new file mode 100644
index 000000000..13b169cab
--- /dev/null
+++ b/packages/shared/src/components/admin/AdminFormat.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest';
+
+import { formatAdminDate, formatAdminDateTime } from './AdminFormat';
+
+describe('formatAdminDateTime', () => {
+  test('把后端的 seconds.microsZ 口径当成同一时刻渲染', () => {
+    // 游戏分发后台接口下发的是 shared-kernel `format_timestamp_micros` 的
+    // `seconds.microsZ` 文本（非 ISO 8601），必须与等价 ISO 时刻渲染一致。
+    const microsText = '1791008678.817257Z';
+    const equivalentIso = new Date(1791008678 * 1000 + 817).toISOString();
+
+    expect(formatAdminDateTime(microsText)).toBe(
+      formatAdminDateTime(equivalentIso),
+    );
+    expect(formatAdminDateTime(microsText)).not.toBe('-');
+  });
+
+  test('微秒位数不足时按毫秒补零，而不是丢位', () => {
+    expect(formatAdminDateTime('1791008678.8Z')).toBe(
+      formatAdminDateTime(new Date(1791008678 * 1000 + 800).toISOString()),
+    );
+  });
+
+  test('ISO 字符串、epoch 毫秒与 Date 仍按原语义渲染', () => {
+    const iso = '2026-09-20T08:00:00Z';
+    expect(formatAdminDateTime(iso)).toBe(formatAdminDateTime(new Date(iso)));
+    expect(formatAdminDateTime(Date.parse(iso))).toBe(
+      formatAdminDateTime(new Date(iso)),
+    );
+  });
+
+  test('无法解析的值回落 fallback', () => {
+    expect(formatAdminDateTime('not-a-time')).toBe('-');
+    expect(formatAdminDateTime('')).toBe('-');
+    expect(formatAdminDateTime(null)).toBe('-');
+  });
+});
+
+describe('formatAdminDate', () => {
+  test('同样接受 seconds.microsZ 口径', () => {
+    expect(formatAdminDate('1791008678.817257Z')).toBe(
+      formatAdminDate(new Date(1791008678 * 1000 + 817).toISOString()),
+    );
+    expect(formatAdminDate('1791008678.817257Z')).not.toBe('-');
+  });
+});
diff --git a/packages/shared/src/components/admin/AdminFormat.ts b/packages/shared/src/components/admin/AdminFormat.ts
index c3fb261a6..21e10f666 100644
--- a/packages/shared/src/components/admin/AdminFormat.ts
+++ b/packages/shared/src/components/admin/AdminFormat.ts
@@ -1,5 +1,28 @@
 /**
- * 后台统一的时间展示：ISO 字符串 / epoch 毫秒 / Date → `zh-CN` 本地时间。
+ * 部分后台接口下发的微秒时间戳是 `seconds.microsZ` 文本口径（见 shared-kernel 的
+ * `format_timestamp_micros`，例如 `1791008678.817257Z`）。它不是 ISO 8601，
+ * JS `new Date()` 会直接判成 `Invalid Date`，因此先归一成 ISO 字符串再解析。
+ * 其它输入原样返回，交给 `new Date()` 处理。
+ */
+function normalizeAdminTimestamp(value: string | number): string | number {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  const micros = /^(\d+)\.(\d{1,9})Z$/.exec(value.trim());
+  if (!micros) {
+    return value;
+  }
+  const seconds = Number(micros[1]);
+  const fraction = micros[2] ?? '';
+  if (!Number.isSafeInteger(seconds)) {
+    return value;
+  }
+  const millis = Number(fraction.padEnd(9, '0').slice(0, 3));
+  return new Date(seconds * 1000 + millis).toISOString();
+}
+
+/**
+ * 后台统一的时间展示：ISO 字符串 / `seconds.microsZ` / epoch 毫秒 / Date → `zh-CN` 本地时间。
  * 解析不出来时回落到 `fallback`，避免页面上出现 `Invalid Date` 或裸 ISO 串。
  */
 export function formatAdminDateTime(
@@ -10,7 +33,8 @@ export function formatAdminDateTime(
     return fallback;
   }
 
-  const date = value instanceof Date ? value : new Date(value);
+  const date =
+    value instanceof Date ? value : new Date(normalizeAdminTimestamp(value));
   if (!Number.isFinite(date.getTime())) {
     return fallback;
   }
@@ -30,7 +54,7 @@ export function formatAdminDateTime(
   }
 }
 
-/** 后台统一的日期展示（不含时分秒）。 */
+/** 后台统一的日期展示（不含时分秒）：同样接受 `seconds.microsZ` 口径。 */
 export function formatAdminDate(
   value: string | number | Date | null | undefined,
   fallback = '-',
@@ -39,7 +63,8 @@ export function formatAdminDate(
     return fallback;
   }
 
-  const date = value instanceof Date ? value : new Date(value);
+  const date =
+    value instanceof Date ? value : new Date(normalizeAdminTimestamp(value));
   if (!Number.isFinite(date.getTime())) {
     return fallback;
   }
diff --git a/packages/shared/src/components/admin/admin.css b/packages/shared/src/components/admin/admin.css
index 3c91b9cfa..ad1772617 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;
@@ -397,7 +431,8 @@
   border-radius: 999px;
   padding: 3px 8px;
   font-size: 12px;
-  overflow-wrap: anywhere;
+  /* 状态标签是短徽标：必须单行，避免在窄列里被拆成每行一两个字。 */
+  white-space: nowrap;
 }
 
 .admin-status-ok {
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..fa6ce1072 100644
--- a/packages/shared/src/contracts/gameCreationApp.ts
+++ b/packages/shared/src/contracts/gameCreationApp.ts
@@ -959,6 +959,44 @@ 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 const GAME_CREATION_APP_FIRST_PROJECT_VERSION = 1;
+
+/**
+ * 发布面板展示的「项目版本」的唯一权威值：AGC 工程内部版本序数。
+ *
+ * 唯一来源是清单里的 `versions[]`（AGC 工程内部版本记录，即资源总览「项目版本」栏目里的
+ * 版本卡）：标签等于当前存活的内部版本条数，也就是最新内部版本卡的「版本 N」；没有版本
+ * 记录时用首版 1。
+ *
+ * 这条值**只读**，且不由平台侧任何字段推导：不读发布绑定里的 `latestVersionNumber`，
+ * 也不读 `publicationRevision`。平台 `versionNumber` 与本地标签是两套独立概念，并列展示、
+ * 互不推导。清单里遗留的 `projectVersion` 只做兼容解析，不参与本函数。
+ */
+export function resolveGameCreationAppProjectVersion(
+  manifest: Pick<GameCreationAppManifest, 'versions'>,
+): number {
+  const count = manifest.versions?.length ?? 0;
+  return count > 0 ? count : GAME_CREATION_APP_FIRST_PROJECT_VERSION;
+}
+
 export interface GameCreationAppManifest {
   schemaVersion: string;
   projectId: string;
@@ -971,6 +1009,15 @@ export interface GameCreationAppManifest {
   versions?: GameIterationVersion[];
   godotProjectRoot?: string | null;
   cocosProjectRoot?: string | null;
+  /**
+   * 遗留位：历史清单写过的用户发行版本标签，仅为兼容旧清单可解析而保留。
+   *
+   * 它**不再**是发行版本来源：读取方一律用 `resolveGameCreationAppProjectVersion` 按工程
+   * 内部版本 `versions[]` 派生，原生也不再写入或回填这个字段（下一次落盘时会被抹掉）。
+   */
+  projectVersion?: number | null;
+  /** 平台发布绑定；缺失即该项目尚未发布过。 */
+  publication?: GameCreationAppPublicationBinding | null;
 }
 
 export interface GameCreationAgentToolCallTrace {
diff --git a/packages/shared/src/contracts/gameDistribution.ts b/packages/shared/src/contracts/gameDistribution.ts
index 1d0d8cd7a..f7803ebdb 100644
--- a/packages/shared/src/contracts/gameDistribution.ts
+++ b/packages/shared/src/contracts/gameDistribution.ts
@@ -168,6 +168,14 @@ export type GameDistributionCreateGameRequest = {
 
 export type GameDistributionCreateVersionRequest = {
   localProjectId?: string | null;
+  /**
+   * 用户可见的正整数版本标签（AGC 发布面板由工程内部版本序数派生后原样提交）。
+   *
+   * 传入时只要求 `>= 1`：同一 `gameId` 的同一个版本号可以反复提交，每次提交生成新的
+   * `versionId`，允许重复标签与回退到更小的版本号，不与已有最大值比较。
+   * 缺省时保留旧客户端兼容行为：服务端按该游戏已有最大版本号 +1。
+   */
+  versionNumber?: number | null;
   packageSha256: string;
   packageBytes: number;
   packageFileCount: number;
@@ -175,20 +183,43 @@ export type GameDistributionCreateVersionRequest = {
   gameMetadata: GameDistributionCreateGameRequest;
 };
 
+/**
+ * 作者编辑游戏级展示资料。
+ *
+ * 只覆盖游戏行上的展示字段；随版本冻结的包摘要与资料快照不受影响。
+ * `expectedPublicationRevision` 是公开切换 CAS，并发变化返回 409。
+ */
+export type GameDistributionUpdateGameMetadataRequest = {
+  expectedPublicationRevision: number;
+  title: string;
+  summary: string;
+  description?: string | null;
+  category: GameDistributionCategory;
+  tags?: string[];
+  coverAssetId?: string | null;
+  /** 截图素材 ID（最多 6 张，复用平台图片上传与归属校验）。 */
+  screenshots?: string[];
+  deviceSupport: GameDistributionDeviceSupport;
+  inputModes: GameDistributionInputMode[];
+  orientation: GameDistributionOrientation;
+};
+
 export type GameDistributionPrivateVersion = {
   versionId: string;
   gameId: string;
   versionNumber: number;
   packageSha256: string;
   packageBytes: number;
+  packageFileCount: number;
   status: GameDistributionVersionStatus;
   /** 游戏公开修订号；撤回与审核动作都必须回传当前值做 CAS。 */
   publicationRevision: number;
   reviewReason?: string | null;
+  /** 审核通过后由服务端派生的公开入口，未公开版本为 null。 */
+  entryUrl: string | null;
   createdAt: string;
   updatedAt: string;
 };
-
 /**
  * 版本状态的下一步动作，由服务端派生；客户端只按它渲染主行动作，不自行推断状态。
  */
diff --git a/scripts/admin-web-fake-api.mjs b/scripts/admin-web-fake-api.mjs
index 171af14d1..f909a3986 100644
--- a/scripts/admin-web-fake-api.mjs
+++ b/scripts/admin-web-fake-api.mjs
@@ -1027,6 +1027,7 @@ function route(pathname, method, url) {
       publicationRevision: versions[0]?.versionNumber ?? 0,
       createdAt: iso(60 * 24 * 20),
       updatedAt: iso(60 * 3),
+      deletedAt: null,
       versions,
     });
     const version = (versionId, versionNumber, status, bytes) => ({
@@ -1041,17 +1042,56 @@ function route(pathname, method, url) {
       reviewReason: null,
       entryUrl: `https://games.example.com/${versionId}/index.html`,
     });
+    const allGames = [
+      game('game_1001', '陶泥小世界', '阿陶', 'published', 345, [
+        version('ver_1001_7', 7, 'published', 18_400_000),
+        version('ver_1001_6', 6, 'published', 17_900_000),
+      ]),
+      game('game_1002', '纸片拼图计划', '小满', 'suspended', 96, [
+        version('ver_1002_3', 3, 'suspended', 5_120_004),
+      ]),
+      game('game_1003', '三消工坊', '老周', 'unpublished', 12, []),
+      {
+        ...game('game_1004', '已删除的试作', '阿陶', 'unpublished', 4, []),
+        status: 'deleted',
+        deletedAt: iso(60 * 2),
+      },
+    ];
+    const limit = Math.min(
+      Math.max(Number(url.searchParams.get('limit') ?? 50) || 50, 1),
+      200,
+    );
+    const keyword = (url.searchParams.get('keyword') ?? '')
+      .trim()
+      .toLowerCase();
+    const owner = (url.searchParams.get('owner') ?? '').trim();
+    const status = (url.searchParams.get('status') ?? '').trim();
+    const offset = Number(url.searchParams.get('cursor') ?? 0) || 0;
+    // 状态/关键词/作者过滤与游标语义跟服务端保持一致：默认排除已删除作品。
+    const filtered = allGames.filter((entry) => {
+      if (status === 'deleted') {
+        if (entry.status !== 'deleted') return false;
+      } else if (status) {
+        if (entry.status !== status || entry.deletedAt) return false;
+      } else if (entry.deletedAt) {
+        return false;
+      }
+      if (owner && entry.author.id !== owner) return false;
+      if (
+        keyword &&
+        !entry.title.toLowerCase().includes(keyword) &&
+        !entry.gameId.toLowerCase().includes(keyword) &&
+        !entry.author.id.toLowerCase().includes(keyword)
+      ) {
+        return false;
+      }
+      return true;
+    });
+    const page = filtered.slice(offset, offset + limit);
+    const nextOffset = offset + page.length;
     return {
-      games: [
-        game('game_1001', '陶泥小世界', '阿陶', 'published', 345, [
-          version('ver_1001_7', 7, 'published', 18_400_000),
-          version('ver_1001_6', 6, 'published', 17_900_000),
-        ]),
-        game('game_1002', '纸片拼图计划', '小满', 'suspended', 96, [
-          version('ver_1002_3', 3, 'suspended', 5_120_004),
-        ]),
-        game('game_1003', '三消工坊', '老周', 'unpublished', 12, []),
-      ],
+      games: page,
+      nextCursor: nextOffset < filtered.length ? String(nextOffset) : null,
     };
   }
   if (pathname === '/admin/api/editor-assets') {
diff --git a/scripts/build-gitea-rust-cache.sh b/scripts/build-gitea-rust-cache.sh
index 13ff337c9..75932951f 100644
--- a/scripts/build-gitea-rust-cache.sh
+++ b/scripts/build-gitea-rust-cache.sh
@@ -75,7 +75,7 @@ set -euo pipefail
 rustc -vV > /opt/genarrative-ci/rust-cache/rustc.txt
 export GITHUB_ENV=/tmp/rust-cache.env CARGO_INCREMENTAL=0 CARGO_BUILD_JOBS=4 CI=true
 # sccache 对 CARGO_*（除 jobserver/jobs 等特例）参与 hash，必须与 workflow 对齐。
-export CARGO_HTTP_MULTIPLEXING=false CARGO_NET_RETRY=10 CARGO_TERM_COLOR=always
+export CARGO_HTTP_MULTIPLEXING=false CARGO_NET_RETRY=10 CARGO_TERM_COLOR=always CARGO_TERM_QUIET=true
 bash /tmp/ci-rust-cache.sh prepare
 set -a
 source "${GITHUB_ENV}"
diff --git a/scripts/check-game-distribution-dto-parity.mjs b/scripts/check-game-distribution-dto-parity.mjs
index c87e829dc..a149af079 100644
--- a/scripts/check-game-distribution-dto-parity.mjs
+++ b/scripts/check-game-distribution-dto-parity.mjs
@@ -49,6 +49,10 @@ const PAIRS = [
     'GameDistributionCreateVersionRequest',
     'GameDistributionCreateVersionRequest',
   ],
+  [
+    'GameDistributionUpdateGameMetadataRequest',
+    'GameDistributionUpdateGameMetadataRequest',
+  ],
   ['GameDistributionPrivateVersion', 'GameDistributionPrivateVersion'],
   ['AdminGameReviewGamesQuery', 'AdminGameReviewGamesQuery'],
   ['AdminGameReviewGame', 'AdminGameReviewGame'],
diff --git a/scripts/check-game-distribution-sandbox-e2e.mjs b/scripts/check-game-distribution-sandbox-e2e.mjs
index 481c8962f..4da971b3a 100644
--- a/scripts/check-game-distribution-sandbox-e2e.mjs
+++ b/scripts/check-game-distribution-sandbox-e2e.mjs
@@ -7,8 +7,8 @@
 //   E2E_CHROMIUM_EXECUTABLE=<ms-playwright 里的 chrome.exe，可省略>
 //   E2E_ADMIN_USER=... E2E_ADMIN_PASSWORD=... npm run check:game-distribution-sandbox-e2e
 //
-// 覆盖：ES module 与同包资源能在 opaque sandbox 下载入；外站 fetch / WebSocket 被挡；
-// localStorage / document.cookie / 父文档 DOM 都拿不到；顶层跳转与弹窗被挡；
+// 覆盖：ES module 与同包资源能在 opaque sandbox 下载入；运行期 storage 兼容层可用；
+// 外站 fetch / WebSocket 被挡；document.cookie / 父文档 DOM 都拿不到；顶层跳转和弹窗被挡；
 // 敏感权限（定位）被拒；同时核对发行网关的 CSP / nosniff / CORS / Cookie 403 策略。
 import { createRequire } from 'node:module';
 import path from 'node:path';
@@ -140,14 +140,14 @@ const PROBE_APP = `import { marker } from './helper.js';
 
 const results = { moduleLoaded: marker === 'helper-ok' };
 
-// 探针自身也可能被浏览器直接抛错挡下（例如 opaque origin 读 cookie），
-// 所以每一步单独兜底，最后无论如何都把结果 postMessage 给父页面。
 try {
+  // opaque origin 的原生 storage 不可用，但发行网关会在游戏脚本前注入运行期兼容层。
   try {
-    window.localStorage.getItem('probe');
-    results.storageBlocked = false;
+    window.localStorage.setItem('probe', 'ok');
+    results.storageAvailable = window.localStorage.getItem('probe') === 'ok';
+    window.localStorage.removeItem('probe');
   } catch {
-    results.storageBlocked = true;
+    results.storageAvailable = false;
   }
 
   try {
@@ -479,8 +479,8 @@ document.body.appendChild(frame);
       results.moduleLoaded === true,
     );
     check(
-      'localStorage 在 opaque sandbox 下不可用',
-      results.storageBlocked === true,
+      'opaque sandbox 下运行期 storage 兼容层可用',
+      results.storageAvailable === true,
     );
     check(
       'document.cookie 在 opaque sandbox 下为空',
diff --git a/scripts/check-native-shells.mjs b/scripts/check-native-shells.mjs
index 4dcf9550b..84e7c5125 100644
--- a/scripts/check-native-shells.mjs
+++ b/scripts/check-native-shells.mjs
@@ -5081,7 +5081,7 @@ for (const step of steps) {
     continue;
   }
 
-  console.log(`[check:native-shells] ${step.label}`);
+  // 成功不打印进度标签；只有在失败时才知道是哪个 step，避免每个 step 一行刷屏。
   const result = spawnSync(step.command, step.args, {
     cwd: process.cwd(),
     stdio: 'inherit',
@@ -5102,6 +5102,9 @@ for (const step of steps) {
   }
 
   if ((result.status ?? 0) !== 0) {
+    console.error(
+      `[check:native-shells] ${step.label} failed (exit=${result.status})`,
+    );
     process.exit(result.status ?? 1);
   }
 }
diff --git a/server-rs/crates/api-server/src/frontend_runtime_config.rs b/server-rs/crates/api-server/src/frontend_runtime_config.rs
index dea103eca..51dd3388b 100644
--- a/server-rs/crates/api-server/src/frontend_runtime_config.rs
+++ b/server-rs/crates/api-server/src/frontend_runtime_config.rs
@@ -16,8 +16,8 @@ use crate::{
 pub struct FrontendRuntimeConfigResponse {
     pub image_editor_agent_sidebar_enabled: bool,
     pub agc_template_library_enabled: bool,
-    /// 游戏发布灰度：运营未配置 `game-distribution:publish` 时对已登录作者默认开放，
-    /// 显式收紧后只有白名单/灰度命中的作者拿到 `true`；匿名一律 `false`（发布必须先登录）。
+    /// 游戏发布灰度：未配置 `game-distribution:publish` 或 `enabled=false` 时不开放；
+    /// 显式配置后按 enabled、白名单、标签和灰度比例判定，匿名一律 `false`（发布必须先登录）。
     pub game_distribution_publish_enabled: bool,
 }
 
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 184afb343..bc7905ed6 100644
--- a/server-rs/crates/api-server/src/modules/game_distribution.rs
+++ b/server-rs/crates/api-server/src/modules/game_distribution.rs
@@ -22,6 +22,7 @@ use module_game_distribution::{
     normalize_review_moderation_reason, release_asset_content_type, validate_release_zip,
     validate_review_list_status,
 };
+use platform_auth::read_refresh_session_token;
 use platform_llm::{EDITOR_AGENT_GPT5_MODEL, LlmMessage, LlmRunRequest};
 use platform_oss::{
     OssAppendInternalObjectRequest, OssDeleteObjectRequest, OssGetObjectRequest,
@@ -36,25 +37,29 @@ 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, GameDistributionPublishMetadataSuggestion,
-    GameDistributionPublishMetadataSuggestionRequest, GameDistributionRatingSummary,
-    GameDistributionReview, GameDistributionReviewsResponse, GameDistributionSaveReviewRequest,
-    GameDistributionSaveReviewResponse,
+    GameDistributionMyReviewResponse, GameDistributionOrientation,
+    GameDistributionPublishMetadataSuggestion, GameDistributionPublishMetadataSuggestionRequest,
+    GameDistributionRatingSummary, GameDistributionReview, GameDistributionReviewsResponse,
+    GameDistributionSaveReviewRequest, GameDistributionSaveReviewResponse,
+    GameDistributionUpdateGameMetadataRequest,
 };
 use spacetime_client::{
     GameDistributionAdminGameListRecordInput, GameDistributionAdminGameRecord,
     GameDistributionAdminUserReviewListRecordInput, GameDistributionAdminUserReviewRecord,
     GameDistributionAdminVersionRecord, GameDistributionApproveRecordInput,
-    GameDistributionCancelVersionRecordInput, GameDistributionGameRecord,
-    GameDistributionGetGameRecordInput, GameDistributionPublicGameListRecordInput,
+    GameDistributionCancelVersionRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionGameRecord, GameDistributionGetGameRecordInput,
+    GameDistributionOwnerGameRecord, GameDistributionPublicGameListRecordInput,
     GameDistributionPublicGameRecord, GameDistributionRatingSummaryRecord,
     GameDistributionRejectRecordInput, GameDistributionRestoreRecordInput,
     GameDistributionReviewGameListRecordInput, GameDistributionReviewModerationOperationRecord,
     GameDistributionReviewModerationRecordInput, GameDistributionSubmitReviewRecordInput,
     GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
-    GameDistributionUserReviewRecord, GameDistributionVersionRecord, SpacetimeClientError,
+    GameDistributionUpdateMetadataRecordInput, GameDistributionUserReviewRecord,
+    GameDistributionVersionRecord, SpacetimeClientError,
 };
 use tracing::{debug, info, warn};
 use uuid::Uuid;
@@ -68,6 +73,7 @@ use crate::{
     platform_errors::{map_llm_error, map_oss_error},
     request_context::{RequestContext, client_ip_from_headers},
     state::AppState,
+    tracking::{TrackingEventDraft, record_tracking_event_after_success},
 };
 
 pub(crate) const MAX_PACKAGE_REQUEST_BODY_BYTES: usize = MAX_PACKAGE_BYTES as usize + 1024;
@@ -81,6 +87,8 @@ const PACKAGE_UPLOAD_OFFSET_HEADER: &str = "x-genarrative-upload-offset";
 const MAX_LIST_LIMIT: u32 = 48;
 /// 后台游戏管理页全量列表上限，与 spacetime-module 的 admin game list limit 保持同口径。
 const MAX_ADMIN_GAME_LIST_LIMIT: u32 = 200;
+/// 后台作品状态过滤的白名单；`deleted` 表示已软删除的作品。
+const ADMIN_GAME_LIST_STATUSES: [&str; 4] = ["published", "unpublished", "suspended", "deleted"];
 const MAX_IDEMPOTENCY_KEY_CHARS: usize = 128;
 const MAX_PACKAGE_MANIFEST_JSON_BYTES: usize = 2 * 1024 * 1024;
 /// 首版截图上限，与主规范冻结口径一致。
@@ -94,6 +102,14 @@ const RELEASE_PACKAGE_CACHE_MAX_ENTRIES: usize = 4;
 /// 缓存字节预算必须比单个发行包上限大出一档，否则 200 MiB 档的包只能刚好自占整份预算，
 /// 任何并发的小包都会被立刻挤掉。
 const RELEASE_PACKAGE_CACHE_MAX_BYTES: usize = 256 * 1024 * 1024;
+/// 发行包运行在 `sandbox="allow-scripts"` 的 opaque origin 中，浏览器原生 storage
+/// 会抛 `SecurityError`。不授予 `allow-same-origin`（否则同源脚本可能移除 sandbox），
+/// 而是在游戏脚本前安装本次运行期的同步兼容存储；它不接触平台 Cookie、DOM 或账号数据。
+const RELEASE_STORAGE_BOOTSTRAP: &str = concat!(
+    "<script>",
+    include_str!("game_distribution_release_storage_bootstrap.js"),
+    "</script>",
+);
 
 /// 发行静态资源的进程内缓存。
 ///
@@ -217,6 +233,21 @@ struct AdminSuspendRequest {
 #[derive(Debug, Deserialize)]
 struct AdminGameListQuery {
     limit: Option<u32>,
+    /// 关键词：匹配标题、gameId 或作者 user ID。
+    keyword: Option<String>,
+    #[serde(alias = "ownerUserId")]
+    owner: Option<String>,
+    /// `published` / `unpublished` / `suspended` / `deleted`；为空时排除已软删除游戏。
+    status: Option<String>,
+    cursor: Option<String>,
+}
+
+/// 作者软删除游戏：CAS 修订号走查询串，删除本身没有请求体。
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DeleteOwnerGameQuery {
+    #[serde(alias = "expected_publication_revision")]
+    expected_publication_revision: u64,
 }
 
 #[derive(Debug, Deserialize)]
@@ -306,6 +337,12 @@ pub fn router(state: AppState) -> Router<AppState> {
             post(cancel_version),
         )
         .route("/api/game-distribution/my-games", get(list_my_games))
+        .route(
+            "/api/game-distribution/my-games/{game_id}",
+            get(get_owner_game)
+                .patch(update_owner_game_metadata)
+                .delete(delete_owner_game),
+        )
         .route(
             "/api/game-distribution/games/{game_id}/unpublish",
             post(unpublish_game),
@@ -328,6 +365,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",
@@ -366,6 +407,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)
@@ -810,7 +863,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)
@@ -818,7 +884,43 @@ async fn serve_release_asset(
         }
         Err(_) => return Err(AppError::from_status(StatusCode::NOT_FOUND)),
     };
-    Ok(release_asset_response(content, content_type))
+    let content = normalize_release_asset_references(content, content_type);
+    let content = inject_release_storage_bootstrap(content, content_type);
+    Ok(release_asset_response_with_cache(
+        content,
+        content_type,
+        cache_control,
+    ))
+}
+
+fn normalize_release_asset_references(content: Vec<u8>, content_type: &str) -> Vec<u8> {
+    if !(content_type.starts_with("text/html")
+        || content_type.starts_with("text/css")
+        || content_type.contains("javascript"))
+    {
+        return content;
+    }
+    let mut source = match String::from_utf8(content) {
+        Ok(source) => source,
+        Err(error) => return error.into_bytes(),
+    };
+    for root in ["assets", "game", "ui"] {
+        source = source.replace(&format!("\"/{root}/"), &format!("\"{root}/"));
+        source = source.replace(&format!("'/{root}/"), &format!("'{root}/"));
+        source = source.replace(&format!("`/{root}/"), &format!("`{root}/"));
+        source = source.replace(&format!("url(/{root}/"), &format!("url({root}/"));
+    }
+    source.into_bytes()
+}
+
+fn inject_release_storage_bootstrap(content: Vec<u8>, content_type: &str) -> Vec<u8> {
+    if !content_type.starts_with("text/html") {
+        return content;
+    }
+    let mut result = Vec::with_capacity(RELEASE_STORAGE_BOOTSTRAP.len() + content.len());
+    result.extend_from_slice(RELEASE_STORAGE_BOOTSTRAP.as_bytes());
+    result.extend_from_slice(&content);
+    result
 }
 
 /// 读取（并按对象键缓存）已确认的私有发行包。
@@ -858,7 +960,11 @@ 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));
@@ -872,7 +978,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，
@@ -1060,26 +1166,267 @@ async fn list_my_games(
         .map_err(map_spacetime_error)?;
     let payload = games
         .into_iter()
-        .map(|entry| {
-            let mut value = game_payload(&entry.game);
-            let versions = entry
-                .versions
-                .iter()
-                .map(private_version_payload)
-                .collect::<Vec<_>>();
-            if let Value::Object(ref mut object) = value {
-                object.insert(
-                    "latestVersion".to_string(),
-                    versions.first().cloned().unwrap_or(Value::Null),
-                );
-                object.insert("versions".to_string(), Value::Array(versions));
-            }
-            value
-        })
+        .map(owner_game_entry_payload)
         .collect::<Vec<_>>();
     Ok(json_success_body(Some(&ctx), json!({ "games": payload })))
 }
 
+/// 作者读取自己名下单个游戏的详情，与 `list_my_games` 的条目同形。
+///
+/// 作者管理页要能打开「审核中 / 被驳回 / 已下架 / 已撤回」的作品，公开详情只服务已公开
+/// 投影，所以作者视角必须走这条 owner 作用域路由，否则作者点自己的作品只会拿到 404。
+/// 游戏不存在或不属于当前主体都返回 404，避免用错误码区分"别人的游戏"和"不存在的游戏"。
+async fn get_owner_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    let game = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: game_id.clone(),
+            owner_user_id: Some(owner_user_id.clone()),
+        })
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let versions = load_owner_game_versions(&state, owner_user_id, &game_id).await?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "game": owner_game_entry_payload(GameDistributionOwnerGameRecord { game, versions }) }),
+    ))
+}
+
+/// 读取当前主体名下某个游戏的版本列表。
+///
+/// 目前复用作者自有列表 procedure（版本随游戏聚合返回），因此与 `/my-games` 共享同一个
+/// 条数上限：单作者作品数超过上限时该游戏没有版本记录。放量前需要补一条按 `game_id`
+/// 精确列版本的 procedure。
+async fn load_owner_game_versions(
+    state: &AppState,
+    owner_user_id: String,
+    game_id: &str,
+) -> Result<Vec<GameDistributionVersionRecord>, AppError> {
+    let games = state
+        .spacetime_client()
+        .list_owner_game_distribution_games(
+            spacetime_client::GameDistributionOwnerGameListRecordInput {
+                owner_user_id,
+                limit: MAX_LIST_LIMIT,
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(games
+        .into_iter()
+        .find(|entry| entry.game.game_id == game_id)
+        .map(|entry| entry.versions)
+        .unwrap_or_default())
+}
+
+/// 把资料编辑请求映射成创建请求，以复用同一套资料校验与素材归属解析。
+///
+/// `localProjectId` 只属于创建语义，编辑资料不参与游戏身份复用，因此固定为空。
+fn game_metadata_update_as_create_request(
+    payload: &GameDistributionUpdateGameMetadataRequest,
+) -> GameDistributionCreateGameRequest {
+    GameDistributionCreateGameRequest {
+        local_project_id: None,
+        title: payload.title.clone(),
+        summary: payload.summary.clone(),
+        description: payload.description.clone(),
+        category: payload.category.clone(),
+        tags: payload.tags.clone(),
+        cover_asset_id: payload.cover_asset_id.clone(),
+        screenshots: payload.screenshots.clone(),
+        device_support: payload.device_support.clone(),
+        input_modes: payload.input_modes.clone(),
+        orientation: payload.orientation,
+    }
+}
+
+/// 编辑游戏资料的审计草稿：谁在什么时候把哪个作品的哪些展示字段改成了什么。
+fn build_game_metadata_update_audit(
+    owner_user_id: &str,
+    game_id: &str,
+    title: &str,
+    category: &str,
+    expected_publication_revision: u64,
+) -> TrackingEventDraft {
+    let mut draft = TrackingEventDraft::user(
+        "game_distribution_game_metadata_updated",
+        "game-distribution",
+        owner_user_id,
+    );
+    draft.metadata = json!({
+        "gameId": game_id,
+        "title": title,
+        "category": category,
+        "expectedPublicationRevision": expected_publication_revision,
+    });
+    draft
+}
+
+/// 软删除游戏的审计草稿：删除动作不可逆，必须能回答"谁在什么时候删了哪个作品"。
+fn build_game_delete_audit(
+    owner_user_id: &str,
+    game_id: &str,
+    title: &str,
+    expected_publication_revision: u64,
+) -> TrackingEventDraft {
+    let mut draft = TrackingEventDraft::user(
+        "game_distribution_game_deleted",
+        "game-distribution",
+        owner_user_id,
+    );
+    draft.metadata = json!({
+        "gameId": game_id,
+        "title": title,
+        "expectedPublicationRevision": expected_publication_revision,
+    });
+    draft
+}
+
+/// 作者编辑自己名下游戏的展示资料。
+///
+/// 资料在 game 级立即生效：页面、公开目录与详情下一次读取即换新；随版本冻结的包摘要与
+/// 资料快照不受影响，下一次审核通过仍会用新版本的冻结资料覆盖游戏行。写入要求
+/// `Idempotency-Key` 与 `expectedPublicationRevision` CAS，并落 `tracking_event` 审计。
+async fn update_owner_game_metadata(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    Json(payload): Json<GameDistributionUpdateGameMetadataRequest>,
+) -> Result<Json<Value>, AppError> {
+    ensure_publish_enabled(&state, Some(auth.claims().user_id())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let owner_user_id = auth.claims().user_id().to_string();
+    // 资料校验与素材归属解析复用创建游戏同一套：编辑不能绕过"必须有封面/截图必须是本人图片"。
+    let create_metadata = game_metadata_update_as_create_request(&payload);
+    validate_game_metadata(&create_metadata)?;
+    let (cover_asset_id, cover_object_key, screenshots) =
+        resolve_owned_game_media(&state, owner_user_id.as_str(), &create_metadata).await?;
+    let audit = build_game_metadata_update_audit(
+        owner_user_id.as_str(),
+        game_id.as_str(),
+        payload.title.as_str(),
+        payload.category.as_str(),
+        payload.expected_publication_revision,
+    );
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(game_id.as_str(), &payload))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let log_owner_user_id = owner_user_id.clone();
+    let log_title = payload.title.clone();
+    let game = state
+        .spacetime_client()
+        .update_game_distribution_game_metadata(GameDistributionUpdateMetadataRecordInput {
+            game_id,
+            owner_user_id,
+            expected_publication_revision: payload.expected_publication_revision,
+            title: payload.title,
+            summary: payload.summary,
+            description: payload.description,
+            category: payload.category,
+            tags_json: serde_json::to_string(&payload.tags)
+                .map_err(|error| internal(error.to_string()))?,
+            cover_asset_id: Some(cover_asset_id),
+            cover_object_key: Some(cover_object_key),
+            screenshots_json: Some(
+                serde_json::to_string(&screenshots).map_err(|error| internal(error.to_string()))?,
+            ),
+            device_support_desktop: payload.device_support.desktop,
+            device_support_mobile: payload.device_support.mobile,
+            device_support_touch: payload.device_support.touch,
+            input_modes_json: serde_json::to_string(&payload.input_modes)
+                .map_err(|error| internal(error.to_string()))?,
+            orientation: orientation_wire_value(payload.orientation)?,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    record_tracking_event_after_success(&state, &ctx, audit).await;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_metadata_updated",
+        game_id = %game.0.game_id,
+        owner_user_id = %log_owner_user_id,
+        title = %log_title,
+        publication_revision = game.0.publication_revision,
+        replayed = game.1,
+        elapsed_ms = ctx.elapsed(),
+        "作者更新游戏展示资料"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "game": game_payload(&game.0), "replayed": game.1 }),
+    ))
+}
+
+/// 作者软删除自己名下的游戏。
+///
+/// 删除只标记 `deleted_at` 并把公开投影下线，保留版本行、发行包与冻结资料；作者视图、
+/// 公开目录/详情、发行网关与后台默认列表都不再返回该作品。与下架一致，该动作不受发布
+/// 灰度开关约束（收紧投稿时仍必须允许作者撤下自己的内容）。
+async fn delete_owner_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    Query(query): Query<DeleteOwnerGameQuery>,
+) -> Result<Json<Value>, AppError> {
+    let idempotency_key = idempotency_key(&headers)?;
+    let owner_user_id = auth.claims().user_id().to_string();
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(game_id.as_str(), query.expected_publication_revision))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let log_owner_user_id = owner_user_id.clone();
+    let log_expected_revision = query.expected_publication_revision;
+    let game = state
+        .spacetime_client()
+        .delete_game_distribution_game(GameDistributionDeleteGameRecordInput {
+            game_id: game_id.clone(),
+            owner_user_id,
+            expected_publication_revision: query.expected_publication_revision,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    let audit = build_game_delete_audit(
+        log_owner_user_id.as_str(),
+        game_id.as_str(),
+        game.0.title.as_str(),
+        log_expected_revision,
+    );
+    record_tracking_event_after_success(&state, &ctx, audit).await;
+    warn!(
+        request_id = ctx.request_id(),
+        operation = "game_deleted",
+        game_id = %game_id,
+        owner_user_id = %log_owner_user_id,
+        expected_publication_revision = log_expected_revision,
+        publication_revision = game.0.publication_revision,
+        replayed = game.1,
+        elapsed_ms = ctx.elapsed(),
+        "作者软删除游戏"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "game": game_payload(&game.0), "replayed": game.1 }),
+    ))
+}
+
 async fn create_game(
     State(state): State<AppState>,
     Extension(ctx): Extension<RequestContext>,
@@ -1117,10 +1464,7 @@ async fn create_game(
             device_support_touch: payload.device_support.touch,
             input_modes_json: serde_json::to_string(&payload.input_modes)
                 .map_err(|error| internal(error.to_string()))?,
-            orientation: serde_json::to_string(&payload.orientation)
-                .map_err(|error| internal(error.to_string()))?
-                .trim_matches('"')
-                .to_string(),
+            orientation: orientation_wire_value(payload.orientation)?,
             idempotency_key,
             request_digest,
             now_micros: now,
@@ -1158,6 +1502,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,
@@ -1996,9 +2341,26 @@ async fn admin_list_games(
         .limit
         .unwrap_or(MAX_ADMIN_GAME_LIST_LIMIT)
         .min(MAX_ADMIN_GAME_LIST_LIMIT);
-    let games = state
+    let status = normalize_optional(query.status);
+    if let Some(status) = status.as_deref() {
+        if !ADMIN_GAME_LIST_STATUSES.contains(&status) {
+            return Err(bad_request(
+                "后台作品状态过滤只支持 published / unpublished / suspended / deleted",
+            ));
+        }
+    }
+    let keyword = normalize_optional(query.keyword);
+    let owner_user_id = normalize_optional(query.owner);
+    let cursor = normalize_optional(query.cursor);
+    let (games, next_cursor) = state
         .spacetime_client()
-        .list_admin_game_distribution_games(GameDistributionAdminGameListRecordInput { limit })
+        .list_admin_game_distribution_games(GameDistributionAdminGameListRecordInput {
+            limit,
+            keyword: keyword.clone(),
+            owner_user_id: owner_user_id.clone(),
+            status: status.clone(),
+            cursor: cursor.clone(),
+        })
         .await
         .map_err(map_spacetime_error)?;
     info!(
@@ -2006,13 +2368,19 @@ async fn admin_list_games(
         operation = "admin_games_listed",
         games = games.len(),
         limit,
+        has_keyword = keyword.is_some(),
+        has_owner = owner_user_id.is_some(),
+        status = status.as_deref().unwrap_or(""),
+        has_cursor = cursor.is_some(),
+        has_more = next_cursor.is_some(),
         elapsed_ms = ctx.elapsed(),
-        "后台读取全量发行游戏"
+        "后台读取发行游戏列表"
     );
     Ok(json_success_body(
         Some(&ctx),
         json!({
             "games": games.iter().map(admin_game_payload).collect::<Vec<_>>(),
+            "nextCursor": next_cursor,
         }),
     ))
 }
@@ -2124,6 +2492,104 @@ 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
+        .get(header::COOKIE)
+        .and_then(|value| value.to_str().ok())
+        .and_then(|cookie_header| {
+            read_refresh_session_token(cookie_header, state.refresh_cookie_config())
+        })
+        .is_some()
+    {
+        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 / 预览环境
@@ -2302,6 +2768,14 @@ fn normalize_local_project_id(value: Option<&str>) -> Result<Option<String>, App
     Ok(Some(value.to_string()))
 }
 
+/// 方向枚举的线上取值：serde 序列化成带引号的 JSON 字符串，这里剥掉引号只留值。
+fn orientation_wire_value(orientation: GameDistributionOrientation) -> Result<String, AppError> {
+    Ok(serde_json::to_string(&orientation)
+        .map_err(|error| internal(error.to_string()))?
+        .trim_matches('"')
+        .to_string())
+}
+
 fn validate_game_metadata(payload: &GameDistributionCreateGameRequest) -> Result<(), AppError> {
     if payload.title.trim().is_empty() || payload.title.chars().count() > 40 {
         return Err(bad_request("游戏标题必须为 1 到 40 个字符"));
@@ -2446,6 +2920,7 @@ fn admin_game_payload(game: &GameDistributionAdminGameRecord) -> Value {
         "publicationRevision": game.publication_revision,
         "createdAt": game.created_at,
         "updatedAt": game.updated_at,
+        "deletedAt": game.deleted_at,
         "versions": game
             .versions
             .iter()
@@ -2509,6 +2984,37 @@ fn game_payload(game: &GameDistributionGameRecord) -> Value {
     })
 }
 
+/// 作者自有游戏条目：公开投影 + 全部版本的私有状态。
+///
+/// 公开目录与公开详情继续只用 `game_payload`，私有字段（包摘要、驳回理由、入口地址）
+/// 不会随公开投影下发。
+fn owner_game_entry_payload(entry: GameDistributionOwnerGameRecord) -> Value {
+    let versions = entry
+        .versions
+        .iter()
+        .map(private_version_payload)
+        .collect::<Vec<_>>();
+    let mut payload = game_payload(&entry.game);
+    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),
+    );
+    object.insert("versions".to_string(), Value::Array(versions));
+    payload
+}
+
 fn version_summary_payload(version: &GameDistributionVersionRecord) -> Value {
     json!({
         "id": version.version_id,
@@ -2527,9 +3033,11 @@ fn private_version_payload(version: &GameDistributionVersionRecord) -> Value {
         "versionNumber": version.version_number,
         "packageSha256": version.package_sha256,
         "packageBytes": version.package_bytes,
+        "packageFileCount": version.package_file_count,
         "status": version.status,
         "publicationRevision": version.publication_revision,
         "reviewReason": version.review_reason,
+        "entryUrl": version.entry_url,
         "createdAt": version.created_at,
         "updatedAt": version.updated_at,
     })
@@ -2777,10 +3285,22 @@ 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 }))
         }
+        // 软删除的作品对所有作者侧入口都按"不存在"处理，避免用错误码区分"已删除"与"不存在"。
+        SpacetimeClientError::Procedure(message) if message.contains("已被删除") => {
+            AppError::from_status(StatusCode::NOT_FOUND)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
         SpacetimeClientError::Procedure(message)
             if message.contains("不存在") || message.contains("已不存在") =>
         {
@@ -3037,9 +3557,7 @@ pub(crate) async fn suggest_publish_metadata(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use shared_contracts::game_distribution::{
-        GameDistributionDeviceSupport, GameDistributionOrientation,
-    };
+    use shared_contracts::game_distribution::GameDistributionDeviceSupport;
 
     #[tokio::test]
     async fn user_review_routes_validate_pagination_and_require_personal_auth() {
@@ -3626,6 +4144,7 @@ mod tests {
             play_count: 0,
             created_at: "2026-09-20T00:00:00Z".to_string(),
             updated_at: "2026-09-20T00:00:00Z".to_string(),
+            local_project_id: None,
             cover_object_key: Some("generated/game-cover.png".to_string()),
             screenshots_json: Some(
                 r#"[{"assetId":"asset_1","objectKey":"generated/shot-1.png"}]"#.to_string(),
@@ -3688,6 +4207,7 @@ mod tests {
             play_count: 0,
             created_at: "2026-09-20T00:00:00Z".to_string(),
             updated_at: "2026-09-20T00:00:00Z".to_string(),
+            local_project_id: None,
             cover_object_key: Some("generated/game-cover.png".to_string()),
             screenshots_json: None,
         };
@@ -3728,6 +4248,77 @@ mod tests {
         assert!(legacy_payload["version"]["frozenMetadata"].is_null());
     }
 
+    /// 作者管理页依赖这条边界：公开投影不带版本私有状态，作者条目必须带。
+    #[test]
+    fn owner_game_entry_payload_carries_private_versions_that_public_payload_omits() {
+        let game = GameDistributionGameRecord {
+            game_id: "game_1".to_string(),
+            owner_user_id: "user_1".to_string(),
+            title: "待审游戏".to_string(),
+            summary: "摘要".to_string(),
+            description: "描述".to_string(),
+            category: "益智".to_string(),
+            tags_json: "[]".to_string(),
+            cover_asset_id: Some("asset_cover".to_string()),
+            author_name: None,
+            author_avatar_url: None,
+            device_support_desktop: true,
+            device_support_mobile: false,
+            device_support_touch: false,
+            input_modes_json: "[]".to_string(),
+            orientation: "responsive".to_string(),
+            publication_revision: 1,
+            active_version_id: None,
+            visibility: "unpublished".to_string(),
+            play_count: 0,
+            created_at: "2026-09-20T00:00:00Z".to_string(),
+            updated_at: "2026-09-20T00:00:00Z".to_string(),
+            local_project_id: None,
+            cover_object_key: None,
+            screenshots_json: None,
+        };
+        let version = GameDistributionVersionRecord {
+            version_id: "version_1".to_string(),
+            game_id: "game_1".to_string(),
+            owner_user_id: "user_1".to_string(),
+            version_number: 1,
+            package_sha256: "b".repeat(64),
+            package_bytes: 4096,
+            package_file_count: 7,
+            package_entry_path: "index.html".to_string(),
+            status: "rejected".to_string(),
+            review_reason: Some("封面与游戏内容无关".to_string()),
+            entry_url: None,
+            publication_revision: 1,
+            created_at: "2026-09-20T00:00:00Z".to_string(),
+            updated_at: "2026-09-20T00:00:00Z".to_string(),
+            metadata_json: None,
+        };
+
+        let public = game_payload(&game);
+        assert!(public.get("versions").is_none());
+        assert!(public.get("latestVersion").is_none());
+
+        let entry = owner_game_entry_payload(GameDistributionOwnerGameRecord {
+            game,
+            versions: vec![version],
+        });
+        assert_eq!(entry["status"], Value::String("unpublished".to_string()));
+        assert_eq!(
+            entry["versions"][0]["status"],
+            Value::String("rejected".to_string())
+        );
+        assert_eq!(
+            entry["versions"][0]["reviewReason"],
+            Value::String("封面与游戏内容无关".to_string())
+        );
+        assert_eq!(entry["versions"][0]["packageFileCount"], 7);
+        assert_eq!(
+            entry["latestVersion"]["versionId"],
+            Value::String("version_1".to_string())
+        );
+    }
+
     #[test]
     fn package_validation_errors_are_unprocessable() {
         let error = map_package_error(ReleasePackageError::MissingEntry);
@@ -3851,6 +4442,7 @@ mod tests {
 
         // 发布写入必须要求登录态，未带 Bearer 时在进入业务前就被拒绝。
         let unauthenticated_create = app
+            .clone()
             .oneshot(
                 Request::builder()
                     .method("POST")
@@ -3862,6 +4454,54 @@ mod tests {
             .await
             .expect("路由响应");
         assert_eq!(unauthenticated_create.status(), StatusCode::UNAUTHORIZED);
+
+        // 作者作品详情是 owner 作用域路由，未带 Bearer 时同样在进入业务前被拒绝。
+        let unauthenticated_owner_game = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/my-games/game_1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(
+            unauthenticated_owner_game.status(),
+            StatusCode::UNAUTHORIZED
+        );
+
+        // 资料编辑与软删除挂在同一条 owner 作用域路径上，未登录必须在业务前被拒。
+        let unauthenticated_metadata_update = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("PATCH")
+                    .uri("/api/game-distribution/my-games/game_1")
+                    .header("content-type", "application/json")
+                    .header("idempotency-key", "metadata-key-1")
+                    .body(Body::from("{}"))
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(
+            unauthenticated_metadata_update.status(),
+            StatusCode::UNAUTHORIZED
+        );
+
+        let unauthenticated_delete = app
+            .oneshot(
+                Request::builder()
+                    .method("DELETE")
+                    .uri("/api/game-distribution/my-games/game_1?expectedPublicationRevision=0")
+                    .header("idempotency-key", "delete-key-1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unauthenticated_delete.status(), StatusCode::UNAUTHORIZED);
     }
 
     #[test]
@@ -4043,7 +4683,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()
@@ -4069,16 +4713,53 @@ mod tests {
         );
     }
 
+    #[test]
+    fn release_html_injects_opaque_storage_compatibility_before_game_code() {
+        let html = inject_release_storage_bootstrap(
+            b"<!doctype html><script>window.started = true;</script>".to_vec(),
+            "text/html; charset=utf-8",
+        );
+        let html = String::from_utf8(html).expect("injected html");
+        assert!(html.starts_with(RELEASE_STORAGE_BOOTSTRAP));
+        assert!(html.contains("window.started = true"));
+        assert_eq!(
+            inject_release_storage_bootstrap(vec![1, 2, 3], "image/png"),
+            vec![1, 2, 3]
+        );
+    }
+
+    #[test]
+    fn release_normalizes_legacy_root_asset_references() {
+        let source =
+            br#"<script>fetch('/assets/hero.png')</script><style>url(/ui/icon.svg)</style>"#;
+        let normalized =
+            normalize_release_asset_references(source.to_vec(), "text/javascript; charset=utf-8");
+        let normalized = String::from_utf8(normalized).expect("normalized source");
+        assert!(normalized.contains("fetch('assets/hero.png')"));
+        assert!(normalized.contains("url(ui/icon.svg)"));
+        assert_eq!(
+            normalize_release_asset_references(vec![1, 2, 3], "image/png"),
+            vec![1, 2, 3]
+        );
+    }
     #[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"
@@ -4188,6 +4869,125 @@ mod tests {
         assert_eq!(generic.category, "益智");
     }
 
+    #[test]
+    fn orientation_wire_value_matches_the_persisted_column_values() {
+        // 领域表里存的是不带引号的枚举值；漏掉 trim 会让资料编辑把 `"responsive"` 写进列，
+        // 公开投影的方向判断随即失配。
+        assert_eq!(
+            orientation_wire_value(GameDistributionOrientation::Responsive).unwrap(),
+            "responsive"
+        );
+        assert_eq!(
+            orientation_wire_value(GameDistributionOrientation::Landscape).unwrap(),
+            "landscape"
+        );
+    }
+
+    #[test]
+    fn metadata_update_request_reuses_create_validation_and_drops_local_project_id() {
+        let update = GameDistributionUpdateGameMetadataRequest {
+            expected_publication_revision: 4,
+            title: "新标题".to_string(),
+            summary: "新简介".to_string(),
+            description: Some("新描述".to_string()),
+            category: "模拟".to_string(),
+            tags: vec!["放置".to_string()],
+            cover_asset_id: Some("asset_cover".to_string()),
+            screenshots: vec!["asset_shot".to_string()],
+            device_support: GameDistributionDeviceSupport {
+                desktop: true,
+                mobile: true,
+                touch: true,
+            },
+            input_modes: vec![GameDistributionInputMode::Touch],
+            orientation: GameDistributionOrientation::Portrait,
+        };
+        let converted = game_metadata_update_as_create_request(&update);
+        // 编辑资料不参与"同一本地项目复用游戏身份"，必须与创建语义隔离。
+        assert_eq!(converted.local_project_id, None);
+        assert_eq!(converted.title, "新标题");
+        assert_eq!(converted.category, "模拟");
+        assert_eq!(converted.tags, vec!["放置".to_string()]);
+        assert_eq!(converted.cover_asset_id.as_deref(), Some("asset_cover"));
+        assert_eq!(converted.screenshots, vec!["asset_shot".to_string()]);
+        assert!(converted.device_support.touch);
+        assert_eq!(
+            converted.input_modes,
+            vec![GameDistributionInputMode::Touch]
+        );
+        assert_eq!(converted.orientation, GameDistributionOrientation::Portrait);
+        // 同一套校验：合法资料通过，缺封面仍然被拒。
+        validate_game_metadata(&converted).expect("合法资料应通过创建口径的校验");
+        let mut without_cover = converted;
+        without_cover.cover_asset_id = None;
+        assert_eq!(
+            validate_game_metadata(&without_cover)
+                .expect_err("缺少封面必须被拒")
+                .status_code(),
+            StatusCode::BAD_REQUEST
+        );
+    }
+
+    #[test]
+    fn admin_game_payload_exposes_soft_delete_marker() {
+        let record = GameDistributionAdminGameRecord {
+            game_id: "game_1".to_string(),
+            owner_user_id: "user_1".to_string(),
+            title: "已删除作品".to_string(),
+            author_name: Some("作者甲".to_string()),
+            author_avatar_url: None,
+            visibility: "unpublished".to_string(),
+            version_count: 2,
+            play_count: 7,
+            active_version_id: None,
+            publication_revision: 3,
+            created_at: "2026-09-18T08:00:00Z".to_string(),
+            updated_at: "2026-09-20T10:00:00Z".to_string(),
+            deleted_at: Some("2026-09-21T10:00:00Z".to_string()),
+            versions: Vec::new(),
+        };
+        let payload = admin_game_payload(&record);
+        assert_eq!(
+            payload["deletedAt"],
+            Value::String("2026-09-21T10:00:00Z".to_string())
+        );
+        assert_eq!(payload["gameId"], Value::String("game_1".to_string()));
+        assert_eq!(payload["status"], Value::String("unpublished".to_string()));
+
+        let alive = GameDistributionAdminGameRecord {
+            deleted_at: None,
+            ..record
+        };
+        assert_eq!(admin_game_payload(&alive)["deletedAt"], Value::Null);
+    }
+
+    #[test]
+    fn game_mutation_audits_carry_actor_target_and_revision() {
+        let metadata_audit =
+            build_game_metadata_update_audit("user_1", "game_1", "新标题", "模拟", 4);
+        assert_eq!(
+            metadata_audit.event_key,
+            "game_distribution_game_metadata_updated"
+        );
+        assert_eq!(
+            metadata_audit.scope_kind,
+            module_runtime::RuntimeTrackingScopeKind::User
+        );
+        assert_eq!(metadata_audit.scope_id, "user_1");
+        assert_eq!(metadata_audit.module_key, Some("game-distribution"));
+        assert_eq!(metadata_audit.metadata["gameId"], "game_1");
+        assert_eq!(metadata_audit.metadata["title"], "新标题");
+        assert_eq!(metadata_audit.metadata["category"], "模拟");
+        assert_eq!(metadata_audit.metadata["expectedPublicationRevision"], 4);
+
+        let delete_audit = build_game_delete_audit("user_1", "game_1", "已删除作品", 5);
+        assert_eq!(delete_audit.event_key, "game_distribution_game_deleted");
+        assert_eq!(delete_audit.scope_id, "user_1");
+        assert_eq!(delete_audit.metadata["gameId"], "game_1");
+        assert_eq!(delete_audit.metadata["title"], "已删除作品");
+        assert_eq!(delete_audit.metadata["expectedPublicationRevision"], 5);
+    }
+
     #[tokio::test]
     async fn game_play_route_is_public_and_no_store_without_spacetime_connection() {
         use axum::http::Request;
diff --git a/server-rs/crates/api-server/src/modules/game_distribution_release_storage_bootstrap.js b/server-rs/crates/api-server/src/modules/game_distribution_release_storage_bootstrap.js
new file mode 100644
index 000000000..31429a388
--- /dev/null
+++ b/server-rs/crates/api-server/src/modules/game_distribution_release_storage_bootstrap.js
@@ -0,0 +1,43 @@
+(function () {
+  function makeStorage() {
+    var values = Object.create(null);
+    return {
+      get length() {
+        return Object.keys(values).length;
+      },
+      key: function (index) {
+        return Object.keys(values)[index] || null;
+      },
+      getItem: function (key) {
+        key = String(key);
+        return Object.prototype.hasOwnProperty.call(values, key)
+          ? values[key]
+          : null;
+      },
+      setItem: function (key, value) {
+        values[String(key)] = String(value);
+      },
+      removeItem: function (key) {
+        delete values[String(key)];
+      },
+      clear: function () {
+        values = Object.create(null);
+      },
+    };
+  }
+
+  function install(name) {
+    try {
+      Object.defineProperty(window, name, {
+        configurable: true,
+        enumerable: true,
+        value: makeStorage(),
+      });
+    } catch (_) {
+      // opaque-origin native storage may reject property replacement; keep the sandbox intact.
+    }
+  }
+
+  install('localStorage');
+  install('sessionStorage');
+})();
diff --git a/server-rs/crates/api-server/src/state.rs b/server-rs/crates/api-server/src/state.rs
index e89cb4829..5de09dde0 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::{
@@ -137,6 +137,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>);
 
@@ -307,6 +313,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,
@@ -698,6 +706,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,
@@ -759,6 +768,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/module-game-distribution/src/application.rs b/server-rs/crates/module-game-distribution/src/application.rs
index 6b958a911..2b868bb2f 100644
--- a/server-rs/crates/module-game-distribution/src/application.rs
+++ b/server-rs/crates/module-game-distribution/src/application.rs
@@ -7,7 +7,7 @@ use crate::{
     commands::{CreateGameInput, CreateVersionInput, IdempotencyRequest, ReviewDecision},
     domain::{
         GameDistributionAction, GameSnapshot, GameVersionSnapshot, GameVersionStatus,
-        GameVisibility, normalize_id,
+        GameVisibility, normalize_id, resolve_version_number,
     },
     errors::{GameDistributionError, GameDistributionFieldError},
 };
@@ -146,14 +146,16 @@ impl GameDistributionService {
         if state.versions.contains_key(&version_id) {
             return Err(GameDistributionError::VersionAlreadyExists);
         }
-        let version_number = state
-            .versions
-            .values()
-            .filter(|version| version.game_id == game_id)
-            .map(|version| version.version_number)
-            .max()
-            .unwrap_or(0)
-            .saturating_add(1);
+        let version_number = resolve_version_number(
+            state
+                .versions
+                .values()
+                .filter(|version| version.game_id == game_id)
+                .map(|version| version.version_number)
+                .max()
+                .unwrap_or(0),
+            input.version_number,
+        )?;
         let snapshot = GameVersionSnapshot {
             version_id: version_id.clone(),
             game_id,
@@ -880,6 +882,7 @@ mod tests {
                 game_id: "game-1".to_string(),
                 owner_user_id: "owner-1".to_string(),
                 version_id: "version-1".to_string(),
+                version_number: None,
                 package_sha256: "a".repeat(64),
                 package_bytes: 42,
                 idempotency: idem("create-version-1", "version-1"),
@@ -1159,6 +1162,7 @@ mod tests {
                 game_id: "game-1".to_string(),
                 owner_user_id: "owner-1".to_string(),
                 version_id: "version-2".to_string(),
+                version_number: None,
                 package_sha256: "b".repeat(64),
                 package_bytes: 7,
                 idempotency: idem("create-version-2", "version-2"),
@@ -1270,4 +1274,61 @@ mod tests {
         assert_eq!(snapshot.status, GameVersionStatus::Uploaded);
         assert_eq!(repeated.snapshot, snapshot);
     }
+
+    #[test]
+    fn explicit_version_number_accepts_repeats_and_reverts_of_the_same_label() {
+        assert_eq!(resolve_version_number(0, Some(1)).expect("首版显式 1"), 1);
+        // 重复标签：线上已有 3 也要能再提交一次 3，并生成新的版本记录。
+        assert_eq!(resolve_version_number(3, Some(3)).expect("重复标签"), 3);
+        // 回退：线上最大 5，也允许提交 2。
+        assert_eq!(resolve_version_number(5, Some(2)).expect("回退标签"), 2);
+        assert_eq!(
+            resolve_version_number(0, None).expect("旧客户端自动递增"),
+            1
+        );
+        assert_eq!(
+            resolve_version_number(7, None).expect("旧客户端按最大值递增"),
+            8
+        );
+    }
+
+    #[test]
+    fn version_number_must_be_positive_and_auto_increment_fails_closed() {
+        assert_eq!(
+            resolve_version_number(0, Some(0)).expect_err("0 不是合法标签"),
+            GameDistributionFieldError::InvalidVersionNumber
+        );
+        assert_eq!(
+            resolve_version_number(u64::MAX, None).expect_err("自动递增溢出必须失败关闭"),
+            GameDistributionFieldError::VersionNumberExhausted
+        );
+    }
+
+    #[test]
+    fn repeating_the_same_label_creates_a_new_version_record() {
+        let service = service();
+        let first = create_version(&service);
+        assert_eq!(first.version_number, 1);
+
+        // 同一个版本标签再提交一次：旧的已公开实例不原地修改，而是新增一条版本记录。
+        let repeated = service
+            .create_version(CreateVersionInput {
+                game_id: "game-1".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                version_id: "version-1-again".to_string(),
+                version_number: Some(first.version_number),
+                package_sha256: "b".repeat(64),
+                package_bytes: 9,
+                idempotency: idem("create-version-again", "version-again"),
+                created_at_micros: 12,
+            })
+            .expect("同一个版本标签可以重复提交")
+            .snapshot;
+        assert_eq!(repeated.version_number, first.version_number);
+        assert_ne!(repeated.version_id, first.version_id);
+        assert_eq!(
+            service.get_version(&first.version_id).expect("旧版本仍在"),
+            first
+        );
+    }
 }
diff --git a/server-rs/crates/module-game-distribution/src/commands.rs b/server-rs/crates/module-game-distribution/src/commands.rs
index 0cd47fb43..b9460264b 100644
--- a/server-rs/crates/module-game-distribution/src/commands.rs
+++ b/server-rs/crates/module-game-distribution/src/commands.rs
@@ -34,6 +34,10 @@ pub struct CreateVersionInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    /// 用户可见的正整数版本标签；`None` 时按该游戏已有最大版本号 +1（旧客户端兼容）。
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一标签可以反复提交，每次都是一条新版本记录。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version_number: Option<u64>,
     pub package_sha256: String,
     pub package_bytes: u64,
     pub idempotency: IdempotencyRequest,
diff --git a/server-rs/crates/module-game-distribution/src/domain.rs b/server-rs/crates/module-game-distribution/src/domain.rs
index 4607a2013..e8d625a1d 100644
--- a/server-rs/crates/module-game-distribution/src/domain.rs
+++ b/server-rs/crates/module-game-distribution/src/domain.rs
@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 
+use crate::errors::GameDistributionFieldError;
 use shared_kernel::{build_prefixed_seed_id, normalize_required_string};
 
 pub const GAME_ID_PREFIX: &str = "game_";
@@ -17,6 +18,25 @@ pub fn generate_game_version_id(seed_micros: i64, version_number: u64) -> String
     )
 }
 
+/// 解析本次创建的版本号（用户可见的版本标签，不是不可变的 `version_id`）。
+///
+/// - `None`：旧客户端兼容路径，取该游戏已有最大版本号 +1；溢出时失败关闭，不回绕成 0。
+/// - `Some(requested)`：只要求正整数。同一个 gameId 的同一个版本号可以反复提交——每次提交都是
+///   一条新的版本记录（新的 `version_id`），旧公开实例不原地修改——所以**不与已有最大值比较**，
+///   允许重复标签，也允许回退到更小的标签。
+pub fn resolve_version_number(
+    max_existing: u64,
+    requested: Option<u64>,
+) -> Result<u64, GameDistributionFieldError> {
+    match requested {
+        Some(0) => Err(GameDistributionFieldError::InvalidVersionNumber),
+        Some(requested) => Ok(requested),
+        None => max_existing
+            .checked_add(1)
+            .ok_or(GameDistributionFieldError::VersionNumberExhausted),
+    }
+}
+
 /// Computes the lowercase SHA-256 digest used by the idempotency contract.
 pub fn compute_request_digest(payload: impl AsRef<[u8]>) -> String {
     let digest = Sha256::digest(payload.as_ref());
diff --git a/server-rs/crates/module-game-distribution/src/errors.rs b/server-rs/crates/module-game-distribution/src/errors.rs
index e3cb17a65..2228183c3 100644
--- a/server-rs/crates/module-game-distribution/src/errors.rs
+++ b/server-rs/crates/module-game-distribution/src/errors.rs
@@ -13,6 +13,8 @@ pub enum GameDistributionFieldError {
     InvalidPackageDigest,
     InvalidPackageBytes,
     MissingReviewReason,
+    InvalidVersionNumber,
+    VersionNumberExhausted,
 }
 
 impl fmt::Display for GameDistributionFieldError {
@@ -27,6 +29,8 @@ impl fmt::Display for GameDistributionFieldError {
             Self::InvalidPackageDigest => "packageSha256 必须是 64 位十六进制摘要",
             Self::InvalidPackageBytes => "packageBytes 必须大于 0",
             Self::MissingReviewReason => "拒绝审核必须提供理由",
+            Self::InvalidVersionNumber => "版本号必须是大于 0 的整数",
+            Self::VersionNumberExhausted => "版本号已达上限，无法自动递增",
         };
         formatter.write_str(message)
     }
diff --git a/server-rs/crates/module-game-distribution/src/lib.rs b/server-rs/crates/module-game-distribution/src/lib.rs
index 2fb820d17..0da10868a 100644
--- a/server-rs/crates/module-game-distribution/src/lib.rs
+++ b/server-rs/crates/module-game-distribution/src/lib.rs
@@ -21,7 +21,7 @@ pub use application::{
 pub use commands::{CreateGameInput, CreateVersionInput, IdempotencyRequest, ReviewDecision};
 pub use domain::{
     GameDistributionAction, GameSnapshot, GameVersionSnapshot, GameVersionStatus, GameVisibility,
-    compute_request_digest, generate_game_id, generate_game_version_id,
+    compute_request_digest, generate_game_id, generate_game_version_id, resolve_version_number,
 };
 pub use errors::{GameDistributionError, GameDistributionFieldError};
 pub use events::GameDistributionEvent;
diff --git a/server-rs/crates/module-runtime/src/application.rs b/server-rs/crates/module-runtime/src/application.rs
index 8e7bd07c8..a644d5166 100644
--- a/server-rs/crates/module-runtime/src/application.rs
+++ b/server-rs/crates/module-runtime/src/application.rs
@@ -84,7 +84,7 @@ pub fn creation_entry_feature_gate_key(creation_type_id: &str) -> String {
 
 pub const IMAGE_EDITOR_AGENT_SIDEBAR_GATE_KEY: &str = "image-editor:agent-sidebar";
 pub const AGC_TEMPLATE_LIBRARY_GATE_KEY: &str = "agc:template-library";
-/// 游戏分发发布开关：`gate 行缺失`或 `enabled=false` 都表示**未开放**（灰度默认关闭）；
+/// 游戏分发发布开关：gate 行缺失或 `enabled=false` 都表示**未开放**；
 /// 只有 `enabled=true` 且白名单 / 灰度比例 / 用户标签命中时才允许发布。
 pub const GAME_DISTRIBUTION_PUBLISH_GATE_KEY: &str = "game-distribution:publish";
 
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..a04fd71e0 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,15 @@ pub struct GameCreationAppManifest {
     pub godot_project_root: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cocos_project_root: Option<String>,
+    /// 遗留位：历史清单写过的用户发行版本标签，仅为兼容旧清单可解析而保留。
+    ///
+    /// 它**不再**是发行版本来源：发布面板的「项目版本」由 AGC 工程内部版本记录 `versions[]`
+    /// 派生（标签 = 存活内部版本条数），原生不再写入或回填这个字段。字段本身不能删除：
+    /// 本结构体带 `deny_unknown_fields`，删掉它会让所有含该键的存量清单解析失败。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project_version: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publication: Option<GameCreationAppPublicationBinding>,
 }
 
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
@@ -1224,6 +1250,8 @@ pub fn new_game_creation_app_manifest(
         command_runs: Vec::new(),
         versions: Vec::new(),
         godot_project_root: None,
+        project_version: None,
+        publication: None,
         cocos_project_root: None,
     }
 }
@@ -2162,6 +2190,50 @@ mod tests {
         assert_eq!(payload["godotProjectRoot"], json!("game-source"));
     }
 
+    /// `projectVersion` 降级为遗留兼容位：存量清单里带这个键时必须照旧可读、可往返
+    /// （本结构体带 `deny_unknown_fields`，拒掉它等于让老项目打不开），但它不再是发行版本
+    /// 来源——Rust 侧不再有任何解析或回填入口，发布面板的「项目版本」改由工程内部版本
+    /// `versions[]` 派生。
+    #[test]
+    fn manifest_project_version_is_a_legacy_compatibility_field() {
+        let manifest = new_game_creation_app_manifest("project-1", "像素动作原型");
+        let payload = serde_json::to_value(&manifest).expect("manifest should serialize");
+        assert!(
+            payload.get("projectVersion").is_none(),
+            "原生不再写入版本标签，新清单不带这个键"
+        );
+
+        let mut legacy = payload.clone();
+        legacy["projectVersion"] = json!(6);
+        let parsed: GameCreationAppManifest =
+            serde_json::from_value(legacy).expect("含遗留 projectVersion 的存量清单必须仍可解析");
+        assert_eq!(parsed.project_version, Some(6));
+        assert!(
+            parsed.publication.is_none(),
+            "遗留键与发布绑定互相独立，不会凭它推导任何东西"
+        );
+
+        let mut published = parsed.clone();
+        published.publication = Some(GameCreationAppPublicationBinding {
+            account_id: "user-1".to_string(),
+            api_base_url: "https://dev.test".to_string(),
+            game_id: "game-1".to_string(),
+            revision: 3,
+            latest_version_id: Some("gamever-1".to_string()),
+            latest_version_number: Some(4),
+            status: Some("pending_review".to_string()),
+        });
+        let payload = serde_json::to_value(&published).expect("published manifest serializes");
+        assert_eq!(payload["projectVersion"], json!(6));
+        assert_eq!(payload["publication"]["latestVersionNumber"], json!(4));
+        assert_eq!(
+            serde_json::from_value::<GameCreationAppManifest>(payload)
+                .expect("legacy project version must round-trip")
+                .project_version,
+            Some(6)
+        );
+    }
+
     /// 未知顶层字段必须失败关闭。这条契约级断言钉住的是本结构体本身的取向，而不是某个调用方：
     /// AGC 客户端读写 manifest 的方式是「整结构体反序列化 + 整结构体重新序列化覆盖落盘」，
     /// 一旦放行未知顶层字段，「读一次 + 任意一次写」就会静默抹掉未来版本新增的字段。
diff --git a/server-rs/crates/shared-contracts/src/game_distribution.rs b/server-rs/crates/shared-contracts/src/game_distribution.rs
index 8142c5761..bfcad0083 100644
--- a/server-rs/crates/shared-contracts/src/game_distribution.rs
+++ b/server-rs/crates/shared-contracts/src/game_distribution.rs
@@ -14,6 +14,14 @@ pub const GAME_DISTRIBUTION_CATEGORIES: [&str; 7] =
 /// 客户端要么放行服务端必拒的包（白等一次上传），要么拦掉服务端能收的包。
 pub const GAME_DISTRIBUTION_MAX_PACKAGE_BYTES: u64 = 200 * 1024 * 1024;
 
+/// 版本号无法分配时的统一错误前缀（只在自动递增溢出时使用）。
+///
+/// 旧的「必须严格大于当前最大版本号」限制已经取消：同一 gameId 的同一个版本号可以反复提交，
+/// 每次生成新的 versionId，也允许回退到更小的标签。显式版本号只要求 `>= 1`，`0` 这类非法值
+/// 走普通 400；只有旧客户端缺省时按最大版本号自动递增、撞上 `u64::MAX` 才会带上此前缀，
+/// api-server 据此映射成 HTTP 409。
+pub const GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT: &str = "VERSION_NUMBER_CONFLICT";
+
 /// 发布页免费生成简介与分类的输入。
 ///
 /// 只传经过裁剪的项目摘要，不传本地绝对路径、聊天记录、凭据或完整 manifest。
@@ -224,6 +232,14 @@ pub struct GameDistributionCreateGameRequest {
 pub struct GameDistributionCreateVersionRequest {
     #[serde(default)]
     pub local_project_id: Option<String>,
+    /// 用户可见的正整数版本标签（AGC 发布面板由工程内部版本序数派生后原样提交）。
+    ///
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一个版本号可以反复提交，每次提交生成新的
+    /// versionId，允许重复标签与回退到更小的版本号，不与已有最大值比较。缺省时保留旧客户端
+    /// 兼容行为：服务端按该游戏已有最大版本号 +1（此时溢出才会返回 409）。
+    /// 缺省时序列化省略该字段，保证旧客户端请求的幂等摘要与升级前一致。
+    #[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,
@@ -231,6 +247,31 @@ pub struct GameDistributionCreateVersionRequest {
     pub game_metadata: GameDistributionCreateGameRequest,
 }
 
+/// 作者编辑游戏级展示资料的请求体。
+///
+/// 只覆盖游戏行上的展示字段，随版本冻结的包摘要与资料快照不受影响；
+/// `expected_publication_revision` 是公开切换 CAS，并发变化返回 409。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionUpdateGameMetadataRequest {
+    pub expected_publication_revision: u64,
+    pub title: String,
+    pub summary: String,
+    #[serde(default)]
+    pub description: Option<String>,
+    pub category: String,
+    #[serde(default)]
+    pub tags: Vec<String>,
+    #[serde(default)]
+    pub cover_asset_id: Option<String>,
+    /// 截图素材 ID（最多 6 张，复用平台图片上传与归属校验）。
+    #[serde(default)]
+    pub screenshots: Vec<String>,
+    pub device_support: GameDistributionDeviceSupport,
+    pub input_modes: Vec<GameDistributionInputMode>,
+    pub orientation: GameDistributionOrientation,
+}
+
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GameDistributionPrivateVersion {
@@ -239,11 +280,14 @@ pub struct GameDistributionPrivateVersion {
     pub version_number: u64,
     pub package_sha256: String,
     pub package_bytes: u64,
+    pub package_file_count: u32,
     pub status: GameDistributionVersionStatus,
     /// 这一版所属游戏的公开切换版本号（撤回与审核回传用）。
     pub publication_revision: u64,
     #[serde(default)]
     pub review_reason: Option<String>,
+    #[serde(default)]
+    pub entry_url: Option<String>,
     pub created_at: String,
     pub updated_at: String,
 }
@@ -334,4 +378,68 @@ mod tests {
             .expect("版本请求应可解析");
         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 =
+            serde_json::from_value(serde_json::json!({
+                "expectedPublicationRevision": 3,
+                "title": "游戏",
+                "summary": "简介",
+                "category": "益智",
+                "coverAssetId": "asset-cover",
+                "screenshots": ["asset-shot"],
+                "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                "inputModes": ["keyboard"],
+                "orientation": "responsive",
+            }))
+            .expect("资料编辑请求应可解析");
+        assert_eq!(payload.expected_publication_revision, 3);
+        assert_eq!(payload.cover_asset_id.as_deref(), Some("asset-cover"));
+        let serialized = serde_json::to_value(&payload).expect("资料编辑请求应可序列化");
+        assert_eq!(serialized["expectedPublicationRevision"], 3);
+        assert_eq!(serialized["coverAssetId"], "asset-cover");
+    }
 }
diff --git a/server-rs/crates/spacetime-client/src/active.rs b/server-rs/crates/spacetime-client/src/active.rs
index db4068181..4f387f1c6 100644
--- a/server-rs/crates/spacetime-client/src/active.rs
+++ b/server-rs/crates/spacetime-client/src/active.rs
@@ -25,13 +25,14 @@ pub use game_distribution::{
     GameDistributionAdminGameListRecordInput, GameDistributionAdminUserReviewListRecordInput,
     GameDistributionApproveRecordInput, GameDistributionCancelVersionRecordInput,
     GameDistributionConfirmPackageRecordInput, GameDistributionCreateGameRecordInput,
-    GameDistributionCreateVersionRecordInput, GameDistributionFailUploadRecordInput,
-    GameDistributionGetGameRecordInput, GameDistributionOwnerGameListRecordInput,
-    GameDistributionPlayCountIncrementRecordInput, GameDistributionPublicGameListRecordInput,
-    GameDistributionRejectRecordInput, GameDistributionRestoreRecordInput,
-    GameDistributionReviewGameListRecordInput, GameDistributionReviewModerationRecordInput,
-    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
-    GameDistributionUnpublishRecordInput,
+    GameDistributionCreateVersionRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionFailUploadRecordInput, GameDistributionGetGameRecordInput,
+    GameDistributionOwnerGameListRecordInput, GameDistributionPlayCountIncrementRecordInput,
+    GameDistributionPublicGameListRecordInput, GameDistributionRejectRecordInput,
+    GameDistributionRestoreRecordInput, GameDistributionReviewGameListRecordInput,
+    GameDistributionReviewModerationRecordInput, GameDistributionSubmitReviewRecordInput,
+    GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionUpdateMetadataRecordInput,
 };
 #[path = "active/external_generation.rs"]
 pub mod external_generation;
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 176783bc4..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>,
 }
 
@@ -232,6 +233,8 @@ pub struct GameDistributionAdminGameRecord {
     pub created_at: String,
     pub updated_at: String,
     pub versions: Vec<GameDistributionAdminVersionRecord>,
+    /// 软删除时间；为空表示未删除。
+    pub deleted_at: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -272,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,
     }
@@ -338,16 +342,22 @@ fn map_admin_game(
         created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
         updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
         versions: value.versions.into_iter().map(map_admin_version).collect(),
+        deleted_at: value
+            .deleted_at_micros
+            .map(shared_kernel::format_timestamp_micros),
     }
 }
 
 pub(crate) fn map_game_distribution_admin_game_list_result(
     result: crate::module_bindings::GameDistributionAdminGameListResult,
-) -> Result<Vec<GameDistributionAdminGameRecord>, SpacetimeClientError> {
+) -> Result<(Vec<GameDistributionAdminGameRecord>, Option<String>), SpacetimeClientError> {
     if !result.ok {
         return Err(SpacetimeClientError::procedure_failed(result.error_message));
     }
-    Ok(result.games.into_iter().map(map_admin_game).collect())
+    Ok((
+        result.games.into_iter().map(map_admin_game).collect(),
+        result.next_cursor,
+    ))
 }
 
 pub(crate) fn map_game_distribution_game_result(
diff --git a/server-rs/crates/spacetime-client/src/game_distribution.rs b/server-rs/crates/spacetime-client/src/game_distribution.rs
index 7e293a8f1..bdea2bc5f 100644
--- a/server-rs/crates/spacetime-client/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/game_distribution.rs
@@ -37,6 +37,14 @@ pub struct GameDistributionPublicGameListRecordInput {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct GameDistributionAdminGameListRecordInput {
     pub limit: u32,
+    /// 关键词：匹配标题、gameId 或作者 user ID。
+    pub keyword: Option<String>,
+    /// 只返回该作者名下的游戏。
+    pub owner_user_id: Option<String>,
+    /// `published` / `unpublished` / `suspended` / `deleted`；为空时排除已软删除游戏。
+    pub status: Option<String>,
+    /// 上一页返回的游标。
+    pub cursor: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -87,6 +95,9 @@ pub struct GameDistributionCreateVersionRecordInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    /// 用户可见的正整数版本标签；`None` 时由服务端按已有最大版本号自动 +1（旧客户端兼容）。
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一标签可以反复提交，每次生成新的 version_id。
+    pub version_number: Option<u64>,
     /// api-server 校验并解析素材后生成的资料快照 JSON。
     pub metadata_json: String,
     pub package_sha256: String,
@@ -198,6 +209,41 @@ pub struct GameDistributionSuspendRecordInput {
     pub now_micros: i64,
 }
 
+/// 作者编辑游戏级展示资料；对象键由 api-server 从素材记录派生后传入。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionUpdateMetadataRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub cover_object_key: Option<String>,
+    pub screenshots_json: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 作者软删除游戏；只标记删除时间并下线公开投影。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionDeleteGameRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
 impl SpacetimeClient {
     pub async fn list_admin_game_distribution_user_reviews(
         &self,
@@ -664,6 +710,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,
@@ -1035,13 +1082,18 @@ impl SpacetimeClient {
         .await
     }
 
-    /// 后台游戏管理页的全量游戏列表：含版本数与最近版本历史，作者名/头像由事务内读时联。
+    /// 后台游戏管理页列表：关键词/作者/状态过滤 + 游标分页，作者名/头像由事务内读时联。
     pub async fn list_admin_game_distribution_games(
         &self,
         input: GameDistributionAdminGameListRecordInput,
-    ) -> Result<Vec<GameDistributionAdminGameRecord>, SpacetimeClientError> {
-        let procedure_input =
-            crate::module_bindings::GameDistributionAdminGameListInput { limit: input.limit };
+    ) -> Result<(Vec<GameDistributionAdminGameRecord>, Option<String>), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionAdminGameListInput {
+            limit: input.limit,
+            keyword: input.keyword,
+            owner_user_id: input.owner_user_id,
+            status: input.status,
+            cursor: input.cursor,
+        };
         self.call_after_connect(
             "list_admin_game_distribution_games",
             move |connection, sender| {
@@ -1061,6 +1113,93 @@ impl SpacetimeClient {
         .await
     }
 
+    /// 作者编辑游戏级展示资料；版本包与冻结资料不受影响。
+    pub async fn update_game_distribution_game_metadata(
+        &self,
+        input: GameDistributionUpdateMetadataRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionUpdateMetadataInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            title: input.title,
+            summary: input.summary,
+            description: input.description,
+            category: input.category,
+            tags_json: input.tags_json,
+            cover_asset_id: input.cover_asset_id,
+            cover_object_key: input.cover_object_key,
+            screenshots_json: input.screenshots_json,
+            device_support_desktop: input.device_support_desktop,
+            device_support_mobile: input.device_support_mobile,
+            device_support_touch: input.device_support_touch,
+            input_modes_json: input.input_modes_json,
+            orientation: input.orientation,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "update_game_distribution_game_metadata",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .update_game_distribution_game_metadata_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(game, _, replayed)| {
+                                    game.map(|game| (game, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏资料更新结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 作者软删除游戏；只下线公开投影，版本行与冻结资料保留。
+    pub async fn delete_game_distribution_game(
+        &self,
+        input: GameDistributionDeleteGameRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionDeleteGameInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "delete_game_distribution_game",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .delete_game_distribution_game_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(game, _, replayed)| {
+                                    game.map(|game| (game, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏删除结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
     /// 管理员解除安全下架：重新激活最近一次曾公开的版本。
     pub async fn restore_game_distribution_game(
         &self,
diff --git a/server-rs/crates/spacetime-client/src/module_bindings.rs b/server-rs/crates/spacetime-client/src/module_bindings.rs
index aa38eeb65..ffce9b440 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings.rs
@@ -200,6 +200,7 @@ pub mod delete_editor_asset_and_return_procedure;
 pub mod delete_editor_asset_folder_and_return_procedure;
 pub mod delete_editor_project_and_return_procedure;
 pub mod delete_error_report_and_return_procedure;
+pub mod delete_game_distribution_game_and_return_procedure;
 pub mod editor_agent_conversation_create_input_type;
 pub mod editor_agent_conversation_delete_input_type;
 pub mod editor_agent_conversation_get_input_type;
@@ -419,6 +420,7 @@ pub mod game_distribution_cancel_version_input_type;
 pub mod game_distribution_confirm_package_input_type;
 pub mod game_distribution_create_game_input_type;
 pub mod game_distribution_create_version_input_type;
+pub mod game_distribution_delete_game_input_type;
 pub mod game_distribution_fail_upload_input_type;
 pub mod game_distribution_game_list_procedure_result_type;
 pub mod game_distribution_game_procedure_result_type;
@@ -453,6 +455,7 @@ pub mod game_distribution_review_type;
 pub mod game_distribution_submit_review_input_type;
 pub mod game_distribution_suspend_input_type;
 pub mod game_distribution_unpublish_input_type;
+pub mod game_distribution_update_metadata_input_type;
 pub mod game_distribution_user_review_input_type;
 pub mod game_distribution_user_review_list_input_type;
 pub mod game_distribution_user_review_result_type;
@@ -850,6 +853,7 @@ pub mod update_editor_project_resource_showcase_and_return_procedure;
 pub mod update_editor_showcase_asset_display_and_return_procedure;
 pub mod update_error_report_and_return_procedure;
 pub mod update_external_generation_job_phase_and_return_procedure;
+pub mod update_game_distribution_game_metadata_and_return_procedure;
 pub mod update_payment_app_and_return_procedure;
 pub mod upload_agc_analytics_batch_procedure;
 pub mod upsert_editor_generation_pricing_config_and_return_procedure;
@@ -1057,6 +1061,7 @@ pub use delete_editor_asset_and_return_procedure::delete_editor_asset_and_return
 pub use delete_editor_asset_folder_and_return_procedure::delete_editor_asset_folder_and_return;
 pub use delete_editor_project_and_return_procedure::delete_editor_project_and_return;
 pub use delete_error_report_and_return_procedure::delete_error_report_and_return;
+pub use delete_game_distribution_game_and_return_procedure::delete_game_distribution_game_and_return;
 pub use editor_agent_conversation_create_input_type::EditorAgentConversationCreateInput;
 pub use editor_agent_conversation_delete_input_type::EditorAgentConversationDeleteInput;
 pub use editor_agent_conversation_get_input_type::EditorAgentConversationGetInput;
@@ -1276,6 +1281,7 @@ pub use game_distribution_cancel_version_input_type::GameDistributionCancelVersi
 pub use game_distribution_confirm_package_input_type::GameDistributionConfirmPackageInput;
 pub use game_distribution_create_game_input_type::GameDistributionCreateGameInput;
 pub use game_distribution_create_version_input_type::GameDistributionCreateVersionInput;
+pub use game_distribution_delete_game_input_type::GameDistributionDeleteGameInput;
 pub use game_distribution_fail_upload_input_type::GameDistributionFailUploadInput;
 pub use game_distribution_game_list_procedure_result_type::GameDistributionGameListProcedureResult;
 pub use game_distribution_game_procedure_result_type::GameDistributionGameProcedureResult;
@@ -1310,6 +1316,7 @@ pub use game_distribution_review_type::GameDistributionReview;
 pub use game_distribution_submit_review_input_type::GameDistributionSubmitReviewInput;
 pub use game_distribution_suspend_input_type::GameDistributionSuspendInput;
 pub use game_distribution_unpublish_input_type::GameDistributionUnpublishInput;
+pub use game_distribution_update_metadata_input_type::GameDistributionUpdateMetadataInput;
 pub use game_distribution_user_review_input_type::GameDistributionUserReviewInput;
 pub use game_distribution_user_review_list_input_type::GameDistributionUserReviewListInput;
 pub use game_distribution_user_review_result_type::GameDistributionUserReviewResult;
@@ -1707,6 +1714,7 @@ pub use update_editor_project_resource_showcase_and_return_procedure::update_edi
 pub use update_editor_showcase_asset_display_and_return_procedure::update_editor_showcase_asset_display_and_return;
 pub use update_error_report_and_return_procedure::update_error_report_and_return;
 pub use update_external_generation_job_phase_and_return_procedure::update_external_generation_job_phase_and_return;
+pub use update_game_distribution_game_metadata_and_return_procedure::update_game_distribution_game_metadata_and_return;
 pub use update_payment_app_and_return_procedure::update_payment_app_and_return;
 pub use upload_agc_analytics_batch_procedure::upload_agc_analytics_batch;
 pub use upsert_editor_generation_pricing_config_and_return_procedure::upsert_editor_generation_pricing_config_and_return;
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs
index 7a42c9ec4..d7df41fea 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait approve_game_distribution_version_and_return {
         input: GameDistributionApproveInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl approve_game_distribution_version_and_return for super::RemoteProcedures {
         input: GameDistributionApproveInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs
index 0f4e6f6d5..5ca2a63c0 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait cancel_game_distribution_version_and_return {
         input: GameDistributionCancelVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl cancel_game_distribution_version_and_return for super::RemoteProcedures {
         input: GameDistributionCancelVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs
index c6e881e84..5d32408ad 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait confirm_game_distribution_package_and_return {
         input: GameDistributionConfirmPackageInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl confirm_game_distribution_package_and_return for super::RemoteProcedures {
         input: GameDistributionConfirmPackageInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs
index 945777c57..46ab463fe 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait create_game_distribution_game_and_return {
         input: GameDistributionCreateGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl create_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionCreateGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs
index ccb8a9cc8..5a9005c87 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait create_game_distribution_version_and_return {
         input: GameDistributionCreateVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl create_game_distribution_version_and_return for super::RemoteProcedures {
         input: GameDistributionCreateVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/delete_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/delete_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..921ab77df
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/delete_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_delete_game_input_type::GameDistributionDeleteGameInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct DeleteGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionDeleteGameInput,
+}
+
+impl __sdk::InModule for DeleteGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `delete_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait delete_game_distribution_game_and_return {
+    fn delete_game_distribution_game_and_return(&self, input: GameDistributionDeleteGameInput) {
+        self.delete_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn delete_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionDeleteGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl delete_game_distribution_game_and_return for super::RemoteProcedures {
+    fn delete_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionDeleteGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "delete_game_distribution_game_and_return",
+                DeleteGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs
index 65235c650..783b523f7 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait fail_game_distribution_upload_and_return {
         input: GameDistributionFailUploadInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl fail_game_distribution_upload_and_return for super::RemoteProcedures {
         input: GameDistributionFailUploadInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_input_type.rs
index bcd5d17d6..8acb3e910 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_input_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_input_type.rs
@@ -8,6 +8,10 @@ use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
 #[sats(crate = __lib)]
 pub struct GameDistributionAdminGameListInput {
     pub limit: u32,
+    pub keyword: Option<String>,
+    pub owner_user_id: Option<String>,
+    pub status: Option<String>,
+    pub cursor: Option<String>,
 }
 
 impl __sdk::InModule for GameDistributionAdminGameListInput {
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_result_type.rs
index 0db38de34..e09073c9b 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_result_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_list_result_type.rs
@@ -12,6 +12,7 @@ pub struct GameDistributionAdminGameListResult {
     pub ok: bool,
     pub games: Vec<GameDistributionAdminGameSnapshot>,
     pub error_message: Option<String>,
+    pub next_cursor: Option<String>,
 }
 
 impl __sdk::InModule for GameDistributionAdminGameListResult {
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
index 8d79a32a3..71e653c96 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
@@ -22,6 +22,7 @@ pub struct GameDistributionAdminGameSnapshot {
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
     pub versions: Vec<GameDistributionAdminVersionSnapshot>,
+    pub deleted_at_micros: Option<i64>,
 }
 
 impl __sdk::InModule for GameDistributionAdminGameSnapshot {
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_delete_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_delete_game_input_type.rs
new file mode 100644
index 000000000..3b0d865c1
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_delete_game_input_type.rs
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionDeleteGameInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionDeleteGameInput {
+    type Module = super::RemoteModule;
+}
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-client/src/module_bindings/game_distribution_game_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs
index 7236ad64b..88a99c964 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs
@@ -31,6 +31,7 @@ pub struct GameDistributionGame {
     pub local_project_id: Option<String>,
     pub cover_object_key: Option<String>,
     pub screenshots_json: Option<String>,
+    pub deleted_at: Option<__sdk::Timestamp>,
 }
 
 impl __sdk::InModule for GameDistributionGame {
@@ -65,6 +66,7 @@ pub struct GameDistributionGameCols {
     pub local_project_id: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
     pub cover_object_key: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
     pub screenshots_json: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+    pub deleted_at: __sdk::__query_builder::Col<GameDistributionGame, Option<__sdk::Timestamp>>,
 }
 
 impl __sdk::__query_builder::HasCols for GameDistributionGame {
@@ -107,6 +109,7 @@ impl __sdk::__query_builder::HasCols for GameDistributionGame {
             local_project_id: __sdk::__query_builder::Col::new(table_name, "local_project_id"),
             cover_object_key: __sdk::__query_builder::Col::new(table_name, "cover_object_key"),
             screenshots_json: __sdk::__query_builder::Col::new(table_name, "screenshots_json"),
+            deleted_at: __sdk::__query_builder::Col::new(table_name, "deleted_at"),
         }
     }
 }
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_metadata_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_metadata_input_type.rs
new file mode 100644
index 000000000..a99c2c59c
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_metadata_input_type.rs
@@ -0,0 +1,33 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionUpdateMetadataInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub cover_object_key: Option<String>,
+    pub screenshots_json: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionUpdateMetadataInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs
index 823d4f2e3..c2d54efa4 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_game_distribution_game_and_return {
         input: GameDistributionGetGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionGetGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs
index 41de8b95f..1a92a268a 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_game_distribution_version_and_return {
         input: GameDistributionVersionLookupInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_game_distribution_version_and_return for super::RemoteProcedures {
         input: GameDistributionVersionLookupInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionVersionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs
index d4cd499f9..2537470b0 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait get_owner_game_distribution_version_and_return {
         input: GameDistributionOwnerVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl get_owner_game_distribution_version_and_return for super::RemoteProcedures
         input: GameDistributionOwnerVersionInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionVersionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs
index 7ed9a62a0..e8bd65865 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_public_game_distribution_game_and_return {
         input: GameDistributionPublicGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_public_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionPublicGameInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionGameProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_games_and_return_procedure.rs
index bb17220f1..915c008a5 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_games_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_games_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait list_admin_game_distribution_games_and_return {
         input: GameDistributionAdminGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionAdminGameListResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminGameListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl list_admin_game_distribution_games_and_return for super::RemoteProcedures {
         input: GameDistributionAdminGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionAdminGameListResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminGameListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionAdminGameListResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs
index 7c75774e5..d5004208b 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait list_game_distribution_games_and_return {
         input: GameDistributionPublicGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl list_game_distribution_games_and_return for super::RemoteProcedures {
         input: GameDistributionPublicGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs
index 0edb574ed..db968103b 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait list_game_distribution_reviews_and_return {
         input: GameDistributionReviewListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl list_game_distribution_reviews_and_return for super::RemoteProcedures {
         input: GameDistributionReviewListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs
index 9e495141d..fa6992457 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait list_owner_game_distribution_games_and_return {
         input: GameDistributionOwnerGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl list_owner_game_distribution_games_and_return for super::RemoteProcedures {
         input: GameDistributionOwnerGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionOwnerGameListProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs
index 90efdc26b..ac07ca5de 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait list_public_game_distribution_games_and_return {
         input: GameDistributionPublicGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl list_public_game_distribution_games_and_return for super::RemoteProcedures
         input: GameDistributionPublicGameListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionGameListProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs
index c1a720f7b..ff7b00ed2 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait reject_game_distribution_version_and_return {
         input: GameDistributionRejectInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl reject_game_distribution_version_and_return for super::RemoteProcedures {
         input: GameDistributionRejectInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/restore_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/restore_game_distribution_game_and_return_procedure.rs
index 1bf5be722..c6a9a4e75 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/restore_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/restore_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait restore_game_distribution_game_and_return {
         input: GameDistributionRestoreInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl restore_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionRestoreInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs
index f68aeb183..365ac0cfe 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs
@@ -34,10 +34,10 @@ pub trait submit_game_distribution_version_for_review_and_return {
         input: GameDistributionSubmitReviewInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl submit_game_distribution_version_for_review_and_return for super::RemotePro
         input: GameDistributionSubmitReviewInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs
index e13060da1..a44f4d0d4 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait suspend_game_distribution_game_and_return {
         input: GameDistributionSuspendInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl suspend_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionSuspendInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs
index 190b12f0c..02346b654 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait unpublish_game_distribution_game_and_return {
         input: GameDistributionUnpublishInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl unpublish_game_distribution_game_and_return for super::RemoteProcedures {
         input: GameDistributionUnpublishInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<GameDistributionProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_game_metadata_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_game_metadata_and_return_procedure.rs
new file mode 100644
index 000000000..703207905
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_game_metadata_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_update_metadata_input_type::GameDistributionUpdateMetadataInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UpdateGameDistributionGameMetadataAndReturnArgs {
+    pub input: GameDistributionUpdateMetadataInput,
+}
+
+impl __sdk::InModule for UpdateGameDistributionGameMetadataAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `update_game_distribution_game_metadata_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait update_game_distribution_game_metadata_and_return {
+    fn update_game_distribution_game_metadata_and_return(
+        &self,
+        input: GameDistributionUpdateMetadataInput,
+    ) {
+        self.update_game_distribution_game_metadata_and_return_then(input, |_, _| {});
+    }
+
+    fn update_game_distribution_game_metadata_and_return_then(
+        &self,
+        input: GameDistributionUpdateMetadataInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl update_game_distribution_game_metadata_and_return for super::RemoteProcedures {
+    fn update_game_distribution_game_metadata_and_return_then(
+        &self,
+        input: GameDistributionUpdateMetadataInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "update_game_distribution_game_metadata_and_return",
+                UpdateGameDistributionGameMetadataAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-module/src/game_distribution.rs b/server-rs/crates/spacetime-module/src/game_distribution.rs
index 9c0ba70a5..e580a3df5 100644
--- a/server-rs/crates/spacetime-module/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-module/src/game_distribution.rs
@@ -761,6 +761,10 @@ pub struct GameDistributionGame {
     /// 审核通过后生效的截图对象键 JSON 数组（与 `cover_asset_id` 同源，来自版本冻结资料）。
     #[default(None::<String>)]
     pub(crate) screenshots_json: Option<String>,
+    /// 作者软删除时间。非空表示该作品已从作者视图、公开目录/详情与发行网关下线；
+    /// 版本行、发行包对象与冻结资料保持不可变，删除只改游戏行的可见性状态。
+    #[default(None::<Timestamp>)]
+    pub(crate) deleted_at: Option<Timestamp>,
 }
 
 /// 游戏发行版本。包摘要、确认字节数和送审资料在创建后作为不可变快照保留；状态和
@@ -886,10 +890,16 @@ const GAME_DISTRIBUTION_ACTION_REJECT: &str = "reject";
 const GAME_DISTRIBUTION_ACTION_UNPUBLISH: &str = "unpublish";
 const GAME_DISTRIBUTION_ACTION_SUSPEND: &str = "suspend";
 const GAME_DISTRIBUTION_ACTION_RESTORE: &str = "restore";
+const GAME_DISTRIBUTION_ACTION_UPDATE_METADATA: &str = "update_metadata";
+const GAME_DISTRIBUTION_ACTION_DELETE: &str = "delete";
 /// 后台游戏管理页每个游戏最多回传多少个版本历史；版本数仍按全量统计。
 const GAME_DISTRIBUTION_ADMIN_VERSION_HISTORY_LIMIT: usize = 20;
-/// 后台游戏管理页一次最多回传多少个游戏；全量视图按上限截断，不做游标分页。
+/// 后台游戏管理页一次最多回传多少个游戏。
 const GAME_DISTRIBUTION_ADMIN_GAME_LIST_LIMIT: u32 = 200;
+/// 后台游戏管理页 `status` 过滤里代表"已软删除"的取值；其余取值与游戏可见性同名。
+const GAME_DISTRIBUTION_ADMIN_STATUS_DELETED: &str = "deleted";
+/// 软删除游戏的统一拒绝文案；api-server 按其中的"已被删除"映射成 404。
+const GAME_DISTRIBUTION_GAME_DELETED_MESSAGE: &str = "游戏已被删除";
 const GAME_DISTRIBUTION_RECEIPT_RETENTION_MICROS: i64 = 30 * 24 * 60 * 60 * 1_000_000;
 const GAME_DISTRIBUTION_MAX_LIST_LIMIT: u32 = 48;
 const GAME_DISTRIBUTION_MAX_OWNER_VERSIONS_PER_GAME: usize = 10;
@@ -923,6 +933,10 @@ pub struct GameDistributionCreateVersionInput {
     pub game_id: String,
     pub owner_user_id: String,
     pub version_id: String,
+    /// 用户可见的正整数版本标签；`None` 时由事务按该游戏最大版本号自动 +1（旧客户端兼容）。
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一标签可以反复提交（每次生成新的 version_id），
+    /// 允许重复标签与回退，因此不再与已有最大值比较。
+    pub version_number: Option<u64>,
     /// 由 api-server 校验并解析素材后生成的资料快照 JSON。
     pub metadata_json: String,
     pub package_sha256: String,
@@ -1032,6 +1046,15 @@ pub struct GameDistributionReviewListInput {
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
 pub struct GameDistributionAdminGameListInput {
     pub limit: u32,
+    /// 关键词：匹配标题、gameId 或作者 user ID（大小写不敏感的子串）。
+    pub keyword: Option<String>,
+    /// 只返回该作者名下的游戏；精确匹配 owner_user_id。
+    pub owner_user_id: Option<String>,
+    /// 可见性过滤：`published` / `unpublished` / `suspended` / `deleted`。
+    /// 为空时排除已软删除的游戏；`deleted` 只返回已软删除的游戏。
+    pub status: Option<String>,
+    /// 上一页最后一条的游标，由 `GameDistributionAdminGameListResult.next_cursor` 返回。
+    pub cursor: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -1044,6 +1067,41 @@ pub struct GameDistributionRestoreInput {
     pub now_micros: i64,
 }
 
+/// 作者编辑游戏级展示资料。版本行与冻结资料不参与，只有游戏行上的展示字段被覆盖。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionUpdateMetadataInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub cover_object_key: Option<String>,
+    pub screenshots_json: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 作者软删除游戏。只写 `deleted_at` 并下线公开投影，不改版本行与冻结资料。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionDeleteGameInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
 pub struct GameDistributionOwnerGameListInput {
     pub owner_user_id: String,
@@ -1109,6 +1167,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>,
 }
@@ -1165,6 +1224,8 @@ pub struct GameDistributionAdminGameSnapshot {
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
     pub versions: Vec<GameDistributionAdminVersionSnapshot>,
+    /// 软删除时间；为空表示未删除。后台列表用它展示"已删除"状态。
+    pub deleted_at_micros: Option<i64>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -1172,6 +1233,8 @@ pub struct GameDistributionAdminGameListResult {
     pub ok: bool,
     pub games: Vec<GameDistributionAdminGameSnapshot>,
     pub error_message: Option<String>,
+    /// 还有下一页时是该页最后一条的游标，否则为空。
+    pub next_cursor: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, SpacetimeType)]
@@ -1467,7 +1530,7 @@ pub fn list_game_distribution_reviews_and_return(
     }
 }
 
-/// 返回后台游戏管理页的全量游戏；版本数与最近版本在同一事务内统计，作者名/头像读时联账号表。
+/// 返回后台游戏管理页的游戏；关键词/作者/状态过滤、游标分页、版本数与最近版本都在同一事务内完成。
 #[spacetimedb::procedure]
 pub fn list_admin_game_distribution_games_and_return(
     ctx: &mut ProcedureContext,
@@ -1478,19 +1541,53 @@ pub fn list_admin_game_distribution_games_and_return(
         require_editor_generation_runtime_service_identity(tx, caller)?;
         list_admin_game_distribution_games_tx(tx, input.clone())
     }) {
-        Ok(games) => GameDistributionAdminGameListResult {
+        Ok((games, next_cursor)) => GameDistributionAdminGameListResult {
             ok: true,
             games,
             error_message: None,
+            next_cursor,
         },
         Err(error) => GameDistributionAdminGameListResult {
             ok: false,
             games: Vec::new(),
             error_message: Some(error),
+            next_cursor: None,
         },
     }
 }
 
+/// 作者编辑游戏级展示资料；立即生效，版本包与冻结资料不受影响。
+#[spacetimedb::procedure]
+pub fn update_game_distribution_game_metadata_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionUpdateMetadataInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        update_game_distribution_game_metadata_tx(tx, input.clone())
+    }) {
+        Ok((game, replayed)) => game_distribution_game_result(game, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 作者软删除自己的游戏；只标记删除时间并下线公开投影，保留版本包与冻结资料。
+#[spacetimedb::procedure]
+pub fn delete_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionDeleteGameInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        delete_game_distribution_game_tx(tx, input.clone())
+    }) {
+        Ok((game, replayed)) => game_distribution_game_result(game, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
 /// 管理员解除安全下架：重新激活该游戏最近一次曾公开的版本。
 #[spacetimedb::procedure]
 pub fn restore_game_distribution_game_and_return(
@@ -1736,13 +1833,17 @@ fn create_game_distribution_game_tx(
     }
 
     // 同一作者同一本地项目再次发布只新增版本，不新建游戏身份。
+    // 已软删除的作品不再复用：删除后重新发布应得到新的游戏身份。
     if let Some(local_project_id) = local_project_id.as_deref() {
         let existing = ctx
             .db
             .game_distribution_game()
             .by_game_distribution_game_owner_user_id()
             .filter(&owner_user_id)
-            .find(|game| game.local_project_id.as_deref() == Some(local_project_id));
+            .find(|game| {
+                game.deleted_at.is_none()
+                    && game.local_project_id.as_deref() == Some(local_project_id)
+            });
         if let Some(game) = existing {
             insert_game_distribution_receipt(
                 ctx,
@@ -1803,6 +1904,7 @@ fn create_game_distribution_game_tx(
             local_project_id,
             cover_object_key: None,
             screenshots_json: None,
+            deleted_at: None,
         });
     insert_game_distribution_receipt(
         ctx,
@@ -1831,6 +1933,30 @@ fn create_game_distribution_game_tx(
     Ok((game_distribution_game_snapshot(&game), false))
 }
 
+/// 解析本次创建的版本号（用户可见版本标签；具体提交实例由 `version_id` 区分）。
+///
+/// 规则本体在 `module-game-distribution` 的 `resolve_version_number`，这里只把领域错误映射成
+/// 传输层错误字符串：
+/// - `None`：旧客户端兼容路径，取该游戏已有最大版本号 +1；溢出时失败关闭并带上冲突前缀。
+/// - `Some(requested)`：只要求正整数。同一个 gameId 的同一个版本号可以反复提交（每次生成新的
+///   `version_id`，旧公开实例不原地修改），所以**不再与已有最大值比较**，允许重复标签与回退。
+/// - `Some(0)` / 非法值：普通参数错误（不带冲突前缀，api-server 映射成 400）。
+fn resolve_game_distribution_version_number(
+    max_existing: u64,
+    requested: Option<u64>,
+) -> Result<u64, String> {
+    match module_game_distribution::resolve_version_number(max_existing, requested) {
+        Ok(version_number) => Ok(version_number),
+        Err(module_game_distribution::GameDistributionFieldError::VersionNumberExhausted) => {
+            Err(format!(
+                "{}: 版本号已达上限 {max_existing}，无法自动递增",
+                shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT
+            ))
+        }
+        Err(error) => Err(error.to_string()),
+    }
+}
+
 fn create_game_distribution_version_tx(
     ctx: &ReducerContext,
     input: GameDistributionCreateVersionInput,
@@ -1880,6 +2006,7 @@ fn create_game_distribution_version_tx(
     if game.owner_user_id != owner_user_id {
         return Err("游戏 owner 不匹配".to_string());
     }
+    ensure_game_distribution_game_not_deleted(&game)?;
     if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         return Err("游戏已被暂停，不能创建版本".to_string());
     }
@@ -1893,17 +2020,35 @@ 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);
+    for mut pending in ctx
+        .db
+        .game_distribution_version()
+        .by_game_distribution_version_game_id()
+        .filter(&game_id)
+        .filter(|version| {
+            version.version_number == version_number
+                && version.status == GAME_DISTRIBUTION_VERSION_PENDING_REVIEW
+        })
+    {
+        pending.status = GAME_DISTRIBUTION_VERSION_CANCELLED.to_string();
+        pending.review_reason = Some("被同一项目版本的新提交替代".to_string());
+        pending.updated_at = now;
+        ctx.db
+            .game_distribution_version()
+            .version_id()
+            .update(pending);
+    }
     ctx.db
         .game_distribution_version()
         .insert(GameDistributionVersion {
@@ -2199,6 +2344,7 @@ fn submit_game_distribution_version_for_review_tx(
         return Err("游戏 owner 不匹配".to_string());
     }
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         return Err("游戏已被暂停，不能提交审核".to_string());
     }
@@ -2292,6 +2438,7 @@ fn cancel_game_distribution_version_tx(
         return Err("游戏 owner 不匹配".to_string());
     }
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if !game_distribution_version_can_cancel(version.status.as_str()) {
         return Err(format!("版本状态 {} 不允许撤回", version.status));
     }
@@ -2383,6 +2530,7 @@ fn approve_game_distribution_version_tx(
         .find(&version.game_id)
         .ok_or_else(|| "游戏不存在".to_string())?;
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         return Err("游戏已被暂停，不能批准版本".to_string());
     }
@@ -2500,6 +2648,7 @@ fn reject_game_distribution_version_tx(
         .find(&version.game_id)
         .ok_or_else(|| "游戏不存在".to_string())?;
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if version.status != GAME_DISTRIBUTION_VERSION_PENDING_REVIEW {
         return Err(format!("版本状态 {} 不允许拒绝", version.status));
     }
@@ -2570,6 +2719,7 @@ fn unpublish_game_distribution_game_tx(
         return Err("游戏 owner 不匹配".to_string());
     }
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         return Err("游戏已被管理员暂停，作者不能解除暂停".to_string());
     }
@@ -2656,6 +2806,7 @@ fn suspend_game_distribution_game_tx(
         .find(&game_id)
         .ok_or_else(|| "游戏不存在".to_string())?;
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
     if game.visibility != GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         if let Some(active_version_id) = game.active_version_id.clone() {
@@ -2744,6 +2895,7 @@ fn restore_game_distribution_game_tx(
         .find(&game_id)
         .ok_or_else(|| "游戏不存在".to_string())?;
     ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    ensure_game_distribution_game_not_deleted(&game)?;
     if game.visibility != GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
         return Err("只有管理员暂停的游戏才能恢复".to_string());
     }
@@ -2762,8 +2914,8 @@ fn restore_game_distribution_game_tx(
         .collect::<Vec<_>>();
     candidates.sort_by(|left, right| {
         right
-            .version_number
-            .cmp(&left.version_number)
+            .updated_at
+            .cmp(&left.updated_at)
             .then_with(|| right.version_id.cmp(&left.version_id))
     });
     let mut version = candidates
@@ -2812,6 +2964,177 @@ fn restore_game_distribution_game_tx(
     Ok((game_distribution_game_snapshot(&game), false))
 }
 
+/// 作者编辑游戏级展示资料：只覆盖游戏行上的字段，版本行与冻结资料保持不可变。
+fn update_game_distribution_game_metadata_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionUpdateMetadataInput,
+) -> Result<(GameDistributionGameSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_UPDATE_METADATA,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let game = ctx
+            .db
+            .game_distribution_game()
+            .game_id()
+            .find(&game_id)
+            .ok_or_else(|| "幂等收据对应的游戏已不存在".to_string())?;
+        if game.owner_user_id != owner_user_id {
+            return Err("游戏 owner 不匹配".to_string());
+        }
+        return Ok((game_distribution_game_snapshot(&game), true));
+    }
+    let mut game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    ensure_game_distribution_game_not_deleted(&game)?;
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    game.title = required_game_distribution_text(input.title, "title")?;
+    game.summary = required_game_distribution_text(input.summary, "summary")?;
+    game.description = input.description.unwrap_or_default();
+    game.category = required_game_distribution_text(input.category, "category")?;
+    game.tags_json = input.tags_json;
+    game.cover_asset_id = input.cover_asset_id;
+    game.cover_object_key = input.cover_object_key;
+    game.screenshots_json = input.screenshots_json;
+    game.device_support_desktop = input.device_support_desktop;
+    game.device_support_mobile = input.device_support_mobile;
+    game.device_support_touch = input.device_support_touch;
+    game.input_modes_json = input.input_modes_json;
+    game.orientation = required_game_distribution_text(input.orientation, "orientation")?;
+    game.updated_at = now;
+    ctx.db
+        .game_distribution_game()
+        .game_id()
+        .update(game.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_UPDATE_METADATA.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id),
+            version_id: None,
+            outcome_kind: "game".to_string(),
+            outcome_game_id: Some(game.game_id.clone()),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_game_snapshot(&game), false))
+}
+
+/// 作者软删除游戏。
+///
+/// 只写 `deleted_at` 并把公开投影下线（可见性回到 `unpublished`、撤销当前公开版本并递增
+/// `publication_revision`）。版本行、包摘要与其冻结资料一律不改写，保证发行记录可追溯；
+/// 删除后作者视图、公开目录/详情、发行网关与后台默认列表都不再返回该游戏。
+fn delete_game_distribution_game_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionDeleteGameInput,
+) -> Result<(GameDistributionGameSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_DELETE,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let game = ctx
+            .db
+            .game_distribution_game()
+            .game_id()
+            .find(&game_id)
+            .ok_or_else(|| "幂等收据对应的游戏已不存在".to_string())?;
+        if game.owner_user_id != owner_user_id {
+            return Err("游戏 owner 不匹配".to_string());
+        }
+        return Ok((game_distribution_game_snapshot(&game), true));
+    }
+    let mut game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    if game.deleted_at.is_none() {
+        if let Some(active_version_id) = game.active_version_id.clone() {
+            if let Some(mut version) = ctx
+                .db
+                .game_distribution_version()
+                .version_id()
+                .find(&active_version_id)
+            {
+                version.status = GAME_DISTRIBUTION_VERSION_REVOKED.to_string();
+                version.revoked_at = Some(now);
+                version.updated_at = now;
+                ctx.db
+                    .game_distribution_version()
+                    .version_id()
+                    .update(version);
+            }
+        }
+        game.deleted_at = Some(now);
+        game.visibility = GAME_DISTRIBUTION_VISIBILITY_UNPUBLISHED.to_string();
+        game.active_version_id = None;
+        game.publication_revision = game
+            .publication_revision
+            .checked_add(1)
+            .ok_or_else(|| "publication_revision 溢出".to_string())?;
+        game.updated_at = now;
+        ctx.db
+            .game_distribution_game()
+            .game_id()
+            .update(game.clone());
+    }
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_DELETE.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id),
+            version_id: None,
+            outcome_kind: "game".to_string(),
+            outcome_game_id: Some(game.game_id.clone()),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_game_snapshot(&game), false))
+}
+
 /// 批量累加游玩次数；只作用于当前公开且有有效公开版本的游戏。
 ///
 /// 同一 `game_id` 的多次增量由 api-server 侧先聚合；这里仍逐条 `find`，对同一行的
@@ -2845,13 +3168,51 @@ fn increment_game_distribution_game_play_counts_tx(
 fn list_admin_game_distribution_games_tx(
     ctx: &ReducerContext,
     input: GameDistributionAdminGameListInput,
-) -> Result<Vec<GameDistributionAdminGameSnapshot>, String> {
+) -> Result<(Vec<GameDistributionAdminGameSnapshot>, Option<String>), String> {
     let limit = if input.limit == 0 {
         GAME_DISTRIBUTION_ADMIN_GAME_LIST_LIMIT
     } else {
         input.limit.min(GAME_DISTRIBUTION_ADMIN_GAME_LIST_LIMIT)
     } as usize;
-    let mut games = ctx.db.game_distribution_game().iter().collect::<Vec<_>>();
+    let keyword = input
+        .keyword
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| value.to_lowercase());
+    let owner_user_id = input
+        .owner_user_id
+        .and_then(normalize_game_distribution_optional);
+    let status = input
+        .status
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| value.to_lowercase());
+    let cursor = input
+        .cursor
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| parse_admin_game_distribution_cursor(value.as_str()))
+        .transpose()?;
+    let mut games = ctx
+        .db
+        .game_distribution_game()
+        .iter()
+        .filter(|game| match status.as_deref() {
+            Some(GAME_DISTRIBUTION_ADMIN_STATUS_DELETED) => game.deleted_at.is_some(),
+            Some(value) => game.deleted_at.is_none() && game.visibility == value,
+            // 默认视图排除软删除行，运营要看已删除作品必须显式带上 status=deleted。
+            None => game.deleted_at.is_none(),
+        })
+        .filter(|game| {
+            owner_user_id
+                .as_deref()
+                .is_none_or(|value| game.owner_user_id == value)
+        })
+        .filter(|game| {
+            keyword.as_deref().is_none_or(|value| {
+                game.title.to_lowercase().contains(value)
+                    || game.game_id.to_lowercase().contains(value)
+                    || game.owner_user_id.to_lowercase().contains(value)
+            })
+        })
+        .collect::<Vec<_>>();
     games.sort_by(|left, right| {
         right
             .created_at
@@ -2859,11 +3220,48 @@ fn list_admin_game_distribution_games_tx(
             .cmp(&left.created_at.to_micros_since_unix_epoch())
             .then_with(|| left.game_id.cmp(&right.game_id))
     });
+    if let Some(cursor) = cursor.as_ref() {
+        games.retain(|game| {
+            let created_at_micros = game.created_at.to_micros_since_unix_epoch();
+            created_at_micros < cursor.0
+                || (created_at_micros == cursor.0 && game.game_id.as_str() > cursor.1.as_str())
+        });
+    }
+    // 多取一条判断是否还有下一页；游标只指向这一页真正回传的最后一条。
+    let has_more = games.len() > limit;
     games.truncate(limit);
-    Ok(games
-        .into_iter()
-        .map(|game| admin_game_distribution_game_snapshot(ctx, &game))
-        .collect())
+    let next_cursor = if has_more {
+        games.last().map(|game| {
+            format!(
+                "{}:{}",
+                game.created_at.to_micros_since_unix_epoch(),
+                game.game_id
+            )
+        })
+    } else {
+        None
+    };
+    Ok((
+        games
+            .into_iter()
+            .map(|game| admin_game_distribution_game_snapshot(ctx, &game))
+            .collect(),
+        next_cursor,
+    ))
+}
+
+/// 后台列表游标：`<created_at_micros>:<game_id>`；gameId 由 api-server 生成，不含冒号。
+fn parse_admin_game_distribution_cursor(value: &str) -> Result<(i64, String), String> {
+    let (micros, game_id) = value
+        .split_once(':')
+        .ok_or_else(|| "后台列表游标格式无效".to_string())?;
+    let micros = micros
+        .parse::<i64>()
+        .map_err(|_| "后台列表游标格式无效".to_string())?;
+    if game_id.is_empty() {
+        return Err("后台列表游标格式无效".to_string());
+    }
+    Ok((micros, game_id.to_string()))
 }
 
 fn admin_game_distribution_game_snapshot(
@@ -2880,8 +3278,8 @@ fn admin_game_distribution_game_snapshot(
     let version_count = versions.len() as u64;
     versions.sort_by(|left, right| {
         right
-            .version_number
-            .cmp(&left.version_number)
+            .updated_at
+            .cmp(&left.updated_at)
             .then_with(|| right.version_id.cmp(&left.version_id))
     });
     versions.truncate(GAME_DISTRIBUTION_ADMIN_VERSION_HISTORY_LIMIT);
@@ -2913,6 +3311,9 @@ fn admin_game_distribution_game_snapshot(
             .iter()
             .map(admin_game_distribution_version_snapshot)
             .collect(),
+        deleted_at_micros: game
+            .deleted_at
+            .map(|value| value.to_micros_since_unix_epoch()),
     }
 }
 
@@ -2956,6 +3357,14 @@ fn list_game_distribution_reviews_tx(
                 && version.package_object_key.is_some()
                 && version.package_manifest_json.is_some()
         })
+        // 已软删除作品的待审版本不再进入审核队列，运营不会看到一个已经下线的作品。
+        .filter(|version| {
+            ctx.db
+                .game_distribution_game()
+                .game_id()
+                .find(&version.game_id)
+                .is_none_or(|game| game.deleted_at.is_none())
+        })
         .collect::<Vec<_>>();
     versions.sort_by(|left, right| {
         left.submitted_at
@@ -2965,7 +3374,7 @@ fn list_game_distribution_reviews_tx(
     versions.truncate(limit);
     Ok(versions
         .iter()
-        .map(game_distribution_version_snapshot)
+        .map(|version| game_distribution_version_snapshot_for_game(ctx, version))
         .collect())
 }
 
@@ -2983,6 +3392,14 @@ fn ensure_game_distribution_publication_revision(
     }
 }
 
+/// 软删除的游戏不再接受任何作者/管理员的写入与读取，统一按"不存在"处理。
+fn ensure_game_distribution_game_not_deleted(game: &GameDistributionGame) -> Result<(), String> {
+    if game.deleted_at.is_some() {
+        return Err(GAME_DISTRIBUTION_GAME_DELETED_MESSAGE.to_string());
+    }
+    Ok(())
+}
+
 fn list_owner_game_distribution_games_tx(
     ctx: &ReducerContext,
     input: GameDistributionOwnerGameListInput,
@@ -2998,6 +3415,7 @@ fn list_owner_game_distribution_games_tx(
         .game_distribution_game()
         .by_game_distribution_game_owner_user_id()
         .filter(&owner_user_id)
+        .filter(|game| game.deleted_at.is_none())
         .collect::<Vec<_>>();
     games.sort_by(|left, right| {
         right
@@ -3018,15 +3436,17 @@ fn list_owner_game_distribution_games_tx(
                 .collect::<Vec<_>>();
             versions.sort_by(|left, right| {
                 right
-                    .version_number
-                    .cmp(&left.version_number)
+                    .updated_at
+                    .cmp(&left.updated_at)
                     .then_with(|| right.version_id.cmp(&left.version_id))
             });
             versions.truncate(GAME_DISTRIBUTION_MAX_OWNER_VERSIONS_PER_GAME);
             GameDistributionOwnerGameSnapshot {
                 versions: versions
                     .iter()
-                    .map(|version| game_distribution_version_snapshot(version))
+                    .map(|version| {
+                        game_distribution_version_snapshot(version, game.publication_revision)
+                    })
                     .collect(),
                 game: game_distribution_game_snapshot(&game),
             }
@@ -3054,6 +3474,7 @@ fn list_public_game_distribution_games_tx(
         .game_distribution_game()
         .iter()
         .filter(|game| game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED)
+        .filter(|game| game.deleted_at.is_none())
         .filter(|game| game.active_version_id.is_some())
         .filter(|game| {
             category
@@ -3090,7 +3511,9 @@ fn get_public_game_distribution_game_tx(
     let Some(game) = ctx.db.game_distribution_game().game_id().find(&game_id) else {
         return Ok(None);
     };
-    if game.visibility != GAME_DISTRIBUTION_VISIBILITY_PUBLISHED || game.active_version_id.is_none()
+    if game.visibility != GAME_DISTRIBUTION_VISIBILITY_PUBLISHED
+        || game.active_version_id.is_none()
+        || game.deleted_at.is_some()
     {
         return Ok(None);
     }
@@ -3105,6 +3528,9 @@ fn get_game_distribution_game_for_owner_or_public_tx(
     let Some(game) = ctx.db.game_distribution_game().game_id().find(&game_id) else {
         return Ok(None);
     };
+    if game.deleted_at.is_some() {
+        return Ok(None);
+    }
     if let Some(owner_user_id) = input
         .owner_user_id
         .and_then(normalize_game_distribution_optional)
@@ -3152,6 +3578,16 @@ fn get_owner_game_distribution_version_tx(
     if version.owner_user_id != owner_user_id {
         return Err("版本 owner 不匹配".to_string());
     }
+    // 作品软删除后，作者侧连版本一起不可见（上传、确认、送审等入口统一走这条回读）。
+    let deleted = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .is_none_or(|game| game.deleted_at.is_some());
+    if deleted {
+        return Ok(None);
+    }
     Ok(Some(game_distribution_version_snapshot_for_game(
         ctx, &version,
     )))
@@ -3273,6 +3709,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(),
     }
@@ -3347,6 +3784,7 @@ pub(crate) fn game_distribution_asset_has_public_read_grant(
     ctx.db.game_distribution_game().iter().any(|game| {
         if game.visibility != GAME_DISTRIBUTION_VISIBILITY_PUBLISHED
             || game.active_version_id.is_none()
+            || game.deleted_at.is_some()
         {
             return false;
         }
@@ -3368,6 +3806,7 @@ pub(crate) fn game_distribution_asset_has_public_read_grant(
 
 fn game_distribution_version_snapshot(
     version: &GameDistributionVersion,
+    publication_revision: u64,
 ) -> GameDistributionVersionSnapshot {
     GameDistributionVersionSnapshot {
         version_id: version.version_id.clone(),
@@ -3381,7 +3820,7 @@ fn game_distribution_version_snapshot(
         status: version.status.clone(),
         review_reason: version.review_reason.clone(),
         entry_url: version.entry_url.clone(),
-        publication_revision: 0,
+        publication_revision,
         created_at_micros: version.created_at.to_micros_since_unix_epoch(),
         updated_at_micros: version.updated_at.to_micros_since_unix_epoch(),
         metadata_json: version.metadata_json.clone(),
@@ -3392,15 +3831,14 @@ fn game_distribution_version_snapshot_for_game(
     ctx: &ReducerContext,
     version: &GameDistributionVersion,
 ) -> GameDistributionVersionSnapshot {
-    let mut snapshot = game_distribution_version_snapshot(version);
-    snapshot.publication_revision = ctx
+    let publication_revision = ctx
         .db
         .game_distribution_game()
         .game_id()
         .find(&version.game_id)
         .map(|game| game.publication_revision)
         .unwrap_or_default();
-    snapshot
+    game_distribution_version_snapshot(version, publication_revision)
 }
 
 fn public_game_distribution_version(
@@ -3430,3 +3868,72 @@ 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_only_requires_a_positive_integer() {
+        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 也能再提交一次 3，生成新的 version_id。
+        assert_eq!(
+            resolve_game_distribution_version_number(3, Some(3)).expect("重复标签应接受"),
+            3
+        );
+        // 回退：线上最大 5，也允许把项目版本改回 2。
+        assert_eq!(
+            resolve_game_distribution_version_number(5, Some(2)).expect("回退标签应接受"),
+            2
+        );
+        assert_eq!(
+            resolve_game_distribution_version_number(u64::MAX - 1, Some(u64::MAX))
+                .expect("u64 上限作为显式值应接受"),
+            u64::MAX
+        );
+    }
+
+    #[test]
+    fn version_number_zero_is_rejected_as_a_plain_bad_request() {
+        // 0 不是合法的版本标签；这类参数错误不带冲突前缀，api-server 映射成 400 而不是 409。
+        let zero =
+            resolve_game_distribution_version_number(0, Some(0)).expect_err("版本号 0 应被拒绝");
+        assert!(!conflict(&zero), "参数错误不应带冲突前缀：{zero}");
+        assert!(zero.contains("大于 0"), "应说明合法形状：{zero}");
+    }
+
+    #[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/server-rs/crates/spacetime-module/src/migration.rs b/server-rs/crates/spacetime-module/src/migration.rs
index f942967bb..83458de87 100644
--- a/server-rs/crates/spacetime-module/src/migration.rs
+++ b/server-rs/crates/spacetime-module/src/migration.rs
@@ -212,6 +212,8 @@ macro_rules! migration_tables {
             // 随迁移导出/导入；私有 ZIP 与展开内容保存在对象存储，不进入这两张表。
             // 资料随版本冻结：版本表末尾追加 metadata_json，游戏表末尾追加
             // cover_object_key / screenshots_json，均为可空列，旧行按“未冻结资料”处理。
+            // 软删除：游戏表末尾追加可空 deleted_at；非空表示作者已删除该作品，
+            // 行本身仍随迁移导出，版本行与冻结资料保持不可变。
             game_distribution_game,
             game_distribution_review,
             game_distribution_review_moderation_log,
diff --git a/src/components/game-distribution/GameDetailPage.tsx b/src/components/game-distribution/GameDetailPage.tsx
index 0820d2b3d..1fee3520d 100644
--- a/src/components/game-distribution/GameDetailPage.tsx
+++ b/src/components/game-distribution/GameDetailPage.tsx
@@ -1,20 +1,25 @@
 import './gameDistribution.css';
-import './gameDistributionShowcase.css';
 
 import {
-  ArrowLeft,
-  Gamepad2,
-  Maximize2,
-  Smartphone,
-  Sparkles,
-} from 'lucide-react';
+  type GameDetailAssetRenderInput,
+  GameDetailDisplay,
+} from '@genarrative/shared/components';
+import { ArrowLeft, Gamepad2, Maximize2 } from 'lucide-react';
 import { useCallback, useEffect, useRef, useState } from 'react';
 
+import type {
+  GameDistributionRecoveryAction,
+  GameDistributionVersionSummary,
+} from '../../../packages/shared/src/contracts/gameDistribution';
 import { useResolvedAssetReadUrl } from '../../hooks/useResolvedAssetReadUrl';
 import {
   type GameDistributionGame,
   type GameDistributionInputMode,
+  type GameDistributionMyGame,
+  type GameDistributionVersionStatusEntry,
   getGame,
+  getMyGame,
+  loadVersionRecoveryActions,
 } from '../../services/gameDistributionClient';
 import { useAuthUi } from '../auth/AuthUiContext';
 import { PlatformActionButton } from '../common/PlatformActionButton';
@@ -24,107 +29,75 @@ 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';
+import {
+  GAME_STATUS_LABEL,
+  resolveNonPublicCoverLabel,
+  VERSION_STATUS_LABEL,
+  VERSION_STATUS_NEEDS_AUTHOR_ACTION,
+} from './gameVersionHistoryModel';
+import { useGameAuthorDisplayName } from './useGameAuthorName';
 import { useGameReviews } from './useGameReviews';
 
 type GameDetailPageProps = {
   gameId: string | null;
   onBack: () => void;
   onPlay: (gameId: string) => void;
-};
-
-const INPUT_MODE_LABELS: Record<GameDistributionInputMode, string> = {
-  keyboard: '键盘',
-  mouse: '鼠标',
-  touch: '触屏',
+  /**
+   * 作者视角：走 `GET /my-games/{gameId}` 读取自己名下作品。
+   *
+   * 公开详情只服务已公开投影，作者点自己的「审核中 / 被驳回 / 已下架 / 已撤回」作品
+   * 会拿到 404；作者中心进入详情时必须带上这个开关（壳层把它编码进 `owner=1`，
+   * 刷新后仍走同一份 owner 作用域数据）。
+   */
+  ownerView?: boolean;
 };
 
 /**
  * 游玩方式优先取版本冻结时声明的输入方式（公开投影里的 `inputModes`），
  * 再退回版本自由文本 `controls`；两者都没有才显示“未标注操作方式”。
+ * 作者视角的版本条目没有 `controls`（它属于公开版本投影），按缺省处理。
  */
 function resolveControlsLabel(
-  version: GameDistributionGame['currentVersion'],
+  version:
+    | GameDistributionVersionSummary
+    | GameDistributionVersionStatusEntry
+    | null,
   inputModes?: GameDistributionInputMode[],
 ) {
   if (!version) return '暂未发布可玩版本';
   const declared = Array.from(
-    new Set((inputModes ?? []).map((mode) => INPUT_MODE_LABELS[mode] ?? mode)),
+    new Set(
+      (inputModes ?? []).map(
+        (mode) => GAME_METADATA_INPUT_MODE_LABELS[mode] ?? mode,
+      ),
+    ),
   ).filter(Boolean);
   if (declared.length > 0) return declared.join(' · ');
-  const controls = version.controls.join(' · ').trim();
-  return controls || '未标注操作方式';
-}
-
-/** 缩略图自己换签，失败时退回空占位，不阻塞 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>
-  );
+  const controls = 'controls' in version ? version.controls : [];
+  const fallback = controls.join(' · ').trim();
+  return fallback || '未标注操作方式';
 }
 
 /**
- * 详情页封面区：默认展示封面，存在截图时在下方给出可点击的缩略图条。
- *
- * 缩略图第一项固定是封面本身，方便作者/玩家从截图切回封面；只有封面时整条不渲染。
+ * 展示层需要的素材换签桥接：公开详情仍按 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"
+    />
   );
 }
 
@@ -132,18 +105,27 @@ export function GameDetailPage({
   gameId,
   onBack,
   onPlay,
+  ownerView = false,
 }: GameDetailPageProps) {
   const authUi = useAuthUi();
-  const [game, setGame] = useState<GameDistributionGame | null>(null);
+  const [publicGame, setPublicGame] = useState<GameDistributionGame | null>(
+    null,
+  );
+  const [ownerGame, setOwnerGame] = useState<GameDistributionMyGame | null>(
+    null,
+  );
+  const [recoveryActions, setRecoveryActions] = useState<
+    Record<string, GameDistributionRecoveryAction>
+  >({});
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState('');
   const requestSerialRef = useRef(0);
   const isMobileViewport = useIsMobileViewport();
 
-  const loadGame = useCallback(() => {
+  const loadPublicGame = useCallback(() => {
     const requestSerial = ++requestSerialRef.current;
     const normalizedGameId = normalizeGameId(gameId);
-    setGame(null);
+    setPublicGame(null);
     setError('');
     if (!normalizedGameId) {
       setIsLoading(false);
@@ -160,13 +142,13 @@ export function GameDetailPage({
             setError('游戏入口地址无效');
             return;
           }
-          setGame({
+          setPublicGame({
             ...value,
             currentVersion: { ...value.currentVersion, entryUrl },
           });
           return;
         }
-        setGame(value);
+        setPublicGame(value);
         if (!value) setError('找不到这款游戏');
       })
       .catch((loadError: unknown) => {
@@ -180,20 +162,75 @@ export function GameDetailPage({
       });
   }, [gameId]);
 
+  /**
+   * 作者视角：读 owner 作用域条目，并只为还需要作者动作的版本补一次 `recoveryAction`
+   * 回读（列表与详情投影都不带这一步动作）。
+   */
+  const loadOwnerGame = useCallback(() => {
+    const requestSerial = ++requestSerialRef.current;
+    const normalizedGameId = normalizeGameId(gameId);
+    setOwnerGame(null);
+    setRecoveryActions({});
+    setError('');
+    if (!normalizedGameId) {
+      setIsLoading(false);
+      setError('游戏编号无效');
+      return;
+    }
+    setIsLoading(true);
+    void getMyGame(normalizedGameId)
+      .then((entry) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        if (!entry) {
+          setError('找不到这款游戏');
+          return;
+        }
+        setOwnerGame(entry);
+        const pendingVersionIds = entry.versions
+          .filter(
+            (version) =>
+              !version.recoveryAction &&
+              VERSION_STATUS_NEEDS_AUTHOR_ACTION[version.status],
+          )
+          .map((version) => version.versionId);
+        if (pendingVersionIds.length === 0) return;
+        return loadVersionRecoveryActions(pendingVersionIds).then((actions) => {
+          if (requestSerial !== requestSerialRef.current) return;
+          setRecoveryActions(actions);
+        });
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setError(
+          loadError instanceof Error ? loadError.message : '作品详情加载失败',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoading(false);
+      });
+  }, [gameId]);
+
   useEffect(() => {
-    void loadGame();
+    if (ownerView) loadOwnerGame();
+    else loadPublicGame();
     return () => {
       requestSerialRef.current += 1;
     };
-  }, [loadGame]);
+  }, [loadOwnerGame, loadPublicGame, ownerView]);
 
-  if (isLoading || (game && game.id !== normalizeGameId(gameId)))
+  const resolvedGame = ownerView ? ownerGame : publicGame;
+  const reload = ownerView ? loadOwnerGame : loadPublicGame;
+
+  if (
+    isLoading ||
+    (resolvedGame && resolvedGame.id !== normalizeGameId(gameId))
+  )
     return (
       <div className="game-detail-page">
         <div className="game-loading-panel">正在加载游戏详情…</div>
       </div>
     );
-  if (error || !game)
+  if (error || !resolvedGame)
     return (
       <div className="game-detail-page">
         <button type="button" className="game-back-button" onClick={onBack}>
@@ -205,7 +242,7 @@ export function GameDetailPage({
           className="game-status-message"
         >
           <span>{error || '找不到这款游戏'}</span>
-          <button type="button" onClick={loadGame}>
+          <button type="button" onClick={reload}>
             重新加载
           </button>
         </PlatformStatusMessage>
@@ -215,8 +252,11 @@ export function GameDetailPage({
   const canReview = Boolean(authUi?.user && authUi.canAccessProtectedData);
   return (
     <GameDetailContent
-      key={`${game.id}:${authUi?.user?.id ?? 'guest'}:${canReview}`}
-      game={game}
+      key={`${resolvedGame.id}:${authUi?.user?.id ?? 'guest'}:${canReview}`}
+      game={resolvedGame}
+      ownerView={ownerView}
+      ownerGame={ownerGame}
+      recoveryActions={recoveryActions}
       isMobileViewport={isMobileViewport}
       canReview={canReview}
       onLogin={() => authUi?.openLoginModal()}
@@ -228,6 +268,9 @@ export function GameDetailPage({
 
 function GameDetailContent({
   game,
+  ownerView,
+  ownerGame,
+  recoveryActions,
   isMobileViewport,
   canReview,
   onLogin,
@@ -235,14 +278,44 @@ function GameDetailContent({
   onPlay,
 }: {
   game: GameDistributionGame;
+  ownerView: boolean;
+  ownerGame: GameDistributionMyGame | null;
+  recoveryActions: Record<string, GameDistributionRecoveryAction>;
   isMobileViewport: boolean;
   canReview: boolean;
   onLogin: () => void;
   onBack: () => void;
   onPlay: (gameId: string) => void;
 }) {
-  const reviews = useGameReviews(game.id, canReview);
-  const version = game.currentVersion;
+  /**
+   * 只有已公开作品才有公开评价/评分投影；审核中、审核未通过、未公开、已下架
+   * 一律不请求评价接口，封面位改为状态文案。
+   */
+  const publiclyVisible = game.status === 'published';
+  const reviews = useGameReviews(game.id, canReview, publiclyVisible);
+  /**
+   * 作者展示名：公开投影只会退化成占位角色词，真实昵称按作者 ID 补查一次
+   * （见 useGameAuthorName）；查不到时给空串，展示层就不渲染「由 X 制作」那一行。
+   */
+  const authorName = useGameAuthorDisplayName(game.author);
+  const displayGame = {
+    ...game,
+    author: { ...game.author, name: authorName ?? '' },
+  };
+  /** 作者视角的条目没有公开投影 `currentVersion`，可玩版本取版本历史里的已发布版本。 */
+  const publishedVersion =
+    ownerGame?.versions.find((item) => item.status === 'published') ?? null;
+  const version = ownerView ? publishedVersion : (game.currentVersion ?? null);
+  const versionLabel = ownerView
+    ? publishedVersion
+      ? `v${publishedVersion.versionNumber}`
+      : ''
+    : (game.currentVersion?.version ?? '');
+  const latestVersion = ownerView ? (ownerGame?.latestVersion ?? null) : null;
+  const coverPlaceholderLabel = publiclyVisible
+    ? ''
+    : resolveNonPublicCoverLabel(game.status, latestVersion?.status);
+  const latestReviewReason = latestVersion?.reviewReason?.trim() ?? '';
   const mobilePlaybackBlocked = isMobileViewport && !game.deviceSupport.mobile;
   const playbackBlocked = !version || mobilePlaybackBlocked;
   return (
@@ -250,22 +323,26 @@ 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={displayGame}
+        coverObjectKey={game.coverObjectKey}
+        screenshotObjectKeys={game.screenshots}
+        coverColor={game.coverColor}
+        icon={game.icon}
+        renderAsset={(asset) =>
+          asset.role === 'cover' && coverPlaceholderLabel ? (
+            <span className="game-detail-cover__pending">
+              {coverPlaceholderLabel}
+            </span>
+          ) : (
+            <GameDetailResolvedAsset {...asset} />
+          )
+        }
+        controlsLabel={resolveControlsLabel(version, game.inputModes)}
+        versionLabel={versionLabel}
+        rating={publiclyVisible ? <GameRatingSummary state={reviews} /> : null}
+        actions={
+          <>
             <PlatformActionButton
               size="lg"
               shape="pill"
@@ -288,43 +365,55 @@ function GameDetailContent({
                 请在电脑上游玩
               </span>
             ) : null}
-            <span className="game-detail-hero__play-count">
-              {game.playCount.toLocaleString()} 次游玩
-            </span>
-          </div>
-        </div>
-      </section>
-      <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>{version?.version || '—'}</span>
-          </div>
-        </aside>
-      </section>
-      <GameReviews state={reviews} canReview={canReview} onLogin={onLogin} />
+            {ownerView && !publishedVersion ? (
+              <span className="game-device-warning" role="status">
+                作品尚未公开，暂时没有在线可玩版本
+              </span>
+            ) : null}
+          </>
+        }
+      >
+        {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}
+                </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}
+        publiclyVisible={publiclyVisible}
+      />
       <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 471613f14..4ecd4ebc3 100644
--- a/src/components/game-distribution/GameDistributionPages.test.tsx
+++ b/src/components/game-distribution/GameDistributionPages.test.tsx
@@ -11,27 +11,42 @@ import {
 } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { GameDistributionGame } from '../../services/gameDistributionClient';
+import type { GameDistributionVersionStatus } from '../../../packages/shared/src/contracts/gameDistribution';
+import type {
+  GameDistributionGame,
+  GameDistributionMyGame,
+  GameDistributionVersionStatusEntry,
+} from '../../services/gameDistributionClient';
 import { GameDetailPage } from './GameDetailPage';
 import { GameGalleryPage } from './GameGalleryPage';
 import { GAME_PLAY_STARTUP_TIMEOUT_MS, GamePlayPage } from './GamePlayPage';
+import { resolveNonPublicCoverLabel } from './gameVersionHistoryModel';
 
 const listGamesMock = vi.hoisted(() => vi.fn());
 const getGameMock = vi.hoisted(() => vi.fn());
+const getMyGameMock = vi.hoisted(() => vi.fn());
+const loadVersionRecoveryActionsMock = vi.hoisted(() => vi.fn());
 const recordGamePlayMock = vi.hoisted(() => vi.fn());
 const resolvedAssetUrlMock = vi.hoisted(() => vi.fn());
+const listGameReviewsMock = vi.hoisted(() => vi.fn());
+const getMyGameReviewMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../../services/gameDistributionClient', () => ({
   listGames: listGamesMock,
   getGame: getGameMock,
+  getMyGame: getMyGameMock,
+  loadVersionRecoveryActions: loadVersionRecoveryActionsMock,
   recordGamePlay: recordGamePlayMock,
-  listGameReviews: vi.fn().mockResolvedValue({
-    reviews: [],
-    page: 1,
-    pageSize: 20,
-    total: 0,
-    totalPages: 0,
-    ratingSummary: { averageScore: null, ratingCount: 0 },
+  listGameReviews: listGameReviewsMock,
+  getMyGameReview: getMyGameReviewMock,
+}));
+
+// 作者视角详情页要按登录身份渲染评价区，这里固定一个可访问受保护数据的用户。
+vi.mock('../auth/AuthUiContext', () => ({
+  useAuthUi: () => ({
+    user: { id: 'author-1' },
+    canAccessProtectedData: true,
+    openLoginModal: vi.fn(),
   }),
 }));
 
@@ -116,6 +131,17 @@ beforeEach(() => {
   setViewportWidth(1024);
   listGamesMock.mockResolvedValue([]);
   getGameMock.mockResolvedValue(createGame());
+  getMyGameMock.mockResolvedValue(null);
+  loadVersionRecoveryActionsMock.mockResolvedValue({});
+  listGameReviewsMock.mockResolvedValue({
+    reviews: [],
+    page: 1,
+    pageSize: 20,
+    total: 0,
+    totalPages: 0,
+    ratingSummary: { averageScore: null, ratingCount: 0 },
+  });
+  getMyGameReviewMock.mockResolvedValue({ review: null });
   recordGamePlayMock.mockResolvedValue(undefined);
   resolvedAssetUrlMock.mockImplementation((objectKey: string) =>
     objectKey ? `https://assets.example.test/${objectKey}` : '',
@@ -222,6 +248,209 @@ describe('GameDetailPage', () => {
   });
 });
 
+describe('GameDetailPage 作者视角', () => {
+  const reviewVersion: GameDistributionVersionStatusEntry = {
+    versionId: 'version-2',
+    gameId: 'game-1',
+    versionNumber: 2,
+    packageSha256: 'b'.repeat(64),
+    packageBytes: 2048,
+    status: 'pending_review',
+    publicationRevision: 6,
+    reviewReason: '封面需要替换',
+    createdAt: '2026-09-20T08:00:00Z',
+    updatedAt: '2026-09-20T09:00:00Z',
+  };
+  const publishedVersion: GameDistributionVersionStatusEntry = {
+    versionId: 'version-1',
+    gameId: 'game-1',
+    versionNumber: 1,
+    packageSha256: 'c'.repeat(64),
+    packageBytes: 1024,
+    status: 'published',
+    publicationRevision: 5,
+    reviewReason: null,
+    createdAt: '2026-09-19T08:00:00Z',
+    updatedAt: '2026-09-19T09:00:00Z',
+  };
+
+  function createOwnerGame(
+    overrides: Partial<GameDistributionMyGame> = {},
+  ): GameDistributionMyGame {
+    return {
+      ...createGame({ currentVersion: null, status: 'unpublished' }),
+      latestVersion: reviewVersion,
+      versions: [reviewVersion],
+      ...overrides,
+    } as GameDistributionMyGame;
+  }
+
+  it('走 owner 路由并展示未公开作品的私有状态，不再请求公开详情', async () => {
+    getMyGameMock.mockResolvedValue(createOwnerGame());
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    expect(await screen.findByText('作品状态')).toBeTruthy();
+    expect(screen.getByText('未公开')).toBeTruthy();
+    expect(
+      screen.getByText('驳回理由：封面需要替换', {
+        selector: '.game-owner-panel__reason',
+      }),
+    ).toBeTruthy();
+    expect(getMyGameMock).toHaveBeenCalledWith('game-1');
+    expect(getGameMock).not.toHaveBeenCalled();
+
+    const playButton = screen.getByRole('button', { name: /立即玩/u });
+    expect((playButton as HTMLButtonElement).disabled).toBe(true);
+    expect(screen.getByText('作品尚未公开，暂时没有在线可玩版本')).toBeTruthy();
+  });
+
+  it('未公开作品的封面显示审核中，且不请求评价与评分接口', async () => {
+    getMyGameMock.mockResolvedValue(createOwnerGame());
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    await screen.findByText('作品状态');
+
+    // 封面位按最新版本状态给出「审核中」，不再只剩手柄占位图。
+    const cover = document.querySelector('.game-detail-cover') as HTMLElement;
+    expect(within(cover).getByText('审核中')).toBeTruthy();
+    // 两栏评价都是空态：没有错误块、没有重试、没有评分加载失败。
+    expect(screen.getAllByText('暂无评价')).toHaveLength(2);
+    expect(screen.queryByText('评分加载失败')).toBeNull();
+    expect(screen.queryByText('评分加载中…')).toBeNull();
+    expect(screen.queryByRole('button', { name: '重试' })).toBeNull();
+    expect(screen.queryByRole('textbox')).toBeNull();
+    // 代码级门禁：非公开作品一个评价/评分请求都不发。
+    expect(listGameReviewsMock).not.toHaveBeenCalled();
+    expect(getMyGameReviewMock).not.toHaveBeenCalled();
+  });
+
+  it('还没有提交过版本的非公开作品封面显示未公开', async () => {
+    getMyGameMock.mockResolvedValue(
+      createOwnerGame({ latestVersion: null, versions: [] }),
+    );
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    await screen.findByText('还没有提交过版本');
+    expect(
+      within(
+        document.querySelector('.game-detail-cover') as HTMLElement,
+      ).getByText('未公开'),
+    ).toBeTruthy();
+    expect(screen.queryByText('评分加载失败')).toBeNull();
+    expect(listGameReviewsMock).not.toHaveBeenCalled();
+    expect(getMyGameReviewMock).not.toHaveBeenCalled();
+  });
+
+  it.each<[string, GameDistributionVersionStatus | null, string]>([
+    ['unpublished', null, '未公开'],
+    ['unpublished', 'awaiting_upload', '未公开'],
+    ['unpublished', 'pending_review', '审核中'],
+    ['unpublished', 'rejected', '审核未通过'],
+    ['suspended', 'pending_review', '审核中'],
+    ['suspended', null, '已被封禁'],
+  ])('封面文案 %s + %s -> %s', (gameStatus, versionStatus, expected) => {
+    expect(resolveNonPublicCoverLabel(gameStatus, versionStatus)).toBe(
+      expected,
+    );
+  });
+
+  it('审核未通过的作品封面用更准确的驳回文案', async () => {
+    const rejected: GameDistributionVersionStatusEntry = {
+      ...reviewVersion,
+      status: 'rejected',
+    };
+    getMyGameMock.mockResolvedValue(
+      createOwnerGame({ latestVersion: rejected, versions: [rejected] }),
+    );
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    await screen.findByText('作品状态');
+    expect(
+      within(
+        document.querySelector('.game-detail-cover') as HTMLElement,
+      ).getByText('审核未通过'),
+    ).toBeTruthy();
+    expect(screen.queryByText('评分加载失败')).toBeNull();
+  });
+
+  it('以已发布版本作为在线版本，并为未完成版本回读下一步动作', async () => {
+    getMyGameMock.mockResolvedValue(
+      createOwnerGame({
+        status: 'published',
+        versions: [reviewVersion, publishedVersion],
+      }),
+    );
+    loadVersionRecoveryActionsMock.mockResolvedValue({ 'version-2': 'wait' });
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    expect(await screen.findByText('下一步：等待审核结果')).toBeTruthy();
+    expect(loadVersionRecoveryActionsMock).toHaveBeenCalledWith(['version-2']);
+    expect(within(screen.getByRole('list')).getByText('v1')).toBeTruthy();
+    // 已公开作品照旧请求评价与评分，门禁只作用于非公开作品。
+    await waitFor(() =>
+      expect(listGameReviewsMock).toHaveBeenCalledWith('game-1', 1),
+    );
+    expect(getMyGameReviewMock).toHaveBeenCalledWith('game-1');
+    const playButton = screen.getByRole('button', { name: /立即玩/u });
+    expect((playButton as HTMLButtonElement).disabled).toBe(false);
+  });
+
+  it('作者读不到自己名下作品时按找不到处理', async () => {
+    getMyGameMock.mockResolvedValue(null);
+
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        ownerView
+      />,
+    );
+
+    expect(await screen.findByText('找不到这款游戏')).toBeTruthy();
+  });
+});
+
 describe('GamePlayPage', () => {
   it('waits for an explicit start before mounting the sandbox iframe', async () => {
     render(<GamePlayPage gameId="game-1" onBack={vi.fn()} />);
@@ -567,9 +796,7 @@ describe('游戏封面与截图展示', () => {
 
     await screen.findByRole('heading', { name: '星轨防线' });
     const heroImage = () =>
-      document
-        .querySelector('.game-detail-showcase img.game-cover__image')
-        ?.getAttribute('src');
+      document.querySelector('.game-detail-cover img')?.getAttribute('src');
     expect(heroImage()).toBe(
       'https://assets.example.test/game-distribution/cover/alpha.png',
     );
@@ -613,7 +840,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/GamePublishMediaFieldset.tsx b/src/components/game-distribution/GamePublishMediaFieldset.tsx
new file mode 100644
index 000000000..f929512fb
--- /dev/null
+++ b/src/components/game-distribution/GamePublishMediaFieldset.tsx
@@ -0,0 +1,234 @@
+import { useRef, useState } from 'react';
+
+import {
+  GAME_PUBLISH_IMAGE_ACCEPT,
+  type GamePublishImageAsset,
+  MAX_GAME_SCREENSHOTS,
+  uploadGamePublishImageAsset,
+} from './gamePublishAssets';
+
+type GamePublishMediaFieldsetProps = {
+  cover: GamePublishImageAsset | null;
+  screenshots: GamePublishImageAsset[];
+  /** 提交流程进行中时禁止换图；上传中的禁用由组件自己叠加。 */
+  disabled?: boolean;
+  /**
+   * 线上封面没有可复用素材 ID 时的提示。
+   *
+   * 发布与资料编辑对“为什么必须重选”的说法不同，其余文案共用。
+   */
+  missingCoverHint: string;
+  onCoverChange: (asset: GamePublishImageAsset | null) => void;
+  onScreenshotsChange: (assets: GamePublishImageAsset[]) => void;
+  onError: (message: string) => void;
+  /** 上传进行中状态；调用方用它禁用提交。 */
+  onUploadingChange: (uploading: boolean) => void;
+};
+
+/**
+ * 封面与截图选择区。
+ *
+ * 发布游戏与「作品资料编辑」共用同一份选图、上传与移除交互：两处都只需要素材 ID，
+ * 本地只负责把文件先传成平台素材再交给服务端冻结/保存。
+ */
+export function GamePublishMediaFieldset({
+  cover,
+  screenshots,
+  disabled = false,
+  missingCoverHint,
+  onCoverChange,
+  onScreenshotsChange,
+  onError,
+  onUploadingChange,
+}: GamePublishMediaFieldsetProps) {
+  const coverInputRef = useRef<HTMLInputElement>(null);
+  const screenshotInputRef = useRef<HTMLInputElement>(null);
+  const [isUploading, setIsUploading] = useState(false);
+  const fieldDisabled = disabled || isUploading;
+
+  async function handleCoverSelected(file: File | null) {
+    if (!file) return;
+    onError('');
+    setIsUploading(true);
+    onUploadingChange(true);
+    try {
+      const uploaded = await uploadGamePublishImageAsset(file, {
+        kind: 'cover',
+      });
+      onCoverChange(uploaded);
+    } catch (uploadError: unknown) {
+      onError(
+        uploadError instanceof Error
+          ? uploadError.message
+          : '封面上传失败，请重试',
+      );
+    } finally {
+      setIsUploading(false);
+      onUploadingChange(false);
+      // 清空 input 才能让作者重新选择同一张图。
+      if (coverInputRef.current) coverInputRef.current.value = '';
+    }
+  }
+
+  async function handleScreenshotsSelected(files: File[]) {
+    if (files.length === 0) return;
+    const remaining = MAX_GAME_SCREENSHOTS - screenshots.length;
+    if (files.length > remaining) {
+      onError(
+        remaining > 0
+          ? `游戏截图最多 6 张，还可以再选 ${remaining} 张`
+          : '游戏截图最多 6 张',
+      );
+      if (screenshotInputRef.current) screenshotInputRef.current.value = '';
+      return;
+    }
+    onError('');
+    setIsUploading(true);
+    onUploadingChange(true);
+    try {
+      // 逐张入库：中途失败时已经传好的截图仍然保留，作者不用重新选择。
+      let nextScreenshots = [...screenshots];
+      for (const file of files) {
+        const uploaded = await uploadGamePublishImageAsset(file, {
+          kind: 'screenshot',
+        });
+        if (nextScreenshots.length >= MAX_GAME_SCREENSHOTS) continue;
+        nextScreenshots = [...nextScreenshots, uploaded];
+        onScreenshotsChange(nextScreenshots);
+      }
+    } catch (uploadError: unknown) {
+      onError(
+        uploadError instanceof Error
+          ? uploadError.message
+          : '截图上传失败，请重试',
+      );
+    } finally {
+      setIsUploading(false);
+      onUploadingChange(false);
+      if (screenshotInputRef.current) screenshotInputRef.current.value = '';
+    }
+  }
+
+  function removeScreenshot(index: number) {
+    onScreenshotsChange(
+      screenshots.filter((_, itemIndex) => itemIndex !== index),
+    );
+  }
+
+  return (
+    <fieldset className="game-publish-fieldset game-publish-media">
+      <legend>封面与截图</legend>
+      <div className="game-publish-media__cover">
+        <div className="game-publish-media__preview">
+          {cover?.src ? (
+            <img src={cover.src} alt="游戏封面预览" />
+          ) : (
+            <span className="game-publish-media__placeholder">
+              {cover ? '封面预览加载中' : '还没有封面'}
+            </span>
+          )}
+        </div>
+        <div className="game-publish-media__copy">
+          <label className="game-publish-field">
+            游戏封面（必需）
+            {/*
+              原生 file 控件在清空 value 后会显示“未选择任何文件”，与下方的“已选择”提示互相
+              矛盾；上传后必须清空 value 才能重选同一张图，所以这里改用自定义触发按钮。
+            */}
+            <span className="game-publish-media__picker">
+              <input
+                ref={coverInputRef}
+                type="file"
+                accept={GAME_PUBLISH_IMAGE_ACCEPT}
+                disabled={fieldDisabled}
+                onChange={(event) => {
+                  void handleCoverSelected(event.target.files?.[0] ?? null);
+                }}
+              />
+              <span className="game-publish-media__pick">
+                {cover ? '更换封面图片' : '选择封面图片'}
+              </span>
+            </span>
+            <span className="game-publish-hint">
+              {cover?.assetObjectId
+                ? `已选择「${cover.name}」；重新选择即可替换当前封面。`
+                : cover
+                  ? missingCoverHint
+                  : '封面会作为广场卡片与详情页首图，建议 16:9 的 JPG/PNG/WebP，最大 6MB。'}
+            </span>
+          </label>
+          {cover ? (
+            <button
+              type="button"
+              className="game-publish-media__remove"
+              disabled={fieldDisabled}
+              onClick={() => onCoverChange(null)}
+            >
+              移除封面
+            </button>
+          ) : null}
+        </div>
+      </div>
+      <div className="game-publish-media__screenshots">
+        <label className="game-publish-field">
+          {`游戏截图（可选，最多 ${MAX_GAME_SCREENSHOTS} 张）`}
+          <span className="game-publish-media__picker">
+            <input
+              ref={screenshotInputRef}
+              type="file"
+              accept={GAME_PUBLISH_IMAGE_ACCEPT}
+              multiple
+              disabled={
+                fieldDisabled || screenshots.length >= MAX_GAME_SCREENSHOTS
+              }
+              onChange={(event) => {
+                void handleScreenshotsSelected(
+                  Array.from(event.target.files ?? []),
+                );
+              }}
+            />
+            <span className="game-publish-media__pick">
+              {screenshots.length >= MAX_GAME_SCREENSHOTS
+                ? '截图已满 6 张'
+                : '添加截图'}
+            </span>
+          </span>
+          <span className="game-publish-hint">
+            截图会按选择顺序展示在详情页；不需要可以留空。
+          </span>
+        </label>
+        {screenshots.length > 0 ? (
+          <ul className="game-publish-media__strip">
+            {screenshots.map((asset, index) => (
+              <li
+                key={`${asset.assetObjectId || asset.objectKey}-${index}`}
+                className="game-publish-media__shot"
+              >
+                {asset.src ? (
+                  <img src={asset.src} alt={`截图 ${index + 1} 预览`} />
+                ) : (
+                  <span className="game-publish-media__placeholder">
+                    {`截图 ${index + 1}`}
+                  </span>
+                )}
+                <button
+                  type="button"
+                  className="game-publish-media__remove"
+                  disabled={fieldDisabled}
+                  onClick={() => removeScreenshot(index)}
+                >
+                  {`移除截图 ${index + 1}`}
+                </button>
+              </li>
+            ))}
+          </ul>
+        ) : null}
+      </div>
+      {isUploading ? (
+        <span className="game-publish-hint">正在上传图片，请稍候…</span>
+      ) : null}
+    </fieldset>
+  );
+}
+
+export default GamePublishMediaFieldset;
diff --git a/src/components/game-distribution/GamePublishPage.tsx b/src/components/game-distribution/GamePublishPage.tsx
index 43ff09833..61f61c793 100644
--- a/src/components/game-distribution/GamePublishPage.tsx
+++ b/src/components/game-distribution/GamePublishPage.tsx
@@ -6,7 +6,6 @@ import { useEffect, useRef, useState } from 'react';
 import type {
   GameDistributionCategory,
   GameDistributionDeviceSupport,
-  GameDistributionInputMode,
   GameDistributionOrientation,
   GameDistributionVersionDetail,
 } from '../../../packages/shared/src/contracts/gameDistribution';
@@ -23,12 +22,12 @@ import { useAuthUi } from '../auth/AuthUiContext';
 import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
 import {
-  GAME_PUBLISH_IMAGE_ACCEPT,
-  type GamePublishImageAsset,
-  MAX_GAME_SCREENSHOTS,
-  resolveGamePublishImagePreview,
-  uploadGamePublishImageAsset,
-} from './gamePublishAssets';
+  GAME_METADATA_CATEGORIES,
+  GAME_METADATA_ORIENTATIONS,
+  parseGameTagsInput,
+  resolveGameInputModes,
+} from './gameMetadataOptions';
+import { type GamePublishImageAsset } from './gamePublishAssets';
 import { GamePublishClientGuide } from './GamePublishClientGuide';
 import {
   clearPublishDraft,
@@ -37,28 +36,11 @@ import {
   resolvePublishDraftRecoveryCopy,
   writePublishDraft,
 } from './gamePublishDraft';
+import { applyVersionMediaDefaults } from './gamePublishMediaDefaults';
+import { GamePublishMediaFieldset } from './GamePublishMediaFieldset';
 import { resolvePublishMetadataError } from './gamePublishMetadata';
 import { prepareGamePackage } from './gameZipPackage';
 
-const CATEGORIES: GameDistributionCategory[] = [
-  '休闲',
-  '益智',
-  '动作',
-  '冒险',
-  '模拟',
-  '策略',
-  '其他',
-];
-
-const ORIENTATIONS: Array<{
-  value: GameDistributionOrientation;
-  label: string;
-}> = [
-  { value: 'responsive', label: '自适应' },
-  { value: 'landscape', label: '横屏' },
-  { value: 'portrait', label: '竖屏' },
-];
-
 type GamePublishPageProps = {
   onBack: () => void;
   onOpenMyGames: () => void;
@@ -83,81 +65,6 @@ function createPublishKey() {
   return `web-publish-${random}`;
 }
 
-type VersionMediaApplyTarget = {
-  setCover: (
-    updater: (
-      current: GamePublishImageAsset | null,
-    ) => GamePublishImageAsset | null,
-  ) => void;
-  setScreenshots: (
-    updater: (current: GamePublishImageAsset[]) => GamePublishImageAsset[],
-  ) => void;
-  isCancelled: () => boolean;
-};
-
-/**
- * 用版本冻结资料回填封面与截图。
- *
- * 快照缺失（或旧版本没存素材 ID）时只回填线上封面预览：此时创作者必须重新选择一次封面，
- * 因为服务端只接受素材 ID 作为冻结输入，前端不能凭对象键猜素材身份。
- */
-async function applyVersionMediaDefaults(
-  detail: GameDistributionVersionDetail,
-  apply: VersionMediaApplyTarget,
-) {
-  const frozen = detail.version.frozenMetadata ?? null;
-  const coverAssetId = frozen?.coverAssetId?.trim() ?? '';
-  const coverObjectKey =
-    frozen?.coverObjectKey?.trim() ?? detail.game.coverObjectKey?.trim() ?? '';
-  const coverName = detail.game.title.trim() || '当前封面';
-  const buildCover = (src: string): GamePublishImageAsset => ({
-    assetObjectId: coverAssetId,
-    objectKey: coverObjectKey,
-    src,
-    name: coverName,
-  });
-
-  const screenshots = (frozen?.screenshots ?? []).filter((screenshot) =>
-    Boolean(screenshot?.assetId?.trim()),
-  );
-  if (apply.isCancelled()) return;
-  apply.setCover(() =>
-    coverAssetId || coverObjectKey ? buildCover('') : null,
-  );
-  apply.setScreenshots(() =>
-    screenshots.map((screenshot, index) => ({
-      assetObjectId: screenshot.assetId.trim(),
-      objectKey: screenshot.objectKey?.trim() ?? '',
-      src: '',
-      name: `截图 ${index + 1}`,
-    })),
-  );
-
-  const coverPreview = await resolveGamePublishImagePreview(coverObjectKey);
-  if (apply.isCancelled()) return;
-  if (coverPreview) {
-    // 只在作者还没换图、且预览仍为空时补上签名地址，避免覆盖作者的新选择。
-    apply.setCover((current) =>
-      current && !current.src && current.objectKey === coverObjectKey
-        ? { ...current, src: coverPreview }
-        : current,
-    );
-  }
-  for (const [index, screenshot] of screenshots.entries()) {
-    const preview = await resolveGamePublishImagePreview(
-      screenshot.objectKey ?? '',
-    );
-    if (apply.isCancelled() || !preview) continue;
-    apply.setScreenshots((current) =>
-      current.map((item, itemIndex) =>
-        itemIndex === index && item.assetObjectId === screenshot.assetId
-          ? { ...item, src: preview }
-          : item,
-      ),
-    );
-  }
-}
-
 export function GamePublishPage({
   onBack,
   onOpenMyGames,
@@ -165,8 +72,6 @@ export function GamePublishPage({
 }: GamePublishPageProps) {
   const authUi = useAuthUi();
   const fileInputRef = useRef<HTMLInputElement>(null);
-  const coverInputRef = useRef<HTMLInputElement>(null);
-  const screenshotInputRef = useRef<HTMLInputElement>(null);
   const [title, setTitle] = useState('');
   const [summary, setSummary] = useState('');
   const [description, setDescription] = useState('');
@@ -344,72 +249,6 @@ export function GamePublishPage({
     draftDetail !== null &&
     draftDetail.version.recoveryAction !== 'submit';
 
-  async function handleCoverSelected(file: File | null) {
-    if (!file) return;
-    setError('');
-    setIsUploadingAsset(true);
-    try {
-      const uploaded = await uploadGamePublishImageAsset(file, {
-        kind: 'cover',
-      });
-      setCoverAsset(uploaded);
-    } catch (uploadError: unknown) {
-      setError(
-        uploadError instanceof Error
-          ? uploadError.message
-          : '封面上传失败，请重试',
-      );
-    } finally {
-      setIsUploadingAsset(false);
-      // 清空 input 才能让作者重新选择同一张图。
-      if (coverInputRef.current) coverInputRef.current.value = '';
-    }
-  }
-
-  async function handleScreenshotsSelected(files: File[]) {
-    if (files.length === 0) return;
-    const remaining = MAX_GAME_SCREENSHOTS - screenshotAssets.length;
-    if (files.length > remaining) {
-      setError(
-        remaining > 0
-          ? `游戏截图最多 6 张，还可以再选 ${remaining} 张`
-          : '游戏截图最多 6 张',
-      );
-      if (screenshotInputRef.current) screenshotInputRef.current.value = '';
-      return;
-    }
-    setError('');
-    setIsUploadingAsset(true);
-    try {
-      for (const file of files) {
-        const uploaded = await uploadGamePublishImageAsset(file, {
-          kind: 'screenshot',
-        });
-        // 逐张入库：中途失败时已经传好的截图仍然保留，作者不用重新选择。
-        setScreenshotAssets((current) =>
-          current.length >= MAX_GAME_SCREENSHOTS
-            ? current
-            : [...current, uploaded],
-        );
-      }
-    } catch (uploadError: unknown) {
-      setError(
-        uploadError instanceof Error
-          ? uploadError.message
-          : '截图上传失败，请重试',
-      );
-    } finally {
-      setIsUploadingAsset(false);
-      if (screenshotInputRef.current) screenshotInputRef.current.value = '';
-    }
-  }
-
-  function removeScreenshotAsset(index: number) {
-    setScreenshotAssets((current) =>
-      current.filter((_, itemIndex) => itemIndex !== index),
-    );
-  }
-
   /** 展示中的线上封面没有素材 ID 时无法冻结进新版本，必须先本地拦一次并说明原因。 */
   function resolveMediaSubmitError() {
     if (coverAsset && !coverAsset.assetObjectId.trim()) {
@@ -507,13 +346,8 @@ export function GamePublishPage({
     try {
       const prepared = await prepareGamePackage(packageFile);
       const updateKey = resolvePublishKey();
-      const inputModes: GameDistributionInputMode[] = ['keyboard', 'mouse'];
-      if (deviceSupport.touch) inputModes.push('touch');
-      const tags = tagsInput
-        .split(/[,，]/u)
-        .map((tag) => tag.trim())
-        .filter(Boolean)
-        .slice(0, 5);
+      const inputModes = resolveGameInputModes(deviceSupport);
+      const tags = parseGameTagsInput(tagsInput);
       const gameMetadata = {
         title: title.trim(),
         summary: summary.trim(),
@@ -601,13 +435,8 @@ export function GamePublishPage({
     setError('');
     try {
       const prepared = await prepareGamePackage(packageFile);
-      const inputModes: GameDistributionInputMode[] = ['keyboard', 'mouse'];
-      if (deviceSupport.touch) inputModes.push('touch');
-      const tags = tagsInput
-        .split(/[,，]/u)
-        .map((tag) => tag.trim())
-        .filter(Boolean)
-        .slice(0, 5);
+      const inputModes = resolveGameInputModes(deviceSupport);
+      const tags = parseGameTagsInput(tagsInput);
       const gameMetadata = {
         title: title.trim(),
         summary: summary.trim(),
@@ -882,7 +711,7 @@ export function GamePublishPage({
                 setCategory(e.target.value as GameDistributionCategory)
               }
             >
-              {CATEGORIES.map((item) => (
+              {GAME_METADATA_CATEGORIES.map((item) => (
                 <option key={item} value={item}>
                   {item}
                 </option>
@@ -907,7 +736,7 @@ export function GamePublishPage({
                 setOrientation(e.target.value as GameDistributionOrientation)
               }
             >
-              {ORIENTATIONS.map((item) => (
+              {GAME_METADATA_ORIENTATIONS.map((item) => (
                 <option key={item.value} value={item.value}>
                   {item.label}
                 </option>
@@ -940,125 +769,16 @@ export function GamePublishPage({
             </label>
           ))}
         </fieldset>
-        <fieldset className="game-publish-fieldset game-publish-media">
-          <legend>封面与截图</legend>
-          <div className="game-publish-media__cover">
-            <div className="game-publish-media__preview">
-              {coverAsset?.src ? (
-                <img src={coverAsset.src} alt="游戏封面预览" />
-              ) : (
-                <span className="game-publish-media__placeholder">
-                  {coverAsset ? '封面预览加载中' : '还没有封面'}
-                </span>
-              )}
-            </div>
-            <div className="game-publish-media__copy">
-              <label className="game-publish-field">
-                游戏封面（必需）
-                {/*
-                  原生 file 控件在清空 value 后会显示“未选择任何文件”，与下方的“已选择”提示互相
-                  矛盾；上传后必须清空 value 才能重选同一张图，所以这里改用自定义触发按钮。
-                */}
-                <span className="game-publish-media__picker">
-                  <input
-                    ref={coverInputRef}
-                    type="file"
-                    accept={GAME_PUBLISH_IMAGE_ACCEPT}
-                    disabled={
-                      isResumingDraft || isSubmitting || isUploadingAsset
-                    }
-                    onChange={(event) => {
-                      void handleCoverSelected(event.target.files?.[0] ?? null);
-                    }}
-                  />
-                  <span className="game-publish-media__pick">
-                    {coverAsset ? '更换封面图片' : '选择封面图片'}
-                  </span>
-                </span>
-                <span className="game-publish-hint">
-                  {coverAsset?.assetObjectId
-                    ? `已选择「${coverAsset.name}」；重新选择即可替换本次发布的封面。`
-                    : coverAsset
-                      ? '本次发布需要重新选择一次封面图片，才能沿用这张线上封面。'
-                      : '封面会作为广场卡片与详情页首图，建议 16:9 的 JPG/PNG/WebP，最大 6MB。'}
-                </span>
-              </label>
-              {coverAsset ? (
-                <button
-                  type="button"
-                  className="game-publish-media__remove"
-                  disabled={isResumingDraft || isSubmitting || isUploadingAsset}
-                  onClick={() => setCoverAsset(null)}
-                >
-                  移除封面
-                </button>
-              ) : null}
-            </div>
-          </div>
-          <div className="game-publish-media__screenshots">
-            <label className="game-publish-field">
-              {`游戏截图（可选，最多 ${MAX_GAME_SCREENSHOTS} 张）`}
-              <span className="game-publish-media__picker">
-                <input
-                  ref={screenshotInputRef}
-                  type="file"
-                  accept={GAME_PUBLISH_IMAGE_ACCEPT}
-                  multiple
-                  disabled={
-                    isResumingDraft ||
-                    isSubmitting ||
-                    isUploadingAsset ||
-                    screenshotAssets.length >= MAX_GAME_SCREENSHOTS
-                  }
-                  onChange={(event) => {
-                    void handleScreenshotsSelected(
-                      Array.from(event.target.files ?? []),
-                    );
-                  }}
-                />
-                <span className="game-publish-media__pick">
-                  {screenshotAssets.length >= MAX_GAME_SCREENSHOTS
-                    ? '截图已满 6 张'
-                    : '添加截图'}
-                </span>
-              </span>
-              <span className="game-publish-hint">
-                截图会按选择顺序展示在详情页；不需要可以留空。
-              </span>
-            </label>
-            {screenshotAssets.length > 0 ? (
-              <ul className="game-publish-media__strip">
-                {screenshotAssets.map((asset, index) => (
-                  <li
-                    key={`${asset.assetObjectId || asset.objectKey}-${index}`}
-                    className="game-publish-media__shot"
-                  >
-                    {asset.src ? (
-                      <img src={asset.src} alt={`截图 ${index + 1} 预览`} />
-                    ) : (
-                      <span className="game-publish-media__placeholder">
-                        {`截图 ${index + 1}`}
-                      </span>
-                    )}
-                    <button
-                      type="button"
-                      className="game-publish-media__remove"
-                      disabled={
-                        isResumingDraft || isSubmitting || isUploadingAsset
-                      }
-                      onClick={() => removeScreenshotAsset(index)}
-                    >
-                      {`移除截图 ${index + 1}`}
-                    </button>
-                  </li>
-                ))}
-              </ul>
-            ) : null}
-          </div>
-          {isUploadingAsset ? (
-            <span className="game-publish-hint">正在上传图片，请稍候…</span>
-          ) : null}
-        </fieldset>
+        <GamePublishMediaFieldset
+          cover={coverAsset}
+          screenshots={screenshotAssets}
+          disabled={isResumingDraft || isSubmitting}
+          missingCoverHint="本次发布需要重新选择一次封面图片，才能沿用这张线上封面。"
+          onCoverChange={setCoverAsset}
+          onScreenshotsChange={setScreenshotAssets}
+          onError={setError}
+          onUploadingChange={setIsUploadingAsset}
+        />
         <label className="game-publish-field">
           {resumeNeedsPackage ? '重新选择发行包 ZIP' : '发行包 ZIP'}
           <input
diff --git a/src/components/game-distribution/GameReviews.test.tsx b/src/components/game-distribution/GameReviews.test.tsx
index c7f54963f..98ce40718 100644
--- a/src/components/game-distribution/GameReviews.test.tsx
+++ b/src/components/game-distribution/GameReviews.test.tsx
@@ -84,9 +84,16 @@ function deferred<T>() {
   });
   return { promise, resolve, reject };
 }
-function Harness() {
-  const state = useGameReviews('game-1', true);
-  return <GameReviews state={state} canReview onLogin={mocks.login} />;
+function Harness({ publiclyVisible = true }: { publiclyVisible?: boolean }) {
+  const state = useGameReviews('game-1', true, publiclyVisible);
+  return (
+    <GameReviews
+      state={state}
+      canReview
+      onLogin={mocks.login}
+      publiclyVisible={publiclyVisible}
+    />
+  );
 }
 async function form() {
   return screen.findByRole('textbox', { name: '评论（可选）' });
@@ -280,6 +287,21 @@ describe('游戏评价', () => {
     await screen.findByText('暂无评分');
   });
 
+  it('非公开作品不请求评价与评分接口，两栏直接是暂无评价', async () => {
+    render(<Harness publiclyVisible={false} />);
+
+    await screen.findByText('全部评价');
+    expect(screen.getAllByText('暂无评价')).toHaveLength(2);
+    expect(screen.queryByText('评分加载中…')).toBeNull();
+    expect(screen.queryByText('评分加载失败')).toBeNull();
+    expect(screen.queryByRole('button', { name: '重试' })).toBeNull();
+    expect(screen.queryByRole('button', { name: '登录后评价' })).toBeNull();
+    expect(screen.queryByText('正在加载我的评价…')).toBeNull();
+    expect(screen.queryByRole('textbox')).toBeNull();
+    expect(mocks.list).not.toHaveBeenCalled();
+    expect(mocks.mine).not.toHaveBeenCalled();
+  });
+
   it('服务端分页保留总数，修改保留当前页、首次提交回第一页', async () => {
     mocks.mine.mockResolvedValue({ review: review() });
     mocks.list.mockImplementation(async (_id, page) =>
diff --git a/src/components/game-distribution/GameReviews.tsx b/src/components/game-distribution/GameReviews.tsx
index 34e11723d..00d215f7c 100644
--- a/src/components/game-distribution/GameReviews.tsx
+++ b/src/components/game-distribution/GameReviews.tsx
@@ -107,10 +107,16 @@ export function GameReviews({
   state,
   canReview,
   onLogin,
+  publiclyVisible,
 }: {
   state: ReviewsState;
   canReview: boolean;
   onLogin: () => void;
+  /**
+   * 作品是否已公开。非公开作品没有公开评价投影，两栏一律按空态展示，
+   * 不出现错误块、重试按钮或评分加载失败。
+   */
+  publiclyVisible: boolean;
 }) {
   const length = reviewCommentLength(state.comment);
   const tooLong = length > GAME_REVIEW_COMMENT_LIMIT;
@@ -119,7 +125,9 @@ export function GameReviews({
     <section className="game-reviews" aria-label="游戏评价">
       <div className="game-reviews__personal">
         <h2>我的评价</h2>
-        {!canReview ? (
+        {!publiclyVisible ? (
+          <PlatformEmptyState>暂无评价</PlatformEmptyState>
+        ) : !canReview ? (
           <PlatformActionButton tone="secondary" onClick={onLogin}>
             登录后评价
           </PlatformActionButton>
@@ -218,9 +226,11 @@ export function GameReviews({
       <div className="game-reviews__public">
         <div className="game-reviews__heading">
           <h2>全部评价</h2>
-          <GameRatingSummary state={state} />
+          {publiclyVisible ? <GameRatingSummary state={state} /> : null}
         </div>
-        {state.listLoading ? (
+        {!publiclyVisible ? (
+          <PlatformEmptyState>暂无评价</PlatformEmptyState>
+        ) : state.listLoading ? (
           <p role="status">正在加载评价…</p>
         ) : state.listError ? (
           <ReviewError
@@ -236,27 +246,31 @@ export function GameReviews({
         ) : (
           <PlatformEmptyState>暂无评价</PlatformEmptyState>
         )}
-        <nav className="game-review-pagination" aria-label="评价分页">
-          <PlatformActionButton
-            tone="secondary"
-            size="sm"
-            disabled={state.page <= 1}
-            onClick={() => void state.loadPage(state.page - 1)}
-          >
-            上一页
-          </PlatformActionButton>
-          <span>
-            {totalPages === 0 ? '0 / 0 页' : `${state.page} / ${totalPages} 页`}
-          </span>
-          <PlatformActionButton
-            tone="secondary"
-            size="sm"
-            disabled={state.page >= totalPages}
-            onClick={() => void state.loadPage(state.page + 1)}
-          >
-            下一页
-          </PlatformActionButton>
-        </nav>
+        {publiclyVisible ? (
+          <nav className="game-review-pagination" aria-label="评价分页">
+            <PlatformActionButton
+              tone="secondary"
+              size="sm"
+              disabled={state.page <= 1}
+              onClick={() => void state.loadPage(state.page - 1)}
+            >
+              上一页
+            </PlatformActionButton>
+            <span>
+              {totalPages === 0
+                ? '0 / 0 页'
+                : `${state.page} / ${totalPages} 页`}
+            </span>
+            <PlatformActionButton
+              tone="secondary"
+              size="sm"
+              disabled={state.page >= totalPages}
+              onClick={() => void state.loadPage(state.page + 1)}
+            >
+              下一页
+            </PlatformActionButton>
+          </nav>
+        ) : null}
       </div>
     </section>
   );
diff --git a/src/components/game-distribution/GameVersionHistory.tsx b/src/components/game-distribution/GameVersionHistory.tsx
new file mode 100644
index 000000000..3c07ce6e9
--- /dev/null
+++ b/src/components/game-distribution/GameVersionHistory.tsx
@@ -0,0 +1,79 @@
+import type { GameDistributionRecoveryAction } from '../../../packages/shared/src/contracts/gameDistribution';
+import type { GameDistributionVersionStatusEntry } from '../../services/gameDistributionClient';
+import {
+  RECOVERY_ACTION_LABEL,
+  VERSION_STATUS_LABEL,
+} from './gameVersionHistoryModel';
+
+function formatVersionTime(value: string) {
+  const time = new Date(value);
+  if (Number.isNaN(time.getTime())) return '';
+  const pad = (part: number) => String(part).padStart(2, '0');
+  return `${time.getFullYear()}-${pad(time.getMonth() + 1)}-${pad(time.getDate())} ${pad(time.getHours())}:${pad(time.getMinutes())}`;
+}
+
+function formatPackageSize(bytes: number) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return '';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+type GameVersionHistoryProps = {
+  id?: string;
+  versions: readonly GameDistributionVersionStatusEntry[];
+  /** 版本回读补到的 `recoveryAction`；条目自带的优先。 */
+  recoveryActions?: Record<string, GameDistributionRecoveryAction>;
+};
+
+/**
+ * 版本历史：逐条列出不可变版本的私有状态、体积与驳回理由。
+ *
+ * 只读列表，撤回/删除等动作仍留在卡片与详情页的行内操作上，避免同一个动作在两处出现。
+ */
+export function GameVersionHistory({
+  id,
+  versions,
+  recoveryActions = {},
+}: GameVersionHistoryProps) {
+  return (
+    <ul id={id} className="game-version-list">
+      {versions.map((version) => {
+        const reason = version.reviewReason?.trim() ?? '';
+        const recoveryAction =
+          version.recoveryAction ?? recoveryActions[version.versionId] ?? null;
+        const size = formatPackageSize(version.packageBytes);
+        const time = formatVersionTime(version.updatedAt);
+        return (
+          <li key={version.versionId} className="game-version-list__item">
+            <div className="game-version-list__heading">
+              <strong>v{version.versionNumber}</strong>
+              <span
+                className={`game-version-status game-version-status--${version.status}`}
+              >
+                {VERSION_STATUS_LABEL[version.status] ?? version.status}
+              </span>
+            </div>
+            {time || size ? (
+              <div className="game-version-list__meta">
+                {time ? <span>更新于 {time}</span> : null}
+                {size ? <span>包体积 {size}</span> : null}
+              </div>
+            ) : null}
+            {reason ? (
+              <p className="game-version-list__reason">驳回理由：{reason}</p>
+            ) : null}
+            {recoveryAction && recoveryAction !== 'none' ? (
+              <p className="game-version-list__action">
+                下一步：
+                {RECOVERY_ACTION_LABEL[recoveryAction] ?? recoveryAction}
+              </p>
+            ) : null}
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
+
+export default GameVersionHistory;
diff --git a/src/components/game-distribution/GameWorkMetadataEditor.tsx b/src/components/game-distribution/GameWorkMetadataEditor.tsx
new file mode 100644
index 000000000..f8c618b07
--- /dev/null
+++ b/src/components/game-distribution/GameWorkMetadataEditor.tsx
@@ -0,0 +1,337 @@
+import './gameDistribution.css';
+
+import { useEffect, useRef, useState } from 'react';
+
+import type {
+  GameDistributionCategory,
+  GameDistributionDeviceSupport,
+  GameDistributionOrientation,
+  GameDistributionUpdateGameMetadataRequest,
+} from '../../../packages/shared/src/contracts/gameDistribution';
+import {
+  type GameDistributionMyGame,
+  type GameDistributionUpdateMyGameResponse,
+  getGameVersion,
+  updateMyGame,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { UnifiedModal } from '../common/UnifiedModal';
+import {
+  GAME_METADATA_CATEGORIES,
+  GAME_METADATA_ORIENTATIONS,
+  parseGameTagsInput,
+  resolveGameInputModes,
+} from './gameMetadataOptions';
+import { type GamePublishImageAsset } from './gamePublishAssets';
+import { applyVersionMediaDefaults } from './gamePublishMediaDefaults';
+import { GamePublishMediaFieldset } from './GamePublishMediaFieldset';
+import { resolvePublishMetadataError } from './gamePublishMetadata';
+
+const DEVICE_OPTIONS = [
+  ['desktop', '桌面端'],
+  ['mobile', '移动端'],
+  ['touch', '触控'],
+] as const;
+
+const MISSING_COVER_ASSET_HINT =
+  '这次编辑需要重新选择一次封面图片，才能保留这张线上封面。';
+
+let metadataKeySeed = 0;
+function createMetadataKey(gameId: string) {
+  metadataKeySeed += 1;
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${metadataKeySeed}`;
+  return `game-metadata-${gameId}-${random}`;
+}
+
+type GameWorkMetadataEditorProps = {
+  game: GameDistributionMyGame;
+  onClose: () => void;
+  /** 保存成功回传服务端最新投影；调用方用它刷新列表里的这一行。 */
+  onSaved: (response: GameDistributionUpdateMyGameResponse) => void;
+};
+
+/**
+ * 作品资料编辑。
+ *
+ * 只改 `game` 级展示资料（标题/简介/分类/标签/设备/封面/截图），立即对公开目录与详情
+ * 生效；发行包与随包冻结的资料仍走「发布新版本」。
+ *
+ * 服务端复用创建游戏的资料校验，所以封面与截图必须带素材 ID：打开时先按最新版本的
+ * 冻结资料回填素材（含签名预览），旧版本没存素材 ID 时要求作者重新选一次封面。
+ * 调用方按作品挂载本组件（key=gameId），表单初值只取一次，不需要额外的重置逻辑。
+ */
+export function GameWorkMetadataEditor({
+  game,
+  onClose,
+  onSaved,
+}: GameWorkMetadataEditorProps) {
+  const [title, setTitle] = useState(game.title);
+  const [summary, setSummary] = useState(game.summary);
+  const [description, setDescription] = useState(game.description);
+  const [category, setCategory] = useState<GameDistributionCategory>(
+    game.category,
+  );
+  const [tagsInput, setTagsInput] = useState((game.tags ?? []).join('，'));
+  const [deviceSupport, setDeviceSupport] =
+    useState<GameDistributionDeviceSupport>({
+      ...game.deviceSupport,
+    });
+  const [orientation, setOrientation] = useState<GameDistributionOrientation>(
+    game.orientation ?? 'responsive',
+  );
+  const [coverAsset, setCoverAsset] = useState<GamePublishImageAsset | null>(
+    null,
+  );
+  const [screenshotAssets, setScreenshotAssets] = useState<
+    GamePublishImageAsset[]
+  >([]);
+  const [isLoadingMedia, setIsLoadingMedia] = useState(
+    Boolean(game.latestVersion),
+  );
+  const [isUploadingAsset, setIsUploadingAsset] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState('');
+  /**
+   * 同一次编辑（含失败重试）复用同一个幂等键：服务端按 key 重放，不会因为双击或
+   * 网络重试写出两份审计记录。
+   */
+  const saveKeyRef = useRef<string | null>(null);
+  const latestVersionId = game.latestVersion?.versionId ?? '';
+
+  useEffect(() => {
+    if (!latestVersionId) {
+      setIsLoadingMedia(false);
+      return;
+    }
+    let cancelled = false;
+    setIsLoadingMedia(true);
+    getGameVersion(latestVersionId)
+      .then((detail) => {
+        if (cancelled) return;
+        return applyVersionMediaDefaults(detail, {
+          setCover: setCoverAsset,
+          setScreenshots: setScreenshotAssets,
+          isCancelled: () => cancelled,
+        });
+      })
+      .catch(() => {
+        // 读不到冻结资料只影响默认素材：作者仍可以自己选一次封面再保存。
+        if (cancelled) return;
+        setCoverAsset(null);
+        setScreenshotAssets([]);
+      })
+      .finally(() => {
+        if (!cancelled) setIsLoadingMedia(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [latestVersionId]);
+
+  /** 封面是服务端必填项：线上封面没有素材 ID 时必须重新选一次，不能凭对象键猜身份。 */
+  function resolveMediaSubmitError() {
+    if (!coverAsset) return '作品必须提供封面图片';
+    if (!coverAsset.assetObjectId.trim()) return MISSING_COVER_ASSET_HINT;
+    return '';
+  }
+
+  async function handleSubmit() {
+    if (isSaving || isLoadingMedia) return;
+    const mediaError = resolveMediaSubmitError();
+    if (mediaError) {
+      setError(mediaError);
+      return;
+    }
+    const metadataError = resolvePublishMetadataError({
+      title,
+      summary,
+      deviceSupport,
+      coverAssetId: coverAsset?.assetObjectId,
+      screenshotCount: screenshotAssets.length,
+    });
+    if (metadataError) {
+      setError(metadataError);
+      return;
+    }
+    const saveKey = saveKeyRef.current ?? createMetadataKey(game.id);
+    saveKeyRef.current = saveKey;
+    const payload: GameDistributionUpdateGameMetadataRequest = {
+      expectedPublicationRevision: game.publicationRevision,
+      title: title.trim(),
+      summary: summary.trim(),
+      description: description.trim() || summary.trim(),
+      category,
+      tags: parseGameTagsInput(tagsInput),
+      coverAssetId: coverAsset?.assetObjectId.trim(),
+      screenshots: screenshotAssets.map((asset) => asset.assetObjectId.trim()),
+      deviceSupport,
+      inputModes: resolveGameInputModes(deviceSupport),
+      orientation,
+    };
+    setIsSaving(true);
+    setError('');
+    try {
+      onSaved(await updateMyGame(game.id, payload, saveKey));
+    } catch (saveError: unknown) {
+      setError(
+        saveError instanceof Error ? saveError.message : '保存作品资料失败',
+      );
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  return (
+    <UnifiedModal
+      open
+      title="编辑作品资料"
+      description="保存后立即对公开目录与详情生效；发行包内容仍随版本冻结，不受影响。"
+      size="md"
+      closeDisabled={isSaving}
+      onClose={onClose}
+      footer={
+        <>
+          <PlatformActionButton
+            tone="secondary"
+            size="sm"
+            shape="pill"
+            disabled={isSaving}
+            onClick={onClose}
+          >
+            取消
+          </PlatformActionButton>
+          <PlatformActionButton
+            type="button"
+            size="sm"
+            shape="pill"
+            disabled={isSaving || isLoadingMedia || isUploadingAsset}
+            onClick={() => void handleSubmit()}
+          >
+            {isSaving ? '正在保存…' : '保存资料'}
+          </PlatformActionButton>
+        </>
+      }
+    >
+      <form
+        className="game-work-editor"
+        onSubmit={(event) => {
+          event.preventDefault();
+          void handleSubmit();
+        }}
+      >
+        {error ? (
+          <PlatformStatusMessage tone="error" surface="platform">
+            {error}
+          </PlatformStatusMessage>
+        ) : null}
+        <label className="game-publish-field">
+          作品名称
+          <input
+            value={title}
+            maxLength={40}
+            onChange={(event) => setTitle(event.target.value)}
+          />
+        </label>
+        <label className="game-publish-field">
+          一句话简介
+          <input
+            value={summary}
+            maxLength={120}
+            onChange={(event) => setSummary(event.target.value)}
+          />
+        </label>
+        <label className="game-publish-field">
+          详细介绍
+          <textarea
+            value={description}
+            rows={4}
+            maxLength={2000}
+            onChange={(event) => setDescription(event.target.value)}
+          />
+        </label>
+        <div className="game-publish-row">
+          <label className="game-publish-field">
+            分类
+            <select
+              value={category}
+              onChange={(event) =>
+                setCategory(event.target.value as GameDistributionCategory)
+              }
+            >
+              {GAME_METADATA_CATEGORIES.map((item) => (
+                <option key={item} value={item}>
+                  {item}
+                </option>
+              ))}
+            </select>
+          </label>
+          <label className="game-publish-field">
+            标签
+            <input
+              value={tagsInput}
+              placeholder="用逗号分隔，最多 5 个"
+              onChange={(event) => setTagsInput(event.target.value)}
+            />
+          </label>
+          <label className="game-publish-field">
+            画面方向
+            <select
+              value={orientation}
+              onChange={(event) =>
+                setOrientation(
+                  event.target.value as GameDistributionOrientation,
+                )
+              }
+            >
+              {GAME_METADATA_ORIENTATIONS.map((item) => (
+                <option key={item.value} value={item.value}>
+                  {item.label}
+                </option>
+              ))}
+            </select>
+          </label>
+        </div>
+        <fieldset className="game-publish-fieldset">
+          <legend>支持设备</legend>
+          {DEVICE_OPTIONS.map(([key, label]) => (
+            <label key={key} className="game-publish-checkbox">
+              <input
+                type="checkbox"
+                checked={deviceSupport[key]}
+                onChange={(event) =>
+                  setDeviceSupport((current) => ({
+                    ...current,
+                    [key]: event.target.checked,
+                  }))
+                }
+              />
+              {label}
+            </label>
+          ))}
+          <span className="game-publish-hint">
+            键盘与鼠标按桌面端派生；选择移动端时必须支持触控。
+          </span>
+        </fieldset>
+        <GamePublishMediaFieldset
+          cover={coverAsset}
+          screenshots={screenshotAssets}
+          disabled={isSaving}
+          missingCoverHint={MISSING_COVER_ASSET_HINT}
+          onCoverChange={setCoverAsset}
+          onScreenshotsChange={setScreenshotAssets}
+          onError={setError}
+          onUploadingChange={setIsUploadingAsset}
+        />
+        {isLoadingMedia ? (
+          <span className="game-publish-hint">正在读取当前封面与截图…</span>
+        ) : null}
+      </form>
+    </UnifiedModal>
+  );
+}
+
+export default GameWorkMetadataEditor;
diff --git a/src/components/game-distribution/MyGamesPage.test.tsx b/src/components/game-distribution/MyGamesPage.test.tsx
index 3856613ff..3af54a224 100644
--- a/src/components/game-distribution/MyGamesPage.test.tsx
+++ b/src/components/game-distribution/MyGamesPage.test.tsx
@@ -1,23 +1,33 @@
 /* @vitest-environment jsdom */
 
 import { render, screen, waitFor } from '@testing-library/react';
-import { fireEvent } from '@testing-library/react';
+import { fireEvent, within } from '@testing-library/react';
 import type { ContextType } from 'react';
 import { beforeEach, expect, test, vi } from 'vitest';
 
 import {
   cancelGameVersion,
+  deleteMyGame,
   type GameDistributionMyGame,
+  getGameVersion,
   listMyGames,
+  loadVersionRecoveryActions,
+  submitGameVersion,
   unpublishGame,
+  updateMyGame,
 } from '../../services/gameDistributionClient';
 import { AuthUiContext } from '../auth/AuthUiContext';
 import { MyGamesPage } from './MyGamesPage';
 
 vi.mock('../../services/gameDistributionClient', () => ({
   cancelGameVersion: vi.fn(),
+  deleteMyGame: vi.fn(),
+  getGameVersion: vi.fn(),
   listMyGames: vi.fn(),
+  loadVersionRecoveryActions: vi.fn(),
+  submitGameVersion: vi.fn(),
   unpublishGame: vi.fn(),
+  updateMyGame: vi.fn(),
 }));
 
 type AuthValue = NonNullable<ContextType<typeof AuthUiContext>>;
@@ -71,13 +81,18 @@ function createGame(
     currentVersion: null,
     playCount: 3,
     createdAt: '2026-09-20T08:00:00Z',
+    latestVersion: null,
+    versions: [],
     ...overrides,
   } as GameDistributionMyGame;
 }
 
 function renderPage(
   authValue: AuthValue | null,
-  overrides: { onPublishVersion?: (gameId: string) => void } = {},
+  overrides: {
+    onPublishVersion?: (gameId: string) => void;
+    onResumePublish?: () => void;
+  } = {},
 ) {
   return render(
     <AuthUiContext.Provider value={authValue}>
@@ -85,6 +100,7 @@ function renderPage(
         onBack={vi.fn()}
         onOpenDetail={vi.fn()}
         onPublishVersion={overrides.onPublishVersion}
+        onResumePublish={overrides.onResumePublish}
       />
     </AuthUiContext.Provider>,
   );
@@ -92,9 +108,20 @@ function renderPage(
 
 beforeEach(() => {
   vi.mocked(cancelGameVersion).mockReset();
+  vi.mocked(deleteMyGame).mockReset();
+  vi.mocked(getGameVersion).mockReset();
   vi.mocked(listMyGames).mockReset();
+  vi.mocked(loadVersionRecoveryActions).mockReset();
+  vi.mocked(submitGameVersion).mockReset();
   vi.mocked(unpublishGame).mockReset();
+  vi.mocked(updateMyGame).mockReset();
   vi.mocked(listMyGames).mockResolvedValue([]);
+  vi.mocked(loadVersionRecoveryActions).mockResolvedValue({});
+  // 默认没有冻结素材：编辑弹窗打开时按“线上封面不可复用”处理，用例按需覆盖。
+  vi.mocked(getGameVersion).mockResolvedValue({
+    game: { coverObjectKey: null },
+    version: { frozenMetadata: null },
+  } as never);
 });
 
 test('未登录时提示登录且不请求作者接口', () => {
@@ -250,3 +277,316 @@ test('作者中心提供发布新版本入口并回传同一个 gameId', async (
 
   expect(onPublishVersion).toHaveBeenCalledWith('game-42');
 });
+
+test('按作品状态与版本状态筛选列表，并可重置筛选', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ id: 'game-live', title: '已上线作品', status: 'published' }),
+    createGame({
+      id: 'game-draft',
+      title: '待审作品',
+      status: 'unpublished',
+      latestVersion: {
+        versionId: 'version-draft',
+        gameId: 'game-draft',
+        versionNumber: 1,
+        packageSha256: 'd'.repeat(64),
+        packageBytes: 512,
+        status: 'pending_review',
+        publicationRevision: 2,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  await screen.findByText('已上线作品');
+  expect(screen.getByText('待审作品')).toBeTruthy();
+
+  fireEvent.change(screen.getByLabelText('版本状态'), {
+    target: { value: 'review' },
+  });
+  await waitFor(() => expect(screen.queryByText('已上线作品')).toBeNull());
+  expect(screen.getByText('待审作品')).toBeTruthy();
+
+  fireEvent.click(screen.getByRole('button', { name: '重置筛选' }));
+  expect(await screen.findByText('已上线作品')).toBeTruthy();
+
+  fireEvent.change(screen.getByLabelText('作品状态'), {
+    target: { value: 'published' },
+  });
+  await waitFor(() => expect(screen.queryByText('待审作品')).toBeNull());
+});
+
+test('展开版本历史展示每个版本的私有状态与驳回理由', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-history',
+      title: '多版本作品',
+      latestVersion: {
+        versionId: 'version-2',
+        gameId: 'game-history',
+        versionNumber: 2,
+        packageSha256: 'e'.repeat(64),
+        packageBytes: 2048,
+        status: 'rejected',
+        publicationRevision: 6,
+        reviewReason: '封面需要替换',
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+      versions: [
+        {
+          versionId: 'version-2',
+          gameId: 'game-history',
+          versionNumber: 2,
+          packageSha256: 'e'.repeat(64),
+          packageBytes: 2048,
+          status: 'rejected',
+          publicationRevision: 6,
+          reviewReason: '封面需要替换',
+          createdAt: '2026-09-20T08:00:00Z',
+          updatedAt: '2026-09-20T09:00:00Z',
+        },
+        {
+          versionId: 'version-1',
+          gameId: 'game-history',
+          versionNumber: 1,
+          packageSha256: 'f'.repeat(64),
+          packageBytes: 1024,
+          status: 'revoked',
+          publicationRevision: 5,
+          reviewReason: null,
+          createdAt: '2026-09-19T08:00:00Z',
+          updatedAt: '2026-09-19T09:00:00Z',
+        },
+      ],
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  await screen.findByText('多版本作品');
+  expect(screen.queryByText('包体积 2.0 KB')).toBeNull();
+
+  fireEvent.click(screen.getByRole('button', { name: /版本历史（2）/u }));
+
+  expect(await screen.findByText('包体积 2.0 KB')).toBeTruthy();
+  expect(screen.getByText('包体积 1.0 KB')).toBeTruthy();
+  expect(screen.getByText('v2')).toBeTruthy();
+  expect(screen.getByText('v1')).toBeTruthy();
+});
+
+test('服务端给出 submit 动作时行内直接提交审核', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-submit',
+      status: 'unpublished',
+      publicationRevision: 8,
+      latestVersion: {
+        versionId: 'version-8',
+        gameId: 'game-submit',
+        versionNumber: 3,
+        packageSha256: 'a'.repeat(64),
+        packageBytes: 4096,
+        status: 'uploaded',
+        publicationRevision: 8,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    }),
+  ]);
+  vi.mocked(loadVersionRecoveryActions).mockResolvedValue({
+    'version-8': 'submit',
+  });
+  vi.mocked(submitGameVersion).mockResolvedValue({});
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText('下一步：提交审核')).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: '提交审核' }));
+
+  await waitFor(() => expect(submitGameVersion).toHaveBeenCalledTimes(1));
+  const [versionId, revision, idempotencyKey] =
+    vi.mocked(submitGameVersion).mock.calls[0] ?? [];
+  expect(versionId).toBe('version-8');
+  expect(revision).toBe(8);
+  expect(String(idempotencyKey)).toContain('version-8');
+});
+
+test('本地草稿对应的未完成版本提供继续上传入口', async () => {
+  window.localStorage.setItem(
+    'genarrative.game-distribution.publish-draft.v1',
+    JSON.stringify({
+      ownerUserId: 'user-1',
+      gameId: 'game-draft',
+      versionId: 'version-draft',
+      versionNumber: 2,
+      title: '待续发作品',
+      updatedAt: '2026-09-20T09:00:00Z',
+    }),
+  );
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-draft',
+      title: '待续发作品',
+      latestVersion: {
+        versionId: 'version-draft',
+        gameId: 'game-draft',
+        versionNumber: 2,
+        packageSha256: 'b'.repeat(64),
+        packageBytes: 1024,
+        status: 'awaiting_upload',
+        publicationRevision: 3,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    }),
+  ]);
+  vi.mocked(loadVersionRecoveryActions).mockResolvedValue({
+    'version-draft': 'upload',
+  });
+  const onResumePublish = vi.fn();
+
+  renderPage(createAuthValue(), { onResumePublish });
+
+  fireEvent.click(await screen.findByRole('button', { name: '继续上传' }));
+
+  expect(onResumePublish).toHaveBeenCalledTimes(1);
+  window.localStorage.clear();
+});
+
+test('编辑资料走 PATCH owner 路由并带上当前修订号与封面素材', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-edit',
+      title: '旧标题',
+      status: 'published',
+      publicationRevision: 11,
+      latestVersion: {
+        versionId: 'version-edit',
+        gameId: 'game-edit',
+        versionNumber: 1,
+        packageSha256: 'b'.repeat(64),
+        packageBytes: 1024,
+        status: 'published',
+        publicationRevision: 11,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    }),
+  ]);
+  // 服务端只接受素材 ID，编辑前必须按最新版本的冻结资料回填封面。
+  vi.mocked(getGameVersion).mockResolvedValue({
+    game: { title: '旧标题', coverObjectKey: null },
+    version: {
+      versionId: 'version-edit',
+      publicationRevision: 11,
+      recoveryAction: 'none',
+      frozenMetadata: { coverAssetId: 'asset-cover-old' },
+    },
+  } as never);
+  vi.mocked(updateMyGame).mockResolvedValue({
+    game: createGame({
+      id: 'game-edit',
+      title: '新标题',
+      status: 'published',
+      publicationRevision: 12,
+    }),
+    replayed: false,
+  });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: '编辑资料' }));
+  const dialog = await screen.findByRole('dialog', { name: '编辑作品资料' });
+  await waitFor(() =>
+    expect(getGameVersion).toHaveBeenCalledWith('version-edit'),
+  );
+  // 封面素材按冻结资料回填完成后保存按钮才可用。
+  await waitFor(() =>
+    expect(within(dialog).queryByText('正在读取当前封面与截图…')).toBeNull(),
+  );
+  fireEvent.change(within(dialog).getByLabelText('作品名称'), {
+    target: { value: '新标题' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '保存资料' }));
+
+  await waitFor(() => expect(updateMyGame).toHaveBeenCalledTimes(1));
+  const [gameId, payload, idempotencyKey] =
+    vi.mocked(updateMyGame).mock.calls[0] ?? [];
+  expect(gameId).toBe('game-edit');
+  expect(payload?.expectedPublicationRevision).toBe(11);
+  expect(payload?.title).toBe('新标题');
+  expect(payload?.coverAssetId).toBe('asset-cover-old');
+  expect(String(idempotencyKey)).toContain('game-edit');
+  expect(await screen.findByText('新标题')).toBeTruthy();
+});
+
+test('线上封面不可复用时阻止保存并要求重新选图', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-legacy',
+      title: '旧作品',
+      status: 'unpublished',
+      latestVersion: {
+        versionId: 'version-legacy',
+        gameId: 'game-legacy',
+        versionNumber: 1,
+        packageSha256: 'c'.repeat(64),
+        packageBytes: 1024,
+        status: 'rejected',
+        publicationRevision: 2,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: '编辑资料' }));
+  const dialog = await screen.findByRole('dialog', { name: '编辑作品资料' });
+  // 默认冻结资料为空：没有可复用的封面素材，服务端会拒收，本地先拦一次。
+  await waitFor(() =>
+    expect(within(dialog).queryByText('正在读取当前封面与截图…')).toBeNull(),
+  );
+  fireEvent.click(within(dialog).getByRole('button', { name: '保存资料' }));
+
+  expect(await within(dialog).findByText('作品必须提供封面图片')).toBeTruthy();
+  expect(updateMyGame).not.toHaveBeenCalled();
+});
+
+test('删除作品需二次确认并带上当前修订号', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'game-delete',
+      title: '待删除作品',
+      status: 'unpublished',
+      publicationRevision: 9,
+    }),
+  ]);
+  vi.mocked(deleteMyGame).mockResolvedValue({ replayed: false });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: '删除作品' }));
+  const dialog = await screen.findByRole('dialog', { name: '删除作品' });
+  expect(deleteMyGame).not.toHaveBeenCalled();
+
+  fireEvent.click(within(dialog).getByRole('button', { name: '删除作品' }));
+
+  await waitFor(() => expect(deleteMyGame).toHaveBeenCalledTimes(1));
+  const [gameId, revision, idempotencyKey] =
+    vi.mocked(deleteMyGame).mock.calls[0] ?? [];
+  expect(gameId).toBe('game-delete');
+  expect(revision).toBe(9);
+  expect(String(idempotencyKey)).toContain('game-delete');
+  await waitFor(() => expect(listMyGames).toHaveBeenCalledTimes(2));
+});
diff --git a/src/components/game-distribution/MyGamesPage.tsx b/src/components/game-distribution/MyGamesPage.tsx
index afa8f7dac..d819e999a 100644
--- a/src/components/game-distribution/MyGamesPage.tsx
+++ b/src/components/game-distribution/MyGamesPage.tsx
@@ -1,45 +1,52 @@
 import './gameDistribution.css';
 
 import { ArrowLeft, RefreshCcw } from 'lucide-react';
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 
+import type { GameDistributionRecoveryAction } from '../../../packages/shared/src/contracts/gameDistribution';
 import {
   cancelGameVersion,
+  deleteMyGame,
   type GameDistributionMyGame,
+  type GameDistributionUpdateMyGameResponse,
   type GameDistributionVersionStatusEntry,
   listMyGames,
+  loadVersionRecoveryActions,
+  submitGameVersion,
   unpublishGame,
 } from '../../services/gameDistributionClient';
 import { useAuthUi } from '../auth/AuthUiContext';
 import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformDangerConfirmDialog } from '../common/PlatformDangerConfirmDialog';
 import { PlatformEmptyState } from '../common/PlatformEmptyState';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
 import { GameCover } from './GameGalleryPage';
-
-const STATUS_LABEL: Record<string, string> = {
-  unpublished: '未公开',
-  published: '已公开',
-  suspended: '已被封禁',
-};
-
-const VERSION_STATUS_LABEL: Record<string, string> = {
-  awaiting_upload: '待上传',
-  uploaded: '已上传',
-  validating: '校验中',
-  pending_review: '审核中',
-  published: '已发布',
-  upload_failed: '上传失败',
-  validation_failed: '校验失败',
-  rejected: '已拒绝',
-  cancelled: '已撤回',
-  revoked: '已撤回',
-};
+import {
+  type GamePublishDraft,
+  readPublishDraft,
+  resolvePublishDraftRecoveryCopy,
+} from './gamePublishDraft';
+import { GameVersionHistory } from './GameVersionHistory';
+import {
+  GAME_STATUS_LABEL,
+  RECOVERY_ACTION_LABEL,
+  VERSION_STATUS_LABEL,
+  VERSION_STATUS_NEEDS_AUTHOR_ACTION,
+} from './gameVersionHistoryModel';
+import { GameWorkMetadataEditor } from './GameWorkMetadataEditor';
 
 type MyGamesPageProps = {
   onBack: () => void;
   onOpenDetail: (gameId: string) => void;
   /** 进入发布页的“新版本”模式；回调缺失时不显示该动作。 */
   onPublishVersion?: (gameId: string) => void;
+  /** 打开发布页恢复本地未完成的发布草稿；缺失时不显示恢复入口。 */
+  onResumePublish?: () => void;
+  /**
+   * 游戏分发写入开关（灰度）。资料编辑与发布一样受服务端开关约束，关闭时不展示入口，
+   * 避免作者点了才吃 503；下架与删除不受开关约束，始终可用。
+   */
+  publishEnabled?: boolean;
 };
 
 let unpublishKeySeed = 0;
@@ -64,6 +71,61 @@ function createCancelKey(versionId: string) {
   return `game-cancel-${versionId}-${Date.now()}-${cancelKeySeed}`;
 }
 
+let submitKeySeed = 0;
+function createSubmitKey(versionId: string) {
+  submitKeySeed += 1;
+  return `game-submit-${versionId}-${Date.now()}-${submitKeySeed}`;
+}
+
+let deleteKeySeed = 0;
+function createDeleteKey(gameId: string) {
+  deleteKeySeed += 1;
+  return `game-delete-${gameId}-${Date.now()}-${deleteKeySeed}`;
+}
+
+export type MyGameStatusFilter =
+  | 'all'
+  | 'published'
+  | 'unpublished'
+  | 'suspended';
+
+export type MyGameVersionFilter =
+  | 'all'
+  | 'action'
+  | 'review'
+  | 'rejected'
+  | 'published'
+  | 'closed';
+
+const VERSION_FILTER_OPTIONS: readonly {
+  value: MyGameVersionFilter;
+  label: string;
+}[] = [
+  { value: 'all', label: '全部' },
+  { value: 'action', label: '待处理' },
+  { value: 'review', label: '审核中' },
+  { value: 'rejected', label: '已拒绝' },
+  { value: 'published', label: '已发布' },
+  { value: 'closed', label: '已撤回' },
+];
+
+/** 版本状态分组：同一个筛选档位下可命中的状态，判定只看服务端返回的版本状态。 */
+const VERSION_FILTER_STATUSES: Record<
+  Exclude<MyGameVersionFilter, 'all'>,
+  Record<string, true>
+> = {
+  action: {
+    awaiting_upload: true,
+    uploaded: true,
+    upload_failed: true,
+    validation_failed: true,
+  },
+  review: { validating: true, pending_review: true },
+  rejected: { rejected: true },
+  published: { published: true },
+  closed: { cancelled: true, revoked: true },
+};
+
 function resolveVersionStatus(game: GameDistributionMyGame) {
   const latest = game.latestVersion;
   if (!latest) return null;
@@ -74,30 +136,79 @@ function resolveVersionStatus(game: GameDistributionMyGame) {
   };
 }
 
+/**
+ * 我的游戏 / 作品管理。
+ *
+ * 一行 = 一个作品，行内给出作者此刻能做的动作（发布新版本、资料编辑、撤回、下架、
+ * 删除、继续未完成的发布）；版本历史与驳回理由展开可见。所有写动作都由服务端鉴权，
+ * 过期修订号由服务端以 409 拒绝后由作者刷新重试。
+ */
 export function MyGamesPage({
   onBack,
   onOpenDetail,
   onPublishVersion,
+  onResumePublish,
+  publishEnabled = true,
 }: MyGamesPageProps) {
   const authUi = useAuthUi();
   const [games, setGames] = useState<GameDistributionMyGame[]>([]);
+  const [recoveryActions, setRecoveryActions] = useState<
+    Record<string, GameDistributionRecoveryAction>
+  >({});
   const [isLoading, setIsLoading] = useState(false);
   const [busyGameId, setBusyGameId] = useState('');
   const [cancellingVersionId, setCancellingVersionId] = useState('');
+  const [submittingVersionId, setSubmittingVersionId] = useState('');
   const [confirmingVersionId, setConfirmingVersionId] = useState('');
+  const [expandedGameId, setExpandedGameId] = useState('');
+  const [editingGame, setEditingGame] = useState<GameDistributionMyGame | null>(
+    null,
+  );
+  const [deletingGame, setDeletingGame] =
+    useState<GameDistributionMyGame | null>(null);
+  const [statusFilter, setStatusFilter] = useState<MyGameStatusFilter>('all');
+  const [versionFilter, setVersionFilter] =
+    useState<MyGameVersionFilter>('all');
   const [notice, setNotice] = useState('');
   const [error, setError] = useState('');
   const canLoad = Boolean(authUi?.user && authUi.canAccessProtectedData);
+  const currentUserId = authUi?.user?.id ?? '';
+  /**
+   * 本地发布草稿只属于本机当前账号：同一作品的最新版本还挂着未完成的发布时，
+   * 行内直接给出「继续上传 / 继续送审」，复用发布页既有的恢复语义。
+   */
+  const [localDraft, setLocalDraft] = useState<GamePublishDraft | null>(null);
+
+  useEffect(() => {
+    setLocalDraft(canLoad ? readPublishDraft() : null);
+  }, [canLoad, games]);
+  const draftMatchesOwner = localDraft?.ownerUserId === currentUserId;
 
   const loadGames = useCallback(async () => {
     if (!canLoad) {
       setGames([]);
+      setRecoveryActions({});
       return;
     }
     setIsLoading(true);
     setError('');
     try {
-      setGames(await listMyGames());
+      const entries = await listMyGames();
+      setGames(entries);
+      // 列表投影不带 recoveryAction，只为还需要作者动作的最新版本补一次版本回读；
+      // 单个回读失败只丢失该版本的下一步提示，不影响列表。
+      const pendingVersionIds = entries
+        .map((game) => game.latestVersion)
+        .filter((version): version is GameDistributionVersionStatusEntry => {
+          if (!version || version.recoveryAction) return false;
+          return VERSION_STATUS_NEEDS_AUTHOR_ACTION[version.status];
+        })
+        .map((version) => version.versionId);
+      setRecoveryActions(
+        pendingVersionIds.length > 0
+          ? await loadVersionRecoveryActions(pendingVersionIds)
+          : {},
+      );
     } catch (loadError: unknown) {
       setError(
         loadError instanceof Error ? loadError.message : '读取我的游戏失败',
@@ -111,6 +222,48 @@ export function MyGamesPage({
     void loadGames();
   }, [loadGames]);
 
+  const visibleGames = useMemo(
+    () =>
+      games.filter((game) => {
+        if (statusFilter !== 'all' && game.status !== statusFilter) {
+          return false;
+        }
+        if (versionFilter === 'all') return true;
+        const status = game.latestVersion?.status;
+        return Boolean(
+          status && VERSION_FILTER_STATUSES[versionFilter][status] === true,
+        );
+      }),
+    [games, statusFilter, versionFilter],
+  );
+  const hasActiveFilter = statusFilter !== 'all' || versionFilter !== 'all';
+
+  function resolveLatestRecoveryAction(game: GameDistributionMyGame) {
+    const latest = game.latestVersion;
+    if (!latest) return null;
+    return latest.recoveryAction ?? recoveryActions[latest.versionId] ?? null;
+  }
+
+  function resolveLatestActionCopy(game: GameDistributionMyGame) {
+    const action = resolveLatestRecoveryAction(game);
+    if (!action || action === 'none') return '';
+    return RECOVERY_ACTION_LABEL[action] ?? '';
+  }
+
+  function resolveDraftResumeLabel(game: GameDistributionMyGame) {
+    if (!onResumePublish || !draftMatchesOwner || !localDraft) return '';
+    const latest = game.latestVersion;
+    if (!latest || latest.versionId !== localDraft.versionId) return '';
+    const action = resolveLatestRecoveryAction(game);
+    if (action !== 'upload' && action !== 'reupload' && action !== 'submit') {
+      return '';
+    }
+    return (
+      resolvePublishDraftRecoveryCopy(action, latest.versionNumber)
+        .actionLabel ?? ''
+    );
+  }
+
   async function handleCancelVersion(
     game: GameDistributionMyGame,
     version: GameDistributionVersionStatusEntry,
@@ -136,6 +289,29 @@ export function MyGamesPage({
     }
   }
 
+  async function handleSubmitVersion(game: GameDistributionMyGame) {
+    const version = game.latestVersion;
+    if (!version) return;
+    setSubmittingVersionId(version.versionId);
+    setError('');
+    setNotice('');
+    try {
+      await submitGameVersion(
+        version.versionId,
+        game.publicationRevision,
+        createSubmitKey(version.versionId),
+      );
+      setNotice(`版本 v${version.versionNumber} 已提交审核。`);
+      await loadGames();
+    } catch (submitError: unknown) {
+      setError(
+        submitError instanceof Error ? submitError.message : '提交审核失败',
+      );
+    } finally {
+      setSubmittingVersionId('');
+    }
+  }
+
   async function handleUnpublish(game: GameDistributionMyGame) {
     setBusyGameId(game.id);
     setError('');
@@ -157,6 +333,42 @@ export function MyGamesPage({
     }
   }
 
+  async function handleDelete(game: GameDistributionMyGame) {
+    setBusyGameId(game.id);
+    setError('');
+    setNotice('');
+    try {
+      await deleteMyGame(
+        game.id,
+        game.publicationRevision,
+        createDeleteKey(game.id),
+      );
+      setDeletingGame(null);
+      setNotice(`《${game.title}》已删除，不再出现在广场与你的作品列表里。`);
+      await loadGames();
+    } catch (deleteError: unknown) {
+      setError(
+        deleteError instanceof Error ? deleteError.message : '删除作品失败',
+      );
+    } finally {
+      setBusyGameId('');
+    }
+  }
+
+  /**
+   * 资料保存只改 `game` 级展示字段，版本列表与恢复动作不变；直接把服务端投影并回这一行，
+   * 不为了改标题再全量拉一次列表。
+   */
+  function handleSaved(response: GameDistributionUpdateMyGameResponse) {
+    setEditingGame(null);
+    setNotice('作品资料已保存，公开目录与详情已同步。');
+    setGames((current) =>
+      current.map((game) =>
+        game.id === response.game.id ? { ...game, ...response.game } : game,
+      ),
+    );
+  }
+
   return (
     <div className="game-page">
       <button type="button" className="game-back-button" onClick={onBack}>
@@ -216,10 +428,70 @@ export function MyGamesPage({
       ) : null}
 
       {canLoad && games.length > 0 ? (
+        <div className="my-game-filters">
+          <label className="game-publish-field">
+            作品状态
+            <select
+              value={statusFilter}
+              onChange={(event) =>
+                setStatusFilter(event.target.value as MyGameStatusFilter)
+              }
+            >
+              <option value="all">全部</option>
+              <option value="published">已公开</option>
+              <option value="unpublished">未公开</option>
+              <option value="suspended">已被封禁</option>
+            </select>
+          </label>
+          <label className="game-publish-field">
+            版本状态
+            <select
+              value={versionFilter}
+              onChange={(event) =>
+                setVersionFilter(event.target.value as MyGameVersionFilter)
+              }
+            >
+              {VERSION_FILTER_OPTIONS.map((item) => (
+                <option key={item.value} value={item.value}>
+                  {item.label}
+                </option>
+              ))}
+            </select>
+          </label>
+          {hasActiveFilter ? (
+            <PlatformActionButton
+              tone="secondary"
+              size="sm"
+              shape="pill"
+              onClick={() => {
+                setStatusFilter('all');
+                setVersionFilter('all');
+              }}
+            >
+              重置筛选
+            </PlatformActionButton>
+          ) : null}
+        </div>
+      ) : null}
+
+      {canLoad &&
+      games.length > 0 &&
+      visibleGames.length === 0 &&
+      !isLoading ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <span>没有符合当前筛选条件的作品。</span>
+        </PlatformEmptyState>
+      ) : null}
+
+      {canLoad && visibleGames.length > 0 ? (
         <div className="my-game-list">
-          {games.map((game) => {
+          {visibleGames.map((game) => {
             const version = resolveVersionStatus(game);
             const latestVersion = game.latestVersion;
+            const actionCopy = resolveLatestActionCopy(game);
+            const resumeLabel = resolveDraftResumeLabel(game);
+            const versions = game.versions;
+            const isHistoryOpen = expandedGameId === game.id;
             return (
               <article key={game.id} className="my-game-card">
                 <GameCover game={game} compact />
@@ -235,7 +507,7 @@ export function MyGamesPage({
                     <span
                       className={`my-game-status my-game-status--${game.status}`}
                     >
-                      {STATUS_LABEL[game.status] ?? game.status}
+                      {GAME_STATUS_LABEL[game.status] ?? game.status}
                     </span>
                   </div>
                   <p className="my-game-card__summary">{game.summary}</p>
@@ -257,6 +529,34 @@ export function MyGamesPage({
                       驳回理由：{version.reviewReason}
                     </p>
                   ) : null}
+                  {actionCopy ? (
+                    <p className="my-game-card__next-step">
+                      下一步：{actionCopy}
+                    </p>
+                  ) : null}
+                  {versions.length > 0 ? (
+                    <button
+                      type="button"
+                      className="my-game-card__history-toggle"
+                      aria-expanded={isHistoryOpen}
+                      aria-controls={`game-version-history-${game.id}`}
+                      onClick={() =>
+                        setExpandedGameId((current) =>
+                          current === game.id ? '' : game.id,
+                        )
+                      }
+                    >
+                      版本历史（{versions.length}）
+                      {isHistoryOpen ? '收起' : '展开'}
+                    </button>
+                  ) : null}
+                  {isHistoryOpen ? (
+                    <GameVersionHistory
+                      id={`game-version-history-${game.id}`}
+                      versions={versions}
+                      recoveryActions={recoveryActions}
+                    />
+                  ) : null}
                   <div className="my-game-card__actions">
                     <PlatformActionButton
                       tone="secondary"
@@ -276,6 +576,42 @@ export function MyGamesPage({
                         发布新版本
                       </PlatformActionButton>
                     ) : null}
+                    {publishEnabled ? (
+                      <PlatformActionButton
+                        tone="secondary"
+                        size="sm"
+                        shape="pill"
+                        disabled={busyGameId === game.id}
+                        onClick={() => setEditingGame(game)}
+                      >
+                        编辑资料
+                      </PlatformActionButton>
+                    ) : null}
+                    {resumeLabel ? (
+                      <PlatformActionButton
+                        tone="secondary"
+                        size="sm"
+                        shape="pill"
+                        onClick={() => onResumePublish?.()}
+                      >
+                        {resumeLabel}
+                      </PlatformActionButton>
+                    ) : null}
+                    {resolveLatestRecoveryAction(game) === 'submit' &&
+                    latestVersion &&
+                    !resumeLabel ? (
+                      <PlatformActionButton
+                        tone="secondary"
+                        size="sm"
+                        shape="pill"
+                        disabled={
+                          submittingVersionId === latestVersion.versionId
+                        }
+                        onClick={() => void handleSubmitVersion(game)}
+                      >
+                        提交审核
+                      </PlatformActionButton>
+                    ) : null}
                     {game.status === 'published' ? (
                       <PlatformActionButton
                         tone="secondary"
@@ -332,6 +668,15 @@ export function MyGamesPage({
                         </PlatformActionButton>
                       )
                     ) : null}
+                    <PlatformActionButton
+                      tone="danger"
+                      size="sm"
+                      shape="pill"
+                      disabled={busyGameId === game.id}
+                      onClick={() => setDeletingGame(game)}
+                    >
+                      删除作品
+                    </PlatformActionButton>
                   </div>
                 </div>
               </article>
@@ -339,6 +684,32 @@ export function MyGamesPage({
           })}
         </div>
       ) : null}
+
+      {editingGame ? (
+        <GameWorkMetadataEditor
+          key={editingGame.id}
+          game={editingGame}
+          onClose={() => setEditingGame(null)}
+          onSaved={handleSaved}
+        />
+      ) : null}
+
+      <PlatformDangerConfirmDialog
+        open={Boolean(deletingGame)}
+        title="删除作品"
+        description={
+          deletingGame
+            ? `《${deletingGame.title}》将从广场与你的作品列表移除，历史版本包进入回收窗口后不可恢复。`
+            : ''
+        }
+        confirmLabel="删除作品"
+        busyConfirmLabel="正在删除…"
+        busy={Boolean(busyGameId) && busyGameId === deletingGame?.id}
+        onClose={() => setDeletingGame(null)}
+        onConfirm={() => {
+          if (deletingGame) void handleDelete(deletingGame);
+        }}
+      />
     </div>
   );
 }
diff --git a/src/components/game-distribution/gameDistribution.css b/src/components/game-distribution/gameDistribution.css
index 948a80a14..ea2a86285 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,90 +361,26 @@
   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 {
+/*
+ * 非公开作品的封面占位文案：封面素材不可换签时，封面位改为状态说明
+ * （审核中 / 审核未通过 / 未公开 / 已被封禁），压在渐变占位之上。
+ */
+.game-detail-cover__pending {
+  position: absolute;
+  inset: 0;
+  z-index: 3;
   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;
+  place-items: center;
+  background: rgba(22, 21, 28, 0.55);
+  color: #fff5dc;
+  font-size: 0.95rem;
+  font-weight: 800;
+  letter-spacing: 0.16em;
 }
 .game-loading-panel {
   display: grid;
@@ -646,25 +550,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 +594,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;
   }
@@ -849,6 +726,7 @@
 }
 .my-game-card__actions {
   display: flex;
+  flex-wrap: wrap;
   gap: 0.5rem;
   margin-top: auto;
   padding-top: 0.35rem;
@@ -879,6 +757,135 @@
   }
 }
 
+/* 作品管理：筛选、版本历史、下一步提示与作者状态面板。 */
+.my-game-filters {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: end;
+  gap: 0.75rem;
+  margin-bottom: 0.9rem;
+}
+.my-game-filters .game-publish-field {
+  flex: 1 1 9rem;
+  max-width: 15rem;
+}
+.my-game-card__next-step {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.72rem;
+  font-weight: 700;
+}
+.my-game-card__history-toggle {
+  align-self: flex-start;
+  border: 0;
+  padding: 0;
+  background: transparent;
+  color: var(--platform-accent-strong);
+  font: inherit;
+  font-size: 0.72rem;
+  font-weight: 700;
+  cursor: pointer;
+}
+.my-game-card__history-toggle:hover {
+  text-decoration: underline;
+}
+.game-version-list {
+  display: grid;
+  gap: 0.4rem;
+  margin: 0.2rem 0 0;
+  padding: 0;
+  list-style: none;
+}
+.game-version-list__item {
+  display: grid;
+  gap: 0.2rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.8rem;
+  padding: 0.5rem 0.7rem;
+  background: var(--platform-surface-fill);
+  min-width: 0;
+}
+.game-version-list__heading {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.45rem;
+  font-size: 0.78rem;
+}
+.game-version-list__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  color: var(--platform-text-soft);
+  font-size: 0.68rem;
+}
+.game-version-list__reason {
+  margin: 0;
+  color: var(--platform-button-danger-text);
+  font-size: 0.7rem;
+}
+.game-version-list__action {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 600;
+}
+.game-version-status {
+  border-radius: 999px;
+  padding: 0.15rem 0.5rem;
+  background: var(--platform-surface-fill);
+  color: var(--platform-text-soft);
+  font-size: 0.64rem;
+  font-weight: 800;
+}
+.game-version-status--published {
+  background: var(--platform-success-bg);
+  color: var(--platform-success-text);
+}
+.game-version-status--rejected,
+.game-version-status--upload_failed,
+.game-version-status--validation_failed {
+  background: var(--platform-button-danger-fill);
+  color: var(--platform-button-danger-text);
+}
+.game-owner-panel {
+  display: grid;
+  gap: 0.5rem;
+  margin-top: 1rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1.2rem;
+  padding: 0.9rem 1rem;
+  background: var(--platform-panel-fill);
+}
+.game-owner-panel__heading {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.6rem;
+}
+.game-owner-panel__heading h2 {
+  margin: 0;
+  font-size: 1rem;
+  letter-spacing: -0.02em;
+}
+.game-owner-panel__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  color: var(--platform-text-soft);
+  font-size: 0.72rem;
+}
+.game-owner-panel__reason {
+  margin: 0;
+  color: var(--platform-button-danger-text);
+  font-size: 0.72rem;
+}
+.game-work-editor {
+  display: grid;
+  gap: 0.85rem;
+}
+
 .game-publish-page {
   max-width: 54rem;
 }
@@ -1086,6 +1093,9 @@
   .game-publish-row {
     grid-template-columns: 1fr;
   }
+  .my-game-filters .game-publish-field {
+    max-width: none;
+  }
   .game-publish-media__preview {
     width: 100%;
   }
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;
-  }
-}
diff --git a/src/components/game-distribution/gameMetadataOptions.ts b/src/components/game-distribution/gameMetadataOptions.ts
new file mode 100644
index 000000000..c3dd24c7f
--- /dev/null
+++ b/src/components/game-distribution/gameMetadataOptions.ts
@@ -0,0 +1,55 @@
+import {
+  GAME_DISTRIBUTION_CATEGORIES,
+  type GameDistributionCategory,
+  type GameDistributionDeviceSupport,
+  type GameDistributionInputMode,
+  type GameDistributionOrientation,
+} from '../../../packages/shared/src/contracts/gameDistribution';
+
+/**
+ * 作品资料的展示选项与派生逻辑。
+ *
+ * 发布页与「作品资料编辑」共用同一份口径，避免同一组分类/方向在两条链路上漂移；
+ * 服务端仍会各自校验，这里只是客户端的一致性来源。
+ */
+export const GAME_METADATA_CATEGORIES: readonly GameDistributionCategory[] =
+  GAME_DISTRIBUTION_CATEGORIES;
+
+export const GAME_METADATA_ORIENTATIONS: readonly {
+  value: GameDistributionOrientation;
+  label: string;
+}[] = [
+  { value: 'responsive', label: '自适应' },
+  { value: 'landscape', label: '横屏' },
+  { value: 'portrait', label: '竖屏' },
+];
+
+export const GAME_METADATA_INPUT_MODE_LABELS: Record<
+  GameDistributionInputMode,
+  string
+> = {
+  keyboard: '键盘',
+  mouse: '鼠标',
+  touch: '触屏',
+};
+
+/** 标签输入框口径：中英文逗号分隔、去空白、最多 5 个，与服务端上限一致。 */
+export function parseGameTagsInput(value: string): string[] {
+  return value
+    .split(/[,，]/u)
+    .map((tag) => tag.trim())
+    .filter(Boolean)
+    .slice(0, 5);
+}
+
+/**
+ * 输入方式由设备支持派生（与创建游戏时同一口径）：桌面端给键盘与鼠标，
+ * 支持触控再补触屏，避免作者在两处填同一件事。
+ */
+export function resolveGameInputModes(
+  deviceSupport: GameDistributionDeviceSupport,
+): GameDistributionInputMode[] {
+  const inputModes: GameDistributionInputMode[] = ['keyboard', 'mouse'];
+  if (deviceSupport.touch) inputModes.push('touch');
+  return inputModes;
+}
diff --git a/src/components/game-distribution/gamePublishMediaDefaults.ts b/src/components/game-distribution/gamePublishMediaDefaults.ts
new file mode 100644
index 000000000..680c5695d
--- /dev/null
+++ b/src/components/game-distribution/gamePublishMediaDefaults.ts
@@ -0,0 +1,80 @@
+import type { GameDistributionVersionDetail } from '../../../packages/shared/src/contracts/gameDistribution';
+import {
+  type GamePublishImageAsset,
+  resolveGamePublishImagePreview,
+} from './gamePublishAssets';
+
+type VersionMediaApplyTarget = {
+  setCover: (
+    updater: (
+      current: GamePublishImageAsset | null,
+    ) => GamePublishImageAsset | null,
+  ) => void;
+  setScreenshots: (
+    updater: (current: GamePublishImageAsset[]) => GamePublishImageAsset[],
+  ) => void;
+  isCancelled: () => boolean;
+};
+
+/**
+ * 用版本冻结资料回填封面与截图。
+ *
+ * 快照缺失（或旧版本没存素材 ID）时只回填线上封面预览：此时作者必须重新选择一次封面，
+ * 因为服务端只接受素材 ID 作为冻结/保存输入，前端不能凭对象键猜素材身份。
+ */
+export async function applyVersionMediaDefaults(
+  detail: GameDistributionVersionDetail,
+  apply: VersionMediaApplyTarget,
+) {
+  const frozen = detail.version.frozenMetadata ?? null;
+  const coverAssetId = frozen?.coverAssetId?.trim() ?? '';
+  const coverObjectKey =
+    frozen?.coverObjectKey?.trim() ?? detail.game.coverObjectKey?.trim() ?? '';
+  const coverName = detail.game.title.trim() || '当前封面';
+  const buildCover = (src: string): GamePublishImageAsset => ({
+    assetObjectId: coverAssetId,
+    objectKey: coverObjectKey,
+    src,
+    name: coverName,
+  });
+
+  const screenshots = (frozen?.screenshots ?? []).filter((screenshot) =>
+    Boolean(screenshot?.assetId?.trim()),
+  );
+  if (apply.isCancelled()) return;
+  apply.setCover(() =>
+    coverAssetId || coverObjectKey ? buildCover('') : null,
+  );
+  apply.setScreenshots(() =>
+    screenshots.map((screenshot, index) => ({
+      assetObjectId: screenshot.assetId.trim(),
+      objectKey: screenshot.objectKey?.trim() ?? '',
+      src: '',
+      name: `截图 ${index + 1}`,
+    })),
+  );
+
+  const coverPreview = await resolveGamePublishImagePreview(coverObjectKey);
+  if (apply.isCancelled()) return;
+  if (coverPreview) {
+    // 只在作者还没换图、且预览仍为空时补上签名地址，避免覆盖作者的新选择。
+    apply.setCover((current) =>
+      current && !current.src && current.objectKey === coverObjectKey
+        ? { ...current, src: coverPreview }
+        : current,
+    );
+  }
+  for (const [index, screenshot] of screenshots.entries()) {
+    const preview = await resolveGamePublishImagePreview(
+      screenshot.objectKey ?? '',
+    );
+    if (apply.isCancelled() || !preview) continue;
+    apply.setScreenshots((current) =>
+      current.map((item, itemIndex) =>
+        itemIndex === index && item.assetObjectId === screenshot.assetId
+          ? { ...item, src: preview }
+          : item,
+      ),
+    );
+  }
+}
diff --git a/src/components/game-distribution/gameVersionHistoryModel.ts b/src/components/game-distribution/gameVersionHistoryModel.ts
new file mode 100644
index 000000000..e5d10b63a
--- /dev/null
+++ b/src/components/game-distribution/gameVersionHistoryModel.ts
@@ -0,0 +1,85 @@
+import type {
+  GameDistributionRecoveryAction,
+  GameDistributionVersionStatus,
+} from '../../../packages/shared/src/contracts/gameDistribution';
+
+/** 作品公开状态文案；`suspended` 由管理员安全下架产生，作者侧只读展示。 */
+export const GAME_STATUS_LABEL: Record<string, string> = {
+  unpublished: '未公开',
+  published: '已公开',
+  suspended: '已被封禁',
+};
+
+export const VERSION_STATUS_LABEL: Record<string, string> = {
+  awaiting_upload: '待上传',
+  uploaded: '已上传',
+  validating: '校验中',
+  pending_review: '审核中',
+  published: '已发布',
+  upload_failed: '上传失败',
+  validation_failed: '校验失败',
+  rejected: '已拒绝',
+  cancelled: '已撤回',
+  revoked: '已撤回',
+};
+
+/**
+ * 非公开作品在封面位置显示的占位文案。
+ *
+ * 作品没公开时封面素材不可换签（封面位只会剩渐变占位），这里按最新版本状态给出最贴近的
+ * 说明；其余状态退回作品级公开文案，避免在封面上编造审核结论。
+ */
+export const NON_PUBLIC_COVER_VERSION_LABEL: Partial<
+  Record<GameDistributionVersionStatus, string>
+> = {
+  pending_review: '审核中',
+  rejected: '审核未通过',
+};
+
+/** 非公开作品的封面占位文案：优先最新版本状态，其次作品公开状态。 */
+export function resolveNonPublicCoverLabel(
+  gameStatus: string,
+  versionStatus?: GameDistributionVersionStatus | null,
+): string {
+  return (
+    (versionStatus ? NON_PUBLIC_COVER_VERSION_LABEL[versionStatus] : null) ??
+    GAME_STATUS_LABEL[gameStatus] ??
+    '未公开'
+  );
+}
+
+/** 服务端 `recoveryAction` 的中文说明；前端只翻译，不推断状态。 */
+export const RECOVERY_ACTION_LABEL: Record<
+  GameDistributionRecoveryAction,
+  string
+> = {
+  upload: '继续上传发行包',
+  submit: '提交审核',
+  wait: '等待审核结果',
+  none: '无需操作',
+  reupload: '重新上传发行包',
+  fix_package: '修正发行包后重新上传',
+  fix_metadata: '修改作品资料后重新提交',
+};
+
+/**
+ * 还需要作者动作的版本状态。
+ *
+ * 已发布 / 已撤回 / 已取消的版本没有下一步，作者列表不为它们多回读一次版本详情；
+ * 只做请求调度用，不参与任何状态文案或动作推断。
+ */
+export const VERSION_STATUS_NEEDS_AUTHOR_ACTION: Record<
+  GameDistributionVersionStatus,
+  boolean
+> = {
+  awaiting_upload: true,
+  uploaded: true,
+  validating: true,
+  pending_review: true,
+  upload_failed: true,
+  validation_failed: true,
+  rejected: true,
+  published: false,
+  cancelled: false,
+  revoked: false,
+};
diff --git a/src/components/game-distribution/useGameAuthorName.ts b/src/components/game-distribution/useGameAuthorName.ts
new file mode 100644
index 000000000..0b58798a0
--- /dev/null
+++ b/src/components/game-distribution/useGameAuthorName.ts
@@ -0,0 +1,69 @@
+import { useEffect, useState } from 'react';
+
+import { getPublicAuthUserById } from '../../services/authService';
+
+/**
+ * 作者展示名缺失时服务端会退化成角色词，不是用户名：
+ * api-server 的 `game_payload`（公开目录/公开详情/作者侧）写的是
+ * `author_name.as_deref().unwrap_or("创作者")`，后台行 `admin_game_payload` 写的是
+ * `unwrap_or("未知作者")`。这两个词一律当成「没有名字」，否则会把占位词当昵称渲染出来。
+ */
+const GAME_AUTHOR_PLACEHOLDER_NAMES: Record<string, true> = {
+  创作者: true,
+  未知作者: true,
+};
+
+export type GameAuthorIdentity = {
+  id?: string | null;
+  name?: string | null;
+};
+
+function isRealAuthorName(value: string | null | undefined) {
+  const name = (value ?? '').trim();
+  return name.length > 0 && GAME_AUTHOR_PLACEHOLDER_NAMES[name] !== true;
+}
+
+/**
+ * 游戏作者的对外展示名。
+ *
+ * 游戏行上的 `author_name` 由创建接口固定写空（api-server `create_game` 传 None），
+ * 所以公开投影里的 `author.name` 只会是占位角色词，不是用户名。真实昵称只能按
+ * `author.id`（owner_user_id）走公开用户查询补一次：`GET /api/auth/public-users/by-id/{userId}`，
+ * 与陶泥号查询 `/api/auth/public-users/by-code/{code}` 同一族接口，不需要登录态。
+ *
+ * 返回 `null` 表示还在查询——展示层此时不要渲染名字，避免先闪一下占位词；
+ * 返回空串表示查不到（账号失效 / 网络失败），由展示层降级。
+ * 回包名本来就是真实昵称时不再多发请求：后端补上作者名后这里自然退化为普通渲染。
+ */
+export function useGameAuthorDisplayName(
+  author: GameAuthorIdentity | null | undefined,
+): string | null {
+  const fallbackName = (author?.name ?? '').trim();
+  const hasFallbackName = isRealAuthorName(fallbackName);
+  const authorId = (author?.id ?? '').trim();
+  const [lookedUp, setLookedUp] = useState<{
+    id: string;
+    name: string;
+  } | null>(null);
+
+  useEffect(() => {
+    if (hasFallbackName || !authorId) return;
+    let alive = true;
+    void getPublicAuthUserById(authorId)
+      .then((user) => {
+        if (alive) setLookedUp({ id: authorId, name: user.displayName.trim() });
+      })
+      .catch(() => {
+        // 作者账号查不到（已失效 / 非公开）时不编造名字，按空名交给展示层降级。
+        if (alive) setLookedUp({ id: authorId, name: '' });
+      });
+    return () => {
+      alive = false;
+    };
+  }, [authorId, hasFallbackName]);
+
+  if (hasFallbackName) return fallbackName;
+  if (!authorId) return '';
+  if (!lookedUp || lookedUp.id !== authorId) return null;
+  return lookedUp.name;
+}
diff --git a/src/components/game-distribution/useGameReviews.ts b/src/components/game-distribution/useGameReviews.ts
index 88f5ded33..0b5ebd55d 100644
--- a/src/components/game-distribution/useGameReviews.ts
+++ b/src/components/game-distribution/useGameReviews.ts
@@ -23,8 +23,17 @@ function errorMessage(error: unknown, fallback: string) {
   return error instanceof Error ? error.message : fallback;
 }
 
-/** 外层以游戏和账号身份为 key，切换上下文会卸载并清空整个评价草稿。 */
-export function useGameReviews(gameId: string, canReview: boolean) {
+/**
+ * 外层以游戏和账号身份为 key，切换上下文会卸载并清空整个评价草稿。
+ *
+ * `publiclyVisible` 为 false（审核中 / 审核未通过 / 未公开 / 已下架）时，服务端对评价与
+ * 评分一律按「作品不存在或不可公开访问」拒绝，前端直接不发起任何评价类请求，按空态展示。
+ */
+export function useGameReviews(
+  gameId: string,
+  canReview: boolean,
+  publiclyVisible: boolean,
+) {
   const [summary, setSummary] = useState<GameDistributionRatingSummary | null>(
     null,
   );
@@ -32,10 +41,10 @@ export function useGameReviews(gameId: string, canReview: boolean) {
     null,
   );
   const [page, setPage] = useState(1);
-  const [listLoading, setListLoading] = useState(true);
+  const [listLoading, setListLoading] = useState(publiclyVisible);
   const [listError, setListError] = useState('');
   const [myReview, setMyReview] = useState<GameDistributionReview | null>(null);
-  const [myLoading, setMyLoading] = useState(canReview);
+  const [myLoading, setMyLoading] = useState(canReview && publiclyVisible);
   const [myError, setMyError] = useState('');
   const [editing, setEditing] = useState(false);
   const [score, setScore] = useState<number | null>(null);
@@ -50,6 +59,8 @@ export function useGameReviews(gameId: string, canReview: boolean) {
 
   const loadPage = useCallback(
     async (nextPage: number) => {
+      // 非公开作品没有公开评价投影：不请求、不置错误态。
+      if (!publiclyVisible) return;
       const serial = ++listSerial.current;
       pageRef.current = nextPage;
       setPage(nextPage);
@@ -68,11 +79,11 @@ export function useGameReviews(gameId: string, canReview: boolean) {
           setListLoading(false);
       }
     },
-    [gameId],
+    [gameId, publiclyVisible],
   );
 
   const loadMine = useCallback(async () => {
-    if (!canReview) return;
+    if (!canReview || !publiclyVisible) return;
     const serial = ++mySerial.current;
     setMyLoading(true);
     setMyError('');
@@ -86,18 +97,28 @@ export function useGameReviews(gameId: string, canReview: boolean) {
     } finally {
       if (alive.current && serial === mySerial.current) setMyLoading(false);
     }
-  }, [canReview, gameId]);
+  }, [canReview, gameId, publiclyVisible]);
 
   useEffect(() => {
     alive.current = true;
-    void loadPage(1);
-    void loadMine();
+    if (!publiclyVisible) {
+      // 非公开作品：不进任何评价/评分请求，按空态起步。
+      listSerial.current += 1;
+      mySerial.current += 1;
+      setListLoading(false);
+      setMyLoading(false);
+      setListError('');
+      setMyError('');
+    } else {
+      void loadPage(1);
+      void loadMine();
+    }
     return () => {
       alive.current = false;
       listSerial.current += 1;
       mySerial.current += 1;
     };
-  }, [loadMine, loadPage]);
+  }, [loadMine, loadPage, publiclyVisible]);
 
   function edit() {
     if (!myReview || savingRef.current) return;
@@ -116,7 +137,14 @@ export function useGameReviews(gameId: string, canReview: boolean) {
   }
 
   async function submit() {
-    if (savingRef.current || !canReview || myLoading || myError) return;
+    if (
+      savingRef.current ||
+      !canReview ||
+      !publiclyVisible ||
+      myLoading ||
+      myError
+    )
+      return;
     const normalizedComment = normalizeReviewNewlines(comment);
     if (score === null || !Number.isInteger(score) || score < 1 || score > 10) {
       setSaveError('请选择 1–10 分');
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
index aff31a85a..d2bccb582 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
@@ -48,12 +48,16 @@ const gameDistributionMock = vi.hoisted(() => ({
   cancelGameVersion: vi.fn(),
   createGame: vi.fn(),
   createGameVersion: vi.fn(),
+  deleteMyGame: vi.fn(),
   getGame: vi.fn(),
   getGameVersion: vi.fn(),
+  getMyGame: vi.fn(),
   listGames: vi.fn(),
   listMyGames: vi.fn(),
+  loadVersionRecoveryActions: vi.fn(),
   submitGameVersion: vi.fn(),
   unpublishGame: vi.fn(),
+  updateMyGame: vi.fn(),
   uploadGamePackage: vi.fn(),
 }));
 
@@ -1012,3 +1016,159 @@ describe('游戏详情返回', () => {
     expect(window.location.pathname).toBe('/games');
   });
 });
+
+describe('作品管理 owner 作用域', () => {
+  beforeEach(() => {
+    window.history.replaceState(null, '', '/creation');
+    authUiMock.value.user = null;
+    authUiMock.value.canAccessProtectedData = false;
+    for (const mock of Object.values(gameDistributionMock)) {
+      mock.mockReset();
+    }
+    frontendRuntimeConfigMock.loadFrontendRuntimeConfig.mockReset();
+    frontendRuntimeConfigMock.loadFrontendRuntimeConfig.mockResolvedValue({
+      imageEditorAgentSidebarEnabled: false,
+      agcTemplateLibraryEnabled: false,
+      gameDistributionPublishEnabled: true,
+    });
+  });
+
+  const ownerEntry = {
+    id: 'game-1',
+    title: '未公开作品',
+    summary: '还在审核',
+    description: '作者自有游戏',
+    category: '动作',
+    tags: ['塔防'],
+    coverColor: '#d77a51',
+    icon: '✦',
+    author: { id: 'user-1', name: '测试作者' },
+    deviceSupport: { desktop: true, mobile: true, touch: true },
+    status: 'unpublished',
+    publicationRevision: 4,
+    currentVersion: null,
+    playCount: 0,
+    createdAt: '2026-09-20T08:00:00Z',
+    latestVersion: {
+      versionId: 'gamever-1',
+      gameId: 'game-1',
+      versionNumber: 1,
+      packageSha256: 'a'.repeat(64),
+      packageBytes: 1024,
+      status: 'pending_review',
+      publicationRevision: 4,
+      reviewReason: '封面需要替换',
+      createdAt: '2026-09-20T08:00:00Z',
+      updatedAt: '2026-09-20T09:00:00Z',
+    },
+    versions: [
+      {
+        versionId: 'gamever-1',
+        gameId: 'game-1',
+        versionNumber: 1,
+        packageSha256: 'a'.repeat(64),
+        packageBytes: 1024,
+        status: 'pending_review',
+        publicationRevision: 4,
+        reviewReason: '封面需要替换',
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+    ],
+  };
+
+  function loginAsAuthor() {
+    authUiMock.value.user = {
+      id: 'user-1',
+      publicUserCode: '100001',
+      displayName: '测试作者',
+      avatarUrl: null,
+      phoneNumberMasked: null,
+      loginMethod: 'password',
+      bindingStatus: 'active',
+      wechatBound: false,
+    };
+    authUiMock.value.canAccessProtectedData = true;
+  }
+
+  it('从我的作品进入详情时把 owner 作用域编码进地址', async () => {
+    loginAsAuthor();
+    gameDistributionMock.listMyGames.mockResolvedValue([ownerEntry]);
+    gameDistributionMock.loadVersionRecoveryActions.mockResolvedValue({
+      'gamever-1': 'wait',
+    });
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-mine"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '查看详情' }));
+
+    expect(setSelectionStage).toHaveBeenCalledWith('game-detail', {
+      path: '/games/detail?id=game-1&owner=1',
+    });
+  });
+
+  it('带 owner 的详情深链读 owner 路由而不是公开详情', async () => {
+    loginAsAuthor();
+    gameDistributionMock.getMyGame.mockResolvedValue(ownerEntry);
+    gameDistributionMock.loadVersionRecoveryActions.mockResolvedValue({
+      'gamever-1': 'wait',
+    });
+    gameDistributionMock.getGame.mockResolvedValue(null);
+    window.history.replaceState(null, '', '/games/detail?id=game-1&owner=1');
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-detail"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('作品状态')).toBeTruthy();
+    expect(gameDistributionMock.getMyGame).toHaveBeenCalledWith('game-1');
+    expect(gameDistributionMock.getGame).not.toHaveBeenCalled();
+  });
+
+  it('没有 owner 的详情仍走公开详情', async () => {
+    gameDistributionMock.getMyGame.mockResolvedValue(ownerEntry);
+    gameDistributionMock.getGame.mockResolvedValue({
+      id: 'game-1',
+      title: '公开作品',
+      summary: '公开详情',
+      description: '公开详情',
+      category: '动作',
+      tags: [],
+      coverColor: '#d77a51',
+      icon: '✦',
+      author: { id: 'author-1', name: '测试作者' },
+      deviceSupport: { desktop: true, mobile: true, touch: true },
+      status: 'published',
+      currentVersion: {
+        id: 'version-1',
+        version: '1.0.0',
+        entryUrl: 'https://play.example.test/releases/version-1/index.html',
+        sha256: 'sha256',
+        publishedAt: '2026-09-18T00:00:00.000Z',
+        controls: ['键盘'],
+      },
+      playCount: 1,
+      createdAt: '2026-09-18T00:00:00.000Z',
+    });
+    window.history.replaceState(null, '', '/games/detail?id=game-1');
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-detail"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('公开作品')).toBeTruthy();
+    expect(gameDistributionMock.getMyGame).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
index a6a621256..128133c6d 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
@@ -454,8 +454,12 @@ export function PlatformEntryFlowShellImpl({
   }, [setSelectionStage]);
 
   const openGameDetail = useCallback(
-    (gameId: string) => {
-      const path = `/games/detail?id=${encodeURIComponent(gameId)}`;
+    (gameId: string, options?: { owner?: boolean }) => {
+      const params = new URLSearchParams({ id: gameId });
+      // 作者视角要一直带着 owner 作用域：刷新或直接打开该链接时详情页仍读
+      // `GET /my-games/{gameId}`，否则作者点自己的未公开作品只会拿到公开接口的 404。
+      if (options?.owner) params.set('owner', '1');
+      const path = `/games/detail?${params.toString()}`;
       setSelectionStage('game-detail', { path });
     },
     [setSelectionStage],
@@ -847,16 +851,23 @@ export function PlatformEntryFlowShellImpl({
                     ) : selectionStage === 'game-mine' ? (
                       <MyGamesPage
                         onBack={openGames}
-                        onOpenDetail={openGameDetail}
+                        onOpenDetail={(gameId) =>
+                          openGameDetail(gameId, { owner: true })
+                        }
                         onPublishVersion={
                           gamePublishGateAllowed
                             ? openGamePublishVersion
                             : undefined
                         }
+                        onResumePublish={
+                          gamePublishGateAllowed ? openGamePublish : undefined
+                        }
+                        publishEnabled={gamePublishGateAllowed}
                       />
                     ) : selectionStage === 'game-detail' ? (
                       <GameDetailPage
                         gameId={gameId}
+                        ownerView={gameSearchParams.get('owner') === '1'}
                         onBack={backFromGameDetail}
                         onPlay={openGamePlay}
                       />
diff --git a/src/services/frontendRuntimeConfigService.ts b/src/services/frontendRuntimeConfigService.ts
index c047cad3a..27d7ffa36 100644
--- a/src/services/frontendRuntimeConfigService.ts
+++ b/src/services/frontendRuntimeConfigService.ts
@@ -6,8 +6,8 @@ export type FrontendRuntimeConfig = {
   imageEditorAgentSidebarEnabled: boolean;
   agcTemplateLibraryEnabled: boolean;
   /**
-   * 游戏发布灰度开关：后端未配置 `game-distribution:publish` 时对已登录作者默认开放，
-   * 显式收紧后只有白名单/灰度命中的作者为 `true`，匿名恒为 `false`。
+   * 游戏发布灰度：未配置 `game-distribution:publish` 或 `enabled=false` 时不开放；
+   * 显式配置后只有白名单/灰度命中的作者为 `true`，匿名恒为 `false`。
    */
   gameDistributionPublishEnabled: boolean;
 };
diff --git a/src/services/gameDistributionClient.ts b/src/services/gameDistributionClient.ts
index dfb89898a..974fab5d7 100644
--- a/src/services/gameDistributionClient.ts
+++ b/src/services/gameDistributionClient.ts
@@ -7,9 +7,11 @@ import type {
   GameDistributionDeviceSupport,
   GameDistributionGame,
   GameDistributionMyReviewResponse,
+  GameDistributionRecoveryAction,
   GameDistributionReviewsResponse,
   GameDistributionSaveReviewRequest,
   GameDistributionSaveReviewResponse,
+  GameDistributionUpdateGameMetadataRequest,
   GameDistributionVersionDetail,
   GameDistributionVersionStatus as GameDistributionVersionStatusValue,
   GameDistributionVersionSummary,
@@ -133,8 +135,40 @@ export type GameDistributionVersionStatusEntry = {
   reviewReason?: string | null;
   createdAt: string;
   updatedAt: string;
+  /**
+   * 版本私有的发行入口；只有已公开版本有值，作者详情用它判定当前是否能在线游玩。
+   */
+  entryUrl?: string | null;
+  /**
+   * 服务端派生的下一步动作。作者列表投影目前不带这一项（只有版本回读带），
+   * 缺失时前端只展示状态、不自行推断动作。
+   */
+  recoveryAction?: GameDistributionRecoveryAction | null;
 };
 
+/**
+ * 作者自有游戏条目一定是「公开投影 + 私有版本状态」的形状；服务端缺字段时按空值兜底，
+ * 避免页面对半成品响应直接崩掉。
+ */
+function normalizeOwnerGameEntry(
+  value: unknown,
+): GameDistributionMyGame | null {
+  if (!value || typeof value !== 'object') return null;
+  const entry = value as Partial<GameDistributionMyGame>;
+  if (!entry.id) return null;
+  const versions = Array.isArray(entry.versions)
+    ? entry.versions.filter(
+        (item): item is GameDistributionVersionStatusEntry =>
+          Boolean(item && typeof item === 'object' && item.versionId),
+      )
+    : [];
+  return {
+    ...(entry as GameDistributionMyGame),
+    latestVersion: entry.latestVersion ?? null,
+    versions,
+  };
+}
+
 export async function listMyGames() {
   const payload = await requestJson<{ games?: unknown[] }>(
     '/my-games',
@@ -142,9 +176,114 @@ export async function listMyGames() {
     '读取我的游戏失败',
   );
   const games = Array.isArray(payload?.games) ? payload.games : [];
-  return games.filter((item): item is GameDistributionMyGame =>
-    Boolean(item && typeof item === 'object' && (item as { id?: string }).id),
+  return games
+    .map(normalizeOwnerGameEntry)
+    .filter((game): game is GameDistributionMyGame => game !== null);
+}
+
+/**
+ * 作者读取自己名下单个作品：审核中 / 被驳回 / 已下架 / 已撤回的作品都能打开，
+ * 公开详情只服务已公开投影（作者点自己的未公开作品会拿到 404）。
+ */
+export async function getMyGame(
+  gameId: string,
+): Promise<GameDistributionMyGame | null> {
+  const normalizedGameId = gameId.trim();
+  if (!normalizedGameId) return null;
+  const payload = await requestJson<{ game?: unknown }>(
+    `/my-games/${encodeURIComponent(normalizedGameId)}`,
+    { method: 'GET' },
+    '读取作品详情失败',
   );
+  return normalizeOwnerGameEntry(payload?.game);
+}
+
+/**
+ * 保存作品资料的成功响应：`game` 是公开投影形状（不含版本列表），
+ * `replayed` 表示服务端按同一个 Idempotency-Key 重放了这次写入。
+ */
+export type GameDistributionUpdateMyGameResponse = {
+  game: GameDistributionGame;
+  replayed: boolean;
+};
+
+/**
+ * 保存作品展示资料；包内容不在这里改动，仍随版本冻结。
+ *
+ * 服务端复用创建游戏的资料校验（含"必须有封面、截图必须是本人素材"），
+ * 因此编辑也必须带上当前封面/截图的素材 ID，否则资料不完整或会把线上截图清空。
+ */
+export async function updateMyGame(
+  gameId: string,
+  payload: GameDistributionUpdateGameMetadataRequest,
+  idempotencyKey: string,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) throw new Error('缺少作品编号');
+  if (!normalizedKey) throw new Error('保存作品资料缺少幂等键');
+  return requestJson<GameDistributionUpdateMyGameResponse>(
+    `/my-games/${encodeURIComponent(normalizedGameId)}`,
+    {
+      method: 'PATCH',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify(payload),
+    },
+    '保存作品资料失败',
+  );
+}
+
+/**
+ * 软删除作品：成功后该作品从作者列表与公开投影里消失，历史版本包留在回收窗口内。
+ *
+ * 与其它写动作一致要带 `Idempotency-Key`；CAS 修订号走查询串（删除本身没有请求体），
+ * 并发下架/审核后过期由服务端拒绝。
+ */
+export async function deleteMyGame(
+  gameId: string,
+  expectedPublicationRevision: number,
+  idempotencyKey: string,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) throw new Error('缺少作品编号');
+  if (!normalizedKey) throw new Error('删除作品缺少幂等键');
+  const params = new URLSearchParams({
+    expectedPublicationRevision: String(expectedPublicationRevision),
+  });
+  return requestJson<{ game?: GameDistributionGame; replayed?: boolean }>(
+    `/my-games/${encodeURIComponent(normalizedGameId)}?${params.toString()}`,
+    {
+      method: 'DELETE',
+      headers: { 'Idempotency-Key': normalizedKey },
+    },
+    '删除作品失败',
+  );
+}
+
+/**
+ * 补读版本回读里的 `recoveryAction`。
+ *
+ * 作者列表投影不带这一步动作，只为「还需要作者动作」的最新版本各回读一次；单个版本
+ * 回读失败只丢失该版本的下一步提示，不影响列表与其它作品。
+ */
+export async function loadVersionRecoveryActions(
+  versionIds: readonly string[],
+): Promise<Record<string, GameDistributionRecoveryAction>> {
+  const uniqueVersionIds = [
+    ...new Set(versionIds.map((versionId) => versionId.trim()).filter(Boolean)),
+  ];
+  const details = await Promise.allSettled(
+    uniqueVersionIds.map((versionId) => getGameVersion(versionId)),
+  );
+  const actions: Record<string, GameDistributionRecoveryAction> = {};
+  uniqueVersionIds.forEach((versionId, index) => {
+    const detail = details[index];
+    if (detail?.status === 'fulfilled') {
+      actions[versionId] = detail.value.version.recoveryAction;
+    }
+  });
+  return actions;
 }
 
 export async function unpublishGame(
diff --git a/vitest.config.ts b/vitest.config.ts
index 2d66a04ff..6401f100f 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -94,6 +94,10 @@ export default defineConfig({
   test: {
     environment: 'node',
     globals: true,
+    // 成功用例不回放被测代码写进 stdout / stderr 的内容：CI 日志里只保留每个
+    // 失败用例的断言摘要，避免 React act 警告、dev 调度日志这类噪音刷屏。
+    // 需要在本机排查时用 `vitest run --silent=false` 覆盖本次配置。
+    silent: true,
     minThreads: 1,
     maxThreads: 8,
     server: {