@genex-ai/cli-demo 0.71.0-dev.186 → 0.71.0

package/templates/skills/genex-ai-skybox/SKILL.md

@@ -35,23 +35,15 @@ in local dev, the published game, and remixes).
 
 ## Load it as background + environment
 
-Load the equirect JPG through the quality tier's rung ladder, mark it
-equirectangular, and use it for both the visible background and the lighting.
-The bare URL is an 8192×4096 original — ~178 MB decoded, over half a phone's
-GPU budget in one texture — so phones must load the downscale rung the platform
-stores next to every skybox (`$genex-threejs-adaptive-quality`):
+Load the equirect JPG, mark it equirectangular, and use it for both the visible
+background and the lighting:
 
 ```ts
 import * as THREE from "three";
-import { detectTier } from "./controllers/quality/tier.ts";
-import { loadTextureWithFallback } from "./controllers/quality/pick-asset.ts";
 
 // the URL `npx genex skybox` printed (R2 sends CORS headers, so cross-origin works):
 const SKYBOX_URL = "https://assets.genex.technology/generations/<id>/skybox-equirect";
-const tier = detectTier(); // reuse the boot tier if you already have it
-const texture = await loadTextureWithFallback(SKYBOX_URL, tier, (u) =>
-  new THREE.TextureLoader().loadAsync(u),
-);
+const texture = await new THREE.TextureLoader().loadAsync(SKYBOX_URL);
 texture.mapping = THREE.EquirectangularReflectionMapping;
 texture.colorSpace = THREE.SRGBColorSpace;
 
@@ -59,9 +51,6 @@ scene.background = texture;   // visible sky
 scene.environment = texture;  // image-based lighting on PBR materials
 ```
 
-Desktop gets the original; phones get the `@2048`/`@4096` rung; a missing rung
-falls back to the original automatically — never a broken boot.
-
 For sharper reflections/lighting, pre-filter it with `PMREMGenerator`:
 
 ```ts
@@ -87,7 +76,7 @@ scene.background = texture; // keep the raw texture for the visible sky
 
 ## Troubleshooting
 
-- **"Not authorized"** — run `npx @genex-ai/cli-demo@dev init` first (it writes your `GENEX_TOKEN`).
+- **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
 - **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
   this skybox generation. Tell the user the facts the CLI printed: their balance, this
   generation's cost, and when their credits refill. Then offer to continue the build

package/templates/skills/genex-ai-texture/SKILL.md

@@ -225,7 +225,7 @@ first one is the one a screenshot of the whole arena will not show you.
 
 ## Troubleshooting
 
-- **"Not authorized"** — run `npx @genex-ai/cli-demo@dev init` first (it writes your `GENEX_TOKEN`).
+- **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
 - **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
   this texture generation. Tell the user the facts the CLI printed: their balance,
   this generation's cost, and when their credits refill. Then offer to continue the

package/templates/skills/genex-ai-video/SKILL.md

@@ -145,7 +145,7 @@ set belongs to `$genex-ai-hud` — both build on `npx genex image`/`video`.
 
 ## Troubleshooting
 
-- **"Not authorized"** — run `npx @genex-ai/cli-demo@dev init` first (it writes your `GENEX_TOKEN`).
+- **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
 - **"Prompt rejected"** — the provider's content-safety filter blocked the prompt.
   This is non-retryable; retrying the same wording fails again. Rewrite the prompt.
 - **Nothing plays / black surface** — the first `video.play()` must run inside a user

package/templates/skills/genex-explore/SKILL.md

@@ -71,7 +71,7 @@ Add `--json` for machine-readable output.
 
 1. `git clone <clone URL from the output> <name>` — pick a short one-word name.
 2. `cd <name>`, then run init on the SAME CLI channel your current project
-   uses: `npx @genex-ai/cli-demo@dev init <name>` — or `@dev` when you're
+   uses: `npx @genex-ai/cli-demo@latest init <name>` — or `@dev` when you're
    on the dev stand (unsure? `dashboardOrigins` in your current project's
    `.genex/project.json` says which). Never use `--force`. This creates your
    own project; the original is untouched.

package/templates/skills/genex-getting-started/SKILL.md

@@ -130,7 +130,7 @@ and re-link the clone to the same live game:
 ```bash
 git clone <the game's repo url> my-game && cd my-game
 npm install
