@volter/game-editor 0.5.68 → 0.5.70

package/template/.github/skills/editor/references/editor-control.md

@@ -4,14 +4,14 @@
 
 - [CLI invocation](#cli-invocation--use-the-project-local-cli)
 - [Quick start](#quick-start)
-- [Connection precondition](#precondition-most-verbs-need-a-connected-browser-tab-not-just-vgai-edit-running)
-- [**Drive the running game — `npx volter-game-editor eval`**](#drive-the-running-game--vgai-eval-the-general-door)
+- [Connection precondition](#precondition-most-verbs-need-a-connected-browser-tab-not-just-volter-edit-running)
+- [**Drive the running game — `npx volter-game-editor eval`**](#drive-the-running-game--volter-eval-the-general-door)
 - [CLI reference](#cli-reference)
 - [Entity IDs](#entity-ids)
 - [Typical workflows](#typical-workflows)
 - [SDK](#sdk-programmatic-access)
 
-Use the `vgai` CLI to create projects, launch the editor, and control it programmatically. The editor is a browser-based WebGL app; the CLI sends commands to it over HTTP.
+Use the `volter` CLI to create projects, launch the editor, and control it programmatically. The editor is a browser-based WebGL app; the CLI sends commands to it over HTTP.
 
 **Driving a running GAME is a different question from driving the editor**, and
 it has one answer: `npx volter-game-editor eval`. Read that section before the verb list — the
@@ -19,31 +19,31 @@ verbs cover the editor, and a game's own commands are never verbs.
 
 ## CLI invocation — use the project-local CLI
 
-Inside this scaffold, invoke every CLI verb as `npm run --silent vgai -- <verb>`. The
+Inside this scaffold, invoke every CLI verb as `npm run --silent volter -- <verb>`. The
 script points at the versioned `@volter/game-editor` installed with this project. Never
-use a bare global `vgai` command here: another installation can own that binary
+use a bare global `volter` command here: another installation can own that binary
 and can silently target the wrong session or apply different manifest rules.
 
 ## Quick Start
 
 ```bash
-npm run --silent vgai -- create "My Game" # Scaffold a new project in ./my-game
+npm run --silent volter -- create "My Game" # Scaffold a new project in ./my-game
 cd my-game
-npm run --silent vgai -- edit .           # Launch editor + open browser
-npm run --silent vgai -- play             # Enter play mode
-npm run --silent vgai -- restart          # Remount all game roots — acks only when the session is READY
+npm run --silent volter -- edit .           # Launch editor + open browser
+npm run --silent volter -- play             # Enter play mode
+npm run --silent volter -- restart          # Remount all game roots — acks only when the session is READY
                                  # again (relay up, tab attached, play measured running); exits
                                  # non-zero naming the gap otherwise. No sleep-then-play dance.
-npm run --silent vgai -- status           # Check editor state
-npm run --silent vgai -- eval --list      # Everything you can drive — ask this FIRST
+npm run --silent volter -- status           # Check editor state
+npm run --silent volter -- eval --list      # Everything you can drive — ask this FIRST
 ```
 
 **Port cross-talk:** the default editor port (5173) is shared across every
-VGAI project on the machine. `npm run --silent vgai -- edit .` never silently retargets a
+Volter project on the machine. `npm run --silent volter -- edit .` never silently retargets a
 DIFFERENT project's already-running editor — if one is already open
 elsewhere, this one starts a second instance on a fresh free port and prints
 that URL instead (use `--switch` to retarget the existing one on purpose).
-If you might have another vgai project's tab open in the browser already,
+If you might have another volter-game-editor project's tab open in the browser already,
 don't assume it's this project: read the URL `npx volter-game-editor edit` actually prints
 (check `npx volter-game-editor sessions` to see every live session's port → project), or pass
 `npx volter-game-editor edit --port <n>` to pin an explicit port for this project so a stale
@@ -74,7 +74,7 @@ one legitimate case is a fully unattended CI job that then drives the
 editor itself, e.g. via Playwright:
 
 ```bash
-npm run --silent vgai -- edit . --no-open # ONLY when no human could be watching (e.g. CI)
+npm run --silent volter -- edit . --no-open # ONLY when no human could be watching (e.g. CI)
 ```
 
 ```ts
@@ -85,7 +85,7 @@ npm run --silent vgai -- edit . --no-open # ONLY when no human could be watching
 await page.goto('http://localhost:5173', { waitUntil: 'load' });
 ```
 
-Once that page has loaded, it registers as a connected client and `vgai
+Once that page has loaded, it registers as a connected client and `volter-game-editor
 status`/`npx volter-game-editor play`/etc. from another shell will reach it for real.
 
 ## Drive the running game — `npx volter-game-editor eval`, the general door
@@ -97,12 +97,12 @@ is no command registry, provider registry, or fixed game vocabulary to learn.
 `{ editor, game, page, tools, session }` from `@volter/game-live` already in scope:
 
 ```bash
-npm run --silent vgai -- eval --list                     # what's in scope (no session needed)
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const arena = await modules("src/sim/arena.ts"); return arena.readArena(); })'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const arena = await modules("src/sim/arena.ts"); arena.setupBossWave(); return arena.readArena(); })'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("sweep"); })'
-npm run --silent vgai -- eval 'await game.waitSimTime({simSeconds: 4})'
-npm run --silent vgai -- eval 'await editor.grid(false)' # the editor half, same door
+npm run --silent volter -- eval --list                     # what's in scope (no session needed)
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const arena = await modules("src/sim/arena.ts"); return arena.readArena(); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const arena = await modules("src/sim/arena.ts"); arena.setupBossWave(); return arena.readArena(); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("sweep"); })'
+npm run --silent volter -- eval 'await game.waitSimTime({simSeconds: 4})'
+npm run --silent volter -- eval 'await editor.grid(false)' # the editor half, same door
 ```
 
 `--list` walks the live binding objects themselves rather than a written list,
@@ -112,7 +112,7 @@ template's `src/tools/use-game-modules.ts` shows how a literal contribution
 reads the exact same running instances.
 
 **NEVER pilot a realtime game from the developer REPL, with synthetic key
-events, rAF loops, wall-clock sleeps, or direct `window.__vgai*`/scene-graph
+events, rAF loops, wall-clock sleeps, or direct `window.__volter*`/scene-graph
 reads.** Arrange expensive preconditions with exported setup functions, then
 hire the resident tester to act through the game's real input store.
 `waitSimTime` advances deterministically even while the editor tab is HIDDEN.
@@ -137,9 +137,9 @@ providers every other tool reads.
 ### Project Management (no running editor needed)
 
 ```bash
-npm run --silent vgai -- create <name> [location]   # Empty project (default location: ./<name>)
-npm run --silent vgai -- create <name> [location] --template game # Game composition; also empty, website, models
-npm run --silent vgai -- edit [project-path]        # Launch editor for project (default: cwd).
+npm run --silent volter -- create <name> [location]   # Empty project (default location: ./<name>)
+npm run --silent volter -- create <name> [location] --template game # Game composition; also empty, website, models
+npm run --silent volter -- edit [project-path]        # Launch editor for project (default: cwd).
                                            # Reuses the session already serving THIS
                                            # project; otherwise starts a NEW instance on
                                            # a free port rather than silently retargeting
@@ -148,15 +148,15 @@ npm run --silent vgai -- edit [project-path]        # Launch editor for project
                                            #   --switch    retarget an existing instance
                                            #               instead of starting a new one
                                            #   --port <n>  force a port for a fresh instance
-npm run --silent vgai -- sessions                   # List live editor sessions (port -> project)
+npm run --silent volter -- sessions                   # List live editor sessions (port -> project)
 ```
 
 ### Scene & Project Info (needs running editor)
 
 ```bash
-npm run --silent vgai -- open <path>      # Switch project in running editor
-npm run --silent vgai -- project          # Show current project info
-npm run --silent vgai -- projects         # List recent projects
+npm run --silent volter -- open <path>      # Switch project in running editor
+npm run --silent volter -- project          # Show current project info
+npm run --silent volter -- projects         # List recent projects
 ```
 
 `open` / `project` / `projects` stay first-class for a concrete reason: project
@@ -166,11 +166,11 @@ management lives on `EditorClient` and was never lifted onto `@volter/editor-liv
 ### Play Control
 
 ```bash
-npm run --silent vgai -- play             # Enter play mode
-npm run --silent vgai -- restart          # Dispose + remount every game root — waits out a relaunching dev
+npm run --silent volter -- play             # Enter play mode
+npm run --silent volter -- restart          # Dispose + remount every game root — waits out a relaunching dev
                                  # server, re-ensures the one tab, and acks only once play is
                                  # measured running (a failure names the next step)
-npm run --silent vgai -- stop             # Exit play mode
+npm run --silent volter -- stop             # Exit play mode
 ```
 
 `pause` / `resume` / `step` were REMOVED — `npx volter-game-editor eval 'editor.pause()'`,
@@ -191,16 +191,16 @@ exposes, so they were deleted rather than kept as aliases. Typing one now
 errors with its exact replacement:
 
 ```bash
-npm run --silent vgai -- eval 'editor.select("<entityId>")'   # or "all"
-npm run --silent vgai -- eval 'editor.deselect()'
-npm run --silent vgai -- eval 'editor.focus("<entityId>")'    # omit arg = current selection
-npm run --silent vgai -- eval 'editor.view("top")'            # top|front|right|perspective
-npm run --silent vgai -- eval 'editor.showPanel("inspector")' # viewport|inspector|console|build
-npm run --silent vgai -- eval 'editor.openAsset("<path>", "<kind>")'
-npm run --silent vgai -- eval 'editor.grid(false)'
-npm run --silent vgai -- eval 'editor.helpers(true)'
-npm run --silent vgai -- eval 'editor.stats(true)'
-npm run --silent vgai -- eval 'editor.shading("wireframe")'   # solid|unlit|wireframe|normals|overdraw
+npm run --silent volter -- eval 'editor.select("<entityId>")'   # or "all"
+npm run --silent volter -- eval 'editor.deselect()'
+npm run --silent volter -- eval 'editor.focus("<entityId>")'    # omit arg = current selection
+npm run --silent volter -- eval 'editor.view("top")'            # top|front|right|perspective
+npm run --silent volter -- eval 'editor.showPanel("inspector")' # viewport|inspector|console|build
+npm run --silent volter -- eval 'editor.openAsset("<path>", "<kind>")'
+npm run --silent volter -- eval 'editor.grid(false)'
+npm run --silent volter -- eval 'editor.helpers(true)'
+npm run --silent volter -- eval 'editor.stats(true)'
+npm run --silent volter -- eval 'editor.shading("wireframe")'   # solid|unlit|wireframe|normals|overdraw
 ```
 
 The advantage is not brevity — it is that one door composes. Selecting an
@@ -208,7 +208,7 @@ entity, framing it, and capturing the result is a single round trip instead of
 four processes:
 
 ```bash
-npm run --silent vgai -- eval 'await editor.select(id); await editor.focus(); await editor.shading("wireframe"); return editor.screenshot()'
+npm run --silent volter -- eval 'await editor.select(id); await editor.focus(); await editor.shading("wireframe"); return editor.screenshot()'
 ```
 
 Shading is temporary, render-only editor state: it never rewrites scene or
@@ -222,7 +222,7 @@ bounds toggles; use `setHelperType()` through the SDK when you need one category
 ### State
 
 ```bash
-npm run --silent vgai -- status           # Print full editor state as JSON
+npm run --silent volter -- status           # Print full editor state as JSON
 ```
 
 The `status` command returns:
@@ -240,9 +240,9 @@ The `status` command returns:
 ### Verification — the LIVE playtest, in as many seats as it needs
 
 ```bash
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); mechanic.<setup>(); return mechanic.<read>(); })'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("<goal>"); })'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.describeTester(); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); mechanic.<setup>(); return mechanic.<read>(); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("<goal>"); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.describeTester(); })'
 ```
 
 Verification IS the interactive playtest: cheats set the situation, the
@@ -270,7 +270,7 @@ functions, which is exactly why the door is general.
 
 ```bash
 --url <url>                      # Editor URL (default: http://localhost:5173)
-                                 # Also: VGAI_EDITOR_URL env var
+                                 # Also: VOLTER_EDITOR_URL env var
 ```
 
 ## Entity IDs
@@ -278,7 +278,7 @@ functions, which is exactly why the door is general.
 Entity ids are minted by the active authoring adapter (a three world's are
 keyed on the OID its source carries — stable across reloads). To find one:
 
-1. `npm run --silent vgai -- eval 'return editor.hierarchy()'` — the hierarchy panel's
+1. `npm run --silent volter -- eval 'return editor.hierarchy()'` — the hierarchy panel's
    rows as data, each with its `id` and label
 2. Use that id with `editor.select("<id>")` / `editor.focus("<id>")` through
    `npx volter-game-editor eval`
@@ -288,29 +288,29 @@ keyed on the OID its source carries — stable across reloads). To find one:
 ### Start a new project from scratch
 
 ```bash
-npm run --silent vgai -- create "My Platformer"
+npm run --silent volter -- create "My Platformer"
 cd my-platformer
-npm run --silent vgai -- edit .
+npm run --silent volter -- edit .
 ```
 
 ### Show the user an entity you just created/modified
 
 ```bash
 # After editing the world's TSX source — select and frame the entity in one round trip:
-npm run --silent vgai -- eval 'await editor.select("<entity-id>"); await editor.focus()'
+npm run --silent volter -- eval 'await editor.select("<entity-id>"); await editor.focus()'
 ```
 
 ### Test gameplay
 
 ```bash
-npm run --silent vgai -- play
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); mechanic.<setup>(); return mechanic.<read>(); })'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("<goal>"); })'
-npm run --silent vgai -- eval 'await game.waitSimTime({simSeconds: 5})'
-npm run --silent vgai -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); return mechanic.<read>(); })'
-npm run --silent vgai -- screenshot                            # and LOOK at the pixels
-npm run --silent vgai -- restart                               # after an init-time source change
-npm run --silent vgai -- stop
+npm run --silent volter -- play
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); mechanic.<setup>(); return mechanic.<read>(); })'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const tester = await modules("src/bot/tester-station.ts"); return tester.hireTester("<goal>"); })'
+npm run --silent volter -- eval 'await game.waitSimTime({simSeconds: 5})'
+npm run --silent volter -- eval 'return game.run(async ({ modules }) => { const mechanic = await modules("src/sim/<mechanic>.ts"); return mechanic.<read>(); })'
+npm run --silent volter -- screenshot                            # and LOOK at the pixels
+npm run --silent volter -- restart                               # after an init-time source change
+npm run --silent volter -- stop
 ```
 
 Arrange and read through the mechanic's own exported functions; let the
@@ -321,7 +321,7 @@ disagrees.
 ### Debug a specific view angle
 
 ```bash
-npm run --silent vgai -- eval 'await editor.view("top"); await editor.shading("wireframe"); await editor.helpers(true)'
+npm run --silent volter -- eval 'await editor.view("top"); await editor.shading("wireframe"); await editor.helpers(true)'
 ```
 
 ## SDK (Programmatic Access)
@@ -358,6 +358,6 @@ the right import for editor-only automation that has no game running — plus th
 handful of project-management calls (`createProject()`, `openProject()`,
 `getProject()`, `listRecentProjects()`) that `@volter/editor-live` does not re-expose.
 
-Run `npm run --silent vgai -- eval --list` for the current member list on every binding.
+Run `npm run --silent volter -- eval --list` for the current member list on every binding.
 It walks the live objects at runtime, so it is accurate in a way this page
 cannot promise to be.

package/template/{.claude/skills/vgai-3d-models → .github/skills/volter-3d-models}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: vgai-3d-models
+name: volter-3d-models
 description: Model and revise game props with ordinary Blender Python through the Blender MCP and export the asset for a reusable Three.js prefab. Use when asked to model a prop, shape, machine, or other game object. For placement, stories and gameplay follow .agents/references/project-manual.md; for procedural geometry generated during gameplay use ordinary Three.js.
 ---
 
@@ -12,7 +12,7 @@ Blender coordinates are **Z-up**, distances are metres, and angles are radians.
 
 Start the game's editor with `npm run dev` **in the background**, keep it running
 while authoring, and tell the user its URL. Connect the project's `blender`
-server in `.mcp.json` (`npm run --silent vgai -- blender-mcp`).
+server in `.mcp.json` (`npm run --silent volter -- blender-mcp`).
 The **Model** document is your Blender viewport; the **Scene** composes game
 objects. Inspect the model there, then inspect its placement in the game.
 
@@ -43,7 +43,7 @@ For an asset revision, edit it in Blender and re-export to the same asset path.
 Check its game placements and preserve the selected starter's studio and
 verification requirements. Before handoff, run the game's build and inspect the
 exported game. Keep input assets and runtime exports in version control;
-keep scratch files in `.vgai/tmp/`.
+keep scratch files in `.volter/tmp/`.
 
 For animation and skinning, a static mesh export is not proof that an animated
 character is game-ready.

package/template/{.claude/skills/vgai-ingest-existing-game → .github/skills/volter-ingest-existing-game}/SKILL.md

@@ -1,8 +1,8 @@
 ---
-name: vgai-ingest-existing-game
+name: volter-ingest-existing-game
 description: >
   Take an existing, unmodified web game (three.js, PixiJS, or React) to FULL
-  vgai editor integration: mount it through the adapter seam, declare its
+  volter editor integration: mount it through the adapter seam, declare its
   real capabilities through the game contract, drive every adapter slot to a
   terminal state (implemented, or verified implemented-empty), and prove it
   live through the product's own doors. Use when asked to ingest, adapt,
@@ -30,7 +30,7 @@ orders. Mounting the game is STEP ONE of seven, not the deliverable.
   objects; the navigation slots show the host-computation form (host BFS
   over the game's own public graph, labeled as the host's in so many
   words).
-- The contract shapes: `packages/project/src/adapter/ingest/game-contract.ts`
+- The contract shapes: `packages/editor-project/src/adapter/ingest/game-contract.ts`
   (root · lifecycle · systems.commands/state/hierarchy · systemAdapters) and
   `contract-system-adapters.ts` (the projection that rejects malformed
   claims — a `present` missing required members, or an `empty` without

package/template/{.agents/skills/vgai-threejs-authoring → .github/skills/volter-threejs-authoring}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: vgai-threejs-authoring
-description: Build, rig, animate, diagnose, and visually refine polished native Three.js scenes and procedural assets with direct Object3D code, reusable construction helpers, geometry libraries, and an inspect-render-critique loop. Use for procedural models, rigid mechanical armatures, environments, static props, stylized materials, lighting, cameras, scene composition, or an agent-focused Blender-like workflow. Use vgai-3d-models when the result should be a Blender source document with an exported GLB. Do not use for Blender bpy work or imported skeletal retargeting.
+name: volter-threejs-authoring
+description: Build, rig, animate, diagnose, and visually refine polished native Three.js scenes and procedural assets with direct Object3D code, reusable construction helpers, geometry libraries, and an inspect-render-critique loop. Use for procedural models, rigid mechanical armatures, environments, static props, stylized materials, lighting, cameras, scene composition, or an agent-focused Blender-like workflow. Use volter-3d-models when the result should be a Blender source document with an exported GLB. Do not use for Blender bpy work or imported skeletal retargeting.
 ---
 
-# VGAI Three.js Authoring
+# Volter Three.js Authoring
 
 Author ordinary project source against Three.js. Treat the source module and
 live `Object3D` graph as truth. Use helpers for leverage, not as a replacement
@@ -14,7 +14,7 @@ scene language.
 1. Read the project instructions and architecture.
 2. Locate the Three root or modeling build entry, existing helpers,
    renderer setup, and verification commands.
-3. Start or reuse the VGAI editor immediately and keep it open.
+3. Start or reuse the Volter editor immediately and keep it open.
 4. Capture a fixed-camera visual baseline.
 5. Inspect the live hierarchy, selected-object facts, renderer state, and
    console before changing code.
@@ -23,7 +23,7 @@ Never introduce a parallel entity tree, semantic operation log, generated
 scene JSON, or wrapper around ordinary Three.js access for agent control. Give
 important objects stable `Object3D.name` values or project metadata.
 
-Use `vgai-3d-models` for Blender-sourced assets; prefab placement, stories and the
+Use `volter-3d-models` for Blender-sourced assets; prefab placement, stories and the
 naming floor are in `.agents/references/project-manual.md`.
 
 ## Choose the lowest sufficient layer
@@ -67,7 +67,7 @@ Use raw Three.js whenever a helper becomes awkward.
 Keep shader source in ordinary `.vert`, `.frag`, or `.glsl` files and bind it
 with `THREE.ShaderMaterial` directly. A sibling `name.vert.glsl` +
 `name.frag.glsl` pair is the portable convention Asset Lab recognizes; it is
-not a VGAI format. Keep authored uniform defaults, defines, textures, and
+not a Volter format. Keep authored uniform defaults, defines, textures, and
 material composition beside the owning material in TS/TSX, where the runtime
 actually reads them. Never add a `.shader.json`, uniform sidecar, or generated
 shader graph to duplicate those facts.
@@ -86,7 +86,7 @@ postprocessing, or the game's actual texture bindings.
 ## Compose postprocessing directly
 
 When a game needs postprocessing, add `@react-three/postprocessing` to that
-project and import its components directly. Do not create a VGAI chain file,
+project and import its components directly. Do not create a Volter chain file,
 effect registry, wrapper component, or JSON descriptor. The owning scene's JSX
 is already the ordered chain; conditionally render one effect to bypass it and
 move its JSX child to reorder it. Keep the finishing order restrained: render,
@@ -267,12 +267,12 @@ is `npx volter-game-editor screenshot`, and the module lane is the asset loop:
    the camera. The corollary is a real blind spot: an asset lane auto-frames
    its subject, so it can NEVER show you a wrong origin, a floating contact
    plane, or a scale that disagrees with the world. Only a scene shot can —
-   `npx volter-game-editor screenshot` with no target (play mode, whole stack) or `vgai
+   `npx volter-game-editor screenshot` with no target (play mode, whole stack) or `volter-game-editor
    screenshot <entityId>` (one entity where it stands, under the scene's own
    lighting).
 
 > Engine-repo aside — not for game projects. When you are working inside the
-> vgai engine checkout itself (no game project, no editor session), the
+> volter engine checkout itself (no game project, no editor session), the
 > equivalent is `node packages/engine/e2e/turntable/capture.mjs <subject>`,
 > run from the checkout root; it boots and tears down its own server. Point
 > it at your own builder with `capture.mjs file --module

package/template/.github/skills/volter-threejs-authoring/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Volter Three.js Authoring"
+  short_description: "Build polished native Three.js scenes and assets"
+  default_prompt: "Use $volter-threejs-authoring to build and visually refine native Three.js source without introducing a parallel scene model."

package/template/.github/skills/{vgai-threejs-authoring → volter-threejs-authoring}/references/helper-catalog.md

@@ -5,7 +5,7 @@ small project helper, or a specialist geometry library.
 
 **MODELING IS BLENDER'S.** A model is a `.blend`, authored in the real Blender
 running headless in the editor tab, and a game loads the GLB it exports. Reach
-for `vgai-3d-models` (bpy through the Blender MCP).
+for `volter-3d-models` (bpy through the Blender MCP).
 
 **Add a capability before you look for its source.** Everything under
 `src/lib/` below is a CAPABILITY, not scaffold contents — a fresh project has

package/template/.mcp.json

@@ -1,12 +1,12 @@
 {
   "mcpServers": {
-    "vgai": {
+    "volter": {
       "command": "npm",
-      "args": ["run", "--silent", "vgai", "--", "mcp", "."]
+      "args": ["run", "--silent", "volter", "--", "mcp", "."]
     },
     "blender": {
       "command": "npm",
-      "args": ["run", "--silent", "vgai", "--", "blender-mcp"]
+      "args": ["run", "--silent", "volter", "--", "blender-mcp"]
     }
   }
 }

package/template/AGENTS.md

@@ -1,6 +1,6 @@
-# AGENTS.md — VGAI Game Project
+# AGENTS.md — Volter Game Project
 
-A standalone game built with VGAI — work here, not in the engine repo.
+A standalone game built with Volter — work here, not in the engine repo.
 The editor is the authoring and verification surface.
 
 ## Route the request first
@@ -9,9 +9,9 @@ The editor is the authoring and verification surface.
 | --- | --- |
 | Build or change this game | This file + the relevant `.agents/references/project-manual.md` section |
 | Open, play, or verify it | `.agents/skills/editor/SKILL.md` |
-| Model or revise a game prop with Blender | `.agents/skills/vgai-3d-models/SKILL.md` |
-| The game needs a 3D asset placed, rigged, or baked | `.agents/skills/vgai-3d-models/SKILL.md` (model and export); placement, stories and baking in `.agents/references/project-manual.md` |
-| Other craft (2D/3D art, animation, humanoids, generated assets) | The matching `.agents/skills/vgai-*/SKILL.md` |
+| Model or revise a game prop with Blender | `.agents/skills/volter-3d-models/SKILL.md` |
+| The game needs a 3D asset placed, rigged, or baked | `.agents/skills/volter-3d-models/SKILL.md` (model and export); placement, stories and baking in `.agents/references/project-manual.md` |
+| Other craft (2D/3D art, animation, humanoids, generated assets) | The matching `.agents/skills/volter-*/SKILL.md` |
 | Import an existing web game | Read-only compatibility report; never rewrite its source |
 | Browse or modify an example | Read-only, or scaffold a copy; user games never go in `examples/` |
 
@@ -21,7 +21,7 @@ generated projections (never edit); `CLAUDE.md` and
 
 **Capabilities are this project's standard libraries, and they are ADDED.**
 Before writing reusable plumbing, run
-bare `npm run --silent vgai -- add` (lists), inspect the match, and `add <id>` it —
+bare `npm run --silent volter -- add` (lists), inspect the match, and `add <id>` it —
 the installed source is project-owned and editable. A doc naming
 `src/lib/<x>` describes what that capability installs.
 
@@ -29,7 +29,7 @@ the installed source is project-owned and editable. A doc naming
 
 1. Read the brief; write the initial `ROADMAP.md` task first (shape:
    the ROADMAP rule below).
-2. Read `vgai.project.json` — each root's `adapter` owns its document
+2. Read `volter.project.json` — each root's `adapter` owns its document
    and lifecycle; read the root entry files and any data schema before
    editing. `src/main.ts` is the game's own standalone boot: it mounts each
    root with its own library (`<Canvas>` for `three`, react-dom for `dom`);
@@ -37,7 +37,7 @@ the installed source is project-owned and editable. A doc naming
 3. Start the editor now (`npm run dev`); tell the user the URL in your
    FIRST visible message. Keep it running and narrate as you build. The
    editor IS the Code-OSS workbench this machine declares in
-   `.vgai/workbench.json` (the product's `create --workbench <dir>` writes it); with
+   `.volter/workbench.json` (the product's `create --workbench <dir>` writes it); with
    no declaration `npm run dev` refuses and prints the exact JSON to write —
    write it, do not work around it.
 4. Multiplayer: every SEAT is a person — an INSTANCE in one editor,
@@ -85,19 +85,19 @@ request needs.
 - **`DEVLOG.md` is the development journal, not a second tracker.** One
   entry per arc: what changed, why, decisions, playtest outcome, what
   remains — with reviewed screenshots (a clip when motion matters)
-  promoted from `.vgai/` history into `media/`; inspect every artifact
+  promoted from `.volter/` history into `media/`; inspect every artifact
   you attach, never the latest blindly.
 - **Record through the eval door**: Play running →
   `eval 'return editor.recording.start({ fps: 30 })'`, drive via
   `game.*`, `eval 'return editor.recording.stop()'` → WebM under
-  `.vgai/recordings/`. Inspect/trim with ordinary `ffmpeg`; no wrappers.
+  `.volter/recordings/`. Inspect/trim with ordinary `ffmpeg`; no wrappers.
 - **Keep Three source modular:** thin `src/world.tsx`; compositions in
   `src/scenes/*Scene.tsx` (no stories); placeables in `src/prefabs/` with
   stories; support in `src/components/`. Owned parts stay inside their
   owner; independent entities never hide in scenery; no monoliths, no
   prefab-per-primitive. E10/E11 enforce declared classifications and W10
   warns when a Three project silently loses all prefabs. Characters are ALWAYS rigged models
-  authored in Blender (`vgai-3d-models`), never primitive stacks.
+  authored in Blender (`volter-3d-models`), never primitive stacks.
 - Use Three.js, PixiJS, React, Rapier, and Colyseus directly — no
   wrappers, no parallel ECS or mirror tree.
 - The world node is the entity. On a TSX root, behavior is a React
@@ -109,8 +109,9 @@ request needs.
   unrecognized manifest key is rejected. Never call `createRoot`,
   `hydrateRoot`, or `ReactDOM.render` from project code.
 - One component, one concern.
-- A player HUD is a `dom` root, never drei `Html` (invisible in
-  captures).
+- UI is React DOM: a player HUD, menus and screens are the `dom` root
+  (`src/ui/game.tsx`, over the world), never a Pixi `canvas` root and never
+  drei `Html` (invisible in captures). A `canvas` root is 2D game rendering.
 - Never fabricate first-party data, modify imported game source without
   consent, or author schema fields with no runtime reader. The game's
   numbers and tables are plain typed literals under `src/data/`.
@@ -120,7 +121,7 @@ request needs.
 - Keep reference images and motion studies in `references/`; Content shows
   them without shipping them. Put assets the game loads in `public/`.
 - Repeatable sequences: flat scripts in `scripts/<task>/steps/` (README
-  per step); intermediates in `.vgai/tmp/<task>/`. Helpers in
+  per step); intermediates in `.volter/tmp/<task>/`. Helpers in
   `src/lib/<domain>/` only when reusable and purely mechanical; no
   runners, task graphs, or auto-judges.
 - Editor control is observation and verification; write through source
@@ -133,7 +134,7 @@ request needs.
 Games are fundamentally unpredictable; pre-written assertions enter an
 endless rewrite cycle. Playtest live; the play log is the receipt.
 
-1. Run `check-idioms`, `typecheck`, `validate`, and `validate-manifest`.
+1. Run `check-idioms`, `typecheck`, and `validate-manifest`.
    **`npm run typecheck` is the gate, never bare `tsc`** (bare `tsc`
    skips `src/tools`).
 2. The ONLY approved slice test is LIVE: a REPL-style manual session in
@@ -146,9 +147,9 @@ endless rewrite cycle. Playtest live; the play log is the receipt.
    the only all-clear.
 4. Enter Play and look. Capture a legible screenshot; **a hidden tab
    captures t≈0** — drive `game.waitSimTime` first.
-5. Drive the game with `npm run --silent vgai -- eval '<js>'` — the one general
+5. Drive the game with `npm run --silent volter -- eval '<js>'` — the one general
    door (`{ editor, game, page, tools, session }`). Never synthetic
-   keys, rAF loops, wall-clock sleeps, or `window.__vgai*` reads.
+   keys, rAF loops, wall-clock sleeps, or `window.__volter*` reads.
 6. Repeat for the few varied situations that could expose the change;
    the observations and screenshots ARE the proof.
 7. Inspect the live hierarchy against the taxonomy above; every prefab
@@ -162,17 +163,16 @@ endless rewrite cycle. Playtest live; the play log is the receipt.
 ## Commands
 
 ```bash
-npm run dev                   # open/reuse this project's editor (the workbench .vgai/workbench.json names)
-npm run --silent vgai -- status        # require connected: true
-npm run --silent vgai -- play          # editor Play mode
-npm run --silent vgai -- restart       # remount after init-time edits
-npm run --silent vgai -- screenshot    # visible evidence
-npm run --silent vgai -- eval '<js>'   # THE door onto the running game
+npm run dev                   # open/reuse this project's editor (the workbench .volter/workbench.json names)
+npm run --silent volter -- status        # require connected: true
+npm run --silent volter -- play          # editor Play mode
+npm run --silent volter -- restart       # remount after init-time edits
+npm run --silent volter -- screenshot    # visible evidence
+npm run --silent volter -- eval '<js>'   # THE door onto the running game
 npm run check-idioms          # every slice
-npm run validate              # manifest/files + React design states
 npm run typecheck             # THE gate: src + src/tools + server
 npm run dev:standalone        # EXPORTED builds only
 ```
 
-Always `npm run --silent vgai -- <verb>`, never a bare `vgai` (a global one may
+Always `npm run --silent volter -- <verb>`, never a bare `volter` (a global one may
 belong to another checkout).

package/template/DEVLOG.md

@@ -16,5 +16,5 @@ every small edit. Put the newest entry first and cover:
 Evidence linked here is durable project material. Review the actual candidate
 captures, reject unclear or unrepresentative frames, and watch each selected
 clip from beginning to end. Copy only the chosen media out of the bounded
-`.vgai/` run history into `media/screenshots/` or `media/clips/` before linking
+`.volter/` run history into `media/screenshots/` or `media/clips/` before linking
 it here. Never cite an unreviewed capture merely because it is the latest one.

package/template/IDIOMS.md

@@ -11,7 +11,7 @@ Legend: **ERROR** fails every run; **WARN** prints but fails only with
 
 - The source is the document. Three roots are ordinary R3F TSX, Canvas roots
   are ordinary Pixi/React source, and DOM roots are ordinary React. The world
-  node is the entity; no mirror ECS, registration layer, or vgai runtime API
+  node is the entity; no mirror ECS, registration layer, or volter runtime API
   belongs in gameplay components. **LOOK**
 - A DOM HUD is a manifest `dom` root and reads the project's own React
   context/store. A timer repeatedly copying game state into React state is a
@@ -60,7 +60,7 @@ Legend: **ERROR** fails every run; **WARN** prints but fails only with
   behavior being judged. The tester's repertoire grows in the slice that adds
   each mechanic. **LOOK**
 - `src/tools/` is literal contribution TSX. The unfinished Tester/Data/Analytics stubs
-  emit `VGAI_STUB_UNIMPLEMENTED`; replacing or honestly deleting the relevant
+  emit `VOLTER_STUB_UNIMPLEMENTED`; replacing or honestly deleting the relevant
   stub is required before completion. **ERROR E6**
 - Tester holds live QA state, controller ownership, goals/mind, setup cheats,
   and judgment readings. Analytics holds historical session data. Data holds
@@ -76,7 +76,7 @@ Legend: **ERROR** fails every run; **WARN** prints but fails only with
 - Playtesting is interactive: arrange, direct the tester, advance sim time,
   observe, read the log, redirect. No committed route, test file, test-runner
   dependency, or test script belongs in a game project. **ERROR E12**
-- Do not boot a private Playwright harness, reach through `window.__vgai`, or
+- Do not boot a private Playwright harness, reach through `window.__volter`, or
   add `?bot=` boot plumbing. Use the editor-owned session and the game's
   running modules. **ERROR E1–E4**
 - Gameplay source must not accumulate for many commits before the first Play

package/template/LICENSE

@@ -2,13 +2,13 @@ MIT License
 
 Copyright (c) 2026 Volter AI, Inc.
 
-This MIT license covers the vgai game-project template (this directory) — the
+This MIT license covers the Volter game-project template (this directory) — the
 starter code scaffolded into your project. It is intentionally permissive so that
-the game you build with vgai, and anything you generate from this template, is
+the game you build with Volter, and anything you generate from this template, is
 YOURS, free of any obligations to us. You may relicense your generated game
 under any terms you choose.
 
-(The vgai engine and tooling — everything outside this directory — are licensed
+(The Volter engine and tooling — everything outside this directory — are licensed
 per component: Apache-2.0 core, AGPL-3.0 editor. See the repository LICENSE.md.)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy