Upload assets for G039_sky_ring_flight

.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/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/import/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/import/model.glb filter=lfs diff=lfs merge=lfs -text
+outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/model.glb filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,30 @@
+{
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "game_id": "G039_sky_ring_flight",
+  "provider": "meshy",
+  "scope": "3d_object_only_not_complete_stage2",
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G039_sky_ring_flight",
+        "task_id": "G039_sky_ring_flight_obj_005",
+        "asset_name": "wind_stream_vane",
+        "name_zh": "风线仪",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1043,
+        "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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1.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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1043
+  },
+  "model": "meshy-6",
+  "task_id": "01a142f8-19ab-7259-962c-aade734abc46",
+  "task_ids": [
+    "01a142f7-70e3-73f4-ab13-bd13ef695829",
+    "01a142f8-19ab-7259-962c-aade734abc46"
+  ],
+  "elapsed_sec": 131.47,
+  "credits": null,
+  "cached": false,
+  "format": "glb",
+  "preview_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/preview.png?Expires=4945708800&Signature=pf9kXoRiecSv9ApuG7GkKsojX1hT~6QZiHhcSPaBUpSHPflxfcyPPssPN2mCsnUhKEkh7Mj3oJxnwhKVgNz5hVARIcMILE0zgXp~mT4YK6cmt4nr2C1NJmJvhf35MmMDJIhfOQiZtR8gVylqYs790e3HHRFqeY033CfPtlhybZRMVoefX4a50x1CkD-ar54OvG-HGWNdiCO6XfCuzXNJ2hN5ocbnWLEf32Ga8Lk4Kj4w5kmhOQsrS5XCowDuDBnk6k2-viXZcxOf4j~pUOr1PY7gaTWBZ1avXGZqH3B9IEUWvHzHP87J4XvSUpC8lnugxH1tnCmPufACYm26utxkhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+  "bytes": 9577000,
+  "triangles": 7880,
+  "meshes": 1,
+  "materials": 1,
+  "textures": 4,
+  "images": 4,
+  "nodes": 1,
+  "generator": "pygltflib@v1.16.5",
+  "cache_key": "621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1"
+}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076.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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "model_seed": 1043,
+    "texture_seed": 1043
+  },
+  "model": "v3.1-20260211",
+  "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
+  "elapsed_sec": 251.71,
+  "credits": 30.0,
+  "cached": false,
+  "preview_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/legacy_mesh.webp?auth_key=1792224016-bibrcxrc-0-b77b51744d52f9e52e969d362bd4a51e",
+  "bytes": 3112864,
+  "triangles": 10929,
+  "meshes": 1,
+  "materials": 1,
+  "textures": 3,
+  "images": 3,
+  "nodes": 1,
+  "generator": "https://tripo3d.ai",
+  "cache_key": "9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076"
+}

outputs/G039_sky_ring_flight/.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": "G039_sky_ring_flight",
+  "parent_frozen_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "parent_frozen_plan_file_sha256": "3c4798c34345ab6f7fc07f850f25deca44051565185a1c8a80058819e1bbd685",
+  "task_count": 1,
+  "parent_plan_original": {
+    "archive": "bench/test_data/outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py": "70f8d79c8596908f7edcd7ff68120f558cea6881f23dc2f0e29ef62f2bab75c4",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py": "92d075ef9308e0d6496a901d85b7847b8f602f88de8e19caeaf85ac893081253",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py": "93c42e454d60d03c30b12e58e8e75453c7caa8fc92ff30bbc20aa645b3fc23dd",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py": "ed1cf1105f95c76b4893e98a84b3e37ef7d1f87c873c93c8e58413457104d28b",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py": "5f88c457ee58f73de5ddbd4d96fa91e474c29bd3ecefbb02f3faf18b93c4365a",
+    "bench/test_data/outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py": "a3c363a3439b3864e05e782340eb3059380c4b1c28eccb2524e9cbf9131fe996",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py": "6f3ee0147b345415cb6d8b1b1433fa557d0d543bb92276840dc85b43cd7a66ad",
+    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs": "b1b6ada273a576083bb167772ec03fee6fe3275470180563722e56687688995c",
+    "bench/test_data/outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G039_sky_ring_flight",
+        "task_id": "G039_sky_ring_flight_obj_005",
+        "asset_name": "wind_stream_vane",
+        "name_zh": "风线仪",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1043,
+        "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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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": "44294753e7e8b8e2c30cc912661baf651ed75b5a88a369b044eed120f1004483"
+}

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

