后台灰度预设补上游戏发布开关

- admin-web：灰度发布配置的固定目标新增「游戏分发 → 游戏发布」（game-distribution:publish），前缀标签与描述说明「未配置或关闭时默认开放，开启后只放行白名单/灰度命中」。
- 默认语义：选中预设后保持 enabled=false，避免误把发布收紧成全关；需要灰度时再显式打开并填白名单/比例。
- 用例：新增「可选择游戏发布开关且默认不收紧」与「保存写入白名单与比例」两条后台用例。
- 文档：开发运维文档说明该键配置前不会出现在已有列表、必须从预设或手填新建一行。

.codex/skills/genarrative-admin-backoffice/references/spacetimedb-http-sql-sats-display.md

@@ -41,14 +41,3 @@
 ## 注意
 
 不同 enum 的 variant 顺序必须以生成 binding 或 module 源码为准，不能复用其他 enum 的索引映射。
-
-## 通用表查询页的枚举展示（2026-09-23 起）
-
-后台“表查询”（`#tables`）不再逐表硬编码枚举映射，改为按 schema 自动解析：
-
-- api-server 在 `server-rs/crates/api-server/src/admin.rs` 读取 schema 的 `typespace.types` 和表的 `product_type_ref`，对每个“`Sum` 且所有变体都是单元变体（`Product.elements` 为空）”的列生成 `列名 -> [按变体索引排列的展示名]`，变体名归一到 snake_case。
-- `Option<枚举>` 列单独标记为可空：`[0, [索引, []]]` 出变体名，`[1, []]` 仍是空值。`Option<普通值>` 与带载荷的 Sum 直接跳过，交回通用解码，避免把普通 `Option` 列误标成枚举名。
-- 映射同时应用到 `cells` 与 `raw`，因此关键词搜索、结构化筛选、稳定排序解析到的都是展示名。
-- 单变体枚举也要出名字；变体索引顺序以 schema 为准，不依赖生成 binding 的副本。
-
-因此新增表或新增枚举列无需再改后端映射，只要模块已发布且 schema 可读；如果 schema 读取失败，表查询会以“表不存在”失败，而不是退回展示数字。定向验证：`cargo test -p api-server --manifest-path server-rs/Cargo.toml --bin api-server admin_database`。

.dockerignore

@@ -30,3 +30,8 @@ server-rs/.data
 server-rs/.spacetimedb
 
 public/generated-*
+
+scripts/loadtest/data/*.local.json
+scripts/loadtest/data/k6-*.log
+scripts/loadtest/data/k6-*summary*.md
+scripts/loadtest/data/latest-*-prefix.txt

.env.example

@@ -237,8 +237,6 @@ GENARRATIVE_ENABLE_IMAGE_EDITOR_AGENT_SIDEBAR="false"
 
 # 官网客户端下载检测渠道：dev、release 或自定义渠道；修改后重启 API 服务。
 # Windows/macOS 是系统维度，不填写 dev-win/dev-mac。
-# 客户端埋点也复用该渠道：dev 对应 https://dev.genarrative.world，release 对应 https://www.genarrative.world。
-# 埋点不接受其它渠道；本地 dev 且 GENARRATIVE_ENV 为 development（默认）/test/container 时允许 loopback 地址及可变端口。
 GENARRATIVE_CLIENT_DOWNLOAD_CHANNEL="dev"
 
 # Optional: official VikingDB credentials for regenerating build-tag similarities

.eslintrc.cjs

@@ -365,6 +365,7 @@ module.exports = {
     'src/types.ts',
     'src/types/**',
     'src/uiAssets.ts',
+    'scripts/loadtest/**',
     'packages/shared/src/contracts/jumpHop.ts',
     'packages/shared/src/contracts/match3dAgent.ts',
     'packages/shared/src/contracts/match3dRuntime.ts',

.gitignore

@@ -88,3 +88,11 @@ nohup.out
 spacetime.local.json
 deploy/container/api-server.env
 deploy/container/worker-smoke/
+
+# Local load-test data extracted from private migration files
+scripts/loadtest/data/*.local.json
+
+# Local load-test run artifacts
+scripts/loadtest/data/k6-*.log
+scripts/loadtest/data/k6-*summary*.md
+scripts/loadtest/data/latest-*-prefix.txt

CONTEXT.md

@@ -194,14 +194,6 @@ _Avoid_: 进度通知、快照轮询、第二套历史
 把项目对话历史条目与运行态事件转换成消息气泡和工具卡片的读取期转换；不持久化，也不构成事实源。
 _Avoid_: 投影缓存文件、已脱敏卡片库、第二套 reducer
 
-**项目对话输入**:
-AGC 项目对话的输入只有自然语言回合（含 `@` 素材引用与附件）；需要动作时由 Runtime 工具与确认卡承接，不从输入文本解析控制词。
-_Avoid_: 斜杠命令、聊天命令草稿、命令发现列表
-
-**项目命令 id**:
-AGC 运行期工具与项目权限策略使用的稳定标识（`GAME_CREATION_APP_COMMANDS` 与 `GameCreationAppPermission`），由 Rust 运行期策略校验与 App 权限审计 / 项目前置条件判定消费，不是用户输入语法。
-_Avoid_: 把命令 id 当作可输入的聊天命令、为权限位补聊天入口
-
 **引用候选**:
 输入区可以命中的对象集合（`@` 素材、`$` Skill），由宿主按种类注入；输入区不判断候选属于哪一类。
 _Avoid_: 输入区自己读项目清单或应用目录、把候选取值写死在组件里
@@ -218,18 +210,6 @@ _Avoid_: 给附件或运行画面区域造候选、为它们保留输入区内
 引用在正文文本里的形态（`@显示名` / `$名称` / `@附件名`）及其反解析；出站与解析必须同一口径，token 前后各留一个空白。
 _Avoid_: 出站与解析各写一套、在空白边界之外再补兼容别名、让解析依赖具体种类的字段
 
-**引用名**:
-引用自己的名字，同时就是它在正文里的 token（资源显示名、Skill 名、附件名）；内部不允许出现空白，空白统一经 `normalizeMentionName` 折成 `-`。
-_Avoid_: 名字与 token 各存一份、靠补兼容别名或 `resourceId` 兜底来消化空白
-
-**引用候选枚举**:
-一种引用种类当前就绪的全部可引用对象，与候选菜单共用同一份集合；区别只在没有查询过滤和条数上限。
-_Avoid_: 拿菜单查询当枚举、为粘贴另建一份候选清单
-
-**引用粘贴解析**:
-把粘贴进来的纯文本按引用文本语法反解析回正文引用；只有身份唯一且逐字确认的 token 才成为引用，其余按原文保留。
-_Avoid_: 猜文件名或路径、为不确定的 token 挑一个候选、改写用户粘贴的其余文字
-
 **引用输入区**:
 只负责编辑与渲染引用的共享输入组件；候选、身份解析与文本语法都来自注入的 provider，它不持有项目清单、不访问后端。
 _Avoid_: 输入区自己拉 Skill 目录、把选择器面板塞在输入区内部
@@ -260,7 +240,6 @@ _Avoid_: 待发送附件列表与正文芯片并存、提交时再拼一遍附
 - **引用输入区** 由宿主注入的若干 **引用 provider** 组成；**引用候选** 与 **引用文本语法** 都来自 provider，输入区不判断引用种类。
 - **引用选择器** 不属于 **引用输入区**：它自己拿数据，确认后只通过输入区的插入缝交付引用。
 - 只有带触发符的 **引用 provider** 会产生候选；**静默 provider** 没有触发符，只能由外部插入或草稿回填进入正文。
-- **引用粘贴解析** 与出站显示是同一条 **引用文本语法** 的两端；**静默 provider** 的 token（`@附件名` / `@区域标签`）没有候选，因此粘贴时不重建。
 - **附件芯片** 是本轮附件的唯一事实源；附件导入失败时不产生芯片。
 
 ## Example dialogue

apps/admin-web/src/api/adminApiClient.test.ts

@@ -7,13 +7,10 @@ import {
   getAdminFeatureGateConfig,
   getAdminUserDetail,
   importAdminAgcTemplates,
-  listAdminAgcTrackingEvents,
-  listAdminGameDistributionGames,
   listAdminGameDistributionReviews,
   listAdminRechargeOrders,
   reconcileAdminUserConsumption,
   resolveAdminRechargeRefundManualReview,
-  restoreAdminGameDistributionGame,
   reviewAdminGameDistributionVersion,
   suspendAdminGameDistributionGame,
   updateAdminAccount,
@@ -27,30 +24,6 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
-test('客户端埋点查询传递筛选和游标并复用后台认证', async () => {
-  const payload = { entries: [], nextCursor: null };
-  const fetchMock = vi.fn().mockResolvedValue(
-    new Response(JSON.stringify({ ok: true, data: payload }), {
-      status: 200,
-    }),
-  );
-  vi.stubGlobal('fetch', fetchMock);
-  expect(
-    await listAdminAgcTrackingEvents('token', {
-      userId: 'user+1',
-      projectId: 'project-1',
-      cursor: 'page/2',
-      limit: 50,
-    }),
-  ).toEqual(payload);
-  expect(fetchMock).toHaveBeenCalledWith(
-    '/admin/api/agc/tracking-events?userId=user%2B1&projectId=project-1&cursor=page%2F2&limit=50',
-    expect.objectContaining({
-      headers: expect.objectContaining({ Authorization: 'Bearer token' }),
-    }),
-  );
-});
-
 test('模板管理读取和更新复用认证封装，提交 revision 和封面但不提交 ZIP 或版本', async () => {
   const library = { revision: 'revision-new', writable: true, templates: [] };
   const fetchMock = vi.fn().mockImplementation(
@@ -503,6 +476,7 @@ test('游戏审核列表与审核动作使用约定的 URL、方法和幂等键'
     {
       decision: 'approve',
       expectedPublicationRevision: 3,
+      entryUrl: 'https://games.example.test/releases/game_1/index.html',
     },
   );
 
@@ -522,90 +496,12 @@ test('游戏审核列表与审核动作使用约定的 URL、方法和幂等键'
       body: JSON.stringify({
         decision: 'approve',
         expectedPublicationRevision: 3,
+        entryUrl: 'https://games.example.test/releases/game_1/index.html',
       }),
     }),
   );
 });
 
-test('游戏管理列表与恢复动作使用约定的 URL、方法和幂等键', async () => {
-  const fetchMock = vi
-    .fn()
-    .mockResolvedValueOnce(
-      new Response(JSON.stringify({ ok: true, data: { games: [] } }), {
-        status: 200,
-      }),
-    )
-    .mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          ok: true,
-          data: {
-            game: {
-              id: 'game/1',
-              title: '测试游戏',
-              status: 'published',
-              publicationRevision: 10,
-            },
-            replayed: false,
-          },
-        }),
-        { status: 200 },
-      ),
-    );
-  vi.stubGlobal('fetch', fetchMock);
-  const controller = new AbortController();
-
-  await listAdminGameDistributionGames(
-    'admin-token',
-    { limit: 80 },
-    controller.signal,
-  );
-  await restoreAdminGameDistributionGame(
-    'admin-token',
-    ' game/1 ',
-    ' game-restore-key-1 ',
-    { expectedPublicationRevision: 9 },
-  );
-
-  expect(fetchMock.mock.calls[0]?.[0]).toBe(
-    '/admin/api/game-distribution/games?limit=50',
-  );
-  expect(fetchMock.mock.calls[0]?.[1]).toEqual(
-    expect.objectContaining({
-      method: 'GET',
-      signal: controller.signal,
-      headers: expect.objectContaining({
-        Authorization: 'Bearer admin-token',
-      }),
-    }),
-  );
-  expect(fetchMock.mock.calls[1]?.[0]).toBe(
-    '/admin/api/game-distribution/games/game%2F1/restore',
-  );
-  expect(fetchMock.mock.calls[1]?.[1]).toEqual(
-    expect.objectContaining({
-      method: 'POST',
-      headers: expect.objectContaining({
-        Authorization: 'Bearer admin-token',
-        'Idempotency-Key': 'game-restore-key-1',
-      }),
-      body: JSON.stringify({ expectedPublicationRevision: 9 }),
-    }),
-  );
-
-  expect(() =>
-    restoreAdminGameDistributionGame('admin-token', '  ', 'key', {
-      expectedPublicationRevision: 9,
-    }),
-  ).toThrow('缺少游戏 ID');
-  expect(() =>
-    restoreAdminGameDistributionGame('admin-token', 'game-1', '  ', {
-      expectedPublicationRevision: 9,
-    }),
-  ).toThrow('恢复幂等键必须是 1 到 128 个字符');
-  expect(fetchMock).toHaveBeenCalledTimes(2);
-});
-
 test('安全下架请求携带公开修订号、原因与幂等键', async () => {
   const fetchMock = vi.fn().mockImplementation(() =>
     Promise.resolve(

apps/admin-web/src/api/adminApiClient.ts

@@ -1,8 +1,6 @@
 import type {
   AdminAccountListResponse,
   AdminAgcTemplateLibraryResponse,
-  AdminAgcTrackingEventListResponse,
-  AdminAgcTrackingEventQuery,
   AdminConfirmEditorShowcaseCampaignImageUploadRequest,
   AdminCreateAccountRequest,
   AdminCreateAccountResponse,
@@ -32,9 +30,6 @@ import type {
   AdminExternalApiKeyListQuery,
   AdminExternalApiKeyListResponse,
   AdminFeatureGateConfigResponse,
-  AdminGameDistributionGameListResponse,
-  AdminGameDistributionRestoreRequest,
-  AdminGameDistributionRestoreResponse,
   AdminGameDistributionReviewListResponse,
   AdminGameDistributionReviewRequest,
   AdminGameDistributionReviewResponse,
@@ -414,31 +409,6 @@ export function listAdminTrackingEventKeys(token: string) {
   );
 }
 
-export function listAdminAgcTrackingEvents(
-  token: string,
-  query: AdminAgcTrackingEventQuery = {},
-) {
-  return request<AdminAgcTrackingEventListResponse>(
-    `/admin/api/agc/tracking-events${buildQueryString((params) => {
-      for (const key of [
-        'userId',
-        'projectId',
-        'creativeTaskId',
-        'agentRunId',
-        'eventName',
-        'clientVersion',
-        'startTime',
-        'endTime',
-        'cursor',
-      ] as const) {
-        appendQueryParam(params, key, query[key]);
-      }
-      appendNumericQueryParam(params, 'limit', query.limit);
-    })}`,
-    { token },
-  );
-}
-
 export function listAdminErrorReports(
   token: string,
   query: {
@@ -1243,46 +1213,6 @@ export function listAdminGameDistributionReviews(token: string, limit = 48) {
   );
 }
 
-export function listAdminGameDistributionGames(
-  token: string,
-  options: { limit?: number } = {},
-  signal?: AbortSignal,
-) {
-  const requestedLimit = options.limit ?? 50;
-  const normalizedLimit = Number.isFinite(requestedLimit)
-    ? Math.min(Math.max(Math.trunc(requestedLimit), 1), 50)
-    : 50;
-  return request<AdminGameDistributionGameListResponse>(
-    `/admin/api/game-distribution/games?limit=${normalizedLimit}`,
-    { token, signal },
-  );
-}
-
-export function restoreAdminGameDistributionGame(
-  token: string,
-  gameId: string,
-  idempotencyKey: string,
-  payload: AdminGameDistributionRestoreRequest,
-) {
-  const normalizedGameId = gameId.trim();
-  const normalizedKey = idempotencyKey.trim();
-  if (!normalizedGameId) {
-    throw new Error('缺少游戏 ID');
-  }
-  if (!normalizedKey || normalizedKey.length > 128) {
-    throw new Error('恢复幂等键必须是 1 到 128 个字符');
-  }
-  return request<AdminGameDistributionRestoreResponse>(
-    `/admin/api/game-distribution/games/${encodeURIComponent(normalizedGameId)}/restore`,
-    {
-      method: 'POST',
-      token,
-      headers: { 'Idempotency-Key': normalizedKey },
-      body: payload,
-    },
-  );
-}
-
 /**
  * 审核游戏发行版本。幂等键由调用方生成并在同一次提交内复用，避免重复点击产生
  * 两条审核结论。

apps/admin-web/src/api/adminApiTypes.ts

@@ -193,10 +193,7 @@ export interface AdminDashboardRangePayload {
 
 export interface AdminDashboardMetricsPayload {
   generatedAssets: number;
-  /** 已对冲退还（生成失败 / 精选审核返还 / LLM Router 冲正）的净消耗泥点。 */
   consumedMudPoints: number;