-npx @genex-ai/cli-demo@dev link <slug>   # slug = the name in the play URL
+npx @genex-ai/cli-demo@latest link <slug>   # slug = the name in the play URL
 ```
 
 Don't know the slug? **`npx genex list`** prints every game on your account —
@@ -157,7 +157,7 @@ Safe to run any time — genex-owned skills are refreshed to the latest version,
 and your own files are never touched:
 
 ```bash
-npx @genex-ai/cli-demo@dev init
+npx @genex-ai/cli-demo@latest init
 ```
 
 Use `--force` only if you intentionally want your own existing files overwritten

package/templates/skills/genex-threejs-bloom/SKILL.md

@@ -32,10 +32,7 @@ reference before adding selective bloom to a composed scene.
 - selective bloom requires mutating scene materials every frame without restoration guarantees;
 - transparent particles disappear from extraction because pass ownership is unclear;
 - bloom radius changes wildly with resolution;
-- highlights become gray because energy is clamped too early;
-- bloom ships un-tiered: phone tiers run the light post level
-  (`$genex-threejs-adaptive-quality`) — bloom is a desktop-tier pass, and its
-  full-res HDR target is exactly the allocation phones get killed for.
+- highlights become gray because energy is clamped too early.
 
 ## Routing boundary
 

package/templates/skills/genex-threejs-bloom/references/bloom.md

@@ -2,7 +2,7 @@
 
 Use this reference to choose bloom ownership, signal order, selective contribution, and scene-relative emissive ranges without making bloom responsible for the underlying form.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-threejs-camera-direction/SKILL.md

@@ -35,12 +35,9 @@ rules, floating-origin shot, pointer controls, and implementation limits.
 
 ## Aiming and pointer lock
 
-The rule is binary: during play, **the cursor is either a gameplay tool or it is
-locked away**. An OS arrow parked over the action in a game that never uses it is
-a shipped defect, not a default. On the bundled `FollowCamera`, pointer-lock aim
-is ON by default on desktop — a click locks the pointer and raw mouse movement
-drives the view — so mostly you decide whether to turn it OFF. Name the bucket in
-the build plan:
+On the bundled `FollowCamera`, **pointer-lock aim is ON by default** on desktop:
+a click locks the pointer and raw mouse movement drives the view. You rarely turn
+it on — you decide whether to turn it OFF. Name the bucket in the build plan:
 
 - **MANDATORY** — first-person of any kind (FPS, walking sim, horror) and any
   mouse-aimed action (third-person shooter, turret/range). Lock is on by default;
@@ -50,16 +47,11 @@ the build plan:
   `genex controller character` game). On by default; leave it on. Opt out with
   `pointerLockAim: false` only for a stated reason (a cursor-heavy UI at the core
   of play).
-- **Keyboard-driven games lock too** — a racer, platformer, or runner that never
-  reads the mouse still locks the pointer on the play/Start click: the cursor is
-  not a tool there, so lock it away (hidden cursor, no stray clicks, Esc = pause
-  as usual). Bundled-controller games get this for free; a hand-rolled game uses
-  the minimal lock recipe in `$genex-threejs-game-ui` (~6 lines).
-- **NEVER** — cursor-core games where the pointer IS the gameplay tool (top-down
-  click-to-move, tower defense, builders, card/board/puzzle) and spectator/orbit
-  showcases. These **must pass `pointerLockAim: false`** — otherwise the bundled
-  camera grabs the cursor on the first click. (Touch needs nothing: pointer lock
-  doesn't exist there and the mode no-ops on coarse pointers.)
+- **NEVER** — cursor-core games (top-down click-to-move, tower defense, builders,
+  card/board/puzzle) and spectator/orbit showcases. These **must pass
+  `pointerLockAim: false`** — otherwise the bundled camera grabs the cursor on the
+  first click. (Touch needs nothing: pointer lock doesn't exist there and the mode
+  no-ops on coarse pointers.)
 
 **Mechanism — games on the bundled controller (most games):** do NOT hand-roll
 lock handling. Aim is already enabled; the kit ships a ready-made cue overlay —
@@ -121,36 +113,6 @@ grants the permission.
 (trackpad "natural scrolling" only flips the wheel). If look feels inverted it's a
 sign bug in the rig, not a device quirk — fix the sign, don't sniff the trackpad.
 
-## The screen-direction contract
-
-Every input axis has one correct on-screen direction, for every rig, bundled or
-hand-rolled. These four invariants are testable and non-negotiable:
-
-1. Mouse/touchpad RIGHT turns the view right; mouse UP looks up (down only behind
-   an explicit invert option the player chose).
-2. `KeyD`/ArrowRight moves or turns the player toward screen-RIGHT; `KeyA`/
-   ArrowLeft toward screen-left. Same for a touch stick's +x.
-3. Drag-pan picks ONE convention — grab-the-world (terrain follows the pointer)
-   or move-the-camera — and BOTH axes obey it. One axis each is the
-   "diagonals feel twisted" bug.
-4. See the OS-setting note above: inversion is always your sign, never the device.
-
-The formula that settles every sign argument: `screenRight = cross(cameraForward, worldUp)`.
-For a Y-up world and forward `(sin yaw, 0, cos yaw)`, screen-right is
-`(-cos yaw, 0, sin yaw)`. **Warning — `(cos yaw, 0, -sin yaw)` is the LEFT
-vector** (that's `cross(worldUp, cameraForward)`), and writing it as "right" is
-the single most-shipped direction bug in generated games: two independent
-projects inverted their A/D exactly this way. Related trap: positive
-`rotation.y` turns a +Z-facing object toward +X, which is screen-LEFT from a
-chase camera behind it — so "positive yaw = turn right" is false in this basis.
-
-Never derive signs by intuition — intuition about right-handed frames is wrong
-about half the time and has been wrong in every shipped instance. Copy a
-verified pair (sign AND basis together) from
-[references/camera-rigs.md](references/camera-rigs.md), then confirm with the
-input-direction part of the smoke check: hold D and watch which way the world
-answers.
-
 ## Non-negotiable rules
 
 - Use subject dimensions to derive offsets; do not tune one fixed distance for
@@ -160,8 +122,6 @@ answers.
 - During an explicit handoff, use one interpolation stage. Do not stack a
   transition blend and a second follow smoother over the same interval.
 - Re-sync yaw/pitch from the camera when pointer lock is acquired.
-- Hand-rolled steering/pan/look math copies a verified basis from the reference
-  and passes the input-direction check — signs are never derived by intuition.
 - Update the projection matrix whenever FOV, near, far, or aspect changes.
 - Keep stars or infinite backgrounds camera-relative when large translation
   would create false parallax or precision loss.

package/templates/skills/genex-threejs-camera-direction/references/camera-rigs.md

@@ -11,7 +11,6 @@ Use this reference for scale-aware chase, side, orbit, authored-shot, pointer-lo
 - Explicit camera handoffs
 - cinematic implementation shot ownership
 - Pointer-look and movement constraints
-- Verified screen-direction bases
 - Floating origin and background handling
 - Projection and lifecycle ownership
 - Failure modes and diagnostics
@@ -167,9 +166,6 @@ yaw -= mouseDeltaX * 0.0022
 pitch -= mouseDeltaY * 0.0018
 ```
 
