wave3d-agent-sdk 0.2.13 → 0.2.15

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdir as mkdir3, readFile as readFile2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile2, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import { execFile } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir2 } from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import JSZip from "jszip";
@@ -14,7 +14,7 @@ import MiniSearch2 from "minisearch";
 
 // ../../scripts/wavegenie-sdk/server.ts
 import { createServer } from "node:http";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { createReadStream } from "node:fs";
 
 // ../../src/lib/waveStudio/aiAssist/core/resultEnvelope.ts
@@ -182,10 +182,10 @@ var WaveGenieBridgeCommandBroker = class {
 };
 
 // ../../scripts/wavegenie-sdk/mcp.ts
-import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path2 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path3 from "node:path";
 
 // ../../wave-engine/dist/src/core/assetPipeline/registry/gaussianSplatAssetTypes.js
 var WAVE_GAUSSIAN_SPLAT_RUNTIME_ASSET_ROOT = "/defaultAssets/runtime/adobe-spz";
@@ -531,6 +531,7 @@ var PROJECT_ASSET_ACCESSOR_BUCKETS = [
   "materials",
   "textures",
   "animations",
+  "vertexAnimations",
   "poses",
   "audios",
   "instruments",
@@ -555,7 +556,6 @@ var WaveModelPartScope;
 (function(WaveModelPartScope2) {
   WaveModelPartScope2["Available"] = "available";
   WaveModelPartScope2["Created"] = "created";
-  WaveModelPartScope2["Promoted"] = "promoted";
   WaveModelPartScope2["All"] = "all";
 })(WaveModelPartScope || (WaveModelPartScope = {}));
 var WaveModelPartLifecycleState;
@@ -25422,12 +25422,12 @@ var Tools = class {
    * @param path defines the path to use
    * @returns the filename
    */
-  static GetFilename(path5) {
-    const index = path5.lastIndexOf("/");
+  static GetFilename(path6) {
+    const index = path6.lastIndexOf("/");
     if (index < 0) {
-      return path5;
+      return path6;
     }
-    return path5.substring(index + 1);
+    return path6.substring(index + 1);
   }
   /**
    * Extracts the "folder" part of a path (everything before the filename).
@@ -41609,7 +41609,7 @@ var DEFAULT_PHYSICS = {
 };
 
 // ../../src/lib/waveStudio/assets/contracts/waveStudioEngineAssetContracts.ts
-var WAVE_STUDIO_ENGINE_ACCESSOR_BUCKET_EXTENSIONS = ["cubeMaps", "poses"];
+var WAVE_STUDIO_ENGINE_ACCESSOR_BUCKET_EXTENSIONS = ["cubeMaps", "poses", "vertexAnimations"];
 function withAccessorBucketExtensions(buckets) {
   const existingBuckets = new Set(buckets);
   return Object.freeze([
@@ -41996,23 +41996,36 @@ var WAVE_STUDIO_PRIMARY_ASSET_BUCKET_SPECS = Object.freeze([
   },
   {
     bucket: "animations",
-    assetTypes: ["animation", "vertexAnimation"],
+    assetTypes: ["animation"],
     label: "Animation",
     pluralLabel: "Animations",
     defaultExtension: ".anim.json",
     baseCategoryAliases: [
       "animations",
       "animation",
-      "fbx_animation",
+      "fbx_animation"
+    ],
+    pathFolderAliases: ["animations"],
+    pathExtensions: ["anim.json", "glb", "gltf", "fbx"],
+    assetManagerAlias: "animationNames",
+    monaco: { interfaceName: "AnimationNames", propertyName: "animationNames" }
+  },
+  {
+    bucket: "vertexAnimations",
+    assetTypes: ["vertexAnimation"],
+    label: "Vertex Animation",
+    pluralLabel: "Vertex Animations",
+    defaultExtension: ".vat.json",
+    baseCategoryAliases: [
       "vertexanimation",
       "vertexanimations",
       "vertex_animation",
       "vat"
     ],
-    pathFolderAliases: ["animations"],
-    pathExtensions: ["anim.json", "vat.json", "glb", "gltf", "fbx"],
-    assetManagerAlias: "animationNames",
-    monaco: { interfaceName: "AnimationNames", propertyName: "animationNames" }
+    pathFolderAliases: ["vertexAnimations", "vertexanimations"],
+    pathExtensions: ["vat.json"],
+    assetManagerAlias: "vertexAnimationNames",
+    monaco: { interfaceName: "VertexAnimationNames", propertyName: "vertexAnimationNames" }
   },
   {
     bucket: "poses",
@@ -42520,8 +42533,8 @@ function normalizeWaveGenieAssetUploadRequest(request) {
 
 // ../../src/lib/waveStudio/aiAssist/bridge/localAgentSdkContract.ts
 var WAVE3D_AGENT_SDK_PACKAGE_NAME = "wave3d-agent-sdk";
-var WAVE3D_AGENT_SDK_REQUIRED_VERSION = "0.2.13";
-var WAVE3D_AGENT_SDK_REQUIRED_BUILD = "agent-sdk-20260625.1";
+var WAVE3D_AGENT_SDK_REQUIRED_VERSION = "0.2.15";
+var WAVE3D_AGENT_SDK_REQUIRED_BUILD = "agent-sdk-20260627.1";
 var WAVE3D_AGENT_SDK_PACKAGE_SPEC = `${WAVE3D_AGENT_SDK_PACKAGE_NAME}@${WAVE3D_AGENT_SDK_REQUIRED_VERSION}`;
 var WAVE3D_AGENT_SDK_START_COMMAND = `npx -y ${WAVE3D_AGENT_SDK_PACKAGE_SPEC} start`;
 var WAVE3D_AGENT_SDK_TOKEN_ENV_VAR = "WAVE3D_MCP_TOKEN";
@@ -42660,7 +42673,12 @@ var WAVE_MCP_TOOL_ALIAS_CANONICAL_NAMES = {
   mcp_status: "get_wave_mcp_health",
   get_mcp_health: "get_wave_mcp_health",
   get_mcp_status: "get_wave_mcp_health",
-  get_wave_mcp_status: "get_wave_mcp_health"
+  get_wave_mcp_status: "get_wave_mcp_health",
+  generate_wave_3d_model: "create_wave_3d_modeling_job",
+  create_wave_3d_model: "create_wave_3d_modeling_job",
+  create_wave_3d_model_from_screenshots: "create_wave_3d_modeling_job",
+  make_wave_3d_model_from_screenshot: "create_wave_3d_modeling_job",
+  scaffold_wave_3d_modeling_job: "create_wave_3d_modeling_job"
 };
 function canonicalizeWaveMcpToolName(toolName) {
   return WAVE_MCP_TOOL_ALIAS_CANONICAL_NAMES[toolName] ?? toolName;
@@ -42802,6 +42820,7 @@ var WAVE_MCP_TOOL_CONTRACTS = {
   get_wave_runtime_entity_snapshot: { workMode: "observe", domain: "runtime", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
   list_wave_runtime_markers: { workMode: "observe", domain: "marker", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
   capture_wave_screenshot: { workMode: "observe", domain: "visual", safety: "readOnly", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true },
+  create_wave_3d_modeling_job: { workMode: "operate", domain: "modeling", safety: "workspaceOperation", targetPolicy: "none", requiresTaskRoute: false, supportsTaskRoute: true, directIntentKind: "asset.manage", directEditIntent: "modifyAssets" },
   query_wave_api: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "none", requiresTaskRoute: true, supportsTaskRoute: true },
   edit_wave_file: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "exactPathRequired", requiresTaskRoute: true, supportsTaskRoute: true },
   apply_wave_patch: { workMode: "author", domain: "code", safety: "authoringMutation", targetPolicy: "exactPathRequired", requiresTaskRoute: true, supportsTaskRoute: true },
@@ -42944,6 +42963,9 @@ var WAVE_MCP_ASSET_STAGING_STORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "get_wave_asset_upload_status",
   "abort_wave_asset_upload"
 ]);
+var WAVE_MCP_LOCAL_SDK_WORKSPACE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_wave_3d_modeling_job"
+]);
 function getWaveMcpToolExecutionScope(toolName) {
   const canonicalToolName = canonicalizeWaveMcpToolName(toolName);
   if (WAVE_MCP_SESSION_DISCOVERY_TOOL_NAMES.has(canonicalToolName)) return "sessionDiscovery";
@@ -42952,6 +42974,7 @@ function getWaveMcpToolExecutionScope(toolName) {
   if (WAVE_MCP_REFERENCE_LOOKUP_TOOL_NAMES.has(canonicalToolName)) return "referenceLookup";
   if (canonicalToolName === "get_wave_command_result") return "commandStatus";
   if (WAVE_MCP_ASSET_STAGING_STORE_TOOL_NAMES.has(canonicalToolName)) return "assetStagingStore";
+  if (WAVE_MCP_LOCAL_SDK_WORKSPACE_TOOL_NAMES.has(canonicalToolName)) return "localSdkWorkspace";
   return "pairedStudioSession";
 }
 function waveMcpToolRequiresStudioSession(toolName) {
@@ -42973,6 +42996,7 @@ function waveMcpToolFamily(toolName) {
   const contract = getWaveMcpToolContract(toolName);
   if (contract?.domain === "vfs") return "studio.vfs";
   if (contract?.domain === "asset") return "studio.assets";
+  if (contract?.domain === "modeling") return "wave.modeling";
   if (contract?.domain === "project") return "studio.project";
   if (contract?.domain === "preview") return "studio.preview";
   if (contract?.domain === "runtime") return "studio.preview";
@@ -43548,7 +43572,7 @@ function buildWaveMcpTaskRouteRecommendedNextToolCall(route) {
     if (route.editIntent === "modifyAssets") {
       return {
         tool: "find_wave_assets_by_category | upload_wave_asset | create_wave_asset_upload | rename_wave_asset | delete_wave_asset",
-        arguments: { category: "<models|textures|materials|audios|hdr|animations|...>" },
+        arguments: { category: "<models|textures|materials|audios|hdr|animations|vertexAnimations|...>" },
         note: "Use category first to reduce search space."
       };
     }
@@ -43720,8 +43744,8 @@ function hasStringProperty(args, names) {
   return names.some((name) => typeof args[name] === "string");
 }
 function editWaveFileArgsAreExact(args) {
-  const path5 = trimString(args?.path, 240);
-  if (!path5) return false;
+  const path6 = trimString(args?.path, 240);
+  if (!path6) return false;
   const hasExactLineRange = isPositiveInteger(args?.startLine) && isPositiveInteger(args?.endLine) && hasStringProperty(args, ["text", "replacement"]);
   const hasExactTextReplace = typeof args?.oldText === "string" && args.oldText.length > 0 && hasStringProperty(args, ["newText", "replacement"]);
   return hasExactLineRange || hasExactTextReplace;
@@ -43755,7 +43779,7 @@ function waveMcpToolRoutingNote(toolName) {
     return " Direct Observe tool: call directly without start_wave_task. Pass taskRouteId only to attach this observation to an active Author/Diagnose route.";
   }
   if (contract.workMode === "operate") {
-    return " Direct Studio Operate tool: when the user asks for this exact Studio operation, call directly without start_wave_task. Pass taskRouteId only if this operation belongs to an active Author/Diagnose route.";
+    return " Direct Operate tool: when the user asks for this exact operation, call directly without start_wave_task. Pass taskRouteId only if this operation belongs to an active Author/Diagnose route.";
   }
   if (contract.workMode === "author" && contract.safety === "readOnly") {
     return " Direct Author lookup tool: callable without start_wave_task, but for normal code authoring use after intent chunks/Core Intent Pass and skill-family selection.";
@@ -44090,14 +44114,14 @@ function validateWaveMcpTaskToolCall(input) {
 function recordWaveMcpTaskEvidenceUse(input) {
   let evidence = input.evidence;
   const canonicalToolName = canonicalizeWaveMcpToolName(input.toolName);
-  const path5 = trimString(input.args?.path, 240);
+  const path6 = trimString(input.args?.path, 240);
   const skillId = trimString(input.args?.skillId, 120) || trimString(input.args?.id, 120);
   if (canonicalToolName === "list_wave_files") evidence = { ...evidence, filesListed: true };
   if (canonicalToolName === "read_wave_file") {
     evidence = {
       ...evidence,
       filesListed: true,
-      filesRead: uniqueStrings([...evidence.filesRead, path5].filter(Boolean), 64)
+      filesRead: uniqueStrings([...evidence.filesRead, path6].filter(Boolean), 64)
     };
   }
   if (canonicalToolName === "find_wave_assets_by_category") evidence = { ...evidence, assetsListed: true };
@@ -44245,7 +44269,7 @@ var WAVE_AUTHORING_CORE_INTENT_STAMPS = [
   "Multiplicity/performance: wave.group.instancing-and-batching for local repeated model-backed objects; classify per-instance needs before choosing real entities, InstanceMeshGroup/waveInstanceGroup/waveInstanceMesh, or waveThinBatch. Count alone never chooses thin batch. Terrain/world/streamed population is a separate world-elements route.",
   'Soft custom geometry: wave.geometry.sdf-surface and assetManager.createSdfSurface("assetName") recipes for buns, cushions, puffy/squishy toys, and organic rounded forms before plain primitives, raw mesh buffers, or vertex editing.',
   "Path-bound surface geometry: wave.geometry.surface-ribbons and wavePathSurface for roads, trails, walkways, bridge decks, waterfalls, and continuous strips before asset-manager factories, scattered planes/cubes, or raw mesh buffers.",
-  "Asset argument vs authoring: typed refs such as models.<asset>, textures.<asset>, materials.<asset>, audios.<asset>, hdr.<asset>, cubeMaps.<asset>, and animations.<asset> for existing assets; waveMaterial for material handles; assetManager only when an exact skill/API requires a low-level generated asset factory."
+  "Asset argument vs authoring: typed refs such as models.<asset>, textures.<asset>, materials.<asset>, audios.<asset>, hdr.<asset>, cubeMaps.<asset>, animations.<asset>, and vertexAnimations.<asset> for existing assets; waveMaterial for material handles; assetManager only when an exact skill/API requires a low-level generated asset factory."
 ];
 var WAVE_AUTHORING_CORE_INTENT_PASS_QUICK_GUIDE = [
   WAVE_AUTHORING_CORE_RULES.coreIntentPass,
@@ -44348,7 +44372,7 @@ function buildWaveMcpAuthoringReminder(kind) {
         ...base,
         nextStep: "Use exact asset refs as method inputs, then return to the authoring strategy.",
         checklist: [
-          "Use returned code refs exactly, such as models.X, textures.X, materials.X, audios.X, or animations.X.",
+          "Use returned code refs exactly, such as models.X, textures.X, materials.X, audios.X, animations.X, or vertexAnimations.X.",
           "For authoring new materials, prefer waveMaterial; quote materials.X only for existing material assets.",
           "If a newly referenced asset changes bootstrap needs, let Studio hot reload escalate internally."
         ],
@@ -44454,7 +44478,7 @@ var WAVE_MCP_AGENT_BRIEF = [
   "VFS modules: scene-root modules and their owned helpers run inside the Studio authoring context, but helpers should stay pure or parameterized. Put live object ownership in scene-root/feature files, not shared helpers.",
   'VFS HTML sketches: for diagram/chart/doc-sketch requests, create or edit an exact `.html` file with Studio VFS tools. Mermaid renders from `<div class="mermaid">flowchart TD ...</div>` when that HTML file is active in the editor/coding pane; HTML sketches must never replace the live engine preview iframe. Do not put Mermaid in markdown fences unless user specifically wants markdown text.',
   'VFS hot reload ownership: Studio hot reload targets the active/open edited file when safe. Editing `/main.ts` reloads the main graph; editing a scene-root module reloads that root; bootstrap/scene registry/assets/network/ambiguous helper surfaces escalate. In multi-file projects, standalone `hot_reload_wave_preview` follows the active Studio editor file, so do not expect it to reload an arbitrary unopened module by path. Put heavy world loading in bootstrap or a coarse world module. Static VFS/package/asset-surface changes can be detected from file/package diffs and Studio may upgrade the tier automatically. Runtime-authored UI state changes cannot be inferred from files; if UI in `main.ts` changes bootstrap/world-provider/runtime-envelope state, store the state and call `waveStudio.reloadPreview({ reason, invalidates: ["world-provider"] })`. Valid invalidations are `bootstrap`, `world-provider`, and `runtime-envelope`. Do not call `myScene.hotReload(...)` from Studio-authored code because it bypasses Studio VFS/package/source-patch orchestration. For intentional cross-module live entities, the owner module calls `waveStudio.exportEntity("Name", entity)` and importer modules call `waveStudio.importEntity<T>("Name")`; Studio restores the exported baseline and replays active importer overlays during source hot reload. Source execution order is dependency-driven: exporter roots run before importer roots; an exporter root runs before `main.ts` when main imports it; importer overlays run after exporter/main baseline. Entity names must be static string literals, unique, and acyclic or run/hot reload stops before execution. Keep shared helpers pure or parameterized.',
-  "Assets: when quoting or passing an existing asset, use typed bare refs in main files: `models.X`, `textures.X`, `materials.X`, `audios.X`, `hdr.X`, `cubeMaps.X`, `animations.X`, etc. Do not paste raw paths or edit Studio-managed generated files just to register assets. If the exact ref is not already visible, call category-first asset discovery (`find_wave_assets_by_category`, alias `list_wave_assets_by_category`, alias `search_wave_assets_by_category`, or tolerant `list_wave_assets`) with required `category` from user intent, semantic `query`, and small `limit` before editing code; category-filtered results can still be capped/truncated, so refine query before concluding absence. Use `list_wave_explorer_assets` only for uploaded library metadata, rename/delete, URL, path, size, or display/ref-name management.",
+  "Assets: when quoting or passing an existing asset, use typed bare refs in main files: `models.X`, `textures.X`, `materials.X`, `audios.X`, `hdr.X`, `cubeMaps.X`, `animations.X`, `vertexAnimations.X`, etc. Do not paste raw paths or edit Studio-managed generated files just to register assets. If the exact ref is not already visible, call category-first asset discovery (`find_wave_assets_by_category`, alias `list_wave_assets_by_category`, alias `search_wave_assets_by_category`, or tolerant `list_wave_assets`) with required `category` from user intent, semantic `query`, and small `limit` before editing code; category-filtered results can still be capped/truncated, so refine query before concluding absence. Use `list_wave_explorer_assets` only for uploaded library metadata, rename/delete, URL, path, size, or display/ref-name management.",
   "Asset authoring facade split: typed refs quote existing assets; `waveMaterial` authors material handles; `assetManager` is only for exact asset-pipeline/generated-asset APIs that a local SDK skill or API lookup names, such as SDF surfaces or surface ribbons. Do not treat `assetManager` as the default creative facade for materials or normal asset arguments.",
   "Material authoring: when creating, configuring, forking, or intentionally editing material handles, route to `wave.material.authoring` and start from `waveMaterial` (`createWater`, `createGrid`, `createSplatMaterial`, `createFromAsset`, `editAsset`). If a material handle later needs runtime sync, `assetManager` may be passed as the sync target; it is still not the authoring root.",
   "Preview: default to hot reload after code changes. On the final edit use `awaitHotReload: true` when you want edit + hot reload + diagnostics in one response; `requestHotReload:true` now also waits for diagnostics by default unless paired with `awaitHotReload:false`. Standalone `run_wave_preview` / `hot_reload_wave_preview` wait by default and return same-call bounded diagnostics in `runtimeVerification`; set `awaitRuntimeResult:false` only for intentional fire-and-poll. Wave Studio may upgrade the hot-reload tier internally for asset/bootstrap/runtime-surface changes, including a full scene rebuild only when required. Caveat: standalone `hot_reload_wave_preview` mirrors the toolbar button and reloads the currently open/active TypeScript file in multi-file projects; it does not take a target path or reload every user-created .ts module. Use `pause_wave_preview` / `resume_wave_preview` for toolbar-equivalent engine pause/resume.",
@@ -44477,7 +44501,7 @@ var WAVE_MCP_AUTHORING_GLOBALS_GUIDE = [
   "- Direction and input enum-style globals: `Direction.X/Y/Z`, `Direction.Left/Right/Up/Down/Forward/Backward`, `Keyboard`, `MouseButton`, `GamepadButton`, `InputPhase`, `MovementMode`, `RotationMode`.",
   "- Colors/materials/fx helpers: `COLOR`, `PALETTE`, `waveCOLOR`, `waveMaterial`, `shaderUniform`, `waveFx`, `waveFxPresets`, `FxAnchor`, `FxCondition`.",
   "- Controller movement helpers: `waveKinematicActor`, `netKinematicActor`, `KinematicHumanoidMovementState`, `KinematicVehicleMovementState`, and `KinematicFlightMovementState`. Use actor-level `.asHumanoid(...)`, `.asVehicle(...)`, or `.asFlight(...)` for player/controller movement.",
-  "- Asset maps: use category-first refs returned by `find_wave_assets_by_category`, commonly `models`, `gaussianSplats`, `animations`, `materials`, `guis`, `textures`, `audios`, `instruments`, `videos`, `hdr`, `fonts`, `serializedData`, `terrains`, `fx`, and `particles`.",
+  "- Asset maps: use category-first refs returned by `find_wave_assets_by_category`, commonly `models`, `gaussianSplats`, `animations`, `vertexAnimations`, `materials`, `guis`, `textures`, `audios`, `instruments`, `videos`, `hdr`, `fonts`, `serializedData`, `terrains`, `fx`, and `particles`.",
   '- Scene/runtime handles: prefer `myScene` for scene composition and `waveStudio` for Studio operations. If authored UI changes bootstrap/world-provider/runtime-envelope state and needs the Studio preview package to rebuild, call `waveStudio.reloadPreview({ reason, invalidates: ["world-provider"] })`, not `myScene.hotReload(...)`. Valid invalidations are `bootstrap`, `world-provider`, and `runtime-envelope`; use the narrowest true reason. `assetManager` is available, but use it only when an exact skill/API names an asset-pipeline or generated-asset factory; do not use it as the default facade for existing asset refs or material authoring. Use lower-level `ctx`, `engine`, or `scene` only when existing code or an exact API requires them.',
   "- Authoring systems/presets: `waveEventBus`, `waveRig`, `waveValueCurve`, `waveValueCurvePresets`, `waveMotionSignal`, `waveParam`, `WaveParam`, `WaveChoice`, `prefabModels`, `effectPrefabs`, and prefab helpers such as `rocketPrefab`.",
   "- Lowercase constructors: `prop`, `marker`, `sphere`, `point`, `cube`, `box`, `cylinder`, `capsule`, `cone`, `torus`, `plane`, `ground`, `line`, `arc`, `path`, and related shape helpers.",
@@ -44510,7 +44534,7 @@ var WAVE_MCP_CODING_GUARDRAIL = [
   `4i. ${WAVE_AUTHORING_CORE_RULES.syncUserCode}`,
   `4j. ${WAVE_AUTHORING_CORE_RULES.terrainGroundRouting}`,
   "5. Use `get_wave_session` and `list_wave_files` to know active file context. `/main.ts` and scene `*/main.ts` get convenience globals: write against `myScene`, not a hand-created scene.",
-  `6. ${WAVE_AUTHORING_CORE_RULES.assetResolution} In main files, use bare asset maps like \`models.Foo\`, \`gaussianSplats.Room\`, \`textures.Grass\`, \`materials.Wood\`, \`animations.Idle\`, \`audios.Click\`, \`hdr.daylight\`, \`cubeMaps.studio\`, \`fonts.Poppins_Regular\`, \`serializedData.SomeJson\`. Do not add \`ASSET_WAREHOUSE.\` unless raw warehouse access is explicitly needed.`,
+  `6. ${WAVE_AUTHORING_CORE_RULES.assetResolution} In main files, use bare asset maps like \`models.Foo\`, \`gaussianSplats.Room\`, \`textures.Grass\`, \`materials.Wood\`, \`animations.Idle\`, \`vertexAnimations.HorseGallopVat\`, \`audios.Click\`, \`hdr.daylight\`, \`cubeMaps.studio\`, \`fonts.Poppins_Regular\`, \`serializedData.SomeJson\`. Do not add \`ASSET_WAREHOUSE.\` unless raw warehouse access is explicitly needed.`,
   `6a. For authoring constants, prefer bare runtime globals declared by the Studio authoring environment. Common examples: ${WAVE_AUTHORING_COMMON_GLOBAL_EXAMPLES_TEXT}. The generated globals surface has many more values; use local-SDK \`query_wave_api\` before inventing namespace-qualified paths such as \`TransformVerbMode.Animate\` in authored code. HTTP Gateway hides/retires skill/API lookup.`,
   "6b. Asset facade split: passing an existing asset uses typed refs such as `models.X`, `textures.X`, `materials.X`, or `audios.X`; material authoring starts from `waveMaterial`; `assetManager` is reserved for exact low-level generated-asset/asset-pipeline APIs named by a local SDK skill or API lookup. Do not use `assetManager` as the default material, asset-ref, or path-surface authoring root.",
   '7. Use category-first asset discovery before referencing uploaded user assets, project aliases, or ambiguous built-in assets. Preferred tool: `find_wave_assets_by_category`; aliases: `list_wave_assets_by_category`, `search_wave_assets_by_category`, tolerant `list_wave_assets`. Choose category from user intent first, then query: `list_wave_assets_by_category({ category:"materials", query:"grass", limit:50 })`. For sound use `audios`, for 3D objects use `models`, for sky/HDR use `hdr`, for cube-map sky/environment use `cubeMaps`, for images use `textures`. Category-filtered responses can still be capped/truncated; absence there is not absence in the library. Only use asset refs returned by this tool. If the current code already contains the exact ref and the user asks for a small pattern-preserving edit, you may reuse that visible ref.',
@@ -44522,7 +44546,7 @@ var WAVE_MCP_CODING_GUARDRAIL = [
   '11. After the final code edit, default to hot reload. Prefer `awaitHotReload: true` on the edit tool when you want one MCP response with edit result + hot reload + bounded diagnostics. `requestHotReload:true` also waits for diagnostics by default unless paired with `awaitHotReload:false`. Standalone `run_wave_preview` / `hot_reload_wave_preview` also wait by default and return `runtimeVerification`; set `awaitRuntimeResult:false` only for intentional fire-and-poll. Caveat: standalone `hot_reload_wave_preview` mirrors the toolbar button and reloads the currently open/active TypeScript file in multi-file projects; it does not take a target path or reload every user-created .ts module. That hot-reload request may internally upgrade from `patchMain` to `preserveScene` or hard `rebuildScene` when assets/bootstrap/scene surface changed; do not manually force bootstrap sync. Runtime-authored UI that changes bootstrap/world-provider/runtime-envelope state must call `waveStudio.reloadPreview({ reason, invalidates: ["world-provider"] })` because Studio cannot infer that from static file diffs. Use `run_wave_preview` only when diagnostics show no successful preview yet (`hasRunSucceeded: false`), the user explicitly asks for a full run/restart, or hot reload/polling fails and a full restart is the last resort. `pause_wave_preview` and `resume_wave_preview` are direct preview controls mirroring the toolbar pause/resume buttons.',
   '12. After run/hot reload, use returned `runtimeVerification` when present; otherwise call `get_wave_runtime_diagnostics` repeatedly until `runtimeBusy` is false and `lastRuntimeOutcome` is `success` or `error`. Use `previewExecutionPhase` to distinguish Studio preparing work from the preview iframe executing it. `isRunning` is only the Studio scheduling flag, not the final runtime completion gate. If the edit/runtime tool returned `requestedAt` or `runtimeActionRequestedAt`, ignore diagnostics whose `lastRuntimeOutcomeAt` is older than that timestamp. Treat `latestError` as current only when `lastRuntimeOutcome` is `error`; older error lines can remain in returned logs as history. Treat `editorErrorCount > 0` as blocking Monaco/linter/compile failure and read `editorDiagnostics` before claiming success, even when `lastRuntimeOutcome` is `success`. If `lastRuntimeOutcome` is `success` and `editorErrorCount` is 0, verify visually with `capture_wave_screenshot({ resolution: "L" })` or structurally with `get_wave_runtime_entity_snapshot({ variableName, filePath? })` instead of declaring failure from old log text. Same-machine screenshots usually return `localPath`; hosted screenshots return exact field `dataBase64`, not `imageBase64`.',
   "12a. Marker waypoint workflow: when the human asks to use preview marking tools such as `clickToMark()`, route with `marker.use` plus the code/project intent, then call `list_wave_runtime_markers`. Treat marker records as runtime observation data, write marker `worldPosition`/`worldRotation` into the appropriate path/waypoint/placement code, hot reload, and verify with screenshot or marker re-read. One marker read may happen before routing only when needed to decide the code intent. Use path/placement skills only when current code does not reveal the marker-to-code pattern.",
-  `13. To use locally generated assets in code, prefer \`create_wave_asset_upload\` for local files when available: pass assetKind from the Wave Studio upload policy SSOT (${getWaveStudioBridgeAssetUploadKindHelpText()}), stat the file first, pass exact byte size, get \`uploadUrl\` + \`uploadHeaders\`, upload raw bytes with plain HTTP PUT using every returned header exactly, keep \`clientToken\`/\`uploadHeaders.Authorization\` out of logs, call \`get_wave_asset_upload_status\` until \`receivedBytes === sizeBytes\`, then call \`commit_wave_asset_upload\` with the same uploadId, assetKind, filename, contentType, and sizeBytes from the create response. No local Python, Vercel package, or Blob SDK is required. On hosted MCP this uses hosted temporary object storage; on same-machine local MCP it uses the local SDK as temporary staging. If direct upload is unavailable, use \`stage_wave_asset_upload_chunk\` plus \`commit_wave_asset_chunk_upload\`: omit uploadId only for chunkIndex 0, then reuse the returned uploadId for every later chunk and for commit. Use \`upload_wave_asset\` with exactly one of \`dataBase64\` or \`dataUrl\` only for small inline assets. If staging is abandoned before commit, call \`abort_wave_asset_upload\` with the uploadId. Do not abort after commit returns pending or completed; the Studio browser cleans committed staging after execution. Hosted MCP cannot read local filesystem paths through inline upload. All flows stage bytes outside the command queue, cap staged bytes at 300 MB, and return \`asset.bareRef\`, for example \`textures.Albedo\`, \`cubeMaps.Studio\`, \`materials.Wood\`, \`audios.Click\`, \`models.Robot\`, \`animations.Run\`, \`fonts.Title\`, or \`serializedData.Config\`. If the name already exists, the upload result returns \`skipped: true\` and the existing asset. Staged chunks/blobs are also swept lazily after about 24 hours. Model-family uploads enable meshoptimizer by default unless \`useMeshoptimizer\` is false.`,
+  `13. To use locally generated assets in code, prefer \`create_wave_asset_upload\` for local files when available: pass assetKind from the Wave Studio upload policy SSOT (${getWaveStudioBridgeAssetUploadKindHelpText()}), stat the file first, pass exact byte size, get \`uploadUrl\` + \`uploadHeaders\`, upload raw bytes with plain HTTP PUT using every returned header exactly, keep \`clientToken\`/\`uploadHeaders.Authorization\` out of logs, call \`get_wave_asset_upload_status\` until \`receivedBytes === sizeBytes\`, then call \`commit_wave_asset_upload\` with the same uploadId, assetKind, filename, contentType, and sizeBytes from the create response. No local Python, Vercel package, or Blob SDK is required. On hosted MCP this uses hosted temporary object storage; on same-machine local MCP it uses the local SDK as temporary staging. If direct upload is unavailable, use \`stage_wave_asset_upload_chunk\` plus \`commit_wave_asset_chunk_upload\`: omit uploadId only for chunkIndex 0, then reuse the returned uploadId for every later chunk and for commit. Use \`upload_wave_asset\` with exactly one of \`dataBase64\` or \`dataUrl\` only for small inline assets. If staging is abandoned before commit, call \`abort_wave_asset_upload\` with the uploadId. Do not abort after commit returns pending or completed; the Studio browser cleans committed staging after execution. Hosted MCP cannot read local filesystem paths through inline upload. All flows stage bytes outside the command queue, cap staged bytes at 300 MB, and return \`asset.bareRef\`, for example \`textures.Albedo\`, \`cubeMaps.Studio\`, \`materials.Wood\`, \`audios.Click\`, \`models.Robot\`, \`animations.Run\`, \`vertexAnimations.HorseGallopVat\`, \`fonts.Title\`, or \`serializedData.Config\`. If the name already exists, the upload result returns \`skipped: true\` and the existing asset. Staged chunks/blobs are also swept lazily after about 24 hours. Model-family uploads enable meshoptimizer by default unless \`useMeshoptimizer\` is false.`,
   "14. Project tools: use `list_wave_project_templates` before `new_wave_project({ templateId? })`; use `list_wave_projects` before `rename_wave_project({ projectId, name })` or `open_wave_project({ projectId })`. Use `read_wave_project` to learn from example packs without replacing the current editor workspace: pass exact `projectId` from `list_wave_projects` for listed/saved projects, or pass a shared/published project `url` directly for silent URL reads. Shared URL reads support old `/waveStudio?share=<uuid>` links and new shared alias links; published URL reads support old/new `/p/<user>/<id>` links. Rename updates saved project display metadata only. New/open replace the live workspace. If there are unsaved changes they return `unsaved_changes` unless you save first or explicitly pass `discardUnsavedChanges: true`; only use exact ids returned by list tools for open/rename.",
   "15. `save_wave_project` quick-saves an existing saved project and ignores name/description. For a new unsaved project, pass name/description when available; otherwise Studio generates defaults and returns whether each field was defaulted.",
   "16. `share_wave_project` runs the same Share Project menu pipeline, returns a 30-day share `url`, and requires write pairing plus the signed-in share policy. Always send the returned `url` back to the user.",
@@ -44541,7 +44565,7 @@ var WAVE_MCP_CODING_GUARDRAIL_SUMMARY = [
   "4. Prefer natural, intent-preserving public APIs and aliases such as Actor, Prop, Cube, Sphere, waveMaterial, semantic directions, Animate/Seconds/DegreesPerSecond, and fluent WaveEngine DSLs.",
   `4a. ${WAVE_AUTHORING_CORE_RULES.hotReloadCallbackSafety} edit_wave_file/apply_wave_patch/create_wave_file preflight this rule and runtime bundling blocks violations before authored code runs.`,
   "4b. For model voxelization, route to `wave.model.voxelization`; use `model.voxelizing().relativeSize(0.05).surfaceOnly().onWorkerThread().usingCubes().asThinBatch().applyAsync()` only when async/worker authored code is explicitly acceptable, or `onMainThread().apply()` only for tiny local synchronous voxel work. Never use `.apply().then(...)` or Promise callback chains. Use `detectNear`, `getColorAt`, and `whenIndexClicked(index => voxelBatch.at(index).enlargeBy(1.2).done().commitBuffers())` for thin-batch voxel interaction. Do not use `voxelizeHeavy`, `voxelize({ voxelSize })`, `withVoxelSize`, `sharedBox`, or stale `atIndex`.",
-  "5. Resolve assets explicitly. Use category-first bare refs returned by `find_wave_assets_by_category` or alias `list_wave_assets_by_category`: models.X, textures.X, materials.X, audios.X, hdr.X, animations.X. Do not guess refs, raw paths, or infer absence from a capped list.",
+  "5. Resolve assets explicitly. Use category-first bare refs returned by `find_wave_assets_by_category` or alias `list_wave_assets_by_category`: models.X, textures.X, materials.X, audios.X, hdr.X, animations.X, vertexAnimations.X. Do not guess refs, raw paths, or infer absence from a capped list.",
   "6. `project.assetrefs.ts`, `project.scene.ts`, `project.scenes.ts`, and `project.execution.ts` are Studio-managed read-only. `bootstrap.ts` is normally managed too; edit it only with a confident `managedFileEditReason` for world streaming/terrain provider, render/runtime backend, media consent/capture, external AI/TTS backend, scene/template baseline, pre-main baseline setup, or stale bootstrap API update to latest. Never edit bootstrap for asset loaders/manifests, instruments, scene registry, or execution manifest.",
   "7. Use safest VFS tool: read first, default to edit_wave_file for small one-file edits, let it auto-resolve baseHash, use apply_wave_patch({ operations }) with explicit baseHash for grouped/advanced work, and inspect skips/partials.",
   "8. For obby/platform tasks, controlled players use kinematic-controller authoring; moving platforms and hazards use rigid-body kinematic geometry/props plus transform/animate/current-code motion.",
@@ -44612,12 +44636,12 @@ var WAVE_MCP_FILE_CONTEXT_GUIDE = [
   "Wave Studio file-context rules:",
   "- Normal scene edit path: use the active `*/main.ts`, write against `myScene`, use bare asset refs, and do not edit Studio-managed generated files.",
   "- Studio-managed generated files are MCP read-only for agents: `project.assetrefs.ts`, `project.scene.ts`, `project.scenes.ts`, and `project.execution.ts`. `bootstrap.ts` / scene `*/bootstrap.ts` is normally Studio-managed too; edit it only when you can confidently pass `managedFileEditReason` as one of: `world_streaming_or_terrain_provider`, `render_profile_or_runtime_backend`, `media_consent_or_capture_plan`, `external_ai_or_tts_backend`, `scene_envelope_or_template_baseline`, `baseline_setup_before_user_main`, `stale_api_update_to_latest`. Never edit bootstrap for assets/loaders, instruments, scene registry, or execution manifest; Studio owns those.",
-  "- `main.ts` / scene `*/main.ts`: user scene authoring code. Prefer `myScene` for the active scene. Also available: `assetManager`, `waveEngine`, `waveStudio`, `models`, `gaussianSplats`, `fbxModels`, `animations`, `materials`, `guis`, `textures`, `audios`, `instruments`, `videos`, `hdr`, `cubeMaps`, `generatedModels`, `fonts`, `serializedData`, `terrains`, `fx`, `particles`.",
+  "- `main.ts` / scene `*/main.ts`: user scene authoring code. Prefer `myScene` for the active scene. Also available: `assetManager`, `waveEngine`, `waveStudio`, `models`, `gaussianSplats`, `fbxModels`, `animations`, `vertexAnimations`, `materials`, `guis`, `textures`, `audios`, `instruments`, `videos`, `hdr`, `cubeMaps`, `generatedModels`, `fonts`, `serializedData`, `terrains`, `fx`, `particles`.",
   `- Studio also injects many authoring constants/functions as bare globals. ${WAVE_AUTHORING_BARE_GLOBALS_RULE} Do not add imports or guessed namespaces. Treat listed globals as examples and use local-SDK \`query_wave_api\` for the complete generated authoring surface. HTTP Gateway hides/retires skill/API lookup.`,
   "- Project code does not need to live in one monolith. Use `create_wave_file`, `rename_wave_file`, and `delete_wave_file` for VFS `.ts` modules and folders, for example `/actors/player.ts` or `/systems/movingPlatforms.ts`. New `.ts/.tsx` files are runnable source roots by default, so top-level scene code in them runs on Run/hot reload; pass `runnable:false` only for pure helper modules that should not execute on their own.",
   '- Studio VFS also supports non-code `.html` sketch files. Use `create_wave_file({ path: "/docs/diagram.html", content })` for Mermaid diagrams, charts, and lightweight docs; put Mermaid source inside `<div class="mermaid">...</div>`, not markdown fences. When that `.html` file is active, the editor/coding pane renders it as an HTML sketch and auto-loads Mermaid if `class="mermaid"` is present. HTML sketches must never replace the live engine preview iframe.',
   "- `list_wave_files` and `read_wave_file` return a full-file `contentHash`. Primary simple edit tool `edit_wave_file` can omit `baseHash`; Studio resolves the latest mirror hash and still performs browser-side stale-write checks. It accepts `edits:[{startLine,endLine,text}]` or `edits:[{rangeOffset,rangeLength,text}]` for one-file multi-edits. Use explicit `baseHash` for advanced `apply_wave_patch({ operations: [...] })` compact operations (`lineEdits`, `textEdits`, strict `searchReplace`, or `unifiedDiff`) and existing-file `writeFile` unless `forceOverwrite: true`. This hash is a cooperative stale-write check, not a security boundary. Prefer forgiving `edit_wave_file` over full-file `writeFile` when only a small span changes. Stale hashes and ambiguous replacements are skipped instead of guessed. `textEdits` offsets are zero-based UTF-16 offsets in the full file, even if you used a scoped line read; line edits use 1-based full-file line numbers. Scoped reads and line edits clamp oversized endLine to lineCount but still reject startLine beyond the file. If you need multiple compact changes in one file, use `edit_wave_file({ path, edits:[...] })` or combine them into one advanced patch operation; re-read between separate operations.",
-  "- Main-file asset refs should be bare: `models.Car`, `gaussianSplats.Room`, `textures.Grass`, `materials.Metal`, `animations.Idle`. Omit `ASSET_WAREHOUSE.` for authored code.",
+  "- Main-file asset refs should be bare: `models.Car`, `gaussianSplats.Room`, `textures.Grass`, `materials.Metal`, `animations.Idle`, `vertexAnimations.HorseGallopVat`. Omit `ASSET_WAREHOUSE.` for authored code.",
   "- Asset facade split: existing asset inputs use typed refs; material authoring starts from `waveMaterial`; `assetManager` is for explicit generated-asset/asset-pipeline APIs named by a local SDK skill or API lookup, not the default place to invent new material or asset code.",
   "- Use `find_wave_assets_by_category({ category, query?, limit? })` to inspect the current live asset surface. Fill category from user intent first. It includes public assets, uploaded user assets, and project aliases, with `source` telling where each ref came from.",
   "- Wave Studio auto-maintains bootstrap/project asset/scene wiring for normal `main.ts` edits. Do not write or modify bootstrap or generated project registry files just to make an asset ref or scene entry available; use the returned bare refs in main code and let Studio sync boot/assets/scenes. Hot reload is the default preview path after code edits and can automatically upgrade its internal tier when new assets or bootstrap-surface changes require it.",
@@ -44672,13 +44696,13 @@ var WAVE_MCP_STUDIO_TOOL_GUIDE = [
   '- Local parity rule: WaveEngine Agent SDK `tools/list` mirrors the HTTP Gateway Studio-operation catalog, then adds local SDK lookup/session-discovery extras. Direct local live-session tools include VFS edits, assets/uploads, project save/open/new/read/share, preview run/hot reload/pause/resume, diagnostics, performance, screenshots, entity snapshots, and runtime markers. Local browser-backed calls wait directly for browser results. Only call `get_wave_command_result` if a tool returns `status:"pending"` plus `requestId`; on local it normally exists only for catalog parity and reports no local pending-command queue.',
   `- MCP topology: same-machine agents should run \`${WAVE3D_AGENT_SDK_START_COMMAND}\`, check /health, and update/restart SDK if version is stale, tools are missing, or SDK prints secrets; after restart recheck /health and tools/list. If restart happens after Copy-to-Agent, preserve MCP_TOKEN with \`${WAVE3D_AGENT_SDK_TOKEN_PRESERVING_START_COMMAND}\` using the current MCP_TOKEN value without printing it, otherwise the SDK may be healthy but unable to authorize the copied local pairing secret. Current SDK start reuses a current same-token peer, replaces verified stale/different-token SDK peers on localhost, and refuses to kill non-SDK port owners. Same-machine stale/missing tools/401-with-Gateway-success means repair local SDK first, not HTTP Gateway first. Same-machine HTTP Gateway is degraded fallback only after SDK cannot run, update, or adopt. Different-machine/cloud/sandbox agents should use \`MCP_HTTP_GATEWAY_FALLBACK_URL\` directly; starting WaveEngine Agent SDK there binds localhost beside the agent, not beside the user browser. Stale SDK/cache are not reasons to use HTTP Gateway fallback; wrong-machine localhost is a topology mismatch.`,
   `- MCP cache priorities: Priority 1 is active role/context cache: keep role, guardrails, authoring workflow, asset/VFS/hot-reload rules, prompt version, and prompt hash in active LLM context. Priority 2 is WaveEngine SDK Cache: production HTTP Gateway/local-SDK onboarding must not claim normal cached success until SDK cache is prepared or accept proof passes. If accept returns \`wave_engine_sdk_cache_not_ready\`, update/restart \`wave3d-agent-sdk\` or run \`${WAVE_MCP_CORPUS_CACHE_COMMAND_TEMPLATE}\`, then retry accept. If local cache cannot work because sandbox/no filesystem/no Node/npm/user refusal/refresh failure, explicitly accept degraded fallback with \`waveEngineSdkFallbackMode:"studio_ops_only"\`, a valid \`waveEngineSdkUnavailableReason\`, and \`studioOpsOnlyFallbackAccepted:true\`; warn user HTTP Gateway is Studio-ops-only and skill/API lookup requires local SDK/cache repair. This cache command reinstalls the package-bundled SDK locally; it is not WaveEngine Agent SDK transport. Never run it to switch MCP transport; never treat cache failure as local transport failure.`,
-  "- Main-file globals include `myScene`, `assetManager`, `waveEngine`, `waveStudio`, and direct asset maps such as `models`, `gaussianSplats`, `textures`, `materials`, `animations`, `audios`, `hdr`, `cubeMaps`, `fonts`, `serializedData`, `terrains`, `fx`, `particles`. Availability is not endorsement: choose the intent-owned facade/skill before using a global.",
+  "- Main-file globals include `myScene`, `assetManager`, `waveEngine`, `waveStudio`, and direct asset maps such as `models`, `gaussianSplats`, `textures`, `materials`, `animations`, `vertexAnimations`, `audios`, `hdr`, `cubeMaps`, `fonts`, `serializedData`, `terrains`, `fx`, `particles`. Availability is not endorsement: choose the intent-owned facade/skill before using a global.",
   `- Bare authoring globals: common examples include ${WAVE_AUTHORING_COMMON_GLOBAL_EXAMPLES_TEXT}, \`waveMaterial\`, \`waveFx\`, \`waveValueCurve\`, and \`waveParam\`. Use them directly in \`main.ts\`; do not import or namespace-qualify them. If the task is unfamiliar, retrieve the relevant local-SDK \`wave.*\` skill first; for the full generated exact-global surface, call local-SDK \`query_wave_api\`.`,
   "- MCP VFS edit tools: primary tool is forgiving `edit_wave_file({ path, ... })`; it infers replaceLines from startLine/endLine, multi-edit from edits:[...], replaceText from oldText, and whole-file replace from text/content. It handles line-based edits, exact string changes, one-file edit arrays, whole-file replacement, omitted baseHash, common aliases, and oversized endLine clamping. Use `apply_wave_patch({ operations: [...] })` only for grouped/multi-file edits and advanced operations; a single operation is tolerated but operations:[...] is preferred. Simple edit tools can omit baseHash; advanced patch operations should pass it.",
   `- MCP hot-reload safety rule: ${WAVE_AUTHORING_CORE_RULES.hotReloadCallbackSafety} edit_wave_file, create_wave_file, and apply_wave_patch preflight this rule before writing.`,
   "- MCP generated-file rule: `project.assetrefs.ts`, `project.scene.ts`, `project.scenes.ts`, and `project.execution.ts` are Studio-managed read-only. `bootstrap.ts` / scene `*/bootstrap.ts` is normally managed too; edit it only when you can confidently pass `managedFileEditReason` as `world_streaming_or_terrain_provider` (Google Maps 3D tiles included), `render_profile_or_runtime_backend`, `media_consent_or_capture_plan`, `external_ai_or_tts_backend`, `scene_envelope_or_template_baseline`, `baseline_setup_before_user_main`, or `stale_api_update_to_latest`. Never edit bootstrap for asset manifests/loaders, instruments, scene registry, or execution manifest; Studio owns those.",
   '- MCP VFS file tools: `create_wave_file({ path, content, requestHotReload? })`, `rename_wave_file({ fromPath, toPath, requestHotReload? })`, and `delete_wave_file({ path, requestHotReload? })` are direct Operate tools for exact live VFS paths, including project `.ts` modules and `.html` sketch files. New `.ts/.tsx` files are standalone runnable source roots by default, so top-level scene code runs on Run/hot reload; pass `runnable:false` only for pure helper modules that should not execute on their own. For Mermaid/diagram/chart requests, create a `.html` file containing a block like `<div class="mermaid">flowchart TD\\n  A --> B</div>`; active `.html` files render in the editor/coding pane as HTML sketches and auto-load Mermaid when `class="mermaid"` is present. HTML sketches must never replace the live engine preview iframe. On the final code edit, `awaitHotReload:true` implies hot reload and returns bounded runtime diagnostics in the same response. These tools manage VFS files, not uploaded asset-library blobs. If the user gives a vague target, call `list_wave_files`/`read_wave_file` or ask before mutating. Scene-root modules and owned helpers run in the Studio authoring context; keep shared helpers pure or parameterized, and keep live object ownership in feature files. Rename/move rewrites relative imports; delete is permanent unless you rewrite the file and refuses files still imported by other VFS code.',
-  "- MCP asset resolution rule: if code needs an existing asset argument, reuse an exact visible typed ref or call category-first asset discovery before editing: `find_wave_assets_by_category({ category, query?, sources?, limit? })`, alias `list_wave_assets_by_category`, alias `search_wave_assets_by_category`, or tolerant `list_wave_assets`. Fill `category` from user intent first: sound/audio -> `audios`, 3D object/character/prop -> `models`, material -> `materials`, image/texture -> `textures`, sky/HDR -> `hdr`, cube-map sky/environment -> `cubeMaps`, animation -> `animations`, JSON/CSV/YAML/XML/ROS data -> `serializedData`. It returns refs safe to use in authored code, ordered projectAlias -> user -> public. In `main.ts`, pass typed bare refs such as `models.X`, `textures.X`, `materials.X`, `audios.X`, `hdr.X`, `cubeMaps.X`, `animations.X`, `videos.X`, `fonts.X`, `serializedData.X`, or `terrains.X`; do not paste raw paths.",
+  "- MCP asset resolution rule: if code needs an existing asset argument, reuse an exact visible typed ref or call category-first asset discovery before editing: `find_wave_assets_by_category({ category, query?, sources?, limit? })`, alias `list_wave_assets_by_category`, alias `search_wave_assets_by_category`, or tolerant `list_wave_assets`. Fill `category` from user intent first: sound/audio -> `audios`, 3D object/character/prop -> `models`, material -> `materials`, image/texture -> `textures`, sky/HDR -> `hdr`, cube-map sky/environment -> `cubeMaps`, skeletal animation -> `animations`, baked vertex/VAT animation -> `vertexAnimations`, JSON/CSV/YAML/XML/ROS data -> `serializedData`. It returns refs safe to use in authored code, ordered projectAlias -> user -> public. In `main.ts`, pass typed bare refs such as `models.X`, `textures.X`, `materials.X`, `audios.X`, `hdr.X`, `cubeMaps.X`, `animations.X`, `vertexAnimations.X`, `videos.X`, `fonts.X`, `serializedData.X`, or `terrains.X`; do not paste raw paths.",
   "- MCP asset-authoring facade rule: quoting or passing existing assets uses typed refs such as `models.X`, `textures.X`, `materials.X`, and `audios.X`; creating/configuring/forking/editing material handles starts from `waveMaterial` and `wave.material.authoring`; path-bound surfaces start from `wavePathSurface`; `assetManager` is reserved for exact low-level asset-pipeline/generated-asset APIs named by a local SDK skill or API lookup.",
   "- MCP material authoring rule: quoting an existing material uses `materials.X`; authoring a material handle uses `waveMaterial`. Do not call internal procedural material lifecycle methods such as `_sync(...)`, `_bindAutoSync(...)`, or `_release(...)` in authored code; apply procedural handles through `entity.useMaterial(...)`, geometry, terrain paint, or shader `.useTexture(...)`. `WaveMaterialAssetEditHandle.sync(assetManager)` remains the explicit commit step for intentional loaded-material asset edits.",
   `- MCP explorer asset tools: \`list_wave_explorer_assets({ query?, assetTypes?, limit? })\`, \`create_wave_asset_upload({ assetKind, filename, contentType?, sizeBytes })\`, \`commit_wave_asset_upload({ assetKind, uploadId, filename, contentType?, sizeBytes, useMeshoptimizer?, useKtx2Compression? })\`, \`get_wave_asset_upload_status({ uploadId, totalChunks? })\`, \`upload_wave_asset({ assetKind, filename, dataBase64? | dataUrl?, contentType?, useMeshoptimizer?, useKtx2Compression? })\`, \`stage_wave_asset_upload_chunk({ uploadId?, chunkIndex, totalChunks, dataBase64 })\`, \`commit_wave_asset_chunk_upload({ assetKind, uploadId, filename, contentType?, totalChunks, totalSizeBytes, useMeshoptimizer?, useKtx2Compression? })\`, \`abort_wave_asset_upload({ uploadId })\`, \`rename_wave_asset({ path, name })\`, and \`delete_wave_asset({ path })\` operate on uploaded user assets shown by the asset explorer. \`assetKind\` values come from the Wave Studio upload policy SSOT: ${getWaveStudioBridgeAssetUploadKindHelpText()}. Status and abort require the same write token, but can still run after the active Studio write grant expires. Read \`resultSummary\` first: asset tools report ASSET ... OK, ASSET ... FAILED, or ASSET ... PENDING in the same response.`,
@@ -44756,8 +44780,8 @@ var WAVE_MCP_TOOL_CATALOG_GUIDE = [
   "- Marker waypoint recipe: direct marker position/rotation questions are Observe and call `list_wave_runtime_markers` directly. When the user asks to use clicked/marked points in code, start a route with `marker.use` plus `code.author` or the fitting fast-lane code kind, then call `list_wave_runtime_markers`. Read the target file, use marker `worldPosition`/`worldRotation` as waypoint/path/placement inputs, and verify with screenshot or marker re-read. Retrieve a path/placement skill only when current code does not reveal the pattern.",
   "",
   "studio.assets - refs, uploads, and asset library:",
-  "- Asset resolution rule: before writing an asset-map input, reuse an exact ref already visible in code or call category-first asset discovery (`find_wave_assets_by_category`, alias `list_wave_assets_by_category`) with required `category`, semantic `query`, and small `limit`; do not invent `models.<asset>`, `textures.<asset>`, `materials.<asset>`, `audios.<asset>`, `hdr.<asset>`, `cubeMaps.<asset>`, or `animations.<asset>` keys from memory. Do not infer absence from a capped category list.",
-  "- Existing asset arguments should be typed bare refs in main files, such as `models.Robot`, `textures.Grass`, `materials.Wood`, `audios.Click`, `hdr.StudioSky`, `cubeMaps.studio`, `animations.Run`, `videos.Intro`, `fonts.Title`, `serializedData.UnitreePose`, or `terrains.Alpine`.",
+  "- Asset resolution rule: before writing an asset-map input, reuse an exact ref already visible in code or call category-first asset discovery (`find_wave_assets_by_category`, alias `list_wave_assets_by_category`) with required `category`, semantic `query`, and small `limit`; do not invent `models.<asset>`, `textures.<asset>`, `materials.<asset>`, `audios.<asset>`, `hdr.<asset>`, `cubeMaps.<asset>`, `animations.<asset>`, or `vertexAnimations.<asset>` keys from memory. Do not infer absence from a capped category list.",
+  "- Existing asset arguments should be typed bare refs in main files, such as `models.Robot`, `textures.Grass`, `materials.Wood`, `audios.Click`, `hdr.StudioSky`, `cubeMaps.studio`, `animations.Run`, `vertexAnimations.HorseGallopVat`, `videos.Intro`, `fonts.Title`, `serializedData.UnitreePose`, or `terrains.Alpine`.",
   "- Asset authoring facade split: quote existing assets as typed refs (`models.X`, `textures.X`, `materials.X`, `audios.X`, etc.); author material handles through `waveMaterial` and `wave.material.authoring`; use `assetManager` only for exact generated-asset/asset-pipeline APIs named by a local SDK Wave skill or API lookup.",
   '- `find_wave_assets_by_category`: category-first refs safe to write in code, such as `models.Robot`, `textures.Grass`, `materials.Wood`, `audios.Click`. Aliases: `list_wave_assets_by_category`, `search_wave_assets_by_category`, tolerant `list_wave_assets`. Examples: `{ category:"models", query:"sparrow", limit:50 }`, `{ category:"audios", query:"footstep", limit:50 }`, `{ category:"materials", query:"grass", limit:50 }`.',
   "- `list_wave_explorer_assets`: uploaded asset library metadata for management: path, URL, display/ref name, type, size. May be empty; not a fallback for built-in/public refs.",
@@ -44794,8 +44818,8 @@ function optionalStringArray(value) {
   const strings = rawItems.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
   return strings.length > 0 ? strings : void 0;
 }
-function normalizeWaveFilePath(path5) {
-  const trimmed = path5.trim();
+function normalizeWaveFilePath(path6) {
+  const trimmed = path6.trim();
   if (!trimmed) return trimmed;
   return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
 }
@@ -44931,9 +44955,9 @@ function readPathArray(value) {
   return value.map((item) => {
     if (typeof item === "string") return item;
     const record = readRecord(item);
-    const path5 = record?.path;
-    return typeof path5 === "string" ? path5 : null;
-  }).filter((path5) => typeof path5 === "string" && path5.length > 0);
+    const path6 = record?.path;
+    return typeof path6 === "string" ? path6 : null;
+  }).filter((path6) => typeof path6 === "string" && path6.length > 0);
 }
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -45910,6 +45934,401 @@ async function runLocalSdkLookupTool(input) {
   );
 }
 
+// ../../scripts/wavegenie-sdk/modeling/modelingJob.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path2 from "node:path";
+function sanitizeAssetName(rawName) {
+  const sanitized = rawName.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "");
+  return sanitized || "generated_model";
+}
+function jsonValueOrNull(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value === "number" && Number.isNaN(value) ? null : value;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => jsonValueOrNull(item));
+    return items.every((item) => item !== null) ? items : null;
+  }
+  if (isRecord2(value)) {
+    const entries = Object.entries(value);
+    const result = {};
+    for (const [key, item] of entries) {
+      const normalized = jsonValueOrNull(item);
+      if (normalized === null) return null;
+      result[key] = normalized;
+    }
+    return result;
+  }
+  return null;
+}
+function normalizeKnownDimensionsMm(value) {
+  if (!isRecord2(value)) return null;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!key.trim()) continue;
+    const normalized = jsonValueOrNull(item);
+    if (normalized === null) return null;
+    result[key.trim()] = normalized;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function duplicateStrings(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (seen.has(item)) {
+      duplicates.add(item);
+    } else {
+      seen.add(item);
+    }
+  }
+  return [...duplicates];
+}
+function parseModelingJobArgs(args) {
+  const sourcePrompt = normalizeOptionalString(args?.sourcePrompt) ?? normalizeOptionalString(args?.prompt) ?? normalizeOptionalString(args?.description);
+  if (!sourcePrompt) {
+    return errorToolResult(
+      "invalid_arguments",
+      "`create_wave_3d_modeling_job` needs sourcePrompt, prompt, or description."
+    );
+  }
+  const rawAssetName = normalizeOptionalString(args?.assetName) ?? normalizeOptionalString(args?.name) ?? sourcePrompt.split(/\s+/u).slice(0, 5).join("_");
+  const knownDimensionsMm = typeof args?.knownDimensionsMm === "undefined" ? null : normalizeKnownDimensionsMm(args.knownDimensionsMm);
+  if (typeof args?.knownDimensionsMm !== "undefined" && !knownDimensionsMm) {
+    return errorToolResult(
+      "invalid_arguments",
+      "`knownDimensionsMm` must be a JSON object with only JSON-safe values."
+    );
+  }
+  const requiredParts = optionalStringArray(args?.requiredParts) ?? [];
+  const duplicateRequiredParts = duplicateStrings(requiredParts);
+  if (duplicateRequiredParts.length > 0) {
+    return errorToolResult(
+      "invalid_arguments",
+      `\`requiredParts\` names must be unique because Wave getPart(name) requires unambiguous public part names. Duplicates: ${duplicateRequiredParts.join(", ")}.`
+    );
+  }
+  return {
+    assetName: sanitizeAssetName(rawAssetName),
+    sourcePrompt,
+    screenshotPaths: optionalStringArray(args?.screenshotPaths) ?? [],
+    referenceImagePaths: optionalStringArray(args?.referenceImagePaths) ?? [],
+    targetStyle: normalizeOptionalString(args?.targetStyle) ?? null,
+    intendedUse: normalizeOptionalString(args?.intendedUse) ?? null,
+    requiredParts,
+    knownDimensionsMm
+  };
+}
+function markdownList(items, emptyText) {
+  if (items.length === 0) return `- ${emptyText}`;
+  return items.map((item) => `- ${item}`).join("\n");
+}
+var WAVE_OBJECT_MODEL_PARTS_CONTRACT = `## WaveEngine objectModel SSOT contract
+
+When requiredParts is non-empty, or the user asks for named/selectable/collidable/material-addressable parts, the GLB must carry Wave objectModel metadata. Mesh names, ordered mesh arrays, and legacy partIds metadata are not source of truth.
+
+Required GLB shape for part-aware output:
+
+- Add an empty/transform node named \`__wave_model_object_model\`; it must have no children.
+- Put \`waveModelObjectModel\` in that node's metadata/extras.
+- The value must be a valid WaveModelObjectModel JSON object:
+  - \`version: 1\`
+  - \`modelId\`: stable asset id/name
+  - \`revision\`: stable revision string for this generated artifact
+  - \`meshes\`: one record per render mesh with stable \`id\`, \`displayName\`, and \`order\`
+  - \`parts\`: one record per user-facing part with stable \`id\`, public \`name\`, \`order\`, optional \`parentPartId\`, optional \`rotationPivot\`, optional \`visualFrame\`
+  - \`meshPartBindings\`: explicit bindings from mesh id to part id with role \`visual\` or \`collision\`
+  - \`parentPartId\` on child part records when parts have authored parent/child relationships
+  - \`topology\`: include \`rootPartIds\` and \`joints: []\` only when a rig/joint topology is needed
+  - \`materialSlots\` and \`materialBindings\`: canonical material targets when materials are meant to be changed by mesh or part
+- Mirror only projection hints on each part-owned mesh metadata:
+  - \`waveModelPartId\`: canonical part id
+  - \`waveModelPartName\`: public part name users pass to \`getPart()\`
+  - \`waveModelPartMetadata\`: serializable part metadata when needed
+  - \`waveModelPartParentId\`: only when part has parent part
+
+Rules:
+
+- If user did not ask for parts, do not invent parts for every mesh. Output mesh-only GLB.
+- If a visual part contains multiple meshes, bind all meshes to the same part id.
+- Preserve authored pivots/origins as objectModel \`rotationPivot\` and \`visualFrame\`, not by baking them away.
+- Do not write \`metadata.partIds\`, \`extras.partIds\`, mesh-name-derived part ids, or positional part arrays as source of truth.
+- Validate before upload: every required part name appears in \`objectModel.parts[].name\`, and every part-owned mesh has a matching \`meshPartBindings[]\` record.
+`;
+function buildModelingSupportFiles(input) {
+  const requestedPartsText = input.requiredParts.length > 0 ? input.requiredParts.join(", ") : "none explicitly requested; keep output mesh-only unless the source request itself asks for named/selectable/collidable/material-addressable parts";
+  const visiblePartsInstruction = input.requiredParts.length > 0 ? "- Named visible parts matching requiredParts exactly." : "- Mesh/object breakdown only; do not invent Wave parts unless the source request itself asks for named/selectable/collidable/material-addressable parts.";
+  const briefJson = JSON.stringify({
+    assetName: input.assetName,
+    sourcePrompt: input.sourcePrompt,
+    screenshotPaths: input.screenshotPaths,
+    referenceImagePaths: input.referenceImagePaths,
+    targetStyle: input.targetStyle,
+    intendedUse: input.intendedUse,
+    requiredParts: input.requiredParts,
+    knownDimensionsMm: input.knownDimensionsMm,
+    outputContract: {
+      preferredModelFile: `${input.assetName}.glb`,
+      optionalCadFile: `${input.assetName}.step`,
+      waveStudioImport: "Use create_wave_asset_upload/upload_wave_asset after GLB exists, then author code with models.<assetName>.",
+      objectModelSSOT: input.requiredParts.length > 0 ? {
+        required: true,
+        envelopeNodeName: "__wave_model_object_model",
+        envelopeMetadataKey: "waveModelObjectModel",
+        perMeshProjectionKeys: [
+          "waveModelPartId",
+          "waveModelPartName",
+          "waveModelPartMetadata",
+          "waveModelPartParentId"
+        ],
+        forbiddenLegacyTruth: [
+          "metadata.partIds",
+          "extras.partIds",
+          "mesh-name-derived part ids",
+          "ordered mesh arrays as part truth"
+        ]
+      } : {
+        required: false,
+        conditionalRequirement: "Embed objectModel SSOT only if the source request itself asks for named/selectable/collidable/material-addressable parts.",
+        rule: "Do not invent objectModel parts for raw multi-mesh GLB unless user explicitly requests parts."
+      }
+    }
+  }, null, 2);
+  const parameterTemplate = JSON.stringify({
+    assetName: input.assetName,
+    units: "millimeter",
+    parameters: {
+      overall_width: input.knownDimensionsMm?.overall_width ?? 1e3,
+      overall_depth: input.knownDimensionsMm?.overall_depth ?? 600,
+      overall_height: input.knownDimensionsMm?.overall_height ?? 500,
+      bevel_radius: 12
+    },
+    parts: input.requiredParts.length > 0 ? input.requiredParts.map((partName) => ({ name: partName, materialHint: "default" })) : []
+  }, null, 2);
+  return [
+    {
+      fileName: "README.md",
+      role: "workflow",
+      content: `# WaveEngine 3D Modeling Job: ${input.assetName}
+
+This folder is a local SDK modeling scaffold. It does not mean a GLB has been generated yet.
+
+## Source request
+
+${input.sourcePrompt}
+
+## Screenshot inputs
+
+${markdownList(input.screenshotPaths, "No screenshot paths provided. Use capture_wave_screenshot first when visual matching matters.")}
+
+## Reference image inputs
+
+${markdownList(input.referenceImagePaths, "No reference image paths provided.")}
+
+## Workflow
+
+1. Use \`cad-sheet-prompt.md\` to derive a CAD sheet or parameter spec from screenshots/reference images.
+2. Fill \`parameters.template.json\`.
+3. Run \`python build_step.py parameters.template.json out\` after installing CadQuery/OCP locally.
+4. Convert the STEP/mesh result to GLB with your approved modeling pipeline.
+5. If parts are requested, embed and validate the Wave objectModel SSOT contract before upload.
+6. Upload the GLB through Wave Studio MCP asset upload tools.
+7. Author scene code with \`models.${input.assetName}\`.
+
+## Safety
+
+Keep API keys and private screenshots out of commits. Generated assets must be reviewed before upload.
+`
+    },
+    {
+      fileName: "asset-brief.json",
+      role: "brief",
+      content: `${briefJson}
+`
+    },
+    {
+      fileName: "cad-sheet-prompt.md",
+      role: "prompt",
+      content: `Create a CAD-ready model specification for this WaveEngine asset.
+
+Asset name: ${input.assetName}
+Request: ${input.sourcePrompt}
+Target style: ${input.targetStyle ?? "match source/reference"}
+Intended use: ${input.intendedUse ?? "WaveEngine scene asset"}
+Required parts: ${requestedPartsText}
+
+${WAVE_OBJECT_MODEL_PARTS_CONTRACT}
+
+Use the screenshots/reference images as visual evidence. Return:
+
+- Orthographic front/side/top proportions.
+${visiblePartsInstruction}
+- Dimensions in millimeters.
+- Bevels, thickness, symmetry, repeating details.
+- Material/color hints. Do not invent engine internals beyond the Wave objectModel SSOT contract.
+- A JSON parameter block compatible with parameters.template.json.
+`
+    },
+    {
+      fileName: "parameter-spec.schema.json",
+      role: "schema",
+      content: `${JSON.stringify({
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        title: "WaveEngine 3D Modeling Parameters",
+        type: "object",
+        required: ["assetName", "units", "parameters", "parts"],
+        additionalProperties: false,
+        properties: {
+          assetName: { type: "string", minLength: 1 },
+          units: { type: "string", enum: ["millimeter"] },
+          parameters: {
+            type: "object",
+            additionalProperties: { type: ["number", "string", "boolean"] }
+          },
+          parts: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["name"],
+              additionalProperties: false,
+              properties: {
+                name: { type: "string", minLength: 1 },
+                materialHint: { type: "string" }
+              }
+            }
+          }
+        }
+      }, null, 2)}
+`
+    },
+    {
+      fileName: "parameters.template.json",
+      role: "parameters",
+      content: `${parameterTemplate}
+`
+    },
+    {
+      fileName: "build_step.py",
+      role: "python-cad-scaffold",
+      content: `#!/usr/bin/env python3
+"""WaveEngine local CAD scaffold.
+
+This is a starting point, not a magic model generator. Replace build_model()
+with the CAD recipe derived from cad-sheet-prompt.md.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import sys
+
+try:
+    import cadquery as cq
+except ImportError as exc:
+    raise SystemExit(
+        "CadQuery is required. Install it in your local modeling environment before running this scaffold."
+    ) from exc
+
+
+def read_params(path: pathlib.Path) -> dict:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def number_param(params: dict, name: str, fallback: float) -> float:
+    value = params.get("parameters", {}).get(name, fallback)
+    if isinstance(value, (int, float)):
+        return float(value)
+    return fallback
+
+
+def build_model(params: dict) -> cq.Workplane:
+    width = number_param(params, "overall_width", 1000)
+    depth = number_param(params, "overall_depth", 600)
+    height = number_param(params, "overall_height", 500)
+    bevel_radius = number_param(params, "bevel_radius", 12)
+    model = cq.Workplane("XY").box(width, depth, height)
+    if bevel_radius > 0:
+        model = model.edges().fillet(bevel_radius)
+    return model
+
+
+def main() -> None:
+    if len(sys.argv) != 3:
+        raise SystemExit("usage: python build_step.py parameters.template.json out")
+    params_path = pathlib.Path(sys.argv[1])
+    out_dir = pathlib.Path(sys.argv[2])
+    out_dir.mkdir(parents=True, exist_ok=True)
+    params = read_params(params_path)
+    asset_name = str(params.get("assetName") or "${input.assetName}")
+    step_path = out_dir / f"{asset_name}.step"
+    cq.exporters.export(build_model(params), str(step_path))
+    print(f"Wrote {step_path}")
+
+
+if __name__ == "__main__":
+    main()
+`
+    },
+    {
+      fileName: "validation-checklist.md",
+      role: "validation",
+      content: `# Validation checklist
+
+- Silhouette matches source screenshots from front/side/top.
+- Scale is correct for WaveEngine world use.
+- If parts were requested, GLB contains \`waveModelObjectModel\` on the \`__wave_model_object_model\` node metadata/extras.
+- If parts were requested, every required part is present in \`objectModel.parts[].name\`.
+- If parts were requested, every part mesh has explicit \`meshPartBindings[]\`; no \`metadata.partIds\` or mesh-name fallback is used.
+- If no parts were requested, raw multi-mesh GLB remains mesh-only and does not eagerly invent parts.
+- Part pivots/origins, if authored, survive as \`rotationPivot\` and \`visualFrame\`.
+- Material slots are clean and simple.
+- GLB loads in Wave Studio before code authoring.
+- Uploaded asset appears as \`models.${input.assetName}\`.
+`
+    }
+  ];
+}
+async function createWave3dModelingJobTool(args) {
+  const parsed = parseModelingJobArgs(args);
+  if ("content" in parsed) return parsed;
+  const jobId = `wave_model_${parsed.assetName}_${randomUUID().slice(0, 8)}`;
+  const jobDir = path2.join(tmpdir(), "wave3d-agent-sdk", "modeling-jobs", jobId);
+  const supportFiles = buildModelingSupportFiles(parsed);
+  await mkdir(jobDir, { recursive: true });
+  await Promise.all(supportFiles.map((file) => writeFile(path2.join(jobDir, file.fileName), file.content, "utf8")));
+  return successToolResult({
+    ok: true,
+    tool: "create_wave_3d_modeling_job",
+    status: "scaffolded",
+    localSdk: true,
+    generatedAssetReady: false,
+    jobId,
+    jobDir,
+    assetName: parsed.assetName,
+    supportFiles: supportFiles.map((file) => ({
+      fileName: file.fileName,
+      role: file.role,
+      path: path2.join(jobDir, file.fileName)
+    })),
+    nextActions: [
+      "Use cad-sheet-prompt.md plus screenshots/reference images to produce a CAD parameter spec.",
+      "Fill parameters.template.json and run the Python scaffold only in a local modeling environment with CadQuery installed.",
+      "Convert generated model output to GLB.",
+      "If parts are requested, embed and validate the Wave objectModel SSOT contract before upload.",
+      "Upload with create_wave_asset_upload/upload_wave_asset.",
+      `After upload, author WaveEngine scene code with models.${parsed.assetName}.`
+    ],
+    caveats: [
+      "This tool creates a modeling job scaffold only; it does not call a cloud model generator.",
+      "Do not commit private screenshots, prompts, or generated assets without review."
+    ]
+  });
+}
+
 // ../../src/lib/waveStudio/aiAssist/bridge/assetListGuidance.ts
 function buildWaveAssetListGuidance(input) {
   const hasQuery = typeof input.query === "string" && input.query.trim().length > 0;
@@ -45918,7 +46337,7 @@ function buildWaveAssetListGuidance(input) {
   const hasFilters = hasQuery || hasBuckets || hasSources;
   const hasMore = input.summary.total > input.summary.returned;
   const guidance = [
-    "Use category-first asset discovery for code-safe refs such as models.X, textures.X, materials.X, audios.X, hdr.X, cubeMaps.X, and animations.X. Callable names: `find_wave_assets_by_category`, `list_wave_assets_by_category`, `search_wave_assets_by_category`, or tolerant `list_wave_assets`.",
+    "Use category-first asset discovery for code-safe refs such as models.X, textures.X, materials.X, audios.X, hdr.X, cubeMaps.X, animations.X, and vertexAnimations.X. Callable names: `find_wave_assets_by_category`, `list_wave_assets_by_category`, `search_wave_assets_by_category`, or tolerant `list_wave_assets`.",
     "Choose category from user intent first, then search semantically with `query`; do not browse a broad slice and infer absence."
   ];
   if (hasMore && !hasQuery) {
@@ -45955,7 +46374,7 @@ function buildWaveExplorerAssetListGuidance(input) {
   const hasMore = input.summary.total > input.summary.returned;
   const guidance = [
     "`list_wave_explorer_assets` is for uploaded user-asset management metadata: path, URL, size, display/ref name, rename, and delete.",
-    "It is not the fallback for built-in/public code refs. Use category-first asset discovery (`find_wave_assets_by_category` or alias `list_wave_assets_by_category`) when code needs models.X, textures.X, materials.X, audios.X, hdr.X, cubeMaps.X, or animations.X."
+    "It is not the fallback for built-in/public code refs. Use category-first asset discovery (`find_wave_assets_by_category` or alias `list_wave_assets_by_category`) when code needs models.X, textures.X, materials.X, audios.X, hdr.X, cubeMaps.X, animations.X, or vertexAnimations.X."
   ];
   if (input.summary.total === 0 && !hasQuery && !hasAssetTypes) {
     guidance.push("Empty explorer does not mean no code assets exist; it only means this uploaded-user library view has no returned items.");
@@ -46401,7 +46820,7 @@ function reportHotReloadUnsafeUsage(params) {
     })
   });
 }
-function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOAD_UNSAFE_ERROR_LIMIT) {
+function collectRuntimeHotReloadSafetyDiagnostics(path6, code, limit = HOT_RELOAD_UNSAFE_ERROR_LIMIT) {
   const diagnostics = [];
   if (limit <= 0) return diagnostics;
   const reported = /* @__PURE__ */ new Set();
@@ -46446,34 +46865,34 @@ function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOA
     const receiverPath = previousChar === "." ? readPropertyReceiverPath(code, tokenStart) : "";
     const globalGuidance = HOT_RELOAD_UNSAFE_GLOBAL_CALLBACKS.get(token);
     if (globalGuidance) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: globalGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: globalGuidance, diagnostics, reported });
       continue;
     }
     const listenerGuidance = HOT_RELOAD_UNSAFE_LISTENER_CALLBACKS.get(token);
     if (listenerGuidance && isCall) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: listenerGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: listenerGuidance, diagnostics, reported });
       continue;
     }
     const promiseGuidance = HOT_RELOAD_UNSAFE_PROMISE_CALLBACKS.get(token);
     if (promiseGuidance && previousChar === "." && isCall) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: promiseGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: promiseGuidance, diagnostics, reported });
       continue;
     }
     const eventBusGuidance = HOT_RELOAD_UNSAFE_EVENTBUS_CALLBACKS.get(token);
     if (eventBusGuidance && previousChar === "." && isCall && isWaveEventBusReceiverPath(receiverPath)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: eventBusGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: eventBusGuidance, diagnostics, reported });
       continue;
     }
     const sceneEventGuidance = HOT_RELOAD_UNSAFE_SCENE_EVENT_CALLBACKS.get(token);
     if (sceneEventGuidance && previousChar === "." && isCall && isWaveSceneEventReceiverPath(receiverPath)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: sceneEventGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: sceneEventGuidance, diagnostics, reported });
       continue;
     }
     const forbiddenStudioSceneMethodGuidance = HOT_RELOAD_FORBIDDEN_STUDIO_SCENE_METHODS.get(token);
     if (forbiddenStudioSceneMethodGuidance && previousChar === "." && isCall && isWaveSceneEventReceiverPath(receiverPath)) {
       reportHotReloadUnsafeUsage({
         code,
-        path: path5,
+        path: path6,
         token,
         offset: tokenStart,
         severity: "error",
@@ -46485,12 +46904,12 @@ function collectRuntimeHotReloadSafetyDiagnostics(path5, code, limit = HOT_RELOA
     }
     const constructorGuidance = HOT_RELOAD_UNSAFE_CONSTRUCTORS.get(token);
     if (constructorGuidance && (previousIdentifier === "new" || previousChar === "." && isCall)) {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: constructorGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: constructorGuidance, diagnostics, reported });
       continue;
     }
     const eventHandlerGuidance = HOT_RELOAD_UNSAFE_EVENT_HANDLER_ASSIGNMENTS.get(token);
     if (eventHandlerGuidance && previousChar === "." && nextNonWhitespace === "=") {
-      reportHotReloadUnsafeUsage({ code, path: path5, token, offset: tokenStart, guidance: eventHandlerGuidance, diagnostics, reported });
+      reportHotReloadUnsafeUsage({ code, path: path6, token, offset: tokenStart, guidance: eventHandlerGuidance, diagnostics, reported });
     }
   }
   return diagnostics;
