From a2b70d92b802d792a8e34e8c031a160651005d1b Mon Sep 17 00:00:00 2001
From: Suzumiya <suzmii@qq.com>
Date: Thu, 1 Oct 2026 16:30:40 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BD=9C=E5=93=81=E7=AE=A1=E7=90=86=E4=B8=8EPh?=
 =?UTF-8?q?aser4=E5=AE=A2=E6=88=B7=E7=AB=AF=E5=8F=91=E5=B8=83=E9=97=AD?=
 =?UTF-8?q?=E7=8E=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

补齐 Phaser4 客户端发布前校验、阶段进度与原生幂等账本

增加 Web 作者私有作品管理、资料编辑、版本历史与软删除

增加后台作品筛选、游标分页与删除治理

同步 SpacetimeDB schema、bindings、DTO、文档与定向测试
---
 apps/admin-web/src/api/adminApiClient.test.ts |  28 +-
 apps/admin-web/src/api/adminApiClient.ts      |  26 +-
 apps/admin-web/src/api/adminApiTypes.ts       |  13 +-
 .../pages/AdminGameManagementPage.test.tsx    | 110 +++++
 .../src/pages/AdminGameManagementPage.tsx     | 287 ++++++++++--
 .../src-tauri/src/commands.rs                 |  20 +
 .../src/game_distribution_publish.rs          | 127 ++++-
 .../src-tauri/src/game_package_upload.rs      |  41 +-
 .../src-tauri/src/game_publish_attempt.rs     | 390 +++++++++++++++
 .../src-tauri/src/main.rs                     |   1 +
 .../src-tauri/src/project/export.rs           | 199 ++++++++
 .../src-tauri/src/tests/project.rs            | 142 ++++++
 apps/ai-game-creator-shell/src/App.tsx        |   1 +
 .../GameDistributionPublishPanel.tsx          |  65 ++-
 .../GamePublishPhaseSteps.tsx                 |  70 +++
 .../GamePublishProgressDialog.tsx             |  13 +
 .../src/services/gameDistributionPublish.ts   |  19 +-
 .../src/services/gamePackageUploadProgress.ts | 116 +++++
 apps/ai-game-creator-shell/src/styles.css     |  96 ++++
 .../tests/gameDistributionPublish.test.ts     |  25 +
 .../tests/gameDistributionPublishLive.test.ts |  43 +-
 .../gameDistributionPublishPanel.test.tsx     | 120 ++++-
 .../tests/gamePackageUploadProgress.test.ts   | 136 ++++++
 ...划】游戏作品管理与客户端发布收口-2026-09-30.md |  49 +-
 ...�】server-rs与SpacetimeDB数据契约-2026-05-15.md |  17 +-
 ...�玩法创作】平台入口与玩法链路-2026-05-15.md |   7 +-
 .../shared/src/contracts/gameDistribution.ts  |  25 +-
 scripts/admin-web-fake-api.mjs                |  60 ++-
 .../check-game-distribution-dto-parity.mjs    |   4 +
 .../src/modules/game_distribution.rs          | 443 +++++++++++++++++-
 .../shared-contracts/src/game_distribution.rs |  50 ++
 .../crates/spacetime-client/src/active.rs     |  11 +-
 .../src/active/mapper/game_distribution.rs    |  12 +-
 .../spacetime-client/src/game_distribution.rs | 143 +++++-
 .../spacetime-client/src/module_bindings.rs   |   8 +
 ...stribution_version_and_return_procedure.rs |  16 +-
 ...stribution_version_and_return_procedure.rs |  16 +-
 ...stribution_package_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ...stribution_version_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  59 +++
 ...istribution_upload_and_return_procedure.rs |  16 +-
 ...distribution_admin_game_list_input_type.rs |   4 +
 ...istribution_admin_game_list_result_type.rs |   1 +
 ...e_distribution_admin_game_snapshot_type.rs |   1 +
 ...ame_distribution_delete_game_input_type.rs |  20 +
 .../game_distribution_game_type.rs            |   3 +
 ...distribution_update_metadata_input_type.rs |  33 ++
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ...stribution_version_and_return_procedure.rs |  16 +-
 ...stribution_version_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ...distribution_games_and_return_procedure.rs |  16 +-
 ...distribution_games_and_return_procedure.rs |  16 +-
 ...stribution_reviews_and_return_procedure.rs |  16 +-
 ...distribution_games_and_return_procedure.rs |  16 +-
 ...distribution_games_and_return_procedure.rs |  16 +-
 ...stribution_version_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ...version_for_review_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ..._distribution_game_and_return_procedure.rs |  16 +-
 ...tion_game_metadata_and_return_procedure.rs |  62 +++
 .../spacetime-module/src/game_distribution.rs | 410 +++++++++++++++-
 .../crates/spacetime-module/src/migration.rs  |   2 +
 .../game-distribution/GameDetailPage.tsx      | 176 ++++++-
 .../GameDistributionPages.test.tsx            | 117 ++++-
 .../GamePublishMediaFieldset.tsx              | 234 +++++++++
 .../game-distribution/GamePublishPage.tsx     | 328 +------------
 .../game-distribution/GameVersionHistory.tsx  |  79 ++++
 .../GameWorkMetadataEditor.tsx                | 337 +++++++++++++
 .../game-distribution/MyGamesPage.test.tsx    | 344 +++++++++++++-
 .../game-distribution/MyGamesPage.tsx         | 417 ++++++++++++++++-
 .../game-distribution/gameDistribution.css    | 133 ++++++
 .../game-distribution/gameMetadataOptions.ts  |  55 +++
 .../gamePublishMediaDefaults.ts               |  80 ++++
 .../gameVersionHistoryModel.ts                |  60 +++
 .../PlatformEntryActiveFlowShell.test.tsx     | 160 +++++++
 .../PlatformEntryActiveFlowShell.tsx          |  17 +-
 src/services/gameDistributionClient.ts        | 143 +++++-
 80 files changed, 5836 insertions(+), 676 deletions(-)
 create mode 100644 apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
 create mode 100644 apps/ai-game-creator-shell/src/components/game-distribution/GamePublishPhaseSteps.tsx
 create mode 100644 apps/ai-game-creator-shell/src/services/gamePackageUploadProgress.ts
 create mode 100644 apps/ai-game-creator-shell/tests/gamePackageUploadProgress.test.ts
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/delete_game_distribution_game_and_return_procedure.rs
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/game_distribution_delete_game_input_type.rs
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_metadata_input_type.rs
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_game_metadata_and_return_procedure.rs
 create mode 100644 src/components/game-distribution/GamePublishMediaFieldset.tsx
 create mode 100644 src/components/game-distribution/GameVersionHistory.tsx
 create mode 100644 src/components/game-distribution/GameWorkMetadataEditor.tsx
 create mode 100644 src/components/game-distribution/gameMetadataOptions.ts
 create mode 100644 src/components/game-distribution/gamePublishMediaDefaults.ts
 create mode 100644 src/components/game-distribution/gameVersionHistoryModel.ts

