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

package/dist/index.js

@@ -287,7 +287,7 @@ async function hasGenexSkills(skillsDir) {
     return false;
   }
 }
-var REMOVED_SKILLS = ["genex-explore"];
+var REMOVED_SKILLS = ["genex-explore", "genex-threejs-skill-router"];
 async function pruneRemovedSkills(skillsDir, log) {
   const removed = [];
   for (const name of REMOVED_SKILLS) {
@@ -1109,7 +1109,7 @@ async function writeProject(meta, cwd = process.cwd()) {
 import fs7 from "fs/promises";
 import path7 from "path";
 var DEFAULT_DASHBOARD_ORIGIN = new URL(DEFAULT_AUTH_URL).origin;
-function renderGenexConfig() {
+function renderGenexConfig(slug) {
   return `// src/genex.config.ts \u2014 written by \`genex init\`. DO NOT hardcode URLs here.
 //
 // Build once, run anywhere. The games host injects the serving environment into
@@ -1117,14 +1117,21 @@ function renderGenexConfig() {
 // bundle), so ONE build is correct on every stand \u2014 promoting a game is a copy,
 // never a rebuild, and an immutable bundle can never pin the wrong environment.
 // Vite env still overrides, but is loaded ONLY by \`npm run dev\`:
-//   .env                    -> VITE_GENEX_SLUG (this game's identity; committed)
+//   .env                    -> VITE_GENEX_SLUG (local override for \`npm run dev\`)
 //   .env.development.local  -> local-stack URL overrides (dev mode ONLY; gitignored)
+//
+// The slug is ALSO baked as a literal below, on purpose: \`genex preview/publish\`
+// excludes .env from the source push (it's treated as a secret file), so a clone of
+// the published repo has no .env. Reading the slug from env ALONE would then build
+// \`slug: undefined\` -> the guest-session call posts {} -> 400 -> guests can't play a
+// remixed game. The literal keeps a bare clone rebuilding into a working game; the
+// env var still wins locally.
 const injected: { apiUrl?: string; dashboardOrigins?: string[] } =
   (typeof window !== "undefined" && (window as { __GENEX__?: unknown }).__GENEX__) as
     | { apiUrl?: string; dashboardOrigins?: string[] }
     | undefined ?? {};
 export const GENEX = {
-  slug: import.meta.env.VITE_GENEX_SLUG as string,
+  slug: (import.meta.env.VITE_GENEX_SLUG as string | undefined) ?? ${JSON.stringify(slug)},
   apiUrl:
     (import.meta.env.VITE_GENEX_API_URL as string | undefined) ??
     injected.apiUrl ??
@@ -1170,7 +1177,7 @@ async function writeIfAbsent(file, content, log) {
 }
 async function writeGameConfigFiles(meta, log, cwd = process.cwd()) {
   await fs7.mkdir(path7.join(cwd, "src"), { recursive: true });
-  await writeIfAbsent(path7.join(cwd, "src", "genex.config.ts"), renderGenexConfig(), log);
+  await writeIfAbsent(path7.join(cwd, "src", "genex.config.ts"), renderGenexConfig(meta.slug), log);
   await writeIfAbsent(path7.join(cwd, ".env"), renderSlugEnv(meta.slug), log);
   const overrides = renderDevOverrides(meta);
   if (overrides) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.78.1-dev.203",
+  "version": "0.80.2-dev.213",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/README.md

@@ -17,5 +17,5 @@ command keeps them in sync with the installed CLI version automatically
 - `agents/` - example subagent definitions.
 - `commands/` - example slash commands.
 
-Start with `skills/genex-threejs-skill-router/SKILL.md` when asking your agent
+Start with `skills/genex-game-director/SKILL.md` when asking your agent
 to build or improve a 3D browser game.

package/templates/controllers/character/character-controller.ts

@@ -88,6 +88,36 @@ type ResolvedMovementInput = {
 /** Crouch input interpretation — see {@link CharacterControllerOptions.crouchMode}. */
 export type CrouchMode = "toggle" | "hold";
 
+/**
+ * The over-the-network snapshot of a character. Publish it every fixed tick with
+ * `room.me.set(character.netState())`; apply a remote's smoothed copy with
+ * `applyNetState(remoteObject, players.get(id).state)`.
+ *
+ * `y` is the SETTLED body height while grounded: the float-spring's idle up/down
+ * oscillation is removed, so a standing remote player does NOT bob in place.
+ * Publish this — never `currPos`, which is the raw physics capsule and bobs on
+ * its suspension spring. Numbers are rounded to ~cm; rotation is a 4-number
+ * quaternion (never a scalar yaw — that lerps the long way across ±π). The six
+ * booleans drive a remote's CharacterAnimations.
+ */
+export interface NetState {
+  x: number;
+  y: number;
+  z: number;
+  q: [number, number, number, number];
+  onGround: boolean;
+  falling: boolean;
+  moving: boolean;
+  running: boolean;
+  jumping: boolean;
+  crouching: boolean;
+}
+
+/** Round a networked number to ~cm precision (raw floats serialize as 17-digit JSON). */
+function roundNet(v: number): number {
+  return Math.round(v * 100) / 100;
+}
+
 export interface CharacterRecoveryEvent {
   reason: "non-finite" | "out-of-bounds";
   position: { x: number; y: number; z: number };
@@ -484,6 +514,8 @@ export class CharacterController {
   private slideFrictionCoef = 0;
   private standingPointFriction = 0;
   private readonly standingPoint = new THREE.Vector3();
+  /** Scratch for {@link netPos} — the float-oscillation-free networked position. */
+  private readonly _netPos = new THREE.Vector3();
   private readonly characterMassImpulse = new THREE.Vector3();
   private readonly movingObjectPosition = new THREE.Vector3();
   private readonly movingObjectVelocity = new THREE.Vector3();
@@ -648,6 +680,29 @@ export class CharacterController {
   get currPos(): THREE.Vector3 {
     return this.currentPos;
   }
+  /**
+   * Body position to PUBLISH over the network. Identical to {@link currPos} while
+   * airborne (jump/fall arcs must survive), but while grounded the up-axis
+   * component is snapped to the SETTLED float height above the ground — removing
+   * the suspension-spring idle oscillation that otherwise makes a standing remote
+   * player bob up and down. Publish this (via {@link netState}), never `currPos`.
+   * Live vector — copy it if you keep it. Follows custom gravity (up = bodyYAxis).
+   */
+  get netPos(): THREE.Vector3 {
+    this._netPos.copy(this.currentPos);
+    if (this._isOnGround) {
+      // currPos bobs because the float spring holds the capsule a VARYING gap
+      // above the ground each step. standingPoint is the STATIC ground contact;
+      // the settled center→ground gap (along up) is groundFloatingDistance −
+      // rayOriginOffset. Shift the up component by (settled − current) so the
+      // published height is the settled one, not the oscillating one.
+      const gapNow =
+        this._netPos.dot(this.characterYAxis) - this.standingPoint.dot(this.characterYAxis);
+      const gapSettled = this.groundFloatingDistance - this.rayOriginOffset;
+      this._netPos.addScaledVector(this.characterYAxis, gapSettled - gapNow);
+    }
+    return this._netPos;
+  }
   /** Body rotation (this step). Live quaternion. */
   get currQuat(): THREE.Quaternion {
     return this.currentQuat;
@@ -799,6 +854,32 @@ export class CharacterController {
   // Public methods
   // ────────────────────────────────────────────────────────────────────────
 
+  /**
+   * The snapshot to PUBLISH for multiplayer, in one call:
+   * `room.me.set(character.netState())` — on the fixed 10–20 Hz tick, never per
+   * frame. Position is {@link netPos} (float-oscillation-free, so remotes never
+   * bob), rotation is a 4-number quaternion, plus the six animation booleans a
+   * remote feeds to its own CharacterAnimations. Numbers are rounded to ~cm to
+   * keep the wire small. This is the ONLY position you should network — reaching
+   * for `currPos` here is the classic "standing remote player bobs" bug.
+   */
+  netState(): NetState {
+    const p = this.netPos;
+    const q = this.currentQuat;
+    return {
+      x: roundNet(p.x),
+      y: roundNet(p.y),
+      z: roundNet(p.z),
+      q: [roundNet(q.x), roundNet(q.y), roundNet(q.z), roundNet(q.w)],
+      onGround: this.isOnGround,
+      falling: this.isFalling,
+      moving: this.isMoving,
+      running: this.runActive,
+      jumping: this.jumpActive,
+      crouching: this.crouchActive,
+    };
+  }
+
   /**
    * Merge movement intents into the input state. Only fields you pass are
    * changed, so different input sources (keyboard, joystick, buttons) can each
@@ -1927,3 +2008,19 @@ export class CharacterController {
     d.velocityArrow.setLength(this._relativeVel.length() / this.targetMoveSpeed(this._runActive));
   }
 }
+
+/**
+ * Apply a remote player's networked snapshot to their VISUAL object (a plain
+ * Object3D — never a CharacterController; remotes are interpolated visuals, not
+ * simulated). Read the SMOOTHED copy the SDK exposes so motion glides:
+ * `applyNetState(remoteObject, players.get(id).state)`. The six booleans
+ * (`s.onGround`, `s.falling`, …) feed that remote's CharacterAnimations
+ * separately — see the character-controller skill's multiplayer rule.
+ */
+export function applyNetState(target: THREE.Object3D, s: NetState): void {
+  target.position.set(s.x, s.y, s.z);
+  // normalize: netState() rounds each quaternion component to ~cm precision, so the 4-tuple is
+  // almost never exactly unit — Three.js bakes a non-unit quaternion straight into the matrix as a
+  // small (~0.4%) scale that shifts as the remote turns. One call keeps remotes at true scale.
+  target.quaternion.set(s.q[0], s.q[1], s.q[2], s.q[3]).normalize();
+}

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

@@ -43,10 +43,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 high-detail pre-rig generation stays in the selected neutral A-pose. There
 is no dynamic-pose concept and no silent T-pose fallback. After the user has

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

@@ -48,14 +48,12 @@ ring) that no hand-written CSS can fake.
   semi-transparency physically cannot survive sprite extraction: a composited
   panel's pixels are a blend of panel and background, and no cutout can
   un-blend them. Plates are NEVER baked into sprites. Give the plate its
-  corners with `border-radius` or a clean `clip-path`/`mask` shape — a CSS
-  chamfer/notch is allowed, as long as the cut never clips the plate's
-  content (text, padding, a glow), leaves no jagged-edge artifacts, and
-  nothing ends up crooked — and a plain `border`/`box-shadow` won't follow a
-  `clip-path` cut, so use `$genex-threejs-game-ui`'s two-layer chamfer-border
-  recipe when a chamfer needs a frame; a genuinely ornamented angular frame is still
-  best as chrome, generated. The load-bearing `mask`/`clip-path` in this
-  skill is the masked-fill reveal below.
+  corners with `border-radius` — **never a raw `clip-path`/`mask` chamfer**
+  (it shears off borders, shadows, and content near the cut and re-breaks on
+  every padding/value change: the recurring "cut corners" defect). A genuinely
+  ornamented or angular frame belongs in chrome, generated. The one
+  load-bearing `mask`/`clip-path` in this skill is the masked-fill reveal
+  below — never corner shaping.
 - **Chrome (sprites — what THIS pipeline generates).** Opaque frames, corner
   brackets, ornaments, emblems, icons, medallions — hard-alpha art laid over
   the glass. The Stage-2 sheet contains ONLY chrome; never a panel with its
@@ -82,7 +80,7 @@ ring) that no hand-written CSS can fake.
   the container is the sprite and the content is DOM — the default split.
 - **Rule B — image vs code (the 5-minute test).** If CSS can build the
   element in under ~5 minutes without losing fidelity — flat plates, simple
-  dots/pips, plain strokes, a chamfered corner — it is CSS. If it needs
+  dots/pips, plain strokes, a rounded corner — it is CSS. If it needs
   craft (material, ornament, painterly texture), it is a sprite. One
   exception cuts the other way: a static label engraved/embossed into a
   frame's craft stays BAKED in the sprite (`baked_static` below) even
@@ -90,9 +88,10 @@ ring) that no hand-written CSS can fake.
 - **CSS-chrome recipes — the middle ground.** Between bare CSS and the full
   sprite pipeline sits brief-styled CSS chrome, right for utilitarian panels
   and secondary screens: a two-hue gradient frame (border + inset
-  box-shadow in brief hues), a clip-path chamfer (execution bar per
-  `$genex-threejs-game-ui`'s corner rules), a 9-slice-ish panel from nested
-  divs (outer div = border hue, inset div = plate hue, 2–3px reveal). What
+  box-shadow in brief hues), rounded with `border-radius` (never a raw
+  `clip-path` chamfer — see `$genex-threejs-game-ui`'s corner rules), a
+  9-slice-ish panel from nested divs (outer div = border hue, inset div =
+  plate hue, 2–3px reveal). What
   makes these legitimate: **CSS elements are styled FROM THE BRIEF — hue,
   weight, texture. Default-gray CSS anywhere on screen is a defect** (the
   classic failure: score pips shipped as unstyled "○ ●" system glyphs).
@@ -219,8 +218,16 @@ serves as the user's style checkpoint, and anchors all later art
 is frame-anchored, so it waits for the user's keep/change YES on that
 checkpoint — kick it off the instant they approve, not before.** The scene half
 of the prompt is written in TEXT from the game plan — `[GAME_SCENE]` in the
-Stage-1 template: setting, the moment, what the player is doing, lighting —
-never `--edit`-anchored to a prior image (there is none). Then write the
+Stage-1 template: setting, the moment, what the player is doing, lighting.
+**If a concept/reference image already exists — the user's own concept art, or
+a look frame you generated and they approved — anchor Stage 1 to it with
+`--edit <that-url>` so the HUD inherits its exact palette, materials, and
+lighting; that anchoring is what makes the final HUD actually match the
+concept, and skipping it is why a text-only mockup drifts.** A text-only
+Stage 1 is the fallback for when no reference exists. (To `--edit` a
+user-supplied image it must be reachable as an R2 URL — a bare chat attachment
+is not; reproduce it as a generation first, or say plainly you can't anchor to
+it rather than silently guessing.) Then write the
 widget layout and wiring code (placement, masked-fill scaffolding,
 plain-CSS placeholder bars) while it renders — the CSS HUD keeps
 the game playable until the sprites land. When a sprite lands it REPLACES
@@ -238,8 +245,9 @@ re-run from Stage 1 with their notes — cheaper than it sounds (one image
 is the whole concept now), so say so in one line and do it.
 
 ```bash
-# Stage 1 — the game CONCEPT: full HUD composited over the game's own scene,
-# described in TEXT (one generation covers concept + layout reference).
+# Stage 1 — the game CONCEPT: full HUD composited over the game's own scene.
+# TEXT-described; add `--edit <concept-url>` to anchor it to an existing
+# concept/reference image so the HUD inherits its exact style.
 # Two candidates in one call; pick the better, save its URL:
 npx genex image "<filled stage-1 prompt>" --size 2560x1440 --quality high --candidates 2
 
@@ -492,6 +500,13 @@ Two hard rules:
 
 ## Verify before calling it done
 
+**This is a gate, not a suggestion — the HUD is not "done", does not ship, and
+is not called a milestone until you have looked at it running.** The field
+failure is an agent that wires the sprites, takes one glance, notices a possible
+clip or cutoff, and ships anyway with "I'll refine if the user reports issues."
+That punt IS the defect. You are the one who verifies, not the user. If you are
+out of budget to check, say the HUD is unverified — never call it done.
+
 - **Open every extracted PNG and eyeball it** — right subject, right name.
   The reading-order sort can mismap when rows are uneven; re-run `extract`
   with corrected name order rather than regenerating anything.
@@ -502,9 +517,11 @@ Two hard rules:
   Display fonts run 25–50% wider than a naive estimate; widen the box or drop
   the weight, don't shrink the font.
 - **No widget overlaps** at the reference viewport, and none off-screen.
-- **Screenshot-check over real gameplay** — bright AND dark scenes — with
-  `$genex-threejs-visual-validation`'s capture discipline. Judge the pixels,
-  not your intent.
+- **Screenshot the running HUD and inspect it** — bright AND dark scenes —
+  with `$genex-threejs-visual-validation`'s capture discipline. **Zoom every
+  corner:** no sheared frames, no clipped/cut corners, no text truncated or
+  colliding with an edge. Judge the pixels, not your intent — skipping this is
+  exactly how the "cut corners" defect ships.
 
 ## The closing wiring audit — the pipeline's final stage, not optional
 
@@ -536,6 +553,16 @@ does not count. fillBox numbers, `segments`, and real sprite dims do not
 survive paraphrase; the canonical version of this failure is a subagent
 reporting "masks validated" while the parent ships width% fills.
 
+**Do not fire-and-forget the whole HUD/menu/logo into one background subagent.**
+The field failure: the entire production art pipeline was handed to a single
+background agent that then stalled overnight, so every preview the user played
+showed the CSS placeholder and the real HUD only landed hours later, unseen. If
+art runs in a subagent it is a BOUNDED task you wait on, then wire and verify in
+THIS session — not an overnight handoff. While the art is pending the HUD is
+unverified: do not call the game done or push it as a finished milestone. If a
+subagent stalls or misses its window, wire what landed and say plainly what is
+still placeholder — never present a placeholder HUD as the finished look.
+
 ## Cost & latency honesty
 
 A full HUD is **~9 image generations** (mockup + deconstruct + clean + a few

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

@@ -370,13 +370,14 @@ not):
   re-anchored the look) re-opens this rule once — re-edit the still
   (`--edit` against the new concept mockup) and re-run the video from the
   new still. Agent-initiated polish never does.
-- **1080p is the default — leave it.** The menu clip is full-screen key art,
-  the first moving thing the player sees, and 720p visibly softens it on any
-  modern display. `genex video` renders 1080p by default; pass
-  `--resolution 720p` only as an explicit cost fallback (about half the
-  credits) when the user asks to economize. The flip side of 1080p: getting
-  the phone rule above wrong now costs twice as much bandwidth — poster on
-  phone tiers, always.
+- **The menu (`--frame`) path renders 720p — don't force 1080p.** The
+  frame-conditioned first-last-frame route was rejected by the provider at
+  1080p (repeated 422 failures that shipped a dead static menu), so the menu
+  video path defaults to the proven-good, seamless-looping 720p — no flag
+  needed. The DOM crossfade + full-screen scale read fine at 720p; do NOT pass
+  `--resolution 1080p` on a `--frame` menu clip just to sharpen it, or you risk
+  re-triggering the 422 and losing the video entirely. (Plain text-to-video,
+  without `--frame`, still defaults to 1080p.)
 - **Pause/victory/defeat variants reuse the same video — as GRADES.** Same
   `<video>` element or URL, different emotion via CSS `filter` on the
   background: pause = a plain dark overlay (`rgba(0,0,0,0.55)`); defeat =
@@ -406,9 +407,11 @@ not):
   genuine state change; expect a loop seam.
 - `--duration <sec>` (video) — 4, 6, or 8 for frame-conditioned clips;
   default 8.
-- `--resolution <720p|1080p>` (video) — default 1080p; `720p` is the
-  explicit cost fallback (~half the credits). Loop clips (`--loop`) ignore
-  it (that model has no resolution parameter).
+- `--resolution <720p|1080p>` (video) — plain text-to-video defaults to 1080p;
+  the frame-conditioned (`--frame`) menu path defaults to **720p** for
+  reliability (1080p was rejected there). `720p` is also the cost fallback
+  (~half the credits). Loop clips (`--loop`) ignore it (that model has no
+  resolution parameter).
 - `--aspect 16:9 --quality high` (image) — the right settings for a menu frame.
 - `--no-wait` — enqueue and return immediately with the generation id; pick
   the result up later with `npx genex wait <id>` (safe to re-run — it attaches

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

@@ -87,16 +87,22 @@ const gltf = await loadModelWithFallback(
   MODEL_URL, tier, (u) => gltfLoader.loader.loadAsync(u), { ktx2: gltfLoader.ktx2 },
 );
 const model = gltf.scene;
-// Clamp the provider's mirror-metal PBR (metalness~1 reflects the whole sky
-// env and swims with every camera move):
+// Tame ONLY the provider's mirror-metal artifact (metalness≈1 + near-zero
+// roughness mirrors the whole sky env and swims with every camera move). Do
+// NOT flatten every material to 0.6 — that was dulling legitimately metallic
+// props (gunmetal, chrome, gold, polished stone). Clamp the extreme case only;
+// leave everything else as authored.
 model.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; // still reads metallic, no longer a full mirror
+    m.roughness = Math.max(m.roughness, 0.3);
   }
+  m.envMapIntensity = Math.min(m.envMapIntensity, 0.8);
 });
+// If a model that SHOULD read metallic still looks dull, this clamp is not the
+// cause — check the model against the concept and lift per-material as needed.
 model.scale.setScalar(1); // tune to taste
 model.position.set(0, 0, 0);
 scene.add(model);