清掉 api-server 两条编译告警：未使用导入与测试态死代码

- server-rs/crates/api-server/src/tripo3d/routes.rs：删除未使用的 Model3dJobTarget 导入，同批使用的 Model3dJobKind 等保留
- server-rs/crates/api-server/src/state.rs：map_editor_generation_pricing_persistence_error 只被 cfg(not(test)) 分支调用，补 cfg_attr(test, allow(dead_code))，与同文件 seed_editor_generation_pricing_config 的既有写法一致
- 验证：cargo check --workspace --all-targets 零告警零错误

.env.example

@@ -237,14 +237,10 @@ 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"
 
-# 客户端埋点接收绑定的公开 origin，由 API Server 运行时读取；修改后重启服务。
-# 必须与客户端登录地址一致，不带 /api、路径或尾部斜杠；未配置/非法时上传接口返回 503。
-# 本地端口按实际启动结果填写（端口漂移后需同步），localhost 与 127.0.0.1 不可混用。
-# dev 使用 https://dev.genarrative.world；release 使用 https://www.genarrative.world。
-GENARRATIVE_AGC_ANALYTICS_ORIGIN="http://127.0.0.1:8082"
-
 # Optional: official VikingDB credentials for regenerating build-tag similarities
 # with the Python embedding script. The script auto-loads `.env.local` and uses
 # the fixed `bge-large-zh` embedding model.

.gitignore

@@ -88,3 +88,16 @@ nohup.out
 spacetime.local.json
 deploy/container/api-server.env
 deploy/container/worker-smoke/
+
+# 仓库根目录下手工下载的 3D 样例模型（Tripo 联调 / 查看器排查用），不入库；
+# glTF / FBX 多文件产物会带着 .bin 缓冲与贴图落在同一目录，一并忽略
+/*.[gG][lL][bB]
+/*.[gG][lL][tT][fF]
+/*.[fF][bB][xX]
+/*.[bB][iI][nN]
+/*.[pP][nN][gG]
+/*.[jJ][pP][gG]
+/*.[jJ][pP][eE][gG]
+/*.[wW][eE][bB][pP]
+/*.[kK][tT][xX]2
+/*.[tT][gG][aA]

CONTEXT.md

@@ -50,6 +50,86 @@ _Avoid_: 为每个玩法单独发明素材流水线、把系列素材建模成
 
 ## Language
 
+### 3D Model Generation
+
+**3D 模型生成操作**:
+由文本提示或平台图片引用驱动、可异步查询并最终产生模型文件的 provider-neutral 操作；操作状态和产品资源结果分开建模。
+_Avoid_: 直接把第三方 provider task 当作产品资源、把模型 URL 当作永久资源地址
+
+**Provider task**:
+第三方 3D 生成平台返回的任务引用与任务快照，只存在于 provider adapter 的 Rust 边界内；它不是 Genarrative 的内部操作 ID。
+_Avoid_: 把 Tripo task ID 当作稳定产品 operationId、让 SDK 类型穿透 api-server
+
+**临时 provider URL**:
+第三方任务完成后返回的短时模型下载地址，必须通过显式下载流程转换为本地或持久化资源，不能直接当作长期资产地址。
+_Avoid_: 永久 OSS URL、资源 ID
+
+**模型 artifact**:
+由 text-to-model、image-to-model 或 multiview-to-model 任务产生、待应用层登记和持久化的模型文件结果；provider adapter 只提供可下载结果，不负责生成 resourceId 或 assetId。
+_Avoid_: 仅 UI 中展示的模型链接、没有来源任务的静态文件
+
+**Tripo API facade**:
+面向站内已认证调用方的全新 Tripo 3D 生成 API 上下文，负责把 API operation、用户归属、异步状态、产物持久化和正式资源引用连接起来；它独立于历史 Hyper3D adapter，不复用其路由、契约或实现。
+_Avoid_: 把 Tripo API 当成 Hyper3D 的 provider 替换、让 Hyper3D 路由悄悄切换到 Tripo
+
+**Tripo operation**:
+Genarrative 为一次 Tripo 生成请求分配的内部异步操作标识；客户端只看到 operationId，Tripo provider task 只作为服务端 checkpoint 保存，二者不是同一个 ID。
+_Avoid_: 将 Tripo taskId 直接当公开 operationId、把 SDK task 状态模型穿透到 API
+
+**模型产物持久化**:
+Tripo 任务完成后，服务端下载模型与预览、写入受控对象存储并登记资源元数据，成功后才把 Tripo operation 置为 completed；本期按完整字节写入，流式上传是后续目标。
+_Avoid_: 返回临时签名 URL作为永久资源、在 API handler 中把完整模型读成 Vec<u8>
+
+**3D 生成底价**:
+一次 3D 生成在指定端点和模型版本下、按是否带贴图区分的基准泥点价，不包含任何叠加项，也不随请求的其它参数变化。
+_Avoid_: 把底价与加价项合并成一个档位价、把 provider 的 credit 数值当底价
+
+**3D 生成加价项**:
+叠加在底价之上、由请求参数判定的可选泥点加价；每个端点各自持有一份加价项价目，同一加价项在不同端点可以是不同价。
+_Avoid_: 全局唯一一份加价项价目、按用途而不是按请求参数判定加价
+
+**定价配置归一化**:
+读取持久化定价时把它与当前契约对齐的过程：缺的键用受控默认值补齐，契约之外的遗留键剔除并告警；它只发生在读取方向，写入方向仍要求完整合法。
+_Avoid_: 把「省略即沿用」当作保存语义、把归一化当成静默改价
+
+**模型生成落点**:
+3D 生成结果要进入的平台容器，调用方必须在工程资源与素材库资产之间显式二选一；工程分支可附带画布占位框回填，素材库分支必须给出目录与标签。
+_Avoid_: 两个都不给就默认落素材库、把落点混进 provider 请求参数
+
+**模型输入资源引用**:
+image-to-model 请求对平台已有图片的明确 tagged 引用，可指向项目资源或素材库资产；服务端负责 owner 校验和 OSS 对象解析，不接受把多种来源塞进裸 `input` 字符串。
+_Avoid_: 任意远程 URL、data URL、未区分语义的 resourceId/assetId 字符串
+
+**3D 模型生成工具**:
+图片画布工程里从底部工具栏打开、给出「文生 3D 模型」与「图生 3D 模型」两个子项的画布生成工具；提交后按画布既有生成链路的占位框、任务侧栏与失败退款口径推进，产物落成 **3D 模型资源**。
+_Avoid_: 独立 3D 生成页、把 3D 生成做成玩法类型或作品、把 3D 生成接进画布 Agent 对话
+
+**3D 生成定价**:
+3D 模型生成工具在提交前展示的泥点价格，来自编辑器生成定价查询的 `model3d` 段；该段缺失即入口不可提交，前端不内置兜底数值。该段的权威事实源是 SpacetimeDB 定价表里的两段强类型列，公开读取时投影回迁移前的旧形状。
+_Avoid_: 前端写死 3D 价格、借用图片模型的兜底定价配置、按 0 元放行、把内部两段结构直接暴露给画布
+
+**定价版本（乐观锁）**:
+后台读取完整模型定价时一并拿到的版本号（SpacetimeDB 行的更新时间微秒值），保存时必须原样回传；与服务端当前版本不一致即整笔拒绝并返回 409，提示重新读取，避免静默覆盖他人的改价。
+_Avoid_: 在前端自造或缓存该版本、把版本不匹配当成可重试的普通失败、把「省略字段」当成「沿用当前值」
+
+### 3D 模型资源预览
+
+**3D 模型资源**:
+类别为 `model3d` 的平台资源 / 素材，一个资源同时持有模型本体与模型预览图两个对象；客户端默认消费预览图，模型本体只在 3D 查看器里加载。
+_Avoid_: 只有模型文件的资源、把模型本体当图片素材、为模型新增并列媒体类型
+
+**模型预览图**:
+3D 模型资源的静态代表图，落在资源投影的 `imageSrc` 与 `thumbnailSrc` 上，供画布卡片、素材缩略图、后台列表和精选卡片使用。
+_Avoid_: 用模型本体充当预览、按需实时渲染缩略图、把预览图当模型真相
+
+**模型本体**:
+3D 模型资源里的可下载模型文件，只由资源的 `objectKey` 指向，格式以对象内容类型为准。
+_Avoid_: 把模型本体当图片地址、用预览图字段承载模型文件、按文件扩展名推断格式
+
+**3D 查看器预览**:
+在资源上打开模态把模型本体交给 3D 查看器渲染的只读能力，不修改资源、不产出新资源，也不是画布图层本身的编辑操作。
+_Avoid_: 在画布里内联渲染模型、把预览当编辑、为预览产出新资源
+
 ### Puzzle Clear
 
 **拼消消**:
@@ -194,6 +274,14 @@ _Avoid_: 进度通知、快照轮询、第二套历史
 把项目对话历史条目与运行态事件转换成消息气泡和工具卡片的读取期转换；不持久化，也不构成事实源。
 _Avoid_: 投影缓存文件、已脱敏卡片库、第二套 reducer
 
+**项目对话输入**:
+AGC 项目对话的输入只有自然语言回合（含 `@` 素材引用与附件）；需要动作时由 Runtime 工具与确认卡承接，不从输入文本解析控制词。
+_Avoid_: 斜杠命令、聊天命令草稿、命令发现列表
+
+**项目命令 id**:
+AGC 运行期工具与项目权限策略使用的稳定标识（`GAME_CREATION_APP_COMMANDS` 与 `GameCreationAppPermission`），由 Rust 运行期策略校验与 App 权限审计 / 项目前置条件判定消费，不是用户输入语法。
+_Avoid_: 把命令 id 当作可输入的聊天命令、为权限位补聊天入口
+
 **引用候选**:
 输入区可以命中的对象集合（`@` 素材、`$` Skill），由宿主按种类注入；输入区不判断候选属于哪一类。
 _Avoid_: 输入区自己读项目清单或应用目录、把候选取值写死在组件里
@@ -210,6 +298,18 @@ _Avoid_: 给附件或运行画面区域造候选、为它们保留输入区内
 引用在正文文本里的形态（`@显示名` / `$名称` / `@附件名`）及其反解析；出站与解析必须同一口径，token 前后各留一个空白。
 _Avoid_: 出站与解析各写一套、在空白边界之外再补兼容别名、让解析依赖具体种类的字段
 
+**引用名**:
+引用自己的名字，同时就是它在正文里的 token（资源显示名、Skill 名、附件名）；内部不允许出现空白，空白统一经 `normalizeMentionName` 折成 `-`。
+_Avoid_: 名字与 token 各存一份、靠补兼容别名或 `resourceId` 兜底来消化空白
+
+**引用候选枚举**:
+一种引用种类当前就绪的全部可引用对象，与候选菜单共用同一份集合；区别只在没有查询过滤和条数上限。
+_Avoid_: 拿菜单查询当枚举、为粘贴另建一份候选清单
+
+**引用粘贴解析**:
+把粘贴进来的纯文本按引用文本语法反解析回正文引用；只有身份唯一且逐字确认的 token 才成为引用，其余按原文保留。
+_Avoid_: 猜文件名或路径、为不确定的 token 挑一个候选、改写用户粘贴的其余文字
+
 **引用输入区**:
 只负责编辑与渲染引用的共享输入组件；候选、身份解析与文本语法都来自注入的 provider，它不持有项目清单、不访问后端。
 _Avoid_: 输入区自己拉 Skill 目录、把选择器面板塞在输入区内部
@@ -240,6 +340,7 @@ _Avoid_: 待发送附件列表与正文芯片并存、提交时再拼一遍附
 - **引用输入区** 由宿主注入的若干 **引用 provider** 组成；**引用候选** 与 **引用文本语法** 都来自 provider，输入区不判断引用种类。
 - **引用选择器** 不属于 **引用输入区**：它自己拿数据，确认后只通过输入区的插入缝交付引用。
 - 只有带触发符的 **引用 provider** 会产生候选；**静默 provider** 没有触发符，只能由外部插入或草稿回填进入正文。
+- **引用粘贴解析** 与出站显示是同一条 **引用文本语法** 的两端；**静默 provider** 的 token（`@附件名` / `@区域标签`）没有候选，因此粘贴时不重建。
 - **附件芯片** 是本轮附件的唯一事实源；附件导入失败时不产生芯片。
 
 ## Example dialogue

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

@@ -57,6 +57,7 @@ import type {
   AdminUpdateAccountResponse,
   AdminUpdateAgcTemplateRequest,
   AdminUploadedEditorShowcaseCampaignImage,
+  AdminUpsertEditorGenerationPricingRequest,
   AdminUpsertEditorShowcaseCampaignRequest,
   AdminUpsertFeatureGateConfigRequest,
   AdminUpsertProfileInviteCodeRequest,
@@ -516,7 +517,7 @@ export function getAdminEditorGenerationPricing(token: string) {
 
 export function upsertAdminEditorGenerationPricing(
   token: string,
-  payload: EditorGenerationPricingConfigPayload,
+  payload: AdminUpsertEditorGenerationPricingRequest,
 ) {
   return request<EditorGenerationPricingConfigPayload>(
     '/admin/api/editor-generation-pricing',

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

@@ -428,8 +428,42 @@ export interface EditorGenerationModelPricingPayload {
   prices?: Record<string, number>;
 }
 
+/** 某个 3D 模型版本在「无贴图 / 带贴图」两种形态下的泥点底价。 */
+export interface EditorGenerationModel3dVersionPricePayload {
+  noTexture: number;
+  texture: number;
+}
+
+/**
+ * 单个 3D 生成端点的整套定价：模型版本底价 + 该端点自己的加价项价目。
+ *
+ * 键集合由后端契约决定，后台只改数值：模型版本键与加价项键都直接来自接口返回，
+ * 不在前端硬编码清单，也不能新增、删除或停用。
+ */
+export interface EditorGenerationModel3dEndpointPricingPayload {
+  versionPrices: Record<string, EditorGenerationModel3dVersionPricePayload>;
+  addOnPrices: Record<string, number>;
+}
+
+/** 3D 生成定价段：两个端点并列，各持自己的设置。 */
+export interface EditorGenerationModel3dPricingPayload {
+  textToModelPricing: EditorGenerationModel3dEndpointPricingPayload;
+  imageToModelPricing: EditorGenerationModel3dEndpointPricingPayload;
+}
+
 export interface EditorGenerationPricingConfigPayload {
   models: Record<string, EditorGenerationModelPricingPayload>;
+  /** 后端尚未配置 3D 段时缺省；缺失即 3D 生成不可提交，后台也不能新建整段。 */
+  model3d?: EditorGenerationModel3dPricingPayload | null;
+  /** 当前定价版本：保存时原样回传做乐观锁，冲突时后端返回 409。 */
+  updatedAtMicros: number;
+}
+
+/** 后台保存定价的请求体：`models` 与 3D 两段都必须显式给出，外加读取到的定价版本。 */
+export interface AdminUpsertEditorGenerationPricingRequest {
+  models: Record<string, EditorGenerationModelPricingPayload>;
+  model3d: EditorGenerationModel3dPricingPayload | null;
+  expectedUpdatedAtMicros: number;
 }
 
 export interface AdminEditorAssetListQuery {

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

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

@@ -0,0 +1,136 @@
+import type { EditorGenerationModel3dPricingPayload } from '../api/adminApiTypes';
+import {
+  EDITOR_MODEL3D_ENDPOINT_SECTIONS,
+  editorModel3dAddOnLabel,
+  parsePositiveInteger,
+  updateEditorModel3dEndpointPricing,
+} from './adminEditorGenerationPricing';
+
+interface AdminEditorGenerationModel3dPricingSectionProps {
+  model3d: EditorGenerationModel3dPricingPayload;
+  onChange: (next: EditorGenerationModel3dPricingPayload) => void;
+}
+
+/**
+ * 3D 生成定价区块：按端点分成「文生 3D」与「图生 3D」两组，每组是该端点自己的
+ * 「模型版本 × {无贴图, 带贴图}」底价表与加价项单值输入。
+ *
+ * 键集合全部来自接口返回，后台只能改数值：不能新增、删除键，也不能停用整段。
+ */
+export function AdminEditorGenerationModel3dPricingSection({
+  model3d,
+  onChange,
+}: AdminEditorGenerationModel3dPricingSectionProps) {
+  function updateEndpoint(
+    section: (typeof EDITOR_MODEL3D_ENDPOINT_SECTIONS)[number]['key'],
+    updater: Parameters<typeof updateEditorModel3dEndpointPricing>[2],
+  ) {
+    onChange(updateEditorModel3dEndpointPricing(model3d, section, updater));
+  }
+
+  return (
+    <section className="admin-panel admin-pricing-model-card">
+      <div className="admin-pricing-model-heading">
+        <strong>3D 生成定价</strong>
+        <span className="admin-pricing-unit">按次</span>
+      </div>
+      <p className="admin-pricing-model3d-hint">
+        模型版本与加价项由后端契约给出，只能改数值；两段必须完整给出，缺失即 3D
+        生成不可提交。
+      </p>
+      <div className="admin-pricing-grid">
+        {EDITOR_MODEL3D_ENDPOINT_SECTIONS.map(({ key, label }) => (
+          <section className="admin-panel admin-pricing-model-card" key={key}>
+            <div className="admin-pricing-model-heading">
+              <strong>{label}</strong>
+            </div>
+            <div className="admin-pricing-model3d-list">
+              {Object.entries(model3d[key].versionPrices).map(
+                ([version, price]) => (
+                  <div className="admin-pricing-model3d-row" key={version}>
+                    <span className="admin-pricing-model3d-row-label">
+                      {version}
+                    </span>
+                    <label className="admin-field">
+                      <span>无贴图</span>
+                      <input
+                        aria-label={`${label} ${version} 无贴图`}
+                        min={1}
+                        step={1}
+                        type="number"
+                        value={price.noTexture}
+                        onChange={(event) =>
+                          updateEndpoint(key, (current) => ({
+                            ...current,
+                            versionPrices: {
+                              ...current.versionPrices,
+                              [version]: {
+                                ...price,
+                                noTexture: parsePositiveInteger(
+                                  event.target.value,
+                                ),
+                              },
+                            },
+                          }))
+                        }
+                      />
+                    </label>
+                    <label className="admin-field">
+                      <span>带贴图</span>
+                      <input
+                        aria-label={`${label} ${version} 带贴图`}
+                        min={1}
+                        step={1}
+                        type="number"
+                        value={price.texture}
+                        onChange={(event) =>
+                          updateEndpoint(key, (current) => ({
+                            ...current,
+                            versionPrices: {
+                              ...current.versionPrices,
+                              [version]: {
+                                ...price,
+                                texture: parsePositiveInteger(
+                                  event.target.value,
+                                ),
+                              },
+                            },
+                          }))
+                        }
+                      />
+                    </label>
+                  </div>
+                ),
+              )}
+            </div>
+            <div className="admin-form-row">
+              {Object.entries(model3d[key].addOnPrices).map(
+                ([addOn, price]) => (
+                  <label className="admin-field" key={addOn}>
+                    <span>{editorModel3dAddOnLabel(addOn)}</span>
+                    <input
+                      aria-label={`${label} ${editorModel3dAddOnLabel(addOn)}`}
+                      min={1}
+                      step={1}
+                      type="number"
+                      value={price}
+                      onChange={(event) =>
+                        updateEndpoint(key, (current) => ({
+                          ...current,
+                          addOnPrices: {
+                            ...current.addOnPrices,
+                            [addOn]: parsePositiveInteger(event.target.value),
+                          },
+                        }))
+                      }
+                    />
+                  </label>
+                ),
+              )}
+            </div>
+          </section>
+        ))}
+      </div>
+    </section>
+  );
+}

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

@@ -5,20 +5,23 @@ import userEvent from '@testing-library/user-event';
 import { beforeEach, expect, test, vi } from 'vitest';
 
 import {
+  AdminApiError,
   getAdminEditorGenerationPricing,
   upsertAdminEditorGenerationPricing,
 } from '../api/adminApiClient';
 import type { EditorGenerationPricingConfigPayload } from '../api/adminApiTypes';
 import { AdminEditorGenerationPricingPage } from './AdminEditorGenerationPricingPage';
 
-vi.mock('../api/adminApiClient', () => ({
-  formatAdminApiError: vi.fn((error: unknown) =>
-    error instanceof Error ? error.message : '请求失败',
-  ),
-  getAdminEditorGenerationPricing: vi.fn(),
-  isAdminApiError: vi.fn(() => false),
-  upsertAdminEditorGenerationPricing: vi.fn(),
-}));
+vi.mock('../api/adminApiClient', async () => {
+  const actual = await vi.importActual<typeof import('../api/adminApiClient')>(
+    '../api/adminApiClient',
+  );
+  return {
+    ...actual,
+    getAdminEditorGenerationPricing: vi.fn(),
+    upsertAdminEditorGenerationPricing: vi.fn(),
+  };
+});
 
 const pricing: EditorGenerationPricingConfigPayload = {
   models: {
@@ -41,36 +44,80 @@ const pricing: EditorGenerationPricingConfigPayload = {
     'audio1.0': { unit: 'perGeneration', price: 5 },
     'chirp-v5': { unit: 'perGeneration', price: 12 },
   },
+  model3d: {
+    textToModelPricing: {
+      versionPrices: {
+        'v3.1-20260211': { noTexture: 8, texture: 16 },
+        'P2-20260801': { noTexture: 80, texture: 88 },
+      },
+      addOnPrices: {
+        hdTexture: 8,
+        ultraTexture: 16,
+        quadMesh: 4,
+        generateParts: 16,
+      },
+    },
+    imageToModelPricing: {
+      versionPrices: {
+        'v3.1-20260211': { noTexture: 16, texture: 24 },
+        'P2-20260801': { noTexture: 80, texture: 88 },
+      },
+      addOnPrices: {
+        hdTexture: 8,
+        ultraTexture: 16,
+        quadMesh: 4,
+        generateParts: 16,
+      },
+    },
+  },
+  updatedAtMicros: 1_700_000_000_000_000,
 };
 
+function savedPricing(
+  overrides: Partial<EditorGenerationPricingConfigPayload> = {},
+) {
+  return {
+    ...pricing,
+    updatedAtMicros: pricing.updatedAtMicros + 1,
+    ...overrides,
+  };
+}
+
 beforeEach(() => {
   vi.clearAllMocks();
   vi.mocked(getAdminEditorGenerationPricing).mockResolvedValue(pricing);
-  vi.mocked(upsertAdminEditorGenerationPricing).mockResolvedValue({
-    ...pricing,
-    models: {
-      ...pricing.models,
-      'gpt-image-2': {
-        unit: 'perGeneration',
-        prices: { '1K': 20, '2K': 58 },
+  vi.mocked(upsertAdminEditorGenerationPricing).mockResolvedValue(
+    savedPricing({
+      models: {
+        ...pricing.models,
+        'gpt-image-2': {
+          unit: 'perGeneration',
+          prices: { '1K': 20, '2K': 58 },
+        },
       },
-    },
-  });
+    }),
+  );
 });
 
-test('模型定价后台按模型展示单位并保存尺寸定价', async () => {
-  const user = userEvent.setup();
+async function renderPage() {
   render(
     <AdminEditorGenerationPricingPage
       token="admin-token"
       onUnauthorized={vi.fn()}
     />,
   );
+  await screen.findByText('3D 生成定价');
+}
+
+test('模型定价后台按模型展示单位并保存尺寸定价', async () => {
+  const user = userEvent.setup();
+  await renderPage();
 
   expect((await screen.findAllByText('按次')).length).toBeGreaterThan(0);
   expect(screen.getAllByText('按秒').length).toBeGreaterThan(0);
-  const gptImage2kInput = screen.getByLabelText('gpt-image-2 2K');
-  fireEvent.change(gptImage2kInput, { target: { value: '58' } });
+  fireEvent.change(screen.getByLabelText('gpt-image-2 2K'), {
+    target: { value: '58' },
+  });
   await user.click(screen.getByRole('button', { name: '保存定价' }));
   await user.click(screen.getByRole('button', { name: '确认' }));
 
@@ -90,3 +137,99 @@ test('模型定价后台按模型展示单位并保存尺寸定价', async () =>
     );
   });
 });
+
+test('3D 区块按端点渲染版本底价与加价项，并随保存回传整段与定价版本', async () => {
+  const user = userEvent.setup();
+  await renderPage();
+
+  expect(screen.getByText('文生 3D')).toBeTruthy();
+  expect(screen.getByText('图生 3D')).toBeTruthy();
+  expect(screen.getAllByText('高清贴图').length).toBeGreaterThan(0);
+
+  fireEvent.change(screen.getByLabelText('文生 3D v3.1-20260211 带贴图'), {
+    target: { value: '18' },
+  });
+  fireEvent.change(screen.getByLabelText('图生 3D P2-20260801 无贴图'), {
+    target: { value: '86' },
+  });
+  fireEvent.change(screen.getByLabelText('文生 3D 四边形网格'), {
+    target: { value: '6' },
+  });
+
+  await user.click(screen.getByRole('button', { name: '保存定价' }));
+  await user.click(screen.getByRole('button', { name: '确认' }));
+
+  await waitFor(() => {
+    expect(upsertAdminEditorGenerationPricing).toHaveBeenCalledWith(
+      'admin-token',
+      expect.objectContaining({
+        expectedUpdatedAtMicros: pricing.updatedAtMicros,
+        model3d: {
+          textToModelPricing: expect.objectContaining({
+            versionPrices: expect.objectContaining({
+              'v3.1-20260211': { noTexture: 8, texture: 18 },
+            }),
+            addOnPrices: expect.objectContaining({ quadMesh: 6 }),
+          }),
+          imageToModelPricing: expect.objectContaining({
+            versionPrices: expect.objectContaining({
+              'P2-20260801': { noTexture: 86, texture: 88 },
+            }),
+          }),
+        },
+      }),
+    );
+  });
+});
+
+test('数值小于 1 时禁用保存并给出中文提示', async () => {
+  const user = userEvent.setup();
+  await renderPage();
+
+  fireEvent.change(screen.getByLabelText('文生 3D 四边形网格'), {
+    target: { value: '0' },
+  });
+
+  expect(await screen.findByText(/以下价格必须是不小于 1 的整数/)).toBeTruthy();
+  const saveButton = screen.getByRole('button', {
+    name: '保存定价',
+  }) as HTMLButtonElement;
+  expect(saveButton.disabled).toBe(true);
+  await user.click(saveButton);
+  expect(upsertAdminEditorGenerationPricing).not.toHaveBeenCalled();
+});
+
+test('保存遇到 409 时提示重新读取且不覆盖本地改动', async () => {
+  const user = userEvent.setup();
+  vi.mocked(upsertAdminEditorGenerationPricing).mockRejectedValue(
+    new AdminApiError({ message: '定价冲突', status: 409 }),
+  );
+  await renderPage();
+
+  await user.click(screen.getByRole('button', { name: '保存定价' }));
+  await user.click(screen.getByRole('button', { name: '确认' }));
+
+  expect(
+    await screen.findByText('定价已被其他人更新，请重新读取后再编辑保存'),
+  ).toBeTruthy();
+  expect(screen.getByRole('button', { name: '重新读取' })).toBeTruthy();
+});
+
+test('后端未配置 3D 段时给出提示并禁止保存', async () => {
+  vi.mocked(getAdminEditorGenerationPricing).mockResolvedValue({
+    ...pricing,
+    model3d: null,
+  });
+  render(
+    <AdminEditorGenerationPricingPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+
+  expect(await screen.findByText(/当前部署未配置 3D 定价段/)).toBeTruthy();
+  expect(
+    (screen.getByRole('button', { name: '保存定价' }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+});

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

@@ -3,14 +3,22 @@ import { FormEvent, useEffect, useState } from 'react';
 
 import {
   getAdminEditorGenerationPricing,
+  isAdminApiError,
   upsertAdminEditorGenerationPricing,
 } from '../api/adminApiClient';
 import type {
+  EditorGenerationModel3dPricingPayload,
   EditorGenerationModelPricingPayload,
   EditorGenerationPricingConfigPayload,
   EditorGenerationPricingUnitPayload,
 } from '../api/adminApiTypes';
 import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
+import { AdminEditorGenerationModel3dPricingSection } from './AdminEditorGenerationModel3dPricingSection';
+import {
+  buildAdminEditorGenerationPricingRequest,
+  collectInvalidEditorGenerationPricingLabels,
+  parsePositiveInteger,
+} from './adminEditorGenerationPricing';
 import { handlePageError } from './pageUtils';
 
 interface AdminEditorGenerationPricingPageProps {
@@ -20,6 +28,8 @@ interface AdminEditorGenerationPricingPageProps {
 
 const emptyPricing: EditorGenerationPricingConfigPayload = {
   models: {},
+  model3d: null,
+  updatedAtMicros: 0,
 };
 
 const unitLabels: Record<EditorGenerationPricingUnitPayload, string> = {
@@ -27,6 +37,9 @@ const unitLabels: Record<EditorGenerationPricingUnitPayload, string> = {
   perSecond: '按秒',
 };
 
+const PRICING_VERSION_CONFLICT_MESSAGE =
+  '定价已被其他人更新，请重新读取后再编辑保存';
+
 export function AdminEditorGenerationPricingPage({
   token,
   onUnauthorized,
@@ -36,6 +49,7 @@ export function AdminEditorGenerationPricingPage({
   const [isLoading, setIsLoading] = useState(false);
   const [isSaving, setIsSaving] = useState(false);
   const [errorMessage, setErrorMessage] = useState('');
+  const [isPricingVersionStale, setIsPricingVersionStale] = useState(false);
   const { confirmWrite, confirmDialog } = useAdminWriteConfirm();
 
   useEffect(() => {
@@ -46,6 +60,7 @@ export function AdminEditorGenerationPricingPage({
   async function refreshPricing() {
     setIsLoading(true);
     setErrorMessage('');
+    setIsPricingVersionStale(false);
     try {
       setPricing(await getAdminEditorGenerationPricing(token));
     } catch (error: unknown) {
@@ -57,10 +72,11 @@ export function AdminEditorGenerationPricingPage({
 
   async function handleSave(event: FormEvent<HTMLFormElement>) {
     event.preventDefault();
-    if (isSaving) {
+    if (isSaving || !canSave) {
       return;
     }
     setErrorMessage('');
+    setIsPricingVersionStale(false);
     const confirmed = await confirmWrite({
       action: '保存模型定价',
       target: '图片画布生成',
@@ -71,8 +87,18 @@ export function AdminEditorGenerationPricingPage({
 
     setIsSaving(true);
     try {
-      setPricing(await upsertAdminEditorGenerationPricing(token, pricing));
+      setPricing(
+        await upsertAdminEditorGenerationPricing(
+          token,
+          buildAdminEditorGenerationPricingRequest(pricing),
+        ),
+      );
     } catch (error: unknown) {
+      if (isAdminApiError(error) && error.status === 409) {
+        setErrorMessage(PRICING_VERSION_CONFLICT_MESSAGE);
+        setIsPricingVersionStale(true);
+        return;
+      }
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
       setIsSaving(false);
@@ -120,6 +146,15 @@ export function AdminEditorGenerationPricingPage({
     });
   }
 
+  function updateModel3dPrice(next: EditorGenerationModel3dPricingPayload) {
+    setPricing((current) => ({ ...current, model3d: next }));
+  }
+
+  const invalidPriceLabels =
+    collectInvalidEditorGenerationPricingLabels(pricing);
+  const isModel3dMissing = !pricing.model3d;
+  const canSave = invalidPriceLabels.length === 0 && !isModel3dMissing;
+
   return (
     <section className="admin-page admin-page-wide">
       <div className="admin-page-heading">
@@ -141,6 +176,31 @@ export function AdminEditorGenerationPricingPage({
       {errorMessage ? (
         <div className="admin-alert" role="status">
           {errorMessage}
+          {isPricingVersionStale ? (
+            <button
+              className="admin-secondary-button"
+              disabled={isLoading}
+              type="button"
+              onClick={refreshPricing}
+            >
+              <RefreshCcw size={17} aria-hidden="true" />
+              <span>重新读取</span>
+            </button>
+          ) : null}
+        </div>
+      ) : null}
+
+      {isModel3dMissing ? (
+        <div className="admin-alert" role="status">
+          当前部署未配置 3D 定价段（缺失即 3D
+          生成不可提交）：需先由受控默认配置提供两段价格，
+          后台不在页面里新建或停用整段。
+        </div>
+      ) : null}
+
+      {invalidPriceLabels.length > 0 ? (
+        <div className="admin-alert" role="status">
+          {`以下价格必须是不小于 1 的整数：${invalidPriceLabels.join('、')}`}
         </div>
       ) : null}
 
@@ -156,9 +216,16 @@ export function AdminEditorGenerationPricingPage({
           )}
         </div>
 
+        {pricing.model3d ? (
+          <AdminEditorGenerationModel3dPricingSection
+            model3d={pricing.model3d}
+            onChange={updateModel3dPrice}
+          />
+        ) : null}
+
         <button
           className="admin-primary-button"
-          disabled={isSaving}
+          disabled={isSaving || !canSave}
           type="submit"
         >
           <Save size={17} aria-hidden="true" />
@@ -223,8 +290,3 @@ function renderModelPricingCard({
     </section>
   );
 }
-
-function parsePositiveInteger(value: string) {
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-}

apps/admin-web/src/pages/adminEditorGenerationPricing.test.ts

@@ -0,0 +1,88 @@
+import { expect, test } from 'vitest';
+
+import type { EditorGenerationPricingConfigPayload } from '../api/adminApiTypes';
+import {
+  buildAdminEditorGenerationPricingRequest,
+  collectInvalidEditorGenerationPricingLabels,
+  editorModel3dAddOnLabel,
+  parsePositiveInteger,
+} from './adminEditorGenerationPricing';
+
+function pricingFixture(): EditorGenerationPricingConfigPayload {
+  return {
+    models: {
+      'gpt-image-2': { unit: 'perGeneration', prices: { '1K': 3, '2K': 5 } },
+      'audio1.0': { unit: 'perGeneration', price: 5 },
+    },
+    model3d: {
+      textToModelPricing: {
+        versionPrices: { 'v3.1-20260211': { noTexture: 8, texture: 16 } },
+        addOnPrices: { hdTexture: 8, unknownAddOn: 7 },
+      },
+      imageToModelPricing: {
+        versionPrices: { 'v3.1-20260211': { noTexture: 16, texture: 24 } },
+        addOnPrices: { hdTexture: 8 },
+      },
+    },
+    updatedAtMicros: 42,
+  };
+}
+
+test('数值解析把空串、非数字与 0 收敛成 0', () => {
+  expect(parsePositiveInteger('12')).toBe(12);
+  expect(parsePositiveInteger('')).toBe(0);
+  expect(parsePositiveInteger('abc')).toBe(0);
+  expect(parsePositiveInteger('0')).toBe(0);
+  expect(parsePositiveInteger('-3')).toBe(0);
+});
+
+test('未登记的 3D 加价项键回退显示原键名', () => {
+  expect(editorModel3dAddOnLabel('hdTexture')).toBe('高清贴图');
+  expect(editorModel3dAddOnLabel('unknownAddOn')).toBe('unknownAddOn');
+});
+
+test('校验覆盖模型档位与 3D 两段的全部数值', () => {
+  expect(collectInvalidEditorGenerationPricingLabels(pricingFixture())).toEqual(
+    [],
+  );
+
+  const invalid = pricingFixture();
+  const invalidImagePricing = invalid.models['gpt-image-2'];
+  const invalidTextEndpoint = invalid.model3d?.textToModelPricing;
+  const invalidImageEndpoint = invalid.model3d?.imageToModelPricing;
+  if (
+    !invalidImagePricing?.prices ||
+    !invalidTextEndpoint ||
+    !invalidImageEndpoint
+  ) {
+    throw new Error('夹具必须包含图片档位与 3D 两段');
+  }
+  const imageVersionPrice = invalidImageEndpoint.versionPrices['v3.1-20260211'];
+  if (!imageVersionPrice) {
+    throw new Error('夹具必须包含图生 3D 的版本底价');
+  }
+  invalidImagePricing.prices['2K'] = 0;
+  invalidTextEndpoint.addOnPrices.hdTexture = 0;
+  imageVersionPrice.noTexture = 0;
+  expect(collectInvalidEditorGenerationPricingLabels(invalid)).toEqual([
+    'gpt-image-2 2K',
+    '文生 3D 高清贴图',
+    '图生 3D v3.1-20260211 无贴图',
+  ]);
+});
+
+test('保存请求整段回传两段与定价版本，3D 缺失时回传 null', () => {
+  const pricing = pricingFixture();
+  expect(buildAdminEditorGenerationPricingRequest(pricing)).toEqual({
+    models: pricing.models,
+    model3d: pricing.model3d,
+    expectedUpdatedAtMicros: 42,
+  });
+  expect(
+    buildAdminEditorGenerationPricingRequest({ ...pricing, model3d: null }),
+  ).toEqual({
+    models: pricing.models,
+    model3d: null,
+    expectedUpdatedAtMicros: 42,
+  });
+});

apps/admin-web/src/pages/adminEditorGenerationPricing.ts

@@ -0,0 +1,116 @@
+import type {
+  AdminUpsertEditorGenerationPricingRequest,
+  EditorGenerationModel3dEndpointPricingPayload,
+  EditorGenerationModel3dPricingPayload,
+  EditorGenerationPricingConfigPayload,
+} from '../api/adminApiTypes';
+
+/** 3D 端点在两个并列段里的字段名与后台展示名。 */
+export const EDITOR_MODEL3D_ENDPOINT_SECTIONS = [
+  { key: 'textToModelPricing', label: '文生 3D' },
+  { key: 'imageToModelPricing', label: '图生 3D' },
+] as const satisfies ReadonlyArray<{
+  key: keyof EditorGenerationModel3dPricingPayload;
+  label: string;
+}>;
+
+/**
+ * 3D 加价项键到中文标签。键来自接口返回，这里只负责展示；遇到未登记的键回退显示原键名，
+ * 不因为标签缺失就把该项漏掉。
+ */
+const EDITOR_MODEL3D_ADD_ON_LABELS: Record<string, string> = {
+  hdTexture: '高清贴图',
+  ultraTexture: '超高清贴图',
+  hdGeometry: '高清几何',
+  quadMesh: '四边形网格',
+  smartLowPoly: '智能低面',
+  generateParts: '分件生成',
+};
+
+export function editorModel3dAddOnLabel(addOn: string) {
+  return EDITOR_MODEL3D_ADD_ON_LABELS[addOn] ?? addOn;
+}
+
+/** 输入框文本转整数；空串、非数字、0 与负数一律收敛成 0，交给提交前校验拦住。 */
+export function parsePositiveInteger(value: string) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+export function isPositiveMudPoints(value: number | null | undefined) {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 1;
+}
+
+/**
+ * 提交前校验：所有泥点数值都必须是不小于 1 的整数，返回不合法项的展示名。
+ *
+ * 后端仍会独立校验一遍；这里只是不把明显非法的 payload 发出去，避免保存后才报错。
+ */
+export function collectInvalidEditorGenerationPricingLabels(
+  pricing: EditorGenerationPricingConfigPayload,
+) {
+  const labels: string[] = [];
+  for (const [model, modelPricing] of Object.entries(pricing.models)) {
+    if (modelPricing.prices) {
+      for (const [tier, price] of Object.entries(modelPricing.prices)) {
+        if (!isPositiveMudPoints(price)) {
+          labels.push(`${model} ${tier}`);
+        }
+      }
+      continue;
+    }
+    if (!isPositiveMudPoints(modelPricing.price)) {
+      labels.push(`${model} 泥点`);
+    }
+  }
+
+  const model3d = pricing.model3d;
+  if (model3d) {
+    for (const { key, label } of EDITOR_MODEL3D_ENDPOINT_SECTIONS) {
+      const endpointPricing = model3d[key];
+      for (const [version, price] of Object.entries(
+        endpointPricing.versionPrices,
+      )) {
+        if (!isPositiveMudPoints(price.noTexture)) {
+          labels.push(`${label} ${version} 无贴图`);
+        }
+        if (!isPositiveMudPoints(price.texture)) {
+          labels.push(`${label} ${version} 带贴图`);
+        }
+      }
+      for (const [addOn, price] of Object.entries(
+        endpointPricing.addOnPrices,
+      )) {
+        if (!isPositiveMudPoints(price)) {
+          labels.push(`${label} ${editorModel3dAddOnLabel(addOn)}`);
+        }
+      }
+    }
+  }
+  return labels;
+}
+
+/**
+ * 组装保存请求：`models` 与 3D 两段整段回传，并带上读取时拿到的定价版本做乐观锁。
+ * 3D 段缺失时回传 `null`——服务端会以 400 拒绝，后台不允许在这里静默新建或丢弃整段。
+ */
+export function buildAdminEditorGenerationPricingRequest(
+  pricing: EditorGenerationPricingConfigPayload,
+): AdminUpsertEditorGenerationPricingRequest {
+  return {
+    models: pricing.models,
+    model3d: pricing.model3d ?? null,
+    expectedUpdatedAtMicros: pricing.updatedAtMicros,
+  };
+}
+
+/** 单个端点段的不可变更新：底价与加价项各改一处，其余原样保留。 */
+export function updateEditorModel3dEndpointPricing(
+  model3d: EditorGenerationModel3dPricingPayload,
+  section: keyof EditorGenerationModel3dPricingPayload,
+  updater: (
+    current: EditorGenerationModel3dEndpointPricingPayload,
+  ) => EditorGenerationModel3dEndpointPricingPayload,
+): EditorGenerationModel3dPricingPayload {
+  return { ...model3d, [section]: updater(model3d[section]) };
+}

apps/admin-web/src/styles/admin.css

@@ -2972,6 +2972,34 @@ button:disabled {
   gap: 10px;
 }
 
+.admin-pricing-model3d-list {
+  display: grid;
+  gap: 10px;
+}
+
+.admin-pricing-model3d-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.2fr) repeat(2, minmax(0, 1fr));
+  align-items: end;
+  gap: 10px;
+}
+
+.admin-pricing-model3d-row-label {
+  color: #5c3a26;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 1.4;
+  overflow-wrap: anywhere;
+  padding-bottom: 10px;
+}
+
+.admin-pricing-model3d-hint {
+  color: #7b5a45;
+  font-size: 13px;
+  line-height: 1.5;
+  margin: 0;
+}
+
 .admin-pricing-unit {
   flex: 0 0 auto;
   border-radius: 999px;
@@ -3022,6 +3050,7 @@ button:disabled {
   .admin-two-column-wide,
   .admin-accounts-layout,
   .admin-pricing-grid,
+  .admin-pricing-model3d-row,
   .admin-form-row,
   .admin-filter-grid,
   .admin-table-query-grid,

apps/ai-game-creator-shell/package.json

@@ -15,20 +15,10 @@
     "skill-pack:test": "node --test scripts/check-skill-pack.test.mjs",
     "llm-status": "node scripts/run-cli-with-config.mjs --llm-status",
     "agent-task": "node scripts/run-cli-with-config.mjs --agent-task",
-    "chat": "node scripts/run-cli-with-config.mjs --swarm-chat",
-    "swarm": "node scripts/run-cli-with-config.mjs --swarm-chat",
     "config": "node scripts/game-creator-config-wizard.mjs",
-    "test:chat": "node scripts/agent-swarm-test-chat.mjs --task \"制作一个可直接试玩的原创植物塔防小游戏：玩家选择并放置原创守卫阻挡敌人，完成波次后可以进入下一关并重新开始。主题、单位名称与视觉语言必须原创，不使用任何现有游戏角色、单位名、Logo 或受保护视觉语言。请自主完成正式产物、静态检查和双视口试玩验证。\" --no-open",
-    "test:chat:manual": "node scripts/agent-swarm-test-chat.mjs",
     "agent-run": "node scripts/run-cli-with-config.mjs --agent-run",
     "agent-run:smoke": "node scripts/smoke-agent-run-local-provider.mjs",
     "agent-runtime:real-e2e": "node scripts/agent-runtime-real-e2e.mjs",
-    "agent-runtime:collaboration-policy-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-collaboration-policy-mixed-recovery",
-    "agent-runtime:mixed-swarm-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-static-isolated-autonomous-chat",
-    "agent-runtime:supervisor-swarm-autonomous-chat-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-autonomous-chat",
-    "agent-runtime:supervisor-autonomous-playable-lane-defense-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-autonomous-playable-lane-defense",
-    "agent-runtime:supervisor-autonomous-playable-lane-defense-deterministic-e2e": "node scripts/agent-runtime-deterministic-playable-e2e.mjs",
-    "agent-runtime:supervisor-autonomous-playable-lane-defense-deterministic-self-test": "node scripts/agent-runtime-deterministic-playable-e2e.mjs --self-test",
     "agent-runtime:supervisor-swarm-transient-retry-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-transient-retry",
     "agent-runtime:supervisor-swarm-final-reply-transient-retry-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-final-reply-transient-retry",
     "agent-runtime:supervisor-swarm-tool-plan-handoff-runner-kill-real-e2e": "node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-tool-plan-handoff-runner-kill",

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/core.mjs

@@ -1,69 +1,8 @@
 import { createHash } from '../dependencies.mjs';
 import { isPlainObject } from '../harness/config.mjs';
-import {
-  interactiveCliOutput,
-  writeInteractiveCliLine,
-} from '../harness/process.mjs';
-import {
-  shutdownWaiters,
-  state,
-  userInputAnswerText,
-} from '../runtime-state.mjs';
+import { shutdownWaiters, state } from '../runtime-state.mjs';
 import { disposableProjectPathVariants } from './runtime.mjs';
 
-export async function answerRemainingInteractiveQuestions(session) {
-  let answeredPromptCount = 1;
-  const deadline = Date.now() + 60_000;
-  while (Date.now() < deadline) {
-    const output = interactiveCliOutput(session);
-    if (output.includes(`[\u5df2\u56de\u7b54] ${state.userInput.requestId}`))
-      return;
-    const promptCount = output.split('或直接输入其他答案：').length - 1;
-    while (answeredPromptCount < promptCount && answeredPromptCount < 3) {
-      writeInteractiveCliLine(session, userInputAnswerText);
-      answeredPromptCount += 1;
-    }
-    if (output.includes('[待确认]')) {
-      throw codedError('user-input-unexpected-tool-confirmation');
-    }
-    if (session.closed) throw codedError('user-input-cli-closed-before-answer');
-    await sleep(100);
-  }
-  throw codedError('user-input-answer-timeout');
-}
-
-export function parseSingleSwarmTurnReport(output, codePrefix) {
-  const reportLines = output
-    .split(/\r?\n/u)
-    .filter((line) => line.startsWith('[turn.report] '));
-  assert(reportLines.length === 1, `${codePrefix}-turn-report-count-invalid`);
-  const report = JSON.parse(reportLines[0].slice('[turn.report] '.length));
-  assert(
-    isPlainObject(report) &&
-      JSON.stringify(Object.keys(report).sort()) ===
-        JSON.stringify(
-          [
-            'schemaVersion',
-            'outcome',
-            'parentAgentId',
-            'sessionId',
-            'parentRunId',
-            'runtimeCount',
-            'busyRuntimeCount',
-            'pendingTaskCount',
-            'runningTaskCount',
-            'waitingForConfirmationCount',
-            'waitingForUserInputCount',
-            'newAssistantMessageCount',
-            'finalReplyChars',
-            'reconciliationAgentCount',
-          ].sort(),
-        ),
-    `${codePrefix}-turn-report-shape-invalid`,
-  );
-  return report;
-}
-
 export function isFailedTask(task) {
   return (
     ['failed', 'cancelled', 'budget-exhausted'].includes(task.status) ||

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/runtime.mjs

@@ -2419,24 +2419,6 @@ export function finalMessageId(agentId, sessionId, runId) {
   ).slice(0, 32)}`;
 }
 
-export function runtimePublicStatusMessageId(
-  agentId,
-  sessionId,
-  runId,
-  status,
-) {
-  const correlationId = runtimeMessageCorrelationId(
-    agentId,
-    sessionId,
-    runId,
-  ).slice(0, 32);
-  const statusFingerprint = createHash('sha256')
-    .update(status)
-    .digest('hex')
-    .slice(0, 16);
-  return `runtime-public-status-${correlationId}-${statusFingerprint}`;
-}
-
 export function backgroundTaskMessageId(agentId, sessionId, runId, source) {
   const fingerprint = createHash('sha256')
     .update(`${agentId}\n${sessionId}\n${runId}\n${source}`)

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/app-data.mjs

@@ -37,26 +37,16 @@ import {
   state,
   steerRunnerKillAppDataSentinelFileName,
   steerRunnerKillAppDataSentinelSchema,
-  supervisorAutonomousPlayableAppDataSentinelFileName,
-  supervisorAutonomousPlayableAppDataSentinelSchema,
   supervisorSwarmAppDataSentinelFileName,
   supervisorSwarmAppDataSentinelSchema,
-  supervisorSwarmAutonomousChatAppDataSentinelFileName,
-  supervisorSwarmAutonomousChatAppDataSentinelSchema,
-  supervisorSwarmCollaborationPolicyAppDataSentinelFileName,
-  supervisorSwarmCollaborationPolicyAppDataSentinelSchema,
   supervisorSwarmFinalReplyTransientRetryAppDataSentinelFileName,
   supervisorSwarmFinalReplyTransientRetryAppDataSentinelSchema,
   supervisorSwarmRequiredAgentIds,
-  supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelFileName,
-  supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelSchema,
   supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelFileName,
   supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelSchema,
   supervisorSwarmTransientRetryAppDataSentinelFileName,
   supervisorSwarmTransientRetryAppDataSentinelSchema,
   supervisorSwarmTransientRetryTargetAgentId,
-  userInputAppDataSentinelFileName,
-  userInputAppDataSentinelSchema,
   webSearchAppDataSentinelFileName,
   webSearchAppDataSentinelSchema,
   windowsProcessHandleHelperSource,
@@ -68,21 +58,14 @@ import { isProjectSkillSuite } from '../suites/project-skill.mjs';
 import { isResponseStreamSuite } from '../suites/response-stream.mjs';
 import { isScopedAgentsSuite } from '../suites/scoped-agents.mjs';
 import { isSteerRunnerKillSuite } from '../suites/steer-runner-kill.mjs';
-import { isSupervisorAutonomousPlayableLaneDefenseSuite } from '../suites/supervisor-autonomous-playable.mjs';
 import {
-  isSupervisorSwarmAutonomousChatSuite,
-  isSupervisorSwarmCollaborationPolicyMixedRecoverySuite,
   isSupervisorSwarmFinalReplyTransientRetrySuite,
   isSupervisorSwarmInitialTransientRetrySuite,
-  isSupervisorSwarmInteractiveChatSuite,
-  isSupervisorSwarmMixedHarnessSuite,
-  isSupervisorSwarmStaticIsolatedAutonomousChatSuite,
   isSupervisorSwarmSuite,
   isSupervisorSwarmToolPlanHandoffRunnerKillSuite,
   isSupervisorSwarmTransientRetrySuite,
   rebuildSupervisorSwarmTranscriptScanner,
 } from '../suites/supervisor-swarm.mjs';
-import { isUserInputRuntimeSuite } from '../suites/user-input.mjs';
 import {
   isWebSearchSuite,
   sameEffectiveAgentLlmWithoutWebSearch,
@@ -100,19 +83,10 @@ import { appendBounded, runProcess } from './process.mjs';
 import { decodeUtf8Fatal, isIsolatedRunnerSuite } from './reporting.mjs';
 import { killRunnerOnce, readRunnerStatus, runnerBootId } from './runtime.mjs';
 
-const platformSessionFixtureEnv = 'GENARRATIVE_AGC_PLATFORM_SESSION_FIXTURE';
-const platformSessionFixtureMaxBytes = 16 * 1024;
-const isolatedPlatformSessionFixtureName =
-  '.deterministic-platform-session.json';
-const platformSessionFixtureSchema =
-  'genarrative-agc-platform-session-fixture.v1';
-
 export function isolatedSuiteProtectsSourceAppData() {
   return (
     isSupervisorSwarmTransientRetrySuite() ||
-    isSupervisorSwarmToolPlanHandoffRunnerKillSuite() ||
-    isSupervisorAutonomousPlayableLaneDefenseSuite() ||
-    isSupervisorSwarmInteractiveChatSuite()
+    isSupervisorSwarmToolPlanHandoffRunnerKillSuite()
   );
 }
 
@@ -120,27 +94,6 @@ export function isolatedSuiteUsesSiblingAppData() {
   return isWebSearchSuite() || isolatedSuiteProtectsSourceAppData();
 }
 
-export function sameSupervisorPlayableProviderBinding(left, right) {
-  const scalarFields = [
-    'providerAgentMode',
-    'providerModel',
-    'providerApiKind',
-    'providerReasoningEffort',
-    'providerBaseUrlSha256',
-  ];
-  return (
-    left != null &&
-    right != null &&
-    scalarFields.every((field) => left[field] === right[field]) &&
-    Array.isArray(left.boundAgentIds) &&
-    Array.isArray(right.boundAgentIds) &&
-    left.boundAgentIds.length === right.boundAgentIds.length &&
-    left.boundAgentIds.every(
-      (agentId, index) => agentId === right.boundAgentIds[index],
-    )
-  );
-}
-
 export function isolatedSuiteAppDataProfile() {
   if (isSteerRunnerKillSuite()) {
     return {
@@ -174,14 +127,6 @@ export function isolatedSuiteAppDataProfile() {
       codePrefix: 'context-compaction-appdata',
     };
   }
-  if (isUserInputRuntimeSuite()) {
-    return {
-      prefix: '.agent-runtime-real-e2e-user-input-',
-      sentinelName: userInputAppDataSentinelFileName,
-      sentinelSchema: userInputAppDataSentinelSchema,
-      codePrefix: 'user-input-appdata',
-    };
-  }
   if (isScopedAgentsSuite()) {
     return {
       prefix: '.agent-runtime-real-e2e-scoped-agents-',
@@ -236,41 +181,6 @@ export function isolatedSuiteAppDataProfile() {
       codePrefix: 'supervisor-swarm-transient-retry-appdata',
     };
   }
-  if (isSupervisorAutonomousPlayableLaneDefenseSuite()) {
-    return {
-      prefix: '.agent-runtime-real-e2e-supervisor-autonomous-playable-',
-      sentinelName: supervisorAutonomousPlayableAppDataSentinelFileName,
-      sentinelSchema: supervisorAutonomousPlayableAppDataSentinelSchema,
-      codePrefix: 'supervisor-autonomous-playable-appdata',
-    };
-  }
-  if (isSupervisorSwarmAutonomousChatSuite()) {
-    return {
-      prefix: '.agent-runtime-real-e2e-supervisor-swarm-autonomous-chat-',
-      sentinelName: supervisorSwarmAutonomousChatAppDataSentinelFileName,
-      sentinelSchema: supervisorSwarmAutonomousChatAppDataSentinelSchema,
-      codePrefix: 'supervisor-swarm-autonomous-chat-appdata',
-    };
-  }
-  if (isSupervisorSwarmStaticIsolatedAutonomousChatSuite()) {
-    return {
-      prefix:
-        '.agent-runtime-real-e2e-supervisor-swarm-static-isolated-autonomous-chat-',
-      sentinelName:
-        supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelFileName,
-      sentinelSchema:
-        supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelSchema,
-      codePrefix: 'supervisor-swarm-static-isolated-autonomous-chat-appdata',
-    };
-  }
-  if (isSupervisorSwarmCollaborationPolicyMixedRecoverySuite()) {
-    return {
-      prefix: '.agent-runtime-real-e2e-supervisor-swarm-collaboration-policy-',
-      sentinelName: supervisorSwarmCollaborationPolicyAppDataSentinelFileName,
-      sentinelSchema: supervisorSwarmCollaborationPolicyAppDataSentinelSchema,
-      codePrefix: 'supervisor-swarm-collaboration-policy-appdata',
-    };
-  }
   if (isSupervisorSwarmSuite()) {
     return {
       prefix: '.agent-runtime-real-e2e-supervisor-swarm-',
@@ -505,120 +415,6 @@ export async function verifySourceAppDataDirectoryUntouched() {
   state.isolatedRunner.sourceAppDataDirectoryUntouched = true;
 }
 
-async function readPlatformSessionFixtureForIsolatedSuite(sourceConfigDir) {
-  const rawPath = process.env[platformSessionFixtureEnv];
-  assert(
-    isNonEmptyString(rawPath) && path.isAbsolute(rawPath),
-    'supervisor-autonomous-playable-platform-session-fixture-missing',
-  );
-  const sourceRealPath = await fs.realpath(sourceConfigDir);
-  const requestedPath = path.resolve(rawPath);
-  const requestedMetadata = await fs.lstat(requestedPath).catch((error) => {
-    if (error?.code === 'ENOENT') return null;
-    throw error;
-  });
-  assert(
-    requestedMetadata?.isFile() && !requestedMetadata.isSymbolicLink(),
-    'supervisor-autonomous-playable-platform-session-fixture-not-regular',
-  );
-  assert(
-    requestedMetadata.size <= platformSessionFixtureMaxBytes,
-    'supervisor-autonomous-playable-platform-session-fixture-too-large',
-  );
-  const realPath = await fs.realpath(requestedPath);
-  assert(
-    isPathInside(sourceRealPath, realPath),
-    'supervisor-autonomous-playable-platform-session-fixture-outside-config',
-  );
-  const bytes = await fs.readFile(realPath);
-  assert(
-    bytes.length <= platformSessionFixtureMaxBytes,
-    'supervisor-autonomous-playable-platform-session-fixture-too-large',
-  );
-  let fixture;
-  try {
-    fixture = JSON.parse(
-      decodeUtf8Fatal(bytes, 'platform-session-fixture-invalid-utf8'),
-    );
-  } catch (error) {
-    throw codedError(
-      'supervisor-autonomous-playable-platform-session-fixture-invalid',
-      error,
-    );
-  }
-  const expectedKeys = [
-    'schemaVersion',
-    'userId',
-    'accessToken',
-    'apiBaseUrl',
-    'generation',
-  ];
-  assert(
-    isPlainObject(fixture) &&
-      JSON.stringify(Object.keys(fixture).sort()) ===
-        JSON.stringify([...expectedKeys].sort()) &&
-      fixture.schemaVersion === platformSessionFixtureSchema &&
-      isNonEmptyString(fixture.userId) &&
-      isNonEmptyString(fixture.accessToken) &&
-      isNonEmptyString(fixture.apiBaseUrl) &&
-      Number.isSafeInteger(fixture.generation) &&
-      fixture.generation > 0,
-    'supervisor-autonomous-playable-platform-session-fixture-invalid',
-  );
-  return {
-    sourcePath: realPath,
-    bytes,
-    fixture,
-    sha256: createHash('sha256').update(bytes).digest('hex'),
-  };
-}
-
-async function installPlatformSessionFixtureIntoIsolatedAppData(
-  sourceConfigDir,
-  appDataDir,
-) {
-  if (!isSupervisorAutonomousPlayableLaneDefenseSuite()) return;
-  const source =
-    await readPlatformSessionFixtureForIsolatedSuite(sourceConfigDir);
-  const isolatedPath = path.join(
-    appDataDir,
-    isolatedPlatformSessionFixtureName,
-  );
-  await fs.copyFile(
-    source.sourcePath,
-    isolatedPath,
-    fsConstants.COPYFILE_EXCL | fsConstants.COPYFILE_FICLONE,
-  );
-  await fs.chmod(isolatedPath, 0o600).catch(() => {});
-  const isolatedMetadata = await fs.lstat(isolatedPath);
-  assert(
-    isolatedMetadata.isFile() &&
-      !isolatedMetadata.isSymbolicLink() &&
-      isolatedMetadata.size === source.bytes.length,
-    'supervisor-autonomous-playable-platform-session-fixture-copy-invalid',
-  );
-  const isolatedBytes = await fs.readFile(isolatedPath);
-  assert(
-    createHash('sha256').update(isolatedBytes).digest('hex') === source.sha256,
-    'supervisor-autonomous-playable-platform-session-fixture-copy-mismatch',
-  );
-  state.isolatedRunner.platformSessionFixtureSourcePath = source.sourcePath;
-  state.isolatedRunner.platformSessionFixturePath = isolatedPath;
-  state.isolatedRunner.platformSessionFixtureSha256 = source.sha256;
-  state.isolatedRunner.platformSessionFixturePreviousEnv =
-    Object.prototype.hasOwnProperty.call(process.env, platformSessionFixtureEnv)
-      ? process.env[platformSessionFixtureEnv]
-      : undefined;
-  process.env[platformSessionFixtureEnv] = isolatedPath;
-  state.formalConfigPathTranscriptScanner?.addSecrets(
-    absolutePathVariants(source.sourcePath, isolatedPath),
-  );
-  const previousLeakCount = state.transcriptScanner?.count ?? 0;
-  state.secrets = [...new Set([...state.secrets, source.fixture.accessToken])];
-  rebuildSupervisorSwarmTranscriptScanner();
-  state.transcriptScanner.count = previousLeakCount;
-}
-
 export async function prepareIsolatedSuiteAppData({
   streamAgentId = null,
   webSearchAgentId = null,
@@ -773,8 +569,7 @@ export async function prepareIsolatedSuiteAppData({
       isScopedAgentsSuite() ||
       isProjectSkillSuite() ||
       isParallelReadSuite() ||
-      isSupervisorSwarmSuite() ||
-      isSupervisorAutonomousPlayableLaneDefenseSuite()
+      isSupervisorSwarmSuite()
         ? 'private-copy'
         : 'hardlink';
     try {
@@ -891,10 +686,6 @@ export async function prepareIsolatedSuiteAppData({
   state.secrets = [...suiteSecrets];
   rebuildSupervisorSwarmTranscriptScanner();
   state.transcriptScanner.count = previousLeakCount;
-  await installPlatformSessionFixtureIntoIsolatedAppData(
-    sourceConfigDir,
-    appDataDir,
-  );
   const unexpectedEndpoint = await fs
     .lstat(path.join(appDataDir, runnerEndpointFileName))
     .catch((error) => {
@@ -903,46 +694,6 @@ export async function prepareIsolatedSuiteAppData({
     });
   assert(!unexpectedEndpoint, `${profile.codePrefix}-endpoint-preexisted`);
   state.runtimeConfigDir = appDataDir;
-  if (isSupervisorAutonomousPlayableLaneDefenseSuite()) {
-    const isolatedConfig = await loadConfig(appDataDir);
-    const expectedBinding = state.config.providerBinding;
-    const agentIds = [projectSupervisorAgentId];
-    const bindings = agentIds.map((agentId) => {
-      const effective = effectiveAgentLlmConfig(isolatedConfig.config, agentId);
-      assert(
-        ['apiKey', 'baseUrl', 'model', 'apiKind', 'reasoningEffort'].every(
-          (key) => isNonEmptyString(effective[key]),
-        ),
-        'supervisor-autonomous-playable-effective-provider-incomplete',
-      );
-      return {
-        providerModel: effective.model.trim(),
-        providerApiKind: effective.apiKind.trim(),
-        providerReasoningEffort: effective.reasoningEffort.trim(),
-        providerBaseUrlSha256: hashValue(effective.baseUrl.trim()),
-      };
-    });
-    const effectiveBinding = {
-      ...bindings[0],
-      boundAgentIds: [...agentIds].sort(),
-    };
-    assert(
-      expectedBinding &&
-        bindings.every(
-          (binding) => JSON.stringify(binding) === JSON.stringify(bindings[0]),
-        ) &&
-        sameSupervisorPlayableProviderBinding(
-          effectiveBinding,
-          expectedBinding,
-        ),
-      'supervisor-autonomous-playable-effective-provider-binding-mismatch',
-    );
-    state.supervisorAutonomousPlayable.expectedProviderBinding = {
-      ...expectedBinding,
-    };
-    state.supervisorAutonomousPlayable.effectiveProviderBinding =
-      effectiveBinding;
-  }
   if (streamAgentId) {
     const isolatedConfig = await loadConfig(appDataDir);
     const isolatedEffective = effectiveAgentLlmConfig(
@@ -981,22 +732,6 @@ export async function prepareIsolatedSuiteAppData({
     );
     state.webSearch.effectiveEnabled = true;
   }
-  if (isUserInputRuntimeSuite()) {
-    const isolatedConfig = await loadConfig(appDataDir);
-    const isolatedEffective = effectiveAgentLlmConfig(
-      isolatedConfig.config,
-      projectSupervisorAgentId,
-    );
-    assert(
-      isolatedEffective.model === 'gpt-5.5' &&
-        ['apiKey', 'baseUrl', 'model'].every(
-          (key) =>
-            typeof isolatedEffective[key] === 'string' &&
-            isolatedEffective[key].trim().length > 0,
-        ),
-      'user-input-effective-gpt-5-5-config-invalid',
-    );
-  }
   if (isScopedAgentsSuite()) {
     const isolatedConfig = await loadConfig(appDataDir);
     const isolatedEffective = effectiveAgentLlmConfig(
@@ -1073,9 +808,8 @@ export async function prepareIsolatedSuiteAppData({
           effective.requestTimeoutMs > 0 &&
           Number.isSafeInteger(effective.maxRetries) &&
           effective.maxRetries >=
-            (isSupervisorSwarmInteractiveChatSuite() ||
             (isSupervisorSwarmTransientRetrySuite() &&
-              agentId !== supervisorSwarmTransientRetryTargetAgentId)
+            agentId !== supervisorSwarmTransientRetryTargetAgentId
               ? 0
               : 1) &&
           effective.maxRetries <= 3 &&
@@ -1095,24 +829,6 @@ export async function prepareIsolatedSuiteAppData({
       { llm: isolatedConfig.config.llm },
       '',
     );
-    if (isSupervisorSwarmMixedHarnessSuite()) {
-      assert(
-        globalEffective.model === 'gpt-5.5' &&
-          globalEffective.apiKind === 'openai_chat' &&
-          isNonEmptyString(globalEffective.reasoningEffort) &&
-          Number.isSafeInteger(globalEffective.requestTimeoutMs) &&
-          globalEffective.requestTimeoutMs > 0 &&
-          Number.isSafeInteger(globalEffective.maxRetries) &&
-          globalEffective.maxRetries >= 0 &&
-          globalEffective.maxRetries <= 3 &&
-          Number.isSafeInteger(globalEffective.retryBackoffMs) &&
-          globalEffective.retryBackoffMs > 0 &&
-          ['apiKey', 'baseUrl', 'model'].every((key) =>
-            isNonEmptyString(globalEffective[key]),
-          ),
-        'supervisor-swarm-mixed-default-provider-policy-invalid',
-      );
-    }
     const configuredAgentIds = Object.keys(
       isPlainObject(isolatedConfig.config.agentLlm)
         ? isolatedConfig.config.agentLlm
@@ -2000,31 +1716,6 @@ export async function verifyIsolatedSuiteConfigLinksUnchanged() {
       'isolated-source-config-changed-during-suite',
     );
   }
-  const fixture = state.isolatedRunner;
-  if (
-    fixture.platformSessionFixtureSourcePath &&
-    fixture.platformSessionFixturePath &&
-    fixture.platformSessionFixtureSha256
-  ) {
-    const [sourceMetadata, isolatedMetadata, sourceBytes, isolatedBytes] =
-      await Promise.all([
-        fs.lstat(fixture.platformSessionFixtureSourcePath),
-        fs.lstat(fixture.platformSessionFixturePath),
-        fs.readFile(fixture.platformSessionFixtureSourcePath),
-        fs.readFile(fixture.platformSessionFixturePath),
-      ]);
-    assert(
-      sourceMetadata.isFile() &&
-        !sourceMetadata.isSymbolicLink() &&
-        isolatedMetadata.isFile() &&
-        !isolatedMetadata.isSymbolicLink() &&
-        createHash('sha256').update(sourceBytes).digest('hex') ===
-          fixture.platformSessionFixtureSha256 &&
-        createHash('sha256').update(isolatedBytes).digest('hex') ===
-          fixture.platformSessionFixtureSha256,
-      'supervisor-autonomous-playable-platform-session-fixture-changed',
-    );
-  }
 }
 
 export async function verifySourceConfigLinkCountsRestored() {
@@ -2064,22 +1755,7 @@ export async function removeIsolatedSuiteAppData() {
   } catch (error) {
     ownershipError = error;
   }
-  try {
-    await fs.rm(appDataDir, { recursive: true, force: false });
-  } finally {
-    if (state.isolatedRunner.platformSessionFixtureSourcePath) {
-      const previous = state.isolatedRunner.platformSessionFixturePreviousEnv;
-      if (previous === undefined) {
-        delete process.env[platformSessionFixtureEnv];
-      } else {
-        process.env[platformSessionFixtureEnv] = previous;
-      }
-    }
-    state.isolatedRunner.platformSessionFixturePath = null;
-    state.isolatedRunner.platformSessionFixtureSourcePath = null;
-    state.isolatedRunner.platformSessionFixtureSha256 = null;
-    state.isolatedRunner.platformSessionFixturePreviousEnv = undefined;
-  }
+  await fs.rm(appDataDir, { recursive: true, force: false });
   state.runtimeConfigDir = state.options.configDir;
   try {
     await verifySourceConfigLinkCountsRestored();

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/config.mjs

@@ -13,15 +13,10 @@ import {
   responseStreamSuite,
   scopedAgentsSuite,
   steerRunnerKillSuite,
-  supervisorAutonomousPlayableLaneDefenseSuite,
-  supervisorSwarmAutonomousChatSuite,
-  supervisorSwarmCollaborationPolicyMixedRecoverySuite,
   supervisorSwarmFinalReplyTransientRetrySuite,
-  supervisorSwarmStaticIsolatedAutonomousChatSuite,
   supervisorSwarmSuite,
   supervisorSwarmToolPlanHandoffRunnerKillSuite,
   supervisorSwarmTransientRetrySuite,
-  userInputRuntimeSuite,
   webSearchSuite,
 } from '../runtime-state.mjs';
 import { collectApiKeys, isPathInside } from './io.mjs';
@@ -58,7 +53,6 @@ export function parseArguments(args) {
       suite === responseStreamSuite ||
       suite === webSearchSuite ||
       suite === contextCompactionSuite ||
-      suite === userInputRuntimeSuite ||
       suite === scopedAgentsSuite ||
       suite === projectSkillSuite ||
       suite === parallelReadSuite ||
@@ -66,10 +60,6 @@ export function parseArguments(args) {
       suite === supervisorSwarmTransientRetrySuite ||
       suite === supervisorSwarmFinalReplyTransientRetrySuite ||
       suite === supervisorSwarmToolPlanHandoffRunnerKillSuite ||
-      suite === supervisorSwarmAutonomousChatSuite ||
-      suite === supervisorAutonomousPlayableLaneDefenseSuite ||
-      suite === supervisorSwarmStaticIsolatedAutonomousChatSuite ||
-      suite === supervisorSwarmCollaborationPolicyMixedRecoverySuite ||
       suite === steerRunnerKillSuite ||
       processSessionSuites.has(suite),
     'unsupported-suite',

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/process.mjs

@@ -2,7 +2,6 @@ import {
   assert,
   codedError,
   hashValue,
-  sleep,
   throwIfShutdownRequested,
 } from '../assertions/core.mjs';
 import { fs, path, spawn, withLoopbackNoProxy } from '../dependencies.mjs';
@@ -13,14 +12,9 @@ import {
   manifestPath,
   state,
 } from '../runtime-state.mjs';
-import {
-  isSupervisorSwarmTransientRetrySuite,
-  recordSupervisorSwarmChatSessionFailureDiagnostic,
-} from '../suites/supervisor-swarm.mjs';
+import { isSupervisorSwarmTransientRetrySuite } from '../suites/supervisor-swarm.mjs';
 import { isIsolatedRunnerSuite } from './reporting.mjs';
 
-export const activeInteractiveCliSessions = new Set();
-
 export async function prepareCliBinary() {
   const cargo = process.platform === 'win32' ? 'cargo.exe' : 'cargo';
   await runProcess(
@@ -84,8 +78,8 @@ export function buildCliChildEnvironment() {
     NO_COLOR: '1',
     RUST_BACKTRACE: '0',
   };
-  // The deterministic playable suite copies its account fixture into the
-  // sibling isolated AppData directory.  Set the path explicitly here so
+  // The isolated runner copies its account fixture into the sibling isolated
+  // AppData directory.  Set the path explicitly here so
   // every CLI and the Runner it launches use the isolated copy, even if the
   // parent harness environment was restored or changed after setup.
   if (state.isolatedRunner.platformSessionFixturePath) {
@@ -144,197 +138,6 @@ export function codedProcessError(code, details) {
   return error;
 }
 
-export function startInteractiveCli(args) {
-  assert(Boolean(state.cliBinary), 'interactive-cli-binary-not-ready');
-  assert(Boolean(state.runtimeConfigDir), 'interactive-config-dir-not-ready');
-  if (
-    isIsolatedRunnerSuite() &&
-    state.options?.configDir &&
-    path.resolve(state.runtimeConfigDir) ===
-      path.resolve(state.options.configDir)
-  ) {
-    state.isolatedRunner.sourceConfigCliCallCount += 1;
-  }
-  const child = spawn(
-    state.cliBinary,
-    [...args, '--config-dir', state.runtimeConfigDir],
-    {
-      cwd: appRoot,
-      env: buildCliChildEnvironment(),
-      stdio: ['pipe', 'pipe', 'pipe'],
-    },
-  );
-  return createInteractiveCliSession(child);
-}
-
-export function createInteractiveCliSession(child) {
-  activeCommandChildren.add(child);
-  const session = {
-    child,
-    stdout: Buffer.alloc(0),
-    stderr: Buffer.alloc(0),
-    exited: false,
-    exitInfo: null,
-    exitPromise: null,
-    closed: false,
-    closeInfo: null,
-    closePromise: null,
-    stdioClosed: false,
-    stdioCloseInfo: null,
-    spawnError: null,
-    stdinError: null,
-  };
-  activeInteractiveCliSessions.add(session);
-  session.exitPromise = new Promise((resolve) => {
-    const settle = (result) => {
-      if (session.exited) return;
-      activeCommandChildren.delete(child);
-      session.exited = true;
-      session.closed = true;
-      session.exitInfo = result;
-      session.closeInfo = result;
-      resolve(result);
-    };
-    child.once('error', (error) => {
-      session.spawnError = error;
-      settle({ code: null, signal: null, error });
-    });
-    child.once('exit', (code, signal) => {
-      settle({ code, signal, error: null });
-    });
-  });
-  session.closePromise = new Promise((resolve) => {
-    child.once('close', (code, signal) => {
-      activeCommandChildren.delete(child);
-      activeInteractiveCliSessions.delete(session);
-      session.stdioClosed = true;
-      session.stdioCloseInfo = {
-        code,
-        signal,
-        error: session.spawnError,
-      };
-      resolve(session.stdioCloseInfo);
-    });
-  });
-  child.stdin?.on('error', (error) => {
-    session.stdinError ??= error;
-  });
-  child.stdout.on('data', (chunk) => {
-    state.transcriptScanner?.scan('interactive-stdout', chunk);
-    state.projectPathTranscriptScanner?.scan('interactive-stdout', chunk);
-    state.formalConfigPathTranscriptScanner?.scan('interactive-stdout', chunk);
-    session.stdout = appendBounded(session.stdout, chunk, commandOutputLimit);
-  });
-  child.stderr.on('data', (chunk) => {
-    state.transcriptScanner?.scan('interactive-stderr', chunk);
-    state.projectPathTranscriptScanner?.scan('interactive-stderr', chunk);
-    state.formalConfigPathTranscriptScanner?.scan('interactive-stderr', chunk);
-    session.stderr = appendBounded(session.stderr, chunk, commandOutputLimit);
-  });
-  return session;
-}
-
-export function interactiveCliOutput(session) {
-  return `${session.stdout.toString('utf8')}\n${session.stderr.toString('utf8')}`;
-}
-
-export function writeInteractiveCliLine(session, line) {
-  assert(!session.closed, 'interactive-cli-already-closed');
-  assert(session.child.stdin.writable, 'interactive-cli-stdin-not-writable');
-  session.child.stdin.write(`${line}\n`);
-}
-
-export async function waitForInteractiveCliOutput(
-  session,
-  predicate,
-  code,
-  timeoutMs,
-  { allowAfterProcessExit = false } = {},
-) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const output = interactiveCliOutput(session);
-    if (predicate(output)) return output;
-    if (session.exited && !allowAfterProcessExit) {
-      if (session === state.supervisorSwarmCliSession) {
-        recordSupervisorSwarmChatSessionFailureDiagnostic(session);
-      }
-      throw codedError(`${code}-cli-exited`);
-    }
-    if (session.stdioClosed) {
-      if (session === state.supervisorSwarmCliSession) {
-        recordSupervisorSwarmChatSessionFailureDiagnostic(session);
-      }
-      throw codedError(`${code}-cli-stdio-closed`);
-    }
-    await sleep(50);
-  }
-  throw codedError(code);
-}
-
-export async function waitForInteractiveCliExit(session, timeoutMs) {
-  const result = await Promise.race([
-    session.exitPromise,
-    sleep(timeoutMs).then(() => null),
-  ]);
-  if (!result) throw codedError('interactive-cli-exit-timeout');
-  if (result.error) throw codedError('interactive-cli-process-error');
-  assert(
-    result.code === 0 && result.signal === null,
-    'interactive-cli-exit-invalid',
-  );
-  return result;
-}
-
-export async function closeInteractiveCli(session) {
-  if (!session) return null;
-  if (session.exited) return session.exitInfo;
-  if (
-    session.child.stdin.writable &&
-    !session.child.stdin.writableEnded &&
-    !session.child.stdin.destroyed
-  ) {
-    session.child.stdin.write('/quit\n');
-  }
-  let result = await Promise.race([
-    session.exitPromise,
-    sleep(3_000).then(() => null),
-  ]);
-  if (!result && !session.exited) {
-    session.child.kill('SIGTERM');
-    result = await Promise.race([
-      session.exitPromise,
-      sleep(2_000).then(() => null),
-    ]);
-  }
-  if (!result && !session.exited) {
-    session.child.kill('SIGKILL');
-    result = await Promise.race([
-      session.exitPromise,
-      sleep(5_000).then(() => null),
-    ]);
-  }
-  assert(Boolean(result), 'interactive-cli-cleanup-timeout');
-  return result;
-}
-
-export async function waitForInteractiveCliStdioClose(session, timeoutMs) {
-  if (!session || session.stdioClosed) return session?.stdioCloseInfo ?? null;
-  const result = await Promise.race([
-    session.closePromise,
-    sleep(timeoutMs).then(() => null),
-  ]);
-  if (!result) throw codedError('interactive-cli-stdio-close-timeout');
-  return result;
-}
-
-export function destroyInteractiveCliOutputStreams(session) {
-  if (!session) return;
-  for (const stream of [session.child.stdout, session.child.stderr]) {
-    if (stream && !stream.destroyed) stream.destroy();
-  }
-}
-
 export async function runProcess(
   program,
   args,
@@ -406,214 +209,6 @@ export async function runProcess(
   });
 }
 
-export async function listSystemProcessIdentities() {
-  if (process.platform === 'win32') {
-    const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
-    assert(
-      typeof systemRoot === 'string' && path.isAbsolute(systemRoot),
-      'owned-process-snapshot-system-root-invalid',
-    );
-    const powershell = path.join(
-      systemRoot,
-      'System32/WindowsPowerShell/v1.0/powershell.exe',
-    );
-    const metadata = await fs.lstat(powershell);
-    assert(
-      metadata.isFile() && !metadata.isSymbolicLink(),
-      'owned-process-snapshot-powershell-invalid',
-    );
-    const result = await runProcess(
-      powershell,
-      [
-        '-NoProfile',
-        '-NonInteractive',
-        '-Command',
-        '$processes = @(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CreationDate,Name); $processes | ConvertTo-Json -Compress',
-      ],
-      {
-        cwd: appRoot,
-        timeoutMs: 30_000,
-        env: { ...process.env, NO_COLOR: '1', RUST_BACKTRACE: '0' },
-      },
-    );
-    const parsed = JSON.parse(result.stdout);
-    return (Array.isArray(parsed) ? parsed : [parsed])
-      .map((record) => ({
-        pid: Number(record?.ProcessId),
-        parentPid: Number(record?.ParentProcessId),
-        startedAt: String(record?.CreationDate ?? ''),
-        name: String(record?.Name ?? ''),
-      }))
-      .filter(validSystemProcessIdentity);
-  }
-  assert(
-    process.platform === 'linux' || process.platform === 'darwin',
-    'owned-process-snapshot-platform-unsupported',
-  );
-  const result = await runProcess(
-    'ps',
-    ['-A', '-o', 'pid=', '-o', 'ppid=', '-o', 'lstart=', '-o', 'comm='],
-    { cwd: appRoot, timeoutMs: 30_000 },
-  );
-  return result.stdout
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const fields = line.split(/\s+/u);
-      return {
-        pid: Number(fields[0]),
-        parentPid: Number(fields[1]),
-        startedAt: fields.slice(2, 7).join(' '),
-        name: fields.slice(7).join(' '),
-      };
-    })
-    .filter(validSystemProcessIdentity);
-}
-
-function validSystemProcessIdentity(record) {
-  return (
-    Number.isSafeInteger(record?.pid) &&
-    record.pid > 0 &&
-    Number.isSafeInteger(record.parentPid) &&
-    record.parentPid >= 0 &&
-    typeof record.startedAt === 'string' &&
-    record.startedAt.length > 0 &&
-    typeof record.name === 'string' &&
-    record.name.length > 0
-  );
-}
-
-export function buildOwnedProcessCleanupSnapshot(
-  processRecords,
-  { rootPids = [], runnerPid = null, helperPids = [] } = {},
-) {
-  assert(
-    Array.isArray(processRecords) &&
-      Array.isArray(rootPids) &&
-      Array.isArray(helperPids),
-    'owned-process-snapshot-input-invalid',
-  );
-  const records = processRecords.filter(validSystemProcessIdentity);
-  const byPid = new Map(records.map((record) => [record.pid, record]));
-  const childrenByParent = new Map();
-  for (const record of records) {
-    const children = childrenByParent.get(record.parentPid) ?? [];
-    children.push(record.pid);
-    childrenByParent.set(record.parentPid, children);
-  }
-  const normalizedRunnerPid = Number.isSafeInteger(runnerPid)
-    ? runnerPid
-    : null;
-  const helperPidSet = new Set(
-    helperPids.filter((pid) => Number.isSafeInteger(pid) && pid > 0),
-  );
-  const roots = [
-    ...new Set(
-      [...rootPids, normalizedRunnerPid, ...helperPidSet].filter(
-        (pid) => Number.isSafeInteger(pid) && pid > 0,
-      ),
-    ),
-  ];
-  assert(roots.length > 0, 'owned-process-snapshot-root-missing');
-  const ownedPids = new Set();
-  const queue = [...roots];
-  while (queue.length > 0) {
-    const pid = queue.shift();
-    if (ownedPids.has(pid)) continue;
-    ownedPids.add(pid);
-    queue.push(...(childrenByParent.get(pid) ?? []));
-  }
-  const identities = [...ownedPids]
-    .map((pid) => byPid.get(pid))
-    .filter(Boolean)
-    .map((record) => ({
-      pid: record.pid,
-      startedAt: record.startedAt,
-      name: record.name,
-      kind: ownedProcessKind(record, normalizedRunnerPid, helperPidSet),
-    }))
-    .sort((left, right) => left.pid - right.pid);
-  return {
-    identities,
-    observedCounts: countOwnedProcessKinds(identities),
-  };
-}
-
-function ownedProcessKind(record, runnerPid, helperPids) {
-  if (record.pid === runnerPid) return 'runner';
-  if (helperPids.has(record.pid)) return 'helper';
-  const name = path.basename(record.name).toLowerCase();
-  if (/^node(?:\.exe)?$/u.test(name)) return 'node';
-  if (/^(?:chrome|chromium|msedge|google-chrome)(?:\.exe)?$/u.test(name)) {
-    return 'browser';
-  }
-  return 'command';
-}
-
-function countOwnedProcessKinds(identities) {
-  const counts = {
-    runner: 0,
-    helper: 0,
-    node: 0,
-    browser: 0,
-    command: 0,
-    total: identities.length,
-  };
-  for (const identity of identities) counts[identity.kind] += 1;
-  return counts;
-}
-
-export function inspectOwnedProcessCleanupResiduals(
-  snapshot,
-  processRecords,
-  { activeCommandChildCount = 0, activeInteractiveCliSessionCount = 0 } = {},
-) {
-  assert(
-    Array.isArray(snapshot?.identities) && Array.isArray(processRecords),
-    'owned-process-residual-input-invalid',
-  );
-  const currentByPid = new Map(
-    processRecords
-      .filter(validSystemProcessIdentity)
-      .map((record) => [record.pid, record]),
-  );
-  const residualIdentities = snapshot.identities.filter((identity) => {
-    const current = currentByPid.get(identity.pid);
-    return (
-      current?.startedAt === identity.startedAt &&
-      current?.name === identity.name
-    );
-  });
-  return {
-    residualCounts: countOwnedProcessKinds(residualIdentities),
-    activeCommandChildCount,
-    activeInteractiveCliSessionCount,
-    clean:
-      residualIdentities.length === 0 &&
-      activeCommandChildCount === 0 &&
-      activeInteractiveCliSessionCount === 0,
-  };
-}
-
-export async function captureOwnedProcessCleanupSnapshot(options) {
-  return buildOwnedProcessCleanupSnapshot(
-    await listSystemProcessIdentities(),
-    options,
-  );
-}
-
-export async function verifyOwnedProcessCleanupSnapshot(snapshot) {
-  return inspectOwnedProcessCleanupResiduals(
-    snapshot,
-    await listSystemProcessIdentities(),
-    {
-      activeCommandChildCount: activeCommandChildren.size,
-      activeInteractiveCliSessionCount: activeInteractiveCliSessions.size,
-    },
-  );
-}
-
 export function appendBounded(current, chunk, limit) {
   const combined = Buffer.concat([current, chunk]);
   return combined.length <= limit

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/project.mjs

@@ -28,12 +28,10 @@ import {
   isGoalRuntimeSuite,
 } from '../suites/goal.mjs';
 import { isResponseStreamSuite } from '../suites/response-stream.mjs';
-import { isSupervisorAutonomousPlayableLaneDefenseSuite } from '../suites/supervisor-autonomous-playable.mjs';
 import {
   isSupervisorSwarmSuite,
   supervisorSwarmVerificationFixtureSource,
 } from '../suites/supervisor-swarm.mjs';
-import { isUserInputRuntimeSuite } from '../suites/user-input.mjs';
 import { isWebSearchSuite } from '../suites/web-search.mjs';
 import { createSentinelOwnedTempDirectory } from './app-data.mjs';
 import { effectiveAgentLlmConfig } from './config.mjs';
@@ -41,19 +39,15 @@ import { runProcess } from './process.mjs';
 import { isIsolatedRunnerSuite } from './reporting.mjs';
 
 export function requiredAgentIdsForSuite() {
-  return isUserInputRuntimeSuite()
-    ? [projectSupervisorAgentId]
-    : isSupervisorAutonomousPlayableLaneDefenseSuite()
-      ? [projectSupervisorAgentId]
-      : isSupervisorSwarmSuite()
-        ? [
-            projectSupervisorAgentId,
-            supervisorSwarmDesignAgentId,
-            supervisorSwarmQualityAgentId,
-          ]
-        : isIsolatedRunnerSuite()
-          ? [mainAgentId]
-          : [mainAgentId, 'quality-review'];
+  return isSupervisorSwarmSuite()
+    ? [
+        projectSupervisorAgentId,
+        supervisorSwarmDesignAgentId,
+        supervisorSwarmQualityAgentId,
+      ]
+    : isIsolatedRunnerSuite()
+      ? [mainAgentId]
+      : [mainAgentId, 'quality-review'];
 }
 
 export function expectedProviderBindingForSuite(config) {
@@ -120,11 +114,9 @@ export async function checkPrerequisites(config) {
   return {
     llmConfigured,
     providerBinding,
-    chromeAvailable:
-      !isIsolatedRunnerSuite() ||
-      isSupervisorAutonomousPlayableLaneDefenseSuite()
-        ? Boolean(await findSupportedBrowser())
-        : false,
+    chromeAvailable: !isIsolatedRunnerSuite()
+      ? Boolean(await findSupportedBrowser())
+      : false,
     editorApiConfigured,
   };
 }
@@ -267,8 +259,7 @@ export async function seedDisposableProject({
             ? supervisorSwarmVerificationFixtureSource()
             : isGoalRuntimeSuite() ||
                 isResponseStreamSuite() ||
-                isWebSearchSuite() ||
-                isSupervisorAutonomousPlayableLaneDefenseSuite()
+                isWebSearchSuite()
               ? goalRevisionOneVerificationFixtureSource()
               : goalRevisionTwoVerificationFixtureSource(),
         ),
@@ -405,23 +396,6 @@ export function seededGameHtml() {
 `;
 }
 
-export function productionDefaultGameIndexHtml() {
-  return `<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Genarrative Game Draft</title>
-    <style>
-      body { margin: 0; display: grid; min-height: 100vh; place-items: center; background: #101827; color: #d9e7ff; font: 16px system-ui, sans-serif; }
-      main { width: min(720px, calc(100vw - 32px)); }
-    </style>
-  </head>
-  <body><main>还没有生成游戏。回到聊天输入创意并确认生成后，这里会写入可试玩原型。</main></body>
-</html>
-`;
-}
-
 export function buildTaskPrompt(suite) {
   const editorAssetOutcome =
     suite === 'full'

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/reporting.mjs

@@ -20,9 +20,7 @@ import { isProjectSkillSuite } from '../suites/project-skill.mjs';
 import { isResponseStreamSuite } from '../suites/response-stream.mjs';
 import { isScopedAgentsSuite } from '../suites/scoped-agents.mjs';
 import { isSteerRunnerKillSuite } from '../suites/steer-runner-kill.mjs';
-import { isSupervisorAutonomousPlayableLaneDefenseSuite } from '../suites/supervisor-autonomous-playable.mjs';
 import { isSupervisorSwarmSuite } from '../suites/supervisor-swarm.mjs';
-import { isUserInputRuntimeSuite } from '../suites/user-input.mjs';
 import { isWebSearchSuite } from '../suites/web-search.mjs';
 import { isPathInside, readJson } from './io.mjs';
 
@@ -88,17 +86,12 @@ export function buildSummary() {
     config: state.config,
     blocked: state.blocked,
     run: {
-      agentId:
-        isUserInputRuntimeSuite() ||
-        isSupervisorAutonomousPlayableLaneDefenseSuite() ||
-        isSupervisorSwarmSuite()
-          ? projectSupervisorAgentId
-          : mainAgentId,
+      agentId: isSupervisorSwarmSuite()
+        ? projectSupervisorAgentId
+        : mainAgentId,
       runIdHash: hashValue(state.initialRunId),
       sessionIdHash: hashValue(state.initialSessionId),
-      runnerKilled: isSupervisorAutonomousPlayableLaneDefenseSuite()
-        ? false
-        : state.runnerKilled,
+      runnerKilled: state.runnerKilled,
       resumed: state.resumed,
       identityStable: state.identityStable,
     },
@@ -110,11 +103,9 @@ export function buildSummary() {
       projectPathReportLeakCount: state.projectPathReportLeakCount,
       ...(isWebSearchSuite() ||
       isContextCompactionSuite() ||
-      isUserInputRuntimeSuite() ||
       isScopedAgentsSuite() ||
       isProjectSkillSuite() ||
       isParallelReadSuite() ||
-      isSupervisorAutonomousPlayableLaneDefenseSuite() ||
       isSupervisorSwarmSuite() ||
       isSteerRunnerKillSuite()
         ? {
@@ -408,11 +399,9 @@ export function isIsolatedRunnerSuite() {
     isResponseStreamSuite() ||
     isWebSearchSuite() ||
     isContextCompactionSuite() ||
-    isUserInputRuntimeSuite() ||
     isScopedAgentsSuite() ||
     isProjectSkillSuite() ||
     isParallelReadSuite() ||
-    isSupervisorAutonomousPlayableLaneDefenseSuite() ||
     isSupervisorSwarmSuite()
   );
 }

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/runtime.mjs

@@ -87,11 +87,7 @@ import {
 import { isProjectSkillSuite } from '../suites/project-skill.mjs';
 import { isScopedAgentsSuite } from '../suites/scoped-agents.mjs';
 import { isSteerRunnerKillSuite } from '../suites/steer-runner-kill.mjs';
-import {
-  confirmSupervisorSwarmPendingActionsInChat,
-  isSupervisorSwarmInteractiveChatSuite,
-  isSupervisorSwarmSuite,
-} from '../suites/supervisor-swarm.mjs';
+import { isSupervisorSwarmSuite } from '../suites/supervisor-swarm.mjs';
 import { killRunnerPidOnce, verifyOwnedRunnerForKill } from './app-data.mjs';
 import { isPlainObject } from './config.mjs';
 import {
@@ -1038,13 +1034,6 @@ export async function confirmPendingActions(
   allowedTools = null,
   shouldConfirm = () => true,
 ) {
-  if (isSupervisorSwarmInteractiveChatSuite()) {
-    await confirmSupervisorSwarmPendingActionsInChat(
-      allowedTools,
-      shouldConfirm,
-    );
-    return;
-  }
   for (const pending of await findPendingActions()) {
     if (state.confirmedActionIds.has(pending.actionId)) continue;
     if (!shouldConfirm(pending)) continue;

apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/runtime-state.mjs

@@ -43,12 +43,6 @@ export const contextCompactionAppDataSentinelFileName =
 export const contextCompactionAppDataSentinelSchema =
   'genarrative-agent-runtime-real-e2e-context-compaction-appdata.v1';
 
-export const userInputAppDataSentinelFileName =
-  '.agent-runtime-real-e2e-user-input-appdata.json';
-
-export const userInputAppDataSentinelSchema =
-  'genarrative-agent-runtime-real-e2e-user-input-appdata.v1';
-
 export const scopedAgentsAppDataSentinelFileName =
   '.agent-runtime-real-e2e-scoped-agents-appdata.json';
 
@@ -109,30 +103,6 @@ export const supervisorSwarmToolPlanHandoffCheckpointReachedFileName =
 export const supervisorSwarmToolPlanHandoffCheckpointReachedSchema =
   'game-creator-tool-plan-handoff-runner-kill-checkpoint-reached.v1';
 
-export const supervisorSwarmAutonomousChatAppDataSentinelFileName =
-  '.agent-runtime-real-e2e-supervisor-swarm-autonomous-chat-appdata.json';
-
-export const supervisorSwarmAutonomousChatAppDataSentinelSchema =
-  'genarrative-agent-runtime-real-e2e-supervisor-swarm-autonomous-chat-appdata.v1';
-
-export const supervisorAutonomousPlayableAppDataSentinelFileName =
-  '.agent-runtime-real-e2e-supervisor-autonomous-playable-appdata.json';
-
-export const supervisorAutonomousPlayableAppDataSentinelSchema =
-  'genarrative-agent-runtime-real-e2e-supervisor-autonomous-playable-appdata.v1';
-
-export const supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelFileName =
-  '.agent-runtime-real-e2e-supervisor-swarm-static-isolated-autonomous-chat-appdata.json';
-
-export const supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelSchema =
-  'genarrative-agent-runtime-real-e2e-supervisor-swarm-static-isolated-autonomous-chat-appdata.v1';
-
-export const supervisorSwarmCollaborationPolicyAppDataSentinelFileName =
-  '.agent-runtime-real-e2e-supervisor-swarm-collaboration-policy-appdata.json';
-
-export const supervisorSwarmCollaborationPolicyAppDataSentinelSchema =
-  'genarrative-agent-runtime-real-e2e-supervisor-swarm-collaboration-policy-appdata.v1';
-
 export const mainAgentId = 'code-prototype';
 
 export const projectSupervisorAgentId = 'project-supervisor';
@@ -179,8 +149,6 @@ export const webSearchSuite = 'web-search';
 
 export const contextCompactionSuite = 'context-compaction';
 
-export const userInputRuntimeSuite = 'user-input-runtime';
-
 export const scopedAgentsSuite = 'scoped-agents';
 
 export const projectSkillSuite = 'project-skill';
@@ -213,18 +181,6 @@ export const supervisorSwarmTransientRetryBackoffMs = 30_000;
 
 export const supervisorSwarmTransientRetryPreDueGuardMs = 1_500;
 
-export const supervisorSwarmAutonomousChatSuite =
-  'supervisor-swarm-autonomous-chat';
-
-export const supervisorAutonomousPlayableLaneDefenseSuite =
-  'supervisor-autonomous-playable-lane-defense';
-
-export const supervisorSwarmStaticIsolatedAutonomousChatSuite =
-  'supervisor-swarm-static-isolated-autonomous-chat';
-
-export const supervisorSwarmCollaborationPolicyMixedRecoverySuite =
-  'supervisor-swarm-collaboration-policy-mixed-recovery';
-
 export const runtimeContextBundleSchemaVersion =
   'game-creator-runtime-context-bundle.v5';
 
@@ -234,17 +190,6 @@ export const providerRequestLifecycleSchemaVersion =
 export const providerActionBatchSchemaVersion =
   'game-creator-provider-action-batch.v2';
 
-export const runProfileBindingSchemaVersion =
-  'game-creator-run-profile-binding.v1';
-
-export const autonomousCompletionContractSchemaVersion =
-  'game-creator-autonomous-completion-contract.v2';
-
-export const autonomousPlaytestReceiptSchemaVersion =
-  'game-creator-autonomous-playtest-receipt.v2';
-
-export const autonomousGameBuildRunProfile = 'autonomous-game-build';
-
 export const supervisorCollaborationPolicySchemaVersion =
   'game-creator-supervisor-collaboration-policy.v1';
 
@@ -287,12 +232,6 @@ export const contextCompactionTriggerTurns = new Set([4, 8]);
 
 export const contextCompactionConstraintCanary = `GENARRATIVE_CONTEXT_CONSTRAINT_${randomUUID().replaceAll('-', '').slice(0, 20)}`;
 
-export const userInputAnswerCanary = `GENARRATIVE_USER_CHOICE_${randomUUID()
-  .replaceAll('-', '')
-  .slice(0, 20)}`;
-
-export const userInputAnswerText = `选择轻量像素风，优先保证移动端轮廓和动作可读性；确认标记 ${userInputAnswerCanary}`;
-
 export const scopedAgentsRootCanary = `GENARRATIVE_SCOPE_ROOT_${randomUUID()
   .replaceAll('-', '')
   .slice(0, 20)}`;
@@ -461,143 +400,6 @@ export const supervisorSwarmConfirmedTools = [
   'project.verify',
 ];
 
-export const supervisorSwarmAutonomousTask =
-  '请把这个试玩项目推进到可以交给首批玩家体验的状态。以仓库现有的正式交付要求、临时检查要求和实际验证结果为准；按阶段生效的临时检查必须在各自生效后全部完成，不能把后续检查并入前置检查或漏掉。完成后简短说明交付内容、验证结论和仍需关注的问题。';
-
-export const supervisorAutonomousPlayableLaneDefenseTask =
-  '做一个植物大战僵尸式的塔防游戏，要能选择植物、阻挡敌人、正常闯关，并且生成后可以直接试玩。';
-
-export const supervisorAutonomousPlayableSourceFieldMaxChars = 8_000;
-
-export const supervisorAutonomousPlayableSourceTotalMaxChars = 10_000;
-
-export const supervisorAutonomousPlayableSafeStatuses = new Set([
-  'cancelling',
-  'budget-exhausted',
-  'cancelled',
-  'completed',
-  'failed',
-  'idle',
-  'needs-reconciliation',
-  'paused',
-  'pausing',
-  'pending',
-  'running',
-  'waiting-for-confirmation',
-  'waiting-for-user-input',
-]);
-
-export const supervisorAutonomousPlayableSafePhases = new Set([
-  'action',
-  'budget-exhausted',
-  'cancelled',
-  'cancelling',
-  'completion-contract-failed',
-  'completed',
-  'conversation-write-failed',
-  'executing',
-  'failed',
-  'finalizing',
-  'idle',
-  'needs-reconciliation',
-  'observation',
-  'parent-terminal',
-  'paused',
-  'pausing',
-  'planning',
-  'provider-action-batch',
-  'queued',
-  'response',
-  'running',
-  'waiting-for-agent',
-  'waiting-for-confirmation',
-  'waiting-for-delegate-receipts',
-  'waiting-for-isolated-join',
-  'waiting-for-process-session',
-  'waiting-for-provider-retry',
-  'waiting-for-user-input',
-]);
-
-export const supervisorAutonomousPlayableSafeDeliveryStatuses = new Set([
-  'claimed-by-parent',
-  'dispatched',
-  'ready',
-  'suppressed',
-]);
-
-export const supervisorAutonomousPlayableSafeTerminalStatuses = new Set([
-  'budget-exhausted',
-  'cancelled',
-  'completed',
-  'failed',
-]);
-
-export const supervisorAutonomousPlayableSafeTurnOutcomes = new Set([
-  'failed',
-  'incomplete',
-  'needs-reconciliation',
-  'settled',
-]);
-
-export const laneDefensePlaytestRequiredAssertions = [
-  'state-surface-valid',
-  'level-positive',
-  'start-control-clicked',
-  'start-sequence-advanced',
-  'start-phase-playing',
-  'defender-option-control-clicked',
-  'defender-selection-sequence-advanced',
-  'defender-selection-recorded',
-  'lane-cell-control-clicked',
-  'defender-placement-sequence-advanced',
-  'defender-count-increased',
-  'enemies-present-after-placement',
-  'speed-up-control-clicked',
-  'battle-sequence-advanced',
-  'battle-sequence-monotonic',
-  'enemy-position-changed',
-  'enemy-health-decreased',
-  'phase-won',
-  'next-level-control-clicked',
-  'next-level-sequence-advanced',
-  'level-increased',
-  'restart-control-clicked',
-  'restart-sequence-advanced',
-  'restart-phase-ready-or-playing',
-];
-
-export const supervisorSwarmAutonomousRoutingTerms = [
-  supervisorSwarmDesignAgentId,
-  supervisorSwarmQualityAgentId,
-  'agent.delegate',
-  'agent.run_status',
-  '同一个 planning 轮次',
-  '同轮',
-  '并行',
-  '返工',
-  'repair',
-  '一次',
-  '两个 Agent',
-  '两个专业',
-  'Runner',
-  'pidfd',
-  'actionId',
-  'delegationId',
-];
-
-export const supervisorSwarmCollaborationPolicyControlTerms = [
-  '.agent/collaboration-policy.json',
-  supervisorCollaborationPolicySchemaVersion,
-  'requiredInitialWave',
-  'minStaticDelegates',
-  'requiredStaticAgentIds',
-  'minIsolatedChildren',
-  'minIsolatedGroupsBeforeClaim',
-  'orchestratorOnlyAfterDelegation',
-  'policyFingerprint',
-  'contractFingerprint',
-];
-
 export const supervisorSwarmIsolatedReviews = [
   {
     path: 'e2e/isolated-a/evidence.txt',
@@ -625,17 +427,6 @@ export const supervisorSwarmIsolatedReviews = [
   },
 ];
 
-export const supervisorSwarmIsolatedReviewGroups = [
-  supervisorSwarmIsolatedReviews.slice(0, 2),
-  supervisorSwarmIsolatedReviews.slice(2),
-];
-
-export const supervisorSwarmInitialIsolatedReviews =
-  supervisorSwarmIsolatedReviewGroups[0];
-
-export const supervisorSwarmFollowupIsolatedReviews =
-  supervisorSwarmIsolatedReviewGroups[1];
-
 export const webSearchBaselineApiUrl =
   'https://api.github.com/repos/nodejs/node/releases/latest';
 
@@ -703,8 +494,6 @@ export const pollIntervalMs = 750;
 
 export const runTimeoutMs = 30 * 60 * 1000;
 
-export const supervisorAutonomousPlayableRunTimeoutMs = 60 * 60 * 1000;
-
 export const supervisorSwarmTerminalSidecarCleanupTimeoutMs = 10_000;
 
 export const processRunnerKillStartTimeoutMs = 5 * 60 * 1000;
@@ -938,10 +727,6 @@ export class BlockedError extends Error {
 
 export const isolatedRunnerState = {
   appDataDir: null,
-  platformSessionFixturePath: null,
-  platformSessionFixtureSourcePath: null,
-  platformSessionFixtureSha256: null,
-  platformSessionFixturePreviousEnv: undefined,
   ownerToken: null,
   createdAt: 0,
   current: null,
@@ -968,9 +753,6 @@ export const state = {
   linuxPidfdPythonPath: null,
   windowsProcessHandlePowerShellPath: null,
   cleanupInProgress: false,
-  userInputCliSession: null,
-  supervisorSwarmCliSession: null,
-  supervisorAutonomousPlayableCliSession: null,
   status: 'FAIL',
   suite: null,
   options: null,
@@ -1082,23 +864,6 @@ export const state = {
     finalReplyFingerprint: null,
     reportLeakCount: 0,
   },
-  userInput: {
-    requestId: null,
-    responseId: null,
-    actionId: null,
-    questionMessageId: null,
-    answerMessageId: null,
-    questionCount: 0,
-    optionCount: 0,
-    providerStartedBeforeKill: 0,
-    providerStartedAfterRestart: 0,
-    conversationCountBeforeKill: 0,
-    conversationCountAfterRestart: 0,
-    oldRunnerBootId: null,
-    newRunnerBootId: null,
-    privateValues: [],
-    reportLeakCount: 0,
-  },
   scopedAgents: {
     effectiveModel: null,
     effectiveApiKind: null,
@@ -1120,20 +885,6 @@ export const state = {
     privateValues: [],
     reportLeakCount: 0,
   },
-  supervisorAutonomousPlayable: {
-    freshInitBaselineUsed: false,
-    initialGameIndexSha256: null,
-    expectedProviderBinding: null,
-    effectiveProviderBinding: null,
-    stdinWriteCount: 0,
-    stdinEnded: false,
-    stdinBytes: 0,
-    turnReport: null,
-    cliOutput: '',
-    privateValues: [],
-    reportLeakCount: 0,
-    ownedProcessCleanupSnapshot: null,
-  },
   supervisorSwarm: {
     effectiveModel: null,
     effectiveApiKind: null,
@@ -1215,47 +966,7 @@ export const state = {
     toolPlanHandoffLifecycleClosedExactlyOnce: false,
     toolPlanHandoffAuditIdempotent: false,
     toolPlanHandoffRecoveredPlanFingerprintMatched: false,
-    autonomousTaskRecipeFree: false,
-    autonomousRepositoryRecipeFree: false,
-    interactiveCliUsed: false,
-    chatSessionUnexpectedlyClosed: false,
-    chatSessionFailureKind: 'none',
-    chatSessionExitCode: 'none',
-    chatSessionCloseSignal: 'none',
-    chatSessionProcessErrorCode: 'none',
-    chatSessionStderrChars: 0,
-    chatSessionStderrSha256: 'none',
-    turnReport: null,
-    mixedSpawnActionId: null,
-    mixedSpawnRequestHash: null,
-    mixedFollowupSpawnActionId: null,
-    mixedFollowupSpawnRequestHash: null,
-    staticIsolatedProviderRequestIds: [],
-    staticIsolatedProviderOverlapObserved: false,
-    preKillMixedIdentity: null,
     collaborationPolicyWritten: false,
-    collaborationPolicySnapshotInitialRecord: null,
-    collaborationPolicySnapshotInitialBytes: null,
-    collaborationPolicySnapshotInitialBytesSha256: null,
-    collaborationPolicySnapshotInitialIdentityHash: null,
-    collaborationPolicySnapshotBindingInitialRecord: null,
-    collaborationPolicySnapshotBindingInitialBytes: null,
-    collaborationPolicySnapshotBindingInitialBytesSha256: null,
-    chatSessionFailureDiagnostic: null,
-    collaborationPolicyDriftFixtureWritten: false,
-    collaborationPolicyDriftFixturePolicyFingerprint: null,
-    collaborationPolicyDriftedMinIsolatedGroupsBeforeClaim: null,
-    initialBatchRecoveryBoundaryObserved: false,
-    initialBatchRecoveryOldRunnerBootId: null,
-    initialBatchRecoveryNewRunnerBootId: null,
-    initialBatchRecoveryPreKillIdentity: null,
-    initialBatchRecoveryPostRecoveryIdentity: null,
-    initialBatchRecoveryPreKillSideEffects: null,
-    initialBatchRecoveryPostRecoverySideEffects: null,
-    initialBatchRecoveryIdentityStable: false,
-    initialBatchRecoveryConfirmationRestoredCount: 0,
-    initialBatchRecoveryPidfdClaimCount: 0,
-    initialBatchRecoveryPidfdSignalCount: 0,
   },
   confirmedActionIds: new Set(),
   cleanupPerformed: false,