@@ -0,0 +1,285 @@
+# 《空中群岛的风场穿环》｜三维飞行穿环机制输入规范
+
+```yaml
+case_id: G039
+base_case_id: G039
+title: 空中群岛的风场穿环
+category: Racing / Vehicle
+tier: M
+engine: unity3d
+report_track: Standard
+paired_conditions: [R, N]
+required_real_clients: 1
+fixed_seed: 1039
+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 反馈——空中环道世界设定、飞行手感冻结（俯仰/横滚/加速/失速预警/复位朝向）、风线与气流粒子、穿环脉冲与尾迹 VFX、穿环提示音、参考图绑定与正向范围清单）；运行引擎：**Unity 2022.3 LTS＋URP**——选择理由：飞行控制、触发器、风场与环形赛道原型在 URP 下便于确定性验证；目标构建：Windows/macOS 64 位桌面包；参考分辨率 1920×1080（1280×720 最低可用）；摄像机：第三人称追机镜头（机尾后上方）；输入：键盘与鼠标；构建启动：Unity 2022.3 打开工程、Build 出桌面可执行文件后直接运行。
+- 原创边界：本作全部名称、飞行器、环架、群岛、文案与美术必须原创，不使用任何商业作品的名称、角色或造型。
+- 规则优先级：本文件全局数值与规则 ＞ 机制章节 ＞ 航线实例 ＞ 生成器自由补充；未指定数值可作为明确标注的配置默认值。
+- 本文件用于游戏生成模型；文档存在不等于玩法完成，静态页面或演示视频不能单独证明可玩。
+
+## 1. 定位与完整流程 [S01–S06]
+
+- S01 类型：三维飞行穿环计时挑战（12 环三段航线）。
+- S02 核心循环一句话：调整姿态 → 穿环 → 应对风场/失速 → 碰撞复位 → 完成航线。
+- S03 流程：起飞 → 低空入门环（环 1–4）→ 风场区环链（环 5–8）→ 高空精密环（环 9–12）→ 终点结算。
+- S04 最低完整流程：开始界面、起飞、飞行 HUD、漏环警告、复位、结算、重开必须全部存在且有真实入口。
+- S05 失败恢复入口：碰撞回最近环前检查点（环序不回退）；超时或复位超限判负后一键重开；Esc 暂停。
+- S06 本局耦合边速览：碰撞复位系统→环序进度系统（复位不回退环序）；风场系统→飞行轨迹系统（区域风持续偏移航迹）。
+
+## 2. 完整核心循环与阶段 [S07–S12]
+
+完整循环：主菜单 → C01 起飞 → 低空入门环 → 风场区环链 → 高空精密环 → 终点结算 → 重开/返回菜单；任意飞行阶段可 Esc 暂停。每阶段六要素如下（引用本 spec §3–§7 对应规则）：
+
+- S07 主菜单
+  - input：系统启动，玩家确认进入
+  - precondition：程序启动完成（C01 可在首次入局前播放）
+  - state_change：显示主菜单（开始/退出）
+  - feedback：主菜单界面（F10）
+  - next_actions：点击「开始」→ S08
+  - outcome：无状态副作用
+- S08 起飞
+  - input：玩家按 Shift 加速并前推（W 俯仰）爬升（I01）
+  - precondition：C01 播完或跳过；滑翔机停于起飞平台、速度 0
+  - state_change：滑翔机离地爬升至巡航速度 60；起飞完成即开始 420 秒总计时（G05）
+  - feedback：尾迹展开、气流粒子掠过（F04/F05），HUD 见 I03
+  - next_actions：到达环 1 → S09
+  - outcome：起飞段用时计入总计时
+- S09 低空入门环（环 1–4）
+  - input：玩家俯仰/横滚/加速驾驶
+  - precondition：起飞完成
+  - state_change：按序穿环 1–4（半径 6）；漏环不计并出警告（M02）
+  - feedback：穿环脉冲与提示音（F05）
+  - next_actions：过环 4 → S10；碰撞 → 复位（M04）；Esc → S12
+  - outcome：环序推进 1→4，计时连续
+- S10 风场区环链（环 5–8）
+  - input：持续驾驶修正侧风偏航（G06）
+  - precondition：环 4 已过
+  - state_change：侧风 15/秒持续偏移航迹；2 个上升气流柱可借力爬升（G06）
+  - feedback：风线与气流粒子（F04/F05），HUD 风区提示（I03）
+  - next_actions：过环 8 → S11；失速 → 按 M01 恢复；Esc → S12
+  - outcome：环序推进 5→8；风区轨迹差分可导出（E02）
+- S11 高空精密环（环 9–12）→ 终点结算
+  - input：精密姿态调整（环半径收窄为 4）
+  - precondition：环 8 已过
+  - state_change：按序穿环 9–12；穿完环 12 → V01 结算（显示用时与复位次数）；复位第 11 次或 420 秒超时 → V02 判负
+  - feedback：C03 结算视频（双意象）＋结算面板
+  - next_actions：Enter 重开 → S07；返回菜单 → S07
+  - outcome：按 V01/V02 判定并结算
+- S12 暂停
+  - input：玩家按 Esc
+  - precondition：处于 S08–S11 任意飞行阶段
+  - state_change：冻结计时、风场与失速判定（G06）
+  - feedback：暂停菜单（继续/重开/返回/设置）
+  - next_actions：Esc/继续 → 返回原阶段；重开 → S07
+  - outcome：恢复后一切计时从冻结点连续累计，无漂移
+
+## 3. 数值口径与全局规则 [G01–G07]
+
+- G01 统一刻度：速度按单位/秒、坐标按单位计、角度为度；时间用游戏模拟秒（暂停冻结）。
+- G02 飞行与失速（本包冻结值）：基础巡航速度 60，速度区间 40–90（Shift 加速至 90、松键回落 60，回落为空气阻力自然衰减）；速度 <40 触发失速——垂直下坠 20/秒且操控力矩减半；俯冲或加速使速度回到 ≥50 才脱离失速；失速预警（速度 ≤45 时 HUD 黄色预警与预警音，G07）；W/S 俯仰、A/D 横滚，均为连续输入。
+- G03 航线与穿环（本包冻结值）：航线共 **12 环**——低空入门环 4（环 1–4）、风场区环链 4（环 5–8）、高空精密环 4（环 9–12）；环为半径 6 的圆环（高空环收窄为半径 4），飞行器中心穿环平面且距环心 ≤6（高空环 ≤4）才计入；必须按 1→12 顺序穿环，穿到未解锁环不计并出漏环警告；环位由 seed=1039 冻结。
+- G04 判定与独立 oracle（本包冻结值）：失速 oracle——速度降到 35 必然触发失速事件且下坠率 20；俯冲至 55 必然脱离失速。风场 oracle——无风区正对环 6 直线飞行 10 秒横向位移为 0（偏航 0）；风场区同操作 10 秒横向位移 150（±15 容差）。穿环 oracle——按序穿环 1、2 计入推进；直飞环 3 平面（跳过环 2）不计且出漏环警告。任何偏离即 FAIL。
+- G05 失败与复位（本包冻结值）：撞岛体/环架/水面 → 复位到最近已穿环后方检查点（每环配 1 个），复位次数上限 **10 次**（第 11 次判负）；航线总时限 **420 秒**（自起飞离地起算，暂停不计入），超时判负。
+- G06 风场与暂停（本包冻结值）：风场区（环 5–8 区段）持续侧风 15/秒（固定指向，seed 冻结）；区内另设 2 个上升气流柱（半径 10，垂直 +25/秒）；高空精密环区无风但环径收窄为半径 4。Esc 暂停冻结计时、风场与失速判定，UI 过渡不推进游戏状态。
+- G07 复位朝向与手感（本包冻结值）：复位后机头朝向下一目标环的航线方向（姿态角重置为航线切向，速度恢复 60 巡航）；横滚信息——相机地平线随横滚同步倾斜，HUD 提供俯仰角/横滚角读数；输入到姿态可见响应 ≤100 毫秒（I07）。
+
+## 4. 操作与输入 [I01–I07]
+
+- I01 键位：W/S＝俯仰（拉杆/推杆）；A/D＝横滚；Shift＝加速；R＝碰撞后手动确认复位；Esc＝暂停；结算界面 Enter＝重开。
+- I02 输入语义边界：失速期间操控输入仍接受但效果减半；暂停/结算期间输入无效；无鼠标瞄准需求。
+- I03 HUD 必须显示：速度、当前环序（下一目标环）、计时（420 秒剩余）、复位计数（0–10）、失速预警（黄）与失速警报（红）、风区提示（进入/离开风场区）、俯仰角/横滚角读数（G07）。
+- I04 输入优先级：暂停与结算状态阻断全部玩法输入；面板打开时玩法键不串入；同帧多输入按 §6 各机制声明的顺序结算。
+- I05 焦点与点击穿透规则：点击画布捕获输入焦点；面板层阻断点击穿透；窗口失焦自动暂停（G06）。
+- I06 UI 必须显示的状态：按 §3 G01 刻度与 §7 结算字段显示本 spec 各规则要求的状态（速度/环序/计时/复位/失速/风区），HUD 对照见 rubric。
+- I07 输入延迟目标：按键到姿态可见响应 ≤100 毫秒（桌面 P95，每类输入 ≥30 次采样）。
+
+## 5. 航线与内容清单 [L01–L04]
+
+- L01 生成对象：飞行器 1（原创造型）、穿环 12（套件实例化）、环前检查点浮标 12、上升气流柱标记 2、风线仪/风幡若干（风区边界）、起飞平台 1、HUD。
+- L02 航线（冻结布局）：单条三段穿环航线；环位、气流柱位置与风场向量由 seed=1039 冻结，不随机扩展；环前检查点位于每环后下方 20 单位处（复位用）。
+- L03 目标物/交互物/场景/UI 对象：本 spec §3–§7 引用的界面元素（菜单/HUD/结算面板）与交互物（穿环判定体、碰撞体、检查点复位体、气流柱判定体）逐类存在且运行时可进入；**程序性穿环判定体不得烘进装饰场景模型**——环架模型为外观件，判定体由引擎触发器构建（A 层资产诊断重点）。
+- L04 冻结需求 vs 实现默认 vs 生成自由度：本 spec 明确写出的数值与数量为冻结需求；未给数值的表现层（装饰造型、配色、粒子参数、音色）为生成自由度，不得评估为缺失；实现默认值必须明确标注且符合核心机制。音效为冻结需求（F06 ��单逐条交付，缺失按 FAIL 计）。
+
+## 6. 机制系统 [M01–M04]
+
+- M01 三维姿态与失速（主机制）
+  - input：俯仰/横滚/加速输入（玩家）
+  - precondition：处于飞行阶段（非暂停/结算/复位中）
+  - state_change：姿态角连续变化；速度 <40 → 失速（下坠 20/秒、操控减半）；速度 ≥50 → 恢复巡航；≤45 → 失速预警（黄）
+  - output：按 G02 结算飞行状态
+  - observable：失速进入/脱离/预警事件与速度、姿态采样流
+  - invalid_case：复位中与暂停中姿态输入无效；失速期间输入减半为规则而非错误
+  - recovery：俯冲或加速回到 ≥50 脱离失速（M01 自恢复）；撞体后走 M04
+- M02 有序穿环
+  - input：穿越环平面（系统判定体）
+  - precondition：环处于已解锁序号（前序环全部通过）
+  - state_change：仅当前序号环计入并推进环序；漏环不计
+  - output：按 G03 结算环序
+  - observable：ring_passed 事件（环号）与 miss_warning 事件
+  - invalid_case：越序穿环不计且出漏环警告（无副作用）；判定体半径按 G03 冻结值（6/高空 4）
+  - recovery：回头补穿被漏环后继续按序推进
+- M03 风场
+  - input：进入/离开风场区与气流柱（系统判定体）
+  - precondition：飞行器处于航线空间
+  - state_change：风区侧风 15/秒持续偏移航迹（偏航须修正）；气流柱内获得垂直速度 +25/秒
+  - output：按 G06 施加风与气流
+  - observable：风场进入/离开事件与位置差分流（10 秒横移 150±15 可复现）
+  - invalid_case：风区外无侧风（E02 对照探针）
+  - recovery：借气流柱爬升或常规俯冲恢复高度
+- M04 碰撞复位
+  - input：撞击岛体/环架/水面（系统）＋手动 R 确认
+  - precondition：发生碰撞且玩家确认（R）；或自动（水面）
+  - state_change：回到最近已穿环后方检查点；机头朝向下一目标环（G07）；速度恢复 60；环序进度保持不回退；复位计数 +1
+  - output：按 G05 计数与判定
+  - observable：respawn 事件（含检查点 ID、环序、复位计数、朝向）
+  - invalid_case：未碰撞时 R 无效；结算/暂停期间复位无效
+  - recovery：第 11 次碰撞 → V02 判负；复位为唯一恢复入口
+
+系统耦合边（玩法必需、可复现）：
+
+- E01 from_system=碰撞复位系统 → to_system=环序进度系统；changed_state=复位后环序不回退（已穿环保持、当前目标环不变），复位朝向指向下一目标环；验证方式=state_before/after 环序对照（复位前后环序差分=0）。
+- E02 from_system=风场系统 → to_system=飞行轨迹系统；changed_state=进入风场区后持续侧风改变航迹（无修正 10 秒横移 150±15），气流柱内垂直分量 +25/秒；验证方式=风区内外同操作轨迹差分采样。
+
+## 7. 成功、失败与恢复 [V01–V05]
+
+- V01 成功条件：按序穿完 12 环 → 终点结算（显示用时与复位次数）。
+- V02 失败条件：复位超过 10 次或 420 秒超时 → 失败结算（注明当前环序与原因）。
+- V03 恢复语义：碰撞回最近环前检查点继续（环序与计时不重置）；判负后一键重开全量重置（seed 复现）。
+- V04 persistent_state：局内（环序进度与复位计数局内保留；重开全量清空）。
+- V04 软锁与不可达处理：不设永久软锁——关键目标均可通过正常飞行达成，或触发 V02 失败路径进入结算；结算界面重开为最终恢复出路。
+- V05 persistent_state 生命周期：当前动作级状态即时结算；当前局级状态（环序/复位/计时）局内保留、重开清空；跨局状态无。
+
+## 8. 世界设定与创作基线 [W01–W08]
+
+- W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。
+- W02 场景所在地：悬浮于云海之上的群岛天路——起飞平台立于首岛崖顶，环 1–4 沿低空岛缘铺设，环 5–8 横穿风谷（侧风常驻、双气流柱），环 9–12 升入高空窄环，终点环悬于终岛灯塔上空。
+- W03 玩家身份与当前任务动机：玩家是群岛信使候补飞行员，须在 420 秒内按序穿完全部 12 环、且复位不超过 10 次，完成首次正式投递。
+- W04 失败代价与结局表达：超时或复位超限＝「信件延误」——灯塔灯暗、信封被风卷走（C03 失败意象）；完成航线＝灯塔点亮、信封送达（C03 胜利意象）。
+- W05 叙事来源：滑翔机＝信使邮翼机（双翼轻航风格）；穿环＝群岛灯塔联盟的悬空环门；气流柱＝风谷上升暖流；检查点浮标＝灯塔联盟的救援浮标。全部原创，不用商业作品命名。
+- W06 视觉风格与色彩材质：明快云���插画风；主色＝云白 #F4F7F2、邮翼红 #D9553F、灯塔金 #E8B84B、远岛青 #6A9C8F；材质为帆布翼面、轻木机身、铜色环架与半透明风线。
+- W07 环境氛围与声音语言：高空风啸与远处海鸟声为底；音效语言＝引擎、风线、穿环提示、失速警报、复位（F06 冻结清单）；混音优先级：失速警报 ＞ 漏环警告 ＞ 穿环提示 ＞ 引擎 ＞ 风环境。
+- W08 故事表达方式：C01 开场交代候鸟节与投递任务 → 过程中风线与环门脉冲承载航线推进 → C03 结算双意象收束；叙事只做包装不改数值。
+
+## 9. 演出、镜头与反馈 [F01–F10]
+
+- F01 视角与镜头：第三人称追机镜头，机尾后上方（距离 8 单位、高 3 单位、FOV 62°）；相机地平线随横滚同步倾斜（横滚信息，G07）；镜头平滑跟随（阻尼 0.1）；C 键复位镜头到正尾方；镜头不入岛体；1920×1080 下 HUD 不遮挡下一目标环，1280×720 保持可读（I03）。
+- F02 关键操作镜头变化：穿环瞬间轻微 FOV +4°（0.3 秒）；碰撞/复位 0.3 秒中幅震动；失速期间镜头下沉跟随表达下坠感；设置可关闭（F09）。
+- F03 输入与延迟：见 I07（≤100ms P95）；顿帧不改变计时口径。
+- F04 环境常驻效果：云海缓慢流动、风线在风区常驻飘移（方向＝侧风指向）、气流柱内上升粒子、岛缘瀑布雾、检查点浮标灯呼吸；均为纯表现层（判定体独立）。
+- F05 事件反馈表（事件 → 画面表现 → 音效 → 结束条件，全部冻结需求）：
+
+| 事件 | 画面表现 | 音效 | 结束条件 |
+|---|---|---|---|
+| 起飞离地 | 尾迹展开＋平台气流粒子 | wind_swell（短促） | 爬升至巡航 |
+| 穿环 | 环门脉冲光环＋FOV +4°（0.3 秒） | ring_pass_chime | 脉冲消散 |
+| 漏环 | 目标环号橙框提示＋屏幕边缘轻闪 | ring_miss_warning | 过下一合法环或复位 |
+| 进入风场区 | 风线密度提升＋HUD 风区提示 | wind_zone_loop 起 | 离开风区 |
+| 进入气流柱 | 上升粒子包裹机身 | thermal_whoosh | 离开气流柱 |
+| 失速预警（≤45） | HUD 速度表转黄 | stall_pre_warning | 速度回升或失速 |
+| 失速（<40） | HUD 红色警报＋镜头下沉＋风噪增强 | stall_alarm | 速度 ≥50 脱离 |
+| 碰撞 | 撞击白闪＋0.3 秒中震＋碎屑 | crash_impact | 复位确认 |
+| 复位 | 淡出淡入回检查点＋机头朝向目标环 | reset_woosh | 复位完成 |
+| 超时/判负 | 暗角＋「TIME OUT / RETRY LIMIT」横幅 | timeout_alarm | 进入判负结算 |
+| 结算 | C03 播放（双意象）＋结算面板 | victory_sting / defeat_sting | 进入结算面板 |
+
+- F06 关键音效清单（one_shot 11 条＋环境循环 3 条，全部冻结需求）：wind_swell、ring_pass_chime、ring_miss_warning、stall_pre_warning、stall_alarm、thermal_whoosh、crash_impact、reset_woosh、timeout_alarm、victory_sting、defeat_sting（one_shot 共 11 条）；环境循环：wind_loop（高空风啸）、wind_zone_loop（风区风噪，强度随位置）、engine_loop（邮翼机引擎，随速变调）。无配音需求。
+- F07 VFX 信息性与遮挡约束：目标环高亮、风线方向、失速警报框为信息类 VFX，必须清晰可辨；穿环脉冲与尾迹不得遮挡下一目标环与 HUD；非结算单个全屏遮挡 ≤0.5 秒。
+- F08 音画同步：穿环音与脉冲同帧；失速警报音与红色警报同帧；复位音与淡出淡入同帧；风区音与风线密度同帧变化。
+- F09 屏幕震动：碰撞/复位 0.3 秒中幅（幅度 6 px 等效）；穿环 0.1 秒轻微；暂停/结算取消未结束的震动；设置可关闭（镜头震动开/关）。
+- F10 前端界面：标题（开始/设置/退出）→ 飞行 HUD（速度/环序/计时/复位数/失速预警/风区提示/姿态角读数，见 I03）→ 暂停面板（继续/重开/返回/设置）→ 结算面板（用时、环序、复位次数、评级；Enter 重开）；关键状态图标＋文字并用；窗口失焦自动暂停。
+
+## 10. 过场视频 [C01–C03]
+
+- C01 候鸟节起飞（Opening，6 秒，1280×720@24fps）
+  - 触发时机：首次由标题点击「开始」后、起飞平台就位之前，每局一次
+  - 内容与角色场景：云海日出、群岛灯塔依次亮起、信使邮翼机在起飞平台展开帆布翼，镜头自灯塔上空掠到平台正后方
+  - 资产对应：邮翼机、环门、起飞平台与游戏内模型同源
+  - 可跳过：Esc/Enter 跳过 → 直接进入起飞平台待命；自然播完 → 进入起飞平台待命
+  - 状态一致：跳过与自然播完后初始状态一致；播放期间不推进任何游戏计时
+- C02 关键穿环与气流事件（Event，5 秒，1280×720@24fps）
+  - 触发时机：本局首次进入上升气流柱时插入一次（画中画、不打断操作），每局最多一次
+  - 内容与角色场景：机身被上升粒子托举、穿过风谷环门的脉冲光环、风线自侧方掠过镜头
+  - 资产对应：邮翼机与环门同源
+  - 可跳过：Esc/Enter 跳过 → 立即返回飞行视角；自然播完 → 自动返回
+  - 状态一致：不打断飞行控制权；播放期间游戏计时正常推进
+- C03 航线结果（Ending，6 秒，1280×720@24fps，双意象共用条目）
+  - 触发时机：V01/V02 成立、结算面板出现之前，每局一次
+  - 内容与角色场景：胜利意象＝终岛灯塔点亮、信封送达、邮翼机绕塔盘旋；失败意象＝灯塔灯暗、信封被风卷走、机身停在检查点浮标旁
+  - 资产对应：邮翼机、环门、浮标与游戏内模型同源
+  - 可跳过：Esc/Enter 跳过 → 直接进入对应结算面板；自然播完 → 进入对应结算面板
+  - 状态一致：仅在真实 V01/V02 后触发；播放期间不推进任何游戏计时
+
+## 11. 范围与正向能力清单 [N01–N06]
+
+- N01 玩法能力：玩家可以驾驶邮翼机完成起飞与三段航线（M01–M03）、按序穿 12 环（M02）、借气流柱爬升与修正侧风偏航（M03）、碰撞后复位且环序不回退（M04/E01），在 420 秒内完成投递（V01）。
+- N02 流程与界面能力：主菜单、起飞、三段航线、终点结算、超时/复位超限判负、暂停（含失焦自动暂停）、一键重开全部具备真实入口。
+- N03 演出能力：C01–C03 视频、F04 常驻环境、F05 事件反馈表全部行、F06 音效 14 条、F09 震动与设置开关。
+- N04 输入范围：键盘为完整输入方式；鼠标为菜单辅助；手柄/触控为表现层扩展，不进入验收分母。
+- N05 音频范围：F06 冻结音效清单（11 one_shot＋3 环境循环）；无配音需求。
+- N06 表现层自由度：未冻结的装饰造型、配色、粒子参数与音色为生成自由度，由 L04 承担，不评估为缺失。
+
+## 12. 参考图绑定 [A01–A02]
+
+- A01 绑定原则：参考图只约束对应资产的造型、配色与比例，不约束航线布局（环位/气流柱/风场以本 spec L02 与 seed 为准）；R 条件提供 images/ 参考图，N 条件仅有文字描述，评测不得因 N 条件未见参考而追加扣分项。
+- A02 绑定表（文件 → 对象）：
+
+| 参考图 | 绑定对象 | 用途 |
+|---|---|---|
+| images/ref_sky_glider_sketch.png | 信使邮翼机 | 3D_object image_to_3d |
+| images/ref_ring_gate_sketch.png | 悬空环门 | 3D_object image_to_3d |
+| images/ref_scene_sky_islands_sketch.png | 浮空群岛天路 | 3D_scene image_to_scene |
+
+参考图为程序化概念草图（1024×1024，无文字；生成参数与负向提示见 asset_tasks/racing_simulation/ref_images_manifest.jsonl），可按该 manifest 扩散重绘后原位覆盖。
+
+## 13. 复杂度档案
+
+```yaml
+difficulty:
+  tier: M
+  complexity_profile: {coupling: C2, persistence: P1, recovery: R2, runtime_complexity: B2, hidden_state: H0}
+  dominant_dimensions: [coupling, runtime_complexity]
+  rationale: "局内多系统耦合：碰撞复位→环序、风场→轨迹两条可复现 A→B 边（C2）；实时三维飞行与风场连续判定（B2）；环序进度局内推进（P1）；检查点复位且环序不回退、失速自恢复（R2）；状态全可见（H0）"
+  downgrade_boundary: "删去按序穿环与复位保留（任意穿环即计、碰撞重开）后降为 S"
+  upgrade_boundary: "若环序进度或成绩跨局保留并解锁新航线，升 L-Regular"
+  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 任务资产为：sky_glider, ring_gate_kit, thermal_column_marker, checkpoint_beacon, wind_stream_vane, takeoff_skydeck。每项只允许一个物体；组合物必须拆成独立任务。
+- motion：1 个；覆盖动作：ring_bank_turn。
+- video/audio/mechanic/UI：分别为 3/14/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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt

@@ -0,0 +1,11 @@
+# G039_sky_ring_flight / 3D_object requirement
+
+Source of truth: ../general_requirement.txt
+
+Frozen task inputs:
+- sky_glider: Light twin-wing courier glider per reference image, canvas wings with postal red trim, light wood fuselage, brass propeller cowl, clear forward axis with origin at fuselage center of gravity, game-ready PBR, Y-up
+- ring_gate_kit: Floating sky-island ring gate per reference image, brass-framed torus with beacon lamps on rim and hanging pennants, decorative shell only for 12 instanced rings at radius 6 and 4, game-ready PBR, Y-up, pivot at ring center
+- thermal_column_marker: Semi-transparent rising air column marker with layered shimmer rings and small floating motes, cyan glow readable from distance, radius 10 zone visual, single object, Y-up
+- checkpoint_beacon: Sky rescue checkpoint buoy with breathing beacon lamp, small canvas pennant and brass chain, readable from flight distance, single object for 12 instanced beacons, Y-up
+- wind_stream_vane: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up
+- takeoff_skydeck: Cliff-top takeoff deck for a courier glider with wooden launch rail, canvas windbreak and beacon post, light timber construction with brass fittings, single object, Y-up

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

@@ -0,0 +1,91 @@
+{
+  "created_at": "2026-10-16T11:10:14+00:00",
+  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "original_records_archive": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_eb602026d1218ea6.zip",
+  "archive_sha256": "3c0dc12c14579072f183b445b9776221474a8d20b0ddfc7de5a2875c1cc4832f",
+  "records": [
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/meshy/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
+      "before_sha256": "3052eb2d0b2ff9aedc6030e2996044f1fea814186097a824a412b2b6b6509f22",
+      "after_sha256": "3052eb2d0b2ff9aedc6030e2996044f1fea814186097a824a412b2b6b6509f22"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/tripo/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
+      "before_sha256": "884815d60d19e1efdf310b046bf469b53cfc9c41a8a89abe410924ce0e9778de",
+      "after_sha256": "884815d60d19e1efdf310b046bf469b53cfc9c41a8a89abe410924ce0e9778de"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/meta.json",
+      "before_sha256": "9913773ebb52573ccc240e93c79adae32c5eab727ac4f6c7e9e8356aa188ddea",
+      "after_sha256": "9913773ebb52573ccc240e93c79adae32c5eab727ac4f6c7e9e8356aa188ddea"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/meta.json",
+      "before_sha256": "e4d9739a275ef147e3e6f1370d3b52ed913c6e56c518c2e2d51dc12644f56032",
+      "after_sha256": "986c5559e9e37e05572bc2de92223557e9d66c1497116d1a76b39194eaa95441"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/render_meta.json",
+      "before_sha256": "81ab429b16cbd258935bf7e191b69077096631c2d3c3ffc0c0ffd57693ecb7dc",
+      "after_sha256": "81ab429b16cbd258935bf7e191b69077096631c2d3c3ffc0c0ffd57693ecb7dc"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/render_meta.json",
+      "before_sha256": "55e1dc5cab226eaf8ba6d2de02458dac14e7599615d64aecbdcd3cf7309f3745",
+      "after_sha256": "55e1dc5cab226eaf8ba6d2de02458dac14e7599615d64aecbdcd3cf7309f3745"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/qa.json",
+      "before_sha256": "eecb95b04429594af21150fab8ea44b54a60a4e5289f6bcf8bfdefa04355f78c",
+      "after_sha256": "eecb95b04429594af21150fab8ea44b54a60a4e5289f6bcf8bfdefa04355f78c"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/render_meta.json",
+      "before_sha256": "3979f171b0a2f3ea895844e15b97a09f7aeed7df8aba6a15af18a798cd8dc02b",
+      "after_sha256": "3979f171b0a2f3ea895844e15b97a09f7aeed7df8aba6a15af18a798cd8dc02b"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/native/render_meta.json",
+      "before_sha256": "a4193e411ff5d22fa23707dfdc46b9dc2f5a296e5b8bd67e10e5a12592df674d",
+      "after_sha256": "a4193e411ff5d22fa23707dfdc46b9dc2f5a296e5b8bd67e10e5a12592df674d"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/qa.json",
+      "before_sha256": "3e8f5bbf4612683e4ff41378879a1c5afe1350214dc50d690eed7dc391d65e45",
+      "after_sha256": "3e8f5bbf4612683e4ff41378879a1c5afe1350214dc50d690eed7dc391d65e45"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_generation_report.json",
+      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
+      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_manifest.json",
+      "before_sha256": "325dca72cd066ac50607a41d7168f4ea52472c2afe2b92dee314b0de210fdeb3",
+      "after_sha256": "cbe68fba970df90e8334487798fc9ac20a5b95b7cddd44a6195dc721271e41f6"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/meta.json",
+      "before_sha256": "ac48050248f74b3e8050849fc0c6ed2b542c57526a0571fd141f6a4790beecee",
+      "after_sha256": "ac48050248f74b3e8050849fc0c6ed2b542c57526a0571fd141f6a4790beecee"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_generation_report.json",
+      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
+      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_manifest.json",
+      "before_sha256": "e2dcb107bfed3245da3925b14105c0c49901c0ba14ebdc4524dc1fe6e765f91a",
+      "after_sha256": "9a004e8c561a52c67498e559cf480dbc851c8d9e721cfadb820ead11f7855148"
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/meta.json",
+      "before_sha256": "3accc0be0e8fc146fca78033f2d1ef39cdf4c932bcadee5b0df030761585aab2",
+      "after_sha256": "3accc0be0e8fc146fca78033f2d1ef39cdf4c932bcadee5b0df030761585aab2"
+    }
+  ],
+  "api_calls": 0,
+  "meshes_changed": false,
+  "absent_artifact_links_cleared_for_undelivered_inventory_rows": true
+}

outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_d287b99e24e5c8fa.zip

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

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_eb602026d1218ea6.zip

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

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json

@@ -0,0 +1,88 @@
+{
+  "submissions": {
+    "0d874e6bc269a6a97496fb701901483c7c0580491fe2d534a4658ff0e6a913d7": {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "reserved_credits": 20,
+      "status": "created",
+      "remote_id": "01a142f7-70e3-73f4-ab13-bd13ef695829",
+      "response": {
+        "result": "01a142f7-70e3-73f4-ab13-bd13ef695829"
+      }
+    },
+    "c8e1ddfa9d9796f0b0f5f644db2b20facd0384f53d5a68b52b1463349bb1108d": {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "reserved_credits": 10,
+      "status": "created",
+      "remote_id": "01a142f8-19ab-7259-962c-aade734abc46",
+      "response": {
+        "result": "01a142f8-19ab-7259-962c-aade734abc46"
+      }
+    }
+  },
+  "results": {
+    "/openapi/v2/text-to-3d/01a142f7-70e3-73f4-ab13-bd13ef695829": {
+      "id": "01a142f7-70e3-73f4-ab13-bd13ef695829",
+      "type": "text-to-3d-preview",
+      "mode": "preview",
+      "name": "",
+      "model_type": "standard",
+      "seed": 1043,
+      "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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": 1792124878520,
+      "progress": 100,
+      "started_at": 1792124878524,
+      "finished_at": 1792124916827,
+      "task_error": null,
+      "model_urls": {
+        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.glb?Expires=4945708800&Signature=atUIywbEpRp6NHnFvzkJAXcknbtm51g0GUOmJN6PGhet5JCvpKnj29KypFnqimi36dZl987L5N~pAu5B0YdcPbd8iEenpZkiaFhvi4z2ewoqAR~aqwH~OChGEyzuyvhSOGsSVyKCJTWcsHjIh54l4PUIh-P~uzX3YxL~LB4r6ci2cyzEZVcZKFdBkF33XfpsOM7FSUtbKa~3H~BvMd25f4EHCyC3ZKPwYhH6pbrGF4UR1LYxGpxPCqxBLTyqaUUndnrCNeaT9L65mcrGp8w4PRl43oK3ZkmlmTStqrMdKMGI55F9umWJ9z8v6lO5SpeXmQ7A2oMfglgr3NM3t4xCfA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.fbx?Expires=4945708800&Signature=hvHZoOpP4oeyo5TLZO-pZeVVdc5VzcMRjIDTfBJUZFewZDhRPCDfm9iJoH6tnLBGYA~JFR69~vVRVE84ezhOgxz5Se~fZq48NizyT8zGDELpofdfjhGzknfawL~mqaqInXP4CBYSAVQKKgSCUKlTB2unaRNGObIxL21BCPgkzh83i5wazbXgkTKkuDTAi1AMdh-7FTvxPcP9n5RB~npky3asM7HVJfzoTHoIOY8dFRxCt4WvHvFBzJ8pmRpDsexnjyFzrGHLVYpVomYbKw9sBTbvk6d~7FA~C2i1ZyDS8-w8FRXSE2PpU0l-iLKPMXC9JdALx7nURYFbEMDAC8F5Xg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.usdz?Expires=4945708800&Signature=W7juJGbjyLit0UPLJLFqpXcA35Mg7y4KfGYV16QUxWhoyRTCn2J-On5fLfD96BW3NadHV6aTQkSTB~oCGze31sZcIXDqtlbBBi0P9gvbCyz74oAga5EaSdNbROSJnvRp5OFsdeSDBnVBzTjwu4-5yXxEb~8nOsW~dk2P-ERw4li~g0XlzcGtRL14Fw~su~B6mZS0aChsqp0U-TNbJU9TzqVrY2~-jZdXeeMmthmyVP78D-QWNhGMUCFJcs8wNZe2V9p6PG-4KpXtno48jra-UArB4GBP~gUlKUK0fIbq6BGs3rgoSuaaOZ~9~Og8ME5PUfvu92iMdIwVVOzOdVMl4Q__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.obj?Expires=4945708800&Signature=RTqtRPssU1XmHlhtzes2tbxuMsCBFRF9jzUU8ZIpIXjrMIqh4PB~jVHITS4A4Rq1UVc2LEPtz4zL0WN5Lt1~Ng3LTc4xu7-4MC1hhnPBbh8Hlb-Df-saqifI~ppqzciOAGck1tcJdduzxRlJ8Sfqi-lKqovbgTMC64xqDaE7hr15Zh1rApIqBPHd-pgfS3VkmuM7bAcovZlN6FN0MV32T6EGmTu6P78K5GMk0PaEv2Z~e1VyPt1xMDHxcBl2qCMFK~GFQ9XrHAqDqHUok0-4D3XZFOkMY-tVKNDd9PnZoDWbTg6LbPRVML2QkT-VmhRqag-P7GvyHSixltnYczuKAQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.stl?Expires=4945708800&Signature=CMVmpymoRFfWtt9kyeuO3okbb89Cyt~x5fZDDAMcIUiMFpRpUneZ6jHz-NrNm-dUOtTNnF7aC7h8qTfytUZW57rw1Ee4XJrgEK0XeIK5QX96EHDecwWm0kA4XpwUexKn46e4CC~fDuEm2xYGbZopHozZJLbDu0cmAd-XlEUkjphos3464SLCc643t0ttAqLeUN83ivrGRN3ST2fndugr3hlvYcNTl19sqkGDxz2hbGsHO43xhH8T2xK3TEEm92MMqsUUYGZTv8uecBRTKh42Scyn5FbX-0WPWQcFfco5uTRsIOzRQ49GlzAn0~2d3OWqztJx~aWE7YBAg7k8OpLFPA__&Key-Pair-Id=K1VGYTHIYLM9UM"
+      },
+      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/preview.png?Expires=4945708800&Signature=eGu0ZemuCL2gLjPZfQu0bAWDBbLH54OWdDO7RUTfXVAjYI3mZzLdOgJUHRfsP6IACTRLZlEgpe4rdzyz1RlhRtMnEInxRsxso3vFMQbndLzSfZPE94IiBv0xZVrzNgXUkjRNIF6wHWK32FVgK~Rxju8SE1nok6LAXrraW2vu-UZc-bj25GCqu2REPyrN60ERv50fJBeV5iyzUjMUh6F5XRK7B2d0zlEntwUwOnQwK32uG3RZ8Ra3Qk~jKTTnNyp3F-CgCl1bKHDAeQgonBGUtPzIwIYBTmTAMwKVB6O-OLJWkMHKPtgvn94~0SgvteM5zTy3E~0p2RbDslTEx~uwyg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+      "texture_urls": [],
+      "consumed_credits": 20
+    },
+    "/openapi/v2/text-to-3d/01a142f8-19ab-7259-962c-aade734abc46": {
+      "id": "01a142f8-19ab-7259-962c-aade734abc46",
+      "type": "text-to-3d-refine",
+      "mode": "refine",
+      "name": "",
+      "model_type": "standard",
+      "seed": 1043,
+      "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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": 1792124918208,
+      "progress": 100,
+      "started_at": 1792124918215,
+      "finished_at": 1792125001169,
+      "task_error": null,
+      "model_urls": {
+        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.glb?Expires=4945708800&Signature=OS63L7aKhQAW9LjUM4S88caGUM46yvOfIQo2ohLkvL~nFADDPLJmRFRY49dMFY-PuW58XbO~2zyxsBBdPMlXFG1Ia3gAQQKZP-qLytUFlAyL3n0ifhAcgFeYWRb6B4Pj5mw07VLuFhdJOmGwITGyvqnNWrSFLtBQeQsWf8dUM1fJGGKirdFo0X9gRSPa94kzCxhdWOiqs~RDXr~DJbaCPdQnQJVluosgBAO08hZY2VkX2N4nT-LWdawMt8Dc0X27CRDr0s8YcKKvc~kSO70XDpIlc-oWT7scqsgFA1a5-VXWzSW5qJ0AuZVH3bzMs7HK~lESjd3uOTXAfvODS-wh8A__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.fbx?Expires=4945708800&Signature=pFAm5WARO6UJ9Iu7IcrmsXqbE7pqLhwljANqNBIFItjMtOwS1FNWs1S~jzPBrGXD1yjRtcv8cs5LyYGJRCx9SbkHrzILSXmGWYtwPAMVp1B0vpzTHCd8UHOURGRez8GiJbBjeowLJVrzKqZEW2k~hVTai6nzaXfwbh-E3-qXGNVWWPOk6oOae~kSad-yY-mPb0pBoISjw0KWSagFptceabbdawGAUKWl4DOj5vcsLzpi~GyxXndk-cAAR18pZ69Zhu8kxgEseWJz7VPWMdZciI92w6u8PDaN2zGijyBjLIhWc7gc0jM6-bMMKqlrOL3ZVg9E3ak1LBRXiu0T7b4Gcg__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.usdz?Expires=4945708800&Signature=kRJqBuAXQPdb~3xarxYG1tpyRN7HZTL4J7h0hToAEJBhdk-wCuxSzLymVVcVan-Yfvj9qO9ugAqdYMwKubyUARzcEQ81oEn8tIpPbEXsiKRltTriz5dt0MdW7FTcWUW8tfcJMizH~nBP6G~ej58J9nTgC1QtFsuErrTn5GSbk9atZBZ2GetSjK0ilgnZfHsRo6EuFuAKnpfQO28ZfFvPl8BWPFapbtY8qQIcXq9lo3wkLDCScZH1RSFX-S5QPtLEgwQq1IkSqtbicArnNsIV3mHnPznpxqR4AOVeNo2sO6YdddLiPpdgjgAxUCeQv0z8X36-t0F5qovLSwnXZIiWBQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.obj?Expires=4945708800&Signature=gP9aGLq9ssk8YDqRqs4VSvxCsxkF4QDD4jLOEPZD~ufbR0CH8j4V5WISuUOsH1Y4MQJl4cY6RGsPEp9I26NGMLgzIpZsE0HIdCs6-Qul9nU3pB7BsNp5Pvum2itpvSYnb9rKKEte4zoNUBMUdTNTjxYtvjBVDIqSS4R1-pNy28sSZHubYJQeF0WxoUo-XlJGy9ahao9~QDkgegqp9xj3mUc3IDjKgJKJagNmruTlF543PLWgJnW5CUrzJhSei1Ua-gXiYRDWCgGwNZDiFdVdU-l7D5hOh3cdGUUtwvM2xgnXG3D1U8C~cNihc3yE4GZRD7N4IMGaziK4f~m7vM42sA__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "mtl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.mtl?Expires=4945708800&Signature=Q7FKC~7lRps2Ie6dO5FDvr4TFLgBtY2uGiR6DY2iMk7eL3gFRnX439BFUzd4qZrOk-xDc2Yo3ahcw2r1CZQgyyqZroIIE1J7smxqrfNrqoZSqPCgV6ld6evkyjKPzdmB0Cp0T6DpRVIdU0umMGDvOa1GXqjT3mxnWAHYHLJovtB~4Ewif-PSDJRHElxiG4PrHUyUOvgx82PNEz9MrEpYpwvSOK4gy0~OKR3MKiqpfO0XMHcdZ4AhIJkJJe5pqvo6G6QajTF5IAziGIoOJHI5O0-0rQuASKpcCvRmhz8Tui9Nc2XBkfGwtNMSFlsKbjUPDUadR3iLVG-~st1QNa-0mw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.stl?Expires=4945708800&Signature=m89BWE2hHm0m01cPWlwHBpbSCX~neuwAaXr520OPM0oXqr7qe4c6f7zOq-J7b-M0R8uHsr0PC33NiBmNN4qMwsKDzijaZm6RVVyP4o5aRc2OjGEUmP4TggUpXb4qpAOaWV0-TAq26pL4eV8t5K6pi9AvAeHSJmXgyHIEzNxKgxOozQoBAt775pmFyUyj19GXok0YA6bj3eshj3BV0zVmLzFWcjee2AFrYPuTZjPhSpbdbnZObMWJJ3nasG3FTXQWoGib4TXfGGHcCtyrGSfiZwKVEqPDqj4253JcI2YFQ5dwid1XhuaTk6JghmDN85L~VowMTsiDFGqOqcSwlJ7R2w__&Key-Pair-Id=K1VGYTHIYLM9UM"
+      },
+      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/preview.png?Expires=4945708800&Signature=pf9kXoRiecSv9ApuG7GkKsojX1hT~6QZiHhcSPaBUpSHPflxfcyPPssPN2mCsnUhKEkh7Mj3oJxnwhKVgNz5hVARIcMILE0zgXp~mT4YK6cmt4nr2C1NJmJvhf35MmMDJIhfOQiZtR8gVylqYs790e3HHRFqeY033CfPtlhybZRMVoefX4a50x1CkD-ar54OvG-HGWNdiCO6XfCuzXNJ2hN5ocbnWLEf32Ga8Lk4Kj4w5kmhOQsrS5XCowDuDBnk6k2-viXZcxOf4j~pUOr1PY7gaTWBZ1avXGZqH3B9IEUWvHzHP87J4XvSUpC8lnugxH1tnCmPufACYm26utxkhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+      "texture_urls": [
+        {
+          "base_color": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0.png?Expires=4945708800&Signature=OvK5Wpl5iaoO5bu~ZYWJY63LAmDF9aMsWwqvPkrGXf5xGrB2BY2gfYljAy5rXHhFG5zclXmY-Ro1e5sPtna2qemQCMJUX9j39gH9Uf~Ng5Ft59athq0EJbvtHFRMUQFnAajWuBiWssFSZrXdX6RBp~Nfbuxf2Zui54giDDqRPJXvXzVr3B9yqpP9tSbczyqZfIFh85GcQcKBGLgdi6UiqDvwC0Sjd271f0fO4VyLJOE3OmnuStCjq4xYYwlKMyqV990hLBQE9uPQINPj4~zkKt8S~gigBoqX0zbKI5HDgV0y53tekerM388wjz3-zniyE35IDKok~lkk1XIYhfbbhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "metallic": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_metallic.png?Expires=4945708800&Signature=NLtsIYZ9qPwS2~BjVpwjNEIjq-NjBQVdaqou0SOsahxgSnOXSeVrTn6AE8IOPvMTDHzClo1jwfl4QY9gQbWXZe7pyf0rWStvUKEJi4G0UbrXAICfwdKTLtnSjtnZVSBHfSYEhy3wM7KNOjeIaP9uKbSg~oRWpzWp0GSsL7Ng1Az-ZvCQaGtUE9D8x-hBeTh9WH95VzDQ~jqEwSawmn8eJYvo7ehaDzHw-y1XNURcxxVJDBJEQtf8GGSTelbU~QTiuZNqoeCRgfwqEmiSxsfpA~Vsd3vkd6aP62xzr844Kln8r7NJwjyF8obSEaN4OslhxkNrYrnBpXkTk3jbKXh-1w__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "roughness": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_roughness.png?Expires=4945708800&Signature=deDzr7dgztYg-qQCFF-vtq2GCVsokRaq10BK3hrkJU5yFaP3P-YNHmXV3WhCO1pfm1IYQiMBTvmfX2O1Tp2AdEOFIfJTv1ltgnxRUWaBEEAHLL3VgUOyHX-zN0UkFWgNV0OMOHzv2e0xsC6iX8yuY0~su6JUX8H1CvtF0jGKfxL4k1-M28ZzIwqlzGuD6tdi8WVso4FzNZ1tk3cvfivrTqjqKvrcmXjG0OVBV4oS6AMsYh2ZV9u-lWLocEn3-7gBbHxOzGqe2TVMhWeAlT~H8wyNn3jgMh6lL40Y8RHGpLizGNyN0DUHzEpWXdP6L5ZLCYd3hnCWqKy7qeb64lakcw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "normal": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_normal.png?Expires=4945708800&Signature=gbgobNdgUbtp4ZHyZDtHme~nmydZ9BwCkhZv2csiYszlN1IF1yYAPKUwAZPWqcMh-yMwjuzdpNkTvYL9zRH79OEtSD2hZuAkVkAMOOJeeI661oobBg3XGk0ts~IJInYkq8eaTv9JyC4omJY2SES5g97GtV25G0JsBYIPFLReoWzJOb3pltyXrxWQKcK-zaxVphBXOqJUrOrZPb--Ew7tH4PuTSeJUdbgDGi1M2iOcRVLictka5qfZ~OQylw81fgqw8wah0tv339~t3xS4-1OiNaOKLuS56jYumu7o0eHudIiAX-O9IkFWINWC0Zy0uaFdOZydmsnlqjc60Znvrf6KQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
+          "emission": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_emission.png?Expires=4945708800&Signature=UEgmoyM1yklAGUtzK7Nr-AN5WL6OWzMabQ4HvgioweDTn7qrEF~CDHAbnd1mWPJeNL3eqJj42nj7l8ouB8B2Xmd86ieBvxESLBQOjHWlcwlM9xSU17p24AUC6W-rzAmeffWGF5~J~e8hs9r7EG4Rl22wxgqvyT99DbTf0xYLOvbs-uwQS5cdFgCnuDPJh9ztVISI7INJIIoW-6KsYj8-aN9gQJTPRzB0bV0c7A4n5xVWHHobmCSPdrkWrHJpOiIdMgHLa2aCkcCkQYwyJ75ifINjkMcW3SHRonwvZsri~tL4qb61HDVi2JHINNhJFy5vKy~VkNceNimz5kum~QcLgA__&Key-Pair-Id=K1VGYTHIYLM9UM"
+        }
+      ],
+      "remove_lighting": true,
+      "consumed_credits": 10
+    }
+  }
+}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json

@@ -0,0 +1,54 @@
+{
+  "submissions": {
+    "d27ea0c549f2f38bdf92e11e71c077f1d03d1930e6715a34f9e63e3f5649c127": {
+      "endpoint": "/generation/text-to-model",
+      "reserved_credits": 30,
+      "status": "created",
+      "remote_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
+      "response": {
+        "code": 0,
+        "status": "success",
+        "data": {
+          "type": "text_to_model",
+          "status": "queued",
+          "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b"
+        }
+      },
+      "reported_credits": 30.0
+    }
+  },
+  "results": {
+    "/tasks/f242bcce-d29e-4a07-a20c-019277c9280b": {
+      "code": 0,
+      "status": "success",
+      "data": {
+        "type": "text_to_model",
+        "status": "success",
+        "progress": 100,
+        "input": {
+          "pbr": true,
+          "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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": 1043,
+          "texture_seed": 1043,
+          "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/f242bcce-d29e-4a07-a20c-019277c9280b/tripo_pbr_model_f242bcce-d29e-4a07-a20c-019277c9280b.glb?auth_key=1792224016-ddtirljj-0-3396bfeef393d8fe2b5f9cf64c602863",
+          "rendered_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/legacy_mesh.webp?auth_key=1792224016-bibrcxrc-0-b77b51744d52f9e52e969d362bd4a51e",
+          "generated_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/text2image_f242bcce-d29e-4a07-a20c-019277c9280b.jpeg?auth_key=1792224016-htafmuue-0-d272e653024adc3a8b6359380251d71e"
+        },
+        "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
+        "created_at": "2026-10-16T07:56:09.040945Z",
+        "completed_at": "2026-10-16T08:00:13.546338Z",
+        "credits_consumed": 30.0
+      }
+    }
+  }
+}

outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/sources_index.json

@@ -0,0 +1,108 @@
+{
+  "files": [
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
+      "bytes": 26758
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
+      "bytes": 1330
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/method_selection.md",
+      "sha256": "d9b0471f4c0e0f1e70c76e2bba676d3275d10530451435dc625972dbcea9abbe",
+      "bytes": 11846
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md",
+      "sha256": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
+      "bytes": 6384
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json",
+      "sha256": "e41ec834db7ed651c3845b1f4fb9e8815778ca82a975b76f25560db16d60fffe",
+      "bytes": 13081
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1.meta.json",
+      "sha256": "e40477fb6672d86566cd0b52422ba81560938720aee700c6cd007febac46e520",
+      "bytes": 1965
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json",
+      "sha256": "a6a1415ee18381e1302df7586d017bb3360a71cea4dd92be30a7c00e761c61fe",
+      "bytes": 2827
+    },
+    {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076.meta.json",
+      "sha256": "d3b46e10d8d43c1c003600d3828cca9f1a073d16a2cdb11585c0f668c2d18808",
+      "bytes": 1574
+    }
+  ],
+  "receipt_bytes_preserved": true,
+  "frozen_plan_unchanged": true,
+  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d"
+}

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

@@ -0,0 +1,30 @@
+{
+  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
+  "game_id": "G039_sky_ring_flight",
+  "provider": "tripo",
+  "scope": "3d_object_only_not_complete_stage2",
+  "tasks": [
+    {
+      "task": {
+        "game_id": "G039_sky_ring_flight",
+        "task_id": "G039_sky_ring_flight_obj_005",
+        "asset_name": "wind_stream_vane",
+        "name_zh": "风线仪",
+        "role": "prop",
+        "input_mode": "text_to_3d",
+        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+        "seed": 1043,
+        "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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/import/model.glb

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

outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/meta.json

@@ -0,0 +1,170 @@
+{
+  "game_id": "G039_sky_ring_flight",
+  "task_id": "G039_sky_ring_flight_obj_005",
+  "asset_name": "wind_stream_vane",
+  "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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "source_task": {
+    "game_id": "G039_sky_ring_flight",
+    "task_id": "G039_sky_ring_flight_obj_005",
+    "asset_name": "wind_stream_vane",
+    "name_zh": "风线仪",
+    "role": "prop",
+    "input_mode": "text_to_3d",
+    "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1043,
+    "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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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:30:06+00:00",
+  "visual_status": "PENDING",
+  "native_delivered": true,
+  "result": {
+    "task_id": "G039_sky_ring_flight_obj_005",
+    "glb_path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/model.glb",
+    "elapsed_sec": 131.48,
+    "game_id": "G039_sky_ring_flight",
+    "task_kind": "3d_object",
+    "output_dir": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy"
+  },
+  "native_structural_qa": "PASS",
+  "model_call": {
+    "provider": "meshy",
+    "model": "meshy-6",
+    "task_id": "01a142f8-19ab-7259-962c-aade734abc46",
+    "task_ids": [
+      "01a142f7-70e3-73f4-ab13-bd13ef695829",
+      "01a142f8-19ab-7259-962c-aade734abc46"
+    ],
+    "elapsed_sec": 131.47,
+    "credits": null,
+    "cached": false,
+    "cache_key": "621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1",
+    "format": "glb",
+    "preview_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/preview.png?Expires=4945708800&Signature=pf9kXoRiecSv9ApuG7GkKsojX1hT~6QZiHhcSPaBUpSHPflxfcyPPssPN2mCsnUhKEkh7Mj3oJxnwhKVgNz5hVARIcMILE0zgXp~mT4YK6cmt4nr2C1NJmJvhf35MmMDJIhfOQiZtR8gVylqYs790e3HHRFqeY033CfPtlhybZRMVoefX4a50x1CkD-ar54OvG-HGWNdiCO6XfCuzXNJ2hN5ocbnWLEf32Ga8Lk4Kj4w5kmhOQsrS5XCowDuDBnk6k2-viXZcxOf4j~pUOr1PY7gaTWBZ1avXGZqH3B9IEUWvHzHP87J4XvSUpC8lnugxH1tnCmPufACYm26utxkhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
+    "bytes": 9577000,
+    "triangles": 7880,
+    "meshes": 1,
+    "materials": 1,
+    "textures": 4,
+    "images": 4,
+    "nodes": 1,
+    "generator": "pygltflib@v1.16.5"
+  },
+  "artifact_sha256": "6b0eab059bd1e619ca24e6e6ef32d2b1380faa094b778c7df2451bc4673d19d4",
+  "import_delivered": true,
+  "import_sha256": "61407909da58fd9808dc88d62e3820ec1edf0570199e5e78c33e1c7d57f9545c",
+  "import_structural_qa": "PASS",
+  "postprocess": {
+    "status": "PASS",
+    "triangles_before": 7880,
+    "triangles_after": 7880,
+    "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": 0.72,
+    "visual_review": "PENDING"
+  },
+  "preview": {
+    "status": "downloaded",
+    "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/preview.png",
+    "visual_review": "PENDING"
+  },
+  "generation_cost": [
+    {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "remote_id": "01a142f7-70e3-73f4-ab13-bd13ef695829",
+      "reservation": 20,
+      "reported_credits": null,
+      "status": "created"
+    },
+    {
+      "endpoint": "/openapi/v2/text-to-3d",
+      "remote_id": "01a142f8-19ab-7259-962c-aade734abc46",
+      "reservation": 10,
+      "reported_credits": null,
+      "status": "created"
+    }
+  ]
+}

outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/model.glb

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

outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/import/model.glb

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

outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/meta.json

@@ -0,0 +1,147 @@
+{
+  "game_id": "G039_sky_ring_flight",
+  "task_id": "G039_sky_ring_flight_obj_005",
+  "asset_name": "wind_stream_vane",
+  "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/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
+      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
+    },
+    "object_requirement": {
+      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
+      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
+      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
+    },
+    "context_excerpt": "空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。",
+    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
+  },
+  "source_task": {
+    "game_id": "G039_sky_ring_flight",
+    "task_id": "G039_sky_ring_flight_obj_005",
+    "asset_name": "wind_stream_vane",
+    "name_zh": "风线仪",
+    "role": "prop",
+    "input_mode": "text_to_3d",
+    "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
+    "seed": 1043,
+    "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 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, 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-16T08:00:19+00:00",
+  "visual_status": "PENDING",
+  "native_delivered": true,
+  "result": {
+    "task_id": "G039_sky_ring_flight_obj_005",
+    "glb_path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/model.glb",
+    "elapsed_sec": 251.72,
+    "game_id": "G039_sky_ring_flight",
+    "task_kind": "3d_object",
+    "output_dir": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo"
+  },
+  "native_structural_qa": "FAIL",
+  "model_call": {
+    "provider": "tripo",
+    "model": "v3.1-20260211",
+    "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
+    "elapsed_sec": 251.71,
+    "credits": 30.0,
+    "cached": false,
+    "cache_key": "9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076",
+    "preview_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/legacy_mesh.webp?auth_key=1792224016-bibrcxrc-0-b77b51744d52f9e52e969d362bd4a51e",
+    "bytes": 3112864,
+    "triangles": 10929,
+    "meshes": 1,
+    "materials": 1,
+    "textures": 3,
+    "images": 3,
+    "nodes": 1,
+    "generator": "https://tripo3d.ai"
+  },
+  "artifact_sha256": "d0c6d905188eb02c5e7d2c1bd21154f8c111b8bdddc1104348e2fac3acc477af",
+  "import_delivered": true,
+  "import_sha256": "8c0dc293ffbb7f46e01d9a9f4e513d28180ca31ac570643ed4ba51aeb7ca3bfc",
+  "import_structural_qa": "PASS",
+  "postprocess": {
+    "status": "PASS",
+    "triangles_before": 10929,
+    "triangles_after": 7999,
+    "triangle_target": 8000,
+    "texture_target": 1024,
+    "textures": [
+      {
+        "name": "Color_f242bcce-d29e-4a07-a20c-019277c9280b",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "ORM_f242bcce-d29e-4a07-a20c-019277c9280b",
+        "before": [
+          2048,
+          2048
+        ],
+        "after": [
+          1024,
+          1024
+        ]
+      },
+      {
+        "name": "NormalGL_f242bcce-d29e-4a07-a20c-019277c9280b",
+        "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.38,
+    "visual_review": "PENDING"
+  },
+  "preview": {
+    "status": "downloaded",
+    "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/preview.png",
+    "visual_review": "PENDING"
+  },
+  "generation_cost": [
+    {
+      "endpoint": "/generation/text-to-model",
+      "remote_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
+      "reservation": 30,
+      "reported_credits": 30.0,
+      "status": "created"
+    }
+  ]
+}

outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/model.glb

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

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/render_meta.json

@@ -0,0 +1,60 @@
+{
+  "label": "meshy_G039_sky_ring_flight_obj_005_import",
+  "source": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/import/model.glb",
+  "output": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import",
+  "provider": "meshy",
+  "task_id": "G039_sky_ring_flight_obj_005",
+  "variant": "import",
+  "source_sha256": "61407909da58fd9808dc88d62e3820ec1edf0570199e5e78c33e1c7d57f9545c",
+  "views": [
+    {
+      "axis": "+z",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_z.png"
+    },
+    {
+      "axis": "-z",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_z.png"
+    },
+    {
+      "axis": "+x",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_x.png"
+    },
+    {
+      "axis": "-x",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_x.png"
+    },
+    {
+      "axis": "+y",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_y.png"
+    },
+    {
+      "axis": "iso",
+      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/iso.png"
+    }
+  ],
+  "geometry": {
+    "bounds": [
+      0.8493079841136932,
+      1.8995019793510437,
+      0.6107359826564789
+    ],
+    "bounds_min": [
+      -0.4268819987773895,
+      -0.9507899880409241,
+      -0.3067989945411682
+    ],
+    "bounds_max": [
+      0.4224259853363037,
+      0.9487119913101196,
+      0.30393698811531067
+    ],
+    "meshes": 1,
+    "triangles": 7880,
+    "skinned": 0,
+    "force_front_side": false,
+    "renderer": "WebKit WebGL",
+    "three": "180",
+    "animation_clips": 0
+  },
+  "status": "rendered"
+}