@genex-ai/cli-demo 1.13.2-dev.559 → 1.14.0-dev.560

package/dist/{blender-mcp-LLN4FPA4.js → blender-mcp-3U5AG7WS.js}

@@ -1,13 +1,13 @@
 import {
-  BLENDER_SETUP_HINT,
   SHEET_FORMATS,
   acquireSeat,
   blenderCall,
   blenderEndpoint,
+  blenderSetupHint,
   isRenderMode,
   sceneSummary,
   sheetOf
-} from "./chunk-WXHTNSFB.js";
+} from "./chunk-2UJK5OCB.js";
 import {
   getCliVersion
 } from "./chunk-HYCSNWYX.js";
@@ -178,7 +178,7 @@ async function handle(msg) {
     if (!tool) return fail(id, -32602, `Unknown tool: ${name}`);
     const base = await mcpEndpoint();
     if (!base) {
-      return reply(id, { content: [{ type: "text", text: BLENDER_SETUP_HINT }], isError: true });
+      return reply(id, { content: [{ type: "text", text: blenderSetupHint() }], isError: true });
     }
     try {
       return reply(id, await tool.run(args, base));

package/dist/{chunk-WXHTNSFB.js → chunk-2UJK5OCB.js}

@@ -124,13 +124,20 @@ function blenderEndpoint() {
   const raw = process.env.GENEX_BLENDER_URL?.trim();
   return raw ? raw.replace(/\/+$/, "") : void 0;
 }
-var BLENDER_SETUP_HINT = [
-  "GENEX_BLENDER_URL is not set \u2014 there is no hosted Blender service yet.",
-  "  Start one locally:",
-  "    docker build --platform=linux/amd64 -t genex-blender:m0 apps/blender-service",
-  "    docker run -d --platform=linux/amd64 -p 8099:8080 genex-blender:m0",
-  "    export GENEX_BLENDER_URL=http://localhost:8099"
-].join("\n");
+function blenderSetupHint() {
+  if (process.env.GENEX_HOSTED_SESSION === "1") {
+    return [
+      "The Blender lane is off on this stand \u2014 there is no seat to acquire.",
+      "  Build the space in code instead ($genex-threejs-procedural-assets); do not wait for it."
+    ].join("\n");
+  }
+  return [
+    "No Blender endpoint. Run the service against your own Blender in another terminal:",
+    "    npx genex blender serve",
+    "    export GENEX_BLENDER_URL=http://localhost:8088",
+    "  GENEX_BLENDER_URL may also point at any running genex-blender service."
+  ].join("\n");
+}
 var SHEET_FORMATS = ["webp", "png"];
 function sheetOf(r) {
   if (r.contactSheet?.b64) return { b64: r.contactSheet.b64, mime: r.contactSheet.mime };
@@ -198,7 +205,8 @@ async function blenderCall(base, route, body) {
           seat ? `${route} refused the seat token (401) \u2014 the seat may have been closed; run the command again to acquire a new one` : `${route} refused the request (401) \u2014 set GENEX_BLENDER_SECRET to the service's secret`
         );
       }
-      throw new Error(`${route} failed (${res.status}): ${json.error ?? text.slice(0, 200)}`);
+      const detail = typeof json.detail === "string" ? ` \u2014 ${json.detail}` : "";
+      throw new Error(`${route} failed (${res.status}): ${json.error ?? text.slice(0, 200)}${detail}`);
     }
     return json;
   } catch (err) {
@@ -431,7 +439,7 @@ export {
   RENDER_MODES,
   isRenderMode,
   blenderEndpoint,
-  BLENDER_SETUP_HINT,
+  blenderSetupHint,
   SHEET_FORMATS,
   sheetOf,
   sheetExt,

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
-  BLENDER_SETUP_HINT,
   RENDER_MODES,
   SHEET_FORMATS,
   acquireSeat,
   apiFetch,
   blenderCall,
   blenderEndpoint,
+  blenderSetupHint,
   fetchSignedInEmail,
   getWorkspacePath,
   isRenderMode,
@@ -22,7 +22,7 @@ import {
   writeProject,
   writeUserToken,
   writeWorkspace
-} from "./chunk-WXHTNSFB.js";
+} from "./chunk-2UJK5OCB.js";
 import {
   CLI_CHANNEL,
   DEFAULT_API_URL,
@@ -700,7 +700,7 @@ var CONTRACT_END = "<!-- genex:contract:end -->";
 var GENEX_CONTRACT_BLOCK = `${CONTRACT_BEGIN}
 # Genex build contract (always in effect for this game)
 
-Your agentic capabilities that can boost your creation (all via \`npx genex \u2026\`): generate \`model\` (\`--image\` from a reference image; \`model segment <id>\` into named parts; \`model rig <id>\` + \`model animate <rig-id> --preset walk\` for non-biped bodies \u2014 7 body plans) \xB7 \`sfx\` \xB7 \`music\` \xB7 \`voice\` \xB7 \`texture\` \xB7 \`image\` (\`--edit\` \xB7 \`--inpaint\` \xB7 \`--glass\` \xB7 \`--clean\` \xB7 \`--upscale\`) \xB7 \`video\` \xB7 rigged \`character\` / \`creature\` \xB7 \`character animate <id> "<verb>"\` (also \`creature animate\`; \`--locomotion\` for the 8-way movement set, \`--video\` for your own footage) \xB7 the pixel toolbox \`ui extract|masks|plate|text-color|trim|audit\` \xB7 vendored \`controller character|car|drone|touch|quality|chat\` \xB7 \`animations search\` \xB7 \`wait <id>\` / \`wait --all\` \xB7 \`preview\` / \`publish\` \xB7 \`rename <name>\` (move the game to a new address \u2014 keeps its plays and likes, kills the old link, needs \`--yes\` once published, and the game must be rebuilt after). Full options: \`npx genex --help\`. There is NO sky generator: every sky, horizon, time of day and weather mood is built in code \u2014 your call how, from a background colour and fog to an atmospheric sky shader with a real sun. It costs nothing, weighs nothing on phones, and keeps the sun in sync with the scene's own lighting, which a painted panorama never can. Task\u2192lane routing lives in the \`genex-game-director\` skill's routing map \u2014 load the owning row before the first file of each subsystem, and re-load the map after any compaction.
+Your agentic capabilities that can boost your creation (all via \`npx genex \u2026\`): generate \`model\` (\`--image\` from a reference image; \`model segment <id>\` into named parts; \`model rig <id>\` + \`model animate <rig-id> --preset walk\` for non-biped bodies \u2014 7 body plans) \xB7 \`sfx\` \xB7 \`music\` \xB7 \`voice\` \xB7 \`texture\` \xB7 \`image\` (\`--edit\` \xB7 \`--inpaint\` \xB7 \`--glass\` \xB7 \`--clean\` \xB7 \`--upscale\`) \xB7 \`video\` \xB7 rigged \`character\` / \`creature\` \xB7 \`character animate <id> "<verb>"\` (also \`creature animate\`; \`--locomotion\` for the 8-way movement set, \`--video\` for your own footage) \xB7 the pixel toolbox \`ui extract|masks|plate|text-color|trim|audit\` \xB7 vendored \`controller character|car|drone|touch|quality|chat\` \xB7 a live Blender for composing levels and interiors \u2014 \`blender scene|exec|snap|import|export\` (hosted sessions with the GPU lane on, or \`blender serve\` on your own machine; the \`genex-blender-scene\` skill owns it) \xB7 \`animations search\` \xB7 \`wait <id>\` / \`wait --all\` \xB7 \`preview\` / \`publish\` \xB7 \`rename <name>\` (move the game to a new address \u2014 keeps its plays and likes, kills the old link, needs \`--yes\` once published, and the game must be rebuilt after). Full options: \`npx genex --help\`. There is NO sky generator: every sky, horizon, time of day and weather mood is built in code \u2014 your call how, from a background colour and fog to an atmospheric sky shader with a real sun. It costs nothing, weighs nothing on phones, and keeps the sun in sync with the scene's own lighting, which a painted panorama never can. Task\u2192lane routing lives in the \`genex-game-director\` skill's routing map \u2014 load the owning row before the first file of each subsystem, and re-load the map after any compaction.
 
 Important note: put soul into your creations, with many details and love. Aim to make them realistic and feel real. Reach for genex capabilities by default \u2014 they are how the world gets real assets (law 22) \u2014 but never limit your imagination \u2014 you are a powerful agent. Use your built-in sub-agents and iteration loops (\`/loop\` or your platform's equivalent) where you need them to reach outstanding results. Verify yourself. Anything you put in front of the player should already feel alive and impressive \u2014 never a bare scene waiting for "later". Build what's still missing before polishing what already works.
 
@@ -20613,7 +20613,7 @@ async function runMotion(opts) {
 // src/commands/blender.ts
 import fs23 from "fs/promises";
 import path22 from "path";
-var SUBS2 = ["demo", "exec", "snap", "scene", "export", "reset", "mcp", "serve"];
+var SUBS2 = ["demo", "exec", "snap", "scene", "import", "export", "reset", "mcp", "serve"];
 var DEFAULT_OUT_DIR = "assets/blender";
 async function writeB64(dir, name, b64) {
   await fs23.mkdir(dir, { recursive: true });
@@ -20644,7 +20644,7 @@ async function runBlender(opts) {
     return serveLocalBlender({ port, log });
   }
   if (sub === "mcp") {
-    const { runBlenderMcp } = await import("./blender-mcp-LLN4FPA4.js");
+    const { runBlenderMcp } = await import("./blender-mcp-3U5AG7WS.js");
     return runBlenderMcp();
   }
   let base = blenderEndpoint();
@@ -20659,8 +20659,8 @@ async function runBlender(opts) {
     return 1;
   }
   if (!base) {
-    const [first, ...rest] = BLENDER_SETUP_HINT.split("\n");
-    log.error(first ?? "GENEX_BLENDER_URL is not set");
+    const [first, ...rest] = blenderSetupHint().split("\n");
+    log.error(first ?? "No Blender endpoint");
     log.plain(rest.join("\n"));
     return 1;
   }
@@ -20706,12 +20706,31 @@ async function runBlender(opts) {
     case "export": {
       const target = opts.out ?? path22.join(outDir, "scene.glb");
       const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
+      if (!r.glbBase64) {
+        log.error(`/export answered with no GLB bytes${r.uploaded ? " (it was uploaded, not inlined)" : ""}`);
+        return 1;
+      }
       await fs23.mkdir(path22.dirname(target), { recursive: true });
-      await fs23.writeFile(target, Buffer.from(r.glbBase64 ?? "", "base64"));
+      await fs23.writeFile(target, Buffer.from(r.glbBase64, "base64"));
       log.success(`Exported ${r.bytes ?? 0} bytes`);
       log.plain(`  ${c.cyan(target)}`);
       return 0;
     }
+    case "import": {
+      const url = opts.importUrl?.trim();
+      if (!url || !/^https?:\/\//.test(url)) {
+        log.error("genex blender import needs a GLB URL: genex blender import https://\u2026/model-glb");
+        return 1;
+      }
+      const r = await blenderCall(base, "/import", { url });
+      log.success(`imported ${r.count ?? 0}: ${(r.imported ?? []).join(", ") || "(nothing)"}`);
+      const snap = await blenderCall(base, "/render", { ...mode ? { mode } : {}, sheet: { formats: SHEET_FORMATS } });
+      const sheet = sheetOf(snap);
+      if (sheet) log.plain(`  ${c.cyan(await writeB64(outDir, `contact-sheet.${sheetExt(sheet.mime)}`, sheet.b64))}`);
+      const info = await blenderCall(base, "/scene");
+      reportScene(log, info);
+      return 0;
+    }
     case "exec":
     case "demo": {
       let script;
@@ -21734,6 +21753,13 @@ ${c.bold("Usage")}
                                      signature move. --lean keeps movement to forward
                                      walk + run (enemies follow a path).
   genex animations search "<intent>" Search Meshy's animation library by gameplay intent.
+  genex blender <verb>               Compose a level or interior in a live Blender \u2014
+                                     scene | exec --in <file.py> | snap [--mode \u2026] |
+                                     import <glb-url> | export --out <file.glb> | reset.
+                                     Hosted sessions get a GPU seat on first use; at a
+                                     terminal run 'genex blender serve' against your
+                                     own Blender. Every scene change writes
+                                     ./assets/blender/contact-sheet.webp \u2014 look at it.
   genex wait <id>                    Attach to a generation enqueued with --no-wait and
                                      print its asset URL(s) when it finishes. Safe to
                                      re-run \u2014 it never creates a new generation.
@@ -22430,6 +22456,13 @@ function parseArgs(argv) {
             parsed.error = `Unexpected argument: ${arg}`;
             return parsed;
           }
+        } else if (parsed.command === "blender") {
+          if (parsed.options.name === "import" && parsed.options.importUrl === void 0) {
+            parsed.options.importUrl = arg;
+          } else {
+            parsed.error = `Unexpected argument: ${arg}`;
+            return parsed;
+          }
         } else {
           parsed.error = `Unexpected argument: ${arg}`;
           return parsed;
@@ -22950,9 +22983,8 @@ async function main() {
       case "ui":
         await runUi({ ...parsed.options, sub: parsed.options.name });
         break;
-      // HIDDEN from --help: the M1 test surface for the Blender service spike
-      // (apps/blender-service). Gated on GENEX_BLENDER_URL, which no hosted
-      // stand sets, so this is a local-only verb until that service is real.
+      // The Blender surface (apps/blender-service): a hosted seat, an explicit
+      // GENEX_BLENDER_URL, or `blender serve` — see commands/blender.ts.
       case "blender":
         process.exitCode = await runBlender({ ...parsed.options, sub: parsed.options.name });
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.13.2-dev.559",
+  "version": "1.14.0-dev.560",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-blender-scene/SKILL.md

@@ -0,0 +1,222 @@
+---
+name: genex-blender-scene
+description: Compose a level, arena, interior, building or map — a SPACE of rooms, lanes, walls and sites that must relate — in a live Blender with `npx genex blender`, then export one GLB the game walks through. Use when the request is a place to move through (from a description or a floor plan), not a single prop; probe the lane first and build the same space in code if it is off.
+---
+
+# Genex Blender · Scene
+
+Build the game's SPACE in a real Blender that answers over HTTP: write a Python
+script, run it, read the numbers, look at the four-view sheet, repeat — then
+export one GLB and load it like any model. The scene persists between steps, so a
+level grows the way a level is actually built: shell, then zones, then dressing.
+
+## When this lane owns the work
+
+- A **space**: a level, arena, interior, building, map, dungeon, station — several
+  rooms, lanes, walls or sites that must relate to each other, and a player who
+  moves through them.
+- A **floor plan or reference** to trace (a sketch, an ASCII plan, a photo of a room).
+- A **blockout**: the playable shape first, dressing later.
+
+Not this lane:
+
+- One recognisable object (a barrel, a cart, a statue) → `$genex-ai-model`.
+- One parameterized object placed many times with variation, or a stylized shader
+  material → `$genex-threejs-procedural-assets`.
+- The player's body, creatures, animation → `$genex-ai-character`,
+  `$genex-threejs-creatures`. Terrain from a heightmap → code.
+
+Mixing all three in one scene is normal: the Blender level is the architecture, a
+generated GLB is the hero piece, code is the repeated dressing.
+
+## Is the lane on? Probe by doing
+
+```bash
+npx genex blender scene
+```
+
+Read the answer literally — there are three:
+
+1. **A scene JSON prints** → the lane is on. Continue.
+2. `Warming up a Blender seat…` and then `The Blender seat is still warming up. Run
+   the same command again in a minute.` → **not done yet**, even though the command
+   exited cleanly. A GPU is booting for you (about 20 s on a warm pod, a few
+   minutes on a cold one). Write your first script meanwhile, then run the command
+   again. Never read this line as success, and never read it as failure.
+3. `The Blender lane is off on this stand` or `No Blender seat: fleet_full` → build
+   the same space **in code** with `$genex-threejs-procedural-assets`, say so in one
+   plain line to the player, and keep going. Do not wait, do not ask.
+
+The seat, once granted, is remembered in `.genex/blender-seat.json` — later
+commands are silent about it.
+
+## The loop
+
+Scripts are the level's source. Keep them in the project, one per zone:
+
+```
+blender/01-shell.py      walls, floor, towers
+blender/02-gatehouse.py
+blender/03-courtyard.py
+…
+```
+
+Run one:
+
+```bash
+npx genex blender exec --in blender/01-shell.py
+```
+
+Every run prints two things and writes one file:
+
+- **The numbers** — `objects N  meshes N  tris N  materials N  radius N`. This is
+  the gate. Before you run, know what the script should produce (twelve objects,
+  about 4k tris, radius ≈ 40); after, compare. A render judge is unreliable for
+  pass/fail; the numbers are not.
+- **The sheet** — `assets/blender/contact-sheet.webp`, four fixed views (front,
+  side, TOP, hero) from cameras derived from the scene bounds, so two steps compare
+  pixel for pixel. **Open it with your file-reading tool after every step.** The
+  TOP view is the floor-plan check; the hero view is the mood check. Nothing shows
+  it to you unless you look.
+- Script `print()` output comes back as stdout; a raised exception comes back with
+  its traceback AND the sheet of the half-built scene, which is usually where the
+  bug is visible.
+
+The Python namespace **persists between runs** (`bpy`, `bmesh`, `mathutils`,
+`math`, `random` are preloaded): define `mat()` and `box()` helpers once in the
+first script and use them in every later one. If a run says the service restarted
+and the scene was restored from a checkpoint, re-read the numbers — your last step
+may be missing; re-run that one script.
+
+Other verbs:
+
+```bash
+npx genex blender snap --mode wireframe   # topology; also normals | solid | lit
+npx genex blender scene                   # the full graph as JSON, when a number surprises you
+npx genex blender reset                   # empty scene (the namespace resets too)
+```
+
+Keep each step under about 90 seconds of Blender time: a script that loops
+hundreds of boolean cuts is killed at the deadline and the scene comes back from
+the last checkpoint. Split heavy work across scripts. A level is 8–15 steps, not 50.
+
+## Craft rules that decide whether the export works
+
+- **Metres.** Floor at `z = 0`, the map's centre at the origin. Blender is Z-up;
+  the export converts to Y-up, so the floor is the XZ plane in Three.js and a
+  Blender `(x, y, z)` lands at `(x, z, -y)`.
+- **Name everything** `<zone>_<thing>` (`gate_portcullis`, `hall_table_1`). Names
+  survive the export and are how the game finds parts.
+- **Materials: few and flat.** Six to eight for a whole level, one per surface
+  family (stone, dark stone, wood, roof, iron, glow). Set the Principled BSDF base
+  colour **and** `material.diffuse_color` — the sheet's fallback renderer reads the
+  second, and a scene that sets only the first exports with correct colours and
+  renders entirely grey. No image textures: they do not fit the export ceiling, and
+  an asset URL does not export.
+- **Repetition by loop, never by an unapplied modifier.** Crenellations, columns,
+  pews: a Python `for`. An Array modifier that is not applied is not in the GLB.
+- **Tri budget.** Keep the whole level under ~150k triangles and use 12–16 segments
+  on cylinders — phones load this file too. The export refuses above 6 MB; treat
+  that as "no longer a game asset", not as a limit to work around.
+- **Markers.** Empties export as named nodes: `bpy.data.objects.new("spawn", None)`
+  placed and linked into the scene collection, likewise `key_1`, `door_crypt`,
+  `patrol_1`. The level tells the game where things go; the game reads them with
+  `scene.getObjectByName("spawn")`.
+- **Lights stay in the game.** Blender lights do not export usefully; light the
+  level in Three.js (a hemisphere + a sun, point lights at torches and hearths).
+- **Collision is the game's.** Static level geometry gets Rapier trimesh colliders
+  per mesh — `$genex-threejs-physics-rapier`. If a mesh is too dense to collide
+  against, add a simplified `col_<zone>` box in Blender and keep the visual one out
+  of physics.
+
+A minimal first script, the shape every later one follows:
+
+```python
+import bpy
+bpy.ops.wm.read_factory_settings(use_empty=True)
+
+def mat(name, rgb, rough=0.85):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    b = m.node_tree.nodes["Principled BSDF"]
+    b.inputs["Base Color"].default_value = (*rgb, 1.0)
+    b.inputs["Roughness"].default_value = rough
+    m.diffuse_color = (*rgb, 1.0)   # BOTH, or the sheet renders grey
+    return m
+
+def box(name, loc, half, m):
+    bpy.ops.mesh.primitive_cube_add(size=2.0, location=loc)
+    o = bpy.context.active_object
+    o.name, o.scale = name, half
+    o.data.materials.append(m)
+    return o
+
+STONE = mat("Stone", (0.46, 0.44, 0.41))
+box("yard_floor", (0, 0, -0.25), (35, 35, 0.25), mat("Ground", (0.30, 0.28, 0.24)))
+for sx, sy in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+    bpy.ops.mesh.primitive_cylinder_add(radius=3, depth=14, vertices=16,
+                                        location=(sx * 35, sy * 35, 7))
+    t = bpy.context.active_object
+    t.name = f"tower_{sx}_{sy}"
+    t.data.materials.append(STONE)
+print("shell:", len(bpy.context.scene.objects), "objects")
+```
+
+## Hero pieces from `genex model`
+
+```bash
+npx genex model "weathered stone knight effigy on a tomb, medieval"   # prints a URL
+npx genex blender import https://assets.genex.technology/generations/<id>/model-glb
+```
+
+`import` prints the object names it added and renders a fresh sheet; place and
+scale them in the next `exec` (`bpy.data.objects["…"].location = (…)`). Import
+when the piece must be composed WITH the architecture (a gate in a wall, a statue
+in a niche). When it is dressing, skip the import: drop a marker in Blender and
+load the GLB in Three.js at that marker — it keeps the level file small.
+
+## Export and load
+
+```bash
+npx genex blender export --out public/assets/level.glb
+```
+
+Load it like any GLB. The quality kit's rung ladder applies only to generated
+`/generations/` URLs, so this file loads as-is — the tri and material budgets
+above are what keep it phone-safe.
+
+```ts
+import { createGltfLoader } from "./controllers/quality/gltf-loader.ts";
+
+const gltfLoader = createGltfLoader(renderer);
+const level = await gltfLoader.loader.loadAsync("/assets/level.glb");
+level.scene.traverse((o) => {
+  if ((o as THREE.Mesh).isMesh) { o.castShadow = true; o.receiveShadow = true; }
+});
+scene.add(level.scene);
+const spawn = level.scene.getObjectByName("spawn");
+```
+
+Then colliders (`$genex-threejs-physics-rapier`), the player
+(`$genex-threejs-character-controller`), lights, and a real screenshot check
+(`$genex-threejs-visual-validation`). Record the level in `DESIGN.md`'s Assets as
+`local Blender build — scripts under blender/`, never a provider generation id.
+
+## Money
+
+The seat bills a few credits **per minute while it is held, idle or not**, and it
+ends with the session — there is no close command. So build the level in one
+sitting: shell → zones → hero pieces → export, then move on to the game. Batch
+changes into fewer, larger scripts; every step renders one sheet.
+
+## Troubleshooting
+
+- `payload_too_large` on export → fewer cylinder segments, delete faces the player
+  never sees, or export two GLBs (`--out public/assets/level-a.glb`).
+- The sheet is grey → `material.diffuse_color` was not set (see above).
+- `refused the seat token (401)` → the seat was closed (the session rested, or the
+  pod was replaced); run the same command again — it re-acquires, and a replaced
+  pod restores your scene from its checkpoint.
+- `seat_not_ready` → the pod is still booting; run again shortly.
+- The numbers are right but the top view is wrong → coordinates: `y` in Blender is
+  depth, and `scale` on a 2-unit cube is the half-size.

package/templates/skills/genex-game-director/SKILL.md

@@ -132,6 +132,7 @@ vendored code from memory of another engine.
 | phone-survivable rendering: device tiers, DPR/shadow/post budgets, runtime governor, generated-asset rungs, Quality picker, dispose-on-swap | `$genex-threejs-adaptive-quality` |
 | anything falls, collides, gets pushed, or needs colliders/events | `$genex-threejs-physics-rapier` |
 | launch/docking timelines, authored transform phases, springs, convergence, deterministic prop/debris motion | `$genex-threejs-procedural-animation` |
+| a level, arena, interior, building or map to walk through — a composed space of rooms, lanes, walls and sites, from a description or a floor plan; a blockout | `$genex-blender-scene` — probe the lane first (`npx genex blender scene`); when it is off, the same space is built as code via `$genex-threejs-procedural-assets` |
 | rebuild a reference prop, hard-surface object, modular decoration, or structural environment piece (kits, fences, walls, paving) as editable parameterized Three.js code — held to the asset bar at the end of this section | `$genex-threejs-procedural-assets` |
 | stylized/abstract shader-authored materials, the procedural/PBR material boundary | `$genex-threejs-procedural-assets` |
 | particles, trails, plasma, shockwaves, pooled bursts, and event effects | `$genex-threejs-procedural-vfx` |
@@ -164,8 +165,10 @@ honestly fit: a generated GLB built from the picture itself
 (`npx genex model --image <path>`), or editable parameterized Three.js code.
 If the request says procedural, parametric, code-built, reusable variations,
 or names a GLB, start the corresponding route directly. An image alone never
-auto-triggers the procedural lane. Player bodies, rigged characters/creatures,
-and animation stay with their protected owners.
+auto-triggers the procedural lane. A floor plan, a room photo or a map sketch
+is a SPACE, not an object: it goes to `$genex-blender-scene` with no route
+question. Player bodies, rigged characters/creatures, and animation stay with
+their protected owners.
 
 If a procedural request has a private reference, use it locally and do not
 upload, publish, or commit it without explicit permission. If no reference was

package/templates/skills/genex-game-director/references/routing-map.md

@@ -107,7 +107,10 @@ parametric, or code-built work. It is a first-class lane, not a fallback, held
 to the same bar as a generated GLB, and mixing it with generated GLBs in one
 scene is the normal way to build a detailed world. An image alone still doesn't decide the route (ask the one
 route question when both honestly fit), and never use it for player bodies,
-rigged characters/creatures, or animation.
+rigged characters/creatures, or animation. An OBJECT is this lane's unit; a
+SPACE the player moves through — a level, an interior, a whole building — is
+`$genex-blender-scene`'s, which falls back to this lane when the Blender lane
+is off on the stand.
 
 - Prefer a supplied reference. A private attachment stays local unless the
   player explicitly permits upload, publication, or commit.