@genex-ai/cli-demo 0.78.1-dev.203 → 0.80.0-dev.211

package/templates/skills/{genex-threejs-skill-router → genex-game-director}/references/routing-map.md

@@ -1,6 +1,8 @@
 # Routing Map
 
-Use this reference when a Genex game request touches multiple visual systems.
+The director's routing source: which skill owns which system, the execution
+order for a Genex game, and the acceptance gate. Use it for every game and
+whenever a request touches multiple visual systems.
 
 ## Three.js version and references
 
@@ -13,6 +15,48 @@ the user asks to upgrade. Use official Three.js docs first, then official
 examples as implementation references. Match examples to the project's installed
 Three.js release or branch, and do not blindly copy demo architecture.
 
+## Route by system
+
+| Work needed | Load |
+| --- | --- |
+| shot composition, chase/side/orbit rigs, camera handoffs, projection ownership, pointer look, mouse-aimed action (shooter, FPS/first-person, sniper, turret, crosshair/reticle), mouse-look, hand-rolled steering/pan/look input signs (screen-direction contract), floating origins | `$genex-threejs-camera-direction` |
+| on-foot player movement: walk/run/jump/crouch, third-person character, slopes, stairs, moving platforms, personal VRM animation, directional locomotion, transitions, action motion | `$genex-threejs-character-controller` |
+| a custom generated playable humanoid or Meshy animation coverage beyond UAL: reference-informed A-pose concepts, explicit candidate + 10k-remesh approvals, exact action IDs, same-rig adapter | `$genex-ai-character` + `$genex-threejs-character-controller` |
+| the player drives or flies something: cars, drones, vehicle physics, gearbox, enter/exit between character and vehicle | `$genex-threejs-vehicle-controllers` |
+| playable on phones: touch/mobile input for any game — joystick, virtual buttons, drag zones, per-genre touch recipes, rotate-device overlay — wired by default for every NEW game when a recipe fits (skip with a one-line reason) | `$genex-threejs-touch-controls` |
+| phone-survivable rendering — device tiers, DPR/shadow/post budgets, the runtime quality governor, per-tier asset rungs for generated skyboxes/textures, the Quality picker, dispose-on-swap discipline — **mandatory for every game at boot wiring** | `$genex-threejs-adaptive-quality` |
+| anything falls, collides, gets pushed, or needs physics: Rapier world setup, colliders for meshes and GLBs, collision events | `$genex-threejs-physics-rapier` |
+| launch and docking timelines, procedural transform phases, springs, staging, rotating-frame alignment, debris motion | `$genex-threejs-procedural-animation` |
+| reusable scalar/vector fields, domain warping, causal masks, procedural normals | `$genex-threejs-procedural-fields` |
+| atlas-filtered blocks, planetary surfaces, terrain wetness, lava/emissive procedural surfaces, authored frame PBR, specular AA | `$genex-threejs-procedural-materials` |
+| sculpted rails/frames, branch rings, semantic mesh writers, material groups | `$genex-threejs-procedural-geometry` |
+| trees, stylized grass, GPU-computed grass fields, branching organisms, roots, foliage, rooted wind deformation | `$genex-threejs-procedural-vegetation` |
+| buildings, façade grammars, profiles, ornaments, modular mesh writers | `$genex-threejs-procedural-architecture` |
+| planets, terrain, craters, biome fields, coastlines, spherical detail | `$genex-threejs-procedural-planets` |
+| sky scattering, planetary shells, depth-based aerial perspective | `$genex-threejs-atmosphere-aerial-perspective` |
+| weather-driven raymarched clouds and cloud shadows | `$genex-threejs-volumetric-clouds` |
+| hero open-water FFT oceans (expensive — only when open water IS the game): spectral cascades, hybrid FFT/Gerstner clear water, choppy derivatives, Jacobian whitecaps | `$genex-threejs-spectral-ocean` |
+| **default water**: an ocean, sea, lake, river, or pool the game plays on or around — authored analytic waves, bounded heightfield pools, object ripples, differential-area caustics, shared normals, heuristic refraction, fallback absorption, crest foam | `$genex-threejs-water-optics` |
+| falling snow, snow accumulation, model snow caps, wet asphalt puddles, procedural ripple normals, splash flipbooks, rain streaks, shared weather envelopes, surface wetness | `$genex-threejs-precipitation-surfaces` |
+| curved-ray black holes, accretion disks, wormholes | `$genex-threejs-raymarched-space-effects` |
+| particles, trails, plasma, shockwaves, layered event effects | `$genex-threejs-procedural-vfx` |
+| accumulated screen frost, touch clearing, reduced blur, and refraction masks | `$genex-threejs-temporal-surfaces` |
+| the light rig and where light belongs: sun/moon key, practical lights (campfire, torch, neon, lava), emissive-to-light coupling, light shafts and visible beams, fog mood, light signals, flicker, a scene that reads flat or uniformly lit | `$genex-threejs-lighting-design` |
+| stable large-world shadows, cascades, clipmaps, cached updates | `$genex-threejs-shadow-systems` |
+| GTAO, bent normals, bilateral reconstruction | `$genex-threejs-screen-space-ambient-occlusion` |
+| HDR bloom and selective emission contribution | `$genex-threejs-bloom` |
+| eye adaptation, tone mapping, LUT grading, output color | `$genex-threejs-exposure-color-grading` |
+| shared depth/normal/velocity ownership and multi-pass ordering | `$genex-threejs-image-pipeline` |
+| fixed-view diagnostics, seed sweeps, temporal and budget evidence | `$genex-threejs-visual-validation` |
+| game content named in the plural or a content genre: quests, objectives, NPCs, dialogue, shops, inventory, loot, XP/progression, an RPG/adventure/story game — **mandatory whenever the ask names content**, and its content contract is written before the asset batch | `$genex-threejs-game-content` |
+| a big/open world: kilometers of terrain, multiple regions or locations, exploration, points of interest, biomes, world streaming | `$genex-threejs-open-world` |
+| the 2D interface — HUD, menus, pause/win/lose screens, loaders, lobby, on-screen text and buttons, UI state flow — **mandatory for every game**, and its "Plan the UI first" gate runs right after the concept is locked | `$genex-threejs-game-ui` |
+| a cinematic menu — main menu/title/pause/victory/defeat/lobby/credits with a looping generated video backdrop behind DOM buttons | `$genex-ai-menu` |
+| a cohesive art-directed HUD — generated sprite set (matched frames, masks, icons in one style) wired with masked fills | `$genex-ai-hud` |
+| the game works but feels flat, floaty, or unresponsive: input response, acceleration curves, camera shake, hit feedback, hitstop, cooldowns, difficulty ramp, fail/retry loop | `$genex-threejs-game-feel` |
+| realtime multiplayer: movement sync, a shared ball/NPC, host-run scores/enemies, shots/emotes, persistence | `$genex-threejs-multiplayer` |
+| player identity, sign-in, guests, saves/progress, per-player state, a shared persistent world, leaderboards — **mandatory for every game** | `$genex-threejs-embed-auth` |
+
 ## Execution order
 
 1. Define the game contract: player verb, win/interaction loop, target device,
@@ -29,12 +73,10 @@ Three.js release or branch, and do not blindly copy demo architecture.
    additionally fixes the world's scale class as a number here via
    `$genex-threejs-open-world` — kilometers of streamed terrain, never one
    fogged plane. Scope belongs to the user: shipping fewer or smaller than
-   the ask requires their explicit OK through a structured question (your
-   environment's structured question tool when it has one — Claude Code:
-   `AskUserQuestion`; Codex: `request_user_input`; if none, e.g. Cursor, a
-   short numbered list in chat) — a
-   "vertical slice first" is a build order, never a license to shrink the
-   destination silently.
+   the ask requires their explicit OK through a question with real options
+   (your question tool when you have one; a short numbered list in chat
+   otherwise) — a "vertical slice first" is a build order, never a license
+   to shrink the destination silently.
 2. Wire player identity before any boot code: `$genex-threejs-embed-auth` is
    mandatory for every game (`initEmbed(...)` + the `waitForPlayer()` gate) —
    saves, leaderboards, and multiplayer auth all come from it.
@@ -45,9 +87,8 @@ Three.js release or branch, and do not blindly copy demo architecture.
    game-ui gate) WITH the full HUD composited over it: the `$genex-ai-hud`
    Stage-1 image, one generation serving as concept, style checkpoint, and
    HUD blueprint (never a separate UI-free concept first). Show it to the user
-   the moment it lands and get a keep-or-change answer through the
-   environment's structured question tool (Claude Code: `AskUserQuestion`;
-   Codex: `request_user_input`; numbered-list fallback otherwise). This answer
+   the moment it lands and get a keep-or-change answer through your question
+   tool (a short numbered list in chat when you have none). This answer
    GATES — but only the style-dependent pipeline: until the user approves a
    frame, do NOT enqueue the Tier-2 art that builds on the look (the
    `$genex-ai-hud` Stage-2 chain, and the `$genex-ai-menu` still + video
@@ -58,10 +99,10 @@ Three.js release or branch, and do not blindly copy demo architecture.
    arrive, and later `--edit`-able generations anchor to the approved frame for
    STYLE while the game contract owns content. Everything that does NOT depend
    on the look — scaffold, boot wiring, the core loop, and the
-   concept-independent content subagents below — keeps building in parallel
-   while the answer is pending, so the wait is never idle. Skipping this enqueue is
-   the #1 way a finished game ships an ugly HUD — by step 12 there is nothing
-   to swap in.
+   concept-independent worker lanes (the director's Delegate section) —
+   keeps building in parallel while the answer is pending, so the wait is
+   never idle. Skipping this enqueue is the #1 way a finished game ships an
+   ugly HUD — by step 12 there is nothing to swap in.
 4. Lock the visual direction — the same plan-first logic as the UI gate, in
    the same plan block, before any rendering code:
    - **camera**: the rig type and the pointer bucket
@@ -144,7 +185,7 @@ Three.js release or branch, and do not blindly copy demo architecture.
      Emissive-only is a real answer said in one line; a coupled practical
      light is the step up; one white ambient wash over everything is the
      unlit look with extra steps, and it reads the same at noon and at
-     midnight. `$genex-threejs-lighting-design` owns this gate;
+     midnight. `$genex-threejs-lighting-design` owns that gate;
    Planning is not building: effects still land LAST (steps 10–11); this step
    only fixes the target so the look isn't improvised pass-by-pass at the end.
 5. Wire the gameplay layer for the player verb: the physics world via
@@ -217,61 +258,23 @@ Three.js release or branch, and do not blindly copy demo architecture.
 13. Validate in a real browser with fixed seeds, captures, interaction checks,
     and performance evidence.
 
-## Parallelize with subagents — the default whenever the environment has them
-
-Generations already render server-side in parallel — the wall-clock savings
-live in the ATTENDED chains. Whenever the coding agent supports background
-subagents (e.g. Claude Code's Agent tool), fanning the independent work out is
-the DEFAULT, not a big-scope special case: split every disjoint chain below off
-by default and keep the main thread building. In environments without them
-(Cursor), the same order simply runs sequentially and the `--no-wait` pattern
-still hides most generation latency.
+## Delegation
 
-**One ordering rule from the concept gate (step 3):** subagents that build ON
-the look are CONCEPT-DEPENDENT and wait for the user's keep/change yes — the
-HUD chain worker and any style-matched art. Subagents that do NOT depend on the
-look — the content-module fan-out, verification of concept-independent parts —
-launch immediately and run while the concept answer is still pending. Never let
-the pending yes stall concept-independent work, and never fan out
-concept-dependent work before it.
+Fan-out is owned by the director: sub-agents own DESIGN.md Modules rows,
+concept-DEPENDENT lanes wait for the player's yes on the concept, one writer
+per file, workers never spawn workers, and the Assets table is the budget —
+the full rules and the worker prompt shape live in the Delegate section of
+`$genex-game-director`. This map adds no separate delegation rules; it is the
+routing source the director and its workers read.
 
-- **HUD chain worker (concept-dependent — starts on the yes).** The moment the
-  user APPROVES the concept, hand the whole
-  `$genex-ai-hud` chain to one subagent: pick the better candidate → Stage-2
-  sheet → clean → extract → masks → write the sprite wiring. Its prompt must
-  be self-contained — the style brief, the approved mockup URL, the
-  output dir, and exactly which files it owns. **Handoff rule:** whoever
-  wires the HUD after the subagent finishes MUST read the produced
-  `*.annotated-progress.json` and `.bbox.json` files from disk — fillBox
-  numbers, `segments`, and sprite dims do not survive a prose summary, and
-  wiring from the summary is how validated masks end up on disk while the
-  shipped fill is a naive width%.
-- **Asset shepherd.** One subagent runs `npx genex wait` on every queued ID
-  and wires each asset in as it lands (skybox, models, menu video, dressing),
-  swapping placeholders out and reporting each swap.
-- **Verification runner.** Browser evidence — screenshots, control presses,
-  the menu loop-seam watch, in-situ checks of placed art — can run in a
-  subagent while the main agent keeps building.
-- **Content module fan-out (big scopes — concept-independent, launch immediately).**
-  When the content contract names a
-  big world or several content systems, serial hand-typing is what runs out
-  of session: split the gameplay modules across parallel subagents instead —
-  one each for world/terrain, quest + dialogue DATA, enemies/AI, items/
-  economy — against a short written module contract (the shared state
-  object's shape, the event names, the content tables from
-  `$genex-threejs-game-content`, exact file ownership). Ship the
-  walking-skeleton v0 preview FIRST, then let the content agents land behind
-  it — the preview cadence and a long parallel build are not in conflict:
-  the user walks the skeleton while the world grows. Each subagent reports
-  deviations from the module contract; the main agent reconciles and stays
-  the only writer of the entry point.
+## Routing rules
 
-Hard rules: **one writer per file** — each subagent owns a disjoint file set
-(the HUD worker owns the hud modules and `public/assets/hud/`, the shepherd
-owns asset-wiring modules), and the main agent stays the only writer of
-gameplay/netcode. Merge points are explicit: a subagent reports what it
-changed, the main agent reconciles. Never put two writers on the same
-module — a corrupted entry point costs more than the minutes saved.
+- Build silhouette, motion, and material readability before adding image
+  effects. Never dress a primitive shape in glow or bloom to fake quality —
+  authored forms first, then materials, then lighting, then effects last.
+- Keep game logic, simulation state, visual fields, and screen-space passes
+  separated unless coupling is intentional.
+- Prefer deterministic seeds and named controls for every procedural system.
 
 ## Acceptance gate
 

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

@@ -26,8 +26,9 @@ out automatically — only `genex-*`-named files are removed, never yours.
 - **agents/** - example subagent definitions (Claude Code).
 - **commands/** - example slash commands (Claude Code).
 
-Start with `$genex-threejs-skill-router` for broad game or graphics requests.
-It routes the agent to focused skills for cameras, procedural geometry,
+Start with `$genex-game-director` for any game or graphics request. It checks
+what your environment can do, writes the `DESIGN.md` design contract, and
+routes the agent to focused skills for cameras, procedural geometry,
 materials, atmosphere, water, weather, VFX, lighting, post-processing, and
 visual validation.
 

package/templates/skills/genex-threejs-adaptive-quality/SKILL.md

@@ -128,15 +128,17 @@ const gltfLoader = createGltfLoader(renderer); // meshopt always; KTX2 when the
 const gltf = await loadModelWithFallback(
   MODEL_URL, tier, (u) => gltfLoader.loader.loadAsync(u), { ktx2: gltfLoader.ktx2 },
 );
-// Provider PBR ships mirror-metal (metalness~1) that reflects the sky env and
-// swims with camera motion — clamp it on every loaded model:
+// Provider PBR sometimes ships mirror-metal (metalness~1 + near-zero roughness)
+// that reflects the sky env and swims with camera motion. Tame ONLY that extreme
+// — do NOT flatten every material to 0.6 (it dulls legitimately metallic props):
 gltf.scene.traverse((o) => {
   const m = (o as THREE.Mesh).material as THREE.MeshStandardMaterial;
-  if (m?.isMeshStandardMaterial) {
-    m.metalness = Math.min(m.metalness, 0.6);
-    m.roughness = Math.max(m.roughness, 0.35);
-    m.envMapIntensity = 0.6;
+  if (!m?.isMeshStandardMaterial) return;
+  if (m.metalness > 0.85 && m.roughness < 0.2) {
+    m.metalness = 0.7;
+    m.roughness = Math.max(m.roughness, 0.3);
   }
+  m.envMapIntensity = Math.min(m.envMapIntensity, 0.8);
 });
 ```
 
@@ -162,7 +164,7 @@ not the player's account. Default Auto.
   at most 2 cascades on phones (`$genex-threejs-shadow-systems`).
 - Post: phone floor is a BUILT tone-mapping/output pass (`postLevel: 'light'`
   adds FXAA/vignette); SSAO, volumetrics, and DoF are desktop-tier only
-  (`$genex-threejs-skill-router` owns the floor wording).
+  (`$genex-game-director`'s routing map owns the floor wording).
 - Particles/scatter: multiply counts by `tier.particleScale`; render heavy
   transparency at half resolution and upsample.
 - Animation: distant mixers update at 1/2–1/4 rate; multiplayer remotes above

package/templates/skills/genex-threejs-character-controller/SKILL.md

@@ -57,10 +57,8 @@ Meshy Image-to-3D first produces an unremeshed high-detail model. Show its
 front, back, left, and right views and report its measured face count. Preserve
 that model in R2. Before rigging, ask the user to approve a separate
 10,000-face triangle remesh. The 10k remesh—not the high-detail source—is
-rigged and animated. (For these approvals, use your environment's structured
-question tool when it has one — Claude Code: `AskUserQuestion`; Codex:
-`request_user_input`; if it has none, e.g. Cursor, a short numbered list in
-chat.)
+rigged and animated. (For these approvals, use your question tool when you
+have one; if you have none, a short numbered list in chat.)
 
 That is a separate, **same-rig Meshy-native lane**. Its animation-only GLBs are
 accepted only when their skeleton signature matches the active character

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

@@ -34,26 +34,19 @@ Guest sessions have **no** overlay — the game just plays.
 ## Install
 
 ```bash
-npm i @genex-ai/embed-sdk @sentry/browser
+npm i @genex-ai/embed-sdk
 ```
 
-(`@sentry/browser` powers the crash reporting + session replay wiring below —
-it's an optional peer of the SDK, and every Genex game installs it. Already
-installed if you followed Step 3 of the scaffold; repeated here so this skill
-is self-contained.)
+(Already installed if you followed Step 3 of the scaffold; repeated here so
+this skill is self-contained.)
 
 ## Bootstrap (required, every game)
 
 ```ts
-// main.ts — the FIRST things in the boot sequence, before any other game code
-import { initGameSentry } from "@genex-ai/embed-sdk/sentry";
+// main.ts — the FIRST thing in the boot sequence, before any other game code
 import { initEmbed } from "@genex-ai/embed-sdk";
 import { GENEX } from "./genex.config";
 
-// Crash reporting + session replay FIRST — so even a failure inside the auth
-// boot below gets reported. One required field; never pass tokens to it.
-initGameSentry({ slug: GENEX.slug });
-
 initEmbed({
   slug: GENEX.slug,
   apiUrl: GENEX.apiUrl,
@@ -153,29 +146,6 @@ Server write limits (per player, per minute): **60 player-saves, 120
 world-saves, 30 score submits**. A debounced ~1/sec checkpoint never gets near
 them — only a save-per-frame loop does (it surfaces as HTTP 429).
 
-From `@genex-ai/embed-sdk/sentry` (crash reporting; exactly these two):
-
-- `initGameSentry({ slug, dsn?, environment? })` — call once, BEFORE
-  `initEmbed()`. Only `slug` is required; the shared Genex Sentry project DSN
-  is built in. Errors, tracing, and session replay all start here; the current
-  player (account or guest) is attached automatically (no code needed).
-- `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:
-
-```ts
-function animate() {
-  requestAnimationFrame(animate);
-  // ...game update...
-  renderer.render(scene, camera);
-  sentryCanvasSnapshot(renderer.domElement); // AFTER render, same frame
-}
-```
-
 ## Saving progress (per-player — every player has their own slot)
 
 Use the SDK helpers; never hand-roll fetch calls to the state API. Progression,
@@ -224,16 +194,6 @@ their Genex account) and keep-best — submitting a worse score changes nothing
 post when they sign in. Send a consistent `mode` per board. Scores are
 client-reported (arcade-style trust) — don't present them as anti-cheat.
 
-## Crash reporting rules
-
-- `initGameSentry` has token scrubbing built in (the sign-in return-trip pass
-  in URLs is redacted automatically). Never wrap, reimplement, or bypass it —
-  and never add Sentry options that capture network request/response bodies.
-- Don't call `Sentry.init` yourself or add a second error reporter —
-  `initGameSentry` is the one entry point.
-- Manual capture is fine where a try/catch swallows a real bug:
-  `import * as Sentry from "@sentry/browser"; Sentry.captureException(err)`.
-
 ## NEVER log the tokens
 
 **NEVER log the return value of `getEmbedToken()` or `getColyseusAuth()` — not
@@ -328,10 +288,8 @@ Rules:
 
 ## Checklist
 
-- [ ] `initGameSentry({ slug: GENEX.slug })` is the very first call in `main.ts`.
-- [ ] `initEmbed(...)` follows it, with all three config fields.
-- [ ] `sentryCanvasSnapshot(renderer.domElement)` runs after `renderer.render()`
-      in the main loop (WebGL and WebGPU alike).
+- [ ] `initEmbed(...)` is the very first call in `main.ts`, with all three
+      config fields.
 - [ ] `genex.config.ts` includes `dashboardOrigins` (from `.genex/project.json`).
 - [ ] Multiplayer and player-name UI await `waitForPlayer()` — NEVER
       `waitForAuth()` (guests would hang forever). Both `connect()` and

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

@@ -48,11 +48,10 @@ Rules that make the contract real:
 - **Scope belongs to the user.** Building a small first slice is the right
   ORDER (`$genex-threejs-game-ui`'s v0 beat still applies) — but the slice is
   a milestone on the way to the contract, never a quiet replacement for it.
-  If the full ask genuinely doesn't fit, shrinking any line is a structured
+  If the full ask genuinely doesn't fit, shrinking any line is a
   question to the user with real options — never a silent cut justified as
-  "standard practice". (Use your environment's structured question tool when
-  it has one — Claude Code: `AskUserQuestion`; Codex: `request_user_input`;
-  if it has none, e.g. Cursor, a short numbered list in chat.)
+  "standard practice". (Use your question tool when you have one; if you
+  have none, a short numbered list in chat.)
 - **Minute ten is the design test.** If the honest answer is "the same sixty
   seconds, again", the contract needs another beat (a new area unlocks, a
   quest chain escalates, a build comes online) before any polish work.

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

@@ -1,6 +1,6 @@
 ---
 name: genex-threejs-game-ui
-description: Design the 2D interface of a Genex Three.js game — plan the full screen set up front (loader, menu, HUD, pause/win/lose, lobby) under one shared art direction, then build it as an animated DOM overlay. Use for every new game before writing UI code, and whenever the game needs on-screen text, meters, buttons, or menus, or the interface reads as a generic dashboard, covers the action, or shifts as numbers change.
+description: Design the UI HUD interface of a Genex Three.js game — plan the full screen set up front (loader, menu, HUD, pause/win/lose, lobby) under one shared art direction, then build it as an animated DOM overlay. Use for every new game before writing UI code, and whenever the game needs on-screen text, meters, buttons, or menus, or the interface reads as a generic dashboard, covers the action, or shifts as numbers change.
 ---
 
 # Genex Three.js Game UI
@@ -43,10 +43,7 @@ The table lists screens; **elements are inventoried separately**. Walk the
 whole loop in your head — loader → menu → spawn → action → pickup → damage →
 death → retry → win — and write down EVERY on-screen element the player will
 ever see: the reticle and each of its states, aim/interact cues, toasts,
-damage numbers, kill feeds, timers, countdowns, pickup popups… Each element
-gets a treatment from the brief. **Nothing ships looking like default
-browser CSS** — an element styled like a bare `<div>` or a system button is
-a bug wherever it appears, listed or not.
+damage numbers, kill feeds, timers, countdowns, pickup popups.
 
 **2. One shared style brief — for the WHOLE game, not just the UI.** Write it
 once — 4–5 named hues, materials, one display + one body font, mood — and
@@ -61,17 +58,12 @@ is LOADED for real — a Google Fonts `<link>` (or `@font-face`) in
 ships as a system-stack fallback (`Arial Black`, `Impact`) is the same bug in
 type.
 
-**3. Name your references — AAA, by name.** Pick the closest capsule in
-[references/style-capsules.md](references/style-capsules.md), name 2–3 top
-AAA games of the genre, and state in one line which structural conventions
-you're borrowing. The bar is what those games ship, not "good enough for a
-demo". Conventions only — never logos, exact layouts, or trade dress. The
-same 2–3 names carry into the router's visual-direction gate for the scene.
-Then turn references + brief into ONE **concept mockup** — the game concept
+**3. Make ONE concept mockup** — the game concept
 and the HUD Stage-1 mockup are the SAME image, generated once (never a
 separate UI-free concept first): a single image of a PLAYABLE MOMENT of this
 game with its complete HUD composited over it, built with `$genex-ai-hud`'s
-Stage-1 prompt template. The scene half of the prompt comes from the game
+Stage-1 prompt template. For genre conventions to borrow, skim
+[references/style-capsules.md](references/style-capsules.md). The scene half of the prompt comes from the game
 contract in TEXT, not from a prior image: what the player is DOING
 mid-action (the verb), what threatens them right now (enemy silhouettes),
 what they are chasing (the objective — a finish gate, a goal, a pickup),
@@ -95,9 +87,9 @@ clickable links saying which one you picked and why — 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 for the yes with your environment's structured question tool** —
-Claude Code: `AskUserQuestion`; Codex: `request_user_input`; a short numbered
-list only where there is none (e.g. Cursor). ONE question — "this is roughly
+**Then ask for the yes with your question tool** — the one that shows the
+user clickable options; a short numbered list in chat only where there is
+none. ONE question — "this is roughly
 how the game and its HUD will look — keep this direction, or change
 something?" — with concrete keep / change options. This confirmation is
 REQUIRED for every game: the concept sets the STYLE every later asset
@@ -155,11 +147,10 @@ an invented mechanic, or the absence of a real one, from a picture.
 
 **4. Ask only when genuinely ambiguous.** If the concept pins the mood (a
 "gothic horror dungeon crawler" pins it), decide and state the plan in one
-line. Only when the art direction is truly open, ask ONE structured question
+line. Only when the art direction is truly open, ask ONE question
 with 2–3 concrete directions, each naming its palette + font pair — using
-your environment's structured question tool when it has one (Claude Code:
-`AskUserQuestion`; Codex: `request_user_input`); if it has none (e.g.
-Cursor), a short numbered list in chat. Never ask about the screen
+your question tool when you have one; if you have none, a short numbered
+list in chat. Never ask about the screen
 inventory — it derives from the game type.
 
 **5. Style follows THIS game's concept.** The examples in every Genex skill
@@ -463,43 +454,18 @@ 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.
-- **CSS-shaped corners must survive their contents.** `border-radius`,
-  `clip-path`, and `mask` are all fair ways to shape a panel or button —
-  including a chamfered/notched "hi-tech" corner in pure CSS. What is
-  non-negotiable is the execution: the cut must never shear off anything
-  that sits near the corner (text, padding, the focus ring, a glow) — keep
-  enough inner padding that content clears the cut shape — and the result
-  must be clean, not crooked: no jagged aliased diagonals, no half-clipped
-  borders or shadows, no text colliding with an edge or truncating. The
-  same bar applies to CSS plates. Verify the corners at real sizes over
-  real gameplay. When the art direction wants a genuinely ornamented
-  frame, a generated frame sprite (`$genex-ai-hud` chrome, or a Tier-3
-  9-slice panel) is still the richer tool. The masked-fill HUD reveal and
-  `genex ui` masks remain the other established uses of `mask`/`clip-path`.
-  - **The #1 chamfer defect: a frame that STOPS at the cut.** A plain
-    `border` or `box-shadow` does NOT follow a `clip-path` chamfer — the clip
-    shears it off along the diagonal, so the straight sides keep their frame
-    while the cut edge goes bare and the panel reads as broken. Two clean
-    fixes: prefer **`border-radius`** when a soft corner reads fine (it keeps
-    its `border` natively — no clip needed); for a HARD angular cut, draw the
-    frame by clipping TWO stacked layers to the SAME polygon — outer = the
-    frame, inner (inset by the frame width) = the fill — so the outer shows
-    through as a uniform edge on the diagonal too:
-
-    ```css
-    /* Chamfered panel whose frame follows the cut. Never `border` + clip-path. */
-    .panel {
-      --chamfer: 16px; --edge: 2px;                  /* --edge = frame width */
-      --cut: polygon(var(--chamfer) 0, 100% 0, 100% calc(100% - var(--chamfer)),
-        calc(100% - var(--chamfer)) 100%, 0 100%, 0 var(--chamfer));
-      clip-path: var(--cut); background: var(--frame-hue);  /* this IS the frame */
-      padding: var(--edge);                          /* revealed all around, incl. the diagonal */
-    }
-    .panel > .panel__fill { clip-path: var(--cut); background: var(--plate-hue); }
-    ```
-
-    Same rule for chamfered buttons and any notched plate; verify the frame
-    is unbroken at every corner over real gameplay.
+- **Panel and button corners come from `border-radius` or a generated frame
+  sprite — never a raw `clip-path`/`mask` chamfer.** A CSS-cut angular corner
+  is the recurring "cut corners" defect: the clip shears off borders, shadows,
+  and any content that sits near the corner, and it re-breaks the instant the
+  padding, font, or value length changes — so it can only be held together by
+  a per-build visual check that is easy to skip. It is not worth that fragility.
+  For a soft corner use `border-radius` (it keeps its `border`/`box-shadow`
+  natively). For a genuinely angular or ornamented "hi-tech" frame, generate it
+  as chrome (`$genex-ai-hud`, or a Tier-3 9-slice panel) and lay the DOM over
+  it — that reads richer and physically cannot shear. `mask`/`clip-path` stay
+  reserved for their ONE established HUD use: the masked-fill progress reveal
+  driven by `genex ui` masks. Never for corner shaping.
 - **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

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

@@ -11,10 +11,13 @@ 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 for bare
 text over arbitrary scenes (never a second plate stacked behind an opaque
-frame sprite), and panel/button corners executed cleanly — `border-radius`,
-a CSS `clip-path`/`mask` shape, or a generated frame all work, as long as the
-cut never clips content (text, padding, glow), stays free of jagged-edge
-artifacts, and text never collides or truncates.
+frame sprite), and panel/button corners done the durable way — `border-radius`
+for soft corners (it keeps its `border`/`box-shadow` natively), or a generated
+frame (`$genex-ai-hud` chrome / a Tier-3 9-slice panel) with the DOM laid over
+it for genuinely angular looks. Raw CSS `clip-path`/`mask` corner cuts are
+banned per the skill — they shear borders, shadows, and near-corner content,
+and re-break on any padding/font change; `mask`/`clip-path` stay reserved for
+their ONE established HUD use, the masked-fill progress reveal.
 
 ## Fantasy / action RPG
 

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

@@ -67,8 +67,7 @@ Infer this yourself when the experience is clear. Do **not** make the player cho
 preset, or config. Ask one plain-language question only when the design genuinely supports both
 models and the answer changes the experience — for example: *"Should this be one ongoing arena
 people drop into, or a fresh fair match that waits for everyone and then starts together?"*
-(Use your environment's structured question tool when it has one — Claude Code:
-`AskUserQuestion`; Codex: `request_user_input`; if it has none, e.g. Cursor, a short numbered
+(Use your question tool when you have one; if you have none, a short numbered
 list in chat.)
 
 | Player experience | Model | Why |

package/templates/skills/genex-threejs-visual-validation/SKILL.md

@@ -40,10 +40,8 @@ Meshy Image-to-3D first produces an unremeshed high-detail model. Show its
 front, back, left, and right views and report its measured face count. Preserve
 that model in R2. Before rigging, ask the user to approve a separate
 10,000-face triangle remesh. The 10k remesh—not the high-detail source—is
-rigged and animated. (For these approvals, use your environment's structured
-question tool when it has one — Claude Code: `AskUserQuestion`; Codex:
-`request_user_input`; if it has none, e.g. Cursor, a short numbered list in
-chat.)
+rigged and animated. (For these approvals, use your question tool when you
+have one; if you have none, a short numbered list in chat.)
 
 The selected high-detail model remains in a neutral A-pose before animation.
 Record evidence that the user saw its four views and face count before