-Expected on screen: mouse-right orbits the view right, mouse-up tilts it up —
-verify both axes against the screen-direction contract before retuning the scales.
-
 Pitch bounds vary by flight mode. The implementation also enforces camera height above
 the ship:
 
@@ -285,9 +281,6 @@ distance = movementSpeed * dt
 
 Default speed is `9`, sensitivity `0.0023`.
 
-Expected on screen: mouse-right turns the view right, mouse-up looks up — assert
-both axes (yaw-only evidence has let inverted pitch ship).
-
 Keys are cleared on:
 
 - pointer-lock exit;
@@ -302,61 +295,6 @@ Scene-specific constraints then run after controls:
 
 Input control and spatial constraint are separate layers.
 
-## Verified screen-direction bases
-
-Copy these pairs whole — the sign and the basis are only correct TOGETHER. Each
-was derived from `screenRight = cross(cameraForward, worldUp)` and verified
-against the on-screen result; if you change one half, re-verify with the
-input-direction check instead of reasoning about it.
-
-**Chase-cam steering** (vehicle/character heading, camera behind):
-
-```text
-heading  = (sin yaw, 0, cos yaw)          // matches rotation.y for a +Z-front model
-yaw     -= steer * rate * dt              // steer: D/right = +1, A/left = -1
-position += heading * speed * dt
-camera at position - heading * dist, lookAt(position)
-```
-
-Why the minus: the camera looks along `heading`, so screen-right is
-`cross(heading, up) = (-cos yaw, 0, sin yaw)`, while `d(heading)/d(yaw) =
-(cos yaw, 0, -sin yaw)` — exactly screen-LEFT. Increasing yaw always veers the
-nose left on screen, so "D turns right" needs `yaw -=`. (Equivalently
-`yaw += steer` is correct only with heading `(-sin yaw, 0, cos yaw)` — a pair,
-never a lone sign.)
-
-**RTS / overhead pan camera** (fixed pitch, yaw-orbiting):
-
-```text
-right         = (-cos yaw, 0, sin yaw)    // pitch-independent screen-right on the ground
-forwardGround = (sin yaw, 0, cos yaw)     // into the screen along the ground
-D / ArrowRight: target += right * pan     A / ArrowLeft: target -= right * pan
-W / ArrowUp:    target += forwardGround * pan     S: target -= forwardGround * pan
-```
-
-Drag-pan, grab-the-world (terrain follows the pointer; both axes, one
-convention — `movementY` is positive DOWNWARD):
-
-```text
-target -= right * movementX * k
-target += forwardGround * movementY * k
-```
-
-Move-the-camera convention = flip BOTH signs, never one. The classic shipped bug
-writes `right = (cos yaw, 0, -sin yaw)` — that is `cross(up, forward)`, the LEFT
-vector — inverting A/D and the horizontal drag while W/S stay correct.
-
-**Pointer-look** (locked mouse driving yaw/pitch, Euler order `YXZ`):
-
-```text
-yaw   -= movementX * sensitivity          // mouse-right -> view turns RIGHT
-pitch -= movementY * sensitivity          // mouse-up    -> view tilts UP
-```
-
-Expected on screen, both axes, before any tuning: a straight-ahead landmark
-slides LEFT when the mouse moves right (the view pans right) and slides DOWN
-when the mouse moves up (the view tilts up).
-
 ## Floating origin and background handling
 
 The Saturn scene first computes a virtual camera pose, stores its orientation

