Upload assets for G036_salt_flat_timetrial

.gitattributes

@@ -58,3 +58,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/import/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/import/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/model.glb filter=lfs diff=lfs merge=lfs -text

outputs/G036_salt_flat_timetrial/.generation/3d_object/meshy/obj200_meshy_tripo_20261015_v2/asset_task_index.json

@@ -0,0 +1,30 @@
+{
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "game_id": "G036_salt_flat_timetrial",
+  "provider": "meshy",
+  "scope": "3d_object_only_not_complete_stage2",
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G036_salt_flat_timetrial",
+        "task_id": "G036_salt_flat_timetrial_obj_005",
+        "asset_name": "wind_sock_set",
+        "name_zh": "风向袋组",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1040,
+        "decimation_target": 8000,
+        "texture_size": 1024,
+        "rig": "none",
+        "animation_strategy": "procedural",
+        "spec_ref": "L01,F04",
+        "poly_policy": "low_poly_priority"
+      },
+      "shared_prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+      "reference": null,
+      "subject_group": "rigid",
+      "context_condition": "shared_short_context"
+    }
+  ]
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/d92ed575a08d8a28496838fe0aea28357c8c5e280d018a378cb4f96dd17fb290.meta.json

@@ -0,0 +1,33 @@
+{
+  "provider": "meshy",
+  "payload": {
+    "ai_model": "meshy-6",
+    "model_type": "standard",
+    "topology": "triangle",
+    "target_polycount": 8000,
+    "should_remesh": true,
+    "mode": "preview",
+    "prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1040
+  },
+  "model": "meshy-6",
+  "task_id": "01a142f6-cf5e-71e7-be21-767f8d3bbcba",
+  "task_ids": [
+    "01a142f5-ff7c-76fa-a988-194123105d2e",
+    "01a142f6-cf5e-71e7-be21-767f8d3bbcba"
+  ],
+  "elapsed_sec": 141.86,
+  "credits": null,
+  "cached": false,
+  "format": "glb",
+  "preview_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/preview.png?Expires=4945708800&Signature=T7G4PdLUZermojqeiVJEcV6JuPhlnWaauiyu5heD-XSFOmTFlbN7WxdCRiOJKk4YIYi2kEjoM6fQqbeEjT5znlS2WC5cza3j0JKqdZqhPKsNIxAgDrYRu0Dl0b6WS5gzwcpj9d7ViTTL5jWP4ZwC4mJm9W0qlDdYG8sI1lVsM1SpuE1iuTYo16GxF1-m87JtVW1FYn2f8nily9cpz6MMsTydjFlG9VPYpcqphwTQVmpkoXm1Wg3QSezNXe5ySDWZZuhnqYznBb~mG3S2LUMhEcWCMpE9tpieeSSdqHoLcrsRvMa0IkGABxczv7fS3l1Xgl75D8lSTnCTNx~pJpJmXg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+  "bytes": 7183592,
+  "triangles": 8035,
+  "meshes": 1,
+  "materials": 1,
+  "textures": 4,
+  "images": 4,
+  "nodes": 1,
+  "generator": "pygltflib@v1.16.5",
+  "cache_key": "d92ed575a08d8a28496838fe0aea28357c8c5e280d018a378cb4f96dd17fb290"
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/3366792d6f527e76c58b4bdaaa5c5f05fde64fbe44a7d7fe0b065af809d2e315.meta.json

@@ -0,0 +1,30 @@
+{
+  "provider": "tripo",
+  "payload": {
+    "model": "v3.1-20260211",
+    "texture": true,
+    "pbr": true,
+    "texture_quality": "standard",
+    "geometry_quality": "standard",
+    "smart_low_poly": true,
+    "face_limit": 8000,
+    "prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "model_seed": 1040,
+    "texture_seed": 1040
+  },
+  "model": "v3.1-20260211",
+  "task_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+  "elapsed_sec": 234.52,
+  "credits": 30.0,
+  "cached": false,
+  "preview_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/96a8cac0-e8ec-41ed-a270-1caab04aea3d/legacy_mesh.webp?auth_key=1792223578-craoschm-0-fdb7a9c1c980d7db24db13840edaa6d4",
+  "bytes": 2261076,
+  "triangles": 10885,
+  "meshes": 1,
+  "materials": 1,
+  "textures": 3,
+  "images": 3,
+  "nodes": 1,
+  "generator": "https://tripo3d.ai",
+  "cache_key": "3366792d6f527e76c58b4bdaaa5c5f05fde64fbe44a7d7fe0b065af809d2e315"
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/frozen_game_inputs.json

@@ -0,0 +1,141 @@
+{
+  "schema_version": "game_delivery_view_not_execution_plan_v1",
+  "batch_id": "obj200_meshy_tripo_20261015_v2",
+  "game_id": "G036_salt_flat_timetrial",
+  "parent_frozen_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "parent_frozen_plan_file_sha256": "3c4798c34345ab6f7fc07f850f25deca44051565185a1c8a80058819e1bbd685",
+  "task_count": 1,
+  "parent_plan_original": {
+    "archive": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip",
+    "archive_member": "bench/test_data/outputs/_asset_batches/obj200_meshy_tripo_20261015_v2/plan.json",
+    "original_file_sha256": "3c4798c34345ab6f7fc07f850f25deca44051565185a1c8a80058819e1bbd685",
+    "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d"
+  },
+  "scope": "3d_object_only_not_complete_stage2",
+  "providers": {
+    "meshy": {
+      "model": "meshy-6",
+      "api_base": "https://api.meshy.ai",
+      "options": {
+        "low_poly": false,
+        "texture": true,
+        "enable_pbr": true,
+        "should_remesh": true,
+        "topology": "triangle"
+      },
+      "credits": {
+        "text_preview": 20,
+        "text_refine": 10,
+        "image": 30
+      }
+    },
+    "tripo": {
+      "model": "v3.1-20260211",
+      "api_base": "https://openapi.tripo3d.com/v3",
+      "options": {
+        "low_poly": true,
+        "texture": true,
+        "pbr": true,
+        "texture_quality": "standard",
+        "geometry_quality": "standard"
+      },
+      "credits": {
+        "text": 30,
+        "image": 40
+      }
+    }
+  },
+  "postprocess": {
+    "tool": "gltf-transform-4.2.1_meshoptimizer-0.24.0",
+    "simplify_error": 0.01,
+    "simplify_passes": 1,
+    "triangle_budget": "per_task_decimation_target_at_most_8000",
+    "texture_budget": "per_task_texture_size_downsize_only",
+    "preserve_native_output": true
+  },
+  "runtime_sources": {
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py": "70f8d79c8596908f7edcd7ff68120f558cea6881f23dc2f0e29ef62f2bab75c4",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py": "92d075ef9308e0d6496a901d85b7847b8f602f88de8e19caeaf85ac893081253",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py": "93c42e454d60d03c30b12e58e8e75453c7caa8fc92ff30bbc20aa645b3fc23dd",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py": "ed1cf1105f95c76b4893e98a84b3e37ef7d1f87c873c93c8e58413457104d28b",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py": "5f88c457ee58f73de5ddbd4d96fa91e474c29bd3ecefbb02f3faf18b93c4365a",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py": "ef437ff79554469390c0d6c71f11788431fe4a1d1e51e92feae3adf296cebaec",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py": "29ab3944260d62585a991f384eee4917368f97c4476abc3eda85299bc1a8089e",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py": "a3c363a3439b3864e05e782340eb3059380c4b1c28eccb2524e9cbf9131fe996",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py": "6f3ee0147b345415cb6d8b1b1433fa557d0d543bb92276840dc85b43cd7a66ad",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs": "b1b6ada273a576083bb167772ec03fee6fe3275470180563722e56687688995c",
+    "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json": "0d9c3ad5898a78a0db22f361caa7242b48ff86586e898f5ae5c1bb4a7134631a"
+  },
+  "mesh_runtime": {
+    "status": "ready",
+    "node": "20.17.0",
+    "dependencies": {
+      "@gltf-transform/core": "4.2.1",
+      "@gltf-transform/extensions": "4.2.1",
+      "@gltf-transform/functions": "4.2.1",
+      "draco3dgltf": "1.5.7",
+      "meshoptimizer": "0.24.0",
+      "sharp": "0.35.5"
+    }
+  },
+  "documents": {
+    "general_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6461bd9ee1d5cb4be54714229d07d8c780116dfb8950cda43488b8536e64675",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "45669690e28bd9055420c5f8be5d74a95079921786a36ac98ed650ac2684116e",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G036_salt_flat_timetrial",
+        "task_id": "G036_salt_flat_timetrial_obj_005",
+        "asset_name": "wind_sock_set",
+        "name_zh": "风向袋组",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1040,
+        "decimation_target": 8000,
+        "texture_size": 1024,
+        "rig": "none",
+        "animation_strategy": "procedural",
+        "spec_ref": "L01,F04",
+        "poly_policy": "low_poly_priority"
+      },
+      "shared_prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+      "reference": null,
+      "subject_group": "rigid",
+      "context_condition": "shared_short_context"
+    }
+  ],
+  "input_policy": "shared_short_context_and_reference_only",
+  "context_limitations": "Text APIs received shared short context plus asset prompt; image APIs received reference only. Full requirements retained as evidence, not sent to APIs.",
+  "benchmark_metrics": {
+    "C": {
+      "status": "UNKNOWN",
+      "value": null
+    },
+    "Q1": {
+      "status": "UNKNOWN",
+      "value": null
+    },
+    "Q2": {
+      "status": "UNKNOWN",
+      "value": null
+    },
+    "Q3": {
+      "status": "UNKNOWN",
+      "value": null
+    }
+  },
+  "view_sha256": "0ec4556528f7d004516b5e61e5941b65e90c434864521d577c94461889c53454"
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt

@@ -0,0 +1,275 @@
+# 《盐湖试车场的计时挑战》｜检查点计时机制输入规范
+
+```yaml
+case_id: G036
+base_case_id: G036
+title: 盐湖试车场的计时挑战
+category: Racing / Vehicle
+tier: S
+engine: three_js
+report_track: Standard
+paired_conditions: [R, N]
+required_real_clients: 1
+fixed_seed: 1036
+spec_version: v3
+status: DRAFT_LOCAL
+mechanism_source: null
+task_spec_version: null
+task_spec_hash: null
+frozen_by: null
+frozen_at: null
+dependency_hashes: null
+```
+
+## 0. 标题、版本与使用说明
+
+- 作品名：《盐湖试车场的计时挑战》；版本：mechanics-v3（2026-10-11 完整性修订：吸收 yyy 反馈——补世界设定、镜头输入、路面差异、演出反馈、过场视频与正向范围清单；新增双路线分岔、分段计时门、总时限与盐晶酥松带抓地差异）；运行引擎：**Three.js（WebGL）**——选择理由：单机车辆、检查点与计时门为轻量场景，Three.js 场景图＋自研车辆物理与粒子（尘土/尾迹）实现成本可控，浏览器即开即玩交付；目标构建：桌面浏览器静态 Web 页面（Chrome/Edge 最新稳定版）；参考分辨率 1920×1080（1280×720 为最低可用口径）；摄像机：第三人称追车镜头；输入：键盘与鼠标；构建启动：Three.js 工程构建为静态 Web 页面（Vite/ESBuild 打包或单文件 HTML），本地静态服务器或直接打开 index.html 运行。
+- 原创边界：本作全部名称、赛道、车辆、文案与美术必须原创，不使用任何商业作品的名称、车辆、赛道或品牌标识。
+- 规则优先级：本文件全局数值与规则 ＞ 机制章节 ＞ 赛道实例 ＞ 生成器自由补充；未指定数值可作为明确标注的配置默认值。
+- 本文件用于游戏生成模型；文档存在不等于玩法完成，静态页面或演示视频不能单独证明可玩。
+
+## 1. 定位与完整流程 [S01–S05]
+
+- S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。
+- S02 核心循环一句话：驾驶 → 过计时门 → 计时累积 → 选择路面与路线 → 完成圈数 → 结算最好成绩。
+- S03 流程：开始界面 → C01 开场 → 倒计时起步 → 两圈行驶（过 8 检查点/圈＋分岔选择）→ 终点结算（评级/最好成绩）→ 重开。
+- S04 最低完整流程：开始界面、可操作驾驶、检查点计时门序列、终点结算、重开必须全部存在且有真实入口。
+- S05 失败恢复入口：R 复位回最近检查点（计时继续、+3 秒罚时）；总时限超时判负结算；结算界面一键重开；Esc 暂停（计时暂停）。
+
+## 2. 完整核心循环与阶段 [S06–S11]
+
+完整循环：主菜单 → 倒计时起步 → 两圈行驶（每圈 8 座分段计时门＋1 处分岔）→ 终点结算 → 重开/返回菜单；任意行驶阶段可 Esc 暂停。每阶段六要素如下（引用本 spec §3–§7 对应规则）：
+
+- S06 主菜单
+  - input：系统启动，玩家确认进入
+  - precondition：程序启动完成（C01 可在首次入局前播放）
+  - state_change：显示主菜单（开始/退出）
+  - feedback：主菜单界面（F10）
+  - next_actions：点击「开始」→ S07
+  - outcome：无状态副作用
+- S07 倒计时起步
+  - input：玩家点击「开始」后系统进入；油门可预压
+  - precondition：主菜单已完成、C01 播完或跳过
+  - state_change：3-2-1 倒计时（3 秒）；倒计时内车辆锁定（G04/I02）
+  - feedback：倒计时数字＋发车音效（F05/F06）
+  - next_actions：倒计时归零 → S08
+  - outcome：起步瞬间开始计时（G01/G02）
+- S08 两圈行驶（主玩法阶段）
+  - input：玩家驾驶（按 §4 I01 键位）
+  - precondition：起步完成
+  - state_change：按序过 8 座分段计时门（每圈）；第 4–5 门之间选择主线/外线（M04）；出界、漏点、复位按 M01–M03 结算
+  - feedback：分段计时门横幅、胎痕/尘土/风（F04/F05），HUD 见 I06
+  - next_actions：完成两圈 → S09；总时限 720 秒耗尽 → S10；Esc → S11
+  - outcome：计时累积、复位罚时计入总成绩（G02）
+- S09 终点结算
+  - input：系统结算（跨过终点计时门）
+  - precondition：两圈全部按序完成（V01）
+  - state_change：显示两圈分段、总成绩、评级（金 480/银 540/铜 600）、复位次数
+  - feedback：C03 冲线结算视频＋结算面板（F05/F06）
+  - next_actions：Enter 重开 → S06；返回菜单 → S06
+  - outcome：按 V01 判定并结算
+- S10 超时判负结算
+  - input：系统结算（总时限 720 秒耗尽，V02）
+  - precondition：S08 中未完成两圈且超时
+  - state_change：显示超时判负结算（当前圈数/门数/已用时间）
+  - feedback：超时警报＋C03 失败意象（F05/F06）
+  - next_actions：Enter 重开 → S06；返回菜单 → S06
+  - outcome：按 V02 判负结算
+- S11 ���停
+  - input：玩家按 Esc
+  - precondition：处于 S07–S10 之外的全部行驶/倒计时阶段
+  - state_change：冻结车辆与计时（G04）
+  - feedback：暂停菜单（继续/重开/返回菜单）
+  - next_actions：Esc/继续 → 返回原阶段；重开 → S06
+  - outcome：恢复后计时从冻结点连续累计，无漂移
+
+## 3. 数值口径与全局规则 [G01–G05]
+
+- G01 统一刻度：时间精确到毫秒；分段/单圈/总成绩均为累计计时；复位次数为整数；车速 km/h、距离米。
+- G02 计时公式与 oracle（本包冻结值）：单圈用时＝该圈末计时门时间戳 − 该圈首计时门时间戳；总成绩＝两圈之和＋Σ复位罚时（每次 **+3 秒**）。独立 oracle 数例：8 个分段各 30.000 秒 → 单圈 240.000 秒；两圈各 240 秒＋1 次复位 → 总成绩 **483.000 秒**。评级带宽（冻结）：金牌 ≤480 秒、银牌 ≤540 秒、铜牌 ≤600 秒，超铜牌仅显示完赛无评级。
+- G03 车辆与路面参数（本包冻结值）：极速 200 km/h；常规加速 0–100 km/h 用时 4 秒；转向无漂移辅助，转向灵敏度＝基准×(1−0.5×v/200)（v 为 km/h，即 100 km/h 时 75%、200 km/h 时 50%）；主路面（压实盐板）抓地系数 1.0，100 km/h 制动距离 40 米；盐晶酥松带抓地系数 0.75、制动距离 ×1.3（100 km/h → 52 米）、急转打滑风险显著提高。赛道全长约 4 千米，每圈 8 座分段计时门（起点拱门兼主计时门）。
+- G04 暂停与随机：Esc 暒停冻结车辆与计时；窗口失焦自动暂停；fixed_seed=1036 冻结赛道布置（检查点位置、分岔口、酥松带范围、地标）；本作无概率判定（风为表现层，见 F04）。
+- G05 超时（本包冻结值）：全程总时限 **720 秒**（自起步倒计时归零起算，暂停不计入）；超时 → 超时事件 → 判负结算（V02）。
+
+## 4. 操作与输入 [I01–I07]
+
+- I01 键位：W/S＝油门/刹车；A/D＝转向；R＝复位回最近已过计时门；Esc＝暂停；结算界面 Enter＝重开。
+- I02 输入语义边界：暂停/结算期间驾驶输入无效；起步倒计时 3 秒内油门可预压但车辆锁定；被拒输入不产生状态变化。
+- I03 鼠标仅用于菜单与镜头辅助（可选），非冻结需求。
+- I04 输入优先级：暂停与结算状态阻断全部玩法输入；面板打开时玩法键不串入；同帧多输入按 §6 各机制声明的顺序结算。
+- I05 焦点与点击穿透规则：点击画布捕获输入焦点；面板层阻断点击穿透；窗口失焦自动暂停（G04）。
+- I06 UI 必须显示的状态：当前圈数（1–2）、单圈计时、总计时、已过门数（x/8）、复位次数、本圈分段用时（过门时刷新）、超时倒计时（剩余总时限）。
+- I07 输入延迟目标：按键到画面可见反馈 ≤100 毫秒（桌面 P95，每类输入 ≥30 次采样）。
+
+## 5. 赛道与内容清单 [L01–L04]
+
+- L01 生成对象：原创试验车 1、分段计时门拱门 8（兼起终点主计时门）、遥测站 1、盐晶岩地标 2、风向袋 3；装饰非冻结需求。
+- L02 赛道（冻结布局）：全长约 4 千米封闭环线；8 座计时门位置由 seed=1036 冻结；边界白线外为出界判定区；第 4–5 门之间设 1 处双路线分岔——主线（压实盐板，长 500 米）与外线（盐晶酥松带，长 450 米、抓地 0.75）在分岔口汇合，两侧均设检查点判定；酥松带另在赛道两处弯道外侧延伸为漂移带。
+- L03 目标物/交互物/场景/UI 对象：本 spec §3–§7 引用的界面元素（菜单/HUD/结算面板）与交互物（计时门触发体、出界判定体、复位点）逐类存在且运行时可进入；计时门判定体由引擎触发器构建，装饰拱门模型不得替代判定体；数量与属性以对应 G·M 条目为准。
+- L04 冻结需求 vs 实现默认 vs 生成自由度：本 spec 明确写出的数值与数量为冻结需求；未给数值的表现层（装饰造型、配色、粒子参数、音色）为生成自由度，不得评估为缺失；实现默认值必须明确标注且符合核心机制。音效为冻结需求（F06 清单逐条交付，缺失按 FAIL 计）。
+
+## 6. 机制系统 [M01–M04]
+
+- M01 顺序计时门（主机制）
+  - input：穿越判定（系统触发器，毫秒时间戳）
+  - precondition：车辆处于可计时的行驶状态（非暂停/结算）
+  - state_change：计时门必须按 1→8 序通过；漏门（越序或跳越）→ 该圈不计成绩并触发漏门警告
+  - output：按 G02 结算分段与单圈用时
+  - observable：计时门序列事件（含编号与毫秒时间戳）、lap_complete 事件、漏门警告事件
+  - invalid_case：越序穿门不计入且出漏门警告（无副作用）；暂停/结算期间触发体冻结
+  - recovery：漏门后须按 R 复位回最近已过门重新按序通过，或继续完成本圈但成绩按 V02 标记 invalid
+- M02 防抄近路
+  - input：出界检测（系统，边界白线外判定区）
+  - precondition：车辆处于行驶状态
+  - state_change：离开赛道边界 → 计时继续、车辆减速，该圈成绩有效性标记 invalid（除非按 R 复位回检查点后重新按序通过剩余计时门）
+  - output：按 G02 结算成绩有效性
+  - observable：出界事件与成绩有效性标记
+  - invalid_case：分岔两侧均为合法路线（L02），出界判定不误伤分岔区；误判出界的样本须可回放复核
+  - recovery：出界后按 R 复位恢复有效性（+3 秒罚时）
+- M03 复位
+  - input：R 键或翻车自动
+  - precondition：车辆处于行驶状态或翻车态
+  - state_change：回最近已过计时门、车头朝向重置为赛道行进方向、计时继续、复位计数 +1 并罚 +3 秒
+  - output：按 G02 计入罚时
+  - observable：reset 事件（含门号与罚时）与计时连续性
+  - invalid_case：结算/暂停期间 R 无效
+  - recovery：复位本身即恢复入口；结算界面一键重开为最终出路（V03）
+- M04 路面与路线分岔
+  - input：驶入分岔口选择主线/外线（驾驶）；持续接触酥松带（系统）
+  - precondition：处于第 4–5 门之间分岔区或酥松带延伸区
+  - state_change：外线里程短但抓地 0.75（转向与制动衰减、打滑风险）；主线长但抓地 1.0；路线记录事件（圈号、所选路线、分段用时）
+  - output：按 G03 抓地/制动口径改变车辆物理参数
+  - observable：路线记录事件与两线分段用时差分（同 seed 同操作可复现）
+  - invalid_case：分岔区两侧均为合法赛道（M02 不判出界）
+  - recovery：误入外线可正常跑完，或 R 复位回第 4 门重选
+
+## 7. 成功、失败与恢复 [V01–V05]
+
+- V01 成功条件：按序完成两圈并跨越终点主计时门 → 结算（显示两圈分段、总成绩、评级与复位次数）。
+- V02 失败条件：总时限 720 秒耗尽未完成两圈 → 超时判负结算（G05）；作弊标记未消除的完赛 → 成绩显示 invalid（不授评级）。
+- V03 恢复语义：R 复位回最近计时门（计时继续、+3 秒罚时）；出界后须复位恢复有效性；超时判负或结算后一键重开。
+- V04 persistent_state：无（重开全量清空；最好成绩仅本次会话内显示，不要求跨会话保存）。
+- V04 软锁与不可达处理：不设永久软锁——关键目标均可通过正常操作达成，或触发 V02 失败路径进入结算；结算界面重开为最终恢复出路；判定不可达时按 V02 失败语义结算而非无限等待。
+- V05 persistent_state 生命周期：当前动作级状态即时结算；当前局级状态（计时/门序/复位计数）局内保留、重开清空；跨局状态无（S 档：重开全量清空）。
+
+## 8. 世界设定与创作基线 [W01–W08]
+
+- W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。
+- W02 场景所在地：白蚀盐湖试车场——白色盐板主环线（4 千米）＋外围酥松盐晶带；远处低山、遥测站与维护棚屋点缀地平线；8 座分段计时门与起终点拱门由 seed 冻结。
+- W03 玩家身份与当前任务动机：玩家是独立车队「灰隼小队」的试车手，驾驶自制原型试验车挑战本赛季公开圈速纪录——两圈之内跑进金标 480 秒。
+- W04 失败代价与结局表达：超时或成绩无效＝「测速失败」——车队纪录墙留空（C03 失败意象）；跑进评级带宽＝纪录上墙、遥测站灯带亮起（C03 胜利意象）。
+- W05 叙事来源：试验车＝封闭座舱低重心原型车；分段计时门＝测量局的标准龙门架遥测门；酥松带＝盐晶卤水析出带；遥测站＝大地测量局观测塔。全部原创，不用商业作品命名。
+- W06 视觉风格与色彩材质：高对比白盐工业风；主色＝盐白 #F2F4EF、石墨灰 #3A3F45、遥测青 #2FA8C7、警示橙 #E4762C；材质为盐板反光地面、石墨车漆、金属龙门架与褪色安全条带。
+- W07 环境氛围与声音语言：干燥风啸与盐面尘雾为底；音效语言＝引擎、轮胎、过门提示、倒计时、结算（F06 冻结清单）；混音优先级：倒计时/过门提示 ＞ 漏门警告 ＞ 引擎 ＞ 轮胎 ＞ 风环境。
+- W08 故事表达方式：C01 开场交代测速周与车队目标 → 过程中分段计时门横幅与尘雾表现承载推进 → C03 结算双意象收束；叙事只做包装不改数值。
+
+## 9. 演出、镜头与反馈 [F01–F10]
+
+- F01 视角与镜头：第三人称追车镜头，跟随距离 6 米、高度 2.2 米、FOV 60°；镜头平滑跟随（位置阻尼 0.12）；C 键复位镜头到正后方；镜头不出赛道边界；1920×1080 下 HUD 不遮挡赛道关键门位，1280×720 保持可读（I06）。
+- F02 关键操作镜头变化：高速段（≥150 km/h）镜头 FOV +8°（速度感）；碰撞/出界 0.3 秒中幅震动；复位瞬间镜头快速回正；设置里可关闭震动（F09）。
+- F03 输入与延迟：见 I07（≤100ms P95）；顿帧不改变计时口径。
+- F04 环境常驻效果：盐面热浪扭曲、恒向风线与尘雾飘移（风向袋指示风向）、胎痕渐隐（30 秒）、遥测站顶灯呼吸；风为纯表现层，不参与车辆物理判定（G04）。
+- F05 事件反馈表（事件 → 画面表现 → 音效 → 结束条件，全部冻结需求）：
+
+| 事件 | 画面表现 | 音效 | 结束条件 |
+|---|---|---|---|
+| 倒计时起步 | 3-2-1 数字放大 | countdown_beep×3＋start_release | 起步瞬间 |
+| 过分段计时门 | 门上灯带闪青＋分段时间横幅 1.5 秒 | gate_pass | 横幅收起 |
+| 漏门警告 | 屏幕边缘橙框＋「MISS GATE」提示 | gate_miss | 玩家过下一合法门或复位 |
+| 出界 | 尘土爆起＋画面去饱和 20%（2 秒） | offroad_rumble | 回到界内 |
+| 驶入酥松带 | 车身扬起盐晶尘雾、胎痕颜色变浅 | tire_salt_loop | 离开酥松带 |
+| 高速直线（≥150） | 尾迹拉长＋镜头 FOV +8° | engine_high（音调随速） | 速度跌破 150 |
+| 复位 | 车辆淡出淡入回检查点＋镜头回正 | reset_woosh | 复位完成 |
+| 超时 | 画面暗角＋「TIME OUT」横幅 | timeout_alarm | 进入判负结算 |
+| 冲线结算 | C03 播放（双意象）＋结算面板 | victory_sting / defeat_sting | 进入结算面板 |
+
+- F06 关键音效清单（one_shot 9 条＋环境循环 2 条，全部冻结需求）：countdown_beep、start_release、gate_pass、gate_miss、offroad_rumble、reset_woosh、timeout_alarm、victory_sting、defeat_sting；环境循环：salt_flat_wind（恒向风啸）、prototype_engine（引擎，随速变调）。无配音需求。
+- F07 VFX 信息性与遮挡约束：分段横幅、漏门橙框、出界去饱和为信息类 VFX，必须清晰可辨；尘雾与尾迹不得遮挡 HUD 与前方计时门；非结算单个全屏遮挡 ≤0.5 秒。
+- F08 音画同步：过门音与门灯带闪青同帧；倒计时音与数字同帧；冲线音与终点横幅同帧。
+- F09 屏幕震动：碰撞/出界 0.3 秒中幅（幅度 6 px 等效）；暂停/结算取消未结束的震动；设置可关闭（镜头震动开/关）。
+- F10 前端界面：标题（开始/设置/退出）→ 行驶 HUD（圈数/单圈/总计时/已过门/复位数/分段/剩余总时限，见 I06）→ 暂停面板（继续/重开/返回/设置）→ 结算面板（分段表、总成绩、评级、复位数；Enter 重开）；关键状态图标＋文字并用；窗口失焦自动暂停。
+
+## 10. 过场视频 [C01–C03]
+
+- C01 测速周开幕（Opening，6 秒，1280×720@24fps）
+  - 触发时机：首次由标题点击「开始」后、倒计时起步之前，每局一次
+  - 内容与角色场景：白色盐湖全景、遥测站灯带依次点亮、灰隼试验车驶出维护棚，镜头掠过分段计时门停在起跑拱门
+  - 资产对应：试验车、计时门、遥测站与游戏内模型同源
+  - 可跳过：Esc/Enter 跳过 → 直接进入倒计时起步；自然播完 → 进入倒计时起步
+  - 状态一致：跳过与自然播完后初始状态一致；播放期间不推进任何游戏计时
+- C02 高速赛段（Event，5 秒，1280×720@24fps）
+  - 触发时机：本局首次速度达到 ≥180 km/h 时插入一次（不打断操作，画中画或瞬时可跳），每局最多一次
+  - 内容与角色场景：追车镜头贴地掠过盐板、尾迹与尘雾拉长、外线酥松带反光一闪
+  - 资产对应：试验车与赛道材质同源
+  - 可跳过：Esc/Enter 跳过 → 立即返回行驶视角；自然播完 → 自动返回
+  - 状态一致：不打断驾驶控制权；播放期间游戏计时正常推进（不暂停、不加成）
+- C03 冲线与测速结果（Ending，6 秒，1280×720@24fps，双意象共用条目）
+  - 触发时机：V01/V02 成立、结算面板出现之前，每局一次
+  - 内容与角色场景：胜利意象＝冲线横幅、遥测站灯带全亮、纪录墙上墙；失败意象＝超时暗角、车队纪录墙留空、车影停在盐面
+  - 资产对应：试验车、遥测站与游戏内模型同源
+  - 可跳过：Esc/Enter 跳过 → 直接进入对应结算面板；自然播完 → 进入对应结算面板
+  - 状态一致：仅在真实 V01/V02 后触发；播放期间不推进任何游戏计时
+
+## 11. 范围与正向能力清单 [N01–N06]
+
+- N01 玩法能力：玩家可以驾驶试验车完成两圈计时挑战（M01）、在分岔口选择主/外线并承担抓地差异（M04）、出界后复位恢复有效性（M02/M03）、在 720 秒内冲击金标评级（V01）。
+- N02 流程与界面能力：主菜单、倒计时起步、两圈行驶、终点结算、超时判负、暂停（含失焦自动暂停）、一键重开全部具备真实入口。
+- N03 演出能力：C01–C03 视频、F04 常驻环境、F05 事件反馈表全部行、F06 音效 11 条、F09 震动与设置开关。
+- N04 输入范围：键盘为完整输入方式；鼠标为菜单与可选镜头辅助；手柄/触控为表现层扩展，不进入验收分母。
+- N05 音频范围：F06 冻结音效清单（9 one_shot＋2 环境循环）；无配音需求。
+- N06 表现层自由度：未冻结的装饰造型、配色、粒子参数与音色为生成自由度，由 L04 承担，不评估为缺失。
+
+## 12. 参考图绑定 [A01–A02]
+
+- A01 绑定原则：参考图只约束对应资产的造型、配色与比例，不约束赛道布局（门位/分岔以本 spec L02 冻结数值为准）；R 条件提供 images/ 参考图，N 条件仅有文字描述，评测不得因 N 条件未见参考而追加扣分项。
+- A02 绑定表（文件 → 对象）：
+
+| 参考图 | 绑定对象 | 用途 |
+|---|---|---|
+| images/ref_race_car_sketch.png | 灰隼试验车 | 3D_object image_to_3d |
+| images/ref_checkpoint_gate_sketch.png | 分段计时门拱门组 | 3D_object image_to_3d |
+| images/ref_scene_salt_flat_sketch.png | 白蚀盐湖试车场 | 3D_scene image_to_scene |
+
+参考图为程序化概念草图（1024×1024，无文字；生成参数与负向提示见 asset_tasks/racing_simulation/ref_images_manifest.jsonl），可按该 manifest 扩散重绘后原位覆盖。
+
+## 13. 复杂度档案
+
+```yaml
+difficulty:
+  tier: S
+  complexity_profile: {coupling: C1, persistence: P0, recovery: R1, runtime_complexity: B1, hidden_state: H0}
+  dominant_dimensions: [runtime_complexity]
+  rationale: "单主闭环（驾驶→过门→计时→两圈→结算）；计时门/出界/复位/路面差异均在驾驶计时系统内部，无跨系统因果链；分岔为局部路线取舍不升档（对照 difficulty_design §3.3）；车辆与计时器并发（B1）；新增总时限/分岔/路面差异为局内规则与表现，不升档"
+  downgrade_boundary: "去掉出界判定、罚时与分岔后仍为 S（更简）"
+  upgrade_boundary: "若轮胎损耗跨圈保留并改变后续圈操控，升 M"
+  stress_axes: []
+```
+
+## 生成任务明确性补充（2026-10-12）
+
+> 本补充只约束游戏生成输入，不引用 rubric。所有生成器必须以本文件规则和下列 JSONL 任务为准；未列出的装饰细节可以自由发挥，但不得省略已列资产或生命周期。
+
+### 故事与流程最低合同
+- **玩家身份与当前冲突**：以 §1、§8 的角色/世界/冲突为唯一叙事入口；开局必须让玩家知道“我是谁、现在要解决什么问题”。
+- **阶段性目标**：必须有可操作的阶段目标、至少一次状态变化/升级，并在 §7 的胜利、失败、重开入口中闭环；不能只生成一个无结果的场景演示。
+- **结果承接**：胜利/失败都要有明确结果文案或演出，并回到可重开、暂停或标题入口；视频、音频和 VFX 不得推进未完成的玩法状态。
+
+### 生成任务清单（JSONL 冻结口径）
+- scene：1 个；必须生成连贯可游玩的空间，不得出现下半部文字、拼贴面板、物体 lineup 或 UI。
+- object：6 个（text-to-3D 4，image-to-3D 2）；object 任务资产为：salt_flat_prototype_car, checkpoint_gate_kit, telemetry_station, salt_crystal_rock, wind_sock_set, maintenance_shed。每项只允许一个物体；组合物必须拆成独立任务。
+- motion：1 个；覆盖动作：drift_recovery。
+- video/audio/mechanic/UI：分别为 3/11/1/1 个任务；若某项为 0，只能是本案例明确的 N/A，不得默默遗漏。
+
+### Video / motion / audio 生命周期
+- Video 每项必须写清 `trigger`、`start_condition`、`duration_sec`、`skippable`、`skip_behavior`、`end_condition` 和进入的下一个游戏状态；播放期间不得偷偷消耗计时或改变战斗/任务数值。
+- Motion 每项必须写清 `source_asset`、`trigger`、`start_condition`、`duration_sec`、`loop`、`end_condition` 和 `cancel_behavior`；动作要与对应输入/机制事件绑定，不可只写“walk animation”。
+- Audio 每项必须写清触发事件、时长、`loop`、`stop_condition`、优先级和 ducking；关键命中/提示音必须与事件帧同步，暂停/结算时按 §9 处理。
+
+### Mechanic / UI / 游玩手感
+- Mechanic JSON 与 §1–§7 配对：每个输入都要有 precondition、state_change、feedback、next_state；必须说明失败/禁用分支。
+- UI JSON 与 §9/F10 配对：HUD、菜单、结算、暂停、错误/禁用态要有 state binding；关键状态不能只用颜色表达。
+- 手感冻结：相机跟随/构图、FOV、碰撞/遮挡、镜头调整与镜头震动必须在 §9 说明；震动反馈必须写明触发、强度和持续时间，并提供关闭设置且不改变判定。
+
+### VFX 时机合同
+每个特效必须写清 `trigger event`、预备/前摇、active window、持续时间、结束条件、被打断/取消条件，以及和相机震动、音效、UI 的同步关系；命中特效、失败特效、胜利特效不能只写“有粒子”。
+

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/method_selection.md

@@ -0,0 +1,152 @@
+# 优先资产：方法选择与执行边界
+
+核对日期：2026-10-15。本文是候选方法建议和开跑前检查，不是实验结果，也不是已验证的
+API 配置。评测口径以 `GameFactory-3A/eval/asset_evaluation_plan.md` 为准；
+本次没有改动该方案、原始全集或其他五份现有优先生成 JSONL。
+
+## 1. 建议首轮组合
+
+| 类别 | 首轮建议 | 放在哪组 | 选择理由 / 限制 |
+|---|---|---|---|
+| 3D Object | Meshy + Tripo + 腾讯云 Hunyuan3D Pro 商用 API | B1 商用生成 API；逐版本核对开放权重状态 | 三家即可；人物/刚体、T2/I2 分组，保持同输入和低模预算 |
+| 3D Scene | 新增 World Labs Marble World API；保留 WorldPlay/HY-World 2.1 Scene → WorldMirror → 导出，以及 LLM 布局/组合 | Marble 为 B2 商用 direct 候选；另两路为组合方法对照 | Marble 提供世界生成和 mesh 导出；不拿仅视频输出替代 3D 交付 |
+| 自然音 / SFX（看情况吧） | ElevenLabs Sound Effects v2 + Stable Audio 3.0 Large 商用 API | B4 Environment / Foley 子组 | 一个面向音效、一个通用音频基线；先用声音事件和环境音 pilot 验证，不跑成音乐任务 |
+| 中文人物语音 | MiniMax Speech（优先验证 `speech-2.8-hd`）+ ElevenLabs TTS 的固定中文支持版本 | B4 Speech 子组 | 当前 38 条都是中文；固定说话人、情绪映射和完整台词 |
+| CG | Seedance + MiniMax Hailuo（优先验证 `MiniMax-Hailuo-2.3`） | B3；T2V 与 I2V 分开 | 先跑两家即可，不急着加入第三家；按 API 的时长/分辨率能力冻结共同条件 |
+| Motion | MoMask + Puppeteer 对比 LLM 直出；可再加 Meshy Text-to-Motion | 前两路是开放模型链 / 系统对照；Meshy 是 B5 商用 API 候选 | 先满足用户要的两路比较；若 B5 必须有闭源专用生成 API，再加第三路 |
+| T-pose | 同一份冻结准备输入 | 不新增主表 | 两个动作方法共享角色输入，不把图像准备差异算成动作模型收益 |
+
+商用 API 不自动等于闭源模型。特别是 Hunyuan3D 必须登记云端实际版本，不能把本地
+开放权重版本包装成闭源行；MiniMax 的视频实验也要写清 Hailuo 的具体 ID，不能只写品牌。
+MoMask、Puppeteer、WorldPlay、WorldMirror 的源码/模型发布可在官方仓库核对 [R1–R4]。
+上述 API 的能力入口见文末官方来源；账户权限和实际可用版本仍需 pilot 确认。
+
+**规模建议**：B1 三家、CG 两家、音频按两种任务各两家；场景优先补 Marble，而不是
+为了凑三列加入不能导出场景的模型。B2 暂时只有一个确认能力范围的商用 direct 候选，
+如需至少两家闭源 direct API，仍须找到并实测第二家，不能用组合方法假充。
+
+## 2. 为什么按这些方法分组
+
+原方案 §1/§4 要求闭源专用生成 API、开放模型与多模型组合分开，首轮主表不混排。
+因此保留用户提出的系统比较，但不悄悄改掉主表含义：
+
+- B1/B3/B4：按相同任务和输入条件比较商用服务，记录模型的权重开放状态。
+- B2：Marble direct 与 WorldPlay + WorldMirror / LLM composition 分 panel 报告。
+- B5：MoMask 生成人形动作，Puppeteer 在本项目链路中主要承担绑骨/蒙皮准备；
+  LLM 直出是另一条系统方法。不能把它们标为两个闭源 motion API。
+- 如果研究问题改成“各种资产生成方法谁更适合游戏”，可以增加系统对照表，
+  但需要显式修改协议，而不是沿用 `Closed-source method` 表头。
+
+为了隔离动作生成能力，建议先冻结一套人形骨架和白模，两路动作采用同一个映射、
+retargeter、20 fps 和接触检查；角色网格、绑骨差异另在第三阶段端到端比较。
+LLM 直出必须交付轨迹/骨骼动画文件，只有 Blender 脚本、文字或预览视频不算交付成功。
+
+## 3. 与当前优先清单对齐的阻塞项
+
+### 3D Object：低模与上下文能力
+
+现有 200 条保留低模 prompt，且 `decimation_target` 最高 8000。
+建议统一保存原始 API mesh 和固定后处理后的导入 mesh，分别报告；不要只给一家减面，
+也不要把减面后生成的新几何缺陷完全归给原始模型。
+
+Hunyuan3D Pro 的普通模式中 `Prompt` 与图像输入互斥，不能假设 I2 能同时传游戏梗概。
+这类调用按原方案记为 `reference-only` 辅助组；T2 可以拼接冻结的短版梗概。
+其 3.0/3.1 的 LowPoly 支持不同，先确定使用的版本和后处理政策 [R5]。
+其他 I2 API 也逐一核对文本上下文能力，不能只在 judge 阶段补梗概。
+
+不要用 `latest` 当作冻结版本。Meshy 文档还提示其 `lowpoly` 模型类型将在
+2026-10-30 退役；现有清单的 `poly_policy: low_poly_priority` 只是实验政策，
+不等于必须调用这个即将退役的 API 类型 [R6]。
+
+### 3D Scene：交付要有真实场景
+
+69 条现有场景任���要求 `output_format: glb`。WorldPlay 的视频需经 WorldMirror 重建
+及场景导出后，才与场景任务对齐；只生成视频不能记 Delivery 成功。
+
+Marble 的世界接口返回 splats 和 collider mesh，并另提供高质量带纹理 GLB 导出。
+建议正式 B2/第三阶段使用后者，保存碰撞网格和世界尺度信息；不要拿无外观的 collider
+mesh 冒充完整美术场景，也不要把 splat 文件简单改后缀作为 GLB [R7]。
+生成和导出都计入耗时/成本；若导出不可用，保留该任务的未交付状态，不替换成全景图。
+
+LLM composition 固定资产池、资产提供者、坐标系统、规划调用数和修补预算；
+若它额外调用对象生成器，费用和调用全部计入系统方法，不能只记 LLM 的 token 成本。
+
+### Audio：需要按声音任务选方法，不是一种模型跑全部
+
+当前非语音 706 条：623 条 `one_shot`、83 条 `ambient_loop`；语音 38 条，全部中文。
+这是分类字段统计；实际循环要求仍以每条任务的 `loop` / 生命周期字段为准。
+非语音时长为 0.15–45 秒，其中 93 条短于 0.5 秒、281 条短于 1 秒、19 条长于 30 秒。
+
+ElevenLabs SFX API reference 写 0.5–30 秒，能力总览却写 0.1–30 秒，存在官方文档差异；
+开跑前应实测短音边界并保存实际请求/响应，不自行认定所有短音都支持 [R8, R9]。
+Stable Audio 的 API 时长范围也应从具体 endpoint 核对。这里建议验证 3.0 Large 商用服务，
+而不是把已开放权重的 3.0 Medium / Small / Small SFX 当作闭源方法 [R10]。
+若账户仍使用 2.5 API，则固定并单列 2.5 版本，不混写成 3.0 的结果 [R16]。
+共同能力子集用于配对排名；其余任务仍留在第三阶段完整清单中，标注能力缺口。
+
+解码、重采样到要求的 48 kHz / 24 kHz 可采用同一确定性工具并保存原件。
+短音裁切、长音拼接/循环、生成式延长不是无代价格式转换：如要使用，须预先冻结规则，
+单列 pipeline 结果及成本，不能悄悄改任务时长来让 API 通过。
+
+语音不得把“游戏梗概 + 角色介绍”拼进需要念出的台词。检查 API 是否有独立的
+instruction/style 通道；没有时仅可使用冻结的 voice/emotion 参数映射，单列标准 TTS
+条件，不宣称模型直接读取了梗概。MiniMax 的 TTS 参数和 ElevenLabs 版本入口见 [R11, R12]。
+
+### CG：现有任务与 reference-image 协议不一致
+
+194 条中 190 条 `text_to_video`、4 条 `image_to_video`，但当前全集和优先清单都没有
+参考图路径字段。不能用这批数据直接声称完成“194 条 reference-image-to-video”评测。
+
+建议明确选择：保留 T2V 子表、Q1 预声明 N/A；同时为 I2V 冻结真实的共同参考帧，
+补齐路径和来源后再运行 Q1。若要全部改成 I2V，应生成并冻结共享参考图，然后形成新的
+任务版本；不能各视频方法自行画图作为自己的参考。
+
+现有时长 4–12 秒、输出 1280×720/24 fps；Hailuo 2.3 文生接口的原生规格是
+768P 的 6/10 秒或 1080P 的 6 秒，不能把原 JSON 原样发出去 [R13]。
+先冻结共同能力 pilot 子集；非原生任务保留并标注，不隐式拉伸视频来满足事件时长。
+Seedance 使用已接入的实际 model ID，先验证能力矩阵，不将品牌名当成版本。
+
+### Motion：保留非人形与短动作
+
+新增 78 条中，76 条人形、G040 一条 vehicle、G030 一条 mechanical。
+两个非人形任务必须保留用于第三阶段，不能因为 MoMask 主要面向人形就删去。
+按 rig group 单列，不支持时明确记录；需要 procedural 交付时另列方法，不冒充 MoMask 结果。
+
+Meshy Text-to-Motion 的官方接口提供自然语言动作和 FBX/BVH，当前时长要求为
+2–10 秒且按 0.5 秒步长 [R14]。它适合补商用动作 API 对照，但不是现有所有短动作的
+无缝替换。LLM 直出也固定同一骨架、帧数和时长，不只比较好看的视频。
+
+## 4. 最小执行顺序
+
+1. 先为 13 个 L 级游戏准备第三阶段的全部既有资产任务；完整性与模型共同能力子集是两件事。
+2. 选 G003/G025/G040 等 3–5 个游戏做 pilot，覆盖中文语音、RTS 压力、机械/载具边界。
+   每类先挑少量代表任务；这不缩减 L 级正式导入清单。
+3. 冻结游戏梗概、任务/参考输入、适用指标、API 版本、调用次数、超时重试和后处理。
+4. 报 Delivery、C、Q1/Q2/Q3、Coverage 和成本，按游戏宏平均；不挑 best-of，也不将
+   未测能力缺口伪装成 API 生成失败。正式分母政策在开跑前固定。
+5. 第三阶段各 repair 方法共享同一冻结资产包。提前固定每类资产的交付来源，不能按
+   单条 judge 最高分挑选，也不能悄悄用 LLM 补产物来遮盖某个生成方法的失败。
+   若比较资产来源，另设因子并保持 repair 方法与预算一致。
+
+## 官方来源
+
+- [R1: MoMask](https://github.com/EricGuo5513/momask-codes)
+- [R2: Puppeteer](https://github.com/Seed3D/Puppeteer)
+- [R3: HY-WorldPlay](https://github.com/Tencent-Hunyuan/HY-WorldPlay)
+- [R4: HunyuanWorld-Mirror](https://github.com/Tencent-Hunyuan/HunyuanWorld-Mirror)
+- [R5: Hunyuan3D Pro API](https://intl.cloud.tencent.com/ind/document/product/1284/75540)
+- [R6: Meshy Text-to-3D](https://docs.meshy.ai/en/api/text-to-3d)
+- [R7: World Labs World API](https://docs.worldlabs.ai/api)
+- [R8: ElevenLabs Sound Effects API](https://elevenlabs.io/docs/api-reference/text-to-sound-effects/convert)
+- [R9: ElevenLabs Sound Effects 能力总览](https://elevenlabs.io/docs/overview/capabilities/sound-effects)
+- [R10: Stable Audio 模型及商用 API 入口](https://stability.ai/stable-audio)
+- [R11: MiniMax TTS](https://platform.minimax.io/docs/api-reference/speech-t2a-http)
+- [R12: ElevenLabs 模型](https://elevenlabs.io/docs/overview/models)
+- [R13: MiniMax Hailuo T2V](https://platform.minimax.io/docs/api-reference/video-generation-t2v)
+- [R14: Meshy Text-to-Motion](https://docs.meshy.ai/en/api/text-to-motion)
+- [R15: Tripo 开发者入口](https://developers.tripo3d.ai/)
+- [R16: Stable Audio 2.5 官方发布与 API 入口](https://stability.ai/news-updates/stability-ai-introduces-stable-audio-25-the-first-audio-model-built-for-enterprise-sound-production-at-scale)
+
+Seedance 的本地封装 `GameFactory-3A/models/gen_cg_video/seedance_model.py` 已登记
+model ID 和官方文档入口；本次网页抓取未能直接读取该火山引擎文档，因此不在本文
+宣称已核对其全部时长/分辨率规格，开跑前仍需 API pilot。

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt

@@ -0,0 +1,11 @@
+# G036_salt_flat_timetrial / 3D_object requirement
+
+Source of truth: ../general_requirement.txt
+
+Frozen task inputs:
+- salt_flat_prototype_car: Enclosed low-center-of-gravity salt-flat prototype test car, clean side three-quarter profile, graphite panels with restrained orange bands, four separate wheels outside the body with visible axle centers and clearance, wheels not intersecting chassis, single centered vehicle on plain studio background, game-ready PBR, Y-up, pivot at base
+- checkpoint_gate_kit: Modular telemetry checkpoint arch per reference image, graphite industrial frame with cyan lamp band and orange safety stripes, blank panel for runtime numbers, single arch module for 8 instanced gates, game-ready PBR, Y-up
+- telemetry_station: Tall survey telemetry tower with wind-load lattice mast, beacon lamp on top and instrument cabin at base, weathered graphite steel and pale panels, single object, Y-up, pivot at base
+- salt_crystal_rock: Crystallized salt rock formation with pale translucent crystal clusters on a weathered white base, low-poly readable silhouette as trackside landmark, single object, Y-up
+- wind_sock_set: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up
+- maintenance_shed: Small canvas maintenance shed with steel tube frame, tool rack and tire stack visible, weathered off-white fabric and graphite frame, single object, Y-up

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/localization_integrity.json

@@ -0,0 +1,91 @@
+{
+  "created_at": "2026-10-16T11:10:08+00:00",
+  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "original_records_archive": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_1e2aea5faacb75c0.zip",
+  "archive_sha256": "272a441c92c5ce17c6a0fb8624018d37baf747e4ce2e620d241c67f56dcd52dd",
+  "records": [
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/meshy/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
+      "before_sha256": "c31f5c167ae13474e58ab14d283fb60cffc6ff14fc10b524627245efc551c06e",
+      "after_sha256": "c31f5c167ae13474e58ab14d283fb60cffc6ff14fc10b524627245efc551c06e"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/tripo/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
+      "before_sha256": "d3f9a5269a6e27405687a037700fe8dfd99bbf12260379cd08d9d695da27cadd",
+      "after_sha256": "d3f9a5269a6e27405687a037700fe8dfd99bbf12260379cd08d9d695da27cadd"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/meta.json",
+      "before_sha256": "953627064def7bf97bcd0e34fd8b2b4d03c8f7bbc5435bec885f3bd55aed315c",
+      "after_sha256": "953627064def7bf97bcd0e34fd8b2b4d03c8f7bbc5435bec885f3bd55aed315c"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/meta.json",
+      "before_sha256": "1c9a001e9dd7b9c556b9496a4b0a6f5aeba2842d79436f21b89b7eab03f9369e",
+      "after_sha256": "a3d6e97e557f11d5820debe825b32e35667d65cbfb47bafaab3bbd858f890adc"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/render_meta.json",
+      "before_sha256": "852f91cb8dfa350e2026a50f3058cc2a16ff985f1413c9088ab312b03dfc8f49",
+      "after_sha256": "852f91cb8dfa350e2026a50f3058cc2a16ff985f1413c9088ab312b03dfc8f49"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/native/render_meta.json",
+      "before_sha256": "62d6ba3d9194584475f2cab9af11c23e9fcc8b46388b5185a7153cda7b203334",
+      "after_sha256": "62d6ba3d9194584475f2cab9af11c23e9fcc8b46388b5185a7153cda7b203334"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/qa.json",
+      "before_sha256": "f83dc966a71871653892be9cfd0b5282e96130b8b7bdfd2640d16ea1dac9144e",
+      "after_sha256": "f83dc966a71871653892be9cfd0b5282e96130b8b7bdfd2640d16ea1dac9144e"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/tripo/previews/import/render_meta.json",
+      "before_sha256": "904f0c0c629233b70618b952cc02a453380ae7afcfa8187792cbfe6f93e3f19f",
+      "after_sha256": "904f0c0c629233b70618b952cc02a453380ae7afcfa8187792cbfe6f93e3f19f"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/tripo/previews/native/render_meta.json",
+      "before_sha256": "4af8e42de5ec2c5212343eb68b150027814cf4e917966b212ee4325ff681d295",
+      "after_sha256": "4af8e42de5ec2c5212343eb68b150027814cf4e917966b212ee4325ff681d295"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/tripo/qa.json",
+      "before_sha256": "b034c00001333307a309553d5bea25a6397dbf455f62d02d70700a93964d6cf7",
+      "after_sha256": "b034c00001333307a309553d5bea25a6397dbf455f62d02d70700a93964d6cf7"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_generation_report.json",
+      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
+      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_manifest.json",
+      "before_sha256": "7ef605ed78c77331ba12ceb8926a24a39d16e9cac0522a5ec8c291266cf90e40",
+      "after_sha256": "3d3e2bfc4b6aa3cc7c95e0386d49d3c288b52b8cd3eec4c3f90f24beb21658b1"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/meshy/meta.json",
+      "before_sha256": "26d9e8e1850484d3735d1f083378c05cba2dc4dc4a28c576e8fe0bd93ea24542",
+      "after_sha256": "26d9e8e1850484d3735d1f083378c05cba2dc4dc4a28c576e8fe0bd93ea24542"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_generation_report.json",
+      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
+      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_manifest.json",
+      "before_sha256": "c17fed1acb7270f5b4a0006b82eb3139f31062d0cf57425bcc314c7201ee86c1",
+      "after_sha256": "1bffa91d8269f9ee81fd6f8bbabd6b7e3cee51711d9322d217d4b5c2107250b4"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/pipeline/G036_salt_flat_timetrial_pipeline/obj200_meshy_tripo_20261015_v2/tripo/meta.json",
+      "before_sha256": "ffa15bd4b6857f930bef751216944d9f61aa2772f049236c7c215981f8988d3b",
+      "after_sha256": "ffa15bd4b6857f930bef751216944d9f61aa2772f049236c7c215981f8988d3b"
+    }
+  ],
+  "api_calls": 0,
+  "meshes_changed": false,
+  "absent_artifact_links_cleared_for_undelivered_inventory_rows": true
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a72e49a29033d161d0ec0abd27dc003f34c8b7a190201c7e8b514e0afc4bce45
+size 60760

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_1e2aea5faacb75c0.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:272a441c92c5ce17c6a0fb8624018d37baf747e4ce2e620d241c67f56dcd52dd
+size 19468

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_4a2a7818396861d0.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:176d2a0ffd5afe9ae1e93fe62988e267d1fe72053b85a30f9ca363c280298198
+size 13809

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G036_salt_flat_timetrial__G036_salt_flat_timetrial_obj_005.json

@@ -0,0 +1,88 @@
+{
+  "submissions": {
+    "9eb3fa0492adefbb36b1eb6a6f16156d3ac0bc7f32a8d459231d0b3049088f5a": {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "reserved_credits": 20,
+      "status": "created",
+      "remote_id": "01a142f5-ff7c-76fa-a988-194123105d2e",
+      "response": {
+        "result": "01a142f5-ff7c-76fa-a988-194123105d2e"
+      }
+    },
+    "fbcad0c99e0f131baeb527223a8ecb309d5036d4f5828aea25a0d697c92b0973": {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "reserved_credits": 10,
+      "status": "created",
+      "remote_id": "01a142f6-cf5e-71e7-be21-767f8d3bbcba",
+      "response": {
+        "result": "01a142f6-cf5e-71e7-be21-767f8d3bbcba"
+      }
+    }
+  },
+  "results": {
+    "/openapi/v2/text-to-3d/01a142f5-ff7c-76fa-a988-194123105d2e": {
+      "id": "01a142f5-ff7c-76fa-a988-194123105d2e",
+      "type": "text-to-3d-preview",
+      "mode": "preview",
+      "name": "",
+      "model_type": "standard",
+      "seed": 1040,
+      "prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+      "texture_prompt": "",
+      "texture_image_url": "",
+      "status": "SUCCEEDED",
+      "created_at": 1792124783165,
+      "progress": 100,
+      "started_at": 1792124783174,
+      "finished_at": 1792124829740,
+      "task_error": null,
+      "model_urls": {
+        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/model.glb?Expires=4945708800&Signature=gWIe54hvvGCdlRhH65neBrctUywqPL610Up6Frwh5iFke3DsI1aNtNC3qwkNjsiFuEfZ1DOxWjzEJQVj5CGQvoe565NuAN~Yvfe~5SUWhRtRyICHpcm3aCjwyKaDjv8cLPNJRDmgn38seLVGo8Vag8V0hghF6Dfty0kB-wiAFhHSAKoQaZ-WZ6O567L3ZXL9ikQy8UNqWcBpMukBNgW-bU~p8ja9rAt9AwEnBSE~8qrLWCgvg3YKqV7FnspKCGnkbSVxfnBeSdAkeKVjq5RB-m6qpPVIKE0GThSnhgqULUrT~aA6sIGvpW1fWE5KbAtQT~YwlmZ8YNYxhK0mVXEUaA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/model.fbx?Expires=4945708800&Signature=iq2zQoSgVUvQD1mwEm1cyv9Zr2Pokzx6tGBK7Drtjib20qlxv4MX95v3z1M7MojHd7eaociQQLvRGVomtuTE5c0oEfGmniAFv4MogBwtGILKvmypEWKnAMwJQ5AT1fwTGWbBI5bLpmB-I3V5e6uo5uliDAvVW8d-QW~kfeMSEou4lVdu-EqprZGk1KAFRguEzKK-jg8gLFUAI6BqgqffjEUACorHnsCUwMKreJ3RlWK7s8Z50ZFzb-XLHlyVBs-fnsZVtDPVtDw5DZ2xNFAMcWL9aXmUpuxuTHIT-8p4NxE9BMZOxoXtdHlbzeeaskJLnRTFxjt~P0bYh5EiggZTQQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/model.usdz?Expires=4945708800&Signature=FLAZjGvFw8Mt2wEaAE7TYqxWpBB31G~kItbRCgoWliMsJs1~OzvGcuhfet7qBNe~8EldpDkdpNBjHJzLtI0QsioHq0qY1vjpWLifRfLLxxuUK7IKyAl7UrSCSTMeAfqtS6-GYDL643U25hOGzZ28oYlVPv2t6LtxpoGENnaqbs~65s4nn9AebKvx7-Mp1ngAITcHMGehuj5jlDjQ4e0idvSXUoqDmquBKvglqGQNuiZfPvTKRXBhOKbqrxmYdH8-Bpb506ffJJe8o57ZiLZP0-RK8mQ7zizhUUIR5-W82vhbKLmJrh0jyqVkvyoTt3VNcGBE5BnSbCPzWD6UcxaifQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/model.obj?Expires=4945708800&Signature=ThWejTE97JEjNS2g7IzxOt6UDEF5WEDCLk7NJ-zrYjnGvwC~ppsN3~JeYlB8tK3D5wdd1rk4rwAV6dAvA27HE3r1MQg3zOiyys3Qms5PX2YBnS0ds8jIQVZb6iku-2GmMrE96TYctZgsF2LVvlVKuF~gWKZmmrWyOQxj9C7pChkqfD~QXOXdHtwYUA0TVLT2yCQLCq0XfsiMfu-hwliPmqPZXCCopRIwBlLLVPJWPgc80gJajurkI1-38dj0kcnQG5lT9jQ152gE0JaJnwB6hYf~CSN5WUVNjsaxGcnrOI6Uf39c8T3Ct~TZb~Ia2smxPe0wt1S-Xxj6H15ccBzLKQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/model.stl?Expires=4945708800&Signature=U5~poOANyioKnW1EXNGKUuMcPitF8BRI-nmoBLBf0Hmglent2T2oUjhFdRVxSKzJTWK78Ke3CYuYxHjWuuAbbjf~m2lyQkWNXQjXywXOcpCUBOnMhTi0hFJ7Lv0AHXBPcoVGba59cadhG4e-I5yT7wPO5D0ezlRudMQ-lcYGXaYkEdofQW1tNYAbKb9TQiqYgG7bgfMEZZARV73g8gq2IZzozrZrKJNHjmXOoq6ExZLZ0yoNyGV2okNpX-mw5eiUc~QwxojOiTpyT5CKwmDI9GExN5od0emf3EwgxgmQD1NdjIgeO1A1CfnKbKLTFdWm4RPAXLmoTNMXan8WMxBSNg__&Key-Pair-Id=K1VGYTHIYLM9UM"
+      },
+      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f5-ff7c-76fa-a988-194123105d2e/output/preview.png?Expires=4945708800&Signature=Wl1DCtm7j14Zhe5fWqlxf~28kOwEafvLs6ZfpxKO3LQrKlrPYxO-aVBqSpjGjpzrjaoZWumROaTeBAwiM1tjVzznGJAyvYigrg-XfQDTlbVBICpuT5Hu8V7sgLEJHBwio-r4ACuwFCikx5TSYXewQOzVotLhVFS6-pIDERCvj-stkCAeB5xYbnEYiuVyHs9uJ7pQ6S851gvB7PGTRDWPW0-w9H~FCiuVOGwQoQsUmLXnIHVkm3QsDZx5YXdWtkXlXuMytIH7K6ZpL981d0AMnFO9qd5CC6jrGoumyS8jzx7YtKNx6mKR~fd0PEkggpfdHodKC~b3WYpw~ERuc9a9BA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+      "texture_urls": [],
+      "consumed_credits": 20
+    },
+    "/openapi/v2/text-to-3d/01a142f6-cf5e-71e7-be21-767f8d3bbcba": {
+      "id": "01a142f6-cf5e-71e7-be21-767f8d3bbcba",
+      "type": "text-to-3d-refine",
+      "mode": "refine",
+      "name": "",
+      "model_type": "standard",
+      "seed": 1040,
+      "prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+      "texture_prompt": "",
+      "texture_image_url": "",
+      "status": "SUCCEEDED",
+      "created_at": 1792124833641,
+      "progress": 100,
+      "started_at": 1792124833648,
+      "finished_at": 1792124918003,
+      "task_error": null,
+      "model_urls": {
+        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.glb?Expires=4945708800&Signature=PIGWDL2O0SW9Bbfdkk~hoBR9y2pUnJq1RH2mwSqS6j8gqq6rKrmYJfHji4Xs1KK13rC-GcyM6GdNSTi4UO3IpCToFxEfmeMCURS4nRxJVJO7bhD5ehKD8IidgdNe~ipRRnsJYjRhEEPYkORG9j0Icy~nVN9KCcbZYmEFAYg0~jAbpFMzOxqnXvqMqUT74lNnTbDKJ0EG0fJo0x9e1YEpMKt9FDXh~wMQmc04~GuC1VFYmJNbjy1VOLZFpJtoBOFkhQVxn~D1hez8~xi6GsKWB3~4PyY5A7TqvkPz3QhoV-uTHjJBo6chvrGk~ENqwLl4TDL8o5uFasW6ey4SGSH54w__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.fbx?Expires=4945708800&Signature=YvlonxONN3kLgSzyQCYN31JtfhxX70RhyPbtqxC0BjEXOm9STuYluXjLELtqtNKUil-ShBoDD7pxfI6RlWKF1oOHcLnsOFw4FD7qIWIyf9TqqEAeTD6S9gzLtY-gzkuWd4Ik6-PXUVzsSR4uCtaO81HtVLfsCS5a0C6rkd7~oHSuCGadcGcFckom1L4EZ751olHgBvg7BnLcxdX0JKDkYmvLKyc7TOhPTKYn7YvFGXNSQj5RsnEywqZHIOAoAOMdLdoMQwfuxTmPmUXWC3K9IKeb-dRg57s1KqNwnjlIGbg7j-ovsT6pmTEm1SNsKZplH4jie9USJ6vFVw6TKnv5ug__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.usdz?Expires=4945708800&Signature=YHyKSwnUy8uVbeu~tpKfSQWgo1vDYbNMzBYPL5BiyHBN2MHSwdj4s2AKWzci63dxL1RJnQJ~RMnGO34H~xINeGeELJ1A7uaPnoZfBnKqboeGfXQl23nc5dc5MyPeH0byXwXiNghaufzcKVVBCkXZAe9oPFaUtjufUoKulJGtcw6ouJUlE9WNp8uOdMTINlkKPx1Gj7CLFcr14yIkFM3NT-74emaBZ8AfEOlRWZlMxv87NoUQdb~n4pHP89RtN0HrSOWvE6VPdyyrU9C1dddLvnj7Np97MDWdNAng8ydhjAOOtiLnhcGrHVGudQFk4b1vWu-w8DzMQN4chSHbS92Afw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.obj?Expires=4945708800&Signature=FeRNudTjKaOJyw7qaktZzXbfa5NW1rpKifnd6x63KSyPqZ9GopihPaKXEYEcGGPP8Ix859OroLOptJAzg9pdLGby6-hF4f4ixvVYn0HidQXQmK3LiOKnfvQqmC3rOP06c9go-1A2MbTBuvJ9hDm9PlNTzC2y4MnDlb1kJcOQv8cIgqzyUHrpKLbDj-iKoe4JZWfN9Tn1hXhQagXsuLREIck0mxwdbVTOJ8bSHJr~KQ07FG0ntPLb79-45UE~XlE2dETqRnwKHaX3keeAViedjvY3fmMLR3-NZddnUgkLtDUdq43aROvewvkcCjvopyvws-r8D4exNGxzvK25Dep2UA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "mtl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.mtl?Expires=4945708800&Signature=oayQDlsIOc8mBEMdf63-Eqx72xRF4sq3GSHZ5dFAnFE4I93Mw2hW1GJhcZL3cWr~Ev7onf1xwQKIgl38l1jUYjByDzgTKeIzH8KUbLcRnYbyo9uPHrtFc0X0UnBgZ1tJ9IGNrBkLuAgSWzcYBGBqZFKNUNbp2aah55TXkiPnrZ5dexBdO6i1Z8gQb8pBV~6qkHAnNVVgVwuF6qTDHObdg7rX9aYuP6tW-O9vTStQkxgQdhoE93H1bweIEzleiIAiASH2TJokxrAIgBb0w3-KpUk1jr3m7zJJN5DC4DBh3iirGu5qOMga9WLsoG722yGGFy-eKZr~xH8BdF6mVDZksA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/model.stl?Expires=4945708800&Signature=TZ8ysCEgau6qaWw9EEXQON~3p~Z5Gyla~1FtYzBeQrs2SXKlHE8As2KQ-F5QVel4tY7bckD4sgIWPMhUNJgISA1~j3EargN~K0U~tJOB3bs6uQwqLDOF9AyokZ7cynpGpV4Db5aJBs7hURHe6WiunQAC-edfi6FmaUnwS4DFcTLiOZM0Pll92S3m0hJPdxJrjzXKiWxjgZWWt6uXhDnXGSHHUbNrjWVQv2sDznaRXYoohAesatrULtgAaRh25nYofyLkQkLID2GpsbCskCEGHsWMbhJn2mNt4UumeHqf6DXlqiakvDpXc2YPEsApqWI3SIrquD-jMdGz5fs1AY6EfQ__&Key-Pair-Id=K1VGYTHIYLM9UM"
+      },
+      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/preview.png?Expires=4945708800&Signature=T7G4PdLUZermojqeiVJEcV6JuPhlnWaauiyu5heD-XSFOmTFlbN7WxdCRiOJKk4YIYi2kEjoM6fQqbeEjT5znlS2WC5cza3j0JKqdZqhPKsNIxAgDrYRu0Dl0b6WS5gzwcpj9d7ViTTL5jWP4ZwC4mJm9W0qlDdYG8sI1lVsM1SpuE1iuTYo16GxF1-m87JtVW1FYn2f8nily9cpz6MMsTydjFlG9VPYpcqphwTQVmpkoXm1Wg3QSezNXe5ySDWZZuhnqYznBb~mG3S2LUMhEcWCMpE9tpieeSSdqHoLcrsRvMa0IkGABxczv7fS3l1Xgl75D8lSTnCTNx~pJpJmXg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+      "texture_urls": [
+        {
+          "base_color": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/texture_0.png?Expires=4945708800&Signature=fazD2hKeeRppD-7vdF3e8PZoxklHmKzP07Pje6f8O5BL0uMqKnCI1BHmWdIYAG6zkYdHGxi7Q0XCzoZLkibtr26WOInGI2rEgs4nM8aWbBsLnh0mCQkZkdXhBGl-g13MrXab0DlO~bxfeJ3fjgs-XHZQUWb-E6mqyhyWKuyn3moYD0kwRXNrMHFgP-1S3bwLO-cssb1ddooqIiimObEueSLKGm~fXYF3880~VTlETFZPSseLNc3okWver9xVgYIzflns2-X7oNoPieKPj~n2lqbZxRW3~rEn-pz759f5pLqep9Bbm-9~oIABPugk7aqMrhBGSYWQgnuJEuW7CKyusA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "metallic": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/texture_0_metallic.png?Expires=4945708800&Signature=e3WXhizj8oi-HhUxue-ZkOasEoFyAmvdPXAeqTc~APCAHdf6kxUNHBQNoSQ4Tj3CYt-KHEP~ldQKncJ9nsDy9jJJrnwEkvl0k1yYlAgRocuRKelrOq3jZ7-wBPh8GCFqwaMLqboJp3g6TpmGGZ92amW~8m9~Il2MEEm4nmiT46M1MLO1n4W55r8MzfaBT8y6Bu-Nq9Bwlq2WC7MFqROjnPCGFKQE6SauCW13Xu1Mcch-OEw4-lZYkY52pwx4I95mQeb8hVDn~6OVvj4QJrm4fpvMROgYK4~I~ymbpjt5GHjD95vsviGcytc4~dTCsvgBk5wHy7-u3EUzw41SlNwmPw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "roughness": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/texture_0_roughness.png?Expires=4945708800&Signature=ZogF2muSAiEGrZpFfslxvY0HCjtU4pXgpXKSiilnte~m9W~5tMkkoFocGGlZCTopjxHqicijGCZ0vLF6-d9rBpAYZfY390r-fCLpUuNMUMaZFsZKlzosLaJgOL-hmOIJ3nDz-6f-1ydxB0f5GXMwL02rsoRfq6jNZ58Syh02z0fb9~MlkGhl5f761SKmGRbiP9fMz0gis4xPJN8SyDjcWMuXXvLfJXlWjSNEA8yq-oqPPHYFcMGC9P-y~x4o0LU6-TwXmL6Y4h7udXw5hvkovdbCadm33XskXUCshUgrljV66kjkjv7S7s7QKBtg4H6b-ndjDGoRK34NlAIyqdfR7Q__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "normal": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/texture_0_normal.png?Expires=4945708800&Signature=KZs7TzdgVCTfXxWCppMt-V-CucXDwszVdR4qLtRe5EbovaLG3l5qG4oV~4xj-lfbG~T2Hbpdwm0306Hyo~C32yEP-GRVUtgS-eWnJn8jSdhoOIW~Kq3dXd9vLiZ2hqsAayEB5KNO6R9lDNy09B6Q17R-UQkdFDrk4ojaLSS4OAPcR705JLJGzRBzdMHHemwtta0mrC-WZCJOUDFcZt69-VIoYtOAbsQrZ2OwWt4E5Oq8mbjFZVwkSP1M0eHBEL9vld5juvyyX5tQHjzs5XSJk0u~QjduUQZv8OOzJDhDshRkXcbK38s57GkDlv-5DKFDYkO9atvDb2-S0Ul6JCBYCw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "emission": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/texture_0_emission.png?Expires=4945708800&Signature=MyGVtJVLOoNTGt2HTpYZhYByegktFJs917k4gVLtZKmQXzavrU0zVEEPUfgRtWxyPX9LiFK7hnff2sahtYuUvVVM67zyILsV8YEbe6sSonny-7Tl~~JOnmipsRwMF4Y6RBggtyFf8sl3Cgq7VYLVqT2LmKXnqnOLmK0zzeCMsjjVqoeuorDcRgJRv8RAMualxW~99gfrwnAPohldn4ELwZ36~TGLiwXs8DxJMxb9PRkw74n2oZIywKUHhnr-XWkRPtbV4XHHvE2n6VyeX7lQ5AF95FK~ImtFghbP9P06RJRsNd4xjP4lPSfTOMIaO3Xdxpzot9U3S2ZPvEUVuM~duA__&Key-Pair-Id=K1VGYTHIYLM9UM"
+        }
+      ],
+      "remove_lighting": true,
+      "consumed_credits": 10
+    }
+  }
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G036_salt_flat_timetrial__G036_salt_flat_timetrial_obj_005.json

@@ -0,0 +1,54 @@
+{
+  "submissions": {
+    "9956cf79926fdb17746204c9e2bc50e679487604f0e920105fc58895219e9be3": {
+      "endpoint": "/generation/text-to-model",
+      "reserved_credits": 30,
+      "status": "created",
+      "remote_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+      "response": {
+        "code": 0,
+        "status": "success",
+        "data": {
+          "type": "text_to_model",
+          "status": "queued",
+          "task_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d"
+        }
+      },
+      "reported_credits": 30.0
+    }
+  },
+  "results": {
+    "/tasks/96a8cac0-e8ec-41ed-a270-1caab04aea3d": {
+      "code": 0,
+      "status": "success",
+      "data": {
+        "type": "text_to_model",
+        "status": "success",
+        "progress": 100,
+        "input": {
+          "pbr": true,
+          "prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+          "texture": true,
+          "export_uv": true,
+          "face_limit": 8000,
+          "model_seed": 1040,
+          "texture_seed": 1040,
+          "model_version": "v3.1-20260211",
+          "smart_low_poly": true,
+          "texture_quality": "standard",
+          "geometry_quality": "standard",
+          "texture_alignment": "geometry"
+        },
+        "output": {
+          "model_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/96a8cac0-e8ec-41ed-a270-1caab04aea3d/tripo_pbr_model_96a8cac0-e8ec-41ed-a270-1caab04aea3d.glb?auth_key=1792223578-jdoqyjzy-0-089b561735ad1ab7717943583a9a2436",
+          "rendered_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/96a8cac0-e8ec-41ed-a270-1caab04aea3d/legacy_mesh.webp?auth_key=1792223578-craoschm-0-fdb7a9c1c980d7db24db13840edaa6d4",
+          "generated_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/96a8cac0-e8ec-41ed-a270-1caab04aea3d/text2image_96a8cac0-e8ec-41ed-a270-1caab04aea3d.jpeg?auth_key=1792223578-kqwdomor-0-acb7c232363c33a03585815ba5299c1f"
+        },
+        "task_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+        "created_at": "2026-10-16T07:49:06.261146Z",
+        "completed_at": "2026-10-16T07:52:54.511942Z",
+        "credits_consumed": 30.0
+      }
+    }
+  }
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py

@@ -0,0 +1,557 @@
+"""
+models/common/cloud_api.py
+
+Shared plumbing for closed-source ("cloud API") model wrappers — the part of
+Tripo / Meshy / Rodin / ElevenLabs / Kling wrappers that is identical no matter
+what the provider generates.
+
+Contract: `agent_skills/develop_harness/api_model_require.md` R9.
+This module owns R9.6 (submit → poll → download behind a blocking call),
+R9.7 (API key from the environment, at call time), R9.8 (response cache, so a
+re-run is not re-billed) and R9.9 (retry with backoff, retryable vs. terminal).
+
+It knows nothing about 3D, audio or video — only HTTP, money and failure modes.
+
+Dependencies: stdlib at import time; `requests` is imported lazily on first use
+so `test/harness/smoke.py` keeps working on a machine that does not have it.
+
+Usage:
+    from models.common import cloud_api
+
+    key = cloud_api.require_api_key(None, "TRIPO_API_KEY",
+                                    "https://platform.tripo3d.ai/api-keys")
+    client = cloud_api.CloudAPIClient("https://openapi.tripo3d.ai/v3", key)
+    data = client.request("POST", "/generation/text-to-model", json={...})
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Callable, Iterable, Optional
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+#: HTTP statuses worth retrying — transient by nature.
+RETRYABLE_STATUS: frozenset[int] = frozenset({408, 409, 425, 429, 500, 502, 503, 504})
+
+#: HTTP statuses that will never succeed on retry: bad request, auth, quota.
+TERMINAL_STATUS: frozenset[int] = frozenset({400, 401, 402, 403, 404, 405, 413, 415, 422})
+
+
+# ── Errors ────────────────────────────────────────────────────────────────────
+
+
+class CloudAPIError(RuntimeError):
+    """
+    Base class for every cloud-API failure.
+
+    Attributes:
+        status:   HTTP status code, when the failure came from a response.
+        task_id:  Provider task id, when one had already been created — keep it,
+                  a timed-out task usually finishes anyway and can be fetched
+                  later (`api_model_require.md` R9.6).
+        payload:  Decoded response body, truncated for readability.
+    """
+
+    retryable = False
+
+    def __init__(self, message: str, *, status: Optional[int] = None,
+                 task_id: Optional[str] = None, payload: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.task_id = task_id
+        self.payload = payload
+
+
+class CloudAPIAuthError(CloudAPIError):
+    """401 / 403 — the key is missing, wrong, or lacks the entitlement."""
+
+
+class CloudAPIQuotaError(CloudAPIError):
+    """402 or a provider-specific "insufficient credits" body. Terminal."""
+
+
+class CloudAPIRequestError(CloudAPIError):
+    """400 / 404 / 422 — the request itself is wrong. Terminal."""
+
+
+class CloudAPIServerError(CloudAPIError):
+    """5xx and connection-level failures. Retryable."""
+
+    retryable = True
+
+
+class CloudAPIRateLimitError(CloudAPIServerError):
+    """429 — retryable, honour `Retry-After` when present."""
+
+
+class CloudTaskFailed(CloudAPIError):
+    """The provider accepted the task and then reported failure."""
+
+
+class CloudTaskTimeout(CloudAPIError):
+    """The task did not reach a terminal state within `timeout` seconds."""
+
+
+# ── Credentials ───────────────────────────────────────────────────────────────
+
+
+def require_api_key(value: Optional[str], env_var: str, signup_url: str,
+                    *, who: str = "This model") -> str:
+    """
+    Resolve an API key, failing fast with an actionable message (R1.6 / R9.7).
+
+    Args:
+        value:      Explicit key passed to the constructor, or None.
+        env_var:    Environment variable to fall back to.
+        signup_url: Where a human gets a key.
+        who:        Name used in the error message.
+
+    Returns:
+        The key.
+
+    Raises:
+        CloudAPIAuthError: no key available.
+    """
+    key = value or os.environ.get(env_var)
+    if key:
+        return key.strip()
+    raise CloudAPIAuthError(
+        f"{who} needs an API key and none was found.\n"
+        f"  1. get one at {signup_url}\n"
+        f"  2. export {env_var}=<your key>          # never commit it\n"
+        f"     (or pass api_key=... to the constructor)"
+    )
+
+
+def redact(key: Optional[str]) -> str:
+    """Key fingerprint safe to put in a log line or `meta.json`."""
+    if not key:
+        return "<unset>"
+    return f"{key[:4]}…{key[-2:]} (len {len(key)})"
+
+
+# ── HTTP ───────���──────────────────────────────────────────────────────────────
+
+
+def _requests():
+    """Import `requests` lazily with an actionable message (R1.5 / R1.6)."""
+    try:
+        import requests  # noqa: PLC0415
+    except ImportError as e:  # pragma: no cover - environment dependent
+        raise ImportError(
+            "Cloud-API model wrappers need the `requests` package:\n"
+            "    bash scripts/asset_env_setup/cloud_api_install.sh\n"
+            "    # or simply: python -m pip install requests\n"
+            "(only needed for the API backends; the local-weight models and "
+            "test/harness/smoke.py do not import it.)"
+        ) from e
+    return requests
+
+
+def _truncate(payload: Any, limit: int = 600) -> Any:
+    text = payload if isinstance(payload, str) else json.dumps(payload, default=str)
+    return text if len(text) <= limit else text[:limit] + f"… (+{len(text) - limit} chars)"
+
+
+def classify_http_error(status: int, body: Any, *,
+                        task_id: Optional[str] = None) -> CloudAPIError:
+    """
+    Map an HTTP status onto the right exception class (R9.9).
+
+    The body is inspected too: providers happily answer 200/400 with a
+    "not enough credits" payload, which must not be retried.
+    """
+    text = _truncate(body)
+    low = str(text).lower()
+    # Providers phrase "you are out of money" in prose, and the status code alone
+    # does not distinguish it from a bad key: Tripo answers **403** with
+    # "You don't have enough credit to create this task". Matching the body first
+    # is what keeps "wrong key" and "no money" apart for the caller.
+    if any(s in low for s in ("insufficient", "enough credit", "enough credits",
+                              "out of credit", "purchase more credit",
+                              "quota exceeded", "no credits", "balance")):
+        return CloudAPIQuotaError(
+            f"HTTP {status}: out of credits — {text}", status=status,
+            task_id=task_id, payload=body)
+    if status in (401, 403):
+        return CloudAPIAuthError(
+            f"HTTP {status}: authentication rejected — {text}", status=status,
+            task_id=task_id, payload=body)
+    if status == 402:
+        return CloudAPIQuotaError(
+            f"HTTP {status}: payment required — {text}", status=status,
+            task_id=task_id, payload=body)
+    if status == 429:
+        return CloudAPIRateLimitError(
+            f"HTTP {status}: rate limited — {text}", status=status,
+            task_id=task_id, payload=body)
+    if status in TERMINAL_STATUS:
+        return CloudAPIRequestError(
+            f"HTTP {status}: request rejected — {text}", status=status,
+            task_id=task_id, payload=body)
+    if status in RETRYABLE_STATUS or status >= 500:
+        return CloudAPIServerError(
+            f"HTTP {status}: server error — {text}", status=status,
+            task_id=task_id, payload=body)
+    return CloudAPIError(
+        f"HTTP {status}: unexpected response — {text}", status=status,
+        task_id=task_id, payload=body)
+
+
+class CloudAPIClient:
+    """
+    Thin retrying HTTP client for one provider.
+
+    Args:
+        base_url:     Root of the API, without a trailing slash.
+        api_key:      Bearer token.
+        timeout:      Per-request socket timeout in seconds (not the task timeout).
+        max_retries:  Extra attempts after the first one, for retryable failures.
+        backoff:      Base of the exponential backoff, seconds.
+        auth_header:  Header name / value template, for providers that do not
+                      use `Authorization: Bearer <key>`.
+        user_agent:   Sent as-is; helps providers attribute traffic.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        *,
+        timeout: int = 60,
+        max_retries: int = 3,
+        backoff: float = 1.5,
+        auth_header: str = "Authorization",
+        auth_template: str = "Bearer {key}",
+        user_agent: str = "3AGameFactory/0.1 (+https://github.com/OpenDCAI/GameFactory-3A)",
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.backoff = backoff
+        self.auth_header = auth_header
+        self.auth_template = auth_template
+        self.user_agent = user_agent
+        self._session = None
+
+    # -- session ---------------------------------------------------------------
+
+    @property
+    def session(self):
+        """Lazily created `requests.Session` (kept alive across polls)."""
+        if self._session is None:
+            requests = _requests()
+            self._session = requests.Session()
+            self._session.headers.update({
+                self.auth_header: self.auth_template.format(key=self._api_key),
+                "User-Agent": self.user_agent,
+            })
+        return self._session
+
+    def close(self) -> None:
+        """Idempotent — safe after a failed construction and safe to call twice."""
+        if self._session is not None:
+            try:
+                self._session.close()
+            finally:
+                self._session = None
+
+    # -- requests --------------------------------------------------------------
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Optional[dict] = None,
+        files: Optional[dict] = None,
+        data: Optional[dict] = None,
+        params: Optional[dict] = None,
+        expect_json: bool = True,
+    ) -> Any:
+        """
+        Perform one API call, retrying retryable failures (R9.9).
+
+        Args:
+            method:      "GET" / "POST" / …
+            path:        Path appended to `base_url`, or a full URL.
+            json_body:   JSON payload.
+            files/data:  multipart payload (`requests` semantics).
+            params:      Query string.
+            expect_json: Parse the response as JSON; otherwise return `bytes`.
+
+        Returns:
+            Parsed JSON (dict / list) or raw `bytes`.
+
+        Raises:
+            CloudAPIError subclass — terminal errors immediately, retryable ones
+            after `max_retries` attempts.
+        """
+        requests = _requests()
+        url = path if path.startswith("http") else f"{self.base_url}/{path.lstrip('/')}"
+
+        last: Optional[CloudAPIError] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = self.session.request(
+                    method, url, json=json_body, files=files, data=data,
+                    params=params, timeout=self.timeout,
+                )
+            except (requests.ConnectionError, requests.Timeout) as e:
+                last = CloudAPIServerError(f"{method} {url} failed at transport level: {e}")
+            else:
+                if resp.ok:
+                    if not expect_json:
+                        return resp.content
+                    try:
+                        return resp.json()
+                    except ValueError as e:
+                        raise CloudAPIError(
+                            f"{method} {url} returned {resp.status_code} with a "
+                            f"non-JSON body: {_truncate(resp.text)}"
+                        ) from e
+                try:
+                    body: Any = resp.json()
+                except ValueError:
+                    body = resp.text
+                err = classify_http_error(resp.status_code, body)
+                if not err.retryable:
+                    raise err
+                last = err
+                retry_after = resp.headers.get("Retry-After")
+                if retry_after:
+                    try:
+                        time.sleep(min(float(retry_after), 60.0))
+                    except ValueError:
+                        pass
+
+            if attempt < self.max_retries:
+                delay = self.backoff * (2 ** attempt)
+                logger.warning("[cloud_api] %s %s attempt %d/%d failed (%s); retrying in %.1fs",
+                               method, url, attempt + 1, self.max_retries + 1, last, delay)
+                time.sleep(delay)
+
+        assert last is not None
+        raise last
+
+    def download(self, url: str, *, max_bytes: Optional[int] = None) -> bytes:
+        """
+        Fetch a generated artifact. Signed asset URLs are short-lived — call this
+        immediately after the task reports success.
+
+        Args:
+            url: Absolute URL from the task output.
+            max_bytes: Reject anything larger, so a wrong URL cannot fill a disk.
+
+        Returns:
+            The file content.
+        """
+        content = self.request("GET", url, expect_json=False)
+        if max_bytes is not None and len(content) > max_bytes:
+            raise CloudAPIError(
+                f"downloaded artifact is {len(content)} bytes, over the "
+                f"{max_bytes} byte limit: {url}")
+        if not content:
+            raise CloudAPIError(f"downloaded artifact is empty: {url}")
+        return content
+
+
+# ── Polling ───────────────────────────────────────────────────────────────────
+
+
+def poll_task(
+    fetch: Callable[[], dict],
+    *,
+    task_id: str,
+    timeout: float = 300.0,
+    poll_interval: float = 3.0,
+    done_states: Iterable[str],
+    failed_states: Iterable[str],
+    state_key: str = "status",
+    progress_key: str = "progress",
+    verbose: bool = False,
+) -> dict:
+    """
+    Block until a provider task reaches a terminal state (R9.6).
+
+    Args:
+        fetch:         Callable returning the decoded task object.
+        task_id:       Only used for messages — every error carries it.
+        timeout:       Wall-clock budget in seconds.
+        poll_interval: Seconds between polls.
+        done_states:   States meaning success (compared case-insensitively).
+        failed_states: States meaning failure.
+        state_key:     Field holding the state.
+        progress_key:  Field holding 0-100 progress, when the provider sends one.
+        verbose:       Print progress; otherwise only DEBUG logs (R3.7).
+
+    Returns:
+        The task object in its successful terminal state.
+
+    Raises:
+        CloudTaskFailed:  provider reported failure.
+        CloudTaskTimeout: budget exhausted; the task may still finish server-side,
+                          the error carries `task_id` so it can be fetched later.
+    """
+    done = {s.lower() for s in done_states}
+    failed = {s.lower() for s in failed_states}
+    deadline = time.time() + timeout
+    last_progress = -1
+
+    while True:
+        task = fetch()
+        state = str(task.get(state_key, "")).lower()
+        progress = task.get(progress_key)
+
+        if progress != last_progress:
+            last_progress = progress
+            logger.debug("[cloud_api] task %s: %s (%s%%)", task_id, state, progress)
+            if verbose:
+                print(f"[cloud_api] task {task_id}: {state} ({progress}%)")
+
+        if state in done:
+            return task
+        if state in failed:
+            raise CloudTaskFailed(
+                f"task {task_id} ended as {state!r}: {_truncate(task)}",
+                task_id=task_id, payload=task)
+
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            raise CloudTaskTimeout(
+                f"task {task_id} still {state!r} after {timeout:.0f}s. It may still "
+                f"finish server-side — query it with the task id above, or raise "
+                f"`timeout=` on the model.",
+                task_id=task_id, payload=task)
+        time.sleep(min(poll_interval, remaining))
+
+
+# ── Response cache ────────────────────────────────────────────────────────────
+
+
+def request_hash(payload: dict) -> str:
+    """
+    Stable sha256 over a request description (R9.8).
+
+    The payload must contain everything that changes the output — model version,
+    prompt, image bytes hash, every generation parameter, the output format.
+    Never put the API key in it.
+    """
+    canonical = json.dumps(payload, sort_keys=True, ensure_ascii=False, default=str)
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def bytes_hash(data: bytes) -> str:
+    """sha256 of a binary input, e.g. the reference image."""
+    return hashlib.sha256(data).hexdigest()
+
+
+class ResponseCache:
+    """
+    Content-addressed cache of generated artifacts.
+
+    A cloud call costs credits, so an identical request must never be sent twice
+    (R9.8). Layout::
+
+        <cache_dir>/<provider>/<hash>.<ext>        the artifact
+        <cache_dir>/<provider>/<hash>.meta.json    request description + task id
+
+    Args:
+        cache_dir: Root directory. `None` disables caching entirely.
+        provider:  Sub-directory name, so two providers never collide.
+    """
+
+    def __init__(self, cache_dir: Optional[str | Path], provider: str):
+        self.root = Path(cache_dir).expanduser() / provider if cache_dir else None
+        self.provider = provider
+
+    @property
+    def enabled(self) -> bool:
+        return self.root is not None
+
+    def _paths(self, key: str, ext: str) -> tuple[Path, Path]:
+        assert self.root is not None
+        return self.root / f"{key}.{ext}", self.root / f"{key}.meta.json"
+
+    def get(self, key: str, ext: str = "glb") -> Optional[bytes]:
+        """Cached artifact bytes, or None. Performs no network I/O, ever."""
+        if not self.enabled:
+            return None
+        blob, _ = self._paths(key, ext)
+        if blob.is_file() and blob.stat().st_size > 0:
+            logger.info("[cloud_api] cache hit (%s): %s", self.provider, blob.name)
+            return blob.read_bytes()
+        return None
+
+    def put(self, key: str, data: bytes, meta: dict, ext: str = "glb") -> Path:
+        """Store an artifact plus the request that produced it. Returns its path."""
+        if not self.enabled:
+            return Path()
+        blob, meta_path = self._paths(key, ext)
+        blob.parent.mkdir(parents=True, exist_ok=True)
+        blob.write_bytes(data)
+        meta_path.write_text(
+            json.dumps({**meta, "cache_key": key, "bytes": len(data)},
+                       indent=2, ensure_ascii=False, default=str),
+            encoding="utf-8",
+        )
+        return blob
+
+
+# ── Input encoding ────────────────────────────────────────────────────────────
+
+
+def image_to_png_bytes(image: Any) -> bytes:
+    """
+    Normalize an image input to PNG bytes.
+
+    Accepts a `PIL.Image.Image`, raw `bytes` (returned unchanged), or a
+    `np.ndarray`. Paths are rejected on purpose — `model_require.md` R3.2 says a
+    model takes the object, not a path.
+
+    Returns:
+        PNG-encoded bytes (RGBA preserved when present).
+    """
+    if isinstance(image, (bytes, bytearray)):
+        return bytes(image)
+    if isinstance(image, (str, Path)):
+        raise TypeError(
+            "models take an image object, not a path (model_require.md R3.2). "
+            "Open it in the operator: Image.open(path).convert('RGBA')"
+        )
+
+    from io import BytesIO  # noqa: PLC0415
+
+    from PIL import Image as PILImage  # noqa: PLC0415
+
+    if not isinstance(image, PILImage.Image):
+        try:
+            import numpy as np  # noqa: PLC0415
+        except ImportError:
+            np = None  # type: ignore[assignment]
+        if np is not None and isinstance(image, np.ndarray):
+            image = PILImage.fromarray(image)
+        else:
+            raise TypeError(
+                f"unsupported image type {type(image).__name__}; expected "
+                f"PIL.Image.Image, numpy.ndarray or bytes"
+            )
+
+    buf = BytesIO()
+    image.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def image_to_data_uri(image: Any, mime: str = "image/png") -> str:
+    """PNG data URI (`data:image/png;base64,…`) for providers that take one inline."""
+    import base64  # noqa: PLC0415
+
+    payload = base64.b64encode(image_to_png_bytes(image)).decode("ascii")
+    return f"data:{mime};base64,{payload}"

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py

@@ -0,0 +1,578 @@
+"""
+models/common/glb_utils.py
+
+Dependency-free inspection of binary glTF (`.glb`) buffers.
+
+Why this exists instead of `trimesh.load(...)`: the API wrappers must report the
+triangle count of what they just paid for (`api_model_require.md` R9.8), and
+that number has to be available on a CPU-only box with nothing but the stdlib
+installed. Parsing the JSON chunk of a GLB is enough for counting.
+
+`glb_summary` and `glb_triangle_count` read the JSON chunk only. `read_glb_mesh`
+decodes vertex data as well, because a generated part has to be *composed* with
+primitives rather than merely counted, and that needs its triangles in the same
+coordinate frame as everything else.
+
+Usage:
+    from models.common.glb_utils import glb_summary, read_glb_mesh
+    info = glb_summary(open("model.glb", "rb").read())
+    print(info["triangles"], info["materials"])
+
+    mesh = read_glb_mesh(open("part.glb", "rb").read())
+    print(len(mesh["positions"]), mesh["low"], mesh["high"])
+"""
+from __future__ import annotations
+
+import json
+import math
+import struct
+from typing import Any, Optional, Sequence
+
+GLB_MAGIC = b"glTF"
+
+#: glTF primitive mode 4 == TRIANGLES. Only triangle primitives are counted.
+_MODE_TRIANGLES = 4
+
+#: glTF componentType -> (struct format, byte size). Indices are allowed to be
+#: any of the unsigned types; positions are float in every file worth reading.
+_COMPONENT_TYPES: dict[int, tuple[str, int]] = {
+    5120: ("b", 1),   # BYTE
+    5121: ("B", 1),   # UNSIGNED_BYTE
+    5122: ("h", 2),   # SHORT
+    5123: ("H", 2),   # UNSIGNED_SHORT
+    5125: ("I", 4),   # UNSIGNED_INT
+    5126: ("f", 4),   # FLOAT
+}
+
+#: glTF accessor type -> component count.
+_TYPE_COUNTS: dict[str, int] = {
+    "SCALAR": 1, "VEC2": 2, "VEC3": 3, "VEC4": 4,
+    "MAT2": 4, "MAT3": 9, "MAT4": 16,
+}
+
+
+class GLBParseError(ValueError):
+    """The buffer is not a GLB we can read."""
+
+
+def is_glb(data: bytes) -> bool:
+    """True when `data` starts with the 12-byte GLB header."""
+    return len(data) >= 12 and data[:4] == GLB_MAGIC
+
+
+def glb_json_chunk(data: bytes) -> dict[str, Any]:
+    """
+    Return the parsed JSON chunk of a GLB.
+
+    Args:
+        data: Whole `.glb` file content.
+
+    Returns:
+        The glTF document as a dict.
+
+    Raises:
+        GLBParseError: bad magic, truncated file, or a missing JSON chunk.
+    """
+    if not is_glb(data):
+        raise GLBParseError(
+            f"not a GLB: expected magic {GLB_MAGIC!r}, got {data[:4]!r}"
+        )
+    if len(data) < 20:
+        raise GLBParseError(f"GLB truncated: {len(data)} bytes")
+
+    _magic, version, total_len = struct.unpack_from("<4sII", data, 0)
+    if total_len > len(data):
+        raise GLBParseError(
+            f"GLB header claims {total_len} bytes, buffer holds {len(data)}"
+        )
+
+    offset = 12
+    while offset + 8 <= len(data):
+        chunk_len, chunk_type = struct.unpack_from("<I4s", data, offset)
+        offset += 8
+        chunk = data[offset:offset + chunk_len]
+        offset += chunk_len
+        if chunk_type == b"JSON":
+            try:
+                return json.loads(chunk.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError) as e:
+                raise GLBParseError(f"GLB JSON chunk is not valid JSON: {e}") from e
+    raise GLBParseError(f"GLB (version {version}) has no JSON chunk")
+
+
+def glb_triangle_count(data: bytes) -> Optional[int]:
+    """
+    Triangle count of a GLB, or None when it cannot be determined.
+
+    Counts every triangle-mode primitive of every mesh once, i.e. the *asset's*
+    triangle budget, not the per-instance count after node duplication.
+
+    Returns:
+        int triangles, or None if the JSON chunk is unreadable.
+    """
+    try:
+        doc = glb_json_chunk(data)
+    except GLBParseError:
+        return None
+
+    accessors = doc.get("accessors", [])
+    total = 0
+    for mesh in doc.get("meshes", []):
+        for prim in mesh.get("primitives", []):
+            if prim.get("mode", _MODE_TRIANGLES) != _MODE_TRIANGLES:
+                continue
+            idx = prim.get("indices")
+            if idx is not None and idx < len(accessors):
+                count = accessors[idx].get("count", 0)
+            else:
+                pos = prim.get("attributes", {}).get("POSITION")
+                count = accessors[pos].get("count", 0) if pos is not None and pos < len(accessors) else 0
+            total += count // 3
+    return total
+
+
+def glb_summary(data: bytes) -> dict[str, Any]:
+    """
+    Cheap description of a GLB, for logs and `meta.json`.
+
+    Returns:
+        dict with keys:
+            bytes (int)            — buffer size
+            triangles (int | None) — see `glb_triangle_count`
+            meshes, materials, textures, images, nodes (int)
+            generator (str | None) — glTF `asset.generator`
+            error (str)            — present only when the JSON chunk is unreadable
+    """
+    out: dict[str, Any] = {"bytes": len(data)}
+    try:
+        doc = glb_json_chunk(data)
+    except GLBParseError as e:
+        out.update({"triangles": None, "error": str(e)})
+        return out
+
+    out.update({
+        "triangles": glb_triangle_count(data),
+        "meshes": len(doc.get("meshes", [])),
+        "materials": len(doc.get("materials", [])),
+        "textures": len(doc.get("textures", [])),
+        "images": len(doc.get("images", [])),
+        "nodes": len(doc.get("nodes", [])),
+        "generator": (doc.get("asset") or {}).get("generator"),
+    })
+    return out
+
+
+# --------------------------------------------------------------------------
+# Vertex decoding
+#
+# Needed to *compose* a generated part with primitives, as opposed to merely
+# reporting on it: composition means putting its triangles into the same
+# coordinate frame as the rest, and that requires reading them.
+# --------------------------------------------------------------------------
+
+
+def glb_binary_chunk(data: bytes) -> bytes:
+    """Return the BIN chunk of a GLB, or b"" when there is none."""
+    if not is_glb(data):
+        raise GLBParseError(f"not a GLB: got magic {data[:4]!r}")
+    offset = 12
+    while offset + 8 <= len(data):
+        chunk_len, chunk_type = struct.unpack_from("<I4s", data, offset)
+        offset += 8
+        if chunk_type == b"BIN\x00":
+            return data[offset:offset + chunk_len]
+        offset += chunk_len
+    return b""
+
+
+def _read_accessor(doc: dict[str, Any], binary: bytes, index: int) -> list[tuple]:
+    """Decode one accessor into a list of component tuples.
+
+    Honours ``byteStride``. Interleaved buffers are normal out of an
+    exporter, and reading one as tightly packed yields positions that are a
+    silent mixture of coordinates and normals — it parses, it renders, it is
+    garbage.
+    """
+
+    accessor = doc["accessors"][index]
+    component_type = accessor["componentType"]
+    if component_type not in _COMPONENT_TYPES:
+        raise GLBParseError(f"unsupported componentType {component_type}")
+    fmt, component_size = _COMPONENT_TYPES[component_type]
+    per_element = _TYPE_COUNTS[accessor["type"]]
+    count = accessor["count"]
+
+    view_index = accessor.get("bufferView")
+    if view_index is None:
+        # A sparse or zero-filled accessor. Legal, and not something a mesh
+        # we are about to weld into another asset should be relying on.
+        return [tuple([0] * per_element)] * count
+
+    view = doc["bufferViews"][view_index]
+    if view.get("buffer", 0) != 0:
+        raise GLBParseError("only single-buffer GLBs are supported")
+    base = view.get("byteOffset", 0) + accessor.get("byteOffset", 0)
+    packed = component_size * per_element
+    stride = view.get("byteStride") or packed
+
+    out: list[tuple] = []
+    element_format = "<" + fmt * per_element
+    for element in range(count):
+        start = base + element * stride
+        if start + packed > len(binary):
+            raise GLBParseError(
+                f"accessor {index} reads past the {len(binary)}-byte buffer"
+            )
+        out.append(struct.unpack_from(element_format, binary, start))
+    return out
+
+
+def _node_matrix(node: dict[str, Any]) -> list[float]:
+    """A node's local transform as a 16-float column-major matrix.
+
+    Handles both an explicit ``matrix`` and a TRS triple, since a file may use
+    either. Ignoring the transform looks like a modelling error: a mesh
+    authored Z-up whose node carries the -90 that stands it upright arrives on
+    its side, and the natural reaction is to rotate it back in the spec —
+    hard-coding a correction for something the file already stated.
+    """
+
+    if "matrix" in node:
+        return [float(value) for value in node["matrix"]]
+
+    tx, ty, tz = [float(value) for value in node.get("translation", (0, 0, 0))]
+    qx, qy, qz, qw = [float(value) for value in node.get("rotation", (0, 0, 0, 1))]
+    sx, sy, sz = [float(value) for value in node.get("scale", (1, 1, 1))]
+
+    # Quaternion to rotation matrix.
+    xx, yy, zz = qx * qx, qy * qy, qz * qz
+    xy, xz, yz = qx * qy, qx * qz, qy * qz
+    wx, wy, wz = qw * qx, qw * qy, qw * qz
+    rotation = (
+        (1 - 2 * (yy + zz), 2 * (xy + wz), 2 * (xz - wy)),
+        (2 * (xy - wz), 1 - 2 * (xx + zz), 2 * (yz + wx)),
+        (2 * (xz + wy), 2 * (yz - wx), 1 - 2 * (xx + yy)),
+    )
+    scale = (sx, sy, sz)
+    return [
+        rotation[0][0] * scale[0], rotation[0][1] * scale[0], rotation[0][2] * scale[0], 0.0,
+        rotation[1][0] * scale[1], rotation[1][1] * scale[1], rotation[1][2] * scale[1], 0.0,
+        rotation[2][0] * scale[2], rotation[2][1] * scale[2], rotation[2][2] * scale[2], 0.0,
+        tx, ty, tz, 1.0,
+    ]
+
+
+def _multiply(a: Sequence[float], b: Sequence[float]) -> list[float]:
+    """Column-major 4x4 product, applying `b` then `a`."""
+    out = [0.0] * 16
+    for column in range(4):
+        for row in range(4):
+            out[column * 4 + row] = sum(
+                a[k * 4 + row] * b[column * 4 + k] for k in range(4)
+            )
+    return out
+
+
+_IDENTITY = [1.0, 0, 0, 0, 0, 1.0, 0, 0, 0, 0, 1.0, 0, 0, 0, 0, 1.0]
+
+
+def read_glb_mesh(data: bytes) -> dict[str, Any]:
+    """Decode every triangle of a GLB into one flat, world-space mesh.
+
+    Walks the scene graph and applies each node's accumulated transform, so
+    the result is in the file's own world coordinates rather than in the
+    local frame of whichever mesh happened to be first.
+
+    The node hierarchy is deliberately *not* preserved. A part fetched from
+    a generator is one object as far as the composition is concerned — the
+    thing worth keeping addressable is the spec's part id, which the writer
+    attaches, and a generator's internal node names ("mesh_0", "Object_2")
+    are not names anything downstream can use.
+
+    Returns:
+        dict with ``positions`` and ``normals`` as lists of 3-tuples,
+        ``uvs`` as 2-tuples, ``indices`` as a flat list, ``low``/``high`` as
+        the axis-aligned bounds, and ``images`` / ``material_runs`` carrying
+        whatever textures the file brought with it. Normals are generated
+        per-face when the file omits them.
+
+    Textures come across because a generated part's whole contribution is
+    surface. Dropping them and letting the part inherit the spec's flat PBR
+    factors is consistent but throws away the thing that was paid for: the
+    stippling on a grip, the panel creases and decals on a car shell. That
+    needs three things travelling together — UVs per vertex, the image
+    bytes, and which triangles use which image — so ``material_runs``
+    records index ranges rather than a single material for the part.
+    """
+
+    doc = glb_json_chunk(data)
+    binary = glb_binary_chunk(data)
+    if not binary:
+        raise GLBParseError(
+            "the GLB has no BIN chunk, so its vertex data is external; "
+            "only self-contained GLBs can be composed"
+        )
+
+    positions: list[tuple[float, float, float]] = []
+    normals: list[tuple[float, float, float]] = []
+    uvs: list[tuple[float, float]] = []
+    indices: list[int] = []
+    material_runs: list[dict[str, Any]] = []
+
+    def add_mesh(mesh_index: int, matrix: Sequence[float]) -> None:
+        # The inverse transpose of the upper 3x3, for the normals. A non-uniform
+        # node scale makes the forward matrix wrong for them, and the symptom is
+        # lighting that reads as a modelling error rather than as a bad import.
+        normal_matrix = _inverse_transpose_3x3(matrix)
+
+        for primitive in doc["meshes"][mesh_index].get("primitives", []):
+            if primitive.get("mode", _MODE_TRIANGLES) != _MODE_TRIANGLES:
+                continue
+            attributes = primitive.get("attributes", {})
+            if "POSITION" not in attributes:
+                continue
+
+            local = _read_accessor(doc, binary, attributes["POSITION"])
+            base = len(positions)
+            for x, y, z in local:
+                positions.append((
+                    matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
+                    matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
+                    matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
+                ))
+
+            if "NORMAL" in attributes:
+                for nx, ny, nz in _read_accessor(doc, binary, attributes["NORMAL"]):
+                    tx = normal_matrix[0] * nx + normal_matrix[3] * ny + normal_matrix[6] * nz
+                    ty = normal_matrix[1] * nx + normal_matrix[4] * ny + normal_matrix[7] * nz
+                    tz = normal_matrix[2] * nx + normal_matrix[5] * ny + normal_matrix[8] * nz
+                    length = math.sqrt(tx * tx + ty * ty + tz * tz) or 1.0
+                    normals.append((tx / length, ty / length, tz / length))
+            else:
+                normals.extend([(0.0, 0.0, 0.0)] * len(local))
+
+            # UVs are per-vertex and must stay aligned with positions, so a
+            # primitive without them still contributes placeholders — a short
+            # UV list would silently shift every following part's texturing.
+            if "TEXCOORD_0" in attributes:
+                uvs.extend(
+                    (float(u), float(v))
+                    for u, v in _read_accessor(doc, binary, attributes["TEXCOORD_0"])
+                )
+            else:
+                uvs.extend([(0.0, 0.0)] * len(local))
+
+            if "indices" in primitive and primitive["indices"] is not None:
+                local_indices = [
+                    value[0] for value in
+                    _read_accessor(doc, binary, primitive["indices"])
+                ]
+            else:
+                local_indices = list(range(len(local)))
+
+            run_start = len(indices)
+            indices.extend(base + value for value in local_indices)
+            material_runs.append({
+                "start": run_start,
+                "count": len(local_indices),
+                "material": primitive.get("material"),
+            })
+
+    def walk(node_index: int, parent: Sequence[float]) -> None:
+        node = doc["nodes"][node_index]
+        matrix = _multiply(parent, _node_matrix(node))
+        if node.get("mesh") is not None:
+            add_mesh(node["mesh"], matrix)
+        for child in node.get("children", ()):
+            walk(child, matrix)
+
+    scenes = doc.get("scenes") or []
+    scene = scenes[doc.get("scene", 0)] if scenes else None
+    roots = scene.get("nodes", ()) if scene else range(len(doc.get("nodes", [])))
+    for root in roots:
+        walk(root, _IDENTITY)
+
+    if not positions:
+        raise GLBParseError("the GLB contains no triangle geometry")
+
+    # Fill in any face normals the file left out, so a consumer never has to
+    # ask whether normals are present.
+    _fill_missing_normals(positions, normals, indices)
+
+    low = tuple(min(point[axis] for point in positions) for axis in range(3))
+    high = tuple(max(point[axis] for point in positions) for axis in range(3))
+    return {
+        "positions": positions,
+        "normals": normals,
+        "uvs": uvs,
+        "indices": indices,
+        "triangles": len(indices) // 3,
+        "low": low,
+        "high": high,
+        "material_runs": material_runs,
+        "materials": _read_materials(doc, binary),
+        "has_uvs": any(u != 0.0 or v != 0.0 for u, v in uvs),
+    }
+
+
+def _read_materials(doc: dict[str, Any], binary: bytes) -> list[dict[str, Any]]:
+    """Each material's PBR factors, its base-colour image and its MR image.
+
+    Base colour and metallic-roughness. Not the normal or occlusion maps:
+    those would give the composed asset a texture set the primitives beside it
+    lack, and a car body with a normal map next to a flat-shaded spoiler reads
+    as two assets. Metallic-roughness is different in kind — it is not detail
+    on top of a surface, it is *which surface it is*.
+
+    Taking the map is what makes the factors trustworthy. An exporter that puts
+    those channels in a texture leaves the factors at glTF's default ``1.0`` to
+    multiply it, so the two only mean anything together. This function used to
+    take the colour alone and substitute dielectric defaults (``0.0``/``0.55``)
+    on the grounds that inherited factors would render a polymer grip as
+    sandblasted steel — true, but it threw away the answer to keep from
+    guessing wrong. Plate armour came out as grey plastic: every generated
+    piece of the knight had ``metallicFactor 1.0`` and an MR map in the file,
+    and both were discarded.
+
+    ``factors_from`` is still recorded, because a material with no map at all
+    still has to fall back and a caller needs to know which happened.
+    """
+
+    out: list[dict[str, Any]] = []
+    images = doc.get("images", [])
+    textures = doc.get("textures", [])
+    views = doc.get("bufferViews", [])
+
+    def image_bytes(reference: dict[str, Any]) -> tuple[bytes | None, str | None]:
+        index = reference.get("index")
+        if index is None or index >= len(textures):
+            return None, None
+        image_index = textures[index].get("source")
+        if image_index is None or image_index >= len(images):
+            return None, None
+        image = images[image_index]
+        view_index = image.get("bufferView")
+        if view_index is not None and view_index < len(views):
+            view = views[view_index]
+            start = view.get("byteOffset", 0)
+            return (
+                bytes(binary[start:start + view["byteLength"]]),
+                image.get("mimeType") or "image/png",
+            )
+        if str(image.get("uri", "")).startswith("data:"):
+            # A data URI is legal and some exporters emit one even in a GLB.
+            # Decoded here so the caller never has to care which form was used.
+            import base64
+
+            header, _, payload = image["uri"].partition(",")
+            return (
+                base64.b64decode(payload),
+                header.split(":")[1].split(";")[0] if ":" in header
+                else "image/png",
+            )
+        return None, None
+
+    for material in doc.get("materials", []):
+        pbr = material.get("pbrMetallicRoughness") or {}
+        colour_image, colour_mime = image_bytes(pbr.get("baseColorTexture") or {})
+        mr_image, mr_mime = image_bytes(
+            pbr.get("metallicRoughnessTexture") or {})
+
+        if mr_image is not None:
+            # The map is coming with us, so the factors mean what they say:
+            # they scale it. glTF's default is 1.0 for exactly this case.
+            metallic = float(pbr.get("metallicFactor", 1.0))
+            roughness = float(pbr.get("roughnessFactor", 1.0))
+            provenance = "file"
+        elif (pbr.get("metallicRoughnessTexture") or {}).get("index") is not None:
+            # A map is declared but its bytes could not be read. Falling back
+            # to dielectric defaults, because inheriting factors written to
+            # scale a map we do not have renders a polymer grip as steel.
+            metallic, roughness, provenance = 0.0, 0.55, "assumed"
+        else:
+            metallic = float(pbr.get("metallicFactor", 1.0))
+            roughness = float(pbr.get("roughnessFactor", 1.0))
+            provenance = "file"
+
+        out.append({
+            "name": material.get("name") or "",
+            "baseColor": [
+                float(value)
+                for value in pbr.get("baseColorFactor", [1.0, 1.0, 1.0, 1.0])
+            ],
+            "metallic": metallic,
+            "roughness": roughness,
+            "factors_from": provenance,
+            "image": colour_image,
+            "mimeType": colour_mime,
+            "mrImage": mr_image,
+            "mrMimeType": mr_mime,
+        })
+    return out
+
+
+def _inverse_transpose_3x3(matrix: Sequence[float]) -> list[float]:
+    """Inverse transpose of a column-major 4x4's rotation/scale block."""
+    a = (matrix[0], matrix[1], matrix[2])
+    b = (matrix[4], matrix[5], matrix[6])
+    c = (matrix[8], matrix[9], matrix[10])
+    determinant = (
+        a[0] * (b[1] * c[2] - b[2] * c[1])
+        - a[1] * (b[0] * c[2] - b[2] * c[0])
+        + a[2] * (b[0] * c[1] - b[1] * c[0])
+    )
+    if abs(determinant) < 1e-20:
+        return [1.0, 0, 0, 0, 1.0, 0, 0, 0, 1.0]
+    # cofactor / determinant, already the inverse transpose.
+    return [
+        (b[1] * c[2] - b[2] * c[1]) / determinant,
+        (b[2] * c[0] - b[0] * c[2]) / determinant,
+        (b[0] * c[1] - b[1] * c[0]) / determinant,
+        (a[2] * c[1] - a[1] * c[2]) / determinant,
+        (a[0] * c[2] - a[2] * c[0]) / determinant,
+        (a[1] * c[0] - a[0] * c[1]) / determinant,
+        (a[1] * b[2] - a[2] * b[1]) / determinant,
+        (a[2] * b[0] - a[0] * b[2]) / determinant,
+        (a[0] * b[1] - a[1] * b[0]) / determinant,
+    ]
+
+
+def _fill_missing_normals(
+    positions: list[tuple[float, float, float]],
+    normals: list[tuple[float, float, float]],
+    indices: list[int],
+) -> None:
+    """Replace zero-length normals with the area-weighted face average."""
+
+    missing = [
+        index for index, normal in enumerate(normals)
+        if normal[0] == 0.0 and normal[1] == 0.0 and normal[2] == 0.0
+    ]
+    if not missing:
+        return
+
+    accumulated = {index: [0.0, 0.0, 0.0] for index in missing}
+    needed = set(missing)
+    for triangle in range(len(indices) // 3):
+        ia, ib, ic = indices[triangle * 3:triangle * 3 + 3]
+        if not (ia in needed or ib in needed or ic in needed):
+            continue
+        pa, pb, pc = positions[ia], positions[ib], positions[ic]
+        e1 = (pb[0] - pa[0], pb[1] - pa[1], pb[2] - pa[2])
+        e2 = (pc[0] - pa[0], pc[1] - pa[1], pc[2] - pa[2])
+        cross = (
+            e1[1] * e2[2] - e1[2] * e2[1],
+            e1[2] * e2[0] - e1[0] * e2[2],
+            e1[0] * e2[1] - e1[1] * e2[0],
+        )
+        for index in (ia, ib, ic):
+            if index in accumulated:
+                for axis in range(3):
+                    accumulated[index][axis] += cross[axis]
+
+    for index, vector in accumulated.items():
+        length = math.sqrt(sum(value * value for value in vector))
+        normals[index] = (
+            (vector[0] / length, vector[1] / length, vector[2] / length)
+            if length > 1e-20 else (0.0, 1.0, 0.0)
+        )

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py

@@ -0,0 +1,463 @@
+"""
+models/gen_3d_object/meshy_model.py
+
+MeshyModel — wrapper around Meshy's cloud 3D-generation API (image-to-3D and
+text-to-3D), producing GLB / FBX / OBJ / USDZ / STL.
+
+Reference: https://docs.meshy.ai/  (base https://api.meshy.ai)
+
+Second backend for the `gen_3d_object` slot. Its `infer` / `infer_and_save`
+signatures are identical to `TripoModel`'s and positionally identical to
+`Trellis2Model`'s, so `Gen3DObjectOperator` dispatches on class name alone
+(model_require.md R6).
+
+CONTRACT DEVIATIONS (model_require.md targets local-weight models; the rules that
+replace it live in agent_skills/develop_harness/api_model_require.md):
+  C1  R2.1/R2.2 → R9.1  `model_path` carries a *model version id* ("meshy-6").
+  C2  R2.3      → R9.2  `device` accepted for interface parity and ignored.
+  C3  R3.6/R5.5 → R9.3  no @torch.no_grad(); torch is not involved.
+  C4  R4.1-R4.3 → R9.4  `unload()` is a no-op that closes the HTTP session.
+  C5  R3.3/R3.4 → R9.5  `seed` is forwarded for text-to-3D only, where the API
+                        accepts it; image-to-3D has no seed. Reproducibility is
+                        NOT guaranteed server-side and is never faked locally.
+  C6  R3.1      → R9.6  task-based API (submit → poll → download); `infer()`
+                        blocks until completion or `timeout` (default 300 s).
+                        Text-to-3D runs two tasks (preview → refine) when a
+                        texture is requested; both ids are logged.
+  C7  R1.2             uses the documented `infer_and_save(..., output_path)`
+                        exception; the bytes-returning `infer()` exists alongside.
+  C8  (new)     → R9.8  `cache_dir` prevents re-billing an identical request.
+  C9  (new)     → R9.9  `max_retries` + exponential backoff; retryable and
+                        terminal failures are split.
+
+Environment:
+    MESHY_API_KEY   required at the first infer() call, not at construction.
+                    Get one at https://www.meshy.ai/api  (a `msy_dummy_...`
+                    test-mode key returns canned assets without spending credits).
+    MESHY_API_BASE  optional override of the API root.
+    `pip install requests` is needed for the API backends only.
+
+Usage:
+    from models.gen_3d_object.meshy_model import MeshyModel
+    model = MeshyModel(model_path="meshy-6", output_format="fbx")
+    path = model.infer_and_save(image, output_path="out/model.fbx", seed=42)
+"""
+from __future__ import annotations
+
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from models.common import cloud_api
+from models.common.glb_utils import glb_summary
+
+logger = logging.getLogger(__name__)
+
+SIGNUP_URL = "https://www.meshy.ai/api"
+
+DEFAULT_API_BASE = "https://api.meshy.ai"
+
+#: Short names accepted for `model_path`. Unknown values pass through untouched.
+MODEL_ALIASES: dict[str, str] = {
+    "meshy": "meshy-6",
+    "meshy-6-text-to-3d": "meshy-6",
+    "meshy-6-image-to-3d": "meshy-6",
+    "meshy-5-text-to-3d": "meshy-5",
+    "meshy-5-image-to-3d": "meshy-5",
+}
+
+DEFAULT_MODEL = "meshy-6"
+
+DONE_STATES = ("succeeded", "success", "completed")
+FAILED_STATES = ("failed", "canceled", "cancelled", "expired")
+
+#: Meshy rejects a target_polycount outside this range with a 400 (terminal).
+POLYCOUNT_RANGE = (100, 300_000)
+
+#: Formats the API can return directly, i.e. keys of `model_urls`.
+SUPPORTED_FORMATS = ("glb", "fbx", "obj", "usdz", "stl", "mtl", "3mf")
+
+
+class MeshyModel:
+    """
+    Cloud image-to-3D / text-to-3D through Meshy.
+
+    Args:
+        model_path: [C1] Meshy `ai_model` id ("meshy-6", "meshy-5", "latest"),
+                    or an alias from `MODEL_ALIASES`.
+        device:     [C2] Accepted for interface parity, ignored. "cpu" is fine.
+        api_key:    Explicit key; defaults to `$MESHY_API_KEY`, read at first call.
+        timeout:    [C6] Seconds to wait for one generation task (each stage of
+                    the text-to-3D preview → refine chain gets the full budget).
+        poll_interval: Seconds between status polls.
+        max_retries: [C9] Extra attempts for retryable HTTP failures.
+        cache_dir:  [C8] Directory for the response cache. None disables it.
+        output_format: Any of `SUPPORTED_FORMATS`; picked out of `model_urls`.
+        low_poly:   [B4.3] Sets `model_type="lowpoly"`, i.e. the service produces
+                    a low-poly mesh instead of us decimating one locally.
+        texture / enable_pbr / topology / should_remesh:
+                    Forwarded to the generation endpoints.
+        refine:     Text-to-3D only. Meshy's preview stage returns an untextured
+                    mesh; the refine stage textures it and costs extra credits.
+                    Ignored when `texture=False`.
+        api_base:   Override the API root (defaults to `$MESHY_API_BASE`).
+        verbose:    Print task progress; off by default (R3.7).
+    """
+
+    PROVIDER = "meshy"
+
+    def __init__(
+        self,
+        model_path: str = DEFAULT_MODEL,
+        device: str = "cuda",
+        *,
+        api_key: Optional[str] = None,
+        # Measured: one image-to-3D with PBR textures took 283 s here, and the
+        # Tripo backend took 601 s for the same job. Timing out does not refund
+        # the credits, so the default errs long; the error carries the task_id.
+        timeout: int = 1800,
+        poll_interval: float = 3.0,
+        max_retries: int = 3,
+        cache_dir: Optional[str] = None,
+        output_format: str = "glb",
+        low_poly: bool = False,
+        texture: bool = True,
+        enable_pbr: bool = True,
+        topology: str = "triangle",
+        should_remesh: Optional[bool] = None,
+        refine: bool = True,
+        api_base: Optional[str] = None,
+        http_timeout: int = 60,
+        verbose: bool = False,
+        **model_specific: Any,
+    ):
+        # [CONTRACT-DEVIATION C1] model_path is a version id, not a weight location.
+        # [CONTRACT-DEVIATION C2] device accepted for interface parity, ignored.
+        self.model_path = MODEL_ALIASES.get(str(model_path).lower(), model_path)
+        self.device = device
+
+        # R2.4 — store everything before anything loads.
+        self.api_key = api_key
+        self.timeout = timeout
+        self.poll_interval = poll_interval
+        self.max_retries = max_retries
+        self.cache_dir = cache_dir
+        self.output_format = output_format.lower().lstrip(".")
+        self.low_poly = low_poly
+        self.texture = texture
+        self.enable_pbr = enable_pbr
+        self.topology = topology
+        self.should_remesh = should_remesh
+        self.refine = refine
+        self.api_base = (api_base or os.environ.get("MESHY_API_BASE")
+                         or DEFAULT_API_BASE)
+        self.http_timeout = http_timeout
+        self.verbose = verbose
+        self.model_specific = model_specific
+
+        if self.output_format not in SUPPORTED_FORMATS:
+            raise ValueError(
+                f"output_format={self.output_format!r} is not one of "
+                f"{SUPPORTED_FORMATS}. Meshy returns these directly in model_urls."
+            )
+
+        self._client: Optional[cloud_api.CloudAPIClient] = None
+        self._cache = cloud_api.ResponseCache(cache_dir, self.PROVIDER)
+
+        #: Record of the most recent **real** call — see `TripoModel.last_call_info`.
+        self.last_call_info: dict[str, Any] = {}
+
+    # ── plumbing ──────────────────────────────────────────────────────────────
+
+    @property
+    def client(self) -> cloud_api.CloudAPIClient:
+        """HTTP client, created on first use. [R9.7] The key is resolved here."""
+        if self._client is None:
+            key = cloud_api.require_api_key(
+                self.api_key, "MESHY_API_KEY", SIGNUP_URL, who="MeshyModel")
+            self._client = cloud_api.CloudAPIClient(
+                self.api_base, key,
+                timeout=self.http_timeout,
+                max_retries=self.max_retries,
+            )
+        return self._client
+
+    def unload(self) -> None:
+        """[C4] Close the HTTP session. Idempotent, and safe before any call."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    close = unload
+
+    @staticmethod
+    def _task_id_of(resp: Any) -> str:
+        """Meshy answers a creation call with `{"result": "<task id>"}`."""
+        if isinstance(resp, dict):
+            for key in ("result", "id", "task_id"):
+                value = resp.get(key)
+                if isinstance(value, str) and value:
+                    return value
+        raise cloud_api.CloudAPIError(
+            f"Meshy accepted the request but returned no task id: {resp!r}")
+
+    def _fetch_task(self, endpoint: str, task_id: str) -> dict:
+        task = self.client.request("GET", f"{endpoint}/{task_id}")
+        if not isinstance(task, dict):
+            raise cloud_api.CloudAPIError(
+                f"unexpected task payload for {task_id}: {task!r}", task_id=task_id)
+        return task
+
+    def _model_url(self, task: dict) -> str:
+        """URL of the requested format, with an actionable message when absent."""
+        urls = task.get("model_urls") or {}
+        url = urls.get(self.output_format)
+        if isinstance(url, str) and url.startswith("http"):
+            return url
+        raise cloud_api.CloudAPIError(
+            f"task {task.get('id')} finished but has no {self.output_format!r} "
+            f"URL. Available: {sorted(urls)}. Set output_format to one of those.",
+            task_id=task.get("id"), payload=task)
+
+    def _clamp_polycount(self, value: Optional[int]) -> Optional[int]:
+        """
+        Keep `target_polycount` inside the documented range.
+
+        `Gen3DObjectOperator` forwards TRELLIS.2's default of 1_000_000, which
+        Meshy rejects with a terminal 400. Clamping (loudly) keeps the operator
+        interchangeable (R6) instead of making the caller special-case backends.
+        """
+        if value is None:
+            return None
+        low, high = POLYCOUNT_RANGE
+        clamped = max(low, min(int(value), high))
+        if clamped != int(value):
+            logger.warning("[meshy] target_polycount %s clamped to %s (API range %s-%s)",
+                           value, clamped, low, high)
+        return clamped
+
+    # ── inference ─────────────────────────────────────────────────────────────
+
+    def infer(
+        self,
+        image: Any = None,
+        seed: int = 42,
+        decimation_target: Optional[int] = None,
+        texture_size: Optional[int] = None,
+        *,
+        prompt: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        image_url: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        **provider_kwargs: Any,
+    ) -> bytes:
+        """
+        Generate one 3D asset and return the model file bytes.
+
+        Args:
+            image: Reference image as `PIL.Image.Image`, `np.ndarray` or PNG
+                   `bytes` — sent inline as a base64 data URI. Not a path (R3.2).
+            seed: [C5] Forwarded for text-to-3D only; image-to-3D has no seed
+                   parameter. Reproducibility is not guaranteed.
+            decimation_target: Target face count → `target_polycount`, clamped to
+                   the API's 100-300000 range.
+            texture_size: Accepted for signature parity with `Trellis2Model` and
+                   **ignored** — Meshy exposes no texture resolution parameter.
+            prompt: Text prompt for text-to-3D. [A4 decision] Same rationale as
+                   `TripoModel`: keeps text-to-3D reachable without a second slot.
+            negative_prompt: Sent as `texture_prompt`'s counterpart is absent in
+                   the API — rejected explicitly rather than silently dropped.
+            image_url: Publicly reachable image URL, used instead of the data URI.
+            verbose: Override the constructor's verbosity for this call.
+            **provider_kwargs: Merged into the request body verbatim.
+
+        Returns:
+            The model file as `bytes`, in `output_format`.
+
+        Raises:
+            CloudAPIAuthError / CloudAPIQuotaError / CloudTaskFailed /
+            CloudTaskTimeout — see `models/common/cloud_api.py`.
+        """
+        verbose = self.verbose if verbose is None else verbose
+        if image is None and image_url is None and not prompt:
+            raise ValueError(
+                "MeshyModel.infer needs an image (`image=` / `image_url=`) or a "
+                "text `prompt=`; got neither.")
+        if negative_prompt:
+            raise ValueError(
+                "Meshy has no negative_prompt parameter. Fold the constraint into "
+                "`prompt`, or use TripoModel which supports it.")
+        if texture_size is not None:
+            logger.debug("[meshy] texture_size=%s ignored; the API has no equivalent",
+                         texture_size)
+
+        polycount = self._clamp_polycount(decimation_target)
+        use_image = image is not None or image_url is not None
+
+        payload: dict[str, Any] = {
+            "ai_model": self.model_path,
+            "model_type": "lowpoly" if self.low_poly else "standard",
+            "topology": self.topology,
+        }
+        if polycount is not None:
+            payload["target_polycount"] = polycount
+        if self.should_remesh is not None:
+            payload["should_remesh"] = self.should_remesh
+
+        if use_image:
+            payload["should_texture"] = self.texture
+            payload["enable_pbr"] = self.enable_pbr
+        else:
+            payload["mode"] = "preview"
+            payload["prompt"] = prompt
+            # [CONTRACT-DEVIATION C5] accepted by the text endpoint only.
+            payload["seed"] = int(seed)
+        payload.update(provider_kwargs)
+
+        # [C8] Everything that changes the output goes into the key; the image is
+        # represented by its hash, and the API key never appears.
+        png = cloud_api.image_to_png_bytes(image) if image is not None else None
+        cache_key = cloud_api.request_hash({
+            "provider": self.PROVIDER,
+            "payload": payload,
+            "image_sha256": cloud_api.bytes_hash(png) if png else None,
+            "image_url": image_url,
+            "refine": self.refine and self.texture and not use_image,
+            "output_format": self.output_format,
+        })
+        cached = self._cache.get(cache_key, ext=self.output_format)
+        if cached is not None:
+            self.last_call_info = {
+                "provider": self.PROVIDER, "cached": True, "cache_key": cache_key,
+                "bytes": len(cached),
+                **(glb_summary(cached) if self.output_format == "glb" else {}),
+            }
+            return cached
+
+        t0 = time.time()
+        task_ids: list[str] = []
+
+        if use_image:
+            endpoint = "/openapi/v1/image-to-3d"
+            payload["image_url"] = (
+                image_url if png is None else cloud_api.image_to_data_uri(image))
+            task = self._submit_and_wait(endpoint, payload, verbose=verbose,
+                                         task_ids=task_ids)
+        else:
+            endpoint = "/openapi/v2/text-to-3d"
+            task = self._submit_and_wait(endpoint, payload, verbose=verbose,
+                                         task_ids=task_ids)
+            if self.texture and self.refine:
+                # [C6] Preview geometry is untextured; refine is a second billed
+                # task that paints it. Skip with texture=False or refine=False.
+                refine_payload = {
+                    "mode": "refine",
+                    "preview_task_id": task_ids[-1],
+                    "ai_model": self.model_path,
+                    "enable_pbr": self.enable_pbr,
+                }
+                task = self._submit_and_wait(endpoint, refine_payload,
+                                             verbose=verbose, task_ids=task_ids)
+
+        data = self.client.download(self._model_url(task))
+        elapsed = time.time() - t0
+
+        info = glb_summary(data) if self.output_format == "glb" else {"bytes": len(data)}
+        self.last_call_info = {
+            "provider": self.PROVIDER,
+            "model": self.model_path,
+            "task_id": task_ids[-1],
+            "task_ids": task_ids,
+            "elapsed_sec": round(elapsed, 2),
+            "credits": task.get("credits_consumed", task.get("credits")),
+            "cached": False,
+            "cache_key": cache_key,
+            "format": self.output_format,
+            # The provider's own render of what it produced. Recording the URL
+            # (rather than downloading it here) keeps the model out of artifact
+            # placement (R1.2) while giving the caller a free visual check —
+            # "the asset exists" and "the asset is what was asked for" are
+            # different claims, and only a picture settles the second one.
+            "preview_url": task.get("thumbnail_url"),
+            **info,
+        }
+        # R9.8 — one line per billed call.
+        logger.info(
+            "[meshy] task=%s model=%s %.1fs credits=%s triangles=%s bytes=%s",
+            task_ids[-1], self.model_path, elapsed, self.last_call_info.get("credits"),
+            info.get("triangles"), len(data),
+        )
+        if verbose:
+            print(f"[meshy] {self.last_call_info}")
+
+        self._cache.put(cache_key, data, {
+            "provider": self.PROVIDER, "payload": payload,
+            **{k: v for k, v in self.last_call_info.items() if k != "cache_key"},
+        }, ext=self.output_format)
+        return data
+
+    def _submit_and_wait(self, endpoint: str, payload: dict, *,
+                         verbose: bool, task_ids: list[str]) -> dict:
+        """Create one task on `endpoint`, poll it to a terminal state, return it."""
+        created = self.client.request("POST", endpoint, json_body=payload)
+        task_id = self._task_id_of(created)
+        task_ids.append(task_id)
+        if verbose:
+            print(f"[meshy] task {task_id} submitted ({endpoint}, "
+                  f"mode={payload.get('mode', 'image')})")
+        return cloud_api.poll_task(
+            lambda: self._fetch_task(endpoint, task_id),
+            task_id=task_id,
+            timeout=self.timeout,
+            poll_interval=self.poll_interval,
+            done_states=DONE_STATES,
+            failed_states=FAILED_STATES,
+            verbose=verbose,
+        )
+
+    def infer_and_save(
+        self,
+        image: Any = None,
+        output_path: Optional[str] = None,
+        seed: int = 42,
+        decimation_target: Optional[int] = None,
+        texture_size: Optional[int] = None,
+        *,
+        prompt: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        image_url: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        **provider_kwargs: Any,
+    ) -> str:
+        """
+        [C7] The documented R1.2 exception: run `infer()` and write the result.
+
+        The path comes **in** from the caller and is never derived here.
+
+        Args:
+            output_path: Destination file. Parent directories are created.
+            (everything else: see `infer`)
+
+        Returns:
+            `str(output_path)`.
+        """
+        if not output_path:
+            raise ValueError("output_path is required (model_require.md R1.2)")
+        data = self.infer(
+            image, seed, decimation_target, texture_size,
+            prompt=prompt, negative_prompt=negative_prompt, image_url=image_url,
+            verbose=verbose, **provider_kwargs,
+        )
+        out = Path(output_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(data)
+        return str(out)
+
+    # ── account ───────────────────────────────────────────────────────────────
+
+    def balance(self) -> dict:
+        """Remaining credits: ``{"balance": int}``. Cheap and unbilled."""
+        resp = self.client.request("GET", "/openapi/v1/balance")
+        return resp if isinstance(resp, dict) else {"balance": resp}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py

@@ -0,0 +1,532 @@
+"""
+models/gen_3d_object/tripo_model.py
+
+TripoModel — wrapper around Tripo3D's cloud 3D-generation API (image-to-3D and
+text-to-3D), producing a GLB.
+
+Reference: https://developers.tripo3d.ai/  (v3 API, base https://openapi.tripo3d.ai/v3)
+
+CONTRACT DEVIATIONS (model_require.md targets local-weight models; the rules that
+replace it live in agent_skills/develop_harness/api_model_require.md):
+  C1  R2.1/R2.2 → R9.1  `model_path` carries a *model version id*
+                        ("v3.1-20260211"), not a weight location.
+  C2  R2.3      → R9.2  `device` accepted for interface parity and ignored.
+  C3  R3.6/R5.5 → R9.3  no @torch.no_grad(); torch is not involved.
+  C4  R4.1-R4.3 → R9.4  `unload()` is a no-op that closes the HTTP session.
+  C5  R3.3/R3.4 → R9.5  `seed` is forwarded as model_seed/texture_seed when the
+                        provider accepts it; server-side reproducibility is NOT
+                        guaranteed and is never faked locally.
+  C6  R3.1      → R9.6  task-based API (submit → poll → download); `infer()`
+                        blocks until completion or `timeout` (default 300 s).
+                        A timeout error carries the `task_id`.
+  C7  R1.2             uses the documented `infer_and_save(..., output_path)`
+                        exception; the bytes-returning `infer()` exists alongside.
+  C8  (new)     → R9.8  `cache_dir` prevents re-billing an identical request.
+  C9  (new)     → R9.9  `max_retries` + exponential backoff; retryable (5xx/429/
+                        transport) and terminal (400/401/402) failures are split.
+
+Environment:
+    TRIPO_API_KEY   required at the first infer() call, not at construction.
+                    Get one at https://platform.tripo3d.ai/api-keys
+    TRIPO_API_BASE  optional override of the API root.
+    `pip install requests` is needed for the API backends only.
+
+Usage:
+    from models.gen_3d_object.tripo_model import TripoModel
+    model = TripoModel(model_path="v3.1-20260211")
+    path = model.infer_and_save(image, output_path="out/model.glb", seed=42)
+    print(model.last_call_info)   # task_id, elapsed, credits, triangles
+"""
+from __future__ import annotations
+
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from models.common import cloud_api
+from models.common.glb_utils import glb_summary
+
+logger = logging.getLogger(__name__)
+
+#: Where a human gets a key. Quoted verbatim in the fail-fast message (R1.6).
+SIGNUP_URL = "https://platform.tripo3d.ai/api-keys"
+
+DEFAULT_API_BASE = "https://openapi.tripo3d.ai/v3"
+
+#: Short names accepted for `model_path`, mapped to the ids the API expects.
+#: Unknown values are passed through untouched, so a version released after this
+#: file was written still works without a code change.
+MODEL_ALIASES: dict[str, str] = {
+    "tripo": "v3.1-20260211",
+    "tripo-v3.1": "v3.1-20260211",
+    "v3.1": "v3.1-20260211",
+    "tripo-v3.0": "v3.0-20250812",
+    "v3.0": "v3.0-20250812",
+    "tripo-v2.5": "v2.5-20250123",
+    "v2.5": "v2.5-20250123",
+    # P series — natively low-poly, the cheap option for mesh particles (B4.2).
+    "tripo-p1": "P1-20260311",
+    "p1": "P1-20260311",
+}
+
+DEFAULT_MODEL = "v3.1-20260211"
+
+#: Terminal task states. Tripo reports lower-case; compared case-insensitively.
+DONE_STATES = ("success", "succeeded", "finished", "completed")
+FAILED_STATES = ("failed", "cancelled", "canceled", "banned", "expired", "unknown")
+
+#: Output fields that have carried the download URL across API versions.
+_MODEL_URL_KEYS = ("model_url", "pbr_model", "model", "base_model", "glb", "gltf")
+
+#: `face_limit` range the service accepts **while `smart_low_poly` is on**.
+#: Outside it the request is rejected with a terminal 400:
+#:   "when smart_low_poly is enabled, face_limit must be between 500 and 20000
+#:    (triangle mesh), got 30000"
+#: Not in the public docs; found by calling it.
+LOW_POLY_FACE_LIMIT_RANGE = (500, 20_000)
+
+
+class TripoModel:
+    """
+    Cloud image-to-3D / text-to-3D through Tripo3D.
+
+    Interchangeable with `Trellis2Model` in `Gen3DObjectOperator`: the
+    `infer_and_save(image, output_path, seed, decimation_target, texture_size)`
+    call signature is positionally identical (model_require.md R6).
+
+    Args:
+        model_path: [C1] Tripo model version id, or an alias from `MODEL_ALIASES`.
+        device:     [C2] Accepted for interface parity, ignored. "cpu" is fine.
+        api_key:    Explicit key; defaults to `$TRIPO_API_KEY`, read at first call.
+        timeout:    [C6] Seconds to wait for one generation task.
+        poll_interval: Seconds between status polls.
+        max_retries: [C9] Extra attempts for retryable HTTP failures.
+        cache_dir:  [C8] Directory for the response cache. None disables it.
+        output_format: "glb" is produced natively. Any other format needs the
+                    conversion endpoint — see `convert_path`.
+        convert_path: API path of the format-conversion endpoint. Left as None
+                    because it is not pinned down in the public v3 docs; set it
+                    to enable `output_format="fbx"` without touching this file.
+        low_poly:   [B4.3] Ask the service for clean low-poly topology
+                    (`smart_low_poly`) instead of decimating locally.
+        texture / pbr / quad / texture_quality / geometry_quality:
+                    Forwarded verbatim to the generation endpoint.
+        api_base:   Override the API root (defaults to `$TRIPO_API_BASE`).
+        verbose:    Print task progress; off by default (R3.7).
+    """
+
+    #: Provider name, used for cache namespacing and log lines.
+    PROVIDER = "tripo"
+
+    def __init__(
+        self,
+        model_path: str = DEFAULT_MODEL,
+        device: str = "cuda",
+        *,
+        api_key: Optional[str] = None,
+        # Measured: image-to-3D with smart_low_poly took **601 s**, i.e. it would
+        # have died one second past a 600 s budget. Timing out does not refund
+        # the credits — the task finishes server-side and only the download is
+        # lost — so the default errs long. The error carries the task_id.
+        timeout: int = 1800,
+        poll_interval: float = 3.0,
+        max_retries: int = 3,
+        cache_dir: Optional[str] = None,
+        output_format: str = "glb",
+        convert_path: Optional[str] = None,
+        low_poly: bool = False,
+        texture: bool = True,
+        pbr: bool = True,
+        quad: bool = False,
+        texture_quality: str = "standard",
+        geometry_quality: str = "standard",
+        api_base: Optional[str] = None,
+        http_timeout: int = 60,
+        verbose: bool = False,
+        **model_specific: Any,
+    ):
+        # [CONTRACT-DEVIATION C1] model_path is a version id, not a weight location.
+        # [CONTRACT-DEVIATION C2] device accepted for interface parity, ignored.
+        self.model_path = MODEL_ALIASES.get(str(model_path).lower(), model_path)
+        self.device = device
+
+        # R2.4 — every constructor argument lands on self before anything loads,
+        # so unload()/reload round-trips without losing configuration.
+        self.api_key = api_key
+        self.timeout = timeout
+        self.poll_interval = poll_interval
+        self.max_retries = max_retries
+        self.cache_dir = cache_dir
+        self.output_format = output_format.lower().lstrip(".")
+        self.convert_path = convert_path
+        self.low_poly = low_poly
+        self.texture = texture
+        self.pbr = pbr
+        self.quad = quad
+        self.texture_quality = texture_quality
+        self.geometry_quality = geometry_quality
+        self.api_base = (api_base or os.environ.get("TRIPO_API_BASE")
+                         or DEFAULT_API_BASE)
+        self.http_timeout = http_timeout
+        self.verbose = verbose
+        self.model_specific = model_specific
+
+        self._client: Optional[cloud_api.CloudAPIClient] = None
+        self._cache = cloud_api.ResponseCache(cache_dir, self.PROVIDER)
+
+        #: Record of the most recent **real** call: task_id, elapsed_sec, credits,
+        #: triangles, bytes, cached. Operators copy it into meta.json (R9.8).
+        self.last_call_info: dict[str, Any] = {}
+
+    # ── plumbing ──────────────────────────────────────────────────────────────
+
+    @property
+    def client(self) -> cloud_api.CloudAPIClient:
+        """
+        HTTP client, created on first use.
+
+        [C6/R9.7] The API key is resolved here rather than in `__init__`, so the
+        wrapper can be imported and constructed on a machine with no credentials
+        (which is exactly what `test/harness/smoke.py` does).
+        """
+        if self._client is None:
+            key = cloud_api.require_api_key(
+                self.api_key, "TRIPO_API_KEY", SIGNUP_URL, who="TripoModel")
+            self._client = cloud_api.CloudAPIClient(
+                self.api_base, key,
+                timeout=self.http_timeout,
+                max_retries=self.max_retries,
+            )
+        return self._client
+
+    def unload(self) -> None:
+        """[C4] Close the HTTP session. Idempotent, and safe before any call."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    close = unload
+
+    @staticmethod
+    def _unwrap(resp: Any) -> dict:
+        """
+        Strip Tripo's `{"code": 0, "data": {...}}` envelope.
+
+        A non-zero `code` on an HTTP 200 is a terminal application error — the
+        same request will fail the same way, so it must not be retried (R9.9).
+        """
+        if not isinstance(resp, dict):
+            raise cloud_api.CloudAPIError(f"unexpected response type {type(resp).__name__}: {resp!r}")
+        code = resp.get("code")
+        if code not in (None, 0):
+            message = resp.get("message") or resp.get("msg") or resp
+            suggestion = resp.get("suggestion")
+            raise cloud_api.CloudAPIRequestError(
+                f"Tripo API error code={code}: {message}"
+                + (f" — {suggestion}" if suggestion else ""),
+                payload=resp,
+            )
+        data = resp.get("data")
+        return data if isinstance(data, dict) else resp
+
+    def _upload_image(self, png: bytes) -> str:
+        """Upload PNG bytes, return the `file_token` used as generation input."""
+        data = self._unwrap(self.client.request(
+            "POST", "/files",
+            files={"file": ("input.png", png, "image/png")},
+        ))
+        token = data.get("file_token") or data.get("image_token") or data.get("token")
+        if not token:
+            raise cloud_api.CloudAPIError(
+                f"upload succeeded but no file_token in the response: {data}")
+        return str(token)
+
+    @staticmethod
+    def _extract_model_url(task: dict) -> str:
+        """Find the artifact URL in a finished task, across output field names."""
+        output = task.get("output") or task.get("result") or {}
+        for key in _MODEL_URL_KEYS:
+            value = output.get(key)
+            if isinstance(value, str) and value.startswith("http"):
+                return value
+            if isinstance(value, dict) and isinstance(value.get("url"), str):
+                return value["url"]
+        raise cloud_api.CloudAPIError(
+            f"task {task.get('task_id')} reported success but carries no model URL. "
+            f"output={output!r}",
+            task_id=task.get("task_id"), payload=task)
+
+    def _fetch_task(self, task_id: str) -> dict:
+        return self._unwrap(self.client.request("GET", f"/tasks/{task_id}"))
+
+    # ── payload ───────────────────────────────────────────────────────────────
+
+    def _clamp_face_limit(self, value: int) -> int:
+        """
+        Keep `face_limit` inside the range the service accepts.
+
+        `Gen3DObjectOperator` forwards TRELLIS.2's default of 1 000 000, and with
+        `low_poly=True` anything outside 500-20 000 is a terminal 400. Clamping
+        (loudly) keeps the backends interchangeable (R6) rather than making the
+        caller special-case each provider.
+        """
+        value = int(value)
+        if not self.low_poly:
+            return value
+        low, high = LOW_POLY_FACE_LIMIT_RANGE
+        clamped = max(low, min(value, high))
+        if clamped != value:
+            logger.warning("[tripo] face_limit %s clamped to %s "
+                           "(smart_low_poly range %s-%s)", value, clamped, low, high)
+        return clamped
+
+    def _build_payload(
+        self,
+        *,
+        prompt: Optional[str],
+        negative_prompt: Optional[str],
+        seed: Optional[int],
+        decimation_target: Optional[int],
+        provider_kwargs: dict,
+    ) -> dict:
+        """Generation parameters shared by the image and text endpoints."""
+        payload: dict[str, Any] = {
+            "model": self.model_path,
+            "texture": self.texture,
+            "pbr": self.pbr,
+            "texture_quality": self.texture_quality,
+            "geometry_quality": self.geometry_quality,
+        }
+        if self.quad:
+            payload["quad"] = True
+        if self.low_poly:
+            # [B4.3] Ask the service for low-poly topology. Decimating a 2M-face
+            # mesh locally wrecks UVs and normals; generating low-poly does not.
+            payload["smart_low_poly"] = True
+        if decimation_target:
+            payload["face_limit"] = self._clamp_face_limit(decimation_target)
+        if prompt:
+            payload["prompt"] = prompt
+        if negative_prompt:
+            payload["negative_prompt"] = negative_prompt
+        if seed is not None:
+            # [CONTRACT-DEVIATION C5] forwarded, but the service does not promise
+            # that the same seed reproduces the same mesh. Never faked locally.
+            payload["model_seed"] = int(seed)
+            payload["texture_seed"] = int(seed)
+        payload.update(provider_kwargs)
+        return payload
+
+    # ── inference ─────────────────────────────────────────────────────────────
+
+    def infer(
+        self,
+        image: Any = None,
+        seed: int = 42,
+        decimation_target: Optional[int] = None,
+        texture_size: Optional[int] = None,
+        *,
+        prompt: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        image_url: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        **provider_kwargs: Any,
+    ) -> bytes:
+        """
+        Generate one 3D asset and return the model file bytes.
+
+        [C6] Submits the task, polls until it finishes, downloads the artifact —
+        all inside this call. Typical wall time is 20 s to 4 min.
+
+        Args:
+            image: Reference image as `PIL.Image.Image`, `np.ndarray` or PNG
+                   `bytes`. Not a path (R3.2). Give `image`, `image_url` or
+                   `prompt`; image wins when several are present.
+            seed: [C5] Forwarded as `model_seed` / `texture_seed`. Reproducibility
+                   is not guaranteed server-side.
+            decimation_target: Target face count, forwarded as `face_limit`.
+                   None leaves it to the service.
+            texture_size: Accepted for signature parity with `Trellis2Model` and
+                   **ignored** — Tripo exposes `texture_quality`, not a
+                   resolution. Pass `texture_quality=` to the constructor.
+            prompt: Text prompt for text-to-3D. [A4 decision] The operator slot is
+                   image-to-3D today; accepting `prompt` here keeps text-to-3D
+                   available without a second wrapper.
+            negative_prompt: Text-to-3D only.
+            image_url: Publicly reachable image URL, used instead of uploading.
+            verbose: Override the constructor's verbosity for this call.
+            **provider_kwargs: Merged into the request body verbatim, so a new
+                   API parameter needs no change here.
+
+        Returns:
+            The model file as `bytes` — GLB unless `output_format`/`convert_path`
+            say otherwise.
+
+        Raises:
+            CloudAPIAuthError: no or invalid `TRIPO_API_KEY`.
+            CloudAPIQuotaError: out of credits (terminal, never retried).
+            CloudTaskTimeout: not finished within `timeout`; carries `task_id`.
+            CloudTaskFailed: the service rejected or failed the task.
+        """
+        verbose = self.verbose if verbose is None else verbose
+        if image is None and image_url is None and not prompt:
+            raise ValueError(
+                "TripoModel.infer needs an image (`image=` / `image_url=`) or a "
+                "text `prompt=`; got neither.")
+        if texture_size is not None:
+            # [CONTRACT-DEVIATION C2-style] accepted for parity, ignored.
+            logger.debug("[tripo] texture_size=%s ignored; use texture_quality",
+                         texture_size)
+        if self.output_format != "glb" and not self.convert_path:
+            raise NotImplementedError(
+                f"TripoModel produces GLB; output_format={self.output_format!r} needs "
+                f"Tripo's conversion endpoint, whose path is not pinned in the public "
+                f"v3 docs. Either set convert_path=... on the constructor, use "
+                f"MeshyModel(output_format='fbx') which returns FBX natively, or "
+                f"convert the GLB with engine_adapters/blender/."
+            )
+
+        png = cloud_api.image_to_png_bytes(image) if image is not None else None
+        use_image = png is not None or bool(image_url)
+        payload = self._build_payload(
+            # The image endpoint has no prompt field — sending one is a terminal
+            # 400. An image plus a prompt means "use the image".
+            prompt=None if use_image else prompt,
+            negative_prompt=None if use_image else negative_prompt,
+            seed=seed,
+            decimation_target=decimation_target, provider_kwargs=provider_kwargs,
+        )
+
+        # [C8] Cache key covers everything that changes the output. The image is
+        # represented by its hash, never its bytes, and the key never sees the API key.
+        cache_key = cloud_api.request_hash({
+            "provider": self.PROVIDER,
+            "payload": payload,
+            "image_sha256": cloud_api.bytes_hash(png) if png else None,
+            "image_url": image_url,
+            "output_format": self.output_format,
+        })
+        cached = self._cache.get(cache_key, ext=self.output_format)
+        if cached is not None:
+            self.last_call_info = {
+                "provider": self.PROVIDER, "cached": True, "cache_key": cache_key,
+                "bytes": len(cached), **glb_summary(cached),
+            }
+            return cached
+
+        t0 = time.time()
+        if png is not None:
+            # `input` takes a file_token, a public URL or a previous task id.
+            payload["input"] = self._upload_image(png)
+            endpoint = "/generation/image-to-model"
+        elif image_url:
+            payload["input"] = image_url
+            endpoint = "/generation/image-to-model"
+        else:
+            endpoint = "/generation/text-to-model"
+
+        created = self._unwrap(self.client.request("POST", endpoint, json_body=payload))
+        task_id = str(created.get("task_id") or created.get("id") or "")
+        if not task_id:
+            raise cloud_api.CloudAPIError(
+                f"{endpoint} accepted the request but returned no task_id: {created}")
+        if verbose:
+            print(f"[tripo] task {task_id} submitted ({endpoint})")
+
+        # Some responses already carry a finished task; only poll when they do not.
+        state = str(created.get("status", "")).lower()
+        if state in DONE_STATES:
+            task = created
+        else:
+            task = cloud_api.poll_task(
+                lambda: self._fetch_task(task_id),
+                task_id=task_id,
+                timeout=self.timeout,
+                poll_interval=self.poll_interval,
+                done_states=DONE_STATES,
+                failed_states=FAILED_STATES,
+                verbose=verbose,
+            )
+
+        data = self.client.download(self._extract_model_url(task))
+        elapsed = time.time() - t0
+
+        info = glb_summary(data) if self.output_format == "glb" else {"bytes": len(data)}
+        self.last_call_info = {
+            "provider": self.PROVIDER,
+            "model": self.model_path,
+            "task_id": task_id,
+            "elapsed_sec": round(elapsed, 2),
+            "credits": task.get("credits_consumed", task.get("credits")),
+            "cached": False,
+            "cache_key": cache_key,
+            # The provider's own render — see the note in meshy_model.py.
+            "preview_url": (task.get("output") or {}).get("rendered_image_url"),
+            **info,
+        }
+        # R9.8 — one line per billed call: what it cost and what it produced.
+        logger.info(
+            "[tripo] task=%s model=%s %.1fs credits=%s triangles=%s bytes=%s",
+            task_id, self.model_path, elapsed, self.last_call_info.get("credits"),
+            info.get("triangles"), len(data),
+        )
+        if verbose:
+            print(f"[tripo] {self.last_call_info}")
+
+        self._cache.put(cache_key, data, {
+            "provider": self.PROVIDER, "payload": payload,
+            **{k: v for k, v in self.last_call_info.items() if k != "cache_key"},
+        }, ext=self.output_format)
+        return data
+
+    def infer_and_save(
+        self,
+        image: Any = None,
+        output_path: Optional[str] = None,
+        seed: int = 42,
+        decimation_target: Optional[int] = None,
+        texture_size: Optional[int] = None,
+        *,
+        prompt: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        image_url: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        **provider_kwargs: Any,
+    ) -> str:
+        """
+        [C7] The documented R1.2 exception: run `infer()` and write the result.
+
+        The path comes **in** from the caller and is never derived here — the
+        operator owns artifact placement.
+
+        Args:
+            output_path: Destination file. Parent directories are created.
+            (everything else: see `infer`)
+
+        Returns:
+            `str(output_path)`.
+        """
+        if not output_path:
+            raise ValueError("output_path is required (model_require.md R1.2)")
+        data = self.infer(
+            image, seed, decimation_target, texture_size,
+            prompt=prompt, negative_prompt=negative_prompt, image_url=image_url,
+            verbose=verbose, **provider_kwargs,
+        )
+        out = Path(output_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(data)
+        return str(out)
+
+    # ── account ───────────────────────────────────────────────────────────────
+
+    def balance(self) -> dict:
+        """
+        Remaining credits: ``{"balance": float, "frozen": float}``.
+
+        Cheap and unbilled — call it before a batch to check the budget (C4 note:
+        this is the only method that talks to the API without generating).
+        """
+        return self._unwrap(self.client.request("GET", "/account/balance"))

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py

@@ -0,0 +1,596 @@
+"""
+operators/gen_3d_object/operator.py
+
+Gen3DObjectOperator — accepts a loaded model and processes an input dict into a
+3D output (GLB file on disk).
+
+The operator is intentionally model-agnostic: you inject any object that
+implements the same interface as Trellis2Model.  New model wrappers can be
+swapped in without touching this file.
+
+Output layout — two modes, chosen by whether `output_dir` is given:
+
+  * **per-game (default, `output_dir=None`)** — resolved by
+    `pipeline.common.paths`, so artifacts are grouped by generated game project::
+
+        test_data/outputs/<game_id>/<run_id>/assets/3d_object/<task_id>/
+            ├── model.glb
+            └── meta.json
+
+  * **flat (legacy, `output_dir="..."`)** — writes `<output_dir>/<task_id>.glb`,
+    byte-for-byte the historical behaviour. Existing callers are unaffected.
+
+Usage:
+    from models.gen_3d_object.trellis_2_model import Trellis2Model
+    from operators.gen_3d_object.operator import Gen3DObjectOperator
+
+    model = Trellis2Model(model_path="...")
+
+    # per-game layout
+    op = Gen3DObjectOperator(model=model, run_id="20260731_1032")
+
+    # legacy flat layout (unchanged)
+    op = Gen3DObjectOperator(model=model, output_dir="outputs/3d_object")
+
+    result = op.run({
+        "game_id": "gameA_cyberpunk_shooter",   # optional, inferred when omitted
+        "task_id": "sword_001",
+        "image_path": "path/to/image.png",      # or "image": PIL.Image
+        "seed": 42,
+    })
+    print(result["glb_path"])
+
+Two optional extras, both additive and off unless asked for:
+
+  * naming an ``asset_id`` in the task hands the finished mesh to the
+    three.js adapter — staged, oriented, manifest rewritten;
+  * ``run_art_plan(game_id, image_model)`` generates a whole game's
+    recorded art plan (``funcs/art_plan.py``) that way in one call.
+
+``funcs/asset_pack.py`` covers the other case: three CC0 models,
+downloaded and imported in seconds, for when generating is overkill.
+
+A third route skips inference entirely. Passing ``spec`` instead of an
+image builds the mesh from a declarative part list
+(``funcs/code_asset.py``), which suits anything exactly describable — a
+crate, a sign, a wheel, a rifle. It needs no model and no GPU, states its
+own facing and size instead of leaving them to be guessed, and keeps its
+parts as named glTF nodes so gameplay can still move them::
+
+    op = Gen3DObjectOperator(model=None, run_id="20260826_1400")
+    op.run({
+        "game_id": "gameA_cyberpunk_shooter",
+        "task_id": "crate_001",
+        "spec": {
+            "subject": "wooden supply crate",
+            "units": "metres", "forward": "+z",
+            "asset_type": "prop", "height_metres": 0.6,
+            "parts": [{"id": "body", "kind": "box",
+                       "size": [0.6, 0.6, 0.6], "at": [0, 0.3, 0]}],
+        },
+    })
+
+The two can be mixed, which is usually the best available answer for a
+detailed hard-surface asset. A ``mesh`` part reads a GLB off disk — one
+component generated by a cloud model — and is placed, measured and gated
+exactly like a primitive. What each side contributes is not
+interchangeable: the generator supplies shapes no formula states (a
+moulded grip's finger swells), and the spec supplies the dimensions and
+placement a prompt cannot specify (a rail's 30 mm slot pitch). Spending
+generation on something a lathe states exactly buys an approximation at a
+hundred times the triangles, and the approximation is the part that can no
+longer be adjusted by editing a number — so the ``provenance`` gate
+reports what was delegated and at what cost::
+
+    op.run({
+        "game_id": "gameA_cyberpunk_shooter",
+        "task_id": "rifle_001",
+        "spec": {
+            "subject": "assault rifle",
+            "units": "metres", "forward": "+z",
+            "asset_type": "weapon", "height_metres": 0.24,
+            "parts": [
+                # exact dimensions: stated
+                {"id": "receiver", "kind": "box",
+                 "size": [0.04, 0.048, 0.30], "at": [0, 0.139, -0.03]},
+                # moulded surface: fetched, with a uniform `size` so the
+                # mesh keeps the proportions it was generated with
+                {"id": "grip", "kind": "mesh",
+                 "source": "parts/grip.glb",
+                 "size": [0.116, 0.116, 0.116], "at": [0, 0.045, -0.104]},
+            ],
+        },
+    })
+"""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from PIL import Image
+
+#: Registered task kind for this operator (see pipeline/common/paths.py).
+TASK_KIND = "3d_object"
+
+#: Artifact filename used by the per-game layout.
+GLB_FILENAME = "model.glb"
+
+
+class Gen3DObjectOperator:
+    """
+    Operator for 3D object generation.
+
+    Args:
+        model: A loaded model with an `infer_and_save(image, output_path, ...)` method.
+               Currently supports Trellis2Model; any model with the same interface works.
+        output_dir (str, optional): **Legacy flat mode.** When given, every GLB is
+               written as `<output_dir>/<task_id>.glb`, exactly as before. When
+               omitted (default), the per-game layout under
+               `test_data/outputs/<game_id>/<run_id>/assets/3d_object/<task_id>/`
+               is used instead.
+        run_id (str): Groups all artifacts of one generation run. Per-game mode only.
+        default_game_id (str, optional): Fallback game project for tasks that carry
+               no `game_id` and whose input paths reveal none. Per-game mode only.
+    """
+
+    def __init__(
+        self,
+        model: Any,
+        output_dir: Optional[str] = None,
+        run_id: str = "default",
+        default_game_id: Optional[str] = None,
+    ):
+        self.model = model
+        self.run_id = run_id
+        self.default_game_id = default_game_id
+        # Legacy flat mode is active only when an explicit output_dir is supplied.
+        self.output_dir = Path(output_dir) if output_dir else None
+        if self.output_dir is not None:
+            self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    # --------------------------------------------------------------------------
+
+    def _load_image(self, inp: dict) -> Image.Image:
+        """Return a PIL image from an input dict that has 'image_path' or 'image'."""
+        if "image" in inp and isinstance(inp["image"], Image.Image):
+            return inp["image"]
+        if "image_path" in inp:
+            p = Path(inp["image_path"])
+            if not p.is_absolute() and not p.exists():
+                # resolve relative to repo root (codes_official/)
+                repo_root = Path(__file__).resolve().parents[2]
+                p = repo_root / inp["image_path"]
+            return Image.open(str(p)).convert("RGBA")
+        raise ValueError("Input must contain 'image_path' (str) or 'image' (PIL.Image).")
+
+    # --------------------------------------------------------------------------
+
+    def _artifact_suffix(self) -> str:
+        """
+        File extension for the artifact — GLB unless the injected model says
+        otherwise (the cloud backends can emit FBX / OBJ / USDZ).
+
+        The result dict keeps the ``glb_path`` key whatever the extension is:
+        renaming a returned key breaks `eval.py` and `test/`.
+        """
+        fmt = getattr(self.model, "output_format", None)
+        return str(fmt).lower().lstrip(".") if fmt else "glb"
+
+    def _resolve_out_path(self, inp: dict, task_id: str) -> tuple[str, Path, Path]:
+        """
+        Return ``(game_id, task_dir, glb_path)`` for either output mode.
+
+        Legacy flat mode keeps the historical `<output_dir>/<task_id>.glb`.
+        """
+        suffix = self._artifact_suffix()
+        if self.output_dir is not None:
+            game_id = str(inp.get("game_id") or inp.get("game") or "")
+            return game_id, self.output_dir, self.output_dir / f"{task_id}.{suffix}"
+
+        from pipeline.common import paths
+        game_id = paths.infer_game_id(inp, fallback=self.default_game_id)
+        task_dir = paths.task_output_dir(game_id, TASK_KIND, task_id, run_id=self.run_id)
+        filename = GLB_FILENAME if suffix == "glb" else f"model.{suffix}"
+        return game_id, task_dir, task_dir / filename
+
+    # --------------------------------------------------------------------------
+
+    def run(self, inp: dict) -> dict:
+        """
+        Generate a 3D object from an image prompt, or build one from a spec.
+
+        Args:
+            inp (dict):
+                - image_path (str): path to the reference / concept image
+                  OR image (PIL.Image): pre-loaded image
+                  OR spec (dict): a part spec, which builds the mesh instead
+                  of inferring it (see `funcs/code_asset.py`)
+                - compose (dict): combine_avatar arguments, including caller-defined
+                  socket_definitions, grip_templates and optional slot_definitions
+                - game_id (str, optional): game project this task belongs to;
+                  inferred from `image_path` when omitted
+                - task_id (str, optional): used to name the output file / directory
+                - seed (int, optional): random seed (default 42)
+                - decimation_target (int, optional)
+                - texture_size (int, optional)
+
+        Returns:
+            dict:
+                - task_id (str)
+                - glb_path (str): absolute path to the saved GLB file
+                - elapsed_sec (float)
+                - game_id (str), task_kind (str), output_dir (str)  ← additive
+        """
+        if inp.get("compose") is not None:
+            if inp.get("spec") is not None:
+                raise ValueError("provide compose or spec, not both")
+            return self._run_compose(inp)
+        if inp.get("spec") is not None:
+            return self._run_spec(inp)
+
+        task_id = inp.get("task_id", f"task_{int(time.time())}")
+        seed = inp.get("seed", 42)
+        decimation_target = inp.get("decimation_target", 1_000_000)
+        texture_size = inp.get("texture_size", 4096)
+
+        game_id, task_dir, out_path = self._resolve_out_path(inp, task_id)
+
+        text_mode = inp.get("input_mode") == "text_to_3d"
+        if text_mode and not str(inp.get("prompt") or "").strip():
+            raise ValueError("text_to_3d requires a non-empty prompt")
+        image = None if text_mode else self._load_image(inp)
+        inference_kwargs = {"prompt": inp["prompt"]} if text_mode else {}
+
+        t0 = time.time()
+        glb_path = self.model.infer_and_save(
+            image,
+            output_path=str(out_path),
+            seed=seed,
+            decimation_target=decimation_target,
+            texture_size=texture_size,
+            **inference_kwargs,
+        )
+        elapsed = time.time() - t0
+
+        result = {
+            "task_id": task_id,
+            "glb_path": glb_path,
+            "elapsed_sec": round(elapsed, 2),
+            "game_id": game_id,
+            "task_kind": TASK_KIND,
+            "output_dir": str(task_dir),
+        }
+
+        # Image-to-3D infers a floor under a subject that stands on the edge
+        # of its own crop, and it is never wanted: measured at a fifth of the
+        # triangle budget, and a grey pancake under the character in the
+        # scene. Removing it here means every consumer of this task output
+        # gets a clean mesh, rather than each game discovering the slab.
+        if inp.get("strip_ground_plate", True):
+            from .funcs.mesh_cleanup import strip_ground_plate
+
+            cleanup = strip_ground_plate(glb_path)
+            result["ground_plate"] = cleanup
+            if cleanup.get("applied"):
+                result.setdefault("warnings", []).append(
+                    f"removed an inferred floor: {cleanup['plate_count']} "
+                    f"sheets and {cleanup['debris_count']} loose lumps, "
+                    f"{cleanup['removed_fraction']:.0%} of the mesh"
+                )
+            elif cleanup.get("reason") and "nothing" not in cleanup["reason"]:
+                result.setdefault("warnings", []).append(
+                    f"left the mesh alone: {cleanup['reason']}"
+                )
+
+        # meta.json only in per-game mode, so legacy output dirs stay untouched.
+        if self.output_dir is None:
+            from pipeline.common import paths
+            meta = {
+                **result,
+                "run_id": self.run_id,
+                "prompt": inp.get("prompt"),
+                "source_image": inp.get("image_path"),
+                "seed": seed,
+                "decimation_target": decimation_target,
+                "texture_size": texture_size,
+                "model": type(self.model).__name__,
+            }
+            for key in ("asset_id", "asset_type", "forward_axis",
+                        "scale_hint_metres", "notes"):
+                if inp.get(key) is not None:
+                    meta[key] = inp[key]
+            # Cloud backends expose what the call cost and produced — task id,
+            # credits, triangle count (api_model_require.md R9.8). Recording it
+            # here is what makes a billed run reproducible after the fact.
+            call_info = getattr(self.model, "last_call_info", None)
+            if call_info:
+                meta["model_call"] = dict(call_info)
+            paths.write_task_meta(task_dir, meta)
+
+        # Optional handover to the engine adapter, active only when the task
+        # names an asset. A generated mesh is not part of a game until the
+        # adapter has staged it and recorded which way it faces.
+        if inp.get("asset_id") and self.output_dir is None:
+            from .funcs.asset_import import import_asset
+            result.update(
+                import_asset(
+                    game_id,
+                    task_id,
+                    asset_id=str(inp["asset_id"]),
+                    asset_type=str(inp.get("asset_type") or "prop"),
+                    run_id=self.run_id,
+                    forward_axis=str(inp.get("forward_axis") or ""),
+                    scale_hint_metres=inp.get("scale_hint_metres"),
+                    verified_by=str(inp.get("verified_by") or "heuristic"),
+                    notes=str(inp.get("notes") or ""),
+                    project_hint=str(inp.get("project_hint") or ""),
+                    preview=bool(inp.get("preview", True)),
+                )
+            )
+
+        return result
+
+    # --------------------------------------------------------------------------
+
+    def _run_compose(self, inp: dict) -> dict:
+        """Resolve caller-configured attachments, then build through the spec route."""
+        import json
+        from .funcs.code_asset_templates.human_template.combine import (
+            combine_avatar, write_report,
+        )
+
+        task_id = inp.get("task_id", f"task_{int(time.time())}")
+        _, _, out_path = self._resolve_out_path(inp, task_id)
+        directory = out_path.parent / f"{out_path.stem}_compose"
+        config = dict(inp["compose"])
+        config.setdefault("parts_dir", directory / "parts")
+        started = time.time()
+        combined = combine_avatar(**config)
+        result = self._run_spec({**inp, "task_id": task_id, "spec": combined["spec"]})
+        report_path = write_report(combined["report"], directory / "report.json")
+        sockets_path = directory / "sockets.json"
+        sockets_path.write_text(json.dumps(combined["report"]["sockets"], indent=2),
+                                encoding="utf-8")
+        result["compose"] = {**combined["report"], "report_path": report_path,
+                             "sockets_path": str(sockets_path)}
+        result["elapsed_sec"] = round(time.time() - started, 2)
+        return result
+
+    def _run_spec(self, inp: dict) -> dict:
+        """Build the asset from a declarative spec rather than an image.
+
+        Taken when the task carries a ``spec``. No model is loaded and no
+        image is read, so this path works with ``model=None`` — a crate
+        does not need a GPU, and requiring one to build a box is what makes
+        primitives feel like a defeat rather than a choice.
+
+        Three things come out of the spec that the generated path can only
+        guess at, which is the reason to prefer it wherever it applies:
+
+          * ``forward_axis`` is *stated*, so the import is recorded as
+            ``verified_by="spec"`` rather than ``"heuristic"``. Facing is
+            the one property `orientation_review` exists to establish, and
+            here there is nothing to establish.
+          * ``scale_hint_metres`` is stated, so the mesh has a real size
+            instead of a unit box someone has to scale by eye.
+          * parts keep their ids as glTF node names, so a wheel can be spun
+            after import. A reconstructed mesh is one fused body.
+
+        ``strip_ground_plate`` is deliberately not run: it removes a floor
+        that image-to-3D *invented*, and a spec cannot invent one. Running
+        it here would risk deleting a plinth that was asked for.
+
+        A spec may also carry ``mesh`` parts, which read a GLB off disk —
+        typically one component from a cloud model, composed in where no
+        formula states the shape. Those change one thing here and nothing
+        else: ``verified_by`` drops to ``"spec+generated"``, because a
+        generated part's facing was *asserted* by whoever placed it and not
+        established by anything. Claiming ``"spec"`` for a composition that
+        is largely fetched geometry would put an unverified facing behind the
+        one label that is supposed to mean it was not guessed.
+        """
+        from .funcs.code_asset import MESH_KIND, build_code_asset
+
+        task_id = inp.get("task_id", f"task_{int(time.time())}")
+        game_id, task_dir, out_path = self._resolve_out_path(inp, task_id)
+        # A spec always yields glTF, whatever output_format an injected
+        # model happens to advertise.
+        out_path = out_path.with_suffix(".glb")
+        task_dir.mkdir(parents=True, exist_ok=True)
+
+        t0 = time.time()
+        report = build_code_asset(
+            inp["spec"],
+            str(out_path),
+            revise=inp.get("revise"),
+            strict=bool(inp.get("strict", True)),
+        )
+        elapsed = time.time() - t0
+
+        # Which parts were fetched rather than derived. Carried on the result
+        # because after export the two are indistinguishable, and only one of
+        # them can still be changed by editing a number: a reviewer who wants
+        # the grip 4 mm thicker needs to know that means regenerating it.
+        # `long_axis` travels too, since a regenerated part is a new set of
+        # axes and the rotation that placed the old one will not place it.
+        generated_parts = [
+            {
+                "id": part["id"],
+                "source": part["source"],
+                "long_axis": part.get("long_axis"),
+            }
+            for part in report["spec"]["parts"]
+            if part.get("kind") == MESH_KIND
+        ]
+
+        result: dict[str, Any] = {
+            "task_id": task_id,
+            "glb_path": report["glb_path"],
+            "elapsed_sec": round(elapsed, 2),
+            "game_id": game_id,
+            "task_kind": TASK_KIND,
+            "output_dir": str(task_dir),
+            "source": "code_asset+generated" if generated_parts else "code_asset",
+            "spec_ok": report["ok"],
+            "gates": report["gates"],
+            "triangles": report["triangles"],
+            "bounds": report["bounds"],
+            "part_ids": report["part_ids"],
+            "generated_parts": generated_parts,
+            "stop_reason": report["stop_reason"],
+            "attempts": report["attempts"],
+        }
+        if report["warnings"]:
+            result.setdefault("warnings", []).extend(report["warnings"])
+        if report["failures"]:
+            # Surfaced as warnings on the result *and* kept in `gates`: a
+            # gate failure that only appears in a nested dict is the silent
+            # early return this whole module is shaped against.
+            result.setdefault("warnings", []).extend(
+                f"gate: {message}" for message in report["failures"]
+            )
+
+        if self.output_dir is None:
+            from pipeline.common import paths
+
+            meta = {
+                **result,
+                "run_id": self.run_id,
+                "spec": report["spec"],
+                "forward_axis": report["forward_axis"],
+                "scale_hint_metres": report["scale_hint_metres"],
+                "model": "code_asset",
+            }
+            for key in ("asset_id", "asset_type", "notes"):
+                if inp.get(key) is not None:
+                    meta[key] = inp[key]
+            paths.write_task_meta(task_dir, meta)
+
+        # A failed spec is not handed to the engine. An asset that exists
+        # gets used, so a gate failure has to stop it becoming an asset.
+        if inp.get("asset_id") and self.output_dir is None and report["ok"]:
+            from .funcs.asset_import import import_asset
+
+            result.update(
+                import_asset(
+                    game_id,
+                    task_id,
+                    asset_id=str(inp["asset_id"]),
+                    asset_type=str(
+                        inp.get("asset_type")
+                        or report["spec"].get("asset_type")
+                        or "prop"
+                    ),
+                    run_id=self.run_id,
+                    # Stated by the spec, not inferred from a view.
+                    forward_axis=report["forward_axis"],
+                    scale_hint_metres=report["scale_hint_metres"],
+                    # "spec" means the facing was stated rather than guessed.
+                    # With generated parts in the composition that is only
+                    # half true: the *placement* is stated, but the mesh
+                    # inside it came from a generator with no facing of its
+                    # own, and whoever wrote the rotation asserted one. Said
+                    # distinctly so a reviewer knows an orientation check is
+                    # still worth a look, instead of trusting a label that
+                    # was earned by a different route.
+                    verified_by="spec+generated" if generated_parts else "spec",
+                    notes=str(inp.get("notes") or "")
+                    or (
+                        f"Built from a spec: {report['subject']}."
+                        + (
+                            f" {len(generated_parts)} generated part(s): "
+                            f"{', '.join(part['id'] for part in generated_parts)}."
+                            if generated_parts else ""
+                        )
+                    ),
+                    project_hint=str(inp.get("project_hint") or ""),
+                    preview=bool(inp.get("preview", True)),
+                )
+            )
+        return result
+
+    # --------------------------------------------------------------------------
+
+    def run_art_plan(
+        self,
+        game_id: str,
+        image_model: Any = None,
+        plan: Optional[list[dict]] = None,
+        assets: tuple[str, ...] = (),
+    ) -> list[dict]:
+        """
+        Generate a game's recorded art plan and import each asset.
+
+        The plan lives in `funcs/art_plan.py`; it names a subject, an asset
+        type and a **height in metres**, because a mesh normalised into a
+        unit box has no size of its own. Concept images come from
+        `image_model` unless an entry points at one.
+
+        Facing is recorded as `heuristic`, never as verified: single-image
+        reconstruction puts the input view on a predictable axis, but a
+        guess labelled as checked stops anyone checking. Each import leaves
+        a review sheet for `agent_skills/asset_qa/`.
+        """
+        from .funcs.art_plan import concept_image, plan_for_game
+
+        entries = plan if plan is not None else plan_for_game(game_id)
+        if not entries:
+            raise ValueError(
+                f"No art plan for {game_id!r}; add one to "
+                "operators/gen_3d_object/funcs/art_plan.py"
+            )
+
+        results: list[dict] = []
+        for entry in entries:
+            if assets and entry["asset_id"] not in assets:
+                continue
+            image, provenance, framing = concept_image(entry, image_model)
+            task_dir = Path(
+                self._resolve_out_path(
+                    {"game_id": game_id}, entry["task_id"]
+                )[1]
+            )
+            task_dir.mkdir(parents=True, exist_ok=True)
+            # Keep the concept image beside the mesh it produced: a bad
+            # asset is almost always a bad concept image, and that is not
+            # diagnosable after the fact if the input was thrown away.
+            image.save(task_dir / "concept.png")
+            result = self.run(
+                {
+                    "game_id": game_id,
+                    "task_id": entry["task_id"],
+                    "image": image,
+                    "prompt": entry["full_prompt"],
+                    "seed": entry.get("seed", 42),
+                    "decimation_target": entry["triangles"],
+                    "texture_size": entry["texture"],
+                    "asset_id": entry["asset_id"],
+                    "asset_type": entry["type"],
+                    "forward_axis": entry["faces"],
+                    "scale_hint_metres": entry["height"],
+                    "verified_by": "heuristic",
+                    "notes": entry["notes"]
+                    or f"Generated from: {provenance}. Facing assumed "
+                    "from the input view.",
+                }
+            )
+            result["asset_id"] = entry["asset_id"]
+            result["concept_source"] = provenance
+            result["framing"] = framing
+            if framing.get("touched_border"):
+                # The subject ran off the edge of the generated image, so
+                # part of it was never drawn. Cropping cannot invent it.
+                result.setdefault("warnings", []).append(
+                    "the concept image was cropped at the border, so the "
+                    "mesh is probably truncated: regenerate with another "
+                    "seed"
+                )
+            results.append(result)
+        return results
+
+    # --------------------------------------------------------------------------
+
+    def run_batch(self, inputs: list[dict]) -> list[dict]:
+        """Run a list of input dicts sequentially and return results."""
+        return [self.run(inp) for inp in inputs]

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py

@@ -0,0 +1,444 @@
+"""
+pipeline/common/paths.py
+
+Single source of truth for every input / output path in 3AGameFactory.
+
+The benchmark is authored **per game project**, so outputs are organized the same
+way. An artifact is uniquely addressed by ``(game_id, run_id, task_kind, task_id)``::
+
+    test_data/test_samples/<game_id>/<TaskDir>/...                        # inputs (read-only)
+    test_data/outputs/<game_id>/<run_id>/<layer>/<task_kind>/<task_id>/   # outputs
+
+Full output tree::
+
+    test_data/outputs/                         # OUTPUT_ROOT ($AAAGF_OUTPUT_ROOT)
+    └── gameA_cyberpunk_shooter/               # one dir per generated game project
+        ├── latest -> 20260731_1032/           # symlink to the most recent run
+        └── <run_id>/                          # "default", or a timestamp
+            ├── run_meta.json                  # ckpts · seeds · git sha · argv
+            ├── assets/
+            │   ├── 3d_object/<task_id>/       # model.glb        + meta.json
+            │   ├── tpose/<task_id>/           # tpose_fg.png     + meta.json
+            │   ├── 3d_scene/<task_id>/
+            │   ├── motion/<task_id>/
+            │   ├── cg_video/<task_id>/
+            │   └── audio/<task_id>/            # dialogue / sound-effect audio + meta.json
+            ├── mechanic/<task_id>/            # engine project + demo_outputs/ + launch.sh
+            ├── ui/<task_id>/
+            ├── pipeline/<task_id>/            # end-to-end game-slice artifacts
+            └── eval/
+                ├── <task_kind>/<task_id>/     # metrics.json · build.log · judge_log.json
+                └── summary.json               # aggregate over the whole run
+
+The root stays next to the test set so any evaluator finds inputs and outputs side
+by side. Generated artifacts get large — point ``$AAAGF_OUTPUT_ROOT`` at a scratch
+disk to relocate the whole tree without touching code.
+
+This module has **no third-party dependencies** and imports no models, so it is
+safe to import from anywhere (including CPU-only tooling and tests).
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+# ── Roots ─────────────────────────────────────────────────────────────────────
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+TEST_DATA_ROOT = REPO_ROOT / "test_data"
+TEST_SAMPLES_ROOT = TEST_DATA_ROOT / "test_samples"
+
+#: Output root. Override with ``export AAAGF_OUTPUT_ROOT=/scratch/aaagf_outputs``.
+OUTPUT_ROOT = Path(
+    os.environ.get("AAAGF_OUTPUT_ROOT", TEST_DATA_ROOT / "outputs")
+).expanduser()
+
+#: Used when a task carries no game association (ad-hoc single-image demos).
+UNASSIGNED_GAME = "_scratch"
+
+#: Run id used when the caller does not ask for a fresh timestamped one.
+DEFAULT_RUN_ID = "default"
+
+LATEST_LINK = "latest"
+
+
+# ── Task kinds ────────────────────────────────────────────────────────────────
+
+#: task_kind -> layer directory. Layer A = assets, B = mechanic, C = ui.
+TASK_LAYER: dict[str, str] = {
+    # Layer A — asset generation
+    "3d_object": "assets",
+    "tpose": "assets",
+    "3d_scene": "assets",
+    "motion": "assets",
+    "cg_video": "assets",
+    "audio": "assets",
+    # Game design (story / chapters / asset & screen plan) — A-layer diagnostic only
+    "design": "design",
+    # Layer B / C — code generation
+    "mechanic": "mechanic",
+    "ui": "ui",
+    # End-to-end vertical slice
+    "pipeline": "pipeline",
+    # Whitebox-stage game evaluation (stage-1 LLM/Agent whitebox rubric) —
+    # an eval-only kind: results land under ``eval/whitebox/<task_id>/``
+    "whitebox": "whitebox",
+}
+
+#: task_kind -> directory name inside ``test_samples/<game_id>/``.
+TASK_INPUT_DIR: dict[str, str] = {
+    "3d_object": "3D_object",
+    "tpose": "tpose",
+    "3d_scene": "3D_scene",
+    "motion": "motion",
+    "cg_video": "cg_video",
+    "audio": "audio",
+    "design": "design",
+    "mechanic": "mechanic",
+    "ui": "ui",
+    "pipeline": "pipeline",
+    # whitebox case inputs (game_spec/rubric/references) live under
+    # ``test_bench_example/<case>/``; this dir keeps the registration
+    # complete for the shared task-input helpers.
+    "whitebox": "whitebox",
+}
+
+#: task_kind -> per-game task list filename inside ``TASK_INPUT_DIR``.
+TASK_JSONL: dict[str, str] = {
+    "3d_object": "object_tasks.jsonl",
+    "tpose": "tpose_tasks.jsonl",
+    "3d_scene": "scene_tasks.jsonl",
+    "motion": "motion_tasks.jsonl",
+    "cg_video": "cg_tasks.jsonl",
+    "audio": "audio_tasks.jsonl",
+    "design": "design_tasks.jsonl",
+    "mechanic": "mechanic_tasks.jsonl",
+    "ui": "ui_tasks.jsonl",
+    "pipeline": "pipeline_task.jsonl",
+    "whitebox": "whitebox_tasks.jsonl",
+}
+
+#: task_kind -> cross-game aggregate jsonl under ``test_samples/``.
+TASK_COLLECT_JSONL: dict[str, str] = {
+    "3d_object": "3D_object_gen_collect.jsonl",
+    "tpose": "tpose_gen_collect.jsonl",
+    "3d_scene": "3D_scene_gen_collect.jsonl",
+    "motion": "motion_gen_collect.jsonl",
+    "cg_video": "cg_video_collect.jsonl",
+    "audio": "audio_gen_collect.jsonl",
+    "design": "design_collect.jsonl",
+    "mechanic": "mechanic_collect.jsonl",
+    "ui": "ui_collect.jsonl",
+    "pipeline": "pipeline_collect.jsonl",
+    "whitebox": "whitebox_collect.jsonl",
+}
+
+#: Layer-A kinds only — what ``pipeline/assets_gen/`` covers.
+ASSET_TASK_KINDS = tuple(k for k, v in TASK_LAYER.items() if v == "assets")
+
+
+def check_kind(task_kind: str) -> str:
+    """Raise a helpful error for an unregistered task kind."""
+    if task_kind not in TASK_LAYER:
+        raise ValueError(
+            f"Unknown task_kind {task_kind!r}. Register it in "
+            f"pipeline/common/paths.py first. Known: {sorted(TASK_LAYER)}"
+        )
+    return task_kind
+
+
+# ── Input paths ───────────────────────────────────────────────────────────────
+
+def game_input_dir(game_id: str) -> Path:
+    """``test_data/test_samples/<game_id>/``"""
+    return TEST_SAMPLES_ROOT / game_id
+
+
+def task_input_dir(game_id: str, task_kind: str) -> Path:
+    """``test_data/test_samples/<game_id>/<TaskDir>/``"""
+    return game_input_dir(game_id) / TASK_INPUT_DIR[check_kind(task_kind)]
+
+
+def task_jsonl(game_id: str, task_kind: str) -> Path:
+    """``test_data/test_samples/<game_id>/<TaskDir>/<kind>_tasks.jsonl``"""
+    return task_input_dir(game_id, task_kind) / TASK_JSONL[check_kind(task_kind)]
+
+
+def collect_jsonl(task_kind: str) -> Path:
+    """``test_data/test_samples/<kind>_collect.jsonl`` — cross-game task list."""
+    return TEST_SAMPLES_ROOT / TASK_COLLECT_JSONL[check_kind(task_kind)]
+
+
+def resolve_tasks_path(task_kind: str, tasks: str | None = None,
+                       game_id: str | None = None) -> Path:
+    """
+    Standard task-list resolution shared by every ``run.py`` / ``eval.py``:
+
+    explicit ``--tasks``  →  the game's own ``*_tasks.jsonl`` (if non-empty)
+                          →  the cross-game ``*_collect.jsonl``.
+    """
+    if tasks:
+        return resolve_input_path(tasks)
+    if game_id:
+        per_game = task_jsonl(game_id, task_kind)
+        if per_game.exists() and per_game.stat().st_size > 0:
+            return per_game
+    return collect_jsonl(task_kind)
+
+
+def list_games() -> list[str]:
+    """Every game project directory present in the test set."""
+    if not TEST_SAMPLES_ROOT.is_dir():
+        return []
+    return sorted(
+        p.name
+        for p in TEST_SAMPLES_ROOT.iterdir()
+        if p.is_dir() and not p.name.startswith((".", "_"))
+    )
+
+
+def infer_game_id(task: dict, fallback: Optional[str] = None) -> str:
+    """
+    Resolve which game project a task belongs to.
+
+    Priority: explicit ``game_id`` / ``game`` field  →  any path-like field that
+    sits under ``test_samples/<game_id>/``  →  ``fallback``  →  ``UNASSIGNED_GAME``.
+    """
+    for key in ("game_id", "game"):
+        if task.get(key):
+            return str(task[key])
+
+    for value in task.values():
+        if not isinstance(value, str) or "test_samples" not in value:
+            continue
+        parts = Path(value).parts
+        if "test_samples" in parts:
+            idx = parts.index("test_samples")
+            if idx + 1 < len(parts):
+                return parts[idx + 1]
+
+    return fallback or UNASSIGNED_GAME
+
+
+def iter_tasks(tasks_path: str | Path, game_filter: str | None = None):
+    """
+    Yield ``(task_dict, game_id)`` from a jsonl, skipping blanks and comments.
+
+    Every runner should iterate through this so `game_id` resolution and the
+    `--game` filter behave identically across tasks.
+    """
+    with open(tasks_path) as f:
+        for lineno, line in enumerate(f, 1):
+            line = line.strip()
+            if not line or line.startswith("//"):
+                continue
+            try:
+                task = json.loads(line)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"{tasks_path}:{lineno} is not valid JSON: {e}") from e
+            game_id = infer_game_id(task)
+            if game_filter and game_id != game_filter:
+                continue
+            yield task, game_id
+
+
+# ── Output paths ──────────────────────────────────────────────────────────────
+
+def new_run_id(prefix: str = "") -> str:
+    """Timestamped run id, e.g. ``20260731_103200`` or ``qwen3b_20260731_103200``."""
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{prefix}_{stamp}" if prefix else stamp
+
+
+def game_output_dir(game_id: str) -> Path:
+    """``test_data/outputs/<game_id>/``"""
+    return OUTPUT_ROOT / game_id
+
+
+def run_dir(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
+    """``test_data/outputs/<game_id>/<run_id>/`` — root of one generation run."""
+    return game_output_dir(game_id) / run_id
+
+
+def task_output_dir(
+    game_id: str,
+    task_kind: str,
+    task_id: str,
+    run_id: str = DEFAULT_RUN_ID,
+    create: bool = True,
+) -> Path:
+    """
+    ``test_data/outputs/<game_id>/<run_id>/<layer>/[<task_kind>/]<task_id>/``
+
+    One directory per task, so an artifact ships alongside its preview,
+    intermediates and ``meta.json`` without filename mangling.
+    """
+    check_kind(task_kind)
+    layer = TASK_LAYER[task_kind]
+    base = run_dir(game_id, run_id) / layer
+    # assets/ is further split by kind; mechanic/ ui/ pipeline/ *are* the kind.
+    if layer == "assets":
+        base = base / task_kind
+    path = base / task_id
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def eval_output_dir(
+    game_id: str,
+    task_kind: str,
+    task_id: str,
+    run_id: str = DEFAULT_RUN_ID,
+    create: bool = True,
+) -> Path:
+    """``test_data/outputs/<game_id>/<run_id>/eval/<task_kind>/<task_id>/``"""
+    check_kind(task_kind)
+    path = run_dir(game_id, run_id) / "eval" / task_kind / task_id
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def eval_summary_path(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
+    """``test_data/outputs/<game_id>/<run_id>/eval/summary.json``"""
+    return run_dir(game_id, run_id) / "eval" / "summary.json"
+
+
+def results_summary_path(game_id: str, task_kind: str,
+                         run_id: str = DEFAULT_RUN_ID) -> Path:
+    """``test_data/outputs/<game_id>/<run_id>/<task_kind>_results_summary.json``"""
+    check_kind(task_kind)
+    return run_dir(game_id, run_id) / f"{task_kind}_results_summary.json"
+
+
+def run_meta_path(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
+    """``test_data/outputs/<game_id>/<run_id>/run_meta.json``"""
+    return run_dir(game_id, run_id) / "run_meta.json"
+
+
+# ── Run bookkeeping ───────────────────────────────────────────────────────────
+
+def _git_sha() -> Optional[str]:
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(REPO_ROOT), "rev-parse", "--short", "HEAD"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return out.stdout.strip() or None
+    except Exception:
+        return None
+
+
+def update_latest_link(game_id: str, run_id: str) -> None:
+    """Repoint ``<game_id>/latest`` at ``run_id`` (best effort, never fatal)."""
+    if run_id == LATEST_LINK:
+        return
+    link = game_output_dir(game_id) / LATEST_LINK
+    try:
+        link.parent.mkdir(parents=True, exist_ok=True)
+        if link.is_symlink() or link.exists():
+            link.unlink()
+        link.symlink_to(run_id, target_is_directory=True)
+    except OSError:
+        pass  # filesystem without symlink support — not fatal
+
+
+def write_run_meta(
+    game_id: str,
+    run_id: str = DEFAULT_RUN_ID,
+    *,
+    task_kind: Optional[str] = None,
+    extra: Optional[dict[str, Any]] = None,
+) -> Path:
+    """Record how a run was produced, so results stay reproducible."""
+    path = run_meta_path(game_id, run_id)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    meta: dict[str, Any] = {
+        "game_id": game_id,
+        "run_id": run_id,
+        "task_kind": task_kind,
+        "created_at": datetime.now().isoformat(timespec="seconds"),
+        "git_sha": _git_sha(),
+        "argv": sys.argv,
+    }
+    if extra:
+        meta.update(extra)
+
+    if path.exists():  # merge with an earlier task_kind in the same run
+        try:
+            prev = json.loads(path.read_text(encoding="utf-8"))
+            history = prev.pop("history", [])
+            history.append(prev)
+            meta["history"] = history
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    path.write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
+    return path
+
+
+def write_task_meta(task_dir: str | Path, meta: dict[str, Any]) -> Path:
+    """Write ``<task_dir>/meta.json`` next to the artifacts."""
+    d = Path(task_dir)
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / "meta.json"
+    from .record_paths import portable_value
+    path.write_text(json.dumps(portable_value(meta, d), indent=2, ensure_ascii=False, default=str),
+                    encoding="utf-8")
+    return path
+
+
+def write_results_summary(results: list[dict], task_kind: str,
+                         run_id: str = DEFAULT_RUN_ID) -> list[Path]:
+    """
+    Group ``run()`` results by ``game_id`` and write one summary per game,
+    refresh ``run_meta.json`` and the ``latest`` symlink.
+
+    Returns the summary paths written.
+    """
+    check_kind(task_kind)
+    grouped: dict[str, list[dict]] = {}
+    for r in results:
+        grouped.setdefault(r.get("game_id") or UNASSIGNED_GAME, []).append(r)
+
+    written = []
+    for game_id, items in grouped.items():
+        path = results_summary_path(game_id, task_kind, run_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(items, indent=2, ensure_ascii=False, default=str),
+                        encoding="utf-8")
+        write_run_meta(game_id, run_id, task_kind=task_kind,
+                       extra={"num_tasks": len(items)})
+        update_latest_link(game_id, run_id)
+        written.append(path)
+    return written
+
+
+# ── Misc ──────────────────────────────────────────────────────────────────────
+
+def resolve_input_path(path_like: str | Path) -> Path:
+    """Resolve a possibly repo-relative input path (jsonl paths are repo-relative)."""
+    if str(path_like).replace("\\", "/").startswith("bench/"):
+        from .record_paths import resolve_path
+        return resolve_path(path_like)
+    p = Path(path_like)
+    if p.is_absolute() or p.exists():
+        return p
+    return REPO_ROOT / p
+
+
+def rel_to_repo(path: str | Path) -> str:
+    """Repo-relative string if possible, else the absolute path — for logs / meta."""
+    p = Path(path).resolve()
+    try:
+        return str(p.relative_to(REPO_ROOT))
+    except ValueError:
+        return str(p)

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py

@@ -0,0 +1,77 @@
+"""Portable workspace paths for persisted records; resolve only when doing I/O."""
+from __future__ import annotations
+
+from pathlib import Path
+import re
+
+BENCH = Path(__file__).resolve().parents[3]
+_PREFIXES = ("test_data/", "GameFactory-3A/", "scripts/", "prompts/", "config/", "reports/")
+_ROOT = BENCH.as_posix()
+_INLINE_ROOT = re.compile(re.escape(_ROOT).replace("/", r"[\\/]"), re.IGNORECASE)
+
+
+def resolve_path(value: str | Path) -> Path:
+    text = str(value).replace("\\", "/")
+    if text == "bench" or text.startswith("bench/"):
+        path = (BENCH.parent / text).resolve()
+        path.relative_to(BENCH.resolve())
+        return path
+    path = Path(value)
+    return path if path.is_absolute() else BENCH / path
+
+
+def portable_path(value: str | Path, base: Path | None = None) -> str:
+    original = str(value)
+    text = original.replace("\\", "/")
+    if re.match(r"^[A-Za-z][A-Za-z0-9+.-]*:", text) and not re.match(r"^[A-Za-z]:/", text):
+        return original  # URLs, API URIs and dependency descriptors retain their meaning.
+    if text.casefold() == _ROOT.casefold() or text.casefold().startswith(_ROOT.casefold() + "/"):
+        return "bench" + text[len(_ROOT):]
+    if text == "bench" or text.startswith("bench/"):
+        path = resolve_path(text)
+        suffix = path.relative_to(BENCH.resolve()).as_posix()
+        return "bench" if suffix == "." else "bench/" + suffix
+    if text.startswith(_PREFIXES):
+        path = (BENCH / text).resolve()
+        path.relative_to(BENCH.resolve())
+        return "bench/" + path.relative_to(BENCH.resolve()).as_posix()
+    if base is not None and "/" in text and "\n" not in text and not text.startswith("/"):
+        candidate = base / text
+        try:
+            if candidate.exists():
+                return "bench/" + candidate.resolve().relative_to(BENCH.resolve()).as_posix()
+        except (OSError, ValueError):
+            pass
+    return original
+
+
+def portable_text(value: str) -> str:
+    """Convert workspace paths embedded in log/error text, leaving URLs intact."""
+    pattern = re.compile(r"(?:https?://[^\s<>]+)|(" + _INLINE_ROOT.pattern + r"(?:[\\/][^\r\n\"'<>|;,)]*)?)", re.IGNORECASE)
+    return pattern.sub(lambda match: portable_path(match.group(1)) if match.group(1) else match.group(0), value)
+
+
+def portable_value(value, base: Path | None = None):
+    if isinstance(value, dict):
+        return {portable_path(key) if isinstance(key, str) else key: portable_value(item, base)
+                for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [portable_value(item, base) for item in value]
+    if isinstance(value, Path):
+        return portable_path(value, base)
+    if isinstance(value, str):
+        result = portable_path(value, base)
+        return portable_text(result)
+    return value
+
+
+def runtime_value(value):
+    """Hydrate a verified frozen plan for runtime use; never use before hashing."""
+    if isinstance(value, dict):
+        return {str(resolve_path(key)) if isinstance(key, str) and (key == "bench" or key.startswith("bench/")) else key:
+                runtime_value(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [runtime_value(item) for item in value]
+    if isinstance(value, str) and (value == "bench" or value.startswith("bench/")):
+        return str(resolve_path(value))
+    return value

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md

@@ -0,0 +1,95 @@
+# GameFactory-3A Stage 2 — asset generation
+
+你正在执行同一个游戏测例的第二阶段资产生成。**开始前必须先阅读 `{SETTING_OVERVIEW}`，并严格遵循其中的 asset refinement、asset QA 和 validation 流程。**
+
+## 测例输入
+
+- 游戏测例：`{GAME_ID}`
+- 测例目录：`{CASE_ROOT}`
+- GameFactory-3A 根目录：`{FRAMEWORK_ROOT}`
+- 总入口文档：`{SETTING_OVERVIEW}`
+- 目标引擎：`{ENGINE}`
+- 完整游戏需求：`{GENERAL_REQUIREMENT}`
+- 当前 run 根目录：`{RUN_ROOT}`
+- runner 控制面（冻结索引、prompt/packet/log）：`{GENERATION_CONTROL_ROOT}`
+- 第一阶段白模 run：`{WHITEBOX_RUN_ROOT}`
+- 第一阶段白模 workspace：`{WHITEBOX_WORKSPACE}`
+- 第一阶段资产接口：`{ASSET_SLOTS}`
+- 第一阶段计划/TODO：`{GENERATION_PLAN}`
+- 外部冻结的资产任务索引：`{ASSET_TASK_INDEX}`
+- 资产输出根目录：`{ASSET_OUTPUT_ROOT}`
+- 当前阶段 pipeline task 目录：`{STAGE_WORKSPACE}`
+- 资产 QA 证据根：`{RUN_ROOT}/eval/<task_kind>/<task_id>/`
+
+请读取游戏完整梗概和玩法，再读取 `{ASSET_TASK_INDEX}` 中列出的**每一条**资产任务、对应的 requirement、JSONL 和参考图片。**每一个资产生成任务都必须使用完整游戏梗概作为上下文**，不能只把孤立的资产 prompt 交给生成流程。
+
+## 本阶段任务
+
+1. 根据第一阶段的任务拆解、TODO 和 `asset_slots.json` 确认资产用途、生命周期、比例、朝向、挂点和风格；
+2. 按 `setting_overview.md` 路由到对应的 T-pose、3D object、3D scene、Motion、Audio、CG video 或其他资产 Skill；
+3. 逐项生成冻结任务索引中的所有资产，并执行对应的结构/视觉 QA；
+4. 保持第一阶段定义的 asset ID 和游戏/UI/mechanic contract 不变；
+5. 记录资产来源、配置、参考图、QA 和后续导入要求；
+6. 生成完整的资产 manifest，供第三阶段导入使用。
+
+## 限制
+
+- 不修改第一阶段核心游戏机制和需求；
+- 不擅自删除、合并或跳过资产任务；
+- 资产失败必须记录为失败，不能伪造成功；
+- 不将资产生成 QA 当成游戏已经完成；
+- 本阶段默认不执行 Agent repair。
+
+## 输出位置和 Layer 规则
+
+资产必须按框架标准布局写入：
+
+- `{ASSET_OUTPUT_ROOT}/tpose/<task_id>/`；
+- `{ASSET_OUTPUT_ROOT}/3d_object/<task_id>/`；
+- `{ASSET_OUTPUT_ROOT}/3d_scene/<task_id>/`；
+- `{ASSET_OUTPUT_ROOT}/motion/<task_id>/`；
+- `{ASSET_OUTPUT_ROOT}/audio/<task_id>/`；
+- `{ASSET_OUTPUT_ROOT}/cg_video/<task_id>/`。
+
+每个任务目录至少应有资产文件、`meta.json`、预览（若适用）和 QA 证据。资产 manifest 和阶段产物说明写入 `{ASSET_MANIFEST}`（位于标准 `pipeline/<task_id>/` task 目录）；冻结索引只读自 `{ASSET_TASK_INDEX}`，runner 控制文件写入 `{GENERATION_CONTROL_ROOT}`。每个资产任务的 QA 证据写入 `{RUN_ROOT}/eval/<task_kind>/<task_id>/`。至少生成：
+
+- `asset_manifest.json`；
+- `asset_generation_report.json`；
+- `asset_task_index.json`（由外部入口生成，不得删改任务）；
+- 失败任务及其失败原因。
+
+不要写入 case 输入目录、不要覆盖白模 run，也不要创建 `pipeline/assets/` stage 目录；真实资产必须按 `assets/<task_kind>/<task_id>/` 放置，不能把所有文件平铺在 pipeline task 目录。
+
+## 已确认的优先 3D Object 双服务对比
+
+当用户明确选择优先 200 条对象任务的 Meshy / Tripo API 对比时，使用
+`scripts/asset/generate_3d_comparison.py` 与 `config/asset_3d_comparison.json`，
+具体命令和费用见 `scripts/asset/README_3d_comparison.md`。这是跨游戏的对象生成实验；
+各游戏只包含 3D Object 子集，不能将其标为六类资产齐全的完整 Stage 2。
+
+- 输入以 `test_data/priority_gen/3d_object_priority_lowpoly_collect.jsonl` 的全部 200 条为准，
+  保留原 task ID、prompt、seed、参考图及最高 8000 三角面的既定政策。
+- 完整游戏需求保留在冻结输入包；两家文生调用使用完全相同的短梗概和原资产 prompt，
+  合计不超过 800 字符。API 未接收完整正文这一事实必须记录，不能宣称正文已送入模型。
+- 两家图生均使用同一冻结参考图，列入 `reference_only` 辅助组；不要为了补文字上下文
+  悄悄改图、另画参考图、改变原任务的输入模式或仅给一家添加贴图提示词。
+- 每家分别运行全部 200 条。按人物/刚体、文生/图生及上下文条件分组；Hunyuan3D Pro
+  仅保留后续接入口，本轮不启用、不消耗第三家额度。
+- 固定具体模型版本，不使用 `latest`；Meshy 本轮使用 standard + remesh，
+  不依赖将于 2026-10-30 退役的 `model_type=lowpoly`。
+- 原始 API mesh 写为 `model.glb`，统一后处理的导入 mesh 写为 `import/model.glb`。
+  两家使用同一固定工具、参数与贴���上限；分别记录原始和后处理 QA、耗时及缺陷。
+  减面未达到预算应如实记录失败，不增加生成次数、不换模型补齐或挑选 best-of。
+- 付费调用前需要用户确认预算并在环境中配置密钥。提交后立刻落盘任务 ID；
+  已知远端任务只续查结果，提交结果不确定时停下核对，不自动重发付费任务。
+- 本轮按游戏级共享资产目录落盘，在任务目录下加厂商一级：
+  `test_data/outputs/<game_id>/assets/3d_object/<task_id>/<provider>/`，
+  `<provider>` 为 `meshy` / `tripo`，不使用 `asset_comparison` 输出目录。
+  原始 `model.glb`、`import/model.glb`、`meta.json`、服务端预览均放在厂商目录内；
+  QA 写入 `test_data/outputs/<game_id>/eval/3d_object/<task_id>/<provider>/`。
+  manifest/阶段报告按游戏、批次、厂商放在
+  `test_data/outputs/<game_id>/pipeline/<game_id>_pipeline/<batch_id>/<provider>/`，
+  冻结输入、计费回执与跨游戏预览保存在 `test_data/outputs/_asset_batches/<batch_id>/`。
+  不覆盖不同批次已有的厂商资产，也不覆盖白模工程。
+  结构检查通过不等于视觉 QA 通过；C、Q1/Q2/Q3 的正式评分缺少证据时保持 UNKNOWN。
+  第三阶段的资产来源需要另行固定，不能按逐条最高评分混选两家产物。

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py

@@ -0,0 +1,178 @@
+"""Durable submit receipts for the comparison runner; no automatic POST retry.
+
+Uses the framework's HTTP plumbing. A lost create response is ambiguous: retain
+the credit reservation and require reconciliation instead of buying a new task.
+The runner holds one batch lock while using this client.
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any
+
+from models.common import cloud_api
+from pipeline.common.record_paths import portable_value, portable_text
+
+
+def read_json(path: Path, default=None):
+    return json.loads(path.read_text(encoding="utf-8")) if path.is_file() else default
+
+
+def write_json(path: Path, value: Any, *, portable: bool = True) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + ".tmp")
+    with temporary.open("w", encoding="utf-8", newline="\n") as stream:
+        json.dump(portable_value(value, path.parent) if portable else value,
+                  stream, ensure_ascii=False, indent=2)
+        stream.write("\n")
+        stream.flush()
+        os.fsync(stream.fileno())
+    os.replace(temporary, path)
+
+
+def safe_error(exc: Exception) -> str:
+    value = str(exc)
+    for name in ("MESHY_API_KEY", "TRIPO_API_KEY"):
+        secret = os.environ.get(name)
+        if secret:
+            value = value.replace(secret, "[REDACTED]")
+    return portable_text(value)[:1600]
+
+
+class BudgetExceeded(RuntimeError):
+    pass
+
+
+class AmbiguousSubmission(RuntimeError):
+    pass
+
+
+def reserved_credits(directory: Path) -> int:
+    return sum(
+        int(item["reserved_credits"])
+        for path in directory.glob("*.json")
+        for item in read_json(path, {}).get("submissions", {}).values()
+        if item["status"] != "rejected"
+    )
+
+
+class JournalClient:
+    """Replay successful create receipts and query the same remote task on resume."""
+
+    def __init__(self, base: str, key: str, journal: Path, cap: int,
+                 prices: dict[str, int], provider: str, transport=None, resume_refused=False):
+        self.journal = journal
+        self.cap = cap
+        self.prices = prices
+        self.provider = provider
+        self.resume_refused = resume_refused
+        # GET is safe to retry. A billed POST gets exactly one transport attempt.
+        self.reader = transport or cloud_api.CloudAPIClient(base, key, max_retries=3)
+        self.writer = transport or cloud_api.CloudAPIClient(base, key, max_retries=0)
+        self.public = None
+
+    def _cost(self, endpoint: str, body: dict) -> int:
+        if endpoint == "/files":
+            return 0
+        if self.provider == "meshy":
+            if endpoint == "/openapi/v2/text-to-3d":
+                return self.prices["text_refine" if body.get("mode") == "refine" else "text_preview"]
+            if endpoint == "/openapi/v1/image-to-3d":
+                return self.prices["image"]
+        elif endpoint in ("/generation/text-to-model", "/generation/image-to-model"):
+            return self.prices["text" if "text-to" in endpoint else "image"]
+        raise ValueError(f"Unpriced POST endpoint: {endpoint}")
+
+    def request(self, method: str, endpoint: str, **kwargs):
+        state = read_json(self.journal, {"submissions": {}, "results": {}})
+        if method != "POST":
+            result = self.reader.request(method, endpoint, **kwargs)
+            if method == "GET" and isinstance(result, dict):
+                state["results"][endpoint] = result
+                payload = result.get("data", result)
+                if isinstance(payload, dict):
+                    remote_id = payload.get("task_id") or payload.get("id")
+                    reported = payload.get("credits_consumed", payload.get("credits"))
+                    for record in state["submissions"].values():
+                        if remote_id and record.get("remote_id") == remote_id and isinstance(reported, (int, float)):
+                            record["reported_credits"] = reported
+                            record["reserved_credits"] = max(record["reserved_credits"], math.ceil(reported))
+                write_json(self.journal, state)
+            return result
+
+        # Hash binary inputs; never persist image bytes or credentials in receipts.
+        descriptor = {"endpoint": endpoint, "body": kwargs.get("json_body"),
+                      "files": {name: cloud_api.bytes_hash(value[1])
+                                for name, value in (kwargs.get("files") or {}).items()}}
+        fingerprint = cloud_api.request_hash(descriptor)
+        previous = state["submissions"].get(fingerprint)
+        if previous:
+            if previous["status"] == "created":
+                return previous["response"]
+            if previous["status"] == "rejected" and not (self.resume_refused and previous.get("resource_refusal")):
+                raise cloud_api.CloudAPIRequestError(previous["error"])
+            if previous["status"] != "rejected":
+                raise AmbiguousSubmission(
+                    f"Unconfirmed submission {fingerprint} in {self.journal}. "
+                    "Reconcile its remote task ID; no automatic resubmission.")
+
+        cost = self._cost(endpoint, kwargs.get("json_body") or {})
+        used = reserved_credits(self.journal.parent)
+        if used + cost > self.cap:
+            raise BudgetExceeded(f"{self.provider}: {used} reserved + {cost} exceeds cap {self.cap}")
+        record = {"endpoint": endpoint, "reserved_credits": cost, "status": "submitting"}
+        if previous:
+            record["rejection_history"] = [*previous.get("rejection_history", []),
+                {k: v for k, v in previous.items() if k != "rejection_history"}]
+        state["submissions"][fingerprint] = record
+        write_json(self.journal, state)  # commit before the request can incur a charge
+        try:
+            response = self.writer.request(method, endpoint, **kwargs)
+        except cloud_api.CloudAPIError as exc:
+            # These are explicit refusals. 5xx/timeouts may have created a task.
+            if exc.status in (400, 401, 402, 403, 404, 405, 413, 415, 422, 429):
+                record.update(status="rejected", error=safe_error(exc), resource_refusal=isinstance(
+                    exc, (cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError, cloud_api.CloudAPIRateLimitError)))
+            else:
+                record.update(status="uncertain", error=safe_error(exc))
+            write_json(self.journal, state)
+            if record["status"] == "uncertain":
+                raise AmbiguousSubmission(f"Unconfirmed POST {fingerprint}; {safe_error(exc)}") from exc
+            raise
+
+        rejected = isinstance(response, dict) and response.get("code") not in (None, 0)
+        envelope = response.get("data", response) if isinstance(response, dict) else {}
+        remote_id = (envelope.get("task_id") or envelope.get("id") or envelope.get("result")
+                     or envelope.get("file_token") or envelope.get("token")) if isinstance(envelope, dict) else None
+        if rejected:
+            rejection = cloud_api.classify_http_error(400, response)
+            record.update(status="rejected", error=safe_error(rejection), resource_refusal=isinstance(
+                rejection, (cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError)))
+        elif not remote_id:
+            record.update(status="uncertain", error="Response contained no remote task/file ID")
+        else:
+            record.update(status="created", remote_id=remote_id, response=response)
+        write_json(self.journal, state)
+        if rejected:
+            raise rejection
+        if record["status"] == "uncertain":
+            raise AmbiguousSubmission(f"Unconfirmed POST {fingerprint}: missing task/file ID")
+        return response
+
+    def download(self, url: str, **kwargs) -> bytes:
+        # Signed CDN downloads must not receive the provider's Authorization key.
+        if not url.startswith("https://"):
+            raise ValueError("Artifact download must use HTTPS")
+        if self.public is None:
+            self.public = cloud_api.CloudAPIClient("", "", max_retries=3)
+            self.public.session.headers.pop("Authorization", None)
+        return self.public.download(url, **kwargs)
+
+    def close(self):
+        self.reader.close()
+        if self.writer is not self.reader:
+            self.writer.close()
+        if self.public is not None:
+            self.public.close()

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py

@@ -0,0 +1,603 @@
+#!/usr/bin/env python3
+"""Prepare, run and resume the frozen Meshy/Tripo 200-object comparison.
+
+Prepare/status are offline. Run requires explicit spending caps and API keys.
+Native generation outputs remain unmodified. A shared postprocessor produces
+separate import meshes; visual acceptance is a separate review.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter, defaultdict
+from contextlib import contextmanager
+from datetime import datetime, timezone
+import hashlib
+import io
+import json
+import math
+import os
+from pathlib import Path
+import re
+import shutil
+import struct
+import subprocess
+import sys
+
+BENCH = Path(__file__).resolve().parents[2]
+FRAMEWORK = BENCH / "GameFactory-3A"
+sys.path.insert(0, str(FRAMEWORK))
+from pipeline.common import paths
+from pipeline.common.record_paths import portable_value, resolve_path, runtime_value
+from models.common import cloud_api
+from models.common.glb_utils import glb_json_chunk, glb_summary
+from cloud_journal import (AmbiguousSubmission, BudgetExceeded, JournalClient,
+                           read_json, reserved_credits, safe_error, write_json)
+
+DEFAULT_CONFIG = BENCH / "config/asset_3d_comparison.json"
+IDENTIFIER = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{0,160}$")
+RUNTIME_FILES = [Path(__file__), Path(__file__).with_name("cloud_journal.py"),
+                 FRAMEWORK / "pipeline/common/record_paths.py",
+                 FRAMEWORK / "pipeline/common/paths.py",
+                 BENCH / "prompts/stage2_assets.md",
+                 FRAMEWORK / "operators/gen_3d_object/operator.py",
+                 FRAMEWORK / "models/gen_3d_object/meshy_model.py",
+                 FRAMEWORK / "models/gen_3d_object/tripo_model.py",
+                 FRAMEWORK / "models/common/cloud_api.py",
+                 FRAMEWORK / "models/common/glb_utils.py",
+                 Path(__file__).with_name("mesh_tools") / "process_mesh.mjs",
+                 Path(__file__).with_name("mesh_tools") / "package-lock.json"]
+MESH_TOOL = Path(__file__).with_name("mesh_tools") / "process_mesh.mjs"
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def digest(path: Path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def checked_id(value: str):
+    if not IDENTIFIER.fullmatch(value):
+        raise ValueError(f"Invalid path identifier: {value!r}")
+    return value
+
+
+def bench_path(value: str):
+    result = resolve_path(value).resolve()
+    result.relative_to(BENCH.resolve())
+    return result
+
+
+def batch_directory(config: dict, batch_id: str):
+    return bench_path(config["output_root"]) / "_asset_batches" / checked_id(batch_id)
+
+
+@contextmanager
+def exclusive_batch(directory: Path):
+    """OS lock releases on process exit, including an interrupted run."""
+    directory.mkdir(parents=True, exist_ok=True)
+    with (directory / "batch.lock").open("a+b") as stream:
+        stream.seek(0, 2)
+        if stream.tell() == 0:
+            stream.write(b"0")
+            stream.flush()
+        stream.seek(0)
+        if os.name == "nt":
+            import msvcrt
+            msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        try:
+            yield
+        finally:
+            stream.seek(0)
+            if os.name == "nt":
+                msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                fcntl.flock(stream, fcntl.LOCK_UN)
+
+
+def game_directory(plan: dict, game: str):
+    return Path(plan["output_root"]) / checked_id(game)
+
+
+def pipeline_directory(plan: dict, provider: str, game: str):
+    return (game_directory(plan, game) / "pipeline" / (game + "_pipeline")
+            / checked_id(plan["batch_id"]) / checked_id(provider))
+
+
+def generation_index(plan: dict, provider: str, game: str):
+    return (game_directory(plan, game) / ".generation/3d_object" / checked_id(provider)
+            / checked_id(plan["batch_id"]) / "asset_task_index.json")
+
+
+def short_context(text: str, limit: int):
+    """Declared deterministic excerpts, not a claim that the model read the brief."""
+    title = re.search(r"^title:\s*(.+)$", text, re.M)
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    title_text = title.group(1) if title else next((s.lstrip("# ") for s in lines if s.startswith("#")), "")
+    world = next((line for line in lines if re.match(r"-\s*W01\b", line)), "")
+    loop = next((line for line in lines if any(word in line for word in ("核心循环：", "核心循环:", "核心玩法：", "核心玩法:"))), "")
+    if not loop:
+        loop = next((line for line in lines if re.match(r"-\s*S01\b", line)), "")
+    if not loop:
+        heading = re.search(r"^##[^\n]*(?:核心循环|一句话定位)[^\n]*\n([^#]+)", text, re.M)
+        loop = heading.group(1) if heading else ""
+    pieces = [re.sub(r"\s+", " ", value).strip()[:size]
+              for value, size in ((title_text, 70), (world, 110), (loop, 110)) if value]
+    value = " | ".join(pieces)
+    if not value:
+        raise ValueError("Cannot extract game context; provide a reviewed short context")
+    return value[:limit]
+
+
+def frozen_copy(source: Path, destination: Path):
+    if destination.exists() and digest(destination) != digest(source):
+        raise ValueError(f"Frozen input changed; use a new batch ID: {destination}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if not destination.exists():
+        shutil.copyfile(source, destination)
+    return {"path": str(destination.resolve()), "sha256": digest(destination),
+            "source": str(source.resolve())}
+
+
+def node_process(arguments: list[str], timeout: int):
+    node = shutil.which("node")
+    if not node:
+        raise ValueError("Node.js is required for the fixed mesh pipeline")
+    environment = os.environ.copy()
+    for key in ("MESHY_API_KEY", "TRIPO_API_KEY"):
+        environment.pop(key, None)
+    if os.name == "nt":
+        # Conda's DLLs can shadow sharp's libvips dependencies in child processes.
+        environment["PATH"] = str(Path(node).parent) + os.pathsep + str(Path(os.environ["SystemRoot"]) / "System32")
+    return subprocess.run([node, str(MESH_TOOL), *arguments], capture_output=True,
+                          text=True, encoding="utf-8", timeout=timeout, env=environment)
+
+
+def mesh_runtime():
+    result = node_process(["--check"], timeout=60)
+    if result.returncode:
+        raise ValueError("Mesh postprocessor unavailable; run npm ci in scripts/asset/mesh_tools. " + result.stderr[-500:])
+    return json.loads(result.stdout)
+
+
+def subject_group(task: dict):
+    role = task.get("role", "")
+    return "character" if task.get("rig", "none") != "none" or role in (
+        "character", "player", "event_figure", "npc", "creature", "unit_special") or role.startswith("enemy") else "rigid"
+
+
+def prepare(config: dict, batch_id: str):
+    if config["input_policy"] != "shared_short_context_and_reference_only" or not config["input_policy_confirmed"]:
+        raise ValueError("The input protocol must be confirmed before preparing this comparison")
+    directory = batch_directory(config, batch_id)
+    plan_file = directory / "plan.json"
+    if plan_file.exists():
+        raise ValueError(f"Batch is already frozen: {plan_file}. Use status/run or a new batch ID.")
+    source = bench_path(config["tasks"])
+    tasks = [json.loads(line) for line in source.read_text(encoding="utf-8-sig").splitlines() if line.strip()]
+    if len(tasks) != config["expected_tasks"]:
+        raise ValueError(f"Expected {config['expected_tasks']} tasks; got {len(tasks)}")
+    for task in tasks:
+        for provider in config["providers"]:
+            output = (bench_path(config["output_root"]) / checked_id(task["game_id"])
+                      / "assets/3d_object" / checked_id(task["task_id"]) / checked_id(provider))
+            if output.is_dir() and any(p.name != ".gitkeep" for p in output.iterdir()):
+                raise ValueError(f"Provider directory already contains assets; resume its batch: {output}")
+    seen = set()
+    frozen_tasks = []
+    documents = {}
+    tool_runtime = mesh_runtime()
+    for task in tasks:
+        game = checked_id(task["game_id"])
+        task_id = checked_id(task["task_id"])
+        identity = (game, task_id)
+        if identity in seen:
+            raise ValueError(f"Duplicate task: {identity}")
+        seen.add(identity)
+        case = BENCH / "test_data/test_samples" / game
+        if game not in documents:
+            requirement = case / "general_requirement.txt"
+            full_text = requirement.read_text(encoding="utf-8")
+            doc_root = directory / "inputs" / game
+            documents[game] = {
+                "general_requirement": frozen_copy(requirement, doc_root / "general_requirement.txt"),
+                "object_requirement": frozen_copy(case / "3D_object/requirement.txt", doc_root / "object_requirement.txt"),
+                "context_excerpt": short_context(full_text, config["context_excerpt_max_chars"]),
+                "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally",
+            }
+        mode = task["input_mode"]
+        prompt = None
+        reference = None
+        if mode == "text_to_3d":
+            # Never shorten the asset prompt. Both providers receive this exact string.
+            prompt = f"Game context (excerpt): {documents[game]['context_excerpt']}\nAsset: {task['prompt']}"
+            if len(prompt) > config["shared_prompt_max_chars"]:
+                raise ValueError(f"Shared prompt exceeds limit: {task_id} ({len(prompt)} chars)")
+        elif mode == "image_to_3d":
+            source_image = bench_path(task["image_path"])
+            reference = frozen_copy(source_image, directory / "references" / (digest(source_image) + source_image.suffix.lower()))
+        else:
+            raise ValueError(f"Unsupported input mode: {mode}")
+        if not 500 <= task["decimation_target"] <= 8000:
+            raise ValueError(f"Unexpected triangle target: {task_id}")
+        frozen_tasks.append({"task": task, "shared_prompt": prompt, "reference": reference,
+                             "subject_group": subject_group(task),
+                             "context_condition": "shared_short_context" if prompt else "reference_only"})
+    output_root = bench_path(config["output_root"])
+    plan = {"schema_version": "asset_3d_comparison_plan_v1", "batch_id": batch_id,
+            "created_at": now(), "scope": "3d_object_only_not_complete_stage2",
+            "config": config, "output_root": str(output_root), "directory": str(directory),
+            "source": frozen_copy(source, directory / "inputs/source_tasks.jsonl"),
+            "method_reference": frozen_copy(bench_path(config["method_reference"]), directory / "inputs/method_selection.md"),
+            "documents": documents, "tasks": frozen_tasks,
+            "runtime_sources": {str(p.resolve()): digest(p) for p in RUNTIME_FILES},
+            "estimated_credits": {}, "recommended_credit_caps": {},
+            "qa_policy": "basic structural checks + pending visual review; no automatic acceptance",
+            "texture_policy": "preserve native output; same deterministic downsize for both import meshes",
+            "postprocess": config["postprocess"], "mesh_runtime": tool_runtime,
+            "deferred_providers": {"hunyuan3d_pro": {"status": "not_enabled", "adapter_contract":
+                "infer_and_save(image, output_path, seed, decimation_target, texture_size, *, prompt); requires pinned cloud version and input capability check"}}}
+    for provider, settings in config["providers"].items():
+        prices = settings["credits"]
+        estimate = sum((prices["text_preview"] + prices["text_refine"] if provider == "meshy" else prices["text"])
+                       if item["shared_prompt"] else prices["image"] for item in frozen_tasks)
+        plan["estimated_credits"][provider] = estimate
+        plan["recommended_credit_caps"][provider] = (estimate * 11 + 9) // 10
+    plan["plan_sha256"] = cloud_api.request_hash(portable_value(plan))
+    write_json(plan_file, plan)
+    write_json(directory / "asset_task_index.json", {"plan_sha256": plan["plan_sha256"],
+        "task_count": len(frozen_tasks), "tasks": frozen_tasks})
+    for provider in config["providers"]:
+        for game in documents:
+            write_json(generation_index(plan, provider, game), {
+                "plan_sha256": plan["plan_sha256"], "game_id": game, "provider": provider,
+                "scope": plan["scope"], "tasks": [item for item in frozen_tasks if item["task"]["game_id"] == game]})
+    refresh_reports(plan)
+    return plan
+
+
+def load_plan(config: dict, batch_id: str):
+    plan = read_json(batch_directory(config, batch_id) / "plan.json")
+    if not plan:
+        raise ValueError("Prepare this batch first")
+    claimed = plan["plan_sha256"]
+    if cloud_api.request_hash({k: v for k, v in plan.items() if k != "plan_sha256"}) != claimed:
+        raise ValueError("Frozen plan was modified")
+    return runtime_value(plan)
+
+
+def validate_inputs(plan: dict):
+    if mesh_runtime() != plan["mesh_runtime"]:
+        raise ValueError("Mesh runtime differs from the frozen version")
+    for filename, expected in plan["runtime_sources"].items():
+        if digest(Path(filename)) != expected:
+            raise ValueError(f"Runtime changed after freeze: {filename}; prepare a new batch")
+    files = [plan["source"], plan["method_reference"]]
+    files.extend(doc[field] for doc in plan["documents"].values()
+                 for field in ("general_requirement", "object_requirement"))
+    files.extend(item["reference"] for item in plan["tasks"] if item["reference"])
+    for entry in files:
+        if digest(Path(entry["path"])) != entry["sha256"]:
+            raise ValueError(f"Frozen input changed: {entry['path']}")
+
+
+def basic_qa(filename: Path, task: dict):
+    data = filename.read_bytes()
+    summary = glb_summary(data)
+    checks = {"parseable_glb": "error" not in summary}
+    if checks["parseable_glb"]:
+        doc = glb_json_chunk(data)
+        checks["glb_v2_exact_length"] = struct.unpack_from("<II", data, 4) == (2, len(data))
+        checks["positive_triangle_count"] = bool(summary["triangles"])
+        checks["triangle_budget"] = 0 < summary["triangles"] <= task["decimation_target"]
+        checks["materials_present"] = summary["materials"] > 0
+        checks["textures_present"] = summary["textures"] > 0 and summary["images"] > 0
+        primitives = [p for m in doc.get("meshes", []) for p in m.get("primitives", [])]
+        checks["uv_present"] = bool(primitives) and all("TEXCOORD_0" in p.get("attributes", {}) for p in primitives)
+        checks["self_contained"] = all("uri" not in b or b["uri"].startswith("data:") for b in doc.get("buffers", [])) and all(
+            "bufferView" in image or str(image.get("uri", "")).startswith("data:") for image in doc.get("images", []))
+    return {"status": "PASS" if all(checks.values()) else "FAIL", "checks": checks,
+            "summary": summary, "triangle_target": task["decimation_target"],
+            "requested_texture_size": task.get("texture_size"),
+            "texture_budget_verified": False, "visual_status": "PENDING",
+            "limitations": ["No visual, orientation, scale, rigging or engine acceptance yet",
+                            "Native texture resolution retained; task texture_size is not enforced",
+                            "Basic checks do not validate every accessor, topology defect or PBR channel"]}
+
+
+def process_import_mesh(source: Path, task: dict):
+    destination = source.parent / "import/model.glb"
+    result = node_process([str(source), str(destination), str(task["decimation_target"]),
+                           str(task["texture_size"])], timeout=300)
+    if result.returncode:
+        raise RuntimeError("Postprocessing failed: " + result.stderr[-1200:])
+    report = json.loads(result.stdout)
+    return destination, report
+
+
+def task_directories(plan: dict, provider: str, task: dict):
+    root = game_directory(plan, task["game_id"])
+    task_id, provider = checked_id(task["task_id"]), checked_id(provider)
+    output = root / "assets/3d_object" / task_id / provider
+    evaluation = root / "eval/3d_object" / task_id / provider
+    return output, evaluation
+
+
+def refresh_reports(plan: dict):
+    summary = {"batch_id": plan["batch_id"], "plan_sha256": plan["plan_sha256"],
+               "updated_at": now(), "expected_assets": len(plan["tasks"]) * len(plan["config"]["providers"]),
+               "estimated_credits": plan["estimated_credits"], "providers": {}}
+    for provider in plan["config"]["providers"]:
+        by_game = defaultdict(list)
+        for item in plan["tasks"]:
+            task = item["task"]
+            output, evaluation = task_directories(plan, provider, task)
+            meta = read_json(output / "meta.json", {})
+            by_game[task["game_id"]].append({"task_id": task["task_id"], "asset_name": task["asset_name"],
+                "task_kind": "3d_object", "status": meta.get("status", "prepared"),
+                "artifact": str(output / "import/model.glb"), "native_artifact": str(output / "model.glb"),
+                "meta": str(output / "meta.json"), "native_structural_qa": meta.get("native_structural_qa"),
+                "import_structural_qa": meta.get("import_structural_qa"),
+                "native_delivered": meta.get("native_delivered", False),
+                "import_delivered": meta.get("import_delivered", False),
+                "qa": str(evaluation / "qa.json"), "visual_status": "PENDING",
+                "context_condition": item["context_condition"], "subject_group": item["subject_group"],
+                "input_mode": task["input_mode"], "error": meta.get("error")})
+        all_entries = [entry for entries in by_game.values() for entry in entries]
+        summary["providers"][provider] = {"task_count": len(all_entries),
+            "status_counts": dict(Counter(entry["status"] for entry in all_entries)),
+            "reserved_credits": reserved_credits(Path(plan["directory"]) / "submissions" / provider),
+            "visual_accepted": 0, "method_group": plan["config"]["method_group"],
+            "benchmark_metrics": {name: {"status": "UNKNOWN", "value": None}
+                                  for name in ("C", "Q1", "Q2", "Q3")},
+            "subgroups": {key: dict(Counter(e[key] for e in all_entries))
+                          for key in ("subject_group", "input_mode", "context_condition")},
+            "game_macro_delivery": sum(sum(e["status"] == "delivered" for e in entries) / len(entries)
+                                       for entries in by_game.values()) / len(by_game),
+            "game_macro_native_delivery": sum(sum(e["native_delivered"] for e in entries) / len(entries)
+                                               for entries in by_game.values()) / len(by_game),
+            "native_structural_pass": sum(e["native_structural_qa"] == "PASS" for e in all_entries),
+            "import_structural_pass": sum(e["import_structural_qa"] == "PASS" for e in all_entries),
+            "delivery_metric_status": "NOT_RUN" if all(e["status"] == "prepared" for e in all_entries) else "PARTIAL"}
+        for game, entries in by_game.items():
+            pipeline = pipeline_directory(plan, provider, game)
+            manifest = {"game_id": game, "provider": provider, "batch_id": plan["batch_id"],
+                "plan_sha256": plan["plan_sha256"], "scope": plan["scope"], "assets": entries,
+                "full_context": plan["documents"][game], "status": "pending_visual_review"}
+            write_json(pipeline / "asset_manifest.json", manifest)
+            write_json(pipeline / "asset_generation_report.json", {
+                "task_count": len(entries), "status_counts": dict(Counter(e["status"] for e in entries)),
+                "failures": [e for e in entries if e["error"]], "visual_accepted": 0})
+            paths.write_task_meta(pipeline, {"game_id": game, "task_id": game + "_pipeline",
+                "task_kind": "pipeline", "run_id": plan["batch_id"], "status": "comparison_only",
+                "provider": provider, "scope": plan["scope"]})
+    write_json(Path(plan["directory"]) / "asset_generation_report.json", summary)
+    return summary
+
+
+def make_model(plan: dict, provider: str, task: dict, cap: int):
+    from models.gen_3d_object.meshy_model import MeshyModel
+    from models.gen_3d_object.tripo_model import TripoModel
+    settings = plan["config"]["providers"][provider]
+    cls = MeshyModel if provider == "meshy" else TripoModel
+    control = Path(plan["directory"])
+    model = cls(model_path=settings["model"], device="cpu", api_base=settings["api_base"],
+                cache_dir=str(control / "cache" / task["game_id"] / task["task_id"]),
+                timeout=1800, poll_interval=5, **settings["options"])
+    key = cloud_api.require_api_key(None, provider.upper() + "_API_KEY", "See the comparison README")
+    journal = control / "submissions" / provider / (task["game_id"] + "__" + task["task_id"] + ".json")
+    model._client = JournalClient(settings["api_base"], key, journal, cap, settings["credits"], provider,
+                                  resume_refused=True)
+    return model
+
+
+def download_preview(model, output: Path):
+    from PIL import Image
+    url = model.last_call_info.get("preview_url")
+    if not url:
+        return {"status": "unavailable"}
+    try:
+        data = model.client.download(url)
+        with Image.open(io.BytesIO(data)) as preview:
+            preview.verify()
+            extension = {"PNG": ".png", "JPEG": ".jpg", "WEBP": ".webp"}.get(preview.format)
+        if not extension:
+            return {"status": "unsupported_image_format"}
+        path = output / ("preview" + extension)
+        path.write_bytes(data)
+        return {"status": "downloaded", "path": str(path), "visual_review": "PENDING"}
+    except Exception as exc:
+        return {"status": "failed", "error": safe_error(exc)}
+
+
+def run(plan: dict, args):
+    from operators.gen_3d_object.operator import Gen3DObjectOperator
+
+    class SharedStoreOperator(Gen3DObjectOperator):
+        def _resolve_out_path(self, inp, task_id):
+            output, _ = task_directories(plan, provider, inp)
+            output.mkdir(parents=True, exist_ok=True)
+            return inp["game_id"], output, output / "model.glb"
+
+    if not args.allow_paid:
+        raise ValueError("Paid generation requires --allow-paid and explicit provider credit caps")
+    validate_inputs(plan)
+    selected = list(dict.fromkeys(args.provider or list(plan["config"]["providers"])))
+    caps = {p: getattr(args, p + "_credit_cap") for p in selected}
+    for provider in selected:
+        if not caps[provider] or caps[provider] < reserved_credits(Path(plan["directory"]) / "submissions" / provider):
+            raise ValueError(f"Supply a positive --{provider}-credit-cap covering existing reservations")
+        cloud_api.require_api_key(None, provider.upper() + "_API_KEY", "See scripts/asset/README_3d_comparison.md")
+    selection = set(args.task_id or [])
+    known = {item["task"]["task_id"] for item in plan["tasks"]}
+    if selection - known:
+        raise ValueError(f"Unknown task IDs: {sorted(selection - known)}")
+    jobs = [item for item in plan["tasks"] if not selection or item["task"]["task_id"] in selection]
+    if args.limit is not None:
+        if args.limit < 1:
+            raise ValueError("--limit must be positive")
+        jobs = jobs[:args.limit]
+    write_json(Path(plan["directory"]) / "spending_authorization.json", {
+        "plan_sha256": plan["plan_sha256"], "credit_caps": caps, "recorded_at": now(),
+        "selected_task_ids": [item["task"]["task_id"] for item in jobs],
+        "note": "Caps reserve estimated credits; account-side limits remain authoritative"})
+    interrupted = False
+    for provider in selected:
+        failures = 0
+        for item in jobs:
+            task = item["task"]
+            output, evaluation = task_directories(plan, provider, task)
+            previous = read_json(output / "meta.json", {})
+            if previous and previous.get("plan_sha256") != plan["plan_sha256"]:
+                raise ValueError(f"Another batch owns this provider directory; do not overwrite: {output}")
+            if not previous and output.is_dir() and any(p.name != ".gitkeep" for p in output.iterdir()):
+                raise ValueError(f"Untracked provider artifacts must not be overwritten: {output}")
+            if previous.get("status") == "delivered" and (output / "model.glb").is_file():
+                imported = output / "import/model.glb"
+                if previous.get("artifact_sha256") == digest(output / "model.glb") and imported.is_file() and previous.get("import_sha256") == digest(imported):
+                    continue
+            if previous.get("status") == "failed":
+                continue  # one generation attempt, no cherry-picking on rerun
+            output.mkdir(parents=True, exist_ok=True)
+            meta = {"game_id": task["game_id"], "task_id": task["task_id"], "asset_name": task["asset_name"],
+                "task_kind": "3d_object", "run_id": plan["batch_id"], "provider": provider,
+                "plan_sha256": plan["plan_sha256"], "context_condition": item["context_condition"],
+                "full_context": plan["documents"][task["game_id"]], "source_task": task,
+                "shared_prompt": item["shared_prompt"], "reference": item["reference"],
+                "status": "running", "updated_at": now(), "visual_status": "PENDING"}
+            write_json(output / "meta.json", meta)
+            model = None
+            stop = False
+            try:
+                model = make_model(plan, provider, task, caps[provider])
+                # Preserve native output for a fair comparison. No automatic mesh cleanup/import.
+                inp = {**task, "strip_ground_plate": False}
+                inp.pop("asset_id", None)
+                if item["reference"]:
+                    inp["image_path"] = item["reference"]["path"]
+                else:
+                    inp["prompt"] = item["shared_prompt"]
+                result = SharedStoreOperator(model, run_id=plan["batch_id"]).run(inp)
+                raw_qa = basic_qa(Path(result["glb_path"]), task)
+                meta.update(native_delivered=raw_qa["checks"]["parseable_glb"], result=result,
+                            native_structural_qa=raw_qa["status"], model_call=model.last_call_info,
+                            artifact_sha256=digest(output / "model.glb"))
+                write_json(evaluation / "qa.json", {"native": raw_qa, "import": {"status": "PENDING"},
+                                                     "visual_status": "PENDING"})
+                imported, postprocess = process_import_mesh(Path(result["glb_path"]), task)
+                import_qa = basic_qa(imported, task)
+                import_qa["texture_budget_verified"] = all(max(t["after"]) <= task["texture_size"] for t in postprocess["textures"])
+                import_qa["checks"]["texture_budget"] = import_qa["texture_budget_verified"]
+                import_qa["status"] = "PASS" if all(import_qa["checks"].values()) else "FAIL"
+                write_json(evaluation / "qa.json", {"native": raw_qa, "import": import_qa,
+                    "postprocess": postprocess, "visual_status": "PENDING"})
+                meta.update(status="delivered", result=result, model_call=model.last_call_info,
+                            import_delivered=import_qa["checks"]["parseable_glb"],
+                            artifact_sha256=digest(output / "model.glb"), import_sha256=digest(imported),
+                            native_structural_qa=raw_qa["status"], import_structural_qa=import_qa["status"],
+                            postprocess=postprocess,
+                            preview=download_preview(model, output))
+                failures = 0
+            except Exception as exc:
+                status = "failed"
+                if isinstance(exc, cloud_api.CloudTaskTimeout):
+                    status = "remote_pending"
+                elif isinstance(exc, AmbiguousSubmission):
+                    status, stop = "submission_uncertain", True
+                elif isinstance(exc, (BudgetExceeded, cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError)):
+                    status, stop = "blocked", True
+                elif isinstance(exc, cloud_api.CloudAPIServerError):
+                    status = "resume_required"  # known receipts survive poll/download failures
+                elif not isinstance(exc, (cloud_api.CloudTaskFailed, cloud_api.CloudAPIRequestError, ValueError)):
+                    status = "resume_required"  # retain a downloaded asset after local/tool failures
+                meta.update(status=status, error=safe_error(exc), error_type=type(exc).__name__)
+                failures += 1
+                stop = stop or failures >= 3
+            finally:
+                if model is not None:
+                    model.unload()
+                meta["updated_at"] = now()
+                journal = read_json(Path(plan["directory"]) / "submissions" / provider /
+                    (task["game_id"] + "__" + task["task_id"] + ".json"), {})
+                meta["generation_cost"] = [{"endpoint": record["endpoint"], "remote_id": record.get("remote_id"),
+                    "reservation": record["reserved_credits"], "reported_credits": record.get("reported_credits"),
+                    "status": record["status"]} for record in journal.get("submissions", {}).values()]
+                write_json(output / "meta.json", meta)
+                refresh_reports(plan)
+            print(json.dumps({"provider": provider, "task_id": task["task_id"], "status": meta["status"],
+                              "error": meta.get("error")}, ensure_ascii=False), flush=True)
+            if stop:
+                interrupted = True
+                break
+        if interrupted:
+            break
+    incomplete = any(read_json(task_directories(plan, p, item["task"])[0] / "meta.json", {}).get("status") != "delivered"
+                     for p in selected for item in jobs)
+    return 2 if interrupted or incomplete else 0
+
+
+def recover(plan: dict, args):
+    """Attach an inspected remote ID to an ambiguous receipt; never submit here."""
+    checked_id(args.remote_task_id)
+    matches = [item["task"] for item in plan["tasks"] if item["task"]["task_id"] == args.task_id]
+    if len(matches) != 1:
+        raise ValueError("Recover requires exactly one known task")
+    task = matches[0]
+    journal = Path(plan["directory"]) / "submissions" / args.provider / (task["game_id"] + "__" + task["task_id"] + ".json")
+    state = read_json(journal, {})
+    record = state.get("submissions", {}).get(args.request_hash)
+    if not record or record["status"] not in ("submitting", "uncertain") or record["endpoint"] == "/files":
+        raise ValueError("Receipt is not an ambiguous generation submission")
+    record.update(status="created", remote_id=args.remote_task_id, reconciled_at=now(),
+                  response={"result": args.remote_task_id} if args.provider == "meshy" else
+                  {"code": 0, "data": {"task_id": args.remote_task_id}})
+    write_json(journal, state)
+    return {"recovered_task_id": args.remote_task_id, "network_requests": 0}
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ("prepare", "status", "run", "recover"):
+        command = sub.add_parser(name)
+        command.add_argument("--batch-id", required=True)
+        if name == "run":
+            command.add_argument("--allow-paid", action="store_true")
+            command.add_argument("--meshy-credit-cap", type=int)
+            command.add_argument("--tripo-credit-cap", type=int)
+            command.add_argument("--provider", action="append", choices=("meshy", "tripo"))
+            command.add_argument("--task-id", action="append")
+            command.add_argument("--limit", type=int, help="Limit tasks per selected provider; full inventory is retained")
+        elif name == "recover":
+            command.add_argument("--provider", required=True, choices=("meshy", "tripo"))
+            command.add_argument("--task-id", required=True)
+            command.add_argument("--request-hash", required=True)
+            command.add_argument("--remote-task-id", required=True)
+    args = parser.parse_args(argv)
+    config = read_json(args.config)
+    with exclusive_batch(batch_directory(config, args.batch_id)):
+        if args.command == "prepare":
+            plan = prepare(config, args.batch_id)
+            print(json.dumps(portable_value({"plan": str(Path(plan["directory"]) / "plan.json"),
+                "tasks_per_provider": len(plan["tasks"]), "estimated_credits": plan["estimated_credits"],
+                "recommended_credit_caps": plan["recommended_credit_caps"]}), indent=2))
+        else:
+            plan = load_plan(config, args.batch_id)
+            if args.command == "run":
+                return run(plan, args)
+            value = recover(plan, args) if args.command == "recover" else refresh_reports(plan)
+            print(json.dumps(portable_value(value), indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except (ValueError, OSError, cloud_api.CloudAPIError) as exc:
+        print(safe_error(exc), file=sys.stderr)
+        raise SystemExit(2)

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json

@@ -0,0 +1,763 @@
+{
+  "name": "bench-asset-comparison-mesh-tools",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "bench-asset-comparison-mesh-tools",
+      "version": "1.0.0",
+      "dependencies": {
+        "@gltf-transform/core": "4.2.1",
+        "@gltf-transform/extensions": "4.2.1",
+        "@gltf-transform/functions": "4.2.1",
+        "draco3dgltf": "1.5.7",
+        "meshoptimizer": "0.24.0",
+        "sharp": "0.35.5"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@gltf-transform/core": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@gltf-transform/core/-/core-4.2.1.tgz",
+      "integrity": "sha512-qKhrQ29KJ9K6sz7xGoGRllqPBlROjPJMQPvCLBOfgMPH3S/Ph5E0e6fD5WmwTY5QPyBsDMRqKd1Vl0ncThTXGw==",
+      "license": "MIT",
+      "dependencies": {
+        "property-graph": "^3.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/donmccurdy"
+      }
+    },
+    "node_modules/@gltf-transform/extensions": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@gltf-transform/extensions/-/extensions-4.2.1.tgz",
+      "integrity": "sha512-ieHSJU9qvb3ucWDxgHFcff+C7fLtFPa6G0Wtc/ki7GsN6Rh7o9eoyqi7Ggj2LO4i3ynCwLLPb/onbJKw2fBtsA==",
+      "license": "MIT",
+      "dependencies": {
+        "@gltf-transform/core": "^4.2.1",
+        "ktx-parse": "^1.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/donmccurdy"
+      }
+    },
+    "node_modules/@gltf-transform/functions": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@gltf-transform/functions/-/functions-4.2.1.tgz",
+      "integrity": "sha512-hFCI80N6zt7yHlqXbzlYEYQbFwK+2OOZNvacrRtrWiCWKI0k1Ad5+nZFsmuIZZV03aXb5XG6UF7JINT3wETS1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@gltf-transform/core": "^4.2.1",
+        "@gltf-transform/extensions": "^4.2.1",
+        "ktx-parse": "^1.0.1",
+        "ndarray": "^1.0.19",
+        "ndarray-lanczos": "^0.3.0",
+        "ndarray-pixels": "^5.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/donmccurdy"
+      }
+    },
+    "node_modules/@img/colour": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
+      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.5.tgz",
+      "integrity": "sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-darwin-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.5.tgz",
+      "integrity": "sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-freebsd-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-freebsd-wasm32/node_modules/@img/sharp-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.11.3"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.4.tgz",
+      "integrity": "sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.4.tgz",
+      "integrity": "sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.4.tgz",
+      "integrity": "sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.4.tgz",
+      "integrity": "sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-ppc64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.4.tgz",
+      "integrity": "sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-riscv64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.4.tgz",
+      "integrity": "sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.4.tgz",
+      "integrity": "sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.4.tgz",
+      "integrity": "sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.4.tgz",
+      "integrity": "sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.4.tgz",
+      "integrity": "sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.5.tgz",
+      "integrity": "sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.5.tgz",
+      "integrity": "sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-ppc64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.5.tgz",
+      "integrity": "sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-ppc64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-riscv64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.5.tgz",
+      "integrity": "sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-s390x": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.5.tgz",
+      "integrity": "sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.5.tgz",
+      "integrity": "sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.5.tgz",
+      "integrity": "sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.5.tgz",
+      "integrity": "sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-webcontainers-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.5.tgz",
+      "integrity": "sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==",
+      "cpu": [
+        "wasm32"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-webcontainers-wasm32/node_modules/@img/sharp-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.11.3"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.5.tgz",
+      "integrity": "sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-ia32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.5.tgz",
+      "integrity": "sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.5.tgz",
+      "integrity": "sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@types/ndarray": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ndarray/-/ndarray-1.1.0.tgz",
+      "integrity": "sha512-go+C6vHBUuO9jH6Tj6qEZ63JEGoMSxFdmd+6QAtthGD6xumBfIz3RbNDDs2aoRVLf9naH8lk5jnWy2UHHKgYQQ==",
+      "license": "MIT"
+    },
+    "node_modules/cwise-compiler": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/cwise-compiler/-/cwise-compiler-1.1.3.tgz",
+      "integrity": "sha512-WXlK/m+Di8DMMcCjcWr4i+XzcQra9eCdXIJrgh4TUgh0pIS/yJduLxS9JgefsHJ/YVLdgPtXm9r62W92MvanEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "uniq": "^1.0.0"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/draco3dgltf": {
+      "version": "1.5.7",
+      "resolved": "https://registry.npmjs.org/draco3dgltf/-/draco3dgltf-1.5.7.tgz",
+      "integrity": "sha512-LeqcpmoHIyYUi0z70/H3tMkGj8QhqVxq6FJGPjlzR24BNkQ6jyMheMvFKJBI0dzGZrEOUyQEmZ8axM1xRrbRiw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/iota-array": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/iota-array/-/iota-array-1.0.0.tgz",
+      "integrity": "sha512-pZ2xT+LOHckCatGQ3DcG/a+QuEqvoxqkiL7tvE8nn3uuu+f6i1TtpB5/FtWFbxUuVr5PZCx8KskuGatbJDXOWA==",
+      "license": "MIT"
+    },
+    "node_modules/is-buffer": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+      "license": "MIT"
+    },
+    "node_modules/ktx-parse": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/ktx-parse/-/ktx-parse-1.1.0.tgz",
+      "integrity": "sha512-mKp3y+FaYgR7mXWAbyyzpa/r1zDWeaunH+INJO4fou3hb45XuNSwar+7llrRyvpMWafxSIi99RNFJ05MHedaJQ==",
+      "license": "MIT"
+    },
+    "node_modules/meshoptimizer": {
+      "version": "0.24.0",
+      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-0.24.0.tgz",
+      "integrity": "sha512-Iq/8cM5cK2B0P0QdKHexr30zEJn5sQxjXKtQJGp6LO7r1VUPwhgxau18pvybVDnEDsKE49GdlJYwqPX9A/P9Sw==",
+      "license": "MIT"
+    },
+    "node_modules/ndarray": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ndarray/-/ndarray-1.1.1.tgz",
+      "integrity": "sha512-AsE8w/M2MS+0pD3nP5qbRRtJFeJJJaJ+qXZaZr0XjVGXhy6LIj2TERTlkpdK2AI3WufoOP+pwPk3q2ilAJcZ9g==",
+      "license": "MIT",
+      "dependencies": {
+        "iota-array": "^1.0.0",
+        "is-buffer": "^1.0.2"
+      }
+    },
+    "node_modules/ndarray-lanczos": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/ndarray-lanczos/-/ndarray-lanczos-0.3.0.tgz",
+      "integrity": "sha512-5kBmmG3Zvyj77qxIAC4QFLKuYdDIBJwCG+DukT6jQHNa1Ft74/hPH1z5mbQXeHBt8yvGPBGVrr3wEOdJPYYZYg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ndarray": "^1.0.11",
+        "ndarray": "^1.0.19"
+      }
+    },
+    "node_modules/ndarray-ops": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/ndarray-ops/-/ndarray-ops-1.2.2.tgz",
+      "integrity": "sha512-BppWAFRjMYF7N/r6Ie51q6D4fs0iiGmeXIACKY66fLpnwIui3Wc3CXiD/30mgLbDjPpSLrsqcp3Z62+IcHZsDw==",
+      "license": "MIT",
+      "dependencies": {
+        "cwise-compiler": "^1.0.0"
+      }
+    },
+    "node_modules/ndarray-pixels": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ndarray-pixels/-/ndarray-pixels-5.2.0.tgz",
+      "integrity": "sha512-lTh4tFKziAatVTa9crIsidUyn+lqujVOQpzfdBWvdFu2wo9Uo6z261lVX7SgMyP89xGmj3TMTPbbxl9YDnV4SA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ndarray": "^1.0.14",
+        "ndarray": "^1.0.19",
+        "ndarray-ops": "^1.2.2",
+        "sharp": "^0.35.0"
+      }
+    },
+    "node_modules/property-graph": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/property-graph/-/property-graph-3.0.0.tgz",
+      "integrity": "sha512-TnzxUsttmGtw+OiU0LDw+0FlMbJ8vV8pOjyDI7+Kdni4Tj0hW5BFh7TatQu7Y68hcvvFmiFOHilKShsA4R82fA==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/sharp": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.5.tgz",
+      "integrity": "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@img/colour": "^1.1.0",
+        "detect-libc": "^2.1.2",
+        "semver": "^7.8.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0.35.5",
+        "@img/sharp-darwin-x64": "0.35.5",
+        "@img/sharp-freebsd-wasm32": "0.35.5",
+        "@img/sharp-libvips-darwin-arm64": "1.3.4",
+        "@img/sharp-libvips-darwin-x64": "1.3.4",
+        "@img/sharp-libvips-linux-arm": "1.3.4",
+        "@img/sharp-libvips-linux-arm64": "1.3.4",
+        "@img/sharp-libvips-linux-ppc64": "1.3.4",
+        "@img/sharp-libvips-linux-riscv64": "1.3.4",
+        "@img/sharp-libvips-linux-s390x": "1.3.4",
+        "@img/sharp-libvips-linux-x64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4",
+        "@img/sharp-linux-arm": "0.35.5",
+        "@img/sharp-linux-arm64": "0.35.5",
+        "@img/sharp-linux-ppc64": "0.35.5",
+        "@img/sharp-linux-riscv64": "0.35.5",
+        "@img/sharp-linux-s390x": "0.35.5",
+        "@img/sharp-linux-x64": "0.35.5",
+        "@img/sharp-linuxmusl-arm64": "0.35.5",
+        "@img/sharp-linuxmusl-x64": "0.35.5",
+        "@img/sharp-webcontainers-wasm32": "0.35.5",
+        "@img/sharp-win32-arm64": "0.35.5",
+        "@img/sharp-win32-ia32": "0.35.5",
+        "@img/sharp-win32-x64": "0.35.5"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/uniq": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz",
+      "integrity": "sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA==",
+      "license": "MIT"
+    }
+  }
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs

@@ -0,0 +1,77 @@
+// One fixed pipeline for both services; keep the original GLB separately.
+import {readFileSync, mkdirSync} from 'node:fs';
+import {dirname} from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {NodeIO, Logger} from '@gltf-transform/core';
+import {ALL_EXTENSIONS} from '@gltf-transform/extensions';
+import {simplify, weld} from '@gltf-transform/functions';
+import {MeshoptDecoder, MeshoptSimplifier} from 'meshoptimizer';
+import draco from 'draco3dgltf';
+import sharp from 'sharp';
+
+const settings = JSON.parse(readFileSync(new URL('./package.json', import.meta.url)));
+await Promise.all([MeshoptDecoder.ready, MeshoptSimplifier.ready]);
+const runtime = {node: process.versions.node, dependencies: settings.dependencies};
+if (process.argv[2] === '--check') {
+  console.log(JSON.stringify({status: 'ready', ...runtime}));
+} else {
+  const [source, destination, triangleArg, textureArg] = process.argv.slice(2);
+  const triangleTarget = Number(triangleArg), textureTarget = Number(textureArg);
+  if (!source || !destination || !Number.isInteger(triangleTarget) || triangleTarget <= 0
+      || !Number.isInteger(textureTarget) || textureTarget <= 0) {
+    throw new Error('Expected: source.glb destination.glb triangle_target texture_size');
+  }
+  const started = performance.now();
+  const io = new NodeIO().registerExtensions(ALL_EXTENSIONS).registerDependencies({
+    'draco3d.decoder': await draco.createDecoderModule(),
+    'meshopt.decoder': MeshoptDecoder,
+  });
+  const document = await io.read(source);
+  document.setLogger(new Logger(Logger.Verbosity.SILENT));
+  // The decoded import GLB is not dependent on the provider's mesh codec.
+  for (const extension of document.getRoot().listExtensionsUsed()) {
+    if (['KHR_draco_mesh_compression', 'EXT_meshopt_compression'].includes(extension.extensionName)) {
+      extension.dispose();
+    }
+  }
+  function triangleCount() {
+    let count = 0;
+    for (const mesh of document.getRoot().listMeshes()) {
+      for (const primitive of mesh.listPrimitives()) {
+        if (primitive.getMode() !== 4) throw new Error('Only triangle primitives are supported');
+        const n = (primitive.getIndices() || primitive.getAttribute('POSITION')).getCount();
+        count += n / 3;
+      }
+    }
+    return count;
+  }
+  const before = triangleCount();
+  if (before > triangleTarget) {
+    await document.transform(weld(), simplify({simplifier: MeshoptSimplifier,
+      ratio: triangleTarget / before, error: 0.01, lockBorder: false}));
+  }
+  const textures = [];
+  for (const texture of document.getRoot().listTextures()) {
+    const image = texture.getImage();
+    if (!image) throw new Error('Texture has no decoded image');
+    const input = Buffer.from(image);
+    const info = await sharp(input).metadata();
+    let sizeAfter = [info.width, info.height];
+    if (Math.max(...sizeAfter) > textureTarget) {
+      const {data, info: resized} = await sharp(input).resize({width: textureTarget, height: textureTarget,
+        fit: 'inside', withoutEnlargement: true, kernel: 'lanczos3'}).png({compressionLevel: 9}).toBuffer({resolveWithObject: true});
+      texture.setImage(new Uint8Array(data)).setMimeType('image/png').setURI('');
+      sizeAfter = [resized.width, resized.height];
+    }
+    textures.push({name: texture.getName(), before: [info.width, info.height], after: sizeAfter});
+  }
+  const after = triangleCount();
+  mkdirSync(dirname(destination), {recursive: true});
+  await io.write(destination, document);
+  console.log(JSON.stringify({status: after <= triangleTarget ? 'PASS' : 'FAIL',
+    triangles_before: before, triangles_after: after, triangle_target: triangleTarget,
+    texture_target: textureTarget, textures, runtime,
+    policy: 'weld; one simplify pass at error 0.01 when over budget; downsize textures only; preserve UV/material/node data',
+    elapsed_sec: Math.round((performance.now() - started) / 10) / 100,
+    visual_review: 'PENDING'}));
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/sources_index.json

@@ -0,0 +1,108 @@
+{
+  "files": [
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6461bd9ee1d5cb4be54714229d07d8c780116dfb8950cda43488b8536e64675",
+      "bytes": 25522
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "45669690e28bd9055420c5f8be5d74a95079921786a36ac98ed650ac2684116e",
+      "bytes": 1482
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/method_selection.md",
+      "sha256": "d9b0471f4c0e0f1e70c76e2bba676d3275d10530451435dc625972dbcea9abbe",
+      "bytes": 11846
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py",
+      "sha256": "70f8d79c8596908f7edcd7ff68120f558cea6881f23dc2f0e29ef62f2bab75c4",
+      "bytes": 33749
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py",
+      "sha256": "92d075ef9308e0d6496a901d85b7847b8f602f88de8e19caeaf85ac893081253",
+      "bytes": 8458
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py",
+      "sha256": "93c42e454d60d03c30b12e58e8e75453c7caa8fc92ff30bbc20aa645b3fc23dd",
+      "bytes": 3390
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py",
+      "sha256": "ed1cf1105f95c76b4893e98a84b3e37ef7d1f87c873c93c8e58413457104d28b",
+      "bytes": 17054
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md",
+      "sha256": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
+      "bytes": 6384
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py",
+      "sha256": "5f88c457ee58f73de5ddbd4d96fa91e474c29bd3ecefbb02f3faf18b93c4365a",
+      "bytes": 27332
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py",
+      "sha256": "ef437ff79554469390c0d6c71f11788431fe4a1d1e51e92feae3adf296cebaec",
+      "bytes": 20927
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py",
+      "sha256": "29ab3944260d62585a991f384eee4917368f97c4476abc3eda85299bc1a8089e",
+      "bytes": 24255
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py",
+      "sha256": "a3c363a3439b3864e05e782340eb3059380c4b1c28eccb2524e9cbf9131fe996",
+      "bytes": 21838
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py",
+      "sha256": "6f3ee0147b345415cb6d8b1b1433fa557d0d543bb92276840dc85b43cd7a66ad",
+      "bytes": 23765
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs",
+      "sha256": "b1b6ada273a576083bb167772ec03fee6fe3275470180563722e56687688995c",
+      "bytes": 3939
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json",
+      "sha256": "0d9c3ad5898a78a0db22f361caa7242b48ff86586e898f5ae5c1bb4a7134631a",
+      "bytes": 26253
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip",
+      "sha256": "a72e49a29033d161d0ec0abd27dc003f34c8b7a190201c7e8b514e0afc4bce45",
+      "bytes": 60760,
+      "kind": "immutable_frozen_parent_plan_archive"
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G036_salt_flat_timetrial__G036_salt_flat_timetrial_obj_005.json",
+      "sha256": "4123db2ef05173b2dec2079ce57a91db3c2dfa0b26a23b93e7b777d8c2034629",
+      "bytes": 13195
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/d92ed575a08d8a28496838fe0aea28357c8c5e280d018a378cb4f96dd17fb290.meta.json",
+      "sha256": "e1571e0793add16e01770c06367900f2c9fc4e18000e8544d2ab8d77e6d28da1",
+      "bytes": 2022
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G036_salt_flat_timetrial__G036_salt_flat_timetrial_obj_005.json",
+      "sha256": "399945f3d7830667c15f6a6b40c68ee9e15950c1b98af9a808ab89341b9528d7",
+      "bytes": 2884
+    },
+    {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/3366792d6f527e76c58b4bdaaa5c5f05fde64fbe44a7d7fe0b065af809d2e315.meta.json",
+      "sha256": "70fd2ca887c7b766342dad07b16a7d2cc631cb4ec098ab18127ad3b2eb828e97",
+      "bytes": 1631
+    }
+  ],
+  "receipt_bytes_preserved": true,
+  "frozen_plan_unchanged": true,
+  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d"
+}

outputs/G036_salt_flat_timetrial/.generation/3d_object/tripo/obj200_meshy_tripo_20261015_v2/asset_task_index.json

@@ -0,0 +1,30 @@
+{
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "game_id": "G036_salt_flat_timetrial",
+  "provider": "tripo",
+  "scope": "3d_object_only_not_complete_stage2",
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G036_salt_flat_timetrial",
+        "task_id": "G036_salt_flat_timetrial_obj_005",
+        "asset_name": "wind_sock_set",
+        "name_zh": "风向袋组",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1040,
+        "decimation_target": 8000,
+        "texture_size": 1024,
+        "rig": "none",
+        "animation_strategy": "procedural",
+        "spec_ref": "L01,F04",
+        "poly_policy": "low_poly_priority"
+      },
+      "shared_prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+      "reference": null,
+      "subject_group": "rigid",
+      "context_condition": "shared_short_context"
+    }
+  ]
+}

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/import/model.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a85d2f3696b88fad409a6076b69282677e16b498d6458198f6028c664eca62
+size 3918720

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/meta.json

@@ -0,0 +1,170 @@
+{
+  "game_id": "G036_salt_flat_timetrial",
+  "task_id": "G036_salt_flat_timetrial_obj_005",
+  "asset_name": "wind_sock_set",
+  "task_kind": "3d_object",
+  "run_id": "obj200_meshy_tripo_20261015_v2",
+  "provider": "meshy",
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "context_condition": "shared_short_context",
+  "full_context": {
+    "general_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6461bd9ee1d5cb4be54714229d07d8c780116dfb8950cda43488b8536e64675",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "45669690e28bd9055420c5f8be5d74a95079921786a36ac98ed650ac2684116e",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "source_task": {
+    "game_id": "G036_salt_flat_timetrial",
+    "task_id": "G036_salt_flat_timetrial_obj_005",
+    "asset_name": "wind_sock_set",
+    "name_zh": "风向袋组",
+    "role": "prop",
+    "input_mode": "text_to_3d",
+    "prompt": "Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1040,
+    "decimation_target": 8000,
+    "texture_size": 1024,
+    "rig": "none",
+    "animation_strategy": "procedural",
+    "spec_ref": "L01,F04",
+    "poly_policy": "low_poly_priority"
+  },
+  "shared_prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+  "reference": null,
+  "status": "delivered",
+  "updated_at": "2026-10-16T04:28:43+00:00",
+  "visual_status": "PENDING",
+  "native_delivered": true,
+  "result": {
+    "task_id": "G036_salt_flat_timetrial_obj_005",
+    "glb_path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/model.glb",
+    "elapsed_sec": 141.86,
+    "game_id": "G036_salt_flat_timetrial",
+    "task_kind": "3d_object",
+    "output_dir": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy"
+  },
+  "native_structural_qa": "FAIL",
+  "model_call": {
+    "provider": "meshy",
+    "model": "meshy-6",
+    "task_id": "01a142f6-cf5e-71e7-be21-767f8d3bbcba",
+    "task_ids": [
+      "01a142f5-ff7c-76fa-a988-194123105d2e",
+      "01a142f6-cf5e-71e7-be21-767f8d3bbcba"
+    ],
+    "elapsed_sec": 141.86,
+    "credits": null,
+    "cached": false,
+    "cache_key": "d92ed575a08d8a28496838fe0aea28357c8c5e280d018a378cb4f96dd17fb290",
+    "format": "glb",
+    "preview_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f6-cf5e-71e7-be21-767f8d3bbcba/output/preview.png?Expires=4945708800&Signature=T7G4PdLUZermojqeiVJEcV6JuPhlnWaauiyu5heD-XSFOmTFlbN7WxdCRiOJKk4YIYi2kEjoM6fQqbeEjT5znlS2WC5cza3j0JKqdZqhPKsNIxAgDrYRu0Dl0b6WS5gzwcpj9d7ViTTL5jWP4ZwC4mJm9W0qlDdYG8sI1lVsM1SpuE1iuTYo16GxF1-m87JtVW1FYn2f8nily9cpz6MMsTydjFlG9VPYpcqphwTQVmpkoXm1Wg3QSezNXe5ySDWZZuhnqYznBb~mG3S2LUMhEcWCMpE9tpieeSSdqHoLcrsRvMa0IkGABxczv7fS3l1Xgl75D8lSTnCTNx~pJpJmXg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+    "bytes": 7183592,
+    "triangles": 8035,
+    "meshes": 1,
+    "materials": 1,
+    "textures": 4,
+    "images": 4,
+    "nodes": 1,
+    "generator": "pygltflib@v1.16.5"
+  },
+  "artifact_sha256": "b2df24d0737299a48c7682fc401310c7bacd07dd1781bfe614039f87411e20e7",
+  "import_delivered": true,
+  "import_sha256": "e1a85d2f3696b88fad409a6076b69282677e16b498d6458198f6028c664eca62",
+  "import_structural_qa": "PASS",
+  "postprocess": {
+    "status": "PASS",
+    "triangles_before": 8035,
+    "triangles_after": 8000,
+    "triangle_target": 8000,
+    "texture_target": 1024,
+    "textures": [
+      {
+        "name": "",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      }
+    ],
+    "runtime": {
+      "node": "20.17.0",
+      "dependencies": {
+        "@gltf-transform/core": "4.2.1",
+        "@gltf-transform/extensions": "4.2.1",
+        "@gltf-transform/functions": "4.2.1",
+        "draco3dgltf": "1.5.7",
+        "meshoptimizer": "0.24.0",
+        "sharp": "0.35.5"
+      }
+    },
+    "policy": "weld; one simplify pass at error 0.01 when over budget; downsize textures only; preserve UV/material/node data",
+    "elapsed_sec": 1.04,
+    "visual_review": "PENDING"
+  },
+  "preview": {
+    "status": "downloaded",
+    "path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/preview.png",
+    "visual_review": "PENDING"
+  },
+  "generation_cost": [
+    {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "remote_id": "01a142f5-ff7c-76fa-a988-194123105d2e",
+      "reservation": 20,
+      "reported_credits": null,
+      "status": "created"
+    },
+    {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "remote_id": "01a142f6-cf5e-71e7-be21-767f8d3bbcba",
+      "reservation": 10,
+      "reported_credits": null,
+      "status": "created"
+    }
+  ]
+}

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/model.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2df24d0737299a48c7682fc401310c7bacd07dd1781bfe614039f87411e20e7
+size 7183592

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/import/model.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b62a85c9254a0c5c00eac42b21f7a7947882e43ff099347f037167cc96ca3a7e
+size 3045020

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/meta.json

@@ -0,0 +1,147 @@
+{
+  "game_id": "G036_salt_flat_timetrial",
+  "task_id": "G036_salt_flat_timetrial_obj_005",
+  "asset_name": "wind_sock_set",
+  "task_kind": "3d_object",
+  "run_id": "obj200_meshy_tripo_20261015_v2",
+  "provider": "tripo",
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "context_condition": "shared_short_context",
+  "full_context": {
+    "general_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6461bd9ee1d5cb4be54714229d07d8c780116dfb8950cda43488b8536e64675",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "45669690e28bd9055420c5f8be5d74a95079921786a36ac98ed650ac2684116e",
+      "source": "bench/test_data/outputs/G036_salt_flat_timetrial/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "source_task": {
+    "game_id": "G036_salt_flat_timetrial",
+    "task_id": "G036_salt_flat_timetrial_obj_005",
+    "asset_name": "wind_sock_set",
+    "name_zh": "风向袋组",
+    "role": "prop",
+    "input_mode": "text_to_3d",
+    "prompt": "Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1040,
+    "decimation_target": 8000,
+    "texture_size": 1024,
+    "rig": "none",
+    "animation_strategy": "procedural",
+    "spec_ref": "L01,F04",
+    "poly_policy": "low_poly_priority"
+  },
+  "shared_prompt": "Game context (excerpt): 盐湖试车场的计时挑战 | - W01 世界与时代背景：近未来「白蚀盐原」上的民间测速纪元——大地测量局每年开放干涸盐湖试车场一周，供独立车队挑战公开计时纪录；盐板之下是未干透的卤水层，酥松盐晶带随时可能让轻率的车手付出圈速代价。 | - S01 类型：3D 单车两圈检查点计时赛（含 1 处双路线分岔）。\nAsset: Pole-mounted orange-and-white striped wind sock with pivot ring, simple cloth cone readable from distance, single object set of one pole and sock, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+  "reference": null,
+  "status": "delivered",
+  "updated_at": "2026-10-16T07:53:00+00:00",
+  "visual_status": "PENDING",
+  "native_delivered": true,
+  "result": {
+    "task_id": "G036_salt_flat_timetrial_obj_005",
+    "glb_path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/model.glb",
+    "elapsed_sec": 234.52,
+    "game_id": "G036_salt_flat_timetrial",
+    "task_kind": "3d_object",
+    "output_dir": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo"
+  },
+  "native_structural_qa": "FAIL",
+  "model_call": {
+    "provider": "tripo",
+    "model": "v3.1-20260211",
+    "task_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+    "elapsed_sec": 234.52,
+    "credits": 30.0,
+    "cached": false,
+    "cache_key": "3366792d6f527e76c58b4bdaaa5c5f05fde64fbe44a7d7fe0b065af809d2e315",
+    "preview_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/96a8cac0-e8ec-41ed-a270-1caab04aea3d/legacy_mesh.webp?auth_key=1792223578-craoschm-0-fdb7a9c1c980d7db24db13840edaa6d4",
+    "bytes": 2261076,
+    "triangles": 10885,
+    "meshes": 1,
+    "materials": 1,
+    "textures": 3,
+    "images": 3,
+    "nodes": 1,
+    "generator": "https://tripo3d.ai"
+  },
+  "artifact_sha256": "00742edef038a80019129d8c91913e7d1937d701f9f3a9e01f3bea5b77810323",
+  "import_delivered": true,
+  "import_sha256": "b62a85c9254a0c5c00eac42b21f7a7947882e43ff099347f037167cc96ca3a7e",
+  "import_structural_qa": "PASS",
+  "postprocess": {
+    "status": "PASS",
+    "triangles_before": 10885,
+    "triangles_after": 8000,
+    "triangle_target": 8000,
+    "texture_target": 1024,
+    "textures": [
+      {
+        "name": "Color_96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "ORM_96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "NormalGL_96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      }
+    ],
+    "runtime": {
+      "node": "20.17.0",
+      "dependencies": {
+        "@gltf-transform/core": "4.2.1",
+        "@gltf-transform/extensions": "4.2.1",
+        "@gltf-transform/functions": "4.2.1",
+        "draco3dgltf": "1.5.7",
+        "meshoptimizer": "0.24.0",
+        "sharp": "0.35.5"
+      }
+    },
+    "policy": "weld; one simplify pass at error 0.01 when over budget; downsize textures only; preserve UV/material/node data",
+    "elapsed_sec": 0.57,
+    "visual_review": "PENDING"
+  },
+  "preview": {
+    "status": "downloaded",
+    "path": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/preview.png",
+    "visual_review": "PENDING"
+  },
+  "generation_cost": [
+    {
+      "endpoint": "/generation/text-to-model",
+      "remote_id": "96a8cac0-e8ec-41ed-a270-1caab04aea3d",
+      "reservation": 30,
+      "reported_credits": 30.0,
+      "status": "created"
+    }
+  ]
+}

outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/tripo/model.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00742edef038a80019129d8c91913e7d1937d701f9f3a9e01f3bea5b77810323
+size 2261076

outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/render_meta.json

@@ -0,0 +1,60 @@
+{
+  "label": "meshy_G036_salt_flat_timetrial_obj_005_import",
+  "source": "bench/test_data/outputs/G036_salt_flat_timetrial/assets/3d_object/G036_salt_flat_timetrial_obj_005/meshy/import/model.glb",
+  "output": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import",
+  "provider": "meshy",
+  "task_id": "G036_salt_flat_timetrial_obj_005",
+  "variant": "import",
+  "source_sha256": "e1a85d2f3696b88fad409a6076b69282677e16b498d6458198f6028c664eca62",
+  "views": [
+    {
+      "axis": "+z",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/pos_z.png"
+    },
+    {
+      "axis": "-z",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/neg_z.png"
+    },
+    {
+      "axis": "+x",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/pos_x.png"
+    },
+    {
+      "axis": "-x",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/neg_x.png"
+    },
+    {
+      "axis": "+y",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/pos_y.png"
+    },
+    {
+      "axis": "iso",
+      "file": "bench/test_data/outputs/G036_salt_flat_timetrial/eval/3d_object/G036_salt_flat_timetrial_obj_005/meshy/previews/import/iso.png"
+    }
+  ],
+  "geometry": {
+    "bounds": [
+      0.38720598816871643,
+      1.8995060324668884,
+      0.3677450120449066
+    ],
+    "bounds_min": [
+      -0.19550399482250214,
+      -0.9507570266723633,
+      -0.18588900566101074
+    ],
+    "bounds_max": [
+      0.1917019933462143,
+      0.9487490057945251,
+      0.18185600638389587
+    ],
+    "meshes": 1,
+    "triangles": 8000,
+    "skinned": 0,
+    "force_front_side": false,
+    "renderer": "WebKit WebGL",
+    "three": "180",
+    "animation_clips": 0
+  },
+  "status": "rendered"
+}