-  /** 同期退还泥点，用于核对「消耗 + 退还」的毛消耗口径。 */
-  refundedMudPoints: number;
   totalRegisteredUsers: number;
   newRegisteredUsers: number;
   newUserPaymentConversion: AdminDashboardPaymentConversionPayload;
@@ -823,44 +820,6 @@ export interface AdminTrackingEventListResponse {
   entries: AdminTrackingEventEntryPayload[];
 }
 
-export interface AdminAgcTrackingEventQuery {
-  userId?: string;
-  projectId?: string;
-  creativeTaskId?: string;
-  agentRunId?: string;
-  eventName?: string;
-  clientVersion?: string;
-  startTime?: string;
-  endTime?: string;
-  cursor?: string;
-  limit?: number;
-}
-
-export interface AdminAgcTrackingEventEntry {
-  eventId: string;
-  schemaVersion: number;
-  eventName: string;
-  eventTime: string;
-  userId: string;
-  editorSessionId: string;
-  projectId: string | null;
-  creativeTaskId: string | null;
-  agentRunId: string | null;
-  agentTurnId: string | null;
-  status: string | null;
-  errorCode: string | null;
-  source: string;
-  clientVersion: string;
-  properties: Record<string, unknown>;
-  batchId: string;
-  receivedAt: string;
-}
-
-export interface AdminAgcTrackingEventListResponse {
-  entries: AdminAgcTrackingEventEntry[];
-  nextCursor: string | null;
-}
-
 export interface AdminTrackingEventKeyPayload {
   eventKey: string;
   eventTitle: string;
@@ -958,8 +917,6 @@ export interface AdminRechargeOrderEntryPayload {
   productTitle: string;
   productKind: string;
   amountCents: number;
-  /** 真实支付金额（分）：未支付 / 已关闭 / 已过期订单固定为 0，不能拿订单金额当实付。 */
-  paidAmountCents: number;
   status: string;
   paymentChannel: string;
   paidAtMicros?: number | null;
@@ -999,8 +956,6 @@ export interface AdminUserDetailResponse {
   phoneBound: boolean;
   wechatBound: boolean;
   historicalConsumedPoints: number;
-  /** 累计充值金额（分）：读取失败或命中读取上限时为 null，前端按未知展示。 */
-  cumulativeRechargedCents?: number | null;
   canReconcileConsumption: boolean;
   wallet: AdminProfileWalletPayload;
   rechargeOrders: AdminRechargeOrderEntryPayload[];
@@ -1110,6 +1065,7 @@ export interface AdminGameDistributionReviewRequest {
   decision: 'approve' | 'reject';
   expectedPublicationRevision: number;
   reviewReason?: string;
+  entryUrl?: string;
 }
 
 export interface AdminGameDistributionReviewResponse {
@@ -1132,57 +1088,6 @@ export interface AdminGameDistributionSuspendResponse {
   replayed: boolean;
 }
 
-export interface AdminGameDistributionGameVersionEntry {
-  versionId: string;
-  gameId: string;
-  versionNumber: number;
-  status: string;
-  reviewReason: string | null;
-  packageBytes: number;
-  packageSha256: string;
-  createdAt: string;
-  updatedAt: string;
-  reviewedAt: string | null;
-  publishedAt: string | null;
-  entryUrl: string | null;
-}
-
-export interface AdminGameDistributionGameEntry {
-  gameId: string;
-  title: string;
-  author: {
-    id: string;
-    name: string;
-    avatarUrl: string | null;
-  };
-  status: string;
-  versionCount: number;
-  playCount: number;
-  activeVersionId: string | null;
-  publicationRevision: number;
-  createdAt: string;
-  updatedAt: string;
-  versions: AdminGameDistributionGameVersionEntry[];
-}
-
-export interface AdminGameDistributionGameListResponse {
-  games: AdminGameDistributionGameEntry[];
-}
-
-export interface AdminGameDistributionRestoreRequest {
-  expectedPublicationRevision: number;
-}
-
-export interface AdminGameDistributionRestoreResponse {
-  game: {
-    id: string;
-    title: string;
-    status: string;
-    publicationRevision: number;
-  };
-  replayed: boolean;
-}
-
 export interface AdminAgcTemplatePayload {
   id: string;
   title: string;

apps/admin-web/src/app/AdminApp.tsx

@@ -20,7 +20,6 @@ import {
 import { AdminAccountsPage } from '../pages/AdminAccountsPage';
 import { AdminAgcModelsPage } from '../pages/AdminAgcModelsPage';
 import { AdminAgcTemplatesPage } from '../pages/AdminAgcTemplatesPage';
-import { AdminAgcTrackingPage } from '../pages/AdminAgcTrackingPage';
 import { AdminDashboardPage } from '../pages/AdminDashboardPage';
 import { AdminDatabaseTablesPage } from '../pages/AdminDatabaseTablesPage';
 import { AdminDebugHttpPage } from '../pages/AdminDebugHttpPage';
@@ -29,7 +28,6 @@ import { AdminEditorGenerationPricingPage } from '../pages/AdminEditorGeneration
 import { AdminEditorShowcaseReviewPage } from '../pages/AdminEditorShowcaseReviewPage';
 import { AdminErrorReportsPage } from '../pages/AdminErrorReportsPage';
 import { AdminGameDistributionReviewPage } from '../pages/AdminGameDistributionReviewPage';
-import { AdminGameManagementPage } from '../pages/AdminGameManagementPage';
 import { AdminGrayReleaseConfigPage } from '../pages/AdminGrayReleaseConfigPage';
 import { AdminInviteCodePage } from '../pages/AdminInviteCodePage';
 import { AdminLoginPage } from '../pages/AdminLoginPage';
@@ -235,12 +233,6 @@ export function AdminApp() {
           onUnauthorized={handleUnauthorized}
         />
       ) : null}
-      {activeRouteId === 'agc-tracking' ? (
-        <AdminAgcTrackingPage
-          token={token}
-          onUnauthorized={handleUnauthorized}
-        />
-      ) : null}
       {activeRouteId === 'error-reports' ? (
         <AdminErrorReportsPage
           token={token}
@@ -322,12 +314,6 @@ export function AdminApp() {
           onUnauthorized={handleUnauthorized}
         />
       ) : null}
-      {activeRouteId === 'game-management' ? (
-        <AdminGameManagementPage
-          token={token}
-          onUnauthorized={handleUnauthorized}
-        />
-      ) : null}
       {activeRouteId === 'editor-assets' ? (
         <AdminEditorAssetQueryPage
           token={token}

apps/admin-web/src/app/AdminShell.tsx

@@ -14,7 +14,6 @@ import {
   ReceiptText,
   ShieldCheck,
   Star,
-  Swords,
   Table2,
   TicketCheck,
   TicketPercent,
@@ -41,7 +40,6 @@ const routeIcons = {
   tables: Database,
   debug: Bug,
   tracking: Table2,
-  'agc-tracking': Table2,
   'error-reports': Bug,
   'gray-release': GitBranch,
   redeem: TicketPercent,
@@ -53,7 +51,6 @@ const routeIcons = {
   'editor-generation-pricing': Coins,
   'editor-showcase': Star,
   'game-distribution': Gamepad2,
-  'game-management': Swords,
   'editor-assets': Images,
   'project-snapshots': FolderArchive,
   accounts: Users,

apps/admin-web/src/app/adminRoutes.test.ts

@@ -8,22 +8,6 @@ import {
   routeHash,
 } from './adminRoutes';
 
-test('客户端埋点路由遵守成员页签权限', () => {
-  expect(resolveAdminRoute('#agc-tracking')).toBe('agc-tracking');
-  expect(
-    getAccessibleAdminRoutes({
-      accountRole: 'member',
-      tabPermissions: ['agc-tracking'],
-    }).map((route) => route.id),
-  ).toEqual(['agc-tracking']);
-  expect(
-    getAccessibleAdminRoutes({
-      accountRole: 'member',
-      tabPermissions: ['tracking'],
-    }).some((route) => route.id === 'agc-tracking'),
-  ).toBe(false);
-});
-
 test('后台默认进入 Dashboard', () => {
   expect(adminRoutes[0]).toEqual({
     id: 'dashboard',
@@ -59,6 +43,12 @@ test('后台灰度发布路由可通过导航和 hash 访问', () => {
   expect(routeHash('gray-release')).toBe('#gray-release');
 });
 
+test('后台不再暴露旧创作模板管理路由', () => {
+  expect(resolveAdminRoute('#creation-entry')).toBe('dashboard');
+  expect(resolveAdminRoute('#creation-announcement')).toBe('dashboard');
+  expect(resolveAdminRoute('#work-visibility')).toBe('dashboard');
+});
+
 test('后台素材查询路由可通过导航和 hash 访问', () => {
   expect(adminRoutes).toContainEqual({
     id: 'editor-assets',
@@ -168,16 +158,6 @@ test('后台游戏审核路由可通过导航和 hash 访问', () => {
   expect(routeHash('game-distribution')).toBe('#game-distribution');
 });
 
-test('后台游戏管理路由可通过导航和 hash 访问', () => {
-  expect(adminRoutes).toContainEqual({
-    id: 'game-management',
-    label: '游戏管理',
-    hash: '#game-management',
-  });
-  expect(resolveAdminRoute('#game-management')).toBe('game-management');
-  expect(routeHash('game-management')).toBe('#game-management');
-});
-
 test('member 可单独获得游戏审核 Tab 权限', () => {
   const routes = getAccessibleAdminRoutes({
     accountRole: 'member',

apps/admin-web/src/app/adminRoutes.ts

@@ -5,7 +5,6 @@ export type AdminRouteId =
   | 'tables'
   | 'debug'
   | 'tracking'
-  | 'agc-tracking'
   | 'error-reports'
   | 'gray-release'
   | 'redeem'
@@ -17,7 +16,6 @@ export type AdminRouteId =
   | 'editor-generation-pricing'
   | 'editor-showcase'
   | 'game-distribution'
-  | 'game-management'
   | 'editor-assets'
   | 'project-snapshots'
   | 'agc-models'
@@ -43,7 +41,6 @@ export const adminRoutes: AdminRouteDefinition[] = [
   { id: 'tables', label: '表查询', hash: '#tables' },
   { id: 'debug', label: 'API 调试', hash: '#debug' },
   { id: 'tracking', label: '埋点数据', hash: '#tracking' },
-  { id: 'agc-tracking', label: '客户端埋点', hash: '#agc-tracking' },
   { id: 'error-reports', label: '错误报告', hash: '#error-reports' },
   { id: 'gray-release', label: '灰度发布', hash: '#gray-release' },
   { id: 'redeem', label: '兑换码', hash: '#redeem' },
@@ -61,7 +58,6 @@ export const adminRoutes: AdminRouteDefinition[] = [
   { id: 'agc-templates', label: '模板管理', hash: '#agc-templates' },
   { id: 'editor-showcase', label: '精选审核', hash: '#editor-showcase' },
   { id: 'game-distribution', label: '游戏审核', hash: '#game-distribution' },
-  { id: 'game-management', label: '游戏管理', hash: '#game-management' },
   { id: 'editor-assets', label: '素材查询', hash: '#editor-assets' },
   { id: 'project-snapshots', label: '项目工程', hash: '#project-snapshots' },
   { id: 'accounts', label: '账号管理', hash: '#accounts', ownerOnly: true },

apps/admin-web/src/components/AdminUserDetailDialog.test.tsx

@@ -51,7 +51,6 @@ const detail: AdminUserDetailResponse = {
   phoneBound: true,
   wechatBound: true,
   historicalConsumedPoints: 1234,
-  cumulativeRechargedCents: 128800,
   canReconcileConsumption: true,
   wallet,
   rechargeOrders: [
@@ -63,7 +62,6 @@ const detail: AdminUserDetailResponse = {
       productTitle: '60泥点',
       productKind: 'points',
       amountCents: 600,
-      paidAmountCents: 600,
       status: 'paid',
       paymentChannel: 'wechat_native',
       paidAtMicros: 1_720_000_000_000_000,
@@ -126,11 +124,7 @@ test('用户查看按钮按内部 ID 查询并展示脱敏资料、余额与退
   expect(screen.getByText('25', { selector: 'strong' })).toBeTruthy();
   expect(screen.getByText('历史花费')).toBeTruthy();
   expect(screen.getByText('1234', { selector: 'strong' })).toBeTruthy();
-  expect(screen.getByText('累计充值')).toBeTruthy();
-  expect(screen.getByText('¥1288.00')).toBeTruthy();
   expect(screen.getByText('order-1')).toBeTruthy();
-  expect(screen.getByRole('columnheader', { name: '实付' })).toBeTruthy();
-  expect(screen.getByRole('columnheader', { name: '发放泥点' })).toBeTruthy();
 
   await user.keyboard('{Escape}');
   await waitFor(() =>
@@ -139,29 +133,6 @@ test('用户查看按钮按内部 ID 查询并展示脱敏资料、余额与退
   await waitFor(() => expect(document.activeElement).toBe(trigger));
 });
 
-test('累计充值读取不到时展示未知，不用订单列表近似', async () => {
-  vi.mocked(getAdminUserDetail).mockResolvedValue({
-    ...detail,
-    cumulativeRechargedCents: null,
-  });
-  const user = userEvent.setup();
-  render(
-    <AdminUserReferenceButton
-      token="admin-token"
-      userId="user-1"
-      onUnauthorized={vi.fn()}
-    />,
-  );
-
-  await user.click(screen.getByRole('button', { name: '查看用户信息' }));
-  await screen.findByText('陶泥用户');
-
-  expect(screen.getByText('累计充值')).toBeTruthy();
-  expect(screen.getByText('累计充值').nextElementSibling?.textContent).toBe(
-    '未知',
-  );
-});
-
 test('只有陶泥号时按 publicUserCode 查询用户', async () => {
   const user = userEvent.setup();
   render(

apps/admin-web/src/components/AdminUserDetailDialog.tsx

@@ -364,7 +364,6 @@ export function AdminUserDetailDialog({
                         <th>订单</th>
                         <th>商品</th>
                         <th>实付</th>
-                        <th>发放泥点</th>
                         <th>退款</th>
                         <th>状态</th>
                       </tr>
@@ -378,13 +377,11 @@ export function AdminUserDetailDialog({
                             </span>
                             <small>{formatMicros(order.createdAtMicros)}</small>
                           </td>
-                          <td>{order.productTitle || order.productId}</td>
                           <td>
-                            {order.paidAmountCents > 0
-                              ? formatMoney(order.paidAmountCents)
-                              : '未支付'}
+                            {order.productTitle || order.productId}
+                            <small>发放 {order.pointsDelta} 泥点</small>
                           </td>
-                          <td>{order.pointsDelta} 泥点</td>
+                          <td>{formatMoney(order.amountCents)}</td>
                           <td>
                             {formatMoney(order.cumulativeSuccessRefundCents)}
                             <small>欠账 {order.unrecoveredPoints} 泥点</small>
@@ -438,14 +435,6 @@ function UserIdentityHeader({ detail }: { detail: AdminUserDetailResponse }) {
           <dt>登录方式</dt>
           <dd>{detail.loginMethod || '-'}</dd>
         </div>
-        <div>
-          <dt>累计充值</dt>
-          <dd>
-            {typeof detail.cumulativeRechargedCents === 'number'
-              ? formatMoney(detail.cumulativeRechargedCents)
-              : '未知'}
-          </dd>
-        </div>
         <div>
           <dt>绑定状态</dt>
           <dd>

apps/admin-web/src/pages/AdminAgcTemplatesPage.test.tsx

@@ -339,10 +339,7 @@ test.each([409, 503])(
     await confirmWrite();
     const message = await screen.findByRole('alert');
     const feedback = message.parentElement!;
-    // 聚焦发生在 React passive effect 里（AdminAgcTemplatesPage 的 feedback 聚焦 useEffect），
-    // 而 findByRole 在 alert 节点一挂上就返回，可能早于该 effect 执行；这里等聚焦落地，
-    // 避免在 CI 负载下抢跑。断言口径不变：焦点最终必须落在提示区而不是弹窗面板。
-    await waitFor(() => expect(document.activeElement).toBe(feedback));
+    expect(document.activeElement).toBe(feedback);
     expect(feedback.tabIndex).toBe(-1);
     expect(focus).toHaveBeenCalledWith({ preventScroll: true });
     expect(viewport.scrollTop).toBe(20);

apps/admin-web/src/pages/AdminAgcTrackingPage.test.tsx

@@ -1,129 +0,0 @@
-// @vitest-environment jsdom
-import {
-  cleanup,
-  fireEvent,
-  render,
-  screen,
-  waitFor,
-  within,
-} from '@testing-library/react';
-import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-
-import {
-  AdminApiError,
-  listAdminAgcTrackingEvents,
-} from '../api/adminApiClient';
-import type { AdminAgcTrackingEventEntry } from '../api/adminApiTypes';
-import { AdminAgcTrackingPage } from './AdminAgcTrackingPage';
-
-vi.mock('../api/adminApiClient', async (original) => ({
-  ...(await original<typeof import('../api/adminApiClient')>()),
-  listAdminAgcTrackingEvents: vi.fn(),
-}));
-vi.mock('../components/AdminUserReferenceButton', () => ({
-  AdminUserReferenceButton: () => null,
-}));
-
-const entry: AdminAgcTrackingEventEntry = {
-  eventId: 'event-1',
-  schemaVersion: 1,
-  eventName: 'project_save',
-  eventTime: '2026-09-21T12:00:00.123Z',
-  userId: 'user-1',
-  editorSessionId: 'session-1',
-  projectId: 'project-1',
-  creativeTaskId: 'project-1',
-  agentRunId: null,
-  agentTurnId: null,
-  status: 'success',
-  errorCode: null,
-  source: 'gui',
-  clientVersion: '1.0',
-  properties: { reason: 'manual' },
-  batchId: 'batch-1',
-  receivedAt: '2026-09-21T12:15:00.000Z',
-};
-
-beforeEach(() => {
-  vi.mocked(listAdminAgcTrackingEvents).mockReset();
-});
-afterEach(cleanup);
-
-test('翻页沿用游标，筛选和刷新从第一页重新查询，详情保留 null 和事件属性', async () => {
-  vi.mocked(listAdminAgcTrackingEvents)
-    .mockResolvedValueOnce({ entries: [entry], nextCursor: 'cursor-page-2' })
-    .mockResolvedValueOnce({
-      entries: [{ ...entry, eventId: 'event-2' }],
-      nextCursor: null,
-    })
-    .mockResolvedValue({ entries: [entry], nextCursor: 'cursor-new' });
-  render(<AdminAgcTrackingPage token="admin-token" onUnauthorized={vi.fn()} />);
-  await screen.findByText('保存项目', { selector: 'td' });
-  expect(listAdminAgcTrackingEvents).toHaveBeenLastCalledWith('admin-token', {
-    cursor: undefined,
-    limit: 50,
-  });
-  fireEvent.click(screen.getByText('查看详情'));
-  const dialog = screen.getByRole('dialog');
-  expect(within(dialog).getAllByText('—').length).toBe(3);
-  expect(within(dialog).getByText(/"reason": "manual"/)).toBeTruthy();
-  expect(within(dialog).getByText(entry.eventTime)).toBeTruthy();
-  fireEvent.click(within(dialog).getByLabelText('关闭详情'));
-  fireEvent.click(screen.getByText('下一页'));
-  await waitFor(() =>
-    expect(listAdminAgcTrackingEvents).toHaveBeenLastCalledWith('admin-token', {
-      cursor: 'cursor-page-2',
-      limit: 50,
-    }),
-  );
-  await waitFor(() =>
-    expect(screen.getByText('查询').closest('button')?.disabled).toBe(false),
-  );
-  fireEvent.click(screen.getByText('上一页'));
-  await screen.findByText('第 1 页');
-  expect(listAdminAgcTrackingEvents).toHaveBeenCalledTimes(2);
-  fireEvent.change(screen.getByLabelText('项目 ID'), {
-    target: { value: 'project-2' },
-  });
-  fireEvent.click(screen.getByText('查询'));
-  await waitFor(() =>
-    expect(listAdminAgcTrackingEvents).toHaveBeenLastCalledWith(
-      'admin-token',
-      expect.objectContaining({
-        projectId: 'project-2',
-        cursor: undefined,
-        limit: 50,
-      }),
-    ),
-  );
-  expect(screen.getByText('第 1 页')).toBeTruthy();
-  await waitFor(() =>
-    expect(screen.getByText('刷新').closest('button')?.disabled).toBe(false),
-  );
-  fireEvent.click(screen.getByText('刷新'));
-  await waitFor(() =>
-    expect(listAdminAgcTrackingEvents).toHaveBeenCalledTimes(4),
-  );
-});
-
-test('空结果、权限失败与登录失效沿用后台反馈', async () => {
-  const unauthorized = vi.fn();
-  vi.mocked(listAdminAgcTrackingEvents)
-    .mockResolvedValueOnce({ entries: [], nextCursor: null })
-    .mockRejectedValueOnce(
-      new AdminApiError({ status: 403, message: '无权访问客户端埋点' }),
-    )
-    .mockRejectedValueOnce(
-      new AdminApiError({ status: 401, message: '登录失效' }),
-    );
-  render(<AdminAgcTrackingPage token="token" onUnauthorized={unauthorized} />);
-  await screen.findByText('暂无客户端埋点数据');
-  fireEvent.click(screen.getByText('刷新'));
-  expect((await screen.findByRole('alert')).textContent).toContain(
-    '无权访问客户端埋点',
-  );
-  fireEvent.click(screen.getByText('刷新'));
-  await waitFor(() =>
-    expect(unauthorized).toHaveBeenCalledWith('登录状态已失效'),
-  );
-});

apps/admin-web/src/pages/AdminAgcTrackingPage.tsx

@@ -1,379 +0,0 @@
-import { Modal } from '@genarrative/shared/components';
-import { FormEvent, useEffect, useRef, useState } from 'react';
-
-import { listAdminAgcTrackingEvents } from '../api/adminApiClient';
-import type {
-  AdminAgcTrackingEventEntry,
-  AdminAgcTrackingEventListResponse,
-  AdminAgcTrackingEventQuery,
-} from '../api/adminApiTypes';
-import { AdminUserReferenceButton } from '../components/AdminUserReferenceButton';
-import { handlePageError } from './pageUtils';
-
-const eventLabels: Record<string, string> = {
-  editor_session_start: '编辑器会话开始',
-  editor_session_end: '编辑器会话结束',
-  editor_focus_start: '编辑器获得焦点',
-  editor_focus_end: '编辑器失去焦点',
-  project_create_success: '项目创建成功',
-  project_open: '打开项目',
-  creative_task_submit: '首次提交创作目标',
-  agent_run_completed: 'Agent 运行完成',
-  agent_run_failed: 'Agent 运行失败',
-  project_revision_created: '项目产生修改',
-  preview_ready: '预览就绪',
-  project_save: '保存项目',
-};
-
-const fieldLabels: Record<keyof AdminAgcTrackingEventEntry, string> = {
-  eventId: '事件 ID',
-  schemaVersion: '事件版本',
-  eventName: '事件类型',
-  eventTime: '发生时间',
-  userId: '用户 ID',
-  editorSessionId: '编辑器会话 ID',
-  projectId: '项目 ID',
-  creativeTaskId: '创作目标 ID',
-  agentRunId: 'Agent run ID',
-  agentTurnId: 'Agent turn ID',
-  status: '结果',
-  errorCode: '错误码',
-  source: '来源',
-  clientVersion: '客户端版本',
-  properties: '事件属性',
-  batchId: '批次 ID',
-  receivedAt: '入库时间',
-};
-
-function formatTime(value: string) {
-  const date = new Date(value);
-  return Number.isNaN(date.getTime()) ? value : date.toLocaleString('zh-CN');
-}
-
-export function AdminAgcTrackingPage({
-  token,
-  onUnauthorized,
-}: {
-  token: string;
-  onUnauthorized: (message?: string) => void;
-}) {
-  const [filters, setFilters] = useState({
-    userId: '',
-    projectId: '',
-    eventName: '',
-    startTime: '',
-    endTime: '',
-  });
-  const [query, setQuery] = useState<AdminAgcTrackingEventQuery>({});
-  const [cursors, setCursors] = useState<Array<string | undefined>>([
-    undefined,
-  ]);
-  const [page, setPage] = useState(0);
-  const [refresh, setRefresh] = useState(0);
-  const [entries, setEntries] = useState<AdminAgcTrackingEventEntry[]>([]);
-  const [nextCursor, setNextCursor] = useState<string | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState('');
-  const [detail, setDetail] = useState<AdminAgcTrackingEventEntry | null>(null);
-  const cursor = cursors[page];
-  // 首页没有入站游标，返回首页时保留原快照，刷新才获取新数据。
-  const firstPage = useRef<{
-    token: string;
-    query: AdminAgcTrackingEventQuery;
-    response: AdminAgcTrackingEventListResponse;
-  } | null>(null);
-
-  useEffect(() => {
-    const saved = firstPage.current;
-    if (!cursor && saved?.token === token && saved.query === query) {
-      setEntries(saved.response.entries);
-      setNextCursor(saved.response.nextCursor);
-      setError('');
-      setLoading(false);
-      return;
-    }
-    let active = true;
-    setLoading(true);
-    setError('');
-    setEntries([]);
-    setNextCursor(null);
-    void listAdminAgcTrackingEvents(token, { ...query, cursor, limit: 50 })
-      .then((response) => {
-        if (!active) return;
-        if (!cursor) firstPage.current = { token, query, response };
-        setEntries(response.entries);
-        setNextCursor(response.nextCursor);
-      })
-      .catch((failure: unknown) => {
-        if (active) handlePageError(failure, onUnauthorized, setError);
-      })
-      .finally(() => {
-        if (active) setLoading(false);
-      });
-    return () => {
-      active = false;
-    };
-  }, [token, query, cursor, refresh, onUnauthorized]);
-
-  function resetPages() {
-    firstPage.current = null;
-    setCursors([undefined]);
-    setPage(0);
-    setDetail(null);
-  }
-
-  function search(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    if (
-      filters.startTime &&
-      filters.endTime &&
-      new Date(filters.startTime) >= new Date(filters.endTime)
-    ) {
-      setError('结束时间必须晚于开始时间');
-      return;
-    }
-    resetPages();
-    setQuery({
-      userId: filters.userId.trim(),
-      projectId: filters.projectId.trim(),
-      eventName: filters.eventName,
-      startTime: filters.startTime
-        ? new Date(filters.startTime).toISOString()
-        : undefined,
-      endTime: filters.endTime
-        ? new Date(filters.endTime).toISOString()
-        : undefined,
-    });
-  }
-
-  function related(
-    key: 'creativeTaskId' | 'agentRunId' | 'clientVersion',
-    value: string,
-  ) {
-    resetPages();
-    setFilters({
-      userId: '',
-      projectId: '',
-      eventName: '',
-      startTime: '',
-      endTime: '',
-    });
-    setQuery({ [key]: value });
-  }
-
-  return (
-    <section className="admin-page admin-page-wide">
-      <div className="admin-page-heading">
-        <div>
-          <h2>客户端埋点</h2>
-          <p>按发生时间倒序展示</p>
-        </div>
-        <button
-          type="button"
-          className="admin-secondary-button"
-          disabled={loading}
-          onClick={() => {
-            resetPages();
-            setRefresh((value) => value + 1);
-          }}
-        >
-          刷新
-        </button>
-      </div>
-      <form className="admin-panel admin-form" onSubmit={search}>
-        <div className="admin-filter-grid">
-          {(['userId', 'projectId'] as const).map((key) => (
-            <label key={key} className="admin-field">
-              <span>{fieldLabels[key]}</span>
-              <input
-                value={filters[key]}
-                onChange={(event) =>
-                  setFilters({ ...filters, [key]: event.target.value })
-                }
-              />
-            </label>
-          ))}
-          <label className="admin-field">
-            <span>事件类型</span>
-            <select
-              value={filters.eventName}
-              onChange={(event) =>
-                setFilters({ ...filters, eventName: event.target.value })
-              }
-            >
-              <option value="">全部</option>
-              {Object.entries(eventLabels).map(([value, label]) => (
-                <option key={value} value={value}>
-                  {label}
-                </option>
-              ))}
-            </select>
-          </label>
-          {(['startTime', 'endTime'] as const).map((key) => (
-            <label key={key} className="admin-field">
-              <span>
-                {key === 'startTime'
-                  ? '发生时间起点（含）'
-                  : '发生时间终点（不含）'}
-              </span>
-              <input
-                type="datetime-local"
-                value={filters[key]}
-                onChange={(event) =>
-                  setFilters({ ...filters, [key]: event.target.value })
-                }
-              />
-            </label>
-          ))}
-        </div>
-        <div className="admin-action-row">
-          <button
-            type="submit"
-            className="admin-primary-button"
-            disabled={loading}
-          >
-            查询
-          </button>
-        </div>
-        {(['creativeTaskId', 'agentRunId', 'clientVersion'] as const)
-          .filter((key) => query[key])
-          .map((key) => (
-            <p key={key}>
-              {fieldLabels[key]}：{query[key]}（重新查询可清除）
-            </p>
-          ))}
-      </form>
-      {error ? (
-        <p role="alert" className="admin-error-message">
-          {error}
-        </p>
-      ) : null}
-      <div className="admin-panel">
-        <div className="admin-table-wrap">
-          <table className="admin-table">
-            <thead>
-              <tr>
-                {[
-                  '入库时间',
-                  '发生时间',
-                  '用户',
-                  '事件名称',
-                  '项目',
-                  '来源',
-                  '结果',
-                  '客户端版本',
-                  '详情',
-                ].map((label) => (
-                  <th key={label}>{label}</th>
-                ))}
-              </tr>
-            </thead>
-            <tbody>
-              {entries.map((entry) => (
-                <tr key={entry.eventId}>
-                  <td>{formatTime(entry.receivedAt)}</td>
-                  <td>{formatTime(entry.eventTime)}</td>
-                  <td>
-                    {entry.userId}
-                    <AdminUserReferenceButton
-                      token={token}
-                      userId={entry.userId}
-                      onUnauthorized={onUnauthorized}
-                    />
-                  </td>
-                  <td>{eventLabels[entry.eventName] ?? entry.eventName}</td>
-                  <td>{entry.projectId ?? '—'}</td>
-                  <td>{entry.source}</td>
-                  <td>{entry.status ?? '—'}</td>
-                  <td>{entry.clientVersion}</td>
-                  <td>
-                    <button
-                      type="button"
-                      className="admin-ghost-button"
-                      onClick={() => setDetail(entry)}
-                    >
-                      查看详情
-                    </button>
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-        </div>
-        {loading ? (
-          <p role="status">加载中…</p>
-        ) : !error && entries.length === 0 ? (
-          <p>暂无客户端埋点数据</p>
-        ) : null}
-        <div className="admin-action-row">
-          <button
-            type="button"
-            className="admin-secondary-button"
-            disabled={loading || page === 0}
-            onClick={() => setPage((value) => value - 1)}
-          >
-            上一页
-          </button>
-          <span>第 {page + 1} 页</span>
-          <button
-            type="button"
-            className="admin-secondary-button"
-            disabled={loading || !nextCursor}
-            onClick={() => {
-              if (!nextCursor) return;
-              setCursors([...cursors.slice(0, page + 1), nextCursor]);
-              setPage(page + 1);
-            }}
-          >
-            下一页
-          </button>
-        </div>
-      </div>
-      {detail ? (
-        <Modal
-          open
-          title="客户端埋点详情"
-          closeLabel="关闭详情"
-          onClose={() => setDetail(null)}
-          className="genarrative-ui"
-        >
-          <dl>
-            {(
-              Object.keys(fieldLabels) as Array<
-                keyof AdminAgcTrackingEventEntry
-              >
-            )
-              .filter((key) => key !== 'properties')
-              .map((key) => (
-                <div key={key}>
-                  <dt>{fieldLabels[key]}</dt>
-                  <dd style={{ overflowWrap: 'anywhere' }}>
-                    {detail[key] == null ? '—' : String(detail[key])}
-                  </dd>
-                </div>
-              ))}
-          </dl>
-          <div className="admin-action-row">
-            {(['creativeTaskId', 'agentRunId', 'clientVersion'] as const).map(
-              (key) =>
-                detail[key] ? (
-                  <button
-                    type="button"
-                    key={key}
-                    className="admin-secondary-button"
-                    onClick={() => related(key, detail[key]!)}
-                  >
-                    查询同一{fieldLabels[key]}
-                  </button>
-                ) : null,
-            )}
-          </div>
-          <h3>事件属性</h3>
-          <pre style={{ whiteSpace: 'pre-wrap', overflowWrap: 'anywhere' }}>
-            {JSON.stringify(detail.properties, null, 2)}
-          </pre>
-        </Modal>
-      ) : null}
-    </section>
-  );
-}

apps/admin-web/src/pages/AdminDashboardPage.test.tsx

@@ -34,7 +34,6 @@ const dashboardResponse: AdminDashboardResponse = {
   metrics: {
     generatedAssets: 12,
     consumedMudPoints: 88,
-    refundedMudPoints: 24,
     totalRegisteredUsers: 1200,
     newRegisteredUsers: 16,
     newUserPaymentConversion: {
@@ -106,8 +105,6 @@ test('Dashboard 默认加载今日指标并支持运营汇总页签', async () =
   expect(await screen.findByText('总计数据')).toBeTruthy();
   expect(screen.getByText('时段数据')).toBeTruthy();
   expect(screen.getByText('本日生产素材数')).toBeTruthy();
-  expect(screen.getByText('本日消耗泥点数')).toBeTruthy();
-  expect(screen.getByText('本日退还泥点数')).toBeTruthy();
   expect(screen.getByText('总注册用户')).toBeTruthy();
   expect(screen.getByText('本日新增用户数')).toBeTruthy();
   expect(screen.getByText('新增用户转化与留存')).toBeTruthy();

apps/admin-web/src/pages/AdminDashboardPage.tsx

@@ -128,12 +128,6 @@ export function AdminDashboardPage({
         value: metrics?.consumedMudPoints ?? 0,
         unit: '泥点',
       },
-      {
-        id: 'refunded-mud-points',
-        label: `${rangePrefix(granularity)}退还泥点数`,
-        value: metrics?.refundedMudPoints ?? 0,
-        unit: '泥点',
-      },
       {
         id: 'new-registered-users',
         label: `${rangePrefix(granularity)}新增用户数`,

apps/admin-web/src/pages/AdminDatabaseTablesPage.tsx

@@ -2641,6 +2641,48 @@ const databaseTableLabelMap: Record<string, string> = {
   profile_recharge_order: '充值订单',
   profile_feedback_submission: '反馈提交',
   profile_save_archive: '存档记录',
+  story_session: '剧情会话',
+  story_event: '剧情事件',
+  npc_state: 'NPC 状态',
+  inventory_slot: '背包槽位',
+  battle_state: '战斗状态',
+  treasure_record: '宝藏记录',
+  quest_record: '任务记录',
+  quest_log: '任务日志',
+  player_progression: '玩家进度',
+  chapter_progression: '章节进度',
+  custom_world_profile: '自定义世界档案',
+  custom_world_session: '自定义世界会话',
+  custom_world_agent_session: '自定义世界 Agent 会话',
+  custom_world_agent_message: '自定义世界 Agent 消息',
+  custom_world_agent_operation: '自定义世界 Agent 操作',
+  custom_world_draft_card: '自定义世界草稿卡片',
+  custom_world_gallery_entry: '自定义世界画廊条目',
+  puzzle_agent_session: '拼图 Agent 会话',
+  puzzle_agent_message: '拼图 Agent 消息',
+  puzzle_work_profile: '拼图作品档案',
+  puzzle_event: '拼图事件',
+  puzzle_runtime_run: '拼图运行记录',
+  puzzle_leaderboard_entry: '拼图排行榜条目',
+  match3d_agent_session: '抓大鹅 Agent 会话',
+  match3d_agent_message: '抓大鹅 Agent 消息',
+  match3d_work_profile: '抓大鹅作品档案',
+  match3d_runtime_run: '抓大鹅运行记录',
+  square_hole_agent_session: '方洞挑战 Agent 会话',
+  square_hole_agent_message: '方洞挑战 Agent 消息',
+  square_hole_work_profile: '方洞挑战作品档案',
+  square_hole_runtime_run: '方洞挑战运行记录',
+  visual_novel_agent_session: '视觉小说 Agent 会话',
+  visual_novel_agent_message: '视觉小说 Agent 消息',
+  visual_novel_work_profile: '视觉小说作品档案',
+  visual_novel_runtime_run: '视觉小说运行记录',
+  visual_novel_runtime_history_entry: '视觉小说历史条目',
+  visual_novel_runtime_event: '视觉小说运行事件',
+  big_fish_creation_session: '大鱼吃小鱼创建会话',
+  big_fish_agent_message: '大鱼吃小鱼 Agent 消息',
+  big_fish_asset_slot: '大鱼吃小鱼资产槽位',
+  big_fish_event: '大鱼吃小鱼事件',
+  big_fish_runtime_run: '大鱼吃小鱼运行记录',
   asset_object: '资产对象',
   asset_entity_binding: '资产实体绑定',
   asset_event: '资产事件',
@@ -2682,6 +2724,48 @@ const databaseTableDescriptionMap: Record<string, string> = {
   profile_recharge_order: '充值订单表',
   profile_feedback_submission: '反馈提交记录表',
   profile_save_archive: '用户存档记录表',
+  story_session: '剧情会话表',
+  story_event: '剧情事件表',
+  npc_state: 'NPC 状态表',
+  inventory_slot: '背包槽位表',
+  battle_state: '战斗状态表',
+  treasure_record: '宝藏记录表',
+  quest_record: '任务记录表',
+  quest_log: '任务日志表',
+  player_progression: '玩家进度表',
+  chapter_progression: '章节进度表',
+  custom_world_profile: '自定义世界档案表',
+  custom_world_session: '自定义世界会话表',
+  custom_world_agent_session: '自定义世界 Agent 会话表',
+  custom_world_agent_message: '自定义世界 Agent 消息表',
+  custom_world_agent_operation: '自定义世界 Agent 操作表',
+  custom_world_draft_card: '自定义世界草稿卡片表',
+  custom_world_gallery_entry: '自定义世界画廊条目表',
+  puzzle_agent_session: '拼图 Agent 会话表',
+  puzzle_agent_message: '拼图 Agent 消息表',
+  puzzle_work_profile: '拼图作品档案表',
+  puzzle_event: '拼图事件表',
+  puzzle_runtime_run: '拼图运行记录表',
+  puzzle_leaderboard_entry: '拼图排行榜条目表',
+  match3d_agent_session: '抓大鹅 Agent 会话表',
+  match3d_agent_message: '抓大鹅 Agent 消息表',
+  match3d_work_profile: '抓大鹅作品档案表',
+  match3d_runtime_run: '抓大鹅运行记录表',
+  square_hole_agent_session: '方洞挑战 Agent 会话表',
+  square_hole_agent_message: '方洞挑战 Agent 消息表',
+  square_hole_work_profile: '方洞挑战作品档案表',
+  square_hole_runtime_run: '方洞挑战运行记录表',
+  visual_novel_agent_session: '视觉小说 Agent 会话表',
+  visual_novel_agent_message: '视觉小说 Agent 消息表',
+  visual_novel_work_profile: '视觉小说作品档案表',
+  visual_novel_runtime_run: '视觉小说运行记录表',
+  visual_novel_runtime_history_entry: '视觉小说历史条目表',
+  visual_novel_runtime_event: '视觉小说运行事件表',
+  big_fish_creation_session: '大鱼吃小鱼创建会话表',
+  big_fish_agent_message: '大鱼吃小鱼 Agent 消息表',
+  big_fish_asset_slot: '大鱼吃小鱼资产槽位表',
+  big_fish_event: '大鱼吃小鱼事件表',
+  big_fish_runtime_run: '大鱼吃小鱼运行记录表',
   asset_object: '资产对象表',
   asset_entity_binding: '资产实体绑定表',
   asset_event: '资产事件表',

apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx

@@ -1,12 +1,6 @@
 /* @vitest-environment jsdom */
 
-import {
-  fireEvent,
-  render,
-  screen,
-  waitFor,
-  within,
-} from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { beforeEach, expect, test, vi } from 'vitest';
 
 import {
@@ -15,7 +9,10 @@ import {
   suspendAdminGameDistributionGame,
 } from '../api/adminApiClient';
 import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
-import { AdminGameDistributionReviewPage } from './AdminGameDistributionReviewPage';
+import {
+  AdminGameDistributionReviewPage,
+  resolveGameReleaseEntryUrlError,
+} from './AdminGameDistributionReviewPage';
 
 vi.mock('../api/adminApiClient', () => ({
   isAdminApiError: vi.fn(
@@ -56,7 +53,23 @@ beforeEach(() => {
   });
 });
 
-test('通过审核只提交当前 publicationRevision 并刷新列表', async () => {
+test('发行入口必须是带完整来源的 HTTPS 地址', () => {
+  expect(resolveGameReleaseEntryUrlError('')).toBe('请填写发行入口');
+  expect(
+    resolveGameReleaseEntryUrlError('http://games.test/a/index.html'),
+  ).toBe('发行入口必须以 https:// 开头');
+  expect(
+    resolveGameReleaseEntryUrlError('https://games.test/a/index.html?token=1'),
+  ).toBe('发行入口不能包含 query 或 fragment');
+  expect(
+    resolveGameReleaseEntryUrlError('https://u:p@games.test/a/index.html'),
+  ).toBe('发行入口不能包含凭据');
+  expect(
+    resolveGameReleaseEntryUrlError('https://games.test/a/index.html'),
+  ).toBe('');
+});
+
+test('通过审核时提交当前 publicationRevision 与发行入口并刷新列表', async () => {
   vi.mocked(reviewAdminGameDistributionVersion).mockResolvedValue({
     version: { ...entry, status: 'published' },
     replayed: false,
@@ -70,10 +83,9 @@ test('通过审核只提交当前 publicationRevision 并刷新列表', async ()
   );
   await screen.findByText('game_1');
 
-  expect(screen.queryByLabelText('发行入口')).toBeNull();
-  expect(screen.queryByText('通过后由系统分配发行地址')).toBeNull();
-  expect(screen.queryByLabelText('拒绝理由')).toBeNull();
-  expect(screen.queryByLabelText('下架原因')).toBeNull();
+  fireEvent.change(screen.getByLabelText('发行入口'), {
+    target: { value: 'https://games.test/releases/game_1/index.html' },
+  });
   fireEvent.click(screen.getByRole('button', { name: '通过' }));
 
   await waitFor(() =>
@@ -87,6 +99,7 @@ test('通过审核只提交当前 publicationRevision 并刷新列表', async ()
   expect(payload).toEqual({
     decision: 'approve',
     expectedPublicationRevision: 4,
+    entryUrl: 'https://games.test/releases/game_1/index.html',
   });
   await waitFor(() =>
     expect(vi.mocked(listAdminGameDistributionReviews)).toHaveBeenCalledTimes(
@@ -95,12 +108,7 @@ test('通过审核只提交当前 publicationRevision 并刷新列表', async ()
   );
 });
 
-test('点击拒绝后填写理由再提交审核接口', async () => {
-  vi.mocked(reviewAdminGameDistributionVersion).mockResolvedValue({
-    version: { ...entry, status: 'rejected', reviewReason: '运行时报错' },
-    replayed: false,
-  });
-
+test('缺少拒绝理由时不调用审核接口', async () => {
   render(
     <AdminGameDistributionReviewPage
       token="admin-token"
@@ -110,32 +118,12 @@ test('点击拒绝后填写理由再提交审核接口', async () => {
   await screen.findByText('game_1');
 
   fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
-  const dialog = await screen.findByRole('dialog');
-  const reasonInput = within(dialog).getByRole('textbox', {
-    name: '拒绝理由',
-  });
 
-  fireEvent.click(within(dialog).getByRole('button', { name: '确认拒绝' }));
-  expect(await within(dialog).findByText('拒绝审核必须填写理由')).toBeTruthy();
+  expect(await screen.findByText('拒绝审核必须填写理由')).toBeTruthy();
   expect(reviewAdminGameDistributionVersion).not.toHaveBeenCalled();
-
-  fireEvent.change(reasonInput, { target: { value: '运行时报错' } });
-  fireEvent.click(within(dialog).getByRole('button', { name: '确认拒绝' }));
-
-  await waitFor(() =>
-    expect(reviewAdminGameDistributionVersion).toHaveBeenCalledTimes(1),
-  );
-  const [, versionId, , payload] =
-    vi.mocked(reviewAdminGameDistributionVersion).mock.calls[0] ?? [];
-  expect(versionId).toBe('version-1');
-  expect(payload).toEqual({
-    decision: 'reject',
-    expectedPublicationRevision: 4,
-    reviewReason: '运行时报错',
-  });
 });
 
-test('安全下架需要先填写原因，再二次确认并携带公开修订号', async () => {
+test('安全下架需要二次确认，并携带公开修订号与原因', async () => {
   vi.mocked(suspendAdminGameDistributionGame).mockResolvedValue({
     game: {
       id: 'game_1',
@@ -154,21 +142,16 @@ test('安全下架需要先填写原因，再二次确认并携带公开修订
   );
   await screen.findByText('game_1');
 
+  fireEvent.change(screen.getByLabelText('下架原因'), {
+    target: { value: '盗用素材' },
+  });
   fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
-  const reasonDialog = await screen.findByRole('dialog');
-  fireEvent.change(
-    within(reasonDialog).getByRole('textbox', { name: '下架原因' }),
-    {
-      target: { value: '盗用素材' },
-    },
-  );
-  fireEvent.click(
-    within(reasonDialog).getByRole('button', { name: '继续下架' }),
-  );
 
-  await screen.findByText('确认操作');
-  const confirmDialog = screen.getByRole('dialog');
-  fireEvent.click(within(confirmDialog).getByRole('button', { name: '确认' }));
+  // 第一次点击只弹出确认面板，不直接调用后端。
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+  expect(await screen.findByRole('dialog')).toBeTruthy();
+
+  fireEvent.click(screen.getByRole('button', { name: '确认' }));
 
   await waitFor(() =>
     expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
@@ -185,24 +168,7 @@ test('安全下架需要先填写原因，再二次确认并携带公开修订
   expect(await screen.findByText(/已安全下架/u)).toBeTruthy();
 });
 
-test('取消理由输入时不做审核操作', async () => {
-  render(
-    <AdminGameDistributionReviewPage
-      token="admin-token"
-      onUnauthorized={vi.fn()}
-    />,
-  );
-  await screen.findByText('game_1');
-
-  fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
-  const dialog = await screen.findByRole('dialog');
-  fireEvent.click(within(dialog).getByRole('button', { name: '取消' }));
-
-  await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
-  expect(reviewAdminGameDistributionVersion).not.toHaveBeenCalled();
-});
-
-test('取消安全下架确认时不下架', async () => {
+test('取消确认时不下架', async () => {
   render(
     <AdminGameDistributionReviewPage
       token="admin-token"
@@ -212,20 +178,8 @@ test('取消安全下架确认时不下架', async () => {
   await screen.findByText('game_1');
 
   fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
-  const reasonDialog = await screen.findByRole('dialog');
-  fireEvent.change(
-    within(reasonDialog).getByRole('textbox', { name: '下架原因' }),
-    {
-      target: { value: '盗用素材' },
-    },
-  );
-  fireEvent.click(
-    within(reasonDialog).getByRole('button', { name: '继续下架' }),
-  );
-
-  await screen.findByText('确认操作');
-  const confirmDialog = screen.getByRole('dialog');
-  fireEvent.click(within(confirmDialog).getByRole('button', { name: '取消' }));
+  await screen.findByRole('dialog');
+  fireEvent.click(screen.getByRole('button', { name: '取消' }));
 
   await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
   expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();

apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx

@@ -1,4 +1,3 @@
-import { Modal, TextField } from '@genarrative/shared/components';
 import { RefreshCcw } from 'lucide-react';
 import { useCallback, useEffect, useState } from 'react';
 
@@ -16,11 +15,6 @@ interface AdminGameDistributionReviewPageProps {
   onUnauthorized: (message?: string) => void;
 }
 
-interface ReviewReasonPrompt {
-  decision: 'reject' | 'suspend';
-  entry: AdminGameDistributionReviewEntry;
-}
-
 function formatBytes(value: number) {
   if (value >= 1024 * 1024) {
     return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
@@ -53,6 +47,26 @@ function createReviewIdempotencyKey(versionId: string) {
   return `game-review-${versionId}-${random}`.slice(0, 128);
 }
 
+export function resolveGameReleaseEntryUrlError(value: string) {
+  const normalized = value.trim();
+  if (!normalized) return '请填写发行入口';
+  if (!normalized.startsWith('https://')) {
+    return '发行入口必须以 https:// 开头';
+  }
+  if (normalized.includes('?') || normalized.includes('#')) {
+    return '发行入口不能包含 query 或 fragment';
+  }
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.username || parsed.password) {
+      return '发行入口不能包含凭据';
+    }
+  } catch {
+    return '发行入口不是合法 URL';
+  }
+  return '';
+}
+
 export function AdminGameDistributionReviewPage({
   token,
   onUnauthorized,
@@ -64,11 +78,15 @@ export function AdminGameDistributionReviewPage({
   const [busyVersionId, setBusyVersionId] = useState('');
   const [errorMessage, setErrorMessage] = useState('');
   const [statusMessage, setStatusMessage] = useState('');
-  const [reasonPrompt, setReasonPrompt] = useState<ReviewReasonPrompt | null>(
-    null,
-  );
-  const [reasonDraft, setReasonDraft] = useState('');
-  const [reasonError, setReasonError] = useState('');
+  const [entryUrlByVersion, setEntryUrlByVersion] = useState<
+    Record<string, string>
+  >({});
+  const [reasonByVersion, setReasonByVersion] = useState<
+    Record<string, string>
+  >({});
+  const [suspendReasonByGame, setSuspendReasonByGame] = useState<
+    Record<string, string>
+  >({});
   const [busyGameId, setBusyGameId] = useState('');
   const writeConfirm = useAdminWriteConfirm();
 
@@ -92,10 +110,16 @@ export function AdminGameDistributionReviewPage({
   async function submitReview(
     entry: AdminGameDistributionReviewEntry,
     decision: 'approve' | 'reject',
-    reason = '',
   ) {
-    const trimmedReason = reason.trim();
-    if (decision === 'reject' && !trimmedReason) {
+    const entryUrl = (entryUrlByVersion[entry.versionId] ?? '').trim();
+    const reason = (reasonByVersion[entry.versionId] ?? '').trim();
+    if (decision === 'approve') {
+      const invalid = resolveGameReleaseEntryUrlError(entryUrl);
+      if (invalid) {
+        setErrorMessage(invalid);
+        return;
+      }
+    } else if (!reason) {
       setErrorMessage('拒绝审核必须填写理由');
       return;
     }
@@ -111,11 +135,12 @@ export function AdminGameDistributionReviewPage({
           ? {
               decision,
               expectedPublicationRevision: entry.publicationRevision,
+              entryUrl,
             }
           : {
               decision,
               expectedPublicationRevision: entry.publicationRevision,
-              reviewReason: trimmedReason,
+              reviewReason: reason,
             },
       );
       setStatusMessage(
@@ -135,11 +160,8 @@ export function AdminGameDistributionReviewPage({
    * 管理员安全下架：先二次确认，再带当前公开修订号调用后端；并发审核导致修订号变化时
    * 由服务端返回冲突，前端只提示刷新，不静默重试。
    */
-  async function suspendGame(
-    entry: AdminGameDistributionReviewEntry,
-    reason: string,
-  ) {
-    const trimmedReason = reason.trim();
+  async function suspendGame(entry: AdminGameDistributionReviewEntry) {
+    const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
     const confirmed = await writeConfirm.confirmWrite({
       action: '安全下架游戏',
       target: `${entry.gameId}（版本 v${entry.versionNumber}）`,
@@ -155,10 +177,11 @@ export function AdminGameDistributionReviewPage({
         createSuspendIdempotencyKey(entry.gameId),
         {
           expectedPublicationRevision: entry.publicationRevision,
-          ...(trimmedReason ? { reason: trimmedReason } : {}),
+          ...(reason ? { reason } : {}),
         },
       );
       setStatusMessage(`游戏 ${entry.gameId} 已安全下架，发行入口已关闭`);
+      setSuspendReasonByGame((current) => ({ ...current, [entry.gameId]: '' }));
       await loadReviews();
     } catch (error) {
       handlePageError(error, onUnauthorized, setErrorMessage);
@@ -167,39 +190,6 @@ export function AdminGameDistributionReviewPage({
     }
   }
 
-  function openReasonPrompt(
-    entry: AdminGameDistributionReviewEntry,
-    decision: ReviewReasonPrompt['decision'],
-  ) {
-    setReasonDraft('');
-    setReasonError('');
-    setReasonPrompt({ decision, entry });
-  }
-
-  function closeReasonPrompt() {
-    setReasonPrompt(null);
-    setReasonDraft('');
-    setReasonError('');
-  }
-
-  function confirmReasonPrompt() {
-    if (!reasonPrompt) return;
-
-    const reason = reasonDraft.trim();
-    if (reasonPrompt.decision === 'reject' && !reason) {
-      setReasonError('拒绝审核必须填写理由');
-      return;
-    }
-
-    const { decision, entry } = reasonPrompt;
-    closeReasonPrompt();
-    if (decision === 'reject') {
-      void submitReview(entry, 'reject', reason);
-      return;
-    }
-    void suspendGame(entry, reason);
-  }
-
   return (
     <section className="admin-page admin-page-wide">
       <div className="admin-page-heading">
@@ -278,6 +268,25 @@ export function AdminGameDistributionReviewPage({
                       <td>{formatTime(entry.createdAt)}</td>
                       <td>
                         <div className="admin-action-row">
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-release-url-${entry.versionId}`}
+                            >
+                              发行入口
+                            </label>
+                            <input
+                              id={`game-release-url-${entry.versionId}`}
+                              value={entryUrlByVersion[entry.versionId] ?? ''}
+                              placeholder="https://"
+                              onChange={(event) =>
+                                setEntryUrlByVersion((current) => ({
+                                  ...current,
+                                  [entry.versionId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
                           <button
                             type="button"
                             className="admin-primary-button"
@@ -286,19 +295,55 @@ export function AdminGameDistributionReviewPage({
                           >
                             通过
                           </button>
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-reject-reason-${entry.versionId}`}
+                            >
+                              拒绝理由
+                            </label>
+                            <input
+                              id={`game-reject-reason-${entry.versionId}`}
+                              value={reasonByVersion[entry.versionId] ?? ''}
+                              onChange={(event) =>
+                                setReasonByVersion((current) => ({
+                                  ...current,
+                                  [entry.versionId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
                           <button
                             type="button"
                             className="admin-ghost-button"
                             disabled={busy}
-                            onClick={() => openReasonPrompt(entry, 'reject')}
+                            onClick={() => void submitReview(entry, 'reject')}
                           >
                             拒绝
                           </button>
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-suspend-reason-${entry.versionId}`}
+                            >
+                              下架原因
+                            </label>
+                            <input
+                              id={`game-suspend-reason-${entry.versionId}`}
+                              value={suspendReasonByGame[entry.gameId] ?? ''}
+                              onChange={(event) =>
+                                setSuspendReasonByGame((current) => ({
+                                  ...current,
+                                  [entry.gameId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
                           <button
                             type="button"
                             className="admin-danger-button"
                             disabled={busy || busyGameId === entry.gameId}
-                            onClick={() => openReasonPrompt(entry, 'suspend')}
+                            onClick={() => void suspendGame(entry)}
                           >
                             {busyGameId === entry.gameId
                               ? '正在下架…'
@@ -314,52 +359,6 @@ export function AdminGameDistributionReviewPage({
           </div>
         ) : null}
       </div>
-      {reasonPrompt ? (
-        <Modal
-          open
-          title={reasonPrompt.decision === 'reject' ? '拒绝审核' : '安全下架'}
-          description={`${reasonPrompt.entry.gameId} · 版本 v${reasonPrompt.entry.versionNumber}`}
-          closeLabel="关闭理由输入"
-          onClose={closeReasonPrompt}
-          size="sm"
-          className="genarrative-ui"
-          footer={
-            <div className="admin-confirm-actions" style={{ width: '100%' }}>
-              <button
-                type="button"
-                className="admin-secondary-button"
-                onClick={closeReasonPrompt}
-              >
-                取消
-              </button>
-              <button
-                type="button"
-                className={
-                  reasonPrompt.decision === 'reject'
-                    ? 'admin-ghost-button'
-                    : 'admin-danger-button'
-                }
-                onClick={confirmReasonPrompt}
-              >
-                {reasonPrompt.decision === 'reject' ? '确认拒绝' : '继续下架'}
-              </button>
-            </div>
-          }
-        >
-          <TextField
-            autoFocus
-            multiline
-            label={reasonPrompt.decision === 'reject' ? '拒绝理由' : '下架原因'}
-            value={reasonDraft}
-            error={reasonError}
-            rows={4}
-            onChange={(event) => {
-              setReasonDraft(event.target.value);
-              if (reasonError) setReasonError('');
-            }}
-          />
-        </Modal>
-      ) : null}
       {writeConfirm.confirmDialog}
     </section>
   );

apps/admin-web/src/pages/AdminGameManagementPage.test.tsx

@@ -1,265 +0,0 @@
-/* @vitest-environment jsdom */
-
-import {
-  cleanup,
-  fireEvent,
-  render,
-  screen,
-  waitFor,
-  within,
-} from '@testing-library/react';
-import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-
-import {
-  listAdminGameDistributionGames,
-  restoreAdminGameDistributionGame,
-  suspendAdminGameDistributionGame,
-} from '../api/adminApiClient';
-import type {
-  AdminGameDistributionGameEntry,
-  AdminGameDistributionGameVersionEntry,
-} from '../api/adminApiTypes';
-import { AdminGameManagementPage } from './AdminGameManagementPage';
-
-vi.mock('../api/adminApiClient', () => ({
-  isAdminApiError: vi.fn(
-    (error: unknown) =>
-      typeof error === 'object' &&
-      error !== null &&
-      'status' in error &&
-      typeof error.status === 'number',
-  ),
-  formatAdminApiError: vi.fn((error: unknown) =>
-    error instanceof Error ? error.message : '请求失败',
-  ),
-  listAdminGameDistributionGames: vi.fn(),
-  restoreAdminGameDistributionGame: vi.fn(),
-  suspendAdminGameDistributionGame: vi.fn(),
-}));
-
-const version: AdminGameDistributionGameVersionEntry = {
-  versionId: 'version-3',
-  gameId: 'game_1',
-  versionNumber: 3,
-  status: 'published',
-  reviewReason: '测试原因',
-  packageBytes: 2048,
-  packageSha256:
-    'abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789',
-  createdAt: '2026-09-20T08:00:00Z',
-  updatedAt: '2026-09-20T08:00:00Z',
-  reviewedAt: '2026-09-20T09:00:00Z',
-  publishedAt: '2026-09-20T10:00:00Z',
-  entryUrl: 'https://game.example.com/game_1',
-};
-
-const publishedGame: AdminGameDistributionGameEntry = {
-  gameId: 'game_1',
-  title: '测试游戏',
-  author: {
-    id: 'user_1',
-    name: '作者甲',
-    avatarUrl: 'https://example.com/avatar.png',
-  },
-  status: 'published',
-  versionCount: 21,
-  playCount: 345,
-  activeVersionId: 'version-3',
-  publicationRevision: 4,
-  createdAt: '2026-09-18T08:00:00Z',
-  updatedAt: '2026-09-20T10:00:00Z',
-  versions: [version],
-};
-
-const suspendedGame: AdminGameDistributionGameEntry = {
-  gameId: 'game_2',
-  title: '下架游戏',
-  author: {
-    id: 'user_2',
-    name: '作者乙',
-    avatarUrl: null,
-  },
-  status: 'suspended',
-  versionCount: 2,
-  playCount: 8,
-  activeVersionId: null,
-  publicationRevision: 7,
-  createdAt: '2026-09-19T08:00:00Z',
-  updatedAt: '2026-09-21T08:00:00Z',
-  versions: [],
-};
-
-beforeEach(() => {
-  vi.mocked(listAdminGameDistributionGames)
-    .mockReset()
-    .mockResolvedValue({ games: [publishedGame] });
-  vi.mocked(restoreAdminGameDistributionGame)
-    .mockReset()
-    .mockResolvedValue({
-      game: {
-        id: suspendedGame.gameId,
-        title: suspendedGame.title,
-        status: 'published',
-        publicationRevision: 8,
-      },
-      replayed: false,
-    });
-  vi.mocked(suspendAdminGameDistributionGame)
-    .mockReset()
-    .mockResolvedValue({
-      game: {
-        id: publishedGame.gameId,
-        title: publishedGame.title,
-        status: 'suspended',
-        publicationRevision: 5,
-      },
-      replayed: false,
-    });
-});
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-});
-
-test('列表展示作者头像、状态、版本数和游玩数', async () => {
-  vi.mocked(listAdminGameDistributionGames).mockResolvedValue({
-    games: [publishedGame, suspendedGame],
-  });
-
-  render(
-    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
-  );
-
-  const publishedRow = (await screen.findByText('测试游戏')).closest('tr')!;
-  expect(within(publishedRow).getByText('作者甲')).toBeTruthy();
-  const avatar = within(publishedRow).getByRole('img', {
-    name: '作者甲 头像',
-  });
-  expect(avatar.getAttribute('src')).toBe('https://example.com/avatar.png');
-  expect(within(publishedRow).getByText('已公开')).toBeTruthy();
-  expect(within(publishedRow).getByText('21')).toBeTruthy();
-  expect(within(publishedRow).getByText('345')).toBeTruthy();
-
-  const suspendedRow = (await screen.findByText('下架游戏')).closest('tr')!;
-  expect(within(suspendedRow).getByText('作者乙')).toBeTruthy();
-  expect(suspendedRow.querySelector('.admin-user-avatar')?.textContent).toBe(
-    '作',
-  );
-  expect(within(suspendedRow).getByText('已下架')).toBeTruthy();
-});
-
-test('恢复按钮只在下架态出现，成功后携带幂等键并刷新列表', async () => {
-  vi.mocked(listAdminGameDistributionGames)
-    .mockResolvedValueOnce({ games: [suspendedGame] })
-    .mockResolvedValueOnce({
-      games: [{ ...suspendedGame, status: 'published' }],
-    });
-
-  render(
-    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
-  );
-
-  await screen.findByText('下架游戏');
-  expect(screen.queryByRole('button', { name: '下架' })).toBeNull();
-  fireEvent.click(screen.getByRole('button', { name: '恢复' }));
-
-  expect(restoreAdminGameDistributionGame).not.toHaveBeenCalled();
-  await screen.findByRole('dialog');
-  fireEvent.click(screen.getByRole('button', { name: '确认' }));
-
-  await waitFor(() =>
-    expect(restoreAdminGameDistributionGame).toHaveBeenCalledTimes(1),
-  );
-  const [token, gameId, idempotencyKey, payload] =
-    vi.mocked(restoreAdminGameDistributionGame).mock.calls[0] ?? [];
-  expect(token).toBe('admin-token');
-  expect(gameId).toBe('game_2');
-  expect(String(idempotencyKey)).toContain('game_2');
-  expect(payload).toEqual({ expectedPublicationRevision: 7 });
-  await waitFor(() =>
-    expect(listAdminGameDistributionGames).toHaveBeenCalledTimes(2),
-  );
-  expect(await screen.findByText('游戏《下架游戏》已恢复')).toBeTruthy();
-});
-
-test('下架需要原因和二次确认，提交原因与当前公开修订号', async () => {
-  render(
-    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
-  );
-
-  await screen.findByText('测试游戏');
-  fireEvent.change(screen.getByLabelText('下架原因'), {
-    target: { value: '违规内容' },
-  });
-  fireEvent.click(screen.getByRole('button', { name: '下架' }));
-
-  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
-  await screen.findByRole('dialog');
-  fireEvent.click(screen.getByRole('button', { name: '确认' }));
-
-  await waitFor(() =>
-    expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
-  );
-  const [token, gameId, idempotencyKey, payload] =
-    vi.mocked(suspendAdminGameDistributionGame).mock.calls[0] ?? [];
-  expect(token).toBe('admin-token');
-  expect(gameId).toBe('game_1');
-  expect(String(idempotencyKey)).toContain('game_1');
-  expect(payload).toEqual({
-    expectedPublicationRevision: 4,
-    reason: '违规内容',
-  });
-  expect(await screen.findByText('游戏《测试游戏》已下架')).toBeTruthy();
-});
-
-test('版本历史弹层展示版本条目与统计信息', async () => {
-  render(
-    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
-  );
-
-  await screen.findByText('测试游戏');
-  fireEvent.click(screen.getByRole('button', { name: '版本历史' }));
-  const dialog = await screen.findByRole('dialog');
-
-  expect(within(dialog).getByText('共 21 个版本，展示最近 20 个')).toBeTruthy();
-  expect(within(dialog).getByText('v3')).toBeTruthy();
-  expect(within(dialog).getByText('published')).toBeTruthy();
-  expect(within(dialog).getByText('2.0 KiB')).toBeTruthy();
-  expect(within(dialog).getByText('abcdef012345')).toBeTruthy();
-  expect(within(dialog).getByText('测试原因')).toBeTruthy();
-  expect(
-    within(dialog).getByText('https://game.example.com/game_1'),
-  ).toBeTruthy();
-});
-
-test('接口失败显示错误文案', async () => {
-  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
-    new Error('游戏列表读取失败'),
-  );
-
-  render(
-    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
-  );
-
-  expect(await screen.findByText('游戏列表读取失败')).toBeTruthy();
-});
-
-test('401 交给 onUnauthorized 处理', async () => {
-  const onUnauthorized = vi.fn();
-  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
-    Object.assign(new Error('未授权'), { status: 401 }),
-  );
-
-  render(
-    <AdminGameManagementPage
-      token="admin-token"
-      onUnauthorized={onUnauthorized}
-    />,
-  );
-
-  await waitFor(() =>
-    expect(onUnauthorized).toHaveBeenCalledWith('登录状态已失效'),
-  );
-  expect(screen.queryByRole('alert')).toBeNull();
-});

apps/admin-web/src/pages/AdminGameManagementPage.tsx

@@ -1,456 +0,0 @@
-import { RefreshCcw, X } from 'lucide-react';
-import { useCallback, useEffect, useState } from 'react';
-
-import {
-  listAdminGameDistributionGames,
-  restoreAdminGameDistributionGame,
-  suspendAdminGameDistributionGame,
-} from '../api/adminApiClient';
-import type {
-  AdminGameDistributionGameEntry,
-  AdminGameDistributionGameVersionEntry,
-} from '../api/adminApiTypes';
-import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
-import { handlePageError } from './pageUtils';
-
-interface AdminGameManagementPageProps {
-  token: string;
-  onUnauthorized: (message?: string) => void;
-}
-
-const GAME_STATUS_META: Record<string, { label: string; className: string }> = {
-  published: { label: '已公开', className: 'admin-status-ok' },
-  suspended: { label: '已下架', className: 'admin-status-error' },
-  unpublished: { label: '未公开', className: 'admin-status-pending' },
-};
-
-function gameStatusMeta(status: string) {
-  return (
-    GAME_STATUS_META[status] ?? {
-      label: status || '—',
-      className: 'admin-status-pending',
-    }
-  );
-}
-
-function formatBytes(value: number) {
-  if (value >= 1024 * 1024) {
-    return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
-  }
-  if (value >= 1024) {
-    return `${(value / 1024).toFixed(1)} KiB`;
-  }
-  return `${value} B`;
-}
-
-function formatTime(value: string) {
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) return value;
-  return parsed.toLocaleString('zh-CN', { hour12: false });
-}
-
-function formatOptionalTime(value: string | null) {
-  return value ? formatTime(value) : '—';
-}
-
-function authorName(entry: AdminGameDistributionGameEntry) {
-  return entry.author?.name?.trim() || '—';
-}
-
-function authorInitial(entry: AdminGameDistributionGameEntry) {
-  const name = authorName(entry);
-  return name === '—' ? '—' : (Array.from(name)[0] ?? '—');
-}
-
-function createGameActionIdempotencyKey(
-  action: 'suspend' | 'restore',
-  gameId: string,
-) {
-  const random =
-    typeof crypto !== 'undefined' && 'randomUUID' in crypto
-      ? crypto.randomUUID()
-      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  const prefix = action === 'suspend' ? 'game-suspend' : 'game-restore';
-  return `${prefix}-${gameId}-${random}`.slice(0, 128);
-}
-
-export function AdminGameManagementPage({
-  token,
-  onUnauthorized,
-}: AdminGameManagementPageProps) {
-  const [games, setGames] = useState<AdminGameDistributionGameEntry[]>([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [busyGameId, setBusyGameId] = useState('');
-  const [errorMessage, setErrorMessage] = useState('');
-  const [statusMessage, setStatusMessage] = useState('');
-  const [suspendReasonByGame, setSuspendReasonByGame] = useState<
-    Record<string, string>
-  >({});
-  const [versionGame, setVersionGame] =
-    useState<AdminGameDistributionGameEntry | null>(null);
-  const writeConfirm = useAdminWriteConfirm();
-
-  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]);
-
-  useEffect(() => {
-    void loadGames();
-  }, [loadGames]);
-
-  useEffect(() => {
-    if (!versionGame) return undefined;
-
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (event.key === 'Escape') {
-        setVersionGame(null);
-      }
-    };
-    window.addEventListener('keydown', handleKeyDown);
-    return () => window.removeEventListener('keydown', handleKeyDown);
-  }, [versionGame]);
-
-  async function suspendGame(entry: AdminGameDistributionGameEntry) {
-    const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
-    if (!reason) {
-      setErrorMessage('下架原因不能为空');
-      setStatusMessage('');
-      return;
-    }
-
-    const confirmed = await writeConfirm.confirmWrite({
-      action: '下架游戏',
-      target: `${entry.title || entry.gameId}（${entry.gameId}）`,
-    });
-    if (!confirmed) return;
-
-    setBusyGameId(entry.gameId);
-    setErrorMessage('');
-    setStatusMessage('');
-    try {
-      await suspendAdminGameDistributionGame(
-        token,
-        entry.gameId,
-        createGameActionIdempotencyKey('suspend', entry.gameId),
-        {
-          expectedPublicationRevision: entry.publicationRevision,
-          reason,
-        },
-      );
-      setStatusMessage(`游戏《${entry.title || entry.gameId}》已下架`);
-      setSuspendReasonByGame((current) => ({
-        ...current,
-        [entry.gameId]: '',
-      }));
-      await loadGames();
-    } catch (error) {
-      handlePageError(error, onUnauthorized, setErrorMessage);
-    } finally {
-      setBusyGameId('');
-    }
-  }
-
-  async function restoreGame(entry: AdminGameDistributionGameEntry) {
-    const confirmed = await writeConfirm.confirmWrite({
-      action: '恢复游戏',
-      target: `${entry.title || entry.gameId}（${entry.gameId}）`,
-    });
-    if (!confirmed) return;
-
-    setBusyGameId(entry.gameId);
-    setErrorMessage('');
-    setStatusMessage('');
-    try {
-      await restoreAdminGameDistributionGame(
-        token,
-        entry.gameId,
-        createGameActionIdempotencyKey('restore', entry.gameId),
-        { expectedPublicationRevision: entry.publicationRevision },
-      );
-      setStatusMessage(`游戏《${entry.title || entry.gameId}》已恢复`);
-      await loadGames();
-    } catch (error) {
-      handlePageError(error, onUnauthorized, setErrorMessage);
-    } finally {
-      setBusyGameId('');
-    }
-  }
-
-  return (
-    <section className="admin-page admin-page-wide">
-      <div className="admin-page-heading">
-        <h1>游戏管理</h1>
-        <button
-          type="button"
-          className="admin-secondary-button"
-          onClick={() => void loadGames()}
-          disabled={isLoading}
-        >
-          <RefreshCcw aria-hidden="true" />
-          刷新
-        </button>
-      </div>
-
-      {errorMessage ? (
-        <div className="admin-alert admin-alert-warning" role="alert">
-          {errorMessage}
-        </div>
-      ) : null}
-      {statusMessage ? (
-        <div className="admin-alert admin-alert-success" role="status">
-          {statusMessage}
-        </div>
-      ) : null}
-
-      <div className="admin-panel">
-        <div className="admin-panel-heading">
-          <h2>游戏列表</h2>
-          <span className="admin-muted-text">共 {games.length} 条</span>
-        </div>
-
-        {isLoading ? (
-          <p className="admin-muted-text">正在加载游戏列表…</p>
-        ) : null}
-
-        {!isLoading && games.length === 0 ? (
-          <p className="admin-muted-text">暂无游戏。</p>
-        ) : null}
-
-        {!isLoading && games.length > 0 ? (
-          <div className="admin-table-wrap">
-            <table className="admin-table admin-table-wide">
-              <thead>
-                <tr>
-                  <th>标题</th>
-                  <th>作者</th>
-                  <th>gameId</th>
-                  <th>状态</th>
-                  <th>版本数</th>
-                  <th>游玩数</th>
-                  <th>操作</th>
-                </tr>
-              </thead>
-              <tbody>
-                {games.map((entry) => {
-                  const status = gameStatusMeta(entry.status);
-                  const isSuspended = entry.status === 'suspended';
-                  const busy = busyGameId === entry.gameId;
-                  return (
-                    <tr key={entry.gameId}>
-                      <td>
-                        <strong>{entry.title?.trim() || '—'}</strong>
-                      </td>
-                      <td>
-                        <div
-                          className="admin-database-user-cell"
-                          style={{ justifyContent: 'flex-start' }}
-                        >
-                          <div
-                            className="admin-user-avatar"
-                            style={{
-                              width: 32,
-                              height: 32,
-                              flex: '0 0 32px',
-                              fontSize: 13,
-                            }}
-                          >
-                            {entry.author?.avatarUrl ? (
-                              <img
-                                alt={`${authorName(entry)} 头像`}
-                                src={entry.author.avatarUrl}
-                              />
-                            ) : (
-                              authorInitial(entry)
-                            )}
-                          </div>
-                          <div>
-                            <span>{authorName(entry)}</span>
-                            <small>{entry.author?.id?.trim() || '—'}</small>
-                          </div>
-                        </div>
-                      </td>
-                      <td>
-                        <code>{entry.gameId}</code>
-                      </td>
-                      <td>
-                        <span className={`admin-status ${status.className}`}>
-                          {status.label}
-                        </span>
-                      </td>
-                      <td>{entry.versionCount}</td>
-                      <td>{entry.playCount}</td>
-                      <td>
-                        <div className="admin-action-row">
-                          {!isSuspended ? (
-                            <>
-                              <div className="admin-field">
-                                <label
-                                  htmlFor={`game-suspend-reason-${entry.gameId}`}
-                                >
-                                  下架原因
-                                </label>
-                                <input
-                                  id={`game-suspend-reason-${entry.gameId}`}
-                                  value={
-                                    suspendReasonByGame[entry.gameId] ?? ''
-                                  }
-                                  onChange={(event) =>
-                                    setSuspendReasonByGame((current) => ({
-                                      ...current,
-                                      [entry.gameId]: event.target.value,
-                                    }))
-                                  }
-                                  disabled={busy}
-                                />
-                              </div>
-                              <button
-                                type="button"
-                                className="admin-danger-button"
-                                disabled={busy}
-                                onClick={() => void suspendGame(entry)}
-                              >
-                                {busy ? '处理中…' : '下架'}
-                              </button>
-                            </>
-                          ) : (
-                            <button
-                              type="button"
-                              className="admin-primary-button"
-                              disabled={busy}
-                              onClick={() => void restoreGame(entry)}
-                            >
-                              {busy ? '处理中…' : '恢复'}
-                            </button>
-                          )}
-                          <button
-                            type="button"
-                            className="admin-secondary-button"
-                            disabled={busy}
-                            onClick={() => setVersionGame(entry)}
-                          >
-                            版本历史
-                          </button>
-                        </div>
-                      </td>
-                    </tr>
-                  );
-                })}
-              </tbody>
-            </table>
-          </div>
-        ) : null}
-      </div>
-
-      {versionGame ? (
-        <div
-          className="admin-confirm-backdrop"
-          role="presentation"
-          onMouseDown={(event) => {
-            if (event.target === event.currentTarget) {
-              setVersionGame(null);
-            }
-          }}
-        >
-          <section
-            aria-labelledby="admin-game-version-history-title"
-            aria-modal="true"
-            className="admin-detail-panel"
-            role="dialog"
-          >
-            <div className="admin-panel-heading">
-              <div>
-                <h2 id="admin-game-version-history-title">版本历史</h2>
-                <span>
-                  {versionGame.title?.trim() || '—'}（{versionGame.gameId}）
-                </span>
-              </div>
-              <button
-                aria-label="关闭版本历史"
-                className="admin-ghost-button"
-                type="button"
-                onClick={() => setVersionGame(null)}
-              >
-                <X size={17} aria-hidden="true" />
-              </button>
-            </div>
-            <p className="admin-muted-text">
-              共 {versionGame.versionCount} 个版本，展示最近 20 个
-            </p>
-            {versionGame.versions.length === 0 ? (
-              <p className="admin-muted-text">暂无版本记录。</p>
-            ) : (
-              <div className="admin-table-wrap">
-                <table className="admin-table admin-table-wide">
-                  <thead>
-                    <tr>
-                      <th>版本</th>
-                      <th>状态</th>
-                      <th>包大小</th>
-                      <th>SHA</th>
-                      <th>创建时间</th>
-                      <th>审核时间</th>
-                      <th>公开时间</th>
-                      <th>审核原因</th>
-                      <th>发行入口</th>
-                    </tr>
-                  </thead>
-                  <tbody>
-                    {versionGame.versions.map((version) => (
-                      <GameVersionRow
-                        key={version.versionId}
-                        version={version}
-                      />
-                    ))}
-                  </tbody>
-                </table>
-              </div>
-            )}
-          </section>
-        </div>
-      ) : null}
-
-      {writeConfirm.confirmDialog}
-    </section>
-  );
-}
-
-function GameVersionRow({
-  version,
-}: {
-  version: AdminGameDistributionGameVersionEntry;
-}) {
-  return (
-    <tr>
-      <td>v{version.versionNumber}</td>
-      <td>{version.status || '—'}</td>
-      <td>{formatBytes(version.packageBytes)}</td>
-      <td>
-        <code>{version.packageSha256?.slice(0, 12) || '—'}</code>
-      </td>
-      <td>{formatOptionalTime(version.createdAt)}</td>
-      <td>{formatOptionalTime(version.reviewedAt)}</td>
-      <td>{formatOptionalTime(version.publishedAt)}</td>
-      <td>{version.reviewReason?.trim() || '—'}</td>
-      <td>
-        {version.entryUrl ? (
-          <a href={version.entryUrl} rel="noreferrer" target="_blank">
-            {version.entryUrl}
-          </a>
-        ) : (
-          '—'
-        )}
-      </td>
-    </tr>
-  );
-}