@@ -46883,16 +47302,16 @@ function parseMutationOperations(value) {
   }
   return operations;
 }
-function isAuthoredCodePath(path5) {
-  const normalized = path5.trim().toLowerCase();
+function isAuthoredCodePath(path6) {
+  const normalized = path6.trim().toLowerCase();
   return normalized.endsWith(".ts") || normalized.endsWith(".js");
 }
-function warnUnsafeCallbackUsage(path5, code) {
-  if (!isAuthoredCodePath(path5) || !code.trim()) return;
-  const diagnostics = collectRuntimeHotReloadSafetyDiagnostics(path5, code);
+function warnUnsafeCallbackUsage(path6, code) {
+  if (!isAuthoredCodePath(path6) || !code.trim()) return;
+  const diagnostics = collectRuntimeHotReloadSafetyDiagnostics(path6, code);
   if (diagnostics.length === 0) return;
   console.warn([
-    `[WaveStudio][HotReloadSafety] Strong warning for ${path5}: code edits introduced unmanaged callback roots. The write is allowed, but preview will show a memory leak warning.`,
+    `[WaveStudio][HotReloadSafety] Strong warning for ${path6}: code edits introduced unmanaged callback roots. The write is allowed, but preview will show a memory leak warning.`,
     "Use Wave-owned callbacks, animation DSL, entity lifecycle/tick/state APIs, or Director/input APIs instead.",
     ...diagnostics.map((diagnostic) => diagnostic.message)
   ].join("\n"));
@@ -47055,8 +47474,8 @@ async function handleVfsTool(input) {
       return errorToolResult("session_not_found", LOCAL_SESSION_NOT_FOUND_MESSAGE);
     }
     const pathInput = typeof args?.path === "string" ? args.path : typeof args?.filePath === "string" ? args.filePath : "";
-    const path5 = normalizeWaveFilePath(pathInput);
-    if (!path5) {
+    const path6 = normalizeWaveFilePath(pathInput);
+    if (!path6) {
       return errorToolResult("invalid_arguments", "`read_wave_file` requires a non-empty string `path` (alias: `filePath`).");
     }
     const startLine = normalizeOptionalPositiveInteger(args?.startLine);
@@ -47075,7 +47494,7 @@ async function handleVfsTool(input) {
     try {
       const result = await context.commandBroker.enqueue(session.sessionId, {
         type: "readFile",
-        path: path5,
+        path: path6,
         ...ifMatchHash ? { ifMatchHash } : {},
         ...typeof effectiveStartLine === "number" ? { startLine: effectiveStartLine } : {},
         ...typeof endLine === "number" ? { endLine } : {}
@@ -47097,7 +47516,7 @@ async function handleVfsTool(input) {
         ...result.payload.range ? { editHint: "This was a scoped line read. For edits in this slice, prefer edit_wave_file with the same full-file line numbers. baseHash is optional for simple edits." } : {}
       });
     } catch (error) {
-      return errorToolResult("command_timeout", error instanceof Error ? error.message : "WaveEngine Agent SDK file read timed out.", { path: path5 });
+      return errorToolResult("command_timeout", error instanceof Error ? error.message : "WaveEngine Agent SDK file read timed out.", { path: path6 });
     }
   }
   if (name === "edit_wave_file") {
@@ -47109,21 +47528,21 @@ async function handleVfsTool(input) {
     ]);
     if ("result" in contentResult) return contentResult.result;
     if (typeof args?.blockContaining !== "undefined" || typeof args?.replaceBlockContaining !== "undefined" || typeof args?.deleteStatementContaining !== "undefined" || typeof args?.replaceBetween !== "undefined") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       const deleteNeedle = normalizeOptionalString(args?.deleteStatementContaining);
       const replacementResult = deleteNeedle ? { value: "" } : resolveReplacementAlias("text", args?.text, args?.replacement);
       if ("result" in replacementResult) return replacementResult.result;
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "Block edit requires `text`/`replacement`, or `deleteStatementContaining` for deletion.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47145,7 +47564,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "lineEdits",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           edits: [{
             startLine: range.startLine,
@@ -47159,7 +47578,7 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: deleteNeedle ? "deleteStatementContaining" : "replaceBlockContaining",
         editTarget: {
-          path: path5,
+          path: path6,
           startLine: range.startLine,
           endLine: range.endLine,
           targetReason: range.reason,
@@ -47172,28 +47591,28 @@ async function handleVfsTool(input) {
     const editArray = parseEditWaveFileEditsArray(args?.edits);
     if (editArray) {
       if ("result" in editArray) return editArray.result;
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       for (const edit of editArray.edits) {
-        warnUnsafeCallbackUsage(path5, edit.text);
+        warnUnsafeCallbackUsage(path6, edit.text);
       }
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
       const operations = editArray.type === "lineEdits" ? [{
         type: "lineEdits",
-        path: path5,
+        path: path6,
         baseHash: resolvedHash.baseHash,
         edits: editArray.edits
       }] : [{
         type: "textEdits",
-        path: path5,
+        path: path6,
         baseHash: resolvedHash.baseHash,
         edits: editArray.edits
       }];
@@ -47207,17 +47626,17 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: editArray.type === "lineEdits" ? "multiLineEdits" : "multiTextEdits",
         editTarget: {
-          path: path5,
+          path: path6,
           editCount: editArray.edits.length
         }
       });
     }
     const inferredMode = normalizeEditWaveFileMode(args?.mode) ?? (requireNonEmptyString(args?.oldText) ? "replaceText" : typeof args?.startLine !== "undefined" || typeof args?.endLine !== "undefined" ? "replaceLines" : typeof contentResult.value === "string" ? "replaceWholeFile" : "");
     if (inferredMode === "replaceLines") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
       const startLine = normalizeOptionalPositiveInteger(args?.startLine);
       const endLine = normalizeOptionalPositiveInteger(args?.endLine);
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       if (startLine === null || typeof startLine === "undefined") {
         return errorToolResult("invalid_arguments", "`startLine` must be a positive integer.");
       }
@@ -47232,13 +47651,13 @@ async function handleVfsTool(input) {
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "`text` or `replacement` must be a string. Use an empty string to delete the line range.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47262,7 +47681,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "lineEdits",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           edits: [{
             startLine,
@@ -47276,7 +47695,7 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash, {
         editMode: "replaceLines",
         editTarget: {
-          path: path5,
+          path: path6,
           startLine,
           endLine: finalEndLine,
           requestedEndLine,
@@ -47289,18 +47708,18 @@ async function handleVfsTool(input) {
       });
     }
     if (inferredMode === "replaceText") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
       const oldText = requireNonEmptyString(args?.oldText);
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
       if (!oldText) {
         if (typeof contentResult.value === "string") {
-          warnUnsafeCallbackUsage(path5, contentResult.value);
+          warnUnsafeCallbackUsage(path6, contentResult.value);
           const sessionResult2 = resolveWritableSession(args, context);
           if ("result" in sessionResult2) return sessionResult2.result;
           const resolvedHash2 = await resolveEditBaseHash({
             context,
             session: sessionResult2.session,
-            path: path5,
+            path: path6,
             baseHash: args?.baseHash
           });
           if ("result" in resolvedHash2) return resolvedHash2.result;
@@ -47309,7 +47728,7 @@ async function handleVfsTool(input) {
             session: sessionResult2.session,
             operations: [{
               type: "writeFile",
-              path: path5,
+              path: path6,
               baseHash: resolvedHash2.baseHash,
               content: contentResult.value
             }],
@@ -47325,7 +47744,7 @@ async function handleVfsTool(input) {
       if (typeof replacementResult.value !== "string") {
         return errorToolResult("invalid_arguments", "`newText` or `replacement` must be a string. Use an empty string to delete the matched text.");
       }
-      warnUnsafeCallbackUsage(path5, replacementResult.value);
+      warnUnsafeCallbackUsage(path6, replacementResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const hasOccurrenceIndex = typeof args?.occurrenceIndex !== "undefined";
@@ -47338,7 +47757,7 @@ async function handleVfsTool(input) {
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47347,7 +47766,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "searchReplace",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           oldText,
           newText: replacementResult.value,
@@ -47360,15 +47779,15 @@ async function handleVfsTool(input) {
       return withEditBaseHashMetadata(result, resolvedHash);
     }
     if (inferredMode === "replaceWholeFile" && typeof contentResult.value === "string") {
-      const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-      if (!path5) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
-      warnUnsafeCallbackUsage(path5, contentResult.value);
+      const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+      if (!path6) return errorToolResult("invalid_arguments", "`edit_wave_file` requires a non-empty string `path`.");
+      warnUnsafeCallbackUsage(path6, contentResult.value);
       const sessionResult = resolveWritableSession(args, context);
       if ("result" in sessionResult) return sessionResult.result;
       const resolvedHash = await resolveEditBaseHash({
         context,
         session: sessionResult.session,
-        path: path5,
+        path: path6,
         baseHash: args?.baseHash
       });
       if ("result" in resolvedHash) return resolvedHash.result;
@@ -47377,7 +47796,7 @@ async function handleVfsTool(input) {
         session: sessionResult.session,
         operations: [{
           type: "writeFile",
-          path: path5,
+          path: path6,
           baseHash: resolvedHash.baseHash,
           content: contentResult.value
         }],
@@ -47389,12 +47808,12 @@ async function handleVfsTool(input) {
     return errorToolResult("invalid_arguments", "`edit_wave_file` could not infer the edit shape. Use oldText+newText, startLine+endLine+text, or path+text/content for whole-file replacement.");
   }
   if (name === "create_wave_file") {
-    const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-    if (!path5) return errorToolResult("invalid_arguments", "`create_wave_file` requires a non-empty string `path`.");
+    const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+    if (!path6) return errorToolResult("invalid_arguments", "`create_wave_file` requires a non-empty string `path`.");
     if (typeof args?.content !== "string") {
       return errorToolResult("invalid_arguments", "`content` must be a string.");
     }
-    warnUnsafeCallbackUsage(path5, args.content);
+    warnUnsafeCallbackUsage(path6, args.content);
     const overwrite = args?.overwrite === true || args?.forceOverwrite === true || args?.replaceExisting === true;
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
@@ -47403,7 +47822,7 @@ async function handleVfsTool(input) {
       session: sessionResult.session,
       operations: [{
         type: "createFile",
-        path: path5,
+        path: path6,
         content: args.content,
         runnable: typeof args?.runnable === "boolean" ? args.runnable : true,
         ...overwrite ? { overwrite: true } : {}
@@ -47434,14 +47853,14 @@ async function handleVfsTool(input) {
   if (name === "delete_wave_file") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
-    if (!path5) return errorToolResult("invalid_arguments", "`delete_wave_file` requires a non-empty string `path`.");
+    const path6 = typeof args?.path === "string" ? normalizeWaveFilePath(args.path) : "";
+    if (!path6) return errorToolResult("invalid_arguments", "`delete_wave_file` requires a non-empty string `path`.");
     return await applyMutationOperations({
       context,
       session: sessionResult.session,
       operations: [{
         type: "deleteFile",
-        path: path5
+        path: path6
       }],
       ...runtimeVerificationArgs(args)
     });
@@ -47659,7 +48078,7 @@ var ASSET_CODE_REF_DISCOVERY_INPUT_SCHEMA = {
   properties: {
     category: {
       type: "string",
-      description: `Preferred asset category or alias. Use user intent to fill this first. Supported categories/aliases from Wave Studio asset SSOT: ${ASSET_CATEGORY_HELP}. Examples: sound/audio -> audios, 3D model/character -> models, material -> materials, texture/image -> textures, HDR sky -> hdr, cube-map sky/environment -> cubeMaps, animation -> animations.`
+      description: `Preferred asset category or alias. Use user intent to fill this first. Supported categories/aliases from Wave Studio asset SSOT: ${ASSET_CATEGORY_HELP}. Examples: sound/audio -> audios, 3D model/character -> models, material -> materials, texture/image -> textures, HDR sky -> hdr, cube-map sky/environment -> cubeMaps, skeletal animation -> animations, baked vertex/VAT animation -> vertexAnimations.`
     },
     bucket: {
       type: "string",
@@ -48389,7 +48808,7 @@ function buildHostedWaveStudioMcpToolDefinitions() {
     },
     {
       name: "find_wave_assets_by_category",
-      description: `[studio.assets] Canonical category-first discovery for code refs. Use when code needs an existing asset: choose an asset category from the user intent first (model/sound/material/texture/sky/animation/etc.), then search the paired Wave Studio asset surface: public assets, uploaded user assets, and project aliases. Preferred shape: { category:"materials", query:"grass", limit:50 }. Friendly aliases \`list_wave_assets_by_category\`, \`search_wave_assets_by_category\`, and \`list_wave_assets\` route here. Returned bare refs are safe in code, e.g. models.Car, textures.Grass, materials.Wood, audios.Click, hdr.Sky, animations.Run. The category-filtered response can still be capped; do not infer absence without semantic query refinement.${BROWSER_COMMAND_PENDING_NOTE}`,
+      description: `[studio.assets] Canonical category-first discovery for code refs. Use when code needs an existing asset: choose an asset category from the user intent first (model/sound/material/texture/sky/animation/VAT/etc.), then search the paired Wave Studio asset surface: public assets, uploaded user assets, and project aliases. Preferred shape: { category:"materials", query:"grass", limit:50 }. Friendly aliases \`list_wave_assets_by_category\`, \`search_wave_assets_by_category\`, and \`list_wave_assets\` route here. Returned bare refs are safe in code, e.g. models.Car, textures.Grass, materials.Wood, audios.Click, hdr.Sky, animations.Run, vertexAnimations.HorseGallopVat. The category-filtered response can still be capped; do not infer absence without semantic query refinement.${BROWSER_COMMAND_PENDING_NOTE}`,
       inputSchema: ASSET_CODE_REF_DISCOVERY_INPUT_SCHEMA
     },
     {
@@ -48436,7 +48855,7 @@ function buildHostedWaveStudioMcpToolDefinitions() {
     },
     {
       name: "upload_wave_asset",
-      description: `[studio.assets] Small inline upload only: upload bytes already loaded by the agent as base64/data URL. This tool does not read local paths. Upload decision tree: tiny bytes already in memory -> upload_wave_asset; local file path/normal size -> create_wave_asset_upload + raw PUT + commit_wave_asset_upload; direct_upload_unavailable or chunk-only environment -> stage_wave_asset_upload_chunk + commit_wave_asset_chunk_upload. assetKind values come from the Wave Studio upload policy SSOT: ${BRIDGE_ASSET_UPLOAD_KIND_HELP}. Meshoptimizer defaults on for model-family uploads only; useMeshoptimizer is ignored for non-model assets unless explicitly supported by the browser pipeline. Pass exactly one of dataBase64 or dataUrl. Returns typed refs such as textures.Albedo, cubeMaps.Studio, materials.Wood, audios.Click, models.Robot, animations.Run, fonts.Title, or serializedData.Config.${WRITE_PAIRING_REQUIRED_NOTE}${BROWSER_COMMAND_PENDING_NOTE}`,
+      description: `[studio.assets] Small inline upload only: upload bytes already loaded by the agent as base64/data URL. This tool does not read local paths. Upload decision tree: tiny bytes already in memory -> upload_wave_asset; local file path/normal size -> create_wave_asset_upload + raw PUT + commit_wave_asset_upload; direct_upload_unavailable or chunk-only environment -> stage_wave_asset_upload_chunk + commit_wave_asset_chunk_upload. assetKind values come from the Wave Studio upload policy SSOT: ${BRIDGE_ASSET_UPLOAD_KIND_HELP}. Meshoptimizer defaults on for model-family uploads only; useMeshoptimizer is ignored for non-model assets unless explicitly supported by the browser pipeline. Pass exactly one of dataBase64 or dataUrl. Returns typed refs such as textures.Albedo, cubeMaps.Studio, materials.Wood, audios.Click, models.Robot, animations.Run, vertexAnimations.HorseGallopVat, fonts.Title, or serializedData.Config.${WRITE_PAIRING_REQUIRED_NOTE}${BROWSER_COMMAND_PENDING_NOTE}`,
       inputSchema: {
         type: "object",
         properties: {
@@ -49497,7 +49916,11 @@ var LOCAL_TOOL_DEFINITION_OVERRIDE_NAMES = /* @__PURE__ */ new Set([
 var LOCAL_EXTRA_TOOL_DEFINITION_NAMES = /* @__PURE__ */ new Set([
   "self_check_wave_mcp",
   "list_wave_sessions",
-  "get_active_wave_session"
+  "get_active_wave_session",
+  "create_wave_3d_modeling_job"
+]);
+var LOCAL_SDK_MODELING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_wave_3d_modeling_job"
 ]);
 var LOCAL_OPTIONAL_SESSION_TOOL_NAMES = /* @__PURE__ */ new Set([
   "get_wave_session",
@@ -49566,6 +49989,7 @@ var LOCAL_SDK_CONTROL_TOOL_NAMES = /* @__PURE__ */ new Set([
 var LOCAL_SDK_IMPLEMENTED_CANONICAL_TOOL_NAMES = /* @__PURE__ */ new Set([
   ...LOCAL_SDK_CONTROL_TOOL_NAMES,
   ...LOCAL_SDK_LOOKUP_TOOL_NAMES,
+  ...LOCAL_SDK_MODELING_TOOL_NAMES,
   ...[...LOCAL_OPTIONAL_SESSION_TOOL_NAMES].map((name) => canonicalizeWaveMcpToolName(name))
 ]);
 function isLocalMcpToolImplemented(name) {
@@ -49688,6 +50112,60 @@ function getReadToolDefinitions() {
         additionalProperties: false
       }
     },
+    {
+      name: "create_wave_3d_modeling_job",
+      description: "[wave.modeling] Create a local SDK 3D-modeling job scaffold from a prompt and optional screenshots/reference image paths. Writes README, CAD prompt, JSON parameter template/schema, Python CadQuery STEP scaffold, and validation checklist into a temp job folder. Does not generate/upload a GLB by itself; use asset upload tools after a real model file exists. If requiredParts is supplied, the resulting GLB must embed Wave objectModel SSOT metadata via waveModelObjectModel on a __wave_model_object_model node plus per-mesh projection keys; raw mesh names, metadata.partIds, extras.partIds, or positional mesh arrays are not part truth. Aliases: generate_wave_3d_model, create_wave_3d_model, create_wave_3d_model_from_screenshots.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sourcePrompt: {
+            type: "string",
+            description: 'Required modeling goal, e.g. "make a low-poly sea lion matching the screenshot". Aliases accepted by handler: prompt, description.'
+          },
+          prompt: {
+            type: "string",
+            description: "Alias for sourcePrompt."
+          },
+          description: {
+            type: "string",
+            description: "Alias for sourcePrompt."
+          },
+          assetName: {
+            type: "string",
+            description: "Optional public Wave asset/model name stem. Handler sanitizes to lowercase snake_case."
+          },
+          screenshotPaths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional local screenshot paths, usually returned from capture_wave_screenshot or supplied by user."
+          },
+          referenceImagePaths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional local reference image paths."
+          },
+          targetStyle: {
+            type: "string",
+            description: "Optional visual style constraint."
+          },
+          intendedUse: {
+            type: "string",
+            description: "Optional Wave scene usage target such as prop, actor, background, UI model, collision mesh."
+          },
+          requiredParts: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional public part names the generated GLB must preserve in objectModel SSOT. When non-empty, model output must include waveModelObjectModel on a __wave_model_object_model node with parts, meshPartBindings, parentPartId/topology/material data as needed, and per-mesh waveModelPartId/waveModelPartName projection keys."
+          },
+          knownDimensionsMm: {
+            type: "object",
+            description: 'Optional JSON-safe dimension hints in millimeters, e.g. {"overall_width": 1200, "overall_height": 500}.',
+            additionalProperties: true
+          }
+        },
+        additionalProperties: false
+      }
+    },
     {
       name: "get_wave_session",
       description: "Return the Wave Studio browser session paired through the WaveEngine Agent SDK. Full Studio tools are available when this local endpoint is called with the adopted HTTP Gateway token from Wave Studio.",
@@ -49792,6 +50270,7 @@ function getLocalToolImplementationSummary() {
     implementedCanonicalToolCount: implementedCanonicalToolNames.length,
     localExtraToolNames: [...LOCAL_EXTRA_TOOL_DEFINITION_NAMES].sort(),
     localLookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort(),
+    localModelingToolNames: [...LOCAL_SDK_MODELING_TOOL_NAMES].sort(),
     omittedCanonicalToolNames: canonicalToolNames.filter((name) => !isLocalMcpToolImplemented(name))
   };
 }
@@ -49815,7 +50294,8 @@ function localSdkLookupStatus(waveEngineSdkCache) {
     corpusCacheReady,
     apiAndSkillQueryAvailable: corpusCacheReady,
     cacheMissAffectsLiveStudioTransport: false,
-    lookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort()
+    lookupToolNames: [...LOCAL_SDK_LOOKUP_TOOL_NAMES].sort(),
+    localModelingToolNames: [...LOCAL_SDK_MODELING_TOOL_NAMES].sort()
   };
 }
 function jsonRpcToolIdempotencyKey(toolName, requestId) {
@@ -50280,10 +50760,10 @@ function screenshotBasePayload(payload, suggestedFilename) {
   };
 }
 async function saveScreenshotPayloadToLocalFile(payload, suggestedFilename) {
-  const directory = path2.join(tmpdir(), "wave3d-agent-sdk", "screenshots");
-  await mkdir(directory, { recursive: true });
-  const localPath = path2.join(directory, suggestedFilename);
-  await writeFile(localPath, Buffer.from(payload.dataBase64, "base64"));
+  const directory = path3.join(tmpdir2(), "wave3d-agent-sdk", "screenshots");
+  await mkdir2(directory, { recursive: true });
+  const localPath = path3.join(directory, suggestedFilename);
+  await writeFile2(localPath, Buffer.from(payload.dataBase64, "base64"));
   return localPath;
 }
 function normalizeRuntimeMarkerSource(value) {
@@ -50476,7 +50956,7 @@ async function callReadTool(name, args, context) {
   if (name === "start_wave_task") {
     const routeResult = startWaveMcpTaskRoute({
       args,
-      taskRouteId: `wgtask_${randomUUID()}`,
+      taskRouteId: `wgtask_${randomUUID2()}`,
       now: nowIso(),
       seedEvidence: mergeWaveMcpTaskEvidence(
         getLocalPreTaskEvidence(context) ?? createWaveMcpEmptyTaskEvidence(),
@@ -50665,7 +51145,8 @@ async function callReadTool(name, args, context) {
         "studio.project: list_wave_project_templates, new_wave_project, list_wave_projects, read_wave_project, rename_wave_project, open_wave_project, save_wave_project, share_wave_project",
         "studio.preview: hot_reload_wave_preview (alias: hotreload_wave_preview), run_wave_preview (alias: run_project), pause_wave_preview (alias: pause_wave_engine), resume_wave_preview (alias: resume_wave_engine), get_wave_runtime_diagnostics (alias: get_wave_errors), get_wave_runtime_performance_snapshot (alias: get_wave_runtime_performance)",
         "studio.capture: capture_wave_screenshot (alias: get_wave_screenshot), get_wave_runtime_entity_snapshot (alias: get_wave_entity_snapshot), list_wave_runtime_markers (alias: list_wave_markers)",
-        "wave.authoring: list_wave_skill_families, query_wave_skills, get_wave_skill, query_wave_api"
+        "wave.authoring: list_wave_skill_families, query_wave_skills, get_wave_skill, query_wave_api",
+        "wave.modeling: create_wave_3d_modeling_job (aliases: generate_wave_3d_model, create_wave_3d_model, create_wave_3d_model_from_screenshots) creates local SDK support files; if parts are requested the generated GLB must embed waveModelObjectModel on a __wave_model_object_model node before upload"
       ],
       rules: [
         "studio.* labels are categories, not callable tools.",
@@ -50686,6 +51167,9 @@ async function callReadTool(name, args, context) {
       args
     });
   }
+  if (name === "create_wave_3d_modeling_job") {
+    return await createWave3dModelingJobTool(args);
+  }
   if (name === "get_wave_command_result") {
     const requestId = requireNonEmptyString(args?.requestId);
     if (!requestId) {
@@ -50938,15 +51422,15 @@ async function callReadTool(name, args, context) {
   if (name === "rename_wave_asset") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = requireNonEmptyString(args?.path);
+    const path6 = requireNonEmptyString(args?.path);
     const nextName = requireNonEmptyString(stringAliasArg(args, ["name", "newName", "displayName"]));
-    if (!path5 || !nextName) return errorToolResult("invalid_arguments", "`rename_wave_asset` requires non-empty `path` and `name`.");
+    if (!path6 || !nextName) return errorToolResult("invalid_arguments", "`rename_wave_asset` requires non-empty `path` and `name`.");
     return await enqueueBrowserCommand({
       context,
       session: sessionResult.session,
       command: {
         type: "renameAsset",
-        path: path5,
+        path: path6,
         name: nextName
       }
     });
@@ -50954,14 +51438,14 @@ async function callReadTool(name, args, context) {
   if (name === "delete_wave_asset") {
     const sessionResult = resolveWritableSession(args, context);
     if ("result" in sessionResult) return sessionResult.result;
-    const path5 = requireNonEmptyString(args?.path);
-    if (!path5) return errorToolResult("invalid_arguments", "`delete_wave_asset` requires a non-empty `path`.");
+    const path6 = requireNonEmptyString(args?.path);
+    if (!path6) return errorToolResult("invalid_arguments", "`delete_wave_asset` requires a non-empty `path`.");
     return await enqueueBrowserCommand({
       context,
       session: sessionResult.session,
       command: {
         type: "deleteAsset",
-        path: path5
+        path: path6
       }
     });
   }
@@ -51415,9 +51899,9 @@ async function handleWaveGenieMcpRequest(request, context) {
 }
 
 // ../../scripts/wavegenie-sdk/sessionRegistry.ts
-import { createHash as createHash4, randomUUID as randomUUID2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function createSessionId() {
-  return `wgb_${randomUUID2()}`;
+  return `wgb_${randomUUID3()}`;
 }
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -51557,18 +52041,18 @@ var WaveGenieBridgeSessionRegistry = class {
 };
 
 // ../../scripts/wavegenie-sdk/assetStaging.ts
-import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import { mkdir as mkdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import path3 from "node:path";
+import { mkdir as mkdir3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import path4 from "node:path";
 var MAX_LOCAL_ASSET_UPLOAD_BYTES = 300 * 1024 * 1024;
 var MAX_LOCAL_ASSET_UPLOAD_CHUNKS = 256;
-var STAGING_ROOT = path3.join(tmpdir2(), "wave3d-agent-sdk-asset-staging");
+var STAGING_ROOT = path4.join(tmpdir3(), "wave3d-agent-sdk-asset-staging");
 var LOCAL_DIRECT_UPLOAD_TTL_MS = 60 * 60 * 1e3;
 var DEFAULT_LOCAL_ASSET_UPLOAD_TTL_MS = 24 * 60 * 60 * 1e3;
 function createUploadId() {
-  return `wgbupload_${randomUUID3()}`;
+  return `wgbupload_${randomUUID4()}`;
 }
 function createSecret() {
   return randomBytes2(24).toString("base64url");
@@ -51628,8 +52112,8 @@ var LocalAssetUploadStagingStore = class {
     this.uploads = /* @__PURE__ */ new Map();
   }
   async ensureUploadDir(uploadId) {
-    const uploadDir = path3.join(STAGING_ROOT, hashPathPart(uploadId));
-    await mkdir2(uploadDir, { recursive: true });
+    const uploadDir = path4.join(STAGING_ROOT, hashPathPart(uploadId));
+    await mkdir3(uploadDir, { recursive: true });
     return uploadDir;
   }
   createPartUrl(uploadId, chunkIndex, readToken) {
@@ -51668,8 +52152,8 @@ var LocalAssetUploadStagingStore = class {
     const currentBytes = [...upload.parts.values()].filter((part2) => part2.chunkIndex !== chunkIndex).reduce((total, part2) => total + part2.sizeBytes, 0);
     assertUploadSize(currentBytes + bytes.byteLength);
     const uploadDir = await this.ensureUploadDir(upload.uploadId);
-    const filePath = path3.join(uploadDir, `part-${chunkIndex}.bin`);
-    await writeFile2(filePath, bytes);
+    const filePath = path4.join(uploadDir, `part-${chunkIndex}.bin`);
+    await writeFile3(filePath, bytes);
     const part = {
       chunkIndex,
       sizeBytes: bytes.byteLength,
@@ -51682,7 +52166,7 @@ var LocalAssetUploadStagingStore = class {
   async putStreamPart(input) {
     const currentBytes = [...input.upload.parts.values()].filter((part2) => part2.chunkIndex !== input.chunkIndex).reduce((total, part2) => total + part2.sizeBytes, 0);
     const uploadDir = await this.ensureUploadDir(input.upload.uploadId);
-    const filePath = path3.join(uploadDir, `part-${input.chunkIndex}.bin`);
+    const filePath = path4.join(uploadDir, `part-${input.chunkIndex}.bin`);
     const output = createWriteStream(filePath, { flags: "w" });
     let writtenBytes = 0;
     try {
@@ -51836,7 +52320,7 @@ var LocalAssetUploadStagingStore = class {
     const upload = this.uploads.get(uploadId);
     if (!upload) return 0;
     this.uploads.delete(uploadId);
-    const uploadDir = path3.join(STAGING_ROOT, hashPathPart(uploadId));
+    const uploadDir = path4.join(STAGING_ROOT, hashPathPart(uploadId));
     await rm(uploadDir, { recursive: true, force: true });
     return upload.parts.size;
   }
@@ -51861,7 +52345,7 @@ var MAX_DIRECT_UPLOAD_BODY_BYTES = 300 * 1024 * 1024;
 var LOCAL_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/i;
 var TRUSTED_WAVE_STUDIO_ORIGIN_RE = /^https:\/\/(www\.)?wave3d\.ai$/i;
 function createBridgeId() {
-  return `wgbridge_${randomUUID4()}`;
+  return `wgbridge_${randomUUID5()}`;
 }
 function isAllowedStudioOrigin(origin) {
   if (!origin) return true;
@@ -52364,10 +52848,10 @@ function readBooleanFlag(options, name) {
   return options.flags.get(name) === true;
 }
 function getDefaultCacheRoot() {
-  return path4.join(homedir2(), ".wave3d", "agent-cache");
+  return path5.join(homedir2(), ".wave3d", "agent-cache");
 }
 function getCacheRoot(options) {
-  return path4.resolve(readStringFlag(options, "cache-dir") ?? process.env[CACHE_DIR_ENV] ?? getDefaultCacheRoot());
+  return path5.resolve(readStringFlag(options, "cache-dir") ?? process.env[CACHE_DIR_ENV] ?? getDefaultCacheRoot());
 }
 function getDefaultMcpUrl(options) {
   const port = readNumberFlag(options, "port") ?? DEFAULT_PORT2;
@@ -52386,29 +52870,29 @@ function assertSafeListenHost(host, allowNetwork) {
   throw new Error(`Refusing to listen on non-loopback host ${host}. Use --allow-network only on a trusted network.`);
 }
 function assertSafeCacheRoot(cacheRoot) {
-  const resolved = path4.resolve(cacheRoot);
-  const root = path4.parse(resolved).root;
+  const resolved = path5.resolve(cacheRoot);
+  const root = path5.parse(resolved).root;
   const dangerous = /* @__PURE__ */ new Set([
     root,
-    path4.resolve(homedir2()),
-    path4.resolve(process.cwd()),
-    path4.resolve(path4.dirname(homedir2()))
+    path5.resolve(homedir2()),
+    path5.resolve(process.cwd()),
+    path5.resolve(path5.dirname(homedir2()))
   ]);
   if (dangerous.has(resolved)) {
     throw new Error(`Refusing to use dangerous cache directory: ${resolved}`);
   }
-  const depth = path4.relative(root, resolved).split(path4.sep).filter(Boolean).length;
+  const depth = path5.relative(root, resolved).split(path5.sep).filter(Boolean).length;
   if (depth < 2) {
     throw new Error(`Refusing to use shallow cache directory: ${resolved}`);
   }
 }
 function isDefaultCacheRoot(cacheRoot) {
-  return path4.resolve(cacheRoot) === path4.resolve(getDefaultCacheRoot());
+  return path5.resolve(cacheRoot) === path5.resolve(getDefaultCacheRoot());
 }
 async function markCacheRoot(cacheRoot) {
   assertSafeCacheRoot(cacheRoot);
-  await mkdir3(cacheRoot, { recursive: true });
-  await writeFile3(path4.join(cacheRoot, CACHE_MARKER_FILE), "wave3d-agent-cache\n");
+  await mkdir4(cacheRoot, { recursive: true });
+  await writeFile4(path5.join(cacheRoot, CACHE_MARKER_FILE), "wave3d-agent-cache\n");
 }
 function isSafePathSegment(value) {
   return /^[A-Za-z0-9._-]+$/.test(value);
@@ -52737,11 +53221,11 @@ function assertCorpusManifestMatches(actual, expected) {
   }
 }
 function getBundledSdkDirectory() {
-  return path4.join(path4.dirname(fileURLToPath(import.meta.url)), BUNDLED_SDK_DIR_NAME);
+  return path5.join(path5.dirname(fileURLToPath(import.meta.url)), BUNDLED_SDK_DIR_NAME);
 }
 async function readBundledSdkManifest() {
   try {
-    const parsed = JSON.parse(await readFile2(path4.join(getBundledSdkDirectory(), "manifest.json"), "utf8"));
+    const parsed = JSON.parse(await readFile2(path5.join(getBundledSdkDirectory(), "manifest.json"), "utf8"));
     return isCorpusManifest(parsed) ? parsed : null;
   } catch {
     return null;
@@ -52749,7 +53233,7 @@ async function readBundledSdkManifest() {
 }
 async function readBundledSdkZip(manifest) {
   const bundleFileName = requireSafePathSegment(manifest.bundleFileName, "Bundled SDK zip file name");
-  const bytes = await readFile2(path4.join(getBundledSdkDirectory(), bundleFileName));
+  const bytes = await readFile2(path5.join(getBundledSdkDirectory(), bundleFileName));
   if (bytes.length > MAX_CORPUS_ZIP_BYTES2) {
     throw new Error(`Bundled SDK zip is too large: ${bytes.length} bytes.`);
   }
@@ -52760,11 +53244,11 @@ async function writeCorpusCacheFromZip(input) {
   await markCacheRoot(cacheRoot);
   const cacheKey = requireSafePathSegment(input.manifest.cacheKey, "Corpus cacheKey");
   const bundleFileName = requireSafePathSegment(input.manifest.bundleFileName, "Corpus bundle file name");
-  const versionDir = path4.join(cacheRoot, cacheKey);
-  const corpusDir = path4.join(versionDir, "corpus");
-  await mkdir3(versionDir, { recursive: true });
-  await writeFile3(path4.join(versionDir, "corpus-handshake.json"), JSON.stringify(input.handshake, null, 2));
-  await writeFile3(path4.join(versionDir, bundleFileName), input.zipBytes);
+  const versionDir = path5.join(cacheRoot, cacheKey);
+  const corpusDir = path5.join(versionDir, "corpus");
+  await mkdir4(versionDir, { recursive: true });
+  await writeFile4(path5.join(versionDir, "corpus-handshake.json"), JSON.stringify(input.handshake, null, 2));
+  await writeFile4(path5.join(versionDir, bundleFileName), input.zipBytes);
   await extractZipToDirectory(input.zipBytes, corpusDir, input.manifest);
   await buildSearchIndex(corpusDir);
   const current = {
@@ -52776,7 +53260,7 @@ async function writeCorpusCacheFromZip(input) {
     sourceVersions: input.manifest.sourceVersions,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile3(path4.join(cacheRoot, "current.json"), JSON.stringify(current, null, 2));
+  await writeFile4(path5.join(cacheRoot, "current.json"), JSON.stringify(current, null, 2));
   return current;
 }
 async function ensureBundledSdkCache(options, input) {
@@ -52915,16 +53399,16 @@ async function commandDoctor(options) {
   await commandCacheStatus(options);
 }
 function normalizeZipEntryPath(entryName) {
-  const normalized = path4.posix.normalize(entryName.replace(/\\/g, "/"));
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("\0") || path4.posix.isAbsolute(normalized)) {
+  const normalized = path5.posix.normalize(entryName.replace(/\\/g, "/"));
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("\0") || path5.posix.isAbsolute(normalized)) {
     throw new Error(`Unsafe corpus zip entry: ${entryName}`);
   }
   return normalized;
 }
 function resolveZipOutputPath(targetDir, normalizedEntryName) {
-  const outputPath = path4.resolve(targetDir, ...normalizedEntryName.split("/"));
-  const relative = path4.relative(targetDir, outputPath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+  const outputPath = path5.resolve(targetDir, ...normalizedEntryName.split("/"));
+  const relative = path5.relative(targetDir, outputPath);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
     throw new Error(`Unsafe corpus zip output path: ${normalizedEntryName}`);
   }
   return outputPath;
@@ -52938,8 +53422,8 @@ function isCorpusCurrentRecord(value) {
   return isRecord4(value) && typeof value.cacheKey === "string" && typeof value.version === "string" && (typeof value.formatVersion === "undefined" || typeof value.formatVersion === "string") && typeof value.bundleHash === "string" && typeof value.corpusDir === "string" && (typeof value.sourceVersions === "undefined" || isRecord4(value.sourceVersions)) && (typeof value.updatedAt === "undefined" || typeof value.updatedAt === "string");
 }
 function isPathInsideDirectory2(parentDir, childPath) {
-  const relative = path4.relative(path4.resolve(parentDir), path4.resolve(childPath));
-  return relative === "" || !!relative && !relative.startsWith("..") && !path4.isAbsolute(relative);
+  const relative = path5.relative(path5.resolve(parentDir), path5.resolve(childPath));
+  return relative === "" || !!relative && !relative.startsWith("..") && !path5.isAbsolute(relative);
 }
 async function readCorpusManifestFromDirectory(corpusDir) {
   try {
@@ -52984,7 +53468,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
   const allowedPaths = /* @__PURE__ */ new Set(["manifest.json", ...expectedFiles.keys()]);
   const extractedFilePaths = /* @__PURE__ */ new Set();
   await rm2(targetDir, { recursive: true, force: true });
-  await mkdir3(targetDir, { recursive: true });
+  await mkdir4(targetDir, { recursive: true });
   const entries = Object.values(zip.files);
   if (entries.length > MAX_CORPUS_FILE_COUNT) {
     throw new Error(`Corpus zip has too many entries: ${entries.length}.`);
@@ -53001,7 +53485,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
       throw new Error(`Corpus extracted size is too large: ${extractedBytes + expectedSize} bytes.`);
     }
     const outputPath = resolveZipOutputPath(targetDir, normalized);
-    await mkdir3(path4.dirname(outputPath), { recursive: true });
+    await mkdir4(path5.dirname(outputPath), { recursive: true });
     const content = await entry.async("nodebuffer");
     extractedBytes += content.length;
     if (extractedBytes > MAX_CORPUS_EXTRACTED_BYTES2) {
@@ -53019,7 +53503,7 @@ async function extractZipToDirectory(zipBytes, targetDir, manifest) {
       }
       extractedFilePaths.add(normalized);
     }
-    await writeFile3(outputPath, content);
+    await writeFile4(outputPath, content);
   }
   for (const expectedPath of expectedFiles.keys()) {
     if (!extractedFilePaths.has(expectedPath)) {
@@ -53031,7 +53515,7 @@ function parseJsonLines2(content) {
   return content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
 }
 async function buildSearchIndex(corpusDir) {
-  const searchPath = path4.join(corpusDir, "search", "search-documents.jsonl");
+  const searchPath = path5.join(corpusDir, "search", "search-documents.jsonl");
   const content = await readFile2(searchPath, "utf8");
   const documents = parseJsonLines2(content);
   const uniqueDocuments = [];
@@ -53058,7 +53542,7 @@ async function buildSearchIndex(corpusDir) {
     }
   });
   miniSearch.addAll(uniqueDocuments);
-  await writeFile3(path4.join(corpusDir, "search", "minisearch-index.json"), JSON.stringify(miniSearch.toJSON()));
+  await writeFile4(path5.join(corpusDir, "search", "minisearch-index.json"), JSON.stringify(miniSearch.toJSON()));
 }
 async function commandCacheRefresh(options) {
   const mcpUrl = readStringFlag(options, "mcp-url");
@@ -53076,12 +53560,12 @@ async function commandCacheRefresh(options) {
   console.log(`Cache root: ${getCacheRoot(options)}`);
 }
 async function readCurrentCache(cacheRoot) {
-  const currentPath = path4.join(cacheRoot, "current.json");
+  const currentPath = path5.join(cacheRoot, "current.json");
   if (!existsSync2(currentPath)) return null;
   try {
     const parsed = JSON.parse(await readFile2(currentPath, "utf8"));
     if (!isCorpusCurrentRecord(parsed)) return null;
-    const corpusDir = path4.resolve(parsed.corpusDir);
+    const corpusDir = path5.resolve(parsed.corpusDir);
     if (!isPathInsideDirectory2(cacheRoot, corpusDir)) return null;
     const manifest = await readCorpusManifestFromDirectory(corpusDir);
     if (!manifest || !corpusCurrentMatchesManifest(parsed, manifest)) return null;
@@ -53110,7 +53594,7 @@ async function commandCacheStatus(options) {
 async function commandCacheClear(options) {
   const cacheRoot = getCacheRoot(options);
   assertSafeCacheRoot(cacheRoot);
-  if (!isDefaultCacheRoot(cacheRoot) && !existsSync2(path4.join(cacheRoot, CACHE_MARKER_FILE))) {
+  if (!isDefaultCacheRoot(cacheRoot) && !existsSync2(path5.join(cacheRoot, CACHE_MARKER_FILE))) {
     throw new Error(`Refusing to clear unmarked custom cache directory: ${cacheRoot}`);
   }
   await rm2(cacheRoot, { recursive: true, force: true });
@@ -53124,7 +53608,7 @@ async function commandCacheSearch(options) {
   const current = await readCurrentCache(cacheRoot);
   const corpusDir = typeof current?.corpusDir === "string" ? current.corpusDir : null;
   if (!corpusDir) throw new Error("No bundled SDK cache is available. Reinstall/update wave3d-agent-sdk.");
-  const indexPath = path4.join(corpusDir, "search", "minisearch-index.json");
+  const indexPath = path5.join(corpusDir, "search", "minisearch-index.json");
   const rawIndex = await readFile2(indexPath, "utf8");
   const miniSearch = MiniSearch2.loadJSON(rawIndex, {
     fields: ["title", "text"],