@genex-ai/cli-demo 0.78.1-dev.203 → 0.80.2-dev.213

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
@@ -320,11 +318,16 @@ it. Simulating remote players' physics locally guarantees divergence — every
 client would compute a different world. Never render every remote with your
 own avatar file: players picked their looks, show them.
 
-- Publish your own `currPos` + `currQuat` as a four-number quaternion on the fixed 10–20 Hz tick,
-  not per frame. Never reduce multiplayer rotation to scalar yaw.
-- To animate remotes, sync the six animation booleans (`isOnGround`,
-  `isFalling`, `isMoving`, `runActive`, `jumpActive`, `crouchActive`) and feed
-  them to a per-remote `CharacterAnimations` — see the animations reference.
+- **Publish `character.netState()`** on the fixed 10–20 Hz tick (never per frame):
+  `room.me.set(character.netState())`. It bundles the network-safe position, a four-number
+  quaternion, and the six animation booleans in one call. It uses `netPos`, **not** `currPos` —
+  `currPos` is the raw physics capsule whose Y bobs on the float-suspension spring, so publishing
+  it makes a *standing* remote player visibly bob up and down. `netState()` snaps the grounded Y to
+  the settled height (raw while airborne, so jumps still arc). Never reduce rotation to a scalar yaw.
+- On each remote, apply the SDK's **smoothed** copy with
+  `applyNetState(remoteObject, players.get(id).state)` (sets position + rotation), and feed the same
+  six booleans (`onGround`, `falling`, `moving`, `running`, `jumping`, `crouching`) to that remote's
+  `CharacterAnimations` — see the animations reference. Never publish `currPos` directly.
 - Only the owning client runs `MotionActionDriver`. Remotes play the same
   one-shot event while following smoothed owner-authored position/rotation;
   their animation mixer never moves them through the world.

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 |
@@ -621,6 +620,12 @@ than silently disappearing. The budget math that matters:
    `players.get(id).state` directly (already smoothed); every object from `objects.get(id).state`.
 4. **Create-or-reuse one mesh per id**; remove a player's mesh on `'leave'`.
 
+> **Physics character?** If your player is the `genex controller character` capsule, do NOT
+> hand-build the state from the body position — publish `room.me.set(character.netState())` and
+> apply remotes with `applyNetState(mesh, players.get(id).state)`. The controller's raw `currPos.y`
+> bobs on its float-suspension spring; `netState()` publishes a settled ground Y so a standing remote
+> doesn't bob. See `$genex-threejs-character-controller` → "Multiplayer rule".
+
 ## Rotation: sync a quaternion, not an angle
 
 Send rotation as a 4-number quaternion `q: mesh.quaternion.toArray()`; on the remote do

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