@genex-ai/cli-demo 0.84.0-dev.215 → 0.86.0-dev.217

package/templates/skills/genex-game-director/references/design-contract.md

@@ -40,8 +40,8 @@ the bottom._
 
 ## Concept
 One paragraph: what the game is, what playing it feels like.
-Concept image: <asset URL> (candidate <n> — my pick, approved by the player
-on <date>)
+Concept image: <asset URL> (standing — shown <date>; player said
+<yes | nothing — pick stands | change → looped>)
 
 ## Core loop
 - **You do:** <primary verb — drive, shoot, build…>
@@ -61,19 +61,35 @@ Every plural noun from the request becomes a countable line:
 ## Screens & UI
 Screens: <loader, menu, HUD, pause, win/lose…> · Style brief: <one line>
 References: <2–3 named games> · Menu archetype: <name>
+HUD lane: <sprites (…) | CSS (…, one-line justification)> — mandatory line;
+the concept decides it (director §5) and the preview preflight checks for it
+Menu video: <yes (the default for every game) | declined (player's reason)>
 
 ## Assets — the generation plan AND the budget
 | Asset            | Kind        | Status                          | Wired? |
 |------------------|-------------|---------------------------------|--------|
-| Concept + HUD    | image       | landed → <URL> (candidate <n>)  | n/a    |
+| Concept + HUD    | image       | landed → <URL>                  | n/a    |
 | <main surface>   | texture     | generating (<id>)               | —      |
 | <hero model>     | model       | planned                         | —      |
 | Background music | music       | planned (one ~90s looping track)| —      |
-| Menu still+video | image+video | blocked on concept yes → queued | —      |
+| Menu still       | image       | enqueued on concept landing (<id>) | —   |
+| Menu video       | video       | waits: yes / next preview after still / style-only-left | — |
+| Logotype         | image       | enqueued on concept landing (<id>) | —   |
 Status flow: proposed → planned → generating (id) → landed (URL) → wired.
 (Optionally note the prompt gist per row — it makes style-change re-rolls one
 command.)
 
+**HUD pipeline state (sprites lane) — keep this current; it is how the
+pipeline survives a context compaction.** One row per stage with its
+generation id / output path, so a resumed session knows exactly where the
+chain stopped and what fires next:
+- Stage-1 mockup: <id → URL>
+- Stage-2 sheet: <id → URL>
+- Cleaned sheet: <id → URL>
+- Extracted sprites: <public/assets/hud/…>
+- Masks: <public/assets/hud/…-mask.png + sidecars>
+- Next stage: <what fires next, one line>
+
 ## World & scale
 <Size in numbers if open world; arena bounds otherwise. Streamed terrain? y/n>
 
@@ -89,7 +105,7 @@ click (when a Play screen exists).
 | World/terrain | src/world/** | sub-agent when available | walkable, matches World & scale |
 | Quests & dialogue data | src/content/** | sub-agent when available | counts match Content lines |
 | Enemies/AI | src/enemies/** | sub-agent when available | roster matches Content |
-| HUD chain (style-dependent) | src/ui/** | sub-agent AFTER concept yes | all screens from Screens & UI |
+| HUD chain (style-dependent) | src/ui/** | sub-agent on concept landing | all screens from Screens & UI |
 
 ## Decisions & changes
 - <date> — <one-liner per decision, including anything the player said no or
@@ -106,7 +122,7 @@ A scrap-robot arena shooter: you skate a magnetized junkyard bot around a
 crusher pit, blasting rival bots into spare parts before the magnet cycle
 pulls everything in. Fast, crunchy, thirty-second lives.
 Concept image: https://assets.genex.technology/g/rustyard/concept.png
-(candidate 2 — approved 2026-07-20)
+(standing — shown 2026-07-20; player said yes)
 
 ## Core loop
 - **You do:** skate + shoot
@@ -121,17 +137,26 @@ Concept image: https://assets.genex.technology/g/rustyard/concept.png
 Screens: loader, title menu, HUD (health, scrap, cycle timer), pause,
 win/lose. Style brief: oily metal, warning-stripe accents, stencil type.
 References: <three named AAA games>. Menu archetype: hangar pan.
+HUD lane: sprites (stencil-cut metal meters + riveted scrap counter — ornate
+material chrome, CSS can't pass for it)
+Menu video: yes
 
 ## Assets
 | Asset            | Kind    | Status                     | Wired? |
 |------------------|---------|----------------------------|--------|
-| Concept + HUD    | image   | landed → <URL> (cand. 2)   | n/a    |
+| Concept + HUD    | image   | landed → <URL>             | n/a    |
 | Junkyard ground  | texture | landed → <URL>             | yes    |
 | Player bot       | model   | generating (gen_8f2k)      | —      |
 | Rival bot        | model   | planned                    | —      |
 | Overcast sky     | skybox  | landed → <URL>             | yes    |
 | Blaster zap      | sfx     | landed → <URL>             | yes    |
-| Menu still+video | image+video | blocked on concept yes | —      |
+| Menu still       | image   | landed → <URL>             | —      |
+| Menu video       | video   | waiting (still landed — fires at yes / next preview / style-only-left) | — |
+| Logotype         | image   | generating (gen_9t3m)      | —      |
+
+HUD pipeline state: Stage-1 mockup gen_7a1x → URL · Stage-2 sheet gen_7b2y →
+URL · cleaned gen_7c3z → URL · extracted public/assets/hud/ · masks derived ·
+next: wire masked fills
 
 ## World & scale
 One 60×60 m arena, walled; no streaming.

package/templates/skills/genex-game-director/references/routing-map.md

@@ -88,24 +88,28 @@ Three.js release or branch, and do not blindly copy demo architecture.
    decided silently. FIRST of all art, generate the gate's **concept mockup** —
    a playable-moment shot (verb + threat + objective in frame, per the
    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 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
-   whenever the menu decision is yes — the default for every game, "it's only
-   a draft" is not a reason to decide no — plus the logotype). The instant
-   they say yes, fire those with `--no-wait` (pick them up with
-   `npx genex wait <id>`); the game-ui skill owns the re-anchor loop when notes
-   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 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.
+   Stage-1 image, ONE generation serving as concept, style checkpoint, and
+   HUD blueprint (never a separate UI-free concept first, and no candidate
+   variants unless the player asks for them). **The moment it lands, the
+   cheap style chain fires — nothing waits for the player here**: decide the
+   HUD lane as art director and record the `HUD lane:` line in DESIGN.md
+   (director §5), then enqueue with `--no-wait` the `$genex-ai-hud` Stage-2
+   sheet, the `$genex-ai-menu` still (the menu is the default for every
+   game — "it's only a draft" is not a reason to decide no), and the
+   logotype. THEN show the player the frame and ask keep-or-change through
+   your question tool (a short numbered list in chat when you have none) —
+   the answer is INFORMATION, never a gate: silence means the concept
+   stands; "change" loops the concept with their notes and the chain re-runs
+   from the new frame (image-priced — cheap by design; the game-ui skill
+   owns the re-anchor loop). Only the menu VIDEO waits, for the FIRST of:
+   the player's yes · the next `genex preview` after the menu still landed ·
+   style work being the only work left — and never while a player objection
+   is open (two failed videos → ship the still). Later `--edit`-able
+   generations anchor to the standing frame for STYLE while the game
+   contract owns content. Everything concept-independent — scaffold, boot
+   wiring, the core loop, the worker lanes — keeps building in parallel.
+   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
@@ -250,12 +254,15 @@ Three.js release or branch, and do not blindly copy demo architecture.
     `$genex-threejs-game-ui` (HUD, pause on Escape, fail/retry, win, and the
     full loading state grown from the step-6 loader), then `npx genex wait`
     the step-3 UI generations and wire them in — the sprite HUD replaces the
-    placeholder CSS, the menu video replaces the still frame (wired with the
-    menu skill's loop crossfade), and the scene's planned generated models
-    replace their placeholder primitives — a shipped wave of enemies may not
-    be untextured boxes. This swap is a
-    completion gate, not an option: a game still on the placeholder CSS HUD,
-    or without a working Escape pause, is not done. Then run a feel pass via
+    placeholder CSS (or the recorded `HUD lane: CSS` build lands finished to
+    its brief), the menu video replaces the still frame (wired with the menu
+    skill's loop crossfade), the logotype lands on the menu and loader, and
+    the scene's planned generated models replace their placeholder
+    primitives — a shipped wave of enemies may not be untextured boxes. This
+    swap is a completion gate, not an option: a game still on the
+    placeholder CSS HUD (with no recorded CSS lane), without the menu video
+    playing (or its recorded still fallback), or without a working Escape
+    pause, is not done. Then run a feel pass via
     `$genex-threejs-game-feel` (input response, camera, impact feedback,
     retry speed).
 13. Validate in a real browser with fixed seeds, captures, interaction checks,
@@ -264,8 +271,9 @@ Three.js release or branch, and do not blindly copy demo architecture.
 ## Delegation
 
 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 —
+concept-DEPENDENT lanes launch the moment the concept lands (only the menu
+video waits for its event triple — step 3), 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.
@@ -285,7 +293,9 @@ routing source the director and its workers read.
 done = a screenshot plus an interaction smoke check (load the page, press each
 control, assert a visible response in its labeled direction — `$genex-threejs-visual-validation` has the
 procedure), **plus the UI floor from `$genex-threejs-game-ui` (the generated
-sprite HUD wired in — not the CSS placeholder — pause on Escape, the branded
+sprite HUD wired in — not the CSS placeholder — or the DESIGN.md-recorded
+`HUD lane: CSS` build finished to its brief; the menu video playing, or its
+recorded still fallback; the logotype placed; pause on Escape, the branded
 loader with its key-art background, the brief's font pair actually loaded)
 and the look floor (the step-4 renderer baseline + named post stack actually
 built; every placed 2D/media piece — decals, posters, in-world screens —
@@ -323,7 +333,9 @@ A routed Genex scene is incomplete until it exposes:
 ## Publish and multiplayer awareness
 
 **Publishing IS calling it done.** Before `npx genex publish`, every completion
-gate above must pass — sprite HUD wired, Escape pause working, branded loader
+gate above must pass — sprite HUD wired (or the recorded CSS lane finished),
+the menu video playing (or its recorded still fallback), the logotype placed,
+Escape pause working, branded loader
 with its key art, fonts loaded, renderer baseline + one built post effect
 (tier-aware), the adaptive-quality tier wired at boot, world dressing placed
 or validly waived, and the content contract's countables present or

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

@@ -339,6 +339,25 @@ exempt — the local player may be invisible to themselves
 - Load `$genex-threejs-multiplayer` before writing any networking code; it is
   mandatory for any 2+ player game.
 
+## Placing rigs outside the controller — facing is explicit
+
+The vendored controller owns the local player's facing. Any rig you place
+YOURSELF — a duel opponent, an NPC, a fighter in a side-view game — obeys
+three hard rules:
+
+- **Meshy / Mixamo / VRM rigs rest facing +Z** — from a side camera that
+  means straight at the lens. Set the yaw explicitly from the character's
+  ROLE the moment you place it (`model.rotation.y = …`); never leave the
+  rest pose and assume it reads right.
+- **Never mirror a SkinnedMesh with negative scale.** `scale.x = -1` is a
+  2D-sprite trick: on a 3D rig it flips triangle winding and normals
+  (broken lighting and culling) and does NOT turn the character. Turning is
+  always a yaw rotation.
+- **Duel / side-view / two-character scenes: the combatants face EACH
+  OTHER along the duel axis.** Two fighters staring into the camera is a
+  bug, not a pose — verify it in the milestone smoke capture (an enemy in
+  frame facing the player's CHARACTER, never the lens).
+
 ## If the user asks for ecctrl
 
 ecctrl is a React / React Three Fiber component; a Genex game is plain

package/templates/skills/genex-threejs-character-controller/references/animations.md

@@ -257,7 +257,34 @@ addEventListener("pointerdown", () => {
 ```
 
 `options`: `fadeIn` (default 0.1 s), `timeScale`, `clamp` (hold the final pose —
-for deaths), `onDone`.
+for deaths), `interruptible` (grounded movement cancels the clip), `onDone`.
+
+**Every one-shot is FULL-BODY** (there is no upper-body layering), so it freezes
+the legs — a moving character SLIDES across the ground in a frozen pose for the
+clip's whole length. Two rules keep that from ever being visible:
+
+- **Reactions and gestures a player can walk out of get `interruptible: true`**
+  (hit flinches, casts, taunts, celebrations). Movement intent releases the clip
+  and locomotion takes over the same frame. A 2.9 s hit reaction without it
+  locks the player's animation for 2.9 s *per hit taken*.
+- **`clamp: true` holds the lock FOREVER by design** — nothing releases it
+  automatically, not even the clip ending. Every clamped one-shot needs a
+  guaranteed paired release: call `anims.clearOneShot()` on the transition out
+  (respawn, revive, action aborted). Audit every early-return on the path
+  between "clamped one-shot started" and "the replacing clip plays" — an abort
+  branch that skips the replacement strands the pose and the character slides
+  around locked until something else clears it.
+
+`anims.clearOneShot()` cancels the active one-shot and crossfades locomotion
+back in with no T-pose frame; it is safe to call when nothing is held. Call it
+on TRANSITIONS only — per-frame calls cancel every in-flight reaction clip. To
+cancel one SPECIFIC one-shot without clobbering whatever replaced it, check
+`anims.currentOneShotName` first:
+
+```ts
+// abort a held charge wind-up, but never a death pose that replaced it:
+if (anims.currentOneShotName === WINDUP_CLIP) anims.clearOneShot();
+```
 
 The 12 core clips are always available; everything else comes from
 `npx genex controller anims <selectors…>` — selectors are **tags** (install a

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

@@ -140,6 +140,14 @@ front of it once — it must face you. This is part of the milestone smoke
 pass once enemies exist (an enemy in frame, facing the player). Set the
 `yawCorrection` constant per model and move on.
 
+Two hard rules alongside it: **never mirror a rig with negative scale** —
+`scale.x = -1` is a 2D-sprite trick that flips winding and normals on a
+SkinnedMesh and does NOT turn a 3D body; turning is always a yaw
+(`rotation.y`), set explicitly from the creature's role. And in any
+**duel / side-view / two-character scene**, the combatants face EACH OTHER
+along the duel axis — a fighter staring into the camera is a bug, not a
+pose, and the smoke capture is where it gets caught.
+
 ### 3. Hit reaction — damage reads on the body
 
 Rigged: the `hit` clip above. Procedural: a 100–150 ms flinch — scale pulse

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

@@ -71,66 +71,62 @@ and how the space reads (route, scale) — plus the brief's palette,
 materials, and light. A beautiful empty vista with nothing to fight and
 nowhere to go is a FAILED concept; so is one that invents mechanics the
 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.
-
-**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.)
+`--size 2560x1440 --quality high --no-wait`, enqueued FIRST of all art —
+ONE image, no candidate variants unless the user asks; its URL goes into
+the style-brief comment.
+
+**Describe the concept in words while it renders.** Lay it out in chat —
+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.
+
+**The moment the mockup lands, the style chain fires — then the user sees
+the frame.** In this order, no waiting between the steps: decide the HUD
+lane as art director and record the `HUD lane:` line in DESIGN.md
+(`$genex-game-director` §5 owns the criteria), enqueue the style-dependent
+chain `--no-wait` — the HUD Stage-2 deconstruct (from the mockup), the menu
+still (`--edit`-anchored to it), and the logotype — and THEN show the frame:
+pick it up with `genex wait <id> --open` (or generate with `--open`) so it
+opens in the user's browser AND prints the link, and paste the URL as a
+clickable link — 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.
+
+**Ask keep-or-change with your question tool — as INFORMATION, never a
+gate.** The one that shows 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. The chain is already running while they
+read it: silence means the concept stands; nothing except the menu VIDEO
+ever waits for the answer. The user still gets a real say — a "change" at
+any time loops the concept with their notes at image prices (below). The
+menu video (the one expensive item) fires at the FIRST of: the user's yes ·
+the next `genex preview` after the menu still landed · style work being the
+only work left — and never while a user objection is open
+(`$genex-ai-menu` owns the trigger). (The core asset set — hero model,
+ground texture, skybox, sfx — is prompted from the game IDEA, not the
+image, and mostly survives a style change: launch it up front with
+placeholders. Everything style-independent — scaffold, boot wiring, the
+core loop, the gameplay-LOGIC subagent modules — keeps moving at full speed
+in parallel throughout.)
 
 **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.
+concept mockup itself) with their exact notes, open + link the new frame,
+ask again the same structured way, and re-run the cheap chain from the new
+frame (image-priced — that is the design: the correction lane is cheap
+because the expensive item waited). Carry every note forward so each round
+compounds; if two rounds don't converge, offer 2–3 distinct directions
+(that's the one moment `--candidates` earns its place) instead of
+re-rolling blind. Each standing frame is the working style. When the style
+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.
 
 **The concept anchors STYLE, not truth.** Palette, materials, light, and
 register come from the frame; CONTENT comes from the game contract. This
@@ -165,13 +161,16 @@ rule explicitly does not apply to this one message):
 ```
 UI plan
 • Screens: <list with tiers — loader / menu / pause (Esc) / win/lose / …>
-• Style: <4–5 named hues> · fonts <display> / <body>
+• Style: <4–5 named hues> · fonts <display> / <body> (from $genex-ai-menu's
+  genre table, or a one-line reason)
 • 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> — 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">
+• HUD lane: <sprites (…) | CSS (…, one-line justification)> — recorded in DESIGN.md
+• Concept (HUD mockup): <generation id> — shown for keep / change
+  (informational — the chain below is already queued; silence = it stands)
+• Queued on concept landing: HUD sheet (Stage 2) · menu still · logotype
+  <or "skipped: reason">; menu VIDEO waits for: your yes / the next preview
+  after the still lands / style work being all that's left <or "no menu: reason">
 • Building now (style-independent): <core loop · logic modules already moving>
 • Deferred from mockup: <widgets the image invented but the game lacks — or "none">
 ```
@@ -190,8 +189,9 @@ 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 this chain the instant the user approves the concept
-  (`--no-wait`) — it is style-dependent, so it waits on the yes — then
+  Enqueue this chain the instant the concept mockup LANDS (`--no-wait`) —
+  the keep/change answer never gates it; only the menu VIDEO waits, for its
+  event triple (`$genex-ai-menu`) — 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
@@ -200,7 +200,9 @@ A message missing any line means the gate did not run — go back and run it.
   Run `npx genex wait` on every enqueued ID before any publish and before
   the final handoff of a session — never park landed assets for "later".
   Shipping the placeholder CSS HUD as the final HUD is a failure, not a
-  tier choice.
+  tier choice — the ONE exception is a DESIGN.md-recorded `HUD lane: CSS`
+  decision (`$genex-game-director` §5), where the CSS build, finished to
+  its brief, IS the production HUD.
 - **Tier 3 — offer, don't build.** Video layers over the HUD, 9-slice panel
   sprites, animated menu sprites. Offer in one line
   after the player has seen Tier 1+2 working; build on request.
@@ -522,11 +524,13 @@ 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.
-- 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.
+- The style chain parked behind the keep/change question — the HUD Stage-2
+  sheet, menu still, and logotype enqueue the moment the mockup LANDS, and
+  silence means the concept stands; OR the menu VIDEO fired while a user
+  objection was still open (its event triple is the only wait in the lane);
+  OR the whole build stalled on the concept at all, when concept-INDEPENDENT
+  work (scaffold, core loop, logic subagents) must keep moving in parallel
+  throughout.
 - 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, or a
   border/frame that stops at the cut instead of following it — the

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

@@ -658,6 +658,25 @@ Corollary: **cap top speeds against the network, not just the physics** — an o
 crossing time should stay above ~2× the smoothing delay (~0.25 s), or receivers are reacting to
 history no matter how correct the code is.
 
+**Packed animation-flag bitfields are the sneakiest violation.** Smoothing lerps EVERY numeric
+field — there is no integer exemption — and a lerped bitfield decodes to garbage: with
+`moving=1, running=2, grounded=8`, walking is `f=9` and running is `f=11`, and the interpolation
+passes through `10`, where `10 & moving === 0` — the sprinting opponent renders as *standing
+still*. Worse, the exponential ease approaches an increasing target from below, so truncation
+reads `target - 1` for the whole approach (~1.5 s median before RUN appears; at a vsync-locked
+frame rate it can stick one ULP below the target *forever*). A field-verified failure: a
+playtester swore he was running while his opponent's screen showed him walking — both were right.
+Always drive remote animation from `stateRaw`:
+
+```js
+avatar.updateFromFlags(p.stateRaw.f ?? 0, dt);   // flags are DISCRETE — never p.state.f
+```
+
+**Reaction one-shots on remotes fire on EDGES, never per frame.** If you replay a remote's
+death/hit pose from their published `out`/`hp` state, track the previous value and act only on
+the transition — a per-frame `reset()`/`playDown()` restarts or cancels every in-flight reaction
+clip (and re-writing ghost/material flags 60×/s is pure churn).
+
 ## Shared objects (the ball, the NPC) — use `objects`, never `shared`
 
 A ball belongs to no player. Put it on `objects`: exactly one client owns it at a time (the SDK +

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

@@ -56,9 +56,9 @@ translation may be normalized for Rapier.
 
 For plain game tasks — nothing from the procedural/visual-system pack loaded —
 this is the whole acceptance gate, and it is also the *ceiling*: a smoke check,
-not a certification. Run it ONCE per milestone, and only AFTER that milestone's
-`genex preview` is pushed — ship the rough draft first, then check it; the
-player may already be walking around your build while you do. Catch obvious
+not a certification. Run it ONCE per milestone, against that milestone's
+`genex preview` build — the player may already be walking around it while
+you check. Catch obvious
 breakage, fix what's clearly broken, and hand the feel/polish judgment to the
 player — don't loop re-testing the same build, don't re-test after cosmetic
 tweaks (sounds, colors, tuning values), and don't try to exercise every button
@@ -106,7 +106,12 @@ everything twice.
 4. In that screenshot, check oriented models: the hero faces its travel
    direction, and NPCs driven by chase/aim code face their target. A model
    rotated 90° reads as broken — `$genex-ai-model` has the one-time facing
-   fix.
+   fix. **In any two-character or enemy-encounter capture, the characters
+   face their TARGET, not the camera** — Meshy/Mixamo/VRM rigs rest facing
+   +Z (straight at a side camera), so an unset yaw ships duelists staring
+   at the lens; and a rig "turned" with `scale.x = -1` is a defect even
+   when it looks right from one angle (negative scale flips a SkinnedMesh's
+   winding and normals — the character-controller skill has the rules).
 5. Vehicles get one extra pass: drive forward once and confirm the NOSE
    leads (a 180° body is this bug's favorite disguise), and check the body
    stands ON the road with its wheels inside the silhouette — a body