@genex-ai/cli-demo 0.78.0-dev.200 → 0.80.0-dev.211

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

@@ -112,11 +112,13 @@ and `$genex-ai-texture` skills show the wiring in place.
 
 ## Generated models: load through the rungs
 
-Generated GLBs are provider-raw — multiple 1–4K PBR textures + dense geometry.
-Every model ships a `@1024` mobile rung (textures budgeted to 1024, meshopt-
-compressed, simplified where safe) plus a `.ktx2` sibling whose textures stay
+Provider-raw GLBs are NOT game assets: one prop is ~500k triangles + several
+4K PBR textures (a pilot scene of them submitted 66M triangles/frame and
+floored an M4 Max). Every model ships a game-ready ladder — `@2048` (the
+desktop rung) and `@1024` (the phone rung), both meshopt-compressed and
+simplified where safe, each with a `.ktx2` sibling whose textures stay
 compressed ON the GPU (~6× less texture VRAM). A plain `GLTFLoader` can decode
-neither — wire the decoders once and load through the ladder:
+none of them — wire the decoders once and load through the ladder:
 
 ```ts
 import { createGltfLoader } from "./controllers/quality/gltf-loader.ts";
@@ -126,11 +128,24 @@ 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 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) 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);
+});
 ```
 
-Fallback chain: `.ktx2` rung → universal `@1024` rung → original — each step
-warns, the worst case is today's full download, never a broken boot. Desktop
-always loads the original. Meshy characters take the same ladder through
+Fallback chain: `.ktx2` rung → the tier's universal rung (`@2048` desktop,
+`@1024` phones) → original — each step warns; the original is archival/remix
+source, fetched only as the fallback of last resort. Meshy characters take
+the same ladder through
 `loadMeshyCharacter(manifestUrl, { loader: gltfLoader.loader, modelUrlCandidates: (u) => [pickModel(u, tier, { ktx2: gltfLoader.ktx2 }), pickModel(u, tier), u] })`.
 KTX2-capable games can also pass `ktx2Load` to `loadTextureWithFallback` so
 skyboxes/textures use their `.ktx2` variants.
@@ -149,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-adaptive-quality/references/adaptive-quality.md

@@ -22,7 +22,7 @@ cost of guessing high is a dead page.
 | Shadow map | 512 (static-cached) | 1024 | 1024 | 2048 |
 | Post level | tone map only | + FXAA/vignette | + FXAA/vignette | full named stack |
 | Skybox rung | @2048 (~11 MB) | @4096 (~45 MB) | original | original |
-| Model rung | @1024 (+.ktx2 when wired) | @1024 (+.ktx2 when wired) | original | original |
+| Model rung | @1024 (+.ktx2 when wired) | @1024 (+.ktx2 when wired) | @2048 (+.ktx2) | @2048 (+.ktx2) |
 | Texture rung (props) | @1024 | @2048 | original | original |
 | Particles/scatter | 0.25× | 0.5× | 0.75× | 1× |
 | Draw distance | 0.5× | 0.75× | 1× | 1× |
@@ -69,6 +69,12 @@ Getting this wrong produces silent no-ops or a session stuck ugly:
   fog, LOD bias, particle counts, mixer update rates, frame cap, remote-avatar
   animation count. Light `intensity` is runtime-free; light COUNT is not (see
   above).
+- **Shadow maps of STATIC lights render once, not per frame:** shadow maps
+  default to re-rendering every frame, and a PointLight's is a 6-face cube —
+  four static shadow lanterns = 24 redundant passes/frame over the whole
+  caster set (measured 66M submitted triangles/frame in a pilot). Freeze them:
+  `light.shadow.autoUpdate = false; light.shadow.needsUpdate = true;` — only
+  the key light that shadows moving actors stays dynamic.
 
 ## Governor mechanics
 
@@ -113,9 +119,15 @@ Getting this wrong produces silent no-ops or a session stuck ugly:
 - Watch `renderer.info.memory.{textures,geometries}` across swaps in dev; a
   monotonic climb is a leak marching toward the OS kill. The governor
   publishes these counts for the platform's field telemetry.
-- Prefer meshopt/instanced geometry for repeats; `BatchedMesh` batches
-  HETEROGENEOUS static meshes into one draw where instancing (identical
-  meshes only) can't.
+- Prefer meshopt/instanced geometry for repeats: 3+ copies of the same
+  generated model → `InstancedMesh` (one draw call per source mesh instead of
+  per copy — `$genex-ai-model` has the collapse snippet); `BatchedMesh`
+  batches HETEROGENEOUS static meshes into one draw where instancing
+  (identical meshes only) can't.
+- Distance LOD comes free with the rung ladder: `THREE.LOD` with the phone
+  rung (`@1024`) as the far level — `lod.addLevel(near, 0);
+  lod.addLevel(far, 25)`. One extra fetch; worth it past ~25 m sightlines,
+  skip in small arenas.
 - Half-resolution transparency: render heavy particle/transparency passes to a
   half-size target and composite up — fill-rate is the phone bottleneck.
 

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),
@@ -82,44 +74,63 @@ game doesn't have (a lap counter in a game without laps). Generate it
 `--size 2560x1440 --quality high --candidates 2 --no-wait`, enqueued FIRST
 of all art; the picked candidate's URL goes into the style-brief comment.
 
-**Share it the moment it lands — queue first, show immediately, never wait.**
-When the mockup lands, pick the stronger of the two candidates yourself,
-enqueue the downstream 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 links. Paste BOTH candidates' URLs as
-clickable links in your message and say 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). Ask ONE keep-or-change question — "this
-is roughly how the game and its HUD 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 of YOUR pick; 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
-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-run Stage 1 — the concept mockup itself —
-with the user's exact notes (strictly CHEAPER than it used to be: one image
-carries scene + HUD, there is no separate concept to redo), then re-anchor
-the style-carrying art made against the old mockup: the menu still is
-re-edited (`--edit`) against the new mockup 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 deconstruct (Stage 2 onward, `$genex-ai-hud`)
-restarts from the new mockup. 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.
+**Describe the concept, show it, then get a YES before the style-dependent
+work fans out.** First lay the concept out in WORDS — the playable moment
+(the verb), what threatens the player, what they chase, how the space reads,
+and the brief's palette / materials / light / references — so the user is
+weighing a stated direction, not guessing at a picture. Generate the mockup
+FIRST of all art (`--candidates 2`) and get it in front of the user AS FAST
+AS POSSIBLE: pick the stronger candidate yourself, pick it up with
+`genex wait <id> --open` (or generate it with `--open`) so it opens in the
+user's browser AND prints the links, and paste BOTH candidates' URLs as
+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 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
+inherits, so the user gets a real say before that style is committed. This
+reverses the old "advisory, never gate" rule — the concept now gates, but
+ONLY the style-dependent work (below), never the whole build.
+
+**The yes gates the STYLE-DEPENDENT work — nothing else.** Until the user
+approves a frame, do NOT fan out the art or subagents that build ON the
+chosen look: the HUD Stage-2 deconstruct (from the picked candidate), the
+menu still + video (`--edit`-anchored to the mockup), and the logotype. (The core asset set — hero model, ground texture, skybox,
+sfx — is prompted from the game IDEA, not the picked image, and mostly
+survives a style change, so it does NOT wait: launch it up front with
+placeholders, re-rolling only the few that don't survive if the look shifts.)
+Everything else that does NOT depend on the look
+keeps moving at full speed IN PARALLEL — the scaffold and boot wiring, the
+core gameplay / network loop, the controller, and the gameplay-LOGIC subagent
+modules (world, quests, enemies, items — their structure comes from the
+contract, not the picture). The wait is therefore never idle: a slow-to-answer
+user still gets a walkable first version, and the instant they say yes the
+style pipeline launches against the frame they approved. (A user who vanishes
+entirely leaves the LOOK pending, not the game — the deliberate trade for
+never committing a style behind their back.)
+
+**Change reopens the loop, same shape.** If the user picks "change" — or
+comes back with notes immediately or an hour later — re-run Stage 1 (the
+concept mockup itself) with their exact notes (`--candidates 2–3` gives them
+options to choose from), open + link the new frame, and ask again the same
+structured way. Carry every note forward so each round compounds; if two
+rounds don't converge, offer 2–3 distinct directions instead of re-rolling
+blind. Each frame the user approves becomes the working style, and the
+style-dependent pipeline stays gated on the latest yes (strictly CHEAPER than
+it used to be: one image carries scene + HUD, there is no separate concept to
+redo). When the style actually changes after downstream art already ran,
+re-anchor it: the menu still is re-edited (`--edit`) against the new mockup
+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 deconstruct
+(Stage 2 onward, `$genex-ai-hud`) restarts from the new mockup. 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.
 
 **The concept anchors STYLE, not truth.** Palette, materials, light, and
 register come from the frame; CONTENT comes from the game contract. This
@@ -136,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
@@ -158,9 +168,11 @@ UI plan
 • Style: <4–5 named hues> · fonts <display> / <body>
 • References: <2–3 AAA games — one line on what's borrowed>
 • Menu: <archetype + button treatment, one-line reason from the brief>
-• Concept (HUD mockup): <generation id — 2 candidates>
-• Queued next: HUD sheet (Stage 2, from the picked mockup) · menu still →
-  video <or "no menu: reason"> · logotype <or "skipped: reason">
+• Concept (HUD mockup): <generation id — 2 candidates> — awaiting your keep / change
+• Queued ON YOUR YES (style-dependent): HUD sheet (Stage 2, from the picked
+  mockup) · menu still → video <or "no menu: reason"> · logotype <or
+  "skipped: reason">
+• Building now (style-independent): <core loop · logic modules already moving>
 • Deferred from mockup: <widgets the image invented but the game lacks — or "none">
 ```
 
@@ -178,7 +190,8 @@ A message missing any line means the gate did not run — go back and run it.
   every game), and the generated **logotype** — one `--transparent` wordmark
   in the brief's display register (`$genex-ai-menu`'s logotype step), default
   YES for every game with a menu; skipping it needs a one-line stated reason.
-  Enqueue the chain at the plan gate with `--no-wait`,
+  Enqueue this chain the instant the user approves the concept
+  (`--no-wait`) — it is style-dependent, so it waits on the yes — then
   keep building, pick results up with `npx genex wait <id>`, swap them in as
   they land. **Tier 2 must never block a playable v0 — but the game is NOT
   DONE until its Tier-2 assets have landed and been wired in** (the only
@@ -441,19 +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`.
+- **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
@@ -510,12 +522,19 @@ 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.
+- Style-dependent art fanned out before the user approved the concept — the
+  concept confirmation is REQUIRED and gates the look-dependent work (HUD
+  Stage 2, menu still/video, logotype, style-matched assets); OR the whole
+  build stalled waiting on that yes, when concept-INDEPENDENT work (scaffold,
+  core loop, logic subagents) must keep moving in parallel while it is pending.
 - A CSS-cut corner (`clip-path`/`mask`) that shears its own content — clipped
-  text or padding, a lost focus ring or glow, a jagged aliased edge — the
+  text or padding, a lost focus ring or glow, a jagged aliased edge, or a
+  border/frame that stops at the cut instead of following it — the
   technique is fine; the sloppy cut is the defect.
+- A rectangular semi-transparent plate protruding past an opaque/angular
+  widget frame — a dark box floating over the scene. The frame's own art is
+  the backing; a plate is only for bare-text/outline widgets and stays inside
+  the widget silhouette (`$genex-ai-hud`'s plate rule).
 - 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

@@ -9,11 +9,15 @@ the capsule says a racing HUD leans oblique and bottom-right-heavy; your brief
 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 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.
+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 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-lighting-design/SKILL.md

@@ -111,6 +111,13 @@ kill-switch diagnostic.
   legitimate time the population changes.
 - Couple a practical to its emitter: one color, one envelope, one on/off state.
 - The key owns shadows; practicals cast none until a shot proves they must.
+- **A shadow-casting practical that never moves gets a FROZEN map**: a
+  PointLight shadow is a 6-face cube render, re-drawn every frame by default —
+  four static lanterns cost 24 shadow passes/frame over your densest props for
+  zero visual change (a pilot game submitted 66M triangles/frame this way).
+  Set `light.shadow.autoUpdate = false; light.shadow.needsUpdate = true;` so
+  the cube renders once; keep only the key (which shadows the movers) dynamic,
+  and budget frozen practicals at ≤1024 map size.
 - Tune intensities only after the renderer baseline is locked — retuning the
   whole rig after a tone-mapping change is self-inflicted.
 - Never repair unbalanced light ratios with exposure — fix the lights.

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