diff --git a/apps/admin-web/src/api/adminApiClient.test.ts b/apps/admin-web/src/api/adminApiClient.test.ts
index 7c5464f06..299f2c2b4 100644
--- a/apps/admin-web/src/api/adminApiClient.test.ts
+++ b/apps/admin-web/src/api/adminApiClient.test.ts
@@ -568,7 +568,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({
@@ -606,6 +606,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 8aae410af..9dd924e8f 100644
--- a/apps/admin-web/src/api/adminApiClient.ts
+++ b/apps/admin-web/src/api/adminApiClient.ts
@@ -33,6 +33,7 @@ import type {
   AdminExternalApiKeyListResponse,
   AdminFeatureGateConfigResponse,
   AdminGameDistributionGameListResponse,
+  AdminGameDistributionGameStatus,
   AdminGameDistributionRestoreRequest,
   AdminGameDistributionRestoreResponse,
   AdminGameDistributionReviewListResponse,
@@ -1243,17 +1244,36 @@ export function listAdminGameDistributionReviews(token: string, limit = 48) {
   );
 }
 
+/**
+ * 后台作品管理列表。
+ *
+ * 关键词、作者与状态过滤以及游标分页都由服务端执行：前端只透传查询参数，
+ * 不本地过滤，否则分页边界会与 `nextCursor` 的语义打架。
+ */
 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 429ce7c5a..e6efdcc19 100644
--- a/apps/admin-web/src/api/adminApiTypes.ts
+++ b/apps/admin-web/src/api/adminApiTypes.ts
@@ -1158,18 +1158,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/AdminGameManagementPage.test.tsx b/apps/admin-web/src/pages/AdminGameManagementPage.test.tsx
index 18407c5bb..8836d3244 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: [],
 };
 
@@ -263,3 +284,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 074a92927..043f6c3d8 100644
--- a/apps/admin-web/src/pages/AdminGameManagementPage.tsx
+++ b/apps/admin-web/src/pages/AdminGameManagementPage.tsx
@@ -4,15 +4,17 @@ import {
   AdminAlert,
   AdminButton,
   AdminDialog,
+  AdminField,
   AdminFieldGroup,
   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 +23,7 @@ import {
 } from '../api/adminApiClient';
 import type {
   AdminGameDistributionGameEntry,
+  AdminGameDistributionGameStatus,
   AdminGameDistributionGameVersionEntry,
 } from '../api/adminApiTypes';
 import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
@@ -38,8 +41,32 @@ 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];
+
+interface GameFilters {
+  keyword: string;
+  owner: string;
+  status: AdminGameDistributionGameStatus | '';
+}
+
+const EMPTY_FILTERS: GameFilters = { keyword: '', owner: '', status: '' };
+
 function gameStatusMeta(status: string) {
   return (
     GAME_STATUS_META[status] ?? {
@@ -89,7 +116,13 @@ 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('');
@@ -99,26 +132,109 @@ export function AdminGameManagementPage({
   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]);
 
+  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,
+  );
+
   async function suspendGame(entry: AdminGameDistributionGameEntry) {
     const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
     if (!reason) {
@@ -151,7 +267,7 @@ export function AdminGameManagementPage({
         ...current,
         [entry.gameId]: '',
       }));
-      await loadGames();
+      refreshCurrentPage();
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
@@ -177,7 +293,7 @@ export function AdminGameManagementPage({
         { expectedPublicationRevision: entry.publicationRevision },
       );
       setStatusMessage(`游戏《${entry.title || entry.gameId}》已恢复`);
-      await loadGames();
+      refreshCurrentPage();
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
@@ -193,7 +309,7 @@ export function AdminGameManagementPage({
           <AdminButton
             variant="secondary"
             type="button"
-            onClick={() => void loadGames()}
+            onClick={refreshCurrentPage}
             disabled={isLoading}
           >
             <RefreshCcw aria-hidden="true" />
@@ -211,14 +327,93 @@ 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"
         columns={[
@@ -230,8 +425,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 (
@@ -277,12 +495,26 @@ export function AdminGameManagementPage({
                 <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>
                 <AdminActionRow>
-                  {!isSuspended ? (
+                  {isDeleted ? null : isSuspended ? (
+                    <AdminButton
+                      variant="primary"
+                      type="button"
+                      disabled={busy}
+                      onClick={() => void restoreGame(entry)}
+                    >
+                      {busy ? '处理中…' : '恢复'}
+                    </AdminButton>
+                  ) : (
                     <>
                       <AdminFieldGroup
                         label="下架原因"
@@ -309,15 +541,6 @@ export function AdminGameManagementPage({
                         {busy ? '处理中…' : '下架'}
                       </AdminButton>
                     </>
-                  ) : (
-                    <AdminButton
-                      variant="primary"
-                      type="button"
-                      disabled={busy}
-                      onClick={() => void restoreGame(entry)}
-                    >
-                      {busy ? '处理中…' : '恢复'}
-                    </AdminButton>
                   )}
                   <AdminButton
                     variant="secondary"
diff --git a/apps/ai-game-creator-shell/src-tauri/src/commands.rs b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
index 072750eca..754f637ed 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/commands.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
@@ -6163,6 +6163,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 {
@@ -6178,11 +6182,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/game_distribution_publish.rs b/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
index 35acdde86..8073ec019 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
@@ -495,19 +495,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,
@@ -517,6 +516,29 @@ 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,
@@ -526,7 +548,11 @@ pub(crate) async fn publish_local_project_game(
     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()
@@ -546,13 +572,36 @@ pub(crate) async fn publish_local_project_game(
     if metadata.screenshots.len() > 6 {
         return Err("游戏截图最多 6 张".to_string());
     }
-    let root_key = idempotency_key
+    // 根幂等键由账本按「账号 + origin + 本地项目 + 包摘要」解析：同一份包重发、响应丢失后
+    // 重试、进程重启后的分片续传都落在同一次服务端尝试上；包内容变了才换键。
+    let root_key = match idempotency_key
         .as_deref()
         .map(str::trim)
         .filter(|value| !value.is_empty())
-        .map(str::to_string)
-        .unwrap_or_else(|| format!("agc-publish-{}", uuid::Uuid::new_v4()));
+    {
+        Some(explicit) => explicit.to_string(),
+        None => {
+            crate::game_publish_attempt::resolve_game_publish_root_key(
+                &app_data_dir,
+                &snapshot.user_id,
+                &snapshot.api_base_url,
+                &local_project_id,
+                &staged.package_sha256,
+            )?
+            .0
+        }
+    };
     let client = build_client()?;
+    // 准备阶段还没有版本标识，事件只用根键关联。
+    emit_publish_progress(
+        &app,
+        &root_key,
+        "",
+        "prepare",
+        "正在创建平台游戏与发行版本…",
+        0,
+        0,
+    );
     let game_value = request_json(
         &client,
         &snapshot,
@@ -572,7 +621,7 @@ pub(crate) async fn publish_local_project_game(
         return Err("创建平台游戏未返回游戏 ID".to_string());
     }
     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,
@@ -605,8 +654,21 @@ pub(crate) async fn publish_local_project_game(
     }
     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 {
@@ -618,18 +680,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,
@@ -650,6 +733,14 @@ pub(crate) async fn publish_local_project_game(
     .await?;
     let submitted: SubmittedVersion =
         serde_json::from_value(submit_value).unwrap_or(SubmittedVersion { version: None });
+    // 服务端已经完成收口（送审成功）：清掉本次尝试记录，下一次同内容的发布就是一个新版本。
+    // 清理失败不影响这次已经成功的发布——重试只会命中服务端幂等收据，不会多建游戏或版本。
+    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,
         version_id: version.version_id,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
index a9a395c17..1b14d959c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
@@ -366,10 +366,14 @@ impl<'a> GamePackageUploadRequest<'a> {
 }
 
 /// 分片续传主循环：权威偏移来自服务端，失败按可重试分类退避，偏移不符立即按权威偏移继续。
+///
+/// `on_verify` 在整包收齐、调用服务端 `/complete`（重算摘要 + 展开清单 + 确认完整对象）
+/// 之前触发：那一步是真正的「校验」，渲染层据此把进度切到校验阶段。
 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}"))?
@@ -444,6 +448,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,
@@ -456,14 +461,25 @@ pub(crate) async fn upload_staged_game_package(
     Ok(outcome)
 }
 
-/// 进度事件的载荷形状（渲染进程按它显示进度）。
+/// 进度事件的载荷形状（渲染进程按它显示阶段与百分比）。
+///
+/// `phase` 是发布链路的稳定阶段标识（`prepare` / `upload` / `verify` / `submit`），
+/// 渲染层据此点亮步骤条；`upload` 之外的阶段 `receivedBytes` / `totalBytes` 为 0，
+/// 表示该阶段没有可换算的百分比而不是 0% 进度。`publishId` 是本次发布尝试的根幂等键，
+/// 只用于把事件归到同一次发布，不含 token 或任何凭据。
 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,
     })
@@ -473,6 +489,29 @@ pub(crate) fn progress_event_payload(
 mod tests {
     use super::*;
 
+    #[test]
+    fn progress_payload_carries_publish_stage_and_percent_inputs() {
+        let payload = progress_event_payload(
+            "ver-1",
+            "agc-publish-key",
+            "upload",
+            "正在上传发行包…",
+            8 * 1024 * 1024,
+            12 * 1024 * 1024,
+        );
+        assert_eq!(payload["versionId"], "ver-1");
+        assert_eq!(payload["publishId"], "agc-publish-key");
+        assert_eq!(payload["phase"], "upload");
+        assert_eq!(payload["message"], "正在上传发行包…");
+        assert_eq!(payload["receivedBytes"], 8 * 1024 * 1024);
+        assert_eq!(payload["totalBytes"], 12 * 1024 * 1024);
+        // 载荷只带本地标识与计数，不带 token、路径或包字节。
+        let serialized = payload.to_string();
+        for forbidden in ["token", "Bearer", "stagingPath", ":\\"] {
+            assert!(!serialized.contains(forbidden), "{serialized}");
+        }
+    }
+
     #[test]
     fn chunk_plan_covers_whole_package_without_gaps_or_overlap() {
         let total = 20 * 1024 * 1024 + 3;
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..c869e76ce
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_publish_attempt.rs
@@ -0,0 +1,390 @@
+//! 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,
+    /// 本次尝试的发布根幂等键。
+    root_key: String,
+    updated_at: u64,
+}
+
+#[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;
+    }
+    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(),
+        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,
+    account_id: &str,
+    origin: &str,
+    local_project_id: &str,
+    package_sha256: &str,
+) -> Result<(String, bool), String> {
+    let candidate = normalize_record(GamePublishAttemptRecord {
+        account_id: account_id.to_string(),
+        origin: origin.to_string(),
+        local_project_id: local_project_id.to_string(),
+        package_sha256: package_sha256.to_string(),
+        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.account_id == candidate.account_id
+            && record.origin == candidate.origin
+            && record.local_project_id == candidate.local_project_id
+            && record.package_sha256 == candidate.package_sha256
+    }) {
+        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))
+}
+
+/// 一次发布在服务端收口后清掉记录：下一次同样内容的发布就是一个新版本。
+///
+/// 清理失败不影响已经成功的发布——重试只会命中服务端幂等收据而不会多建版本，
+/// 代价是作者可能看不到新版本，因此这里只在账本可写时才是「干净」的。
+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
+    }
+
+    #[test]
+    fn same_package_reuses_root_key_and_new_package_rotates_it() {
+        let dir = fixture_dir("reuse");
+        let sha = "a".repeat(64);
+        let (first, reused) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+                .expect("first key");
+        assert!(!reused);
+        assert!(first.starts_with("agc-publish-"));
+
+        let (again, reused) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+                .expect("reused key");
+        assert!(reused, "同一份包重发必须复用同一个根幂等键");
+        assert_eq!(again, first);
+
+        // 重启不改变结论：换一个进程视角重新读盘仍然是同一个键。
+        let (after_restart, reused) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+                .expect("restarted key");
+        assert!(reused);
+        assert_eq!(after_restart, first);
+
+        let other_sha = "b".repeat(64);
+        let (rotated, reused) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &other_sha)
+                .expect("rotated key");
+        assert!(!reused, "换了包就不是同一次尝试");
+        assert_ne!(rotated, first);
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn attempts_are_scoped_per_account_origin_and_project() {
+        let dir = fixture_dir("scope");
+        let sha = "c".repeat(64);
+        let (base, _) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+                .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, 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, "user-1", "https://dev.test", "proj-1", &sha)
+                .expect("first key");
+        clear_game_publish_attempt(&dir, "user-1", "https://dev.test", "proj-1")
+            .expect("clear attempt");
+        let (second, reused) =
+            resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+                .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);
+        resolve_game_publish_root_key(&dir, "user-1", "https://dev.test", "proj-1", &sha)
+            .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")
+        );
+        // 账本不写 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 31d9323e1..b6e6fa737 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/main.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/main.rs
@@ -141,6 +141,7 @@ mod environment_check;
 pub mod error_report;
 mod game_distribution_publish;
 mod game_package_upload;
+mod game_publish_attempt;
 mod git_inspect;
 mod goal;
 mod http_client;
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..c048e0147 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
@@ -269,6 +269,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 +304,173 @@ 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 构建工作区」的项目（`resolve_publish_build_cwd` 命中）：老的
+/// 单文件 HTML 项目没有 `package.json`，不在首版 npm 打包合同内，保持原有发布能力。
+/// 判定顺序以**将被构建的那个工作区**为准，它没声明 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;
+    let mut workspace_found = false;
+    for cwd_relative in candidates {
+        let Some((package_root, package)) = read_publish_workspace_package(root, cwd_relative)?
+        else {
+            continue;
+        };
+        workspace_found = true;
+        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;
+        }
+    }
+    if !workspace_found {
+        return Ok(());
+    }
+    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(())
+}
+
+/// 发布前校验工程栈：存在 npm 构建工作区时要求 Phaser 4 + Vite，否则不作判断。
+pub(crate) fn ensure_publish_project_stack(root: &Path) -> Result<(), String> {
+    match resolve_publish_build_cwd(root)? {
+        Some(cwd_relative) => ensure_publish_project_stack_at(root, cwd_relative),
+        None => Ok(()),
+    }
+}
+
 /// 发布前的客户端预检：包体不得超过平台上限。
 ///
 /// 服务端仍会独立校验；这里先判一次是为了给作者可操作错误（含实际体积与上限），
@@ -660,6 +830,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;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
index f1ed549ff..9523a9625 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
@@ -4019,6 +4019,148 @@ fn publish_build_plan_falls_back_to_root_npm_build() {
     fs::remove_dir_all(root).ok();
 }
 
+#[test]
+fn publish_stack_validation_accepts_scaffolded_phaser4_vite_project() {
+    let root = unique_project_path();
+    init_local_game_project_at(&root, "project-stack-ok", "栈校验通过项目").expect("project init");
+    ensure_publish_project_stack(&root).expect("Phaser 4 + Vite 脚手架应通过发布前工程栈校验");
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn publish_stack_validation_reports_actionable_error_for_phaser3() {
+    let root = unique_project_path();
+    init_local_game_project_at(&root, "project-stack-phaser3", "Phaser 3 项目")
+        .expect("project init");
+    fs::write(
+        root.join("game/package.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "name": "stack-phaser3",
+            "private": true,
+            "scripts": { "build": "vite build" },
+            "dependencies": { "phaser": "^3.90.0" },
+            "devDependencies": { "vite": "^6.2.0" }
+        }))
+        .expect("serialize phaser3 package json"),
+    )
+    .expect("write phaser3 package json");
+
+    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}"
+    );
+
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn publish_stack_validation_requires_phaser_dependency_and_vite() {
+    let root = unique_project_path();
+    init_local_game_project_at(&root, "project-stack-missing", "缺依赖项目").expect("project init");
+    fs::write(
+        root.join("game/package.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "name": "stack-no-phaser",
+            "private": true,
+            "scripts": { "build": "vite build" },
+            "devDependencies": { "vite": "^6.2.0" }
+        }))
+        .expect("serialize no-phaser package json"),
+    )
+    .expect("write no-phaser package json");
+    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");
+    fs::write(
+        root.join("game/package.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "name": "stack-webpack",
+            "private": true,
+            "scripts": { "build": "webpack" },
+            "dependencies": { "phaser": "4.2.1" }
+        }))
+        .expect("serialize non-vite package json"),
+    )
+    .expect("write non-vite package json");
+    let error = ensure_publish_project_stack(&root).expect_err("非 Vite 工程必须被拦下");
+    assert!(error.contains("vite"), "{error}");
+    assert!(error.contains("Vite 构建"), "{error}");
+
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn publish_stack_validation_reads_semver_ranges_and_lockfile_versions() {
+    let root = unique_project_path();
+    init_local_game_project_at(&root, "project-stack-semver", "版本区间项目")
+        .expect("project init");
+    fs::write(
+        root.join("game/package.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "name": "stack-semver",
+            "private": true,
+            "scripts": { "build": "vite build" },
+            "dependencies": { "phaser": ">=4 <5" },
+            "devDependencies": { "vite": "^6.2.0" }
+        }))
+        .expect("serialize semver package json"),
+    )
+    .expect("write semver package json");
+    ensure_publish_project_stack(&root).expect(">=4 <5 属于 Phaser 4");
+
+    // 声明成 `*` 时以 package-lock.json 的解析版本为准。
+    fs::write(
+        root.join("game/package.json"),
+        serde_json::to_string_pretty(&serde_json::json!({
+            "name": "stack-star",
+            "private": true,
+            "scripts": { "build": "vite build" },
+            "dependencies": { "phaser": "*" },
+            "devDependencies": { "vite": "^6.2.0" }
+        }))
+        .expect("serialize star package json"),
+    )
+    .expect("write star package json");
+    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}");
+
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn publish_stack_validation_skips_projects_without_npm_build_workspace() {
+    let root = unique_project_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");
+
+    ensure_publish_project_stack(&root).expect("没有 npm 构建工作区时不做 Phaser 4 判断");
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn publish_export_runs_project_build_before_packaging() {
     let root = unique_project_path();
diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index f1d3bee15..538b7ba14 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -936,6 +936,7 @@ export function App({
     setPublishProgress({
       phase: 'running',
       message: '正在构建并打包试玩包，请稍候…',
+      step: 'build',
     });
     try {
       const result = await invoke<LocalProjectExportPackageResult>(
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..114366e48 100644
--- a/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
@@ -8,7 +8,6 @@ import { resolveTauriInvoke } from '../../app/tauri';
 import type { LocalProjectExportPackageResult } from '../../app/types';
 import { uploadPlatformMediaAsset } from '../../services/assetDirectUpload';
 import {
-  createGameDistributionPublishKey,
   type GameDistributionPublishMetadata,
   type GameDistributionPublishResult,
   generateGameDistributionCover,
@@ -17,7 +16,14 @@ import {
   readGameCoverGenerationPrice,
   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;
@@ -182,7 +188,12 @@ export function GameDistributionPublishPanel({
     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 metadataSuggestionRequestRef = useRef(0);
   const summaryTouchedRef = useRef(false);
   const categoryTouchedRef = useRef(false);
@@ -210,6 +221,7 @@ export function GameDistributionPublishPanel({
     setCoverGenerationPrice(null);
     setCoverGenerationDetail('');
     setPreviewScreenshot(null);
+    setPublishPhase(null);
     summaryTouchedRef.current = false;
     categoryTouchedRef.current = false;
 
@@ -240,12 +252,6 @@ export function GameDistributionPublishPanel({
       });
   }, [manifest, open, packageResult?.packageRelativePath]);
 
-  useEffect(() => {
-    if (open) {
-      publishIdempotencyKeyRef.current = createGameDistributionPublishKey();
-    }
-  }, [open, packageResult?.packageRelativePath]);
-
   useEffect(() => {
     if (!open) return;
     let cancelled = false;
@@ -485,6 +491,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,
@@ -506,7 +538,6 @@ export function GameDistributionPublishPanel({
             )
             .map((item) => item.assetObjectId),
         },
-        idempotencyKey: publishIdempotencyKeyRef.current,
       });
       setResult(next);
       onPublished?.(next);
@@ -515,7 +546,9 @@ export function GameDistributionPublishPanel({
         nextError instanceof Error ? nextError.message : String(nextError),
       );
     } finally {
+      unsubscribe();
       setBusy(false);
+      setPublishPhase(null);
     }
   }
 
@@ -811,6 +844,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"
@@ -833,7 +878,7 @@ export function GameDistributionPublishPanel({
                 }
               >
                 {busy
-                  ? '上传中…'
+                  ? '正在发布…'
                   : generatingCover
                     ? '封面生成中…'
                     : screenshotsUploading
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/services/gameDistributionPublish.ts b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
index fc67e37cd..d9e98ab70 100644
--- a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
+++ b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
@@ -61,14 +61,6 @@ export type GameDistributionPublishResult = {
   fileCount: number;
 };
 
-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}`;
-}
-
 export type GameDistributionPublishMetadataSuggestion = {
   summary: string;
   category: GameDistributionCategory;
@@ -226,6 +218,12 @@ export async function publishLocalProjectGame(args: {
   packageRelativePath: string;
   manifest: GameCreationAppManifest;
   metadata?: Partial<GameDistributionPublishMetadata>;
+  /**
+   * 发布根幂等键。渲染层默认**不**生成也不持久化它：原生发布链路按
+   * 「账号身份 + 本地项目 + 发行包摘要」在应用数据里维护发布尝试账本，同一份包
+   * 重发、响应丢失、进程重启与分片续传都落在同一次服务端尝试上。只有显式传入
+   * （测试或调用方已持有键）时才覆盖账本。
+   */
   idempotencyKey?: string;
 }): Promise<GameDistributionPublishResult> {
   const projectPath = args.projectPath.trim();
@@ -239,8 +237,7 @@ export async function publishLocalProjectGame(args: {
     throw new Error('发布需要本地项目标识，请重新打开项目后再试');
   }
   const gameMetadata = toCreateGameRequest(metadata, localProjectId);
-  const rootKey =
-    args.idempotencyKey?.trim() || createGameDistributionPublishKey();
+  const rootKey = args.idempotencyKey?.trim() ?? '';
   // 发布编排、认证、origin、分片续传与送审都在 Rust 完成；渲染进程只传递
   // 已归一化的资料和本地项目相对包路径，不接触 token、base URL 或整包字节。
   return args.invoke<GameDistributionPublishResult>(
@@ -249,7 +246,7 @@ export async function publishLocalProjectGame(args: {
       projectPath,
       packageRelativePath,
       metadata: gameMetadata,
-      idempotencyKey: rootKey,
+      ...(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 86fb836d4..12888ab2d 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -3913,6 +3913,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;
@@ -9894,6 +9902,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);
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
index e1213d6a4..ebfbcbf38 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
@@ -91,6 +91,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(
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
index a55e9fee9..ac81e4baa 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,13 +487,21 @@ liveTest(
     } as unknown as GameCreationAppManifest;
     // 记录本次发布实际发送过的分片偏移，用来证明「中断后不重传已收字节」。
     const sentOffsets: number[] = [];
+    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 ?? '');
+        // 渲染层不再铸键；显式传入时覆盖账本，与 Rust 发布命令同口径。
+        const explicitKey = String(args?.idempotencyKey ?? '').trim();
+        const rootKey =
+          explicitKey ||
+          attempts.resolve(
+            String(metadata.localProjectId),
+            staged.packageSha256,
+          );
         const game = await unwrap<{
           id: string;
           publicationRevision?: number;
@@ -534,6 +568,8 @@ liveTest(
             },
           ),
         );
+        // 送审成功即服务端收口：原生账本同样在这里清除本次尝试。
+        attempts.clear(String(metadata.localProjectId));
         return {
           gameId: game.id,
           versionId: version.versionId,
@@ -612,7 +648,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',
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
index ddc3458b8..d23c916bf 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,
@@ -25,6 +26,10 @@ import {
   readGameCoverGenerationPrice,
   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 =
@@ -124,6 +129,8 @@ beforeEach(() => {
 
 afterEach(() => {
   cleanup();
+  eventFake?.restore();
+  eventFake = null;
   vi.mocked(generateGameDistributionCover).mockReset();
   vi.mocked(publishLocalProjectGame).mockReset();
   vi.mocked(readGameCoverGenerationPrice).mockReset();
@@ -311,7 +318,9 @@ 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();
@@ -335,7 +344,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({
@@ -350,6 +359,113 @@ describe('GameDistributionPublishPanel', () => {
     expect(await screen.findByText('已提交审核')).not.toBeNull();
   });
 
+  test('发布进行中按原生事件显示阶段与上传百分比', async () => {
+    let resolvePublish: (value: unknown) => void = () => undefined;
+    vi.mocked(publishLocalProjectGame).mockImplementation(() => {
+      const pending = Promise.withResolvers<unknown>();
+      resolvePublish = pending.resolve;
+      return pending.promise 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(
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/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md b/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md
index eef8998e6..5239fcc45 100644
--- a/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md
+++ b/docs/project-memory/plans/【实施计划】游戏作品管理与客户端发布收口-2026-09-30.md
@@ -7,14 +7,9 @@
 
 在 10.7「陶泥儿游戏平台」上线前，把「创作者作品管理（用户侧 / 后台）+ 客户端打包上传（只保证 Phaser 4）」这条链路补齐到可用：作品能进来、能看得见状态、能管住。
 
-## 当前事实
-
 - 发布管道（AGC 构建打包 → 8 MiB 分片上传 → 送审 → 后台审核 → 公开可玩 → 发行网关）已实现，并有真实栈证据（见[实施计划【游戏分发阶段A领域合同】](【实施计划】游戏分发阶段A领域合同-2026-09-19.md)）。
-- 未通电：`game-distribution:publish` 灰度默认关闭；生产 0 个作品；dev 仅 4 条记录。
-- 创作者侧缺作品管理：AGC 内没有作品列表 / 详情；`/games/mine` 不能删除作品、不能改展示资料、看不到版本历史。
-- 作者点自己的「审核中 / 被驳回 / 已下架」作品只有 404：公开详情只服务已公开投影。
-- 后台作品管理前端固定 50 条、无搜索无分页。
-- 客户端发布没有真实进度（分片进度事件 Rust 已 emit、前端零监听）；幂等键只存在于面板内存，关面板即换 key。
+- 本轮已补齐：客户端 Phaser 4 + Vite 工程栈门禁、发布阶段/上传百分比、发布根幂等账本；Web 作者私有详情、状态/版本筛选、版本历史、资料编辑、软删除和作者操作；后台作品搜索、作者/状态筛选、游标分页与删除状态展示。
+- 生产发布开关仍默认关闭；真实客户端 GUI 发布、生产首个作品和发布包清理策略仍需运行时取证。
 
 ## 已落地（本分支）
 
@@ -26,23 +21,21 @@
 
 设计要点：不新增 SpacetimeDB 表与 procedure。详情路由的 game 走 `get_game_distribution_game`（owner 作用域，精确命中），版本沿用作者自有列表 procedure 的聚合结果。
 
-## 计划
+## 计划与落地状态
 
 ### 波 1：闭环可用
 
-1. AGC 真机把「构建 → 打包 → 分片上传 → 送审」跑通一次（唯一还没在客户端 GUI 取证的环节）。
-2. 发布进度接线：前端监听既有 `game-package-upload-progress`，渲染真实阶段与百分比。
-3. 幂等键落盘：按 `gameId` + 本地项目持久化，重试复用同一 key。
-4. AGC「我的作品」页：状态筛选、内联驳回理由、行内操作。
-5. AGC 作品详情抽屉：展示资料、当前公开版本、版本历史、公开链接。
-6. 运营开闸 + 生产发布第一个作品，走完审核 → 公开 → 游客可玩。
+- [ ] AGC 真机把「构建 → 打包 → 分片上传 → 送审」跑通一次。
+- [x] 发布进度接线：前端监听既有 `game-package-upload-progress`，渲染真实阶段与百分比。
+- [x] 幂等键落盘：按账号、origin、本地项目和包摘要持久化根键，重试复用同一 key。
+- [ ] 运营开闸 + 生产发布第一个作品，走完审核 → 公开 → 游客可玩。
 
 ### 波 2：管理完整
 
-7. 作品资料编辑：展示资料在 `game` 级可编辑、立即生效并留审计；包仍随版本冻结。
-8. 作品软删除：`game_distribution_game` 末尾追加 `deleted_at`，公开投影与列表过滤软删行，OSS 对象进入回收窗口。
-9. 网页侧对齐：`/games/mine` 补删除、资料编辑、版本历史、作者看自己未公开作品。
-10. 后台作品列表：分页 + 搜索 + 按作者筛选（当前前端固定 50 条）。
+- [x] 作品资料编辑：展示资料在 `game` 级可编辑、立即生效并留审计；包仍随版本冻结。
+- [x] 作品软删除：`game_distribution_game` 末尾追加 `deleted_at`，公开投影与列表过滤软删行。
+- [x] 网页侧对齐：`/games/mine` 补删除、资料编辑、版本历史、作者查看未公开作品。
+- [x] 后台作品列表：游标分页 + 搜索 + 按作者/状态筛选。
 
 ### 波 3：运营治理
 
@@ -51,20 +44,38 @@
 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 / 单 HTML）发布的主动拦截：当前只给泛化错误文案。
+- 非 Phaser（Godot / Cocos / Unity）发布的主动拦截：这些工程没有 npm 构建工作区，仍只给泛化错误文案（单 HTML 项目同理）。
 - 发布包清理策略的上线验收。
diff --git a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
index 4f61f7f79..70865d2c6 100644
--- a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
+++ b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
@@ -458,8 +458,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` 的投影。
 
 ### `game_distribution_version`
 
@@ -473,11 +475,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 9ba6d41b5..0e755b302 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 发行合同；生产发布开关默认关闭 |
 
 ### 交付目标与范围
 
@@ -122,6 +122,8 @@
 | `GET /game-distribution/releases/{gameId}[/{assetPath}]` | 游客 | **已实现**：根路径等价于 `index.html`；发行网关只服务当前已公开版本包内文件，按扩展名白名单设内容类型，未知扩展名 404，带 Cookie 的请求 403；游玩页的入口来自详情投影的 `currentVersion.entryUrl` |
 | `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、重算摘要与文件清单并写入私有对象；不执行游戏代码 |
@@ -132,6 +134,7 @@
 | `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 与幂等键；后台游戏审核页提供带原因输入与二次确认的入口；此行是完整后台路径 |
+| `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；服务端响应不包含存储凭据和本地绝对路径。
 
diff --git a/packages/shared/src/contracts/gameDistribution.ts b/packages/shared/src/contracts/gameDistribution.ts
index 388a3ac3a..c08c6609d 100644
--- a/packages/shared/src/contracts/gameDistribution.ts
+++ b/packages/shared/src/contracts/gameDistribution.ts
@@ -133,20 +133,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/check-game-distribution-dto-parity.mjs b/scripts/check-game-distribution-dto-parity.mjs
index 672cd1b2b..44544bf7b 100644
--- a/scripts/check-game-distribution-dto-parity.mjs
+++ b/scripts/check-game-distribution-dto-parity.mjs
@@ -41,6 +41,10 @@ const PAIRS = [
     'GameDistributionCreateVersionRequest',
     'GameDistributionCreateVersionRequest',
   ],
+  [
+    'GameDistributionUpdateGameMetadataRequest',
+    'GameDistributionUpdateGameMetadataRequest',
+  ],
   ['GameDistributionPrivateVersion', 'GameDistributionPrivateVersion'],
 ];
 
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 a88aebd16..af2a6a2fe 100644
--- a/server-rs/crates/api-server/src/modules/game_distribution.rs
+++ b/server-rs/crates/api-server/src/modules/game_distribution.rs
@@ -27,18 +27,20 @@ use serde::Deserialize;
 use serde_json::{Value, json};
 use shared_contracts::game_distribution::{
     GAME_DISTRIBUTION_CATEGORIES, GameDistributionCreateGameRequest,
-    GameDistributionCreateVersionRequest, GameDistributionInputMode,
+    GameDistributionCreateVersionRequest, GameDistributionInputMode, GameDistributionOrientation,
     GameDistributionPublishMetadataSuggestion, GameDistributionPublishMetadataSuggestionRequest,
+    GameDistributionUpdateGameMetadataRequest,
 };
 use spacetime_client::{
     GameDistributionAdminGameListRecordInput, GameDistributionAdminGameRecord,
     GameDistributionAdminVersionRecord, GameDistributionApproveRecordInput,
-    GameDistributionCancelVersionRecordInput, GameDistributionGameRecord,
-    GameDistributionGetGameRecordInput, GameDistributionOwnerGameRecord,
-    GameDistributionPublicGameListRecordInput, GameDistributionPublicGameRecord,
-    GameDistributionRejectRecordInput, GameDistributionRestoreRecordInput,
-    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
-    GameDistributionUnpublishRecordInput, GameDistributionVersionRecord, SpacetimeClientError,
+    GameDistributionCancelVersionRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionGameRecord, GameDistributionGetGameRecordInput,
+    GameDistributionOwnerGameRecord, GameDistributionPublicGameListRecordInput,
+    GameDistributionPublicGameRecord, GameDistributionRejectRecordInput,
+    GameDistributionRestoreRecordInput, GameDistributionSubmitReviewRecordInput,
+    GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionUpdateMetadataRecordInput, GameDistributionVersionRecord, SpacetimeClientError,
 };
 use tracing::{debug, info, warn};
 use uuid::Uuid;
@@ -51,6 +53,7 @@ use crate::{
     platform_errors::{map_llm_error, map_oss_error},
     request_context::RequestContext,
     state::AppState,
+    tracking::{TrackingEventDraft, record_tracking_event_after_success},
 };
 
 pub(crate) const MAX_PACKAGE_REQUEST_BODY_BYTES: usize = MAX_PACKAGE_BYTES as usize + 1024;
@@ -64,6 +67,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;
 /// 首版截图上限，与主规范冻结口径一致。
@@ -181,6 +186,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)]
@@ -236,7 +256,9 @@ pub fn router(state: AppState) -> Router<AppState> {
         .route("/api/game-distribution/my-games", get(list_my_games))
         .route(
             "/api/game-distribution/my-games/{game_id}",
-            get(get_owner_game),
+            get(get_owner_game)
+                .patch(update_owner_game_metadata)
+                .delete(delete_owner_game),
         )
         .route(
             "/api/game-distribution/games/{game_id}/unpublish",
@@ -578,6 +600,207 @@ async fn load_owner_game_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>,
@@ -615,10 +838,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,
@@ -1494,9 +1714,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!(
@@ -1504,13 +1741,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,
         }),
     ))
 }
@@ -1800,6 +2043,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 个字符"));
@@ -1940,6 +2191,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()
@@ -2299,6 +2551,11 @@ fn map_spacetime_error(error: SpacetimeClientError) -> AppError {
             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("已不存在") =>
         {
@@ -2555,9 +2812,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;
 
     fn metadata() -> GameDistributionCreateGameRequest {
         GameDistributionCreateGameRequest {
@@ -2998,6 +3253,7 @@ mod tests {
 
         // 作者作品详情是 owner 作用域路由，未带 Bearer 时同样在进入业务前被拒绝。
         let unauthenticated_owner_game = app
+            .clone()
             .oneshot(
                 Request::builder()
                     .uri("/api/game-distribution/my-games/game_1")
@@ -3010,6 +3266,38 @@ mod tests {
             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]
@@ -3335,4 +3623,123 @@ mod tests {
         assert_eq!(generic.summary, "一款由陶泥儿创作的益智游戏");
         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);
+    }
 }
diff --git a/server-rs/crates/shared-contracts/src/game_distribution.rs b/server-rs/crates/shared-contracts/src/game_distribution.rs
index 0009f9b1a..1540bafdb 100644
--- a/server-rs/crates/shared-contracts/src/game_distribution.rs
+++ b/server-rs/crates/shared-contracts/src/game_distribution.rs
@@ -175,6 +175,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 {
@@ -183,11 +208,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,
 }
@@ -250,4 +278,26 @@ mod tests {
             .expect("版本请求应可解析");
         assert_eq!(payload.local_project_id.as_deref(), Some("proj-1"));
     }
+
+    #[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 9bcd727c7..a732b6266 100644
--- a/server-rs/crates/spacetime-client/src/active.rs
+++ b/server-rs/crates/spacetime-client/src/active.rs
@@ -25,11 +25,12 @@ pub use game_distribution::{
     GameDistributionAdminGameListRecordInput, GameDistributionApproveRecordInput,
     GameDistributionCancelVersionRecordInput, GameDistributionConfirmPackageRecordInput,
     GameDistributionCreateGameRecordInput, GameDistributionCreateVersionRecordInput,
-    GameDistributionFailUploadRecordInput, GameDistributionGetGameRecordInput,
-    GameDistributionOwnerGameListRecordInput, GameDistributionPublicGameListRecordInput,
-    GameDistributionRejectRecordInput, GameDistributionRestoreRecordInput,
-    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
-    GameDistributionUnpublishRecordInput,
+    GameDistributionDeleteGameRecordInput, GameDistributionFailUploadRecordInput,
+    GameDistributionGetGameRecordInput, GameDistributionOwnerGameListRecordInput,
+    GameDistributionPublicGameListRecordInput, GameDistributionRejectRecordInput,
+    GameDistributionRestoreRecordInput, 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 3814b976b..e2b2d742f 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
@@ -77,6 +77,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)]
@@ -182,16 +184,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 0a20dea7b..24b3bd553 100644
--- a/server-rs/crates/spacetime-client/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/game_distribution.rs
@@ -10,6 +10,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)]
@@ -164,6 +172,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_game_distribution_games(
         &self,
@@ -680,13 +723,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| {
@@ -706,6 +754,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 8c316104e..de23da632 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings.rs
@@ -194,6 +194,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;
@@ -407,6 +408,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;
@@ -430,6 +432,7 @@ pub mod game_distribution_review_list_input_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_version_lookup_input_type;
 pub mod game_distribution_version_procedure_result_type;
 pub mod game_distribution_version_snapshot_type;
@@ -771,6 +774,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 upload_agc_analytics_batch_procedure;
 pub mod upsert_editor_generation_pricing_config_and_return_procedure;
 pub mod upsert_editor_showcase_campaign_config_and_return_procedure;
@@ -971,6 +975,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;
@@ -1184,6 +1189,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;
@@ -1207,6 +1213,7 @@ pub use game_distribution_review_list_input_type::GameDistributionReviewListInpu
 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_version_lookup_input_type::GameDistributionVersionLookupInput;
 pub use game_distribution_version_procedure_result_type::GameDistributionVersionProcedureResult;
 pub use game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
@@ -1548,6 +1555,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 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;
 pub use upsert_editor_showcase_campaign_config_and_return_procedure::upsert_editor_showcase_campaign_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_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_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 7c552a707..cf222d566 100644
--- a/server-rs/crates/spacetime-module/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-module/src/game_distribution.rs
@@ -46,6 +46,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>,
 }
 
 /// 游戏发行版本。包摘要、确认字节数和送审资料在创建后作为不可变快照保留；状态和
@@ -171,10 +175,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;
@@ -317,6 +327,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)]
@@ -329,6 +348,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,
@@ -437,6 +491,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)]
@@ -444,6 +500,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, Eq, SpacetimeType)]
@@ -737,7 +795,7 @@ pub fn list_game_distribution_reviews_and_return(
     }
 }
 
-/// 返回后台游戏管理页的全量游戏；版本数与最近版本在同一事务内统计，作者名/头像读时联账号表。
+/// 返回后台游戏管理页的游戏；关键词/作者/状态过滤、游标分页、版本数与最近版本都在同一事务内完成。
 #[spacetimedb::procedure]
 pub fn list_admin_game_distribution_games_and_return(
     ctx: &mut ProcedureContext,
@@ -748,19 +806,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(
@@ -978,13 +1070,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,
@@ -1045,6 +1141,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,
@@ -1122,6 +1219,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());
     }
@@ -1441,6 +1539,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());
     }
@@ -1534,6 +1633,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));
     }
@@ -1625,6 +1725,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());
     }
@@ -1742,6 +1843,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));
     }
@@ -1812,6 +1914,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());
     }
@@ -1898,6 +2001,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() {
@@ -1986,6 +2090,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());
     }
@@ -2054,16 +2159,225 @@ 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))
+}
+
 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
@@ -2071,11 +2385,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(
@@ -2125,6 +2476,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()),
     }
 }
 
@@ -2168,6 +2522,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
@@ -2195,6 +2557,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,
@@ -2210,6 +2580,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
@@ -2266,6 +2637,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
@@ -2300,7 +2672,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);
     }
@@ -2315,6 +2689,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)
@@ -2362,6 +2739,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,
     )))
@@ -2557,6 +2944,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;
         }
diff --git a/server-rs/crates/spacetime-module/src/migration.rs b/server-rs/crates/spacetime-module/src/migration.rs
index e413af575..336c224d9 100644
--- a/server-rs/crates/spacetime-module/src/migration.rs
+++ b/server-rs/crates/spacetime-module/src/migration.rs
@@ -208,6 +208,8 @@ macro_rules! migration_tables {
             // 随迁移导出/导入；私有 ZIP 与展开内容保存在对象存储，不进入这两张表。
             // 资料随版本冻结：版本表末尾追加 metadata_json，游戏表末尾追加
             // cover_object_key / screenshots_json，均为可空列，旧行按“未冻结资料”处理。
+            // 软删除：游戏表末尾追加可空 deleted_at；非空表示作者已删除该作品，
+            // 行本身仍随迁移导出，版本行与冻结资料保持不可变。
             game_distribution_game,
             game_distribution_version,
             game_distribution_idempotency_receipt,
diff --git a/src/components/game-distribution/GameDetailPage.tsx b/src/components/game-distribution/GameDetailPage.tsx
index d66abbcb7..44537d514 100644
--- a/src/components/game-distribution/GameDetailPage.tsx
+++ b/src/components/game-distribution/GameDetailPage.tsx
@@ -10,11 +10,19 @@ import {
 } 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 { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
@@ -24,34 +32,52 @@ import {
   useIsMobileViewport,
 } from './gameDistributionGuards';
 import { GameCover } from './GameGalleryPage';
+import { GAME_METADATA_INPUT_MODE_LABELS } from './gameMetadataOptions';
+import { GameVersionHistory } from './GameVersionHistory';
+import {
+  GAME_STATUS_LABEL,
+  VERSION_STATUS_LABEL,
+  VERSION_STATUS_NEEDS_AUTHOR_ACTION,
+} from './gameVersionHistoryModel';
 
 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 || '未标注操作方式';
+  const controls = 'controls' in version ? version.controls : [];
+  const fallback = controls.join(' · ').trim();
+  return fallback || '未标注操作方式';
 }
 
 /** 缩略图自己换签，失败时退回空占位，不阻塞 hero 与主行动作。 */
@@ -129,17 +155,26 @@ export function GameDetailPage({
   gameId,
   onBack,
   onPlay,
+  ownerView = false,
 }: GameDetailPageProps) {
-  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);
@@ -156,13 +191,13 @@ export function GameDetailPage({
             setError('游戏入口地址无效');
             return;
           }
-          setGame({
+          setPublicGame({
             ...value,
             currentVersion: { ...value.currentVersion, entryUrl },
           });
           return;
         }
-        setGame(value);
+        setPublicGame(value);
         if (!value) setError('找不到这款游戏');
       })
       .catch((loadError: unknown) => {
@@ -176,12 +211,64 @@ 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]);
+
+  const game = ownerView ? ownerGame : publicGame;
+  const reload = ownerView ? loadOwnerGame : loadPublicGame;
 
   if (isLoading)
     return (
@@ -201,14 +288,24 @@ export function GameDetailPage({
           className="game-status-message"
         >
           <span>{error || '找不到这款游戏'}</span>
-          <button type="button" onClick={loadGame}>
+          <button type="button" onClick={reload}>
             重新加载
           </button>
         </PlatformStatusMessage>
       </div>
     );
 
-  const version = game.currentVersion;
+  /** 作者视角的条目没有公开投影 `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 latestReviewReason = latestVersion?.reviewReason?.trim() ?? '';
   const mobilePlaybackBlocked = isMobileViewport && !game.deviceSupport.mobile;
   const playbackBlocked = !version || mobilePlaybackBlocked;
   return (
@@ -251,12 +348,51 @@ export function GameDetailPage({
                 请在电脑上游玩
               </span>
             ) : null}
+            {ownerView && !publishedVersion ? (
+              <span className="game-device-warning" role="status">
+                作品尚未公开，暂时没有在线可玩版本
+              </span>
+            ) : null}
             <span className="game-detail-hero__play-count">
               {game.playCount.toLocaleString()} 次游玩
             </span>
           </div>
         </div>
       </section>
+      {ownerView && ownerGame ? (
+        <section className="game-owner-panel" aria-label="作品状态">
+          <div className="game-owner-panel__heading">
+            <h2>作品状态</h2>
+            <span
+              className={`my-game-status my-game-status--${ownerGame.status}`}
+            >
+              {GAME_STATUS_LABEL[ownerGame.status] ?? ownerGame.status}
+            </span>
+          </div>
+          <div className="game-owner-panel__meta">
+            {latestVersion ? (
+              <span>
+                最新版本 v{latestVersion.versionNumber} ·{' '}
+                {VERSION_STATUS_LABEL[latestVersion.status] ??
+                  latestVersion.status}
+              </span>
+            ) : (
+              <span>还没有提交过版本</span>
+            )}
+          </div>
+          {latestReviewReason ? (
+            <p className="game-owner-panel__reason">
+              驳回理由：{latestReviewReason}
+            </p>
+          ) : null}
+          {ownerGame.versions.length > 0 ? (
+            <GameVersionHistory
+              versions={ownerGame.versions}
+              recoveryActions={recoveryActions}
+            />
+          ) : null}
+        </section>
+      ) : null}
       <section className="game-detail-body">
         <div className="game-detail-main">
           <h2>关于这款游戏</h2>
@@ -283,7 +419,7 @@ export function GameDetailPage({
           </div>
           <div className="game-info-card">
             <strong>当前版本</strong>
-            <span>{version?.version || '—'}</span>
+            <span>{versionLabel || '—'}</span>
           </div>
         </aside>
       </section>
diff --git a/src/components/game-distribution/GameDistributionPages.test.tsx b/src/components/game-distribution/GameDistributionPages.test.tsx
index 8c2c4a430..9a0facefb 100644
--- a/src/components/game-distribution/GameDistributionPages.test.tsx
+++ b/src/components/game-distribution/GameDistributionPages.test.tsx
@@ -11,18 +11,26 @@ import {
 } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { GameDistributionGame } from '../../services/gameDistributionClient';
+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';
 
 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 resolvedAssetUrlMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../../services/gameDistributionClient', () => ({
   listGames: listGamesMock,
   getGame: getGameMock,
+  getMyGame: getMyGameMock,
+  loadVersionRecoveryActions: loadVersionRecoveryActionsMock,
 }));
 
 // 只替换换签结果，测试不发起任何真实请求；返回空串即代表签名失败或字段为空。
@@ -105,6 +113,8 @@ beforeEach(() => {
   setViewportWidth(1024);
   listGamesMock.mockResolvedValue([]);
   getGameMock.mockResolvedValue(createGame());
+  getMyGameMock.mockResolvedValue(null);
+  loadVersionRecoveryActionsMock.mockResolvedValue({});
   resolvedAssetUrlMock.mockImplementation((objectKey: string) =>
     objectKey ? `https://assets.example.test/${objectKey}` : '',
   );
@@ -198,6 +208,111 @@ 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({
+        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();
+    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()} />);
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/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 986e43668..4a564bb8c 100644
--- a/src/components/game-distribution/gameDistribution.css
+++ b/src/components/game-distribution/gameDistribution.css
@@ -841,6 +841,7 @@
 }
 .my-game-card__actions {
   display: flex;
+  flex-wrap: wrap;
   gap: 0.5rem;
   margin-top: auto;
   padding-top: 0.35rem;
@@ -871,6 +872,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;
 }
@@ -1078,6 +1208,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/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..d96fcf3d5
--- /dev/null
+++ b/src/components/game-distribution/gameVersionHistoryModel.ts
@@ -0,0 +1,60 @@
+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: '已撤回',
+};
+
+/** 服务端 `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/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 6c7a21e46..e7694e203 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
@@ -443,8 +443,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],
@@ -804,16 +808,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/gameDistributionClient.ts b/src/services/gameDistributionClient.ts
index a18e05605..330246925 100644
--- a/src/services/gameDistributionClient.ts
+++ b/src/services/gameDistributionClient.ts
@@ -6,6 +6,8 @@ import type {
   GameDistributionCreateVersionRequest,
   GameDistributionDeviceSupport,
   GameDistributionGame,
+  GameDistributionRecoveryAction,
+  GameDistributionUpdateGameMetadataRequest,
   GameDistributionVersionDetail,
   GameDistributionVersionStatus as GameDistributionVersionStatusValue,
   GameDistributionVersionSummary,
@@ -119,8 +121,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',
@@ -128,9 +162,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(