feat(asset-gen): blender-to-unity skill — deterministic scale normalization + scale note

Blender FBX imports ~100x oversized; import_model_file target_size only acts when
Auto-normalize is on and is unreliable for Blender FBX (target_size=2 measured 200m
in a live test). Step 4 now measures the placed model's world bounds and sets
localScale to hit the target size deterministically. Adds a Scale note + checklist item.

Claude-Session: https://claude.ai/code/session_01NoHk4f7N1vUFs7gu817ihm

Author: Scriptwonder

.claude/skills/blender-to-unity/SKILL.md

@@ -30,15 +30,35 @@ directly.
    ```
    (glTF branch: `bpy.ops.export_scene.gltf(filepath=out_glb, export_format='GLB')`.)
 3. **Import into Unity** with `import_model_file`:
-   `import_model_file(source_path=<temp path>, name=<asset name>, target_size=<meters, optional>)`.
-   It returns `{ asset_path, asset_guid }`.
-4. **Place it in the scene.** Ensure the scene has a camera + directional light
-   (`manage_scene` / `manage_gameobject`). Instantiate the imported model into the open scene
-   at the chosen position via `manage_gameobject(action="create", prefab_path=<asset_path>, ...)`.
+   `import_model_file(source_path=<temp path>, name=<asset name>, target_size=<final size in meters>)`.
+   It returns `{ asset_path, asset_guid }`. Pass `target_size` as the intended final size, but treat
+   it only as a hint: it rescales at import solely when the project's **Auto-normalize** pref is on,
+   and even then is unreliable for Blender FBX (see the **Scale** note). Step 4 does the reliable
+   normalization.
+4. **Place it in the scene, normalized to size.** Ensure the scene has a camera + directional
+   light (`manage_scene` / `manage_gameobject`). Instantiate the model at the chosen position via
+   `manage_gameobject(action="create", prefab_path=<asset_path>, name=<asset name>, position=[x,y,z])`.
+   Then normalize its size deterministically — Blender FBX commonly imports ~100× too large — by
+   measuring the placed model's world bounds and scaling so its largest dimension equals your target
+   size. Run via `execute_code` (substitute your object name and target meters):
+   ```csharp
+   var go = GameObject.Find("<asset name>");
+   var rs = go.GetComponentsInChildren<Renderer>();
+   var b = rs[0].bounds; for (int i = 1; i < rs.Length; i++) b.Encapsulate(rs[i].bounds);
+   float maxDim = Mathf.Max(b.size.x, Mathf.Max(b.size.y, b.size.z));
+   float target = 2f; // intended size in meters
+   if (maxDim > 0.0001f) go.transform.localScale *= target / maxDim;
+   ```
 5. **Verify** with `manage_camera(action="screenshot", include_image=true)` and report the
    asset path + a screenshot.
 
 ## Notes
+- **Scale.** Models from Blender almost always arrive at the wrong scale — its FBX unit handling
+  makes them land ~100× too large in Unity. `import_model_file`'s `target_size` only rescales at
+  import when the project's Auto-normalize pref is enabled, and its importer-level normalization is
+  unreliable for Blender FBX (it can over- or under-shoot, e.g. a `target_size=2` model measured 200 m).
+  The robust fix is the Step 4 measure-bounds-then-set-`localScale` routine, which hits the target
+  size deterministically regardless of the import scale or the Auto-normalize pref.
 - FBX is the default because glTFast is optional in MCP for Unity. If the import errors with
   "GLB import requires glTFast", re-export as FBX (or install glTFast from the Dependencies tab).
 - Keep one model per handoff; for batches, repeat the loop with distinct names.

.claude/skills/blender-to-unity/manual-verify.md

@@ -7,6 +7,8 @@ Run against a live Blender (BlenderMCP) + Unity (MCP for Unity) pair.
 - [ ] `import_model_file` returns `success: true` with `asset_path` under `Assets/` and a non-empty `asset_guid`.
 - [ ] The imported model appears in the Project window at `asset_path`.
 - [ ] The model is instantiated in the open scene and visible in a `manage_camera` screenshot.
+- [ ] Scale: after the Step 4 measure-bounds-then-`localScale` routine, the placed model's largest
+      world dimension ≈ the target size (Blender FBX imports ~100× too large until normalized).
 - [ ] glTF path: with glTFast installed, a `.glb` export imports successfully; without it,
       the error names glTFast/the Dependencies tab (and FBX still works).
 - [ ] No API keys or file bytes appear in any bridge payload (handoff is filesystem-only).