package/templates/skills/genex-threejs-embed-auth/SKILL.md

@@ -162,10 +162,7 @@ From `@genex-ai/embed-sdk/sentry` (crash reporting; exactly these two):
 - `sentryCanvasSnapshot(canvas)` — session replay records the DOM, not the 3D
   canvas; call this once per frame at the END of the render loop so replays
   show actual gameplay. Works for BOTH WebGL and WebGPU renderers; internally
-  throttled, so calling at 60fps is fine. On TOUCH devices it is a deliberate
-  no-op (and session replay/tracing sample down): each capture is a full-canvas
-  GPU readback, exactly the overhead phones get memory-killed for — mobile
-  replays are DOM-only by design, on-error replays still record everywhere:
+  throttled, so calling at 60fps is fine:
 
 ```ts
 function animate() {

package/templates/skills/genex-threejs-game-feel/SKILL.md

@@ -37,10 +37,7 @@ no matter how good it looks.
   unlocked drag-to-turn camera feels imprecise no matter how tight the numbers
   are. The bucket rule + the bundled `FollowCamera` aim mode live in
   `$genex-threejs-camera-direction`; on the bundled controller it's ON by default
-  (with a ready-made cue), not hand-rolled events. Direction is half of it: a
-  movement key or look axis whose on-screen direction contradicts its label is a
-  defect, not a tuning issue — the screen-direction contract and verified bases
-  are in `$genex-threejs-camera-direction`.
+  (with a ready-made cue), not hand-rolled events.
 
 ## Movement: snappy beats realistic
 

package/templates/skills/genex-threejs-game-ui/SKILL.md

@@ -27,7 +27,7 @@ in another.
 | Pause | always — opens on the Escape key | 1 — menu backdrop under a dark overlay |
 | Fail / retry | always | 1 — a *graded* variant of the menu screen |
 | Win / next | always | 1 — graded variant, warm |
-| Settings | always — every game carries the Quality picker (Auto/Low/Medium/High, `$genex-threejs-adaptive-quality`), plus whatever else it has to set | 1 |
+| Settings | when there is anything to set | 1 |
 | Lobby / waiting | multiplayer only | 1 over the menu backdrop |
 | HUD | always | 2 — generated sprite HUD (`$genex-ai-hud`), enqueued at this gate for EVERY game; plain CSS is the placeholder until the sprites land, never the final HUD |
 
@@ -79,40 +79,25 @@ lap counter in a game without laps). `--aspect 16:9 --quality high
 --no-wait`, enqueued FIRST of all art; the URL goes into the style-brief
 comment.
 
-**Share it the moment it lands — queue first, show immediately, never wait.**
-When the concept lands, enqueue the Tier-2 UI jobs and the core asset set
-against it in the same breath — the frame you just generated IS the working
-style until the user says otherwise. Then pick it up with
-`genex wait <id> --open` (or generate it with `--open`): it opens in the
-user's browser AND prints the link. Paste that URL as a clickable link in
-your message — a URL is invisible in a terminal, and "do you like it?" with
-no picture in front of the user is the #1 way this checkpoint fails (they end
-up digging logs for the file path). Ask ONE keep-or-change question — "this
-is roughly how the game will look: keep it, or change something?" — **as
-plain chat text, never via the blocking structured-question tool: a suspended
-turn is a gate, and this question must not gate anything.** Silence is
-acceptance; only explicit notes reopen the style. An unanswered style
-question that parks the art pipeline is how a finished game ships bare walls
-and a placeholder HUD — strictly worse than re-rolling a few assets later.
-**Feedback triggers a LOOP whenever it arrives:** if the user comes back
-disliking ANYTHING — immediately or an hour later — regenerate with their
-exact notes (`--candidates 2–3` gives them options to choose from), open +
-link the new frame, and ask again the same non-blocking way. Carry every note
+**Share it before building on it — actually SHOW the image, don't just ask.**
+When the concept lands, pick it up with `genex wait <id> --open` (or generate it
+with `--open`): it opens in the user's browser AND prints the link. Paste that
+URL as a clickable link in your approval message — a URL is invisible in a
+terminal, and "do you like it?" with no picture in front of the user is the #1
+way this checkpoint fails (they end up digging logs for the file path). Then ask
+ONE structured question — "this is roughly how the game will look: keep it, or
+change something?" — with 2–3 concrete adjustment options. Keep building
+gameplay-neutral work (scaffold, physics, netcode) while waiting, but do NOT
+anchor further art to an unapproved frame. **Approval is a LOOP, not a
+one-shot:** if the user dislikes ANYTHING, regenerate with their exact notes
+(`--candidates 2–3` gives them options to choose from), open + link the new
+frame, and ask again — repeat until they actually approve. Carry every note
 forward so each round compounds; if two rounds don't converge, offer 2–3
-distinct directions instead of re-rolling blind (plain chat, same rule).
-Every shown frame becomes the working style exactly like the first did:
-silence after a shown regeneration accepts THAT frame, and when
-`--candidates` goes unanswered, pick the strongest yourself and say so. When
-the style actually changes, re-anchor the style-carrying art made against
-the old frame: the menu still is re-edited (`--edit`) against the new frame
-and its video re-run once from the new still (`$genex-ai-menu` — a
-user-driven style change re-opens its one-video rule), and the HUD chrome
-re-runs its pipeline from Stage 1 with the new frame as the `--edit` anchor
-(`$genex-ai-hud` — budget the full serial chain; it is the most expensive
-re-anchor in the set). Style-neutral assets (most textures, sfx, models)
-usually survive — judge each in one line. The same "open it + paste the
-link" rule covers every image the user weighs in on — the menu still, the
-HUD mockup candidates.
+distinct directions as a structured question instead of re-rolling blind. The
+HUD mockup, the menu, and every downstream asset wait for a frame the user has
+signed off — a single "meh" is never permission to move on. The same "open it +
+paste the link" rule covers every image the user weighs in on — the menu still,
+the HUD mockup candidates.
 
 **The concept anchors STYLE, not truth.** Palette, materials, light, and
 register come from the frame; CONTENT comes from the game contract. When
@@ -265,15 +250,8 @@ document.addEventListener("keydown", (e) => {
   so ALSO keep the pointer-lock-loss → pause path (`pointerlockchange`: if
   unlocked while `playing`, `setPhase("paused")`). Escape then always pauses; it
   only *also* drops fullscreen on browsers without the lock — unavoidable there.
-- **Skip Keyboard Lock + fullscreen only when the cursor stays a tool.**
-  Cursor-core / top-down / menu-driven games never capture the pointer — skip
-  `enterImmersive` and Keyboard Lock entirely. But ANY game that locks the
-  pointer during play — aim games AND keyboard-only racers/platformers/runners
-  under the lock-or-tool rule (next section) — keeps the Escape → pause path and
-  the `pointerlockchange` fallback (if unlocked while `playing`, pause): without
-  it, Esc frees the cursor while the game keeps running. Keyboard-only games may
-  still skip Keyboard Lock + fullscreen; the lock + pause/resume path is the
-  non-negotiable part.
+- **Only for immersive/pointer-lock games.** A top-down or menu-driven game never
+  captures the mouse and has no window to shrink — skip all of this.
 - **Dashboard embed:** no setup needed — the platform's game frame grants keyboard
   lock (and pointer lock + fullscreen), so Escape-to-pause works the same inside
   `/world/` + `/draft/` as it does standalone (`<slug>.genex.technology`).
@@ -283,28 +261,6 @@ menu — trackpads feel slower than mice, so let the player tune it. On the bund
 camera the setter is live: `slider.oninput = () => { followCam.aimSensitivity = +slider.value; };`
 (radians per pixel; default `0.0023`, a usable range is ~`0.0008`–`0.005`).
 
-## The cursor during play: locked or a tool
-
-During play the OS cursor is either the gameplay tool (cursor-core: click-to-move,
-tower defense, builders, card/board — it stays visible, that's correct) or it is
-**locked away — including keyboard-only games** (racer, platformer, runner): an
-arrow parked over the action for the whole session is a shipped defect. Games on
-the bundled `FollowCamera` get the lock free (on by default). A hand-rolled game
-locks with ~6 lines, reusing this section's Escape flow:
-
-```ts
-// In the Play/Start/Resume CLICK handler (lock needs a user gesture):
-canvas.requestPointerLock?.();          // hides the cursor, focuses the game
-// Already in the Escape recipe above: pointerlockchange → if unlocked while
-// playing, pause; the Resume click re-locks. Keyboard games need nothing more —
-// no reticle, no aim code; the lock just parks the cursor.
-```
-
-If the lock is genuinely unavailable (a third-party embed without
-`allow="pointer-lock"`), fall back to hiding the idle cursor over the canvas:
-`canvas.style.cursor = "none"` after ~2s without `pointermove`, restored
-instantly on move. Menus and pause screens always keep their cursor.
-
 ## The loader
 
 The loader is the first thing every player sees — a bare "Loading… 3/5" over
@@ -406,16 +362,6 @@ Order the HUD by what the player loses the game for ignoring:
 - **Contrast against the real scene.** Test text over the brightest AND
   darkest areas of actual gameplay; a soft dark plate or text-shadow beats
   restyling per level.
-- **Panel and button corners come from `border-radius`, not a CSS clip.**
-  Don't chamfer, notch, or slice corners with `clip-path: polygon(...)` or a
-  `mask` for a "hi-tech" look: a raw CSS clip hard-cuts the box, so it shears
-  off whatever sits near the corner (text, padding, the focus ring, a glow)
-  and leaves a jagged aliased diagonal that reads as *broken*, not as a
-  designed bevel. Soft corners are `border-radius`; a genuinely angular or
-  ornamented frame is a generated frame sprite (`$genex-ai-hud` chrome, or a
-  Tier-3 9-slice panel), never hand-cut in CSS. This governs decorative
-  panel/button **shape** only — it does not touch the masked-fill HUD reveal
-  or `genex ui` masks, which are the correct uses of `mask`/`clip-path`.
 - **One cohesion layer.** A single full-screen vignette div (a subtle radial
   gradient darkening the corners, optionally faint grain) over canvas + UI is
   the cheapest way to make DOM-over-WebGL read as one composed image instead
@@ -426,13 +372,11 @@ Order the HUD by what the player loses the game for ignoring:
   `vUv` grain shimmers.
 - **Desktop first.** Verify at desktop sizes and survive window resizes
   without clipping; don't design phone layouts or test mobile viewports unless
-  the user asks. Two exceptions ship by default precisely BECAUSE you don't
-  test on phones: touch *input* when a recipe fits — a bundled controller's
-  built-in touch controls, or the touch kit + recipes in
-  `$genex-threejs-touch-controls` — behind `navigator.maxTouchPoints > 0`,
-  invisible on desktop (skipping needs a one-line reason, not silence); and
-  the adaptive-quality tier at boot (`$genex-threejs-adaptive-quality`), which
-  keeps the shared link from being a dead OR crashing link on a phone.
+  the user asks. Exception: touch *input* is wired by default when a recipe
+  fits — a bundled controller's built-in touch controls, or the touch kit +
+  recipes in `$genex-threejs-touch-controls` — behind
+  `navigator.maxTouchPoints > 0`, invisible on desktop, so the shared link
+  isn't dead on a phone (skipping needs a one-line reason, not silence).
 
 ## Wire UI to game state, never the reverse
 
@@ -455,9 +399,6 @@ architecture and consume the shared style brief.
 - HUD sprites never enqueued at the gate — the placeholder CSS shipped as the
   final HUD.
 - No pause screen, or a pause that isn't bound to Escape.
-- The OS arrow parked over the action for the whole session in a keyboard-driven
-  game (the cursor is either a gameplay tool or locked away — see the cursor
-  section).
 - A style brief whose fonts were never actually loaded (a system-stack display
   font at runtime).
 - A micro-element (reticle, cue, toast, damage number) left as default CSS
@@ -467,11 +408,6 @@ architecture and consume the shared style brief.
 - Hard-cut phase swaps, a menu whose elements just appear, numbers that
   teleport.
 - A silent menu; a bare "Loading…" over black.
-- The art pipeline parked on an unanswered look question — the question is
-  advisory: queue Tier-2 + the asset set against the shown frame and keep
-  moving; silence is acceptance.
-- Panel or button corners chamfered/notched with `clip-path`/`mask` instead of
-  `border-radius` — the corner looks sheared off, not designed.
 - UI panels covering the player or the thing about to kill them.
 - Layout shifting as numbers grow.
 - A fail state with no visible restart key, or a restart that reloads the page.

package/templates/skills/genex-threejs-game-ui/references/style-capsules.md

@@ -10,8 +10,7 @@ says what it's made of in THIS game.
 
 Every capsule below assumes the base rules from the skill: corners/edges for
 UI, one display + one body font, tabular numerals, contrast plates over
-arbitrary scenes, and panel/button corners from `border-radius` or a generated
-frame — never a raw CSS `clip-path`/`mask` chamfer.
+arbitrary scenes.
 
 ## Fantasy / action RPG
 

package/templates/skills/genex-threejs-image-pipeline/SKILL.md

@@ -43,11 +43,6 @@ ownership boundaries between whole-scene and effect-local graphs.
 - Build pass toggles and effect-only views before tuning.
 - UI rendered in the same target needs an explicit protection strategy.
 - Do not load all atomic post skills by default. Route only the effects actually requested.
-- Budget the pipeline per device tier (`$genex-threejs-adaptive-quality`):
-  phone pixel budget ≈ 1,000,000 px at DPR ≤ 1.25–1.5, desktop ≈ 1,650,000 px —
-  every full-res pass target multiplies that cost, so phone tiers run the light
-  post level and per-pass resolution scales (0.4–0.5 DPR blurs) are the norm,
-  not an optimization.
 
 ## Routing boundary
 

package/templates/skills/genex-threejs-image-pipeline/references/image-pipeline.md

@@ -2,7 +2,7 @@
 
 Use this reference to compose shared scene buffers, lighting effects, atmosphere, bloom, exposure, tone mapping, grading, and feature-local render targets with explicit ownership.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-threejs-lighting-design/SKILL.md

@@ -107,11 +107,7 @@ kill-switch diagnostic.
   whole rig after a tone-mapping change is self-inflicted.
 - Never repair unbalanced light ratios with exposure — fix the lights.
 - Flicker from elapsed time, never per-frame randomness.
-- Dispose lights and their shadow maps with the level that spawned them — and
-  the rest of the level with them: traverse the outgoing scene and dispose
-  geometry, materials, AND textures separately (three frees nothing; material
-  dispose does not touch textures). Leaked levels march phones toward the
-  OS memory kill — `$genex-threejs-adaptive-quality` owns the budget watch.
+- Dispose lights and their shadow maps with the level that spawned them.
 - The rig must read with post off: time of day and where-to-go, before bloom.
 
 ## Routing boundary

package/templates/skills/genex-threejs-multiplayer/SKILL.md

@@ -536,13 +536,7 @@ fights (many writers). A ball on `objects` glides and has one owner. That's the
   `stateRaw` is the raw latest (hit-tests, discrete values). A reconnect-grace seat remains in this
   map with `connected: false`. `avatarUrl` is that player's verified VRM pick (server-set, `''`
   when unknown) — in a VRM-lane game render each remote with
-  `loadVrmClone(p.avatarUrl || "./assets/avatar.vrm")` (the vendored loader's shared-GPU clone:
-  N remotes share one set of geometry/textures instead of re-parsing per player — retarget
-  clips once on `loadVrmClone.base(url)` and play them on each clone's own mixer); never
-  publish avatar URLs through `me.set`. On phone tiers, animate and fully draw only the
-  nearest `tier.remoteAvatarCap` remotes (`$genex-threejs-adaptive-quality`) — freeze the
-  mixer and billboard or hide the rest; a room allows up to 64 players and 64 live avatars
-  is a real phone memory kill on its own.
+  `loadVrm(p.avatarUrl || "./assets/avatar.vrm")`; never publish avatar URLs through `me.set`.
 - `room.activePlayers` — the connected-only subset of `room.players`; use its size for live quorum.
 - `room.objects` — shared objects nobody owns until claimed (a ball, an NPC):
   - `claim(id)` — **legacy** optimistic request. It flips local ownership immediately and is corrected

package/templates/skills/genex-threejs-multiplayer/references/host-physics.md

@@ -275,12 +275,9 @@ room.me.set({
 
 // Remote players: a VISUAL-ONLY avatar — NO Rapier body, NO controller instance for remotes.
 // Build each remote's visual from THEIR OWN model: in a VRM-lane game that is
-// loadVrmClone(pl.avatarUrl || "./assets/avatar.vrm") — the verified per-player pick the
-// relay replicates ('' = unknown → fall back; deepDispose the clone on 'leave'). The clone
-// shares parsed GPU geometry/textures across remotes with the same file (most rooms: all of
-// them) — retarget clips once against loadVrmClone.base(url).vrm and drive each clone's own
-// AnimationMixer. Never reuse your own avatar OBJECT for a remote (clones, not references).
-// Phone tiers animate only the nearest tier.remoteAvatarCap remotes (adaptive-quality skill). Position/rotation from smoothed state; animation from the
+// loadVrm(pl.avatarUrl || "./assets/avatar.vrm") — the verified per-player pick the relay
+// replicates ('' = unknown → fall back; deepDispose the model on 'leave'). Never reuse your
+// own avatar file for every remote. Position/rotation from smoothed state; animation from the
 // synced flags via the avatar's own update(flags, dt). The character-controller skill's
 // animations reference owns the flag set.
 const pl = room.players.get(id)!;

package/templates/skills/genex-threejs-physics-rapier/references/colliders-from-assets.md

@@ -26,7 +26,6 @@ already resolved — constructing a collider before WASM init throws.
 | tall dynamic props, posts | `capsuleCollider` / `cylinderCollider` | stable standing shapes |
 | pickups, triggers, zones | any shape + `{ sensor: true, mass: 0 }` | overlap events, no contact forces |
 | the player, cars, drones | none of the above — `npx genex controller` | controllers own their collider recipes |
-| any prop on a PHONE tier (`$genex-threejs-adaptive-quality`) | prefer `cuboidCollider`/hull over trimesh | trimesh contacts scale with triangle count — a phone CPU/memory tax; keep trimesh for static level geometry only |
 
 ## Explicit primitive helpers
 

package/templates/skills/genex-threejs-screen-space-ambient-occlusion/references/ambient-occlusion.md

@@ -2,7 +2,7 @@
 
 Use this reference for a bounded-cost WebGPU/TSL ambient-visibility pass with half-resolution horizon integration, bent normals, bilateral reconstruction, and directional ambient tint.
 
-> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project. Either way the effect obeys the device tier (`$genex-threejs-adaptive-quality`): expensive passes are desktop-tier, and on WebGPU the per-target MSAA sample count is a runtime knob the governor may drive.
+> **Renderer note:** this reference assumes `WebGPURenderer` + TSL node materials. Check the project's actual renderer first — the Genex scaffold ships vanilla WebGL three.js. On WebGL, adapt the technique with standard materials / `EffectComposer` passes or pick a simpler alternative; never switch renderers mid-project.
 
 ## Contents
 

package/templates/skills/genex-threejs-shadow-systems/SKILL.md

@@ -12,12 +12,6 @@ and shadows shimmer, swim, or run out of coverage.
 
 Use a single shadow map only when its receiver region is genuinely bounded. For large moving views, make shadow coverage an explicit spatial hierarchy.
 
-**Phone budgets ride the quality tier** (`$genex-threejs-adaptive-quality`):
-shadow maps ≤1024² on phones (512² on the low tier — a 4096² map alone is
-~67 MB of the phone's whole GPU budget), at most 2 cascades where desktop runs
-4, and `shadowMap.autoUpdate = false` for static scenes (re-render on demand:
-a shadow pass is a full extra scene render every frame otherwise).
-
 ## Cached clipmap workflow
 
 1. Define concentric light